KVM: arm64: vgic-v3 userspace access consolidation (and other goodies)
Marc Zyngier
maintainerv2 cover KVM: arm64: vgic-v3 userspace access consolidation (and other goodies)
This is a follow-up to [1], which aims a performing a bunch of cleanups in the way we expose sysregs to userspace, with a particular focus on the GICv3 part of that code.
* From v1:
- A couple of extra cleanups thanks to Reiji's comments
- A fix for the breakage of the legacy GICv2 address setup
- Collected RBs from Reiji and Oliver, with thanks.
[1] https://lore.kernel.org/r/[email protected]
Marc Zyngier (20):
KVM: arm64: Add get_reg_by_id() as a sys_reg_desc retrieving helper
KVM: arm64: Reorder handling of invariant sysregs from userspace
KVM: arm64: Introduce generic get_user/set_user helpers for system
registers
KVM: arm64: Rely on index_to_param() for size checks on userspace
access
KVM: arm64: Consolidate sysreg userspace accesses
KVM: arm64: Get rid of reg_from/to_user()
KVM: arm64: vgic-v3: Simplify vgic_v3_has_cpu_sysregs_attr()
KVM: arm64: vgic-v3: Push user access into
vgic_v3_cpu_sysregs_uaccess()
KVM: arm64: vgic-v3: Make the userspace accessors use sysreg API
KVM: arm64: vgic-v3: Convert userspace accessors over to
FIELD_GET/FIELD_PREP
KVM: arm64: vgic-v3: Use u32 to manage the line level from userspace
KVM: arm64: vgic-v3: Consolidate userspace access for MMIO registers
KVM: arm64: vgic-v2: Consolidate userspace access for MMIO registers
KVM: arm64: vgic: Use {get,put}_user() instead of copy_{from.to}_user
KVM: arm64: vgic-v2: Add helper for legacy dist/cpuif base address
setting
KVM: arm64: vgic: Consolidate userspace access for base address
setting
KVM: arm64: vgic: Tidy-up calls to vgic_{get,set}_common_attr()
KVM: arm64: Get rid of find_reg_by_id()
KVM: arm64: Descope kvm_arm_sys_reg_{get,set}_reg()
KVM: arm64: Get rid or outdated comments
arch/arm64/include/asm/kvm_host.h | 2 - arch/arm64/kvm/arm.c | 11 +- arch/arm64/kvm/sys_regs.c | 282 +++++++--------- arch/arm64/kvm/sys_regs.h | 18 +- arch/arm64/kvm/vgic-sys-reg-v3.c | 462 +++++++++++++++----------- arch/arm64/kvm/vgic/vgic-kvm-device.c | 342 ++++++++----------- arch/arm64/kvm/vgic/vgic-mmio-v3.c | 10 +- arch/arm64/kvm/vgic/vgic-mmio.c | 6 +- arch/arm64/kvm/vgic/vgic-mmio.h | 4 +- arch/arm64/kvm/vgic/vgic.h | 9 +- include/kvm/arm_vgic.h | 2 +- 11 files changed, 547 insertions(+), 601 deletions(-)
Signature · 1 line
2.34.1
Marc Zyngier
maintainerPATCH v2 1/20 KVM: arm64: Add get_reg_by_id() as a sys_reg_desc retrieving helper
find_reg_by_id() requires a sys_reg_param as input, which most users provide as a on-stack variable, but don't make any use of the result.
Provide a helper that doesn't have this requirement and simplify the callers (all but one).
--- arch/arm64/kvm/sys_regs.c | 28 +++++++++++++++++----------- arch/arm64/kvm/sys_regs.h | 4 ++++ arch/arm64/kvm/vgic-sys-reg-v3.c | 8 ++------ 3 files changed, 23 insertions(+), 17 deletions(-)
arch/arm64/kvm/sys_regs.c +17 -11
@@ -2650,21 +2650,29 @@ const struct sys_reg_desc *find_reg_by_id(u64 id,return find_reg (params, table, num); } +const struct sys_reg_desc *get_reg_by_id (u64 id, +const struct sys_reg_desc table[], +unsigned int num) +{ +struct sys_reg_params params; + +if (!index_to_params (id, ¶ms)) +return NULL ; + +return find_reg (¶ms, table, num); +} +/* Decode an index value, and find the sys_reg_desc entry. */ static const struct sys_reg_desc *index_to_sys_reg_desc (struct kvm_vcpu *vcpu,u64 id) {const struct sys_reg_desc *r; -struct sys_reg_params params;/* We only do sys_reg for now. */ if ((id &KVM_REG_ARM_COPROC_MASK ) !=KVM_REG_ARM64_SYSREG )return NULL ; -if (!index_to_params (id, ¶ms)) -return NULL ; - - r =find_reg (¶ms, sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); + r =get_reg_by_id (id, sys_reg_descs,ARRAY_SIZE (sys_reg_descs));/* Not saved in the sys_reg array and not otherwise accessible? */ if (r && !(r->reg || r->get_user))
@@ -2723,11 +2731,10 @@ static int reg_to_user(void __user *uaddr, const u64 *val, u64 id)static int get_invariant_sys_reg (u64 id,void __user *uaddr) { -struct sys_reg_params params;const struct sys_reg_desc *r; - r =find_reg_by_id (id, ¶ms, invariant_sys_regs, -ARRAY_SIZE (invariant_sys_regs)); + r =get_reg_by_id (id, invariant_sys_regs, +ARRAY_SIZE (invariant_sys_regs));if (!r)return -ENOENT ;
@@ -2736,13 +2743,12 @@ static int get_invariant_sys_reg(u64 id, void __user *uaddr)static int set_invariant_sys_reg (u64 id,void __user *uaddr) { -struct sys_reg_params params;const struct sys_reg_desc *r;int err;u64 val =0 ;/* Make sure high bits are 0 for 32-bit regs */ - r =find_reg_by_id (id, ¶ms, invariant_sys_regs, -ARRAY_SIZE (invariant_sys_regs)); + r =get_reg_by_id (id, invariant_sys_regs, +ARRAY_SIZE (invariant_sys_regs));if (!r)return -ENOENT ;
arch/arm64/kvm/sys_regs.h +4 -0
@@ -195,6 +195,10 @@ const struct sys_reg_desc *find_reg_by_id(u64 id,const struct sys_reg_desc table[], unsigned int num); +const struct sys_reg_desc *get_reg_by_id (u64 id, +const struct sys_reg_desc table[], +unsigned int num); +#define AA32 (_x) .aarch32_map = AA32_##_x#define Op0 (_x) .Op0 = _x#define Op1 (_x) .Op1 = _x
arch/arm64/kvm/vgic-sys-reg-v3.c +2 -6
@@ -263,14 +263,10 @@ static const struct sys_reg_desc gic_v3_icc_reg_descs[] = {int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,bool is_write,u64 id,u64 *reg) { -struct sys_reg_params params;u64 sysreg = (id &KVM_DEV_ARM_VGIC_SYSREG_MASK ) |KVM_REG_SIZE_U64 ; - params.regval = *reg; - params.is_write = is_write; - -if (find_reg_by_id (sysreg, ¶ms, gic_v3_icc_reg_descs, -ARRAY_SIZE (gic_v3_icc_reg_descs))) +if (get_reg_by_id (sysreg, gic_v3_icc_reg_descs, +ARRAY_SIZE (gic_v3_icc_reg_descs)))return 0 ;return -ENXIO ;
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 2/20 KVM: arm64: Reorder handling of invariant sysregs from userspace
In reply to Marc ZyngierIn order to allow some further refactor of the sysreg helpers, move the handling of invariant sysreg to occur before we handle all the other ones.
--- arch/arm64/kvm/sys_regs.c | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-)
arch/arm64/kvm/sys_regs.c +12 -6
@@ -2849,6 +2849,7 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg {const struct sys_reg_desc *r;void __user *uaddr = (void __user *)(unsigned long )reg->addr; +int err;if ((reg->id &KVM_REG_ARM_COPROC_MASK ) ==KVM_REG_ARM_DEMUX )return demux_c15_get (reg->id, uaddr);
@@ -2856,12 +2857,14 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regif (KVM_REG_SIZE (reg->id) !=sizeof (__u64))return -ENOENT ; + err =get_invariant_sys_reg (reg->id, uaddr); +if (err != -ENOENT ) +return err; + r =index_to_sys_reg_desc (vcpu, reg->id); -if (!r) -return get_invariant_sys_reg (reg->id, uaddr);/* Check for regs disabled by runtime config */ -if (sysreg_hidden (vcpu, r)) +if (!r ||sysreg_hidden (vcpu, r))return -ENOENT ;if (r->get_user)
@@ -2874,6 +2877,7 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg {const struct sys_reg_desc *r;void __user *uaddr = (void __user *)(unsigned long )reg->addr; +int err;if ((reg->id &KVM_REG_ARM_COPROC_MASK ) ==KVM_REG_ARM_DEMUX )return demux_c15_set (reg->id, uaddr);
@@ -2881,12 +2885,14 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regif (KVM_REG_SIZE (reg->id) !=sizeof (__u64))return -ENOENT ; + err =set_invariant_sys_reg (reg->id, uaddr); +if (err != -ENOENT ) +return err; + r =index_to_sys_reg_desc (vcpu, reg->id); -if (!r) -return set_invariant_sys_reg (reg->id, uaddr);/* Check for regs disabled by runtime config */ -if (sysreg_hidden (vcpu, r)) +if (!r ||sysreg_hidden (vcpu, r))return -ENOENT ;if (r->set_user)
Signature · 1 line
2.34.1
Marc Zyngier
maintainerPATCH v2 3/20 KVM: arm64: Introduce generic get_user/set_user helpers for system registers
In reply to Marc ZyngierThe userspace access to the system registers is done using helpers that hardcode the table that is looked up. extract some generic helpers from this, moving the handling of hidden sysregs into the core code.
--- arch/arm64/kvm/sys_regs.c | 60 +++++++++++++++++++++++++-------------- arch/arm64/kvm/sys_regs.h | 6 ++++ 2 files changed, 44 insertions(+), 22 deletions(-)
arch/arm64/kvm/sys_regs.c +38 -22
@@ -2663,8 +2663,10 @@ const struct sys_reg_desc *get_reg_by_id(u64 id, }/* Decode an index value, and find the sys_reg_desc entry. */ -static const struct sys_reg_desc *index_to_sys_reg_desc (struct kvm_vcpu *vcpu, -u64 id) +static const struct sys_reg_desc * +id_to_sys_reg_desc (struct kvm_vcpu *vcpu,u64 id, +const struct sys_reg_desc table[],unsigned int num) + {const struct sys_reg_desc *r;
@@ -2672,10 +2674,10 @@ static const struct sys_reg_desc *index_to_sys_reg_desc(struct kvm_vcpu *vcpu,if ((id &KVM_REG_ARM_COPROC_MASK ) !=KVM_REG_ARM64_SYSREG )return NULL ; - r =get_reg_by_id (id, sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); + r =get_reg_by_id (id, table, num);/* Not saved in the sys_reg array and not otherwise accessible? */ -if (r && !(r->reg || r->get_user)) +if (r && (!(r->reg || r->get_user) ||sysreg_hidden (vcpu, r))) r =NULL ;return r;
@@ -2845,9 +2847,24 @@ static int demux_c15_set(u64 id, void __user *uaddr) } } -int kvm_arm_sys_reg_get_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg) +int kvm_sys_reg_get_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg, +const struct sys_reg_desc table[],unsigned int num) { +void __user *uaddr = (void __user *)(unsigned long )reg->addr;const struct sys_reg_desc *r; + + r =id_to_sys_reg_desc (vcpu, reg->id, table, num); +if (!r) +return -ENOENT ; + +if (r->get_user) +return (r->get_user)(vcpu, r, reg, uaddr); + +return reg_to_user (uaddr, &__vcpu_sys_reg (vcpu, r->reg), reg->id); +} + +int kvm_arm_sys_reg_get_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg) +{void __user *uaddr = (void __user *)(unsigned long )reg->addr;int err;
@@ -2861,21 +2878,28 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regif (err != -ENOENT )return err; - r =index_to_sys_reg_desc (vcpu, reg->id); +return kvm_sys_reg_get_user (vcpu, reg, + sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); +} -/* Check for regs disabled by runtime config */ -if (!r ||sysreg_hidden (vcpu, r)) +int kvm_sys_reg_set_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg, +const struct sys_reg_desc table[],unsigned int num) +{ +void __user *uaddr = (void __user *)(unsigned long )reg->addr; +const struct sys_reg_desc *r; + + r =id_to_sys_reg_desc (vcpu, reg->id, table, num); +if (!r)return -ENOENT ; -if (r->get_user) -return (r->get_user)(vcpu, r, reg, uaddr); +if (r->set_user) +return (r->set_user)(vcpu, r, reg, uaddr); -return reg_to_user (uaddr, &__vcpu_sys_reg (vcpu, r->reg), reg->id); +return reg_from_user (&__vcpu_sys_reg (vcpu, r->reg), uaddr, reg->id); }int kvm_arm_sys_reg_set_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg) { -const struct sys_reg_desc *r;void __user *uaddr = (void __user *)(unsigned long )reg->addr;int err;
@@ -2889,16 +2913,8 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regif (err != -ENOENT )return err; - r =index_to_sys_reg_desc (vcpu, reg->id); - -/* Check for regs disabled by runtime config */ -if (!r ||sysreg_hidden (vcpu, r)) -return -ENOENT ; - -if (r->set_user) -return (r->set_user)(vcpu, r, reg, uaddr); - -return reg_from_user (&__vcpu_sys_reg (vcpu, r->reg), uaddr, reg->id); +return kvm_sys_reg_set_user (vcpu, reg, + sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); }static unsigned int num_demux_regs (void )
arch/arm64/kvm/sys_regs.h +6 -0
@@ -199,6 +199,12 @@ const struct sys_reg_desc *get_reg_by_id(u64 id,const struct sys_reg_desc table[], unsigned int num); +int kvm_sys_reg_get_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg, +const struct sys_reg_desc table[],unsigned int num); + +int kvm_sys_reg_set_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg, +const struct sys_reg_desc table[],unsigned int num); +#define AA32 (_x) .aarch32_map = AA32_##_x#define Op0 (_x) .Op0 = _x#define Op1 (_x) .Op1 = _x
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 4/20 KVM: arm64: Rely on index_to_param() for size checks on userspace access
In reply to Marc Zyngierindex_to_param() already checks that we use 64bit accesses for all registers accessed from userspace.
However, we have extra checks in other places, which is pretty confusing. Get rid on these checks.
--- arch/arm64/kvm/sys_regs.c | 6 ------ 1 file changed, 6 deletions(-)
arch/arm64/kvm/sys_regs.c +0 -6
@@ -2871,9 +2871,6 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regif ((reg->id &KVM_REG_ARM_COPROC_MASK ) ==KVM_REG_ARM_DEMUX )return demux_c15_get (reg->id, uaddr); -if (KVM_REG_SIZE (reg->id) !=sizeof (__u64)) -return -ENOENT ; - err =get_invariant_sys_reg (reg->id, uaddr);if (err != -ENOENT )return err;
@@ -2906,9 +2903,6 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regif ((reg->id &KVM_REG_ARM_COPROC_MASK ) ==KVM_REG_ARM_DEMUX )return demux_c15_set (reg->id, uaddr); -if (KVM_REG_SIZE (reg->id) !=sizeof (__u64)) -return -ENOENT ; - err =set_invariant_sys_reg (reg->id, uaddr);if (err != -ENOENT )return err;
Signature · 1 line
2.34.1
Re: [PATCH v2 04/20] KVM: arm64: Rely on index_to_param() for size checks on userspace access
Quoted 8 lines · Marc Zyngier
index_to_param()already checks that we use 64bit accesses for all registers accessed from userspace.However, we have extra checks in other places, which is pretty confusing. Get rid on these checks.
Signed-off-by Marc Zyngier <[email protected]>
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 5/20 KVM: arm64: Consolidate sysreg userspace accesses
In reply to Marc ZyngierUntil now, the .set_user and .get_user callbacks have to implement (directly or not) the userspace memory accesses. Although this gives us maximem flexibility, this is also a maintenance burden, making it hard to audit, and I'd feel much better if it was all located in a single place.
So let's do just that, simplifying most of the function signatures in the process (the callbacks are now only concerned with the data itself, and not with userspace).
--- arch/arm64/kvm/sys_regs.c | 160 ++++++++++++++------------------------ arch/arm64/kvm/sys_regs.h | 4 +- 2 files changed, 61 insertions(+), 103 deletions(-)
arch/arm64/kvm/sys_regs.c +59 -101
@@ -321,16 +321,8 @@ static bool trap_oslsr_el1(struct kvm_vcpu *vcpu, }static int set_oslsr_el1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -u64 id =sys_reg_to_index (rd); -u64 val; -int err; - - err =reg_from_user (&val, uaddr, id); -if (err) -return err; -/* * The only modifiable bit is the OSLK bit. Refuse the write if * userspace attempts to change any other bit in the register.
@@ -451,22 +443,16 @@ static bool trap_bvr(struct kvm_vcpu *vcpu, }static int set_bvr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_bvr[rd->CRm]; - -if (copy_from_user (r, uaddr,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + vcpu->arch.vcpu_debug_state.dbg_bvr[rd->CRm] = val;return 0 ; }static int get_bvr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 *val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_bvr[rd->CRm]; - -if (copy_to_user (uaddr, r,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + *val = vcpu->arch.vcpu_debug_state.dbg_bvr[rd->CRm];return 0 ; }
@@ -493,23 +479,16 @@ static bool trap_bcr(struct kvm_vcpu *vcpu, }static int set_bcr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_bcr[rd->CRm]; - -if (copy_from_user (r, uaddr,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; - + vcpu->arch.vcpu_debug_state.dbg_bcr[rd->CRm] = val;return 0 ; }static int get_bcr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 *val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_bcr[rd->CRm]; - -if (copy_to_user (uaddr, r,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + *val = vcpu->arch.vcpu_debug_state.dbg_bcr[rd->CRm];return 0 ; }
@@ -537,22 +516,16 @@ static bool trap_wvr(struct kvm_vcpu *vcpu, }static int set_wvr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_wvr[rd->CRm]; - -if (copy_from_user (r, uaddr,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + vcpu->arch.vcpu_debug_state.dbg_wvr[rd->CRm] = val;return 0 ; }static int get_wvr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 *val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_wvr[rd->CRm]; - -if (copy_to_user (uaddr, r,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + *val = vcpu->arch.vcpu_debug_state.dbg_wvr[rd->CRm];return 0 ; }
@@ -579,22 +552,16 @@ static bool trap_wcr(struct kvm_vcpu *vcpu, }static int set_wcr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_wcr[rd->CRm]; - -if (copy_from_user (r, uaddr,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + vcpu->arch.vcpu_debug_state.dbg_wcr[rd->CRm] = val;return 0 ; }static int get_wcr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 *val) { -__u64 *r = &vcpu->arch.vcpu_debug_state.dbg_wcr[rd->CRm]; - -if (copy_to_user (uaddr, r,KVM_REG_SIZE (reg->id)) !=0 ) -return -EFAULT ; + *val = vcpu->arch.vcpu_debug_state.dbg_wcr[rd->CRm];return 0 ; }
@@ -1227,16 +1194,9 @@ static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,static int set_id_aa64pfr0_el1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -const u64 id =sys_reg_to_index (rd);u8 csv2, csv3; -int err; -u64 val; - - err =reg_from_user (&val, uaddr, id); -if (err) -return err;/* * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
@@ -1262,7 +1222,7 @@ static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,return -EINVAL ; vcpu->kvm->arch.pfr0_csv2 = csv2; - vcpu->kvm->arch.pfr0_csv3 = csv3 ; + vcpu->kvm->arch.pfr0_csv3 = csv3;return 0 ; }
@@ -1275,27 +1235,17 @@ static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,* to be changed. */ static int __get_id_reg (const struct kvm_vcpu *vcpu, -const struct sys_reg_desc *rd,void __user *uaddr, +const struct sys_reg_desc *rd,u64 *val,bool raz) { -const u64 id =sys_reg_to_index (rd); -const u64 val =read_id_reg (vcpu, rd, raz); - -return reg_to_user (uaddr, &val, id); + *val =read_id_reg (vcpu, rd, raz); +return 0 ; }static int __set_id_reg (const struct kvm_vcpu *vcpu, -const struct sys_reg_desc *rd,void __user *uaddr, +const struct sys_reg_desc *rd,u64 val,bool raz) { -const u64 id =sys_reg_to_index (rd); -int err; -u64 val; - - err =reg_from_user (&val, uaddr, id); -if (err) -return err; -/* This is what we mean by invariant: you can't change it. */ if (val !=read_id_reg (vcpu, rd, raz))return -EINVAL ;
@@ -1304,47 +1254,37 @@ static int __set_id_reg(const struct kvm_vcpu *vcpu, }static int get_id_reg (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 *val) {bool raz =sysreg_visible_as_raz (vcpu, rd); -return __get_id_reg (vcpu, rd, uaddr, raz); +return __get_id_reg (vcpu, rd, val, raz); }static int set_id_reg (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) {bool raz =sysreg_visible_as_raz (vcpu, rd); -return __set_id_reg (vcpu, rd, uaddr, raz); +return __set_id_reg (vcpu, rd, val, raz); }static int set_raz_id_reg (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -return __set_id_reg (vcpu, rd, uaddr, true); +return __set_id_reg (vcpu, rd, val, true); }static int get_raz_reg (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 *val) { -const u64 id =sys_reg_to_index (rd); -const u64 val =0 ; - -return reg_to_user (uaddr, &val, id); + *val =0 ; +return 0 ; }static int set_wi_reg (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr) +u64 val) { -int err; -u64 val; - -/* Perform the access even if we are going to ignore the value */ - err =reg_from_user (&val, uaddr,sys_reg_to_index (rd)); -if (err) -return err; -return 0 ; }
@@ -2850,17 +2790,26 @@ static int demux_c15_set(u64 id, void __user *uaddr)int kvm_sys_reg_get_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg,const struct sys_reg_desc table[],unsigned int num) { -void __user *uaddr = (void __user *)(unsigned long )reg->addr; +u64 __user *uaddr = (u64 __user *)(unsigned long )reg->addr;const struct sys_reg_desc *r; +u64 val; +int ret; r =id_to_sys_reg_desc (vcpu, reg->id, table, num);if (!r)return -ENOENT ; -if (r->get_user) -return (r->get_user)(vcpu, r, reg, uaddr); +if (r->get_user) { + ret = (r->get_user)(vcpu, r, &val); + }else { + val =__vcpu_sys_reg (vcpu, r->reg); + ret =0 ; + } + +if (!ret) + ret =put_user (val, uaddr); -return reg_to_user (uaddr, &__vcpu_sys_reg (vcpu, r->reg), reg->id); +return ret; }int kvm_arm_sys_reg_get_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg)
@@ -2882,17 +2831,26 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *regint kvm_sys_reg_set_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg,const struct sys_reg_desc table[],unsigned int num) { -void __user *uaddr = (void __user *)(unsigned long )reg->addr; +u64 __user *uaddr = (u64 __user *)(unsigned long )reg->addr;const struct sys_reg_desc *r; +u64 val; +int ret; + +if (get_user (val, uaddr)) +return -EFAULT ; r =id_to_sys_reg_desc (vcpu, reg->id, table, num);if (!r)return -ENOENT ; -if (r->set_user) -return (r->set_user)(vcpu, r, reg, uaddr); +if (r->set_user) { + ret = (r->set_user)(vcpu, r, val); + }else { +__vcpu_sys_reg (vcpu, r->reg) = val; + ret =0 ; + } -return reg_from_user (&__vcpu_sys_reg (vcpu, r->reg), uaddr, reg->id); +return ret; }int kvm_arm_sys_reg_set_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg)
arch/arm64/kvm/sys_regs.h +2 -2
@@ -75,9 +75,9 @@ struct sys_reg_desc {/* Custom get/set_user functions, fallback to generic if NULL */ int (*get_user)(struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr); +u64 *val);int (*set_user)(struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, -const struct kvm_one_reg *reg,void __user *uaddr); +u64 val);/* Return mask of REG_* runtime visibility overrides */ unsigned int (*visibility)(const struct kvm_vcpu *vcpu,
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 6/20 KVM: arm64: Get rid of reg_from/to_user()
In reply to Marc ZyngierThese helpers are only used by the invariant stuff now, and while they pretend to support non-64bit registers, this only serves as a way to scare the casual reviewer...
Replace these helpers with our good friends get/put_user(), and don't look back.
--- arch/arm64/kvm/sys_regs.c | 30 ++++++------------------------ 1 file changed, 6 insertions(+), 24 deletions(-)
arch/arm64/kvm/sys_regs.c +6 -24
@@ -44,8 +44,6 @@* 64bit interface. */ -static int reg_from_user (u64 *val,const void __user *uaddr,u64 id); -static int reg_to_user (void __user *uaddr,const u64 *val,u64 id);static u64 sys_reg_to_index (const struct sys_reg_desc *reg); static bool read_from_write_only(struct kvm_vcpu *vcpu,
@@ -2657,21 +2655,7 @@ static struct sys_reg_desc invariant_sys_regs[] = { { SYS_DESC(SYS_CTR_EL0), NULL, get_ctr_el0 }, }; -static int reg_from_user (u64 *val,const void __user *uaddr,u64 id) -{ -if (copy_from_user (val, uaddr,KVM_REG_SIZE (id)) !=0 ) -return -EFAULT ; -return 0 ; -} - -static int reg_to_user (void __user *uaddr,const u64 *val,u64 id) -{ -if (copy_to_user (uaddr, val,KVM_REG_SIZE (id)) !=0 ) -return -EFAULT ; -return 0 ; -} - -static int get_invariant_sys_reg (u64 id,void __user *uaddr) +static int get_invariant_sys_reg (u64 id,u64 __user *uaddr) {const struct sys_reg_desc *r;
@@ -2680,23 +2664,21 @@ static int get_invariant_sys_reg(u64 id, void __user *uaddr)if (!r)return -ENOENT ; -return reg_to_user (uaddr, &r->val, id); +return put_user (r->val, uaddr); } -static int set_invariant_sys_reg (u64 id,void __user *uaddr) +static int set_invariant_sys_reg (u64 id,u64 __user *uaddr) {const struct sys_reg_desc *r; -int err; -u64 val =0 ;/* Make sure high bits are 0 for 32-bit regs */ +u64 val; r =get_reg_by_id (id, invariant_sys_regs,ARRAY_SIZE (invariant_sys_regs));if (!r)return -ENOENT ; - err =reg_from_user (&val, uaddr, id); -if (err) -return err; +if (get_user (val, uaddr)) +return -EFAULT ;/* This is what we mean by invariant: you can't change it. */ if (r->val != val)
Signature · 1 line
2.34.1
Marc Zyngier
maintainerPATCH v2 7/20 KVM: arm64: vgic-v3: Simplify vgic_v3_has_cpu_sysregs_attr()
In reply to Marc ZyngierFinding out whether a sysreg exists has little to do with that register being accessed, so drop the is_write parameter.
Also, the reg pointer is completely unused, and we're better off just passing the attr pointer to the function.
This result in a small cleanup of the calling site, with a new helper converting the vGIC view of a sysreg into the canonical one (this is purely cosmetic, as the encoding is the same).
--- arch/arm64/kvm/vgic-sys-reg-v3.c | 14 ++++++++++---- arch/arm64/kvm/vgic/vgic-mmio-v3.c | 8 ++------ arch/arm64/kvm/vgic/vgic.h | 3 +-- 3 files changed, 13 insertions(+), 12 deletions(-)
arch/arm64/kvm/vgic-sys-reg-v3.c +10 -4
@@ -260,12 +260,18 @@ static const struct sys_reg_desc gic_v3_icc_reg_descs[] = { { SYS_DESC(SYS_ICC_IGRPEN1_EL1), access_gic_grpen1 }, }; -int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,bool is_write,u64 id, -u64 *reg) +static u64 attr_to_id (u64 attr) { -u64 sysreg = (id &KVM_DEV_ARM_VGIC_SYSREG_MASK ) |KVM_REG_SIZE_U64 ; +return ARM64_SYS_REG (FIELD_GET (KVM_REG_ARM_VGIC_SYSREG_OP0_MASK , attr), +FIELD_GET (KVM_REG_ARM_VGIC_SYSREG_OP1_MASK , attr), +FIELD_GET (KVM_REG_ARM_VGIC_SYSREG_CRN_MASK , attr), +FIELD_GET (KVM_REG_ARM_VGIC_SYSREG_CRM_MASK , attr), +FIELD_GET (KVM_REG_ARM_VGIC_SYSREG_OP2_MASK , attr)); +} -if (get_reg_by_id (sysreg, gic_v3_icc_reg_descs, +int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,struct kvm_device_attr *attr) +{ +if (get_reg_by_id (attr_to_id (attr->attr), gic_v3_icc_reg_descs,ARRAY_SIZE (gic_v3_icc_reg_descs)))return 0 ;
arch/arm64/kvm/vgic/vgic-mmio-v3.c +2 -6
@@ -986,12 +986,8 @@ int vgic_v3_has_attr_regs(struct kvm_device *dev, struct kvm_device_attr *attr) iodev.base_addr =0 ;break ; } -case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : { -u64 reg, id; - - id = (attr->attr &KVM_DEV_ARM_VGIC_SYSREG_INSTR_MASK ); -return vgic_v3_has_cpu_sysregs_attr (vcpu,0 , id, ®); - } +case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : +return vgic_v3_has_cpu_sysregs_attr (vcpu, attr);default :return -ENXIO ; }
arch/arm64/kvm/vgic/vgic.h +1 -2
@@ -247,8 +247,7 @@ int vgic_v3_redist_uaccess(struct kvm_vcpu *vcpu, bool is_write, int offset, u32 *val);int vgic_v3_cpu_sysregs_uaccess (struct kvm_vcpu *vcpu,bool is_write,u64 id,u64 *val); -int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,bool is_write,u64 id, -u64 *reg); +int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,struct kvm_device_attr *attr);int vgic_v3_line_level_info_uaccess (struct kvm_vcpu *vcpu,bool is_write,u32 intid,u64 *val);int kvm_register_vgic_device (unsigned long type);
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 8/20 KVM: arm64: vgic-v3: Push user access into vgic_v3_cpu_sysregs_uaccess()
In reply to Marc ZyngierIn order to start making the vgic sysreg access from userspace similar to all the other sysregs, push the userspace memory access one level down into vgic_v3_cpu_sysregs_uaccess().
The next step will be to rely on the sysreg infrastructure to perform this task.
--- arch/arm64/kvm/vgic-sys-reg-v3.c | 22 ++++++++++++------ arch/arm64/kvm/vgic/vgic-kvm-device.c | 33 ++++++--------------------- arch/arm64/kvm/vgic/vgic.h | 4 ++-- 3 files changed, 24 insertions(+), 35 deletions(-)
arch/arm64/kvm/vgic-sys-reg-v3.c +15 -7
@@ -278,15 +278,21 @@ int vgic_v3_has_cpu_sysregs_attr(struct kvm_vcpu *vcpu, struct kvm_device_attr *return -ENXIO ; } -int vgic_v3_cpu_sysregs_uaccess (struct kvm_vcpu *vcpu,bool is_write,u64 id, -u64 *reg) +int vgic_v3_cpu_sysregs_uaccess (struct kvm_vcpu *vcpu, +struct kvm_device_attr *attr, +bool is_write) { +u64 __user *uaddr = (u64 __user *)(long )attr->addr;struct sys_reg_params params;const struct sys_reg_desc *r; -u64 sysreg = (id &KVM_DEV_ARM_VGIC_SYSREG_MASK ) |KVM_REG_SIZE_U64 ; +u64 sysreg; -if (is_write) - params.regval = *reg; + sysreg =attr_to_id (attr->attr); + +if (is_write) { +if (get_user (params.regval, uaddr)) +return -EFAULT ; + } params.is_write = is_write; r = find_reg_by_id(sysreg, ¶ms, gic_v3_icc_reg_descs,
@@ -297,8 +303,10 @@ int vgic_v3_cpu_sysregs_uaccess(struct kvm_vcpu *vcpu, bool is_write, u64 id,if (!r->access (vcpu, ¶ms, r))return -EINVAL ; -if (!is_write) - *reg = params.regval; +if (!is_write) { +if (put_user (params.regval, uaddr)) +return -EFAULT ; + }return 0 ; }
arch/arm64/kvm/vgic/vgic-kvm-device.c +7 -26
@@ -512,7 +512,7 @@ int vgic_v3_parse_attr(struct kvm_device *dev, struct kvm_device_attr *attr,* * @dev: kvm device handle * @attr: kvm device attribute -* @reg: address the value is read or written +* @reg: address the value is read or written, NULL for sysregs * @is_write: true if userspace is writing a register */ static int vgic_v3_attr_regs_access(struct kvm_device *dev,
@@ -561,14 +561,9 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev,if (!is_write) *reg = tmp32;break ; -case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : { -u64 regid; - - regid = (attr->attr &KVM_DEV_ARM_VGIC_SYSREG_INSTR_MASK ); - ret =vgic_v3_cpu_sysregs_uaccess (vcpu, is_write, - regid, reg); +case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : + ret =vgic_v3_cpu_sysregs_uaccess (vcpu, attr, is_write);break ; - }case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : {unsigned int info, intid;
@@ -617,15 +612,8 @@ static int vgic_v3_set_attr(struct kvm_device *dev, reg = tmp32;return vgic_v3_attr_regs_access (dev, attr, ®, true); } -case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : { -u64 __user *uaddr = (u64 __user *)(long )attr->addr; -u64 reg; - -if (get_user (reg, uaddr)) -return -EFAULT ; - -return vgic_v3_attr_regs_access (dev, attr, ®, true); - } +case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : +return vgic_v3_attr_regs_access (dev, attr,NULL , true);case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : {u32 __user *uaddr = (u32 __user *)(long )attr->addr;u64 reg;
@@ -681,15 +669,8 @@ static int vgic_v3_get_attr(struct kvm_device *dev, tmp32 = reg;return put_user (tmp32, uaddr); } -case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : { -u64 __user *uaddr = (u64 __user *)(long )attr->addr; -u64 reg; - - ret =vgic_v3_attr_regs_access (dev, attr, ®, false); -if (ret) -return ret; -return put_user (reg, uaddr); - } +case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : +return vgic_v3_attr_regs_access (dev, attr,NULL , false);case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : {u32 __user *uaddr = (u32 __user *)(long )attr->addr;u64 reg;
arch/arm64/kvm/vgic/vgic.h +2 -2
@@ -245,8 +245,8 @@ int vgic_v3_dist_uaccess(struct kvm_vcpu *vcpu, bool is_write, int offset, u32 *val);int vgic_v3_redist_uaccess (struct kvm_vcpu *vcpu,bool is_write,int offset,u32 *val); -int vgic_v3_cpu_sysregs_uaccess (struct kvm_vcpu *vcpu,bool is_write, -u64 id,u64 *val); +int vgic_v3_cpu_sysregs_uaccess (struct kvm_vcpu *vcpu, +struct kvm_device_attr *attr,bool is_write);int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,struct kvm_device_attr *attr);int vgic_v3_line_level_info_uaccess (struct kvm_vcpu *vcpu,bool is_write,u32 intid,u64 *val);
Signature · 1 line
2.34.1
Re: [PATCH v2 08/20] KVM: arm64: vgic-v3: Push user access into vgic_v3_cpu_sysregs_uaccess()
Quoted 9 lines · Marc Zyngier
In order to start making the vgic sysreg access from userspace similar to all the other sysregs, push the userspace memory access one level down into
vgic_v3_cpu_sysregs_uaccess().The next step will be to rely on the sysreg infrastructure to perform this task.
Signed-off-by Marc Zyngier <[email protected]>
Thank you for addressing the comments!
Reiji
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 9/20 KVM: arm64: vgic-v3: Make the userspace accessors use sysreg API
In reply to Marc ZyngierThe vgic-v3 sysreg accessors have been ignored as the rest of the sysreg internal API was evolving, and are stuck with the .access method (which is normally reserved to the guest's own access) for the userspace accesses (which should use the .set/.get_user() methods).
Catch up with the program and repaint all the accessors so that they fit into the normal userspace model, and plug the result into the helpers that have been introduced earlier.
--- arch/arm64/kvm/vgic-sys-reg-v3.c | 454 +++++++++++++++++-------------- 1 file changed, 257 insertions(+), 197 deletions(-)
arch/arm64/kvm/vgic-sys-reg-v3.c +257 -197
@@ -10,254 +10,330 @@#include "vgic/vgic.h" #include "sys_regs.h" -static bool access_gic_ctlr (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int set_gic_ctlr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) {u32 host_pri_bits, host_id_bits, host_seis, host_a3v, seis, a3v;struct vgic_cpu *vgic_v3_cpu = &vcpu->arch.vgic_cpu;struct vgic_vmcr vmcr; + +vgic_get_vmcr (vcpu, &vmcr); + +/* +* Disallow restoring VM state if not supported by this +* hardware. +*/ + host_pri_bits = ((val &ICC_CTLR_EL1_PRI_BITS_MASK ) >> +ICC_CTLR_EL1_PRI_BITS_SHIFT ) +1 ; +if (host_pri_bits > vgic_v3_cpu->num_pri_bits) +return -EINVAL ; + + vgic_v3_cpu->num_pri_bits = host_pri_bits; + + host_id_bits = (val &ICC_CTLR_EL1_ID_BITS_MASK ) >> +ICC_CTLR_EL1_ID_BITS_SHIFT ; +if (host_id_bits > vgic_v3_cpu->num_id_bits) +return -EINVAL ; + + vgic_v3_cpu->num_id_bits = host_id_bits; + + host_seis = ((kvm_vgic_global_state.ich_vtr_el2 & +ICH_VTR_SEIS_MASK ) >>ICH_VTR_SEIS_SHIFT ); + seis = (val &ICC_CTLR_EL1_SEIS_MASK ) >> +ICC_CTLR_EL1_SEIS_SHIFT ; +if (host_seis != seis) +return -EINVAL ; + + host_a3v = ((kvm_vgic_global_state.ich_vtr_el2 & +ICH_VTR_A3V_MASK ) >>ICH_VTR_A3V_SHIFT ); + a3v = (val &ICC_CTLR_EL1_A3V_MASK ) >>ICC_CTLR_EL1_A3V_SHIFT ; +if (host_a3v != a3v) +return -EINVAL ; + +/* +* Here set VMCR.CTLR in ICC_CTLR_EL1 layout. +* The vgic_set_vmcr() will convert to ICH_VMCR layout. +*/ + vmcr.cbpr = (val &ICC_CTLR_EL1_CBPR_MASK ) >>ICC_CTLR_EL1_CBPR_SHIFT ; + vmcr.eoim = (val & ICC_CTLR_EL1_EOImode_MASK) >> ICC_CTLR_EL1_EOImode_SHIFT; +vgic_set_vmcr (vcpu, &vmcr); + +return 0 ; +} + +static int get_gic_ctlr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *valp) +{ +struct vgic_cpu *vgic_v3_cpu = &vcpu->arch.vgic_cpu; +struct vgic_vmcr vmcr;u64 val;vgic_get_vmcr (vcpu, &vmcr); -if (p->is_write) { - val = p->regval; - -/* -* Disallow restoring VM state if not supported by this -* hardware. -*/ - host_pri_bits = ((val &ICC_CTLR_EL1_PRI_BITS_MASK ) >> -ICC_CTLR_EL1_PRI_BITS_SHIFT ) +1 ; -if (host_pri_bits > vgic_v3_cpu->num_pri_bits) -return false; - - vgic_v3_cpu->num_pri_bits = host_pri_bits; - - host_id_bits = (val &ICC_CTLR_EL1_ID_BITS_MASK ) >> -ICC_CTLR_EL1_ID_BITS_SHIFT ; -if (host_id_bits > vgic_v3_cpu->num_id_bits) -return false; - - vgic_v3_cpu->num_id_bits = host_id_bits; - - host_seis = ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_SEIS_MASK ) >>ICH_VTR_SEIS_SHIFT ); - seis = (val &ICC_CTLR_EL1_SEIS_MASK ) >> -ICC_CTLR_EL1_SEIS_SHIFT ; -if (host_seis != seis) -return false; - - host_a3v = ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_A3V_MASK ) >>ICH_VTR_A3V_SHIFT ); - a3v = (val &ICC_CTLR_EL1_A3V_MASK ) >>ICC_CTLR_EL1_A3V_SHIFT ; -if (host_a3v != a3v) -return false; - -/* -* Here set VMCR.CTLR in ICC_CTLR_EL1 layout. -* The vgic_set_vmcr() will convert to ICH_VMCR layout. -*/ - vmcr.cbpr = (val &ICC_CTLR_EL1_CBPR_MASK ) >>ICC_CTLR_EL1_CBPR_SHIFT ; - vmcr.eoim = (val & ICC_CTLR_EL1_EOImode_MASK) >> ICC_CTLR_EL1_EOImode_SHIFT; -vgic_set_vmcr (vcpu, &vmcr); - }else { - val =0 ; - val |= (vgic_v3_cpu->num_pri_bits -1 ) << -ICC_CTLR_EL1_PRI_BITS_SHIFT ; - val |= vgic_v3_cpu->num_id_bits <<ICC_CTLR_EL1_ID_BITS_SHIFT ; - val |= ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_SEIS_MASK ) >>ICH_VTR_SEIS_SHIFT ) << -ICC_CTLR_EL1_SEIS_SHIFT ; - val |= ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_A3V_MASK ) >>ICH_VTR_A3V_SHIFT ) << -ICC_CTLR_EL1_A3V_SHIFT ; -/* -* The VMCR.CTLR value is in ICC_CTLR_EL1 layout. -* Extract it directly using ICC_CTLR_EL1 reg definitions. -*/ - val |= (vmcr.cbpr <<ICC_CTLR_EL1_CBPR_SHIFT ) &ICC_CTLR_EL1_CBPR_MASK ; - val |= (vmcr.eoim << ICC_CTLR_EL1_EOImode_SHIFT) & ICC_CTLR_EL1_EOImode_MASK; - - p->regval = val; - } + val =0 ; + val |= (vgic_v3_cpu->num_pri_bits -1 ) <<ICC_CTLR_EL1_PRI_BITS_SHIFT ; + val |= vgic_v3_cpu->num_id_bits <<ICC_CTLR_EL1_ID_BITS_SHIFT ; + val |= ((kvm_vgic_global_state.ich_vtr_el2 & +ICH_VTR_SEIS_MASK ) >>ICH_VTR_SEIS_SHIFT ) << +ICC_CTLR_EL1_SEIS_SHIFT ; + val |= ((kvm_vgic_global_state.ich_vtr_el2 & +ICH_VTR_A3V_MASK ) >>ICH_VTR_A3V_SHIFT ) << +ICC_CTLR_EL1_A3V_SHIFT ; +/* +* The VMCR.CTLR value is in ICC_CTLR_EL1 layout. +* Extract it directly using ICC_CTLR_EL1 reg definitions. +*/ + val |= (vmcr.cbpr <<ICC_CTLR_EL1_CBPR_SHIFT ) &ICC_CTLR_EL1_CBPR_MASK ; + val |= (vmcr.eoim << ICC_CTLR_EL1_EOImode_SHIFT) & ICC_CTLR_EL1_EOImode_MASK; + + *valp = val; -return true; +return 0 ; } -static bool access_gic_pmr (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int set_gic_pmr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) {struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); -if (p->is_write) { - vmcr.pmr = (p->regval &ICC_PMR_EL1_MASK ) >>ICC_PMR_EL1_SHIFT ; -vgic_set_vmcr (vcpu, &vmcr); - }else { - p->regval = (vmcr.pmr <<ICC_PMR_EL1_SHIFT ) &ICC_PMR_EL1_MASK ; - } + vmcr.pmr = (val &ICC_PMR_EL1_MASK ) >>ICC_PMR_EL1_SHIFT ; +vgic_set_vmcr (vcpu, &vmcr); -return true; +return 0 ; } -static bool access_gic_bpr0 (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int get_gic_pmr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) {struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); -if (p->is_write) { - vmcr.bpr = (p->regval &ICC_BPR0_EL1_MASK ) >> -ICC_BPR0_EL1_SHIFT ; -vgic_set_vmcr (vcpu, &vmcr); - }else { - p->regval = (vmcr.bpr <<ICC_BPR0_EL1_SHIFT ) & -ICC_BPR0_EL1_MASK ; - } + *val = (vmcr.pmr <<ICC_PMR_EL1_SHIFT ) &ICC_PMR_EL1_MASK ; -return true; +return 0 ; } -static bool access_gic_bpr1 (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int set_gic_bpr0 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) {struct vgic_vmcr vmcr; -if (!p->is_write) - p->regval =0 ; +vgic_get_vmcr (vcpu, &vmcr); + vmcr.bpr = (val &ICC_BPR0_EL1_MASK ) >>ICC_BPR0_EL1_SHIFT ; +vgic_set_vmcr (vcpu, &vmcr); + +return 0 ; +} + +static int get_gic_bpr0 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) +{ +struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); -if (!vmcr.cbpr) { -if (p->is_write) { - vmcr.abpr = (p->regval &ICC_BPR1_EL1_MASK ) >> -ICC_BPR1_EL1_SHIFT ; -vgic_set_vmcr (vcpu, &vmcr); - }else { - p->regval = (vmcr.abpr <<ICC_BPR1_EL1_SHIFT ) & -ICC_BPR1_EL1_MASK ; - } - }else { -if (!p->is_write) - p->regval =min ((vmcr.bpr +1 ),7U ); - } + *val = (vmcr.bpr <<ICC_BPR0_EL1_SHIFT ) &ICC_BPR0_EL1_MASK ; -return true; +return 0 ; } -static bool access_gic_grpen0 (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int set_gic_bpr1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) {struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); -if (p->is_write) { - vmcr.grpen0 = (p->regval &ICC_IGRPEN0_EL1_MASK ) >> -ICC_IGRPEN0_EL1_SHIFT ; +if (!vmcr.cbpr) { + vmcr.abpr = (val &ICC_BPR1_EL1_MASK ) >>ICC_BPR1_EL1_SHIFT ;vgic_set_vmcr (vcpu, &vmcr); - }else { - p->regval = (vmcr.grpen0 <<ICC_IGRPEN0_EL1_SHIFT ) & -ICC_IGRPEN0_EL1_MASK ; } -return true; +return 0 ; } -static bool access_gic_grpen1 (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int get_gic_bpr1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) {struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); -if (p->is_write) { - vmcr.grpen1 = (p->regval &ICC_IGRPEN1_EL1_MASK ) >> -ICC_IGRPEN1_EL1_SHIFT ; -vgic_set_vmcr (vcpu, &vmcr); - }else { - p->regval = (vmcr.grpen1 <<ICC_IGRPEN1_EL1_SHIFT ) & -ICC_IGRPEN1_EL1_MASK ; - } +if (!vmcr.cbpr) + *val = (vmcr.abpr <<ICC_BPR1_EL1_SHIFT ) &ICC_BPR1_EL1_MASK ; +else + *val =min ((vmcr.bpr +1 ),7U ); + + +return 0 ; +} + +static int set_gic_grpen0 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) +{ +struct vgic_vmcr vmcr; + +vgic_get_vmcr (vcpu, &vmcr); + vmcr.grpen0 = (val &ICC_IGRPEN0_EL1_MASK ) >>ICC_IGRPEN0_EL1_SHIFT ; +vgic_set_vmcr (vcpu, &vmcr); + +return 0 ; +} + +static int get_gic_grpen0 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) +{ +struct vgic_vmcr vmcr; + +vgic_get_vmcr (vcpu, &vmcr); + *val = (vmcr.grpen0 <<ICC_IGRPEN0_EL1_SHIFT ) &ICC_IGRPEN0_EL1_MASK ; + +return 0 ; +} + +static int set_gic_grpen1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) +{ +struct vgic_vmcr vmcr; -return true; +vgic_get_vmcr (vcpu, &vmcr); + vmcr.grpen1 = (val &ICC_IGRPEN1_EL1_MASK ) >>ICC_IGRPEN1_EL1_SHIFT ; +vgic_set_vmcr (vcpu, &vmcr); + +return 0 ; } -static void vgic_v3_access_apr_reg (struct kvm_vcpu *vcpu, -struct sys_reg_params *p,u8 apr,u8 idx) +static int get_gic_grpen1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) +{ +struct vgic_vmcr vmcr; + +vgic_get_vmcr (vcpu, &vmcr); + *val = (vmcr.grpen1 <<ICC_IGRPEN1_EL1_SHIFT ) &ICC_IGRPEN1_EL1_MASK ; + +return 0 ; +} + +static void set_apr_reg (struct kvm_vcpu *vcpu,u64 val,u8 apr,u8 idx) {struct vgic_v3_cpu_if *vgicv3 = &vcpu->arch.vgic_cpu.vgic_v3; -uint32_t *ap_reg;if (apr) - ap_reg = &vgicv3->vgic_ap1r[idx]; + vgicv3->vgic_ap1r[idx] = val;else - ap_reg = &vgicv3->vgic_ap0r[idx]; + vgicv3->vgic_ap0r[idx] = val; +} + +static u64 get_apr_reg (struct kvm_vcpu *vcpu,u8 apr,u8 idx) +{ +struct vgic_v3_cpu_if *vgicv3 = &vcpu->arch.vgic_cpu.vgic_v3; -if (p->is_write) - *ap_reg = p->regval; +if (apr) +return vgicv3->vgic_ap1r[idx];else - p->regval = *ap_reg; +return vgicv3->vgic_ap0r[idx]; +} + +static int set_gic_ap0r (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) + +{ +u8 idx = r->Op2 &3 ; + +if (idx >vgic_v3_max_apr_idx (vcpu)) +return -EINVAL ; + +set_apr_reg (vcpu, val,0 , idx); +return 0 ; } -static bool access_gic_aprn (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r,u8 apr) +static int get_gic_ap0r (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) {u8 idx = r->Op2 &3 ;if (idx >vgic_v3_max_apr_idx (vcpu)) - goto err; +return -EINVAL ; -vgic_v3_access_apr_reg (vcpu, p, apr, idx); -return true; -err: -if (!p->is_write) - p->regval =0 ; + *val =get_apr_reg (vcpu,0 , idx); -return false; +return 0 ; } -static bool access_gic_ap0r (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int set_gic_ap1r (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) { -return access_gic_aprn (vcpu, p, r,0 ); +u8 idx = r->Op2 &3 ; + +if (idx >vgic_v3_max_apr_idx (vcpu)) +return -EINVAL ; + +set_apr_reg (vcpu, val,1 , idx); +return 0 ; +} + +static int get_gic_ap1r (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) +{ +u8 idx = r->Op2 &3 ; + +if (idx >vgic_v3_max_apr_idx (vcpu)) +return -EINVAL ; + + *val =get_apr_reg (vcpu,1 , idx); + +return 0 ; } -static bool access_gic_ap1r (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int set_gic_sre (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 val) { -return access_gic_aprn (vcpu, p, r,1 ); +/* Validate SRE bit */ +if (!(val &ICC_SRE_EL1_SRE )) +return -EINVAL ; + +return 0 ; } -static bool access_gic_sre (struct kvm_vcpu *vcpu,struct sys_reg_params *p, -const struct sys_reg_desc *r) +static int get_gic_sre (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r, +u64 *val) {struct vgic_v3_cpu_if *vgicv3 = &vcpu->arch.vgic_cpu.vgic_v3; -/* Validate SRE bit */ -if (p->is_write) { -if (!(p->regval &ICC_SRE_EL1_SRE )) -return false; - }else { - p->regval = vgicv3->vgic_sre; - } + *val = vgicv3->vgic_sre; -return true; +return 0 ; } +static const struct sys_reg_desc gic_v3_icc_reg_descs[] = { - {SYS_DESC (SYS_ICC_PMR_EL1 ), access_gic_pmr }, - {SYS_DESC (SYS_ICC_BPR0_EL1 ), access_gic_bpr0 }, - {SYS_DESC (SYS_ICC_AP0R0_EL1 ), access_gic_ap0r }, - {SYS_DESC (SYS_ICC_AP0R1_EL1 ), access_gic_ap0r }, - {SYS_DESC (SYS_ICC_AP0R2_EL1 ), access_gic_ap0r }, - {SYS_DESC (SYS_ICC_AP0R3_EL1 ), access_gic_ap0r }, - {SYS_DESC (SYS_ICC_AP1R0_EL1 ), access_gic_ap1r }, - {SYS_DESC (SYS_ICC_AP1R1_EL1 ), access_gic_ap1r }, - {SYS_DESC (SYS_ICC_AP1R2_EL1 ), access_gic_ap1r }, - {SYS_DESC (SYS_ICC_AP1R3_EL1 ), access_gic_ap1r }, - {SYS_DESC (SYS_ICC_BPR1_EL1 ), access_gic_bpr1 }, - {SYS_DESC (SYS_ICC_CTLR_EL1 ), access_gic_ctlr }, - {SYS_DESC (SYS_ICC_SRE_EL1 ), access_gic_sre }, - {SYS_DESC (SYS_ICC_IGRPEN0_EL1 ), access_gic_grpen0 }, - {SYS_DESC (SYS_ICC_IGRPEN1_EL1 ), access_gic_grpen1 }, + {SYS_DESC (SYS_ICC_PMR_EL1 ), + .set_user = set_gic_pmr, .get_user = get_gic_pmr, }, + {SYS_DESC (SYS_ICC_BPR0_EL1 ), + .set_user = set_gic_bpr0, .get_user = get_gic_bpr0, }, + {SYS_DESC (SYS_ICC_AP0R0_EL1 ), + .set_user = set_gic_ap0r, .get_user = get_gic_ap0r, }, + {SYS_DESC (SYS_ICC_AP0R1_EL1 ), + .set_user = set_gic_ap0r, .get_user = get_gic_ap0r, }, + {SYS_DESC (SYS_ICC_AP0R2_EL1 ), + .set_user = set_gic_ap0r, .get_user = get_gic_ap0r, }, + {SYS_DESC (SYS_ICC_AP0R3_EL1 ), + .set_user = set_gic_ap0r, .get_user = get_gic_ap0r, }, + {SYS_DESC (SYS_ICC_AP1R0_EL1 ), + .set_user = set_gic_ap1r, .get_user = get_gic_ap1r, }, + {SYS_DESC (SYS_ICC_AP1R1_EL1 ), + .set_user = set_gic_ap1r, .get_user = get_gic_ap1r, }, + {SYS_DESC (SYS_ICC_AP1R2_EL1 ), + .set_user = set_gic_ap1r, .get_user = get_gic_ap1r, }, + {SYS_DESC (SYS_ICC_AP1R3_EL1 ), + .set_user = set_gic_ap1r, .get_user = get_gic_ap1r, }, + {SYS_DESC (SYS_ICC_BPR1_EL1 ), + .set_user = set_gic_bpr1, .get_user = get_gic_bpr1, }, + {SYS_DESC (SYS_ICC_CTLR_EL1 ), + .set_user = set_gic_ctlr, .get_user = get_gic_ctlr, }, + {SYS_DESC (SYS_ICC_SRE_EL1 ), + .set_user = set_gic_sre, .get_user = get_gic_sre, }, + {SYS_DESC (SYS_ICC_IGRPEN0_EL1 ), + .set_user = set_gic_grpen0, .get_user = get_gic_grpen0, }, + {SYS_DESC (SYS_ICC_IGRPEN1_EL1 ), + .set_user = set_gic_grpen1, .get_user = get_gic_grpen1, }, };static u64 attr_to_id (u64 attr)
@@ -282,31 +358,15 @@ int vgic_v3_cpu_sysregs_uaccess(struct kvm_vcpu *vcpu, struct kvm_device_attr *attr, bool is_write) { -u64 __user *uaddr = (u64 __user *)(long )attr->addr; -struct sys_reg_params params; -const struct sys_reg_desc *r; -u64 sysreg; - - sysreg =attr_to_id (attr->attr); - -if (is_write) { -if (get_user (params.regval, uaddr)) -return -EFAULT ; - } - params.is_write = is_write; - - r =find_reg_by_id (sysreg, ¶ms, gic_v3_icc_reg_descs, -ARRAY_SIZE (gic_v3_icc_reg_descs)); -if (!r) -return -ENXIO ; - -if (!r->access (vcpu, ¶ms, r)) -return -EINVAL ; - -if (!is_write) { -if (put_user (params.regval, uaddr)) -return -EFAULT ; - } - -return 0 ; +struct kvm_one_reg reg = { + .id =attr_to_id (attr->attr), + .addr = attr->addr, + }; + +if (is_write) +return kvm_sys_reg_set_user (vcpu, ®, gic_v3_icc_reg_descs, +ARRAY_SIZE (gic_v3_icc_reg_descs)); +else +return kvm_sys_reg_get_user (vcpu, ®, gic_v3_icc_reg_descs, +ARRAY_SIZE (gic_v3_icc_reg_descs)); }
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 10/20 KVM: arm64: vgic-v3: Convert userspace accessors over to FIELD_GET/FIELD_PREP
In reply to Marc ZyngierThe GICv3 userspace accessors are all about dealing with conversion between fields from architectural registers and internal representations.
However, and owing to the age of this code, the accessors use a combination of shift/mask that is hard to read. It is nonetheless easy to make it better by using the FIELD_{GET,PREP} macros that solely rely on a mask.
This results in somewhat nicer looking code, and is probably easier to maintain.
--- arch/arm64/kvm/vgic-sys-reg-v3.c | 60 ++++++++++++++------------------ 1 file changed, 27 insertions(+), 33 deletions(-)
arch/arm64/kvm/vgic-sys-reg-v3.c +27 -33
@@ -23,30 +23,25 @@ static int set_gic_ctlr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,* Disallow restoring VM state if not supported by this * hardware. */ - host_pri_bits = ((val &ICC_CTLR_EL1_PRI_BITS_MASK ) >> -ICC_CTLR_EL1_PRI_BITS_SHIFT ) +1 ; + host_pri_bits =FIELD_GET (ICC_CTLR_EL1_PRI_BITS_MASK , val) +1 ;if (host_pri_bits > vgic_v3_cpu->num_pri_bits)return -EINVAL ; vgic_v3_cpu->num_pri_bits = host_pri_bits; - host_id_bits = (val &ICC_CTLR_EL1_ID_BITS_MASK ) >> -ICC_CTLR_EL1_ID_BITS_SHIFT ; + host_id_bits =FIELD_GET (ICC_CTLR_EL1_ID_BITS_MASK , val);if (host_id_bits > vgic_v3_cpu->num_id_bits)return -EINVAL ; vgic_v3_cpu->num_id_bits = host_id_bits; - host_seis = ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_SEIS_MASK ) >>ICH_VTR_SEIS_SHIFT ); - seis = (val &ICC_CTLR_EL1_SEIS_MASK ) >> -ICC_CTLR_EL1_SEIS_SHIFT ; + host_seis =FIELD_GET (ICH_VTR_SEIS_MASK , kvm_vgic_global_state.ich_vtr_el2); + seis =FIELD_GET (ICC_CTLR_EL1_SEIS_MASK , val);if (host_seis != seis)return -EINVAL ; - host_a3v = ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_A3V_MASK ) >>ICH_VTR_A3V_SHIFT ); - a3v = (val &ICC_CTLR_EL1_A3V_MASK ) >>ICC_CTLR_EL1_A3V_SHIFT ; + host_a3v =FIELD_GET (ICH_VTR_A3V_MASK , kvm_vgic_global_state.ich_vtr_el2); + a3v =FIELD_GET (ICC_CTLR_EL1_A3V_MASK , val);if (host_a3v != a3v)return -EINVAL ;
@@ -54,8 +49,8 @@ static int set_gic_ctlr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,* Here set VMCR.CTLR in ICC_CTLR_EL1 layout. * The vgic_set_vmcr() will convert to ICH_VMCR layout. */ - vmcr.cbpr = (val &ICC_CTLR_EL1_CBPR_MASK ) >>ICC_CTLR_EL1_CBPR_SHIFT ; - vmcr.eoim = (val & ICC_CTLR_EL1_EOImode_MASK) >> ICC_CTLR_EL1_EOImode_SHIFT; + vmcr.cbpr =FIELD_GET (ICC_CTLR_EL1_CBPR_MASK , val); + vmcr.eoim =FIELD_GET (ICC_CTLR_EL1_EOImode_MASK, val);vgic_set_vmcr (vcpu, &vmcr);return 0 ;
@@ -70,20 +65,19 @@ static int get_gic_ctlr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,vgic_get_vmcr (vcpu, &vmcr); val =0 ; - val |= (vgic_v3_cpu->num_pri_bits -1 ) <<ICC_CTLR_EL1_PRI_BITS_SHIFT ; - val |= vgic_v3_cpu->num_id_bits <<ICC_CTLR_EL1_ID_BITS_SHIFT ; - val |= ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_SEIS_MASK ) >>ICH_VTR_SEIS_SHIFT ) << -ICC_CTLR_EL1_SEIS_SHIFT ; - val |= ((kvm_vgic_global_state.ich_vtr_el2 & -ICH_VTR_A3V_MASK ) >>ICH_VTR_A3V_SHIFT ) << -ICC_CTLR_EL1_A3V_SHIFT ; + val |=FIELD_PREP (ICC_CTLR_EL1_PRI_BITS_MASK , vgic_v3_cpu->num_pri_bits -1 ); + val |=FIELD_PREP (ICC_CTLR_EL1_ID_BITS_MASK , vgic_v3_cpu->num_id_bits); + val |=FIELD_PREP (ICC_CTLR_EL1_SEIS_MASK , +FIELD_GET (ICH_VTR_SEIS_MASK , + kvm_vgic_global_state.ich_vtr_el2)); + val |=FIELD_PREP (ICC_CTLR_EL1_A3V_MASK , +FIELD_GET (ICH_VTR_A3V_MASK , kvm_vgic_global_state.ich_vtr_el2));/* * The VMCR.CTLR value is in ICC_CTLR_EL1 layout. * Extract it directly using ICC_CTLR_EL1 reg definitions. */ - val |= (vmcr.cbpr <<ICC_CTLR_EL1_CBPR_SHIFT ) &ICC_CTLR_EL1_CBPR_MASK ; - val |= (vmcr.eoim << ICC_CTLR_EL1_EOImode_SHIFT) & ICC_CTLR_EL1_EOImode_MASK; + val |=FIELD_PREP (ICC_CTLR_EL1_CBPR_MASK , vmcr.cbpr); + val |=FIELD_PREP (ICC_CTLR_EL1_EOImode_MASK, vmcr.eoim); *valp = val;
@@ -96,7 +90,7 @@ static int set_gic_pmr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - vmcr.pmr = (val &ICC_PMR_EL1_MASK ) >>ICC_PMR_EL1_SHIFT ; + vmcr.pmr =FIELD_GET (ICC_PMR_EL1_MASK , val);vgic_set_vmcr (vcpu, &vmcr);return 0 ;
@@ -108,7 +102,7 @@ static int get_gic_pmr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - *val = (vmcr.pmr <<ICC_PMR_EL1_SHIFT ) &ICC_PMR_EL1_MASK ; + *val =FIELD_PREP (ICC_PMR_EL1_MASK , vmcr.pmr);return 0 ; }
@@ -119,7 +113,7 @@ static int set_gic_bpr0(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - vmcr.bpr = (val &ICC_BPR0_EL1_MASK ) >>ICC_BPR0_EL1_SHIFT ; + vmcr.bpr =FIELD_GET (ICC_BPR0_EL1_MASK , val);vgic_set_vmcr (vcpu, &vmcr);return 0 ;
@@ -131,7 +125,7 @@ static int get_gic_bpr0(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - *val = (vmcr.bpr <<ICC_BPR0_EL1_SHIFT ) &ICC_BPR0_EL1_MASK ; + *val =FIELD_PREP (ICC_BPR0_EL1_MASK , vmcr.bpr);return 0 ; }
@@ -143,7 +137,7 @@ static int set_gic_bpr1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,vgic_get_vmcr (vcpu, &vmcr);if (!vmcr.cbpr) { - vmcr.abpr = (val &ICC_BPR1_EL1_MASK ) >>ICC_BPR1_EL1_SHIFT ; + vmcr.abpr =FIELD_GET (ICC_BPR1_EL1_MASK , val);vgic_set_vmcr (vcpu, &vmcr); }
@@ -157,7 +151,7 @@ static int get_gic_bpr1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,vgic_get_vmcr (vcpu, &vmcr);if (!vmcr.cbpr) - *val = (vmcr.abpr <<ICC_BPR1_EL1_SHIFT ) &ICC_BPR1_EL1_MASK ; + *val =FIELD_PREP (ICC_BPR1_EL1_MASK , vmcr.abpr);else *val =min ((vmcr.bpr +1 ),7U );
@@ -171,7 +165,7 @@ static int set_gic_grpen0(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - vmcr.grpen0 = (val &ICC_IGRPEN0_EL1_MASK ) >>ICC_IGRPEN0_EL1_SHIFT ; + vmcr.grpen0 =FIELD_GET (ICC_IGRPEN0_EL1_MASK , val);vgic_set_vmcr (vcpu, &vmcr);return 0 ;
@@ -183,7 +177,7 @@ static int get_gic_grpen0(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - *val = (vmcr.grpen0 <<ICC_IGRPEN0_EL1_SHIFT ) &ICC_IGRPEN0_EL1_MASK ; + *val =FIELD_PREP (ICC_IGRPEN0_EL1_MASK , vmcr.grpen0);return 0 ; }
@@ -194,7 +188,7 @@ static int set_gic_grpen1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - vmcr.grpen1 = (val &ICC_IGRPEN1_EL1_MASK ) >>ICC_IGRPEN1_EL1_SHIFT ; + vmcr.grpen1 =FIELD_GET (ICC_IGRPEN1_EL1_MASK , val);vgic_set_vmcr (vcpu, &vmcr);return 0 ;
@@ -206,7 +200,7 @@ static int get_gic_grpen1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,struct vgic_vmcr vmcr;vgic_get_vmcr (vcpu, &vmcr); - *val = (vmcr.grpen1 <<ICC_IGRPEN1_EL1_SHIFT ) &ICC_IGRPEN1_EL1_MASK ; + *val =FIELD_GET (ICC_IGRPEN1_EL1_MASK , vmcr.grpen1);return 0 ; }
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 11/20 KVM: arm64: vgic-v3: Use u32 to manage the line level from userspace
In reply to Marc ZyngierDespite the userspace ABI clearly defining the bits dealt with by KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO as a __u32, the kernel uses a u64.
Use a u32 to match the userspace ABI, which will subsequently lead to some simplifications.
--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 6 +++++- arch/arm64/kvm/vgic/vgic-mmio-v3.c | 2 +- arch/arm64/kvm/vgic/vgic-mmio.c | 6 +++--- arch/arm64/kvm/vgic/vgic-mmio.h | 4 ++-- arch/arm64/kvm/vgic/vgic.h | 2 +- 5 files changed, 12 insertions(+), 8 deletions(-)
arch/arm64/kvm/vgic/vgic-kvm-device.c +5 -1
@@ -570,10 +570,14 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev, info = (attr->attr &KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_MASK ) >>KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_SHIFT ;if (info ==VGIC_LEVEL_INFO_LINE_LEVEL ) { +if (is_write) + tmp32 = *reg; intid = attr->attr &KVM_DEV_ARM_VGIC_LINE_LEVEL_INTID_MASK ; ret =vgic_v3_line_level_info_uaccess (vcpu, is_write, - intid, reg); + intid, &tmp32); +if (!is_write) + *reg = tmp32; }else { ret = -EINVAL ; }
arch/arm64/kvm/vgic/vgic-mmio-v3.c +1 -1
@@ -1154,7 +1154,7 @@ int vgic_v3_redist_uaccess(struct kvm_vcpu *vcpu, bool is_write, }int vgic_v3_line_level_info_uaccess (struct kvm_vcpu *vcpu,bool is_write, -u32 intid,u64 *val) +u32 intid,u32 *val) {if (intid %32 )return -EINVAL ;
arch/arm64/kvm/vgic/vgic-mmio.c +3 -3
@@ -775,10 +775,10 @@ void vgic_mmio_write_config(struct kvm_vcpu *vcpu, } } -u64 vgic_read_irq_line_level_info (struct kvm_vcpu *vcpu,u32 intid) +u32 vgic_read_irq_line_level_info (struct kvm_vcpu *vcpu,u32 intid) {int i; -u64 val =0 ; +u32 val =0 ;int nr_irqs = vcpu->kvm->arch.vgic.nr_spis +VGIC_NR_PRIVATE_IRQS ;for (i =0 ; i <32 ; i++) {
@@ -798,7 +798,7 @@ u64 vgic_read_irq_line_level_info(struct kvm_vcpu *vcpu, u32 intid) }void vgic_write_irq_line_level_info (struct kvm_vcpu *vcpu,u32 intid, -const u64 val) +const u32 val) {int i;int nr_irqs = vcpu->kvm->arch.vgic.nr_spis +VGIC_NR_PRIVATE_IRQS ;
arch/arm64/kvm/vgic/vgic-mmio.h +2 -2
@@ -207,10 +207,10 @@ void vgic_mmio_write_config(struct kvm_vcpu *vcpu,int vgic_uaccess (struct kvm_vcpu *vcpu,struct vgic_io_device *dev,bool is_write,int offset,u32 *val); -u64 vgic_read_irq_line_level_info (struct kvm_vcpu *vcpu,u32 intid); +u32 vgic_read_irq_line_level_info (struct kvm_vcpu *vcpu,u32 intid);void vgic_write_irq_line_level_info (struct kvm_vcpu *vcpu,u32 intid, -const u64 val); +const u32 val);unsigned int vgic_v2_init_dist_iodev (struct vgic_io_device *dev);
arch/arm64/kvm/vgic/vgic.h +1 -1
@@ -249,7 +249,7 @@ int vgic_v3_cpu_sysregs_uaccess(struct kvm_vcpu *vcpu, struct kvm_device_attr *attr, bool is_write);int vgic_v3_has_cpu_sysregs_attr (struct kvm_vcpu *vcpu,struct kvm_device_attr *attr);int vgic_v3_line_level_info_uaccess (struct kvm_vcpu *vcpu,bool is_write, -u32 intid,u64 *val); +u32 intid,u32 *val);int kvm_register_vgic_device (unsigned long type);void vgic_set_vmcr (struct kvm_vcpu *vcpu,struct vgic_vmcr *vmcr);void vgic_get_vmcr (struct kvm_vcpu *vcpu,struct vgic_vmcr *vmcr);
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 12/20 KVM: arm64: vgic-v3: Consolidate userspace access for MMIO registers
In reply to Marc ZyngierFor userspace accesses to GICv3 MMIO registers (and related data), vgic_v3_{get,set}_attr are littered with {get,put}_user() calls, making it hard to audit and reason about.
Consolidate all userspace accesses in vgic_v3_attr_regs_access(), making the code far simpler to audit.
--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 103 +++++++++----------------- 1 file changed, 37 insertions(+), 66 deletions(-)
arch/arm64/kvm/vgic/vgic-kvm-device.c +37 -66
@@ -512,18 +512,18 @@ int vgic_v3_parse_attr(struct kvm_device *dev, struct kvm_device_attr *attr,* * @dev: kvm device handle * @attr: kvm device attribute -* @reg: address the value is read or written, NULL for sysregs * @is_write: true if userspace is writing a register */ static int vgic_v3_attr_regs_access (struct kvm_device *dev,struct kvm_device_attr *attr, -u64 *reg,bool is_write) +bool is_write) {struct vgic_reg_attr reg_attr;gpa_t addr;struct kvm_vcpu *vcpu; +bool uaccess; +u32 val;int ret; -u32 tmp32; ret =vgic_v3_parse_attr (dev, attr, ®_attr);if (ret)
@@ -532,6 +532,21 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev, vcpu = reg_attr.vcpu; addr = reg_attr.addr; +switch (attr->group) { +case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : +/* Sysregs uaccess is performed by the sysreg handling code */ + uaccess = false; +break ; +default : + uaccess = true; + } + +if (uaccess && is_write) { +u32 __user *uaddr = (u32 __user *)(unsigned long )attr->addr; +if (get_user (val, uaddr)) +return -EFAULT ; + } +mutex_lock (&dev->kvm->lock);if (unlikely (!vgic_initialized (dev->kvm))) {
@@ -546,20 +561,10 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev,switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS : -if (is_write) - tmp32 = *reg; - - ret =vgic_v3_dist_uaccess (vcpu, is_write, addr, &tmp32); -if (!is_write) - *reg = tmp32; + ret =vgic_v3_dist_uaccess (vcpu, is_write, addr, &val);break ;case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : -if (is_write) - tmp32 = *reg; - - ret =vgic_v3_redist_uaccess (vcpu, is_write, addr, &tmp32); -if (!is_write) - *reg = tmp32; + ret =vgic_v3_redist_uaccess (vcpu, is_write, addr, &val);break ;case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : ret =vgic_v3_cpu_sysregs_uaccess (vcpu, attr, is_write);
@@ -570,14 +575,10 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev, info = (attr->attr &KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_MASK ) >>KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_SHIFT ;if (info ==VGIC_LEVEL_INFO_LINE_LEVEL ) { -if (is_write) - tmp32 = *reg; intid = attr->attr &KVM_DEV_ARM_VGIC_LINE_LEVEL_INTID_MASK ; ret =vgic_v3_line_level_info_uaccess (vcpu, is_write, - intid, &tmp32); -if (!is_write) - *reg = tmp32; + intid, &val); }else { ret = -EINVAL ; }
@@ -591,6 +592,12 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev,unlock_all_vcpus (dev->kvm); out:mutex_unlock (&dev->kvm->lock); + +if (!ret && uaccess && !is_write) { +u32 __user *uaddr = (u32 __user *)(unsigned long )attr->addr; + ret =put_user (val, uaddr); + } +return ret; }
@@ -605,30 +612,12 @@ static int vgic_v3_set_attr(struct kvm_device *dev,switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS : -case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : { -u32 __user *uaddr = (u32 __user *)(long )attr->addr; -u32 tmp32; -u64 reg; - -if (get_user (tmp32, uaddr)) -return -EFAULT ; - - reg = tmp32; -return vgic_v3_attr_regs_access (dev, attr, ®, true); - } +case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : +return vgic_v3_attr_regs_access (dev, attr, true);case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : -return vgic_v3_attr_regs_access (dev, attr,NULL , true); -case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : { -u32 __user *uaddr = (u32 __user *)(long )attr->addr; -u64 reg; -u32 tmp32; - -if (get_user (tmp32, uaddr)) -return -EFAULT ; - - reg = tmp32; -return vgic_v3_attr_regs_access (dev, attr, ®, true); - } +return vgic_v3_attr_regs_access (dev, attr, true); +case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : +return vgic_v3_attr_regs_access (dev, attr, true);case KVM_DEV_ARM_VGIC_GRP_CTRL : {int ret;
@@ -662,30 +651,12 @@ static int vgic_v3_get_attr(struct kvm_device *dev,switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS : -case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : { -u32 __user *uaddr = (u32 __user *)(long )attr->addr; -u64 reg; -u32 tmp32; - - ret =vgic_v3_attr_regs_access (dev, attr, ®, false); -if (ret) -return ret; - tmp32 = reg; -return put_user (tmp32, uaddr); - } +case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : +return vgic_v3_attr_regs_access (dev, attr, false);case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : -return vgic_v3_attr_regs_access (dev, attr,NULL , false); -case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : { -u32 __user *uaddr = (u32 __user *)(long )attr->addr; -u64 reg; -u32 tmp32; - - ret =vgic_v3_attr_regs_access (dev, attr, ®, false); -if (ret) -return ret; - tmp32 = reg; -return put_user (tmp32, uaddr); - } +return vgic_v3_attr_regs_access (dev, attr, false); +case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO : +return vgic_v3_attr_regs_access (dev, attr, false); }return -ENXIO ; }
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 13/20 KVM: arm64: vgic-v2: Consolidate userspace access for MMIO registers
In reply to Marc ZyngierAlign the GICv2 MMIO accesses from userspace with the way the GICv3 code is now structured.
--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 39 ++++++++++++--------------- 1 file changed, 17 insertions(+), 22 deletions(-)
arch/arm64/kvm/vgic/vgic-kvm-device.c +17 -22
@@ -348,17 +348,18 @@ bool lock_all_vcpus(struct kvm *kvm)* * @dev: kvm device handle * @attr: kvm device attribute -* @reg: address the value is read or written * @is_write: true if userspace is writing a register */ static int vgic_v2_attr_regs_access (struct kvm_device *dev,struct kvm_device_attr *attr, -u32 *reg,bool is_write) +bool is_write) { +u32 __user *uaddr = (u32 __user *)(unsigned long )attr->addr;struct vgic_reg_attr reg_attr;gpa_t addr;struct kvm_vcpu *vcpu;int ret; +u32 val; ret =vgic_v2_parse_attr (dev, attr, ®_attr);if (ret)
@@ -367,6 +368,10 @@ static int vgic_v2_attr_regs_access(struct kvm_device *dev, vcpu = reg_attr.vcpu; addr = reg_attr.addr; +if (is_write) +if (get_user (val, uaddr)) +return -EFAULT ; +mutex_lock (&dev->kvm->lock); ret =vgic_init (dev->kvm);
@@ -380,10 +385,10 @@ static int vgic_v2_attr_regs_access(struct kvm_device *dev,switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_CPU_REGS : - ret =vgic_v2_cpuif_uaccess (vcpu, is_write, addr, reg); + ret =vgic_v2_cpuif_uaccess (vcpu, is_write, addr, &val);break ;case KVM_DEV_ARM_VGIC_GRP_DIST_REGS : - ret =vgic_v2_dist_uaccess (vcpu, is_write, addr, reg); + ret =vgic_v2_dist_uaccess (vcpu, is_write, addr, &val);break ;default : ret = -EINVAL ;
@@ -393,6 +398,10 @@ static int vgic_v2_attr_regs_access(struct kvm_device *dev,unlock_all_vcpus (dev->kvm); out:mutex_unlock (&dev->kvm->lock); + +if (!ret && !is_write) + ret =put_user (val, uaddr); +return ret; }
@@ -407,15 +416,8 @@ static int vgic_v2_set_attr(struct kvm_device *dev,switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS : -case KVM_DEV_ARM_VGIC_GRP_CPU_REGS : { -u32 __user *uaddr = (u32 __user *)(long )attr->addr; -u32 reg; - -if (get_user (reg, uaddr)) -return -EFAULT ; - -return vgic_v2_attr_regs_access (dev, attr, ®, true); - } +case KVM_DEV_ARM_VGIC_GRP_CPU_REGS : +return vgic_v2_attr_regs_access (dev, attr, true); }return -ENXIO ;
@@ -432,15 +434,8 @@ static int vgic_v2_get_attr(struct kvm_device *dev,switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS : -case KVM_DEV_ARM_VGIC_GRP_CPU_REGS : { -u32 __user *uaddr = (u32 __user *)(long )attr->addr; -u32 reg =0 ; - - ret =vgic_v2_attr_regs_access (dev, attr, ®, false); -if (ret) -return ret; -return put_user (reg, uaddr); - } +case KVM_DEV_ARM_VGIC_GRP_CPU_REGS : +return vgic_v2_attr_regs_access (dev, attr, false); }return -ENXIO ;
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 14/20 KVM: arm64: vgic: Use {get,put}_user() instead of copy_{from.to}_user
In reply to Marc ZyngierTidy-up vgic_get_common_attr() and vgic_set_common_attr() to use {get,put}_user() instead of the more complex (and less type-safe) copy_{from,to}_user().
--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/arm64/kvm/vgic/vgic-kvm-device.c +3 -3
@@ -170,7 +170,7 @@ static int vgic_set_common_attr(struct kvm_device *dev,u64 addr;unsigned long type = (unsigned long )attr->attr; -if (copy_from_user (&addr, uaddr,sizeof (addr))) +if (get_user (addr, uaddr))return -EFAULT ; r =kvm_vgic_addr (dev->kvm, type, &addr, true);
@@ -233,14 +233,14 @@ static int vgic_get_common_attr(struct kvm_device *dev,u64 addr;unsigned long type = (unsigned long )attr->attr; -if (copy_from_user (&addr, uaddr,sizeof (addr))) +if (get_user (addr, uaddr))return -EFAULT ; r =kvm_vgic_addr (dev->kvm, type, &addr, false);if (r)return (r == -ENODEV ) ? -ENXIO : r; -if (copy_to_user (uaddr, &addr,sizeof (addr))) +if (put_user (addr, uaddr))return -EFAULT ;break ; }
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 15/20 KVM: arm64: vgic-v2: Add helper for legacy dist/cpuif base address setting
In reply to Marc ZyngierWe carry a legacy interface to set the base addresses for GICv2. As this is currently plumbed into the same handling code as the modern interface, it limits the evolution we can make there.
Add a helper dedicated to this handling, with a view of maybe removing this in the future.
--- arch/arm64/kvm/arm.c | 11 ++------- arch/arm64/kvm/vgic/vgic-kvm-device.c | 32 +++++++++++++++++++++++++++ include/kvm/arm_vgic.h | 1 + 3 files changed, 35 insertions(+), 9 deletions(-)
arch/arm64/kvm/arm.c +2 -9
@@ -1414,18 +1414,11 @@ void kvm_arch_flush_remote_tlbs_memslot(struct kvm *kvm,static int kvm_vm_ioctl_set_device_addr (struct kvm *kvm,struct kvm_arm_device_addr *dev_addr) { -unsigned long dev_id, type; - - dev_id = (dev_addr->id &KVM_ARM_DEVICE_ID_MASK ) >> -KVM_ARM_DEVICE_ID_SHIFT ; - type = (dev_addr->id &KVM_ARM_DEVICE_TYPE_MASK ) >> -KVM_ARM_DEVICE_TYPE_SHIFT ; - -switch (dev_id) { +switch (FIELD_GET (KVM_ARM_DEVICE_ID_MASK , dev_addr->id)) {case KVM_ARM_DEVICE_VGIC_V2 :if (!vgic_present)return -ENXIO ; -return kvm_vgic_addr (kvm, type, &dev_addr->addr, true); +return kvm_set_legacy_vgic_v2_addr (kvm, dev_addr);default :return -ENODEV ; }
arch/arm64/kvm/vgic/vgic-kvm-device.c +32 -0
@@ -41,6 +41,38 @@ static int vgic_check_type(struct kvm *kvm, int type_needed)return 0 ; } +int kvm_set_legacy_vgic_v2_addr (struct kvm *kvm,struct kvm_arm_device_addr *dev_addr) +{ +struct vgic_dist *vgic = &kvm->arch.vgic; +int r; + +mutex_lock (&kvm->lock); +switch (FIELD_GET (KVM_ARM_DEVICE_TYPE_MASK , dev_addr->id)) { +case KVM_VGIC_V2_ADDR_TYPE_DIST : + r =vgic_check_type (kvm,KVM_DEV_TYPE_ARM_VGIC_V2 ); +if (!r) + r =vgic_check_iorange (kvm, vgic->vgic_dist_base, dev_addr->addr, +SZ_4K ,KVM_VGIC_V2_DIST_SIZE ); +if (!r) + vgic->vgic_dist_base = dev_addr->addr; +break ; +case KVM_VGIC_V2_ADDR_TYPE_CPU : + r =vgic_check_type (kvm,KVM_DEV_TYPE_ARM_VGIC_V2 ); +if (!r) + r =vgic_check_iorange (kvm, vgic->vgic_cpu_base, dev_addr->addr, +SZ_4K ,KVM_VGIC_V2_CPU_SIZE ); +if (!r) + vgic->vgic_cpu_base = dev_addr->addr; +break ; +default : + r = -ENODEV ; + } + +mutex_unlock (&kvm->lock); + +return r; +} +/** * kvm_vgic_addr - set or get vgic VM base addresses * @kvm: pointer to the vm struct
include/kvm/arm_vgic.h +1 -0
@@ -365,6 +365,7 @@ extern struct static_key_false vgic_v2_cpuif_trap;extern struct static_key_false vgic_v3_cpuif_trap;int kvm_vgic_addr (struct kvm *kvm,unsigned long type,u64 *addr,bool write); +int kvm_set_legacy_vgic_v2_addr (struct kvm *kvm,struct kvm_arm_device_addr *dev_addr);void kvm_vgic_early_init (struct kvm *kvm);int kvm_vgic_vcpu_init (struct kvm_vcpu *vcpu);int kvm_vgic_create (struct kvm *kvm,u32 type);
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 16/20 KVM: arm64: vgic: Consolidate userspace access for base address setting
In reply to Marc ZyngierAlign kvm_vgic_addr() with the rest of the code by moving the userspace accesses into it. kvm_vgic_addr() is also made static.
--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 75 +++++++++++---------------- include/kvm/arm_vgic.h | 1 - 2 files changed, 31 insertions(+), 45 deletions(-)
arch/arm64/kvm/vgic/vgic-kvm-device.c +31 -44
@@ -76,8 +76,7 @@ int kvm_set_legacy_vgic_v2_addr(struct kvm *kvm, struct kvm_arm_device_addr *dev/** * kvm_vgic_addr - set or get vgic VM base addresses * @kvm: pointer to the vm struct -* @type: the VGIC addr type, one of KVM_VGIC_V[23]_ADDR_TYPE_XXX -* @addr: pointer to address value +* @attr: pointer to the attribute being retrieved/updated * @write: if true set the address in the VM address space, if false read the * address *
@@ -89,15 +88,22 @@ int kvm_set_legacy_vgic_v2_addr(struct kvm *kvm, struct kvm_arm_device_addr *dev* overlapping regions in case of a virtual GICv3 here, since we don't know * the number of VCPUs yet, so we defer this check to map_resources(). */ -int kvm_vgic_addr (struct kvm *kvm,unsigned long type,u64 *addr,bool write) +static int kvm_vgic_addr (struct kvm *kvm,struct kvm_device_attr *attr,bool write) { -int r =0 ; +u64 __user *uaddr = (u64 __user *)attr->addr;struct vgic_dist *vgic = &kvm->arch.vgic;phys_addr_t *addr_ptr, alignment, size;u64 undef_value =VGIC_ADDR_UNDEF ; +u64 addr; +int r; + +/* Reading a redistributor region addr implies getting the index */ +if (write || attr->attr ==KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION ) +if (get_user (addr, uaddr)) +return -EFAULT ;mutex_lock (&kvm->lock); -switch (type) { +switch (attr->attr) {case KVM_VGIC_V2_ADDR_TYPE_DIST : r =vgic_check_type (kvm,KVM_DEV_TYPE_ARM_VGIC_V2 ); addr_ptr = &vgic->vgic_dist_base;
@@ -123,7 +129,7 @@ int kvm_vgic_addr(struct kvm *kvm, unsigned long type, u64 *addr, bool write)if (r)break ;if (write) { - r =vgic_v3_set_redist_base (kvm,0 , *addr,0 ); + r =vgic_v3_set_redist_base (kvm,0 , addr,0 ); goto out; } rdreg = list_first_entry_or_null(&vgic->rd_regions,
@@ -143,14 +149,12 @@ int kvm_vgic_addr(struct kvm *kvm, unsigned long type, u64 *addr, bool write)if (r)break ; - index = *addr &KVM_VGIC_V3_RDIST_INDEX_MASK ; + index = addr &KVM_VGIC_V3_RDIST_INDEX_MASK ;if (write) { -gpa_t base = *addr &KVM_VGIC_V3_RDIST_BASE_MASK ; -u32 count = (*addr &KVM_VGIC_V3_RDIST_COUNT_MASK ) - >>KVM_VGIC_V3_RDIST_COUNT_SHIFT ; -u8 flags = (*addr &KVM_VGIC_V3_RDIST_FLAGS_MASK ) - >>KVM_VGIC_V3_RDIST_FLAGS_SHIFT ; +gpa_t base = addr &KVM_VGIC_V3_RDIST_BASE_MASK ; +u32 count =FIELD_GET (KVM_VGIC_V3_RDIST_COUNT_MASK , addr); +u8 flags =FIELD_GET (KVM_VGIC_V3_RDIST_FLAGS_MASK , addr);if (!count || flags) r = -EINVAL ;
@@ -166,9 +170,9 @@ int kvm_vgic_addr(struct kvm *kvm, unsigned long type, u64 *addr, bool write) goto out; } - *addr = index; - *addr |= rdreg->base; - *addr |= (u64 )rdreg->count <<KVM_VGIC_V3_RDIST_COUNT_SHIFT ; + addr = index; + addr |= rdreg->base; + addr |= (u64 )rdreg->count <<KVM_VGIC_V3_RDIST_COUNT_SHIFT ; goto out; }default :
@@ -179,15 +183,19 @@ int kvm_vgic_addr(struct kvm *kvm, unsigned long type, u64 *addr, bool write) goto out;if (write) { - r =vgic_check_iorange (kvm, *addr_ptr, *addr, alignment, size); + r =vgic_check_iorange (kvm, *addr_ptr, addr, alignment, size);if (!r) - *addr_ptr = *addr; + *addr_ptr = addr; }else { - *addr = *addr_ptr; + addr = *addr_ptr; } out:mutex_unlock (&kvm->lock); + +if (!r && !write) + r =put_user (addr, uaddr); +return r; }
@@ -197,17 +205,9 @@ static int vgic_set_common_attr(struct kvm_device *dev,int r;switch (attr->group) { -case KVM_DEV_ARM_VGIC_GRP_ADDR : { -u64 __user *uaddr = (u64 __user *)(long )attr->addr; -u64 addr; -unsigned long type = (unsigned long )attr->attr; - -if (get_user (addr, uaddr)) -return -EFAULT ; - - r =kvm_vgic_addr (dev->kvm, type, &addr, true); +case KVM_DEV_ARM_VGIC_GRP_ADDR : + r =kvm_vgic_addr (dev->kvm, attr, true);return (r == -ENODEV ) ? -ENXIO : r; - }case KVM_DEV_ARM_VGIC_GRP_NR_IRQS : {u32 __user *uaddr = (u32 __user *)(long )attr->addr;u32 val;
@@ -260,22 +260,9 @@ static int vgic_get_common_attr(struct kvm_device *dev,int r = -ENXIO ;switch (attr->group) { -case KVM_DEV_ARM_VGIC_GRP_ADDR : { -u64 __user *uaddr = (u64 __user *)(long )attr->addr; -u64 addr; -unsigned long type = (unsigned long )attr->attr; - -if (get_user (addr, uaddr)) -return -EFAULT ; - - r =kvm_vgic_addr (dev->kvm, type, &addr, false); -if (r) -return (r == -ENODEV ) ? -ENXIO : r; - -if (put_user (addr, uaddr)) -return -EFAULT ; -break ; - } +case KVM_DEV_ARM_VGIC_GRP_ADDR : + r =kvm_vgic_addr (dev->kvm, attr, false); +return (r == -ENODEV ) ? -ENXIO : r;case KVM_DEV_ARM_VGIC_GRP_NR_IRQS : {u32 __user *uaddr = (u32 __user *)(long )attr->addr;
include/kvm/arm_vgic.h +0 -1
@@ -364,7 +364,6 @@ struct vgic_cpu {extern struct static_key_false vgic_v2_cpuif_trap;extern struct static_key_false vgic_v3_cpuif_trap; -int kvm_vgic_addr (struct kvm *kvm,unsigned long type,u64 *addr,bool write);int kvm_set_legacy_vgic_v2_addr (struct kvm *kvm,struct kvm_arm_device_addr *dev_addr);void kvm_vgic_early_init (struct kvm *kvm);int kvm_vgic_vcpu_init (struct kvm_vcpu *vcpu);
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 17/20 KVM: arm64: vgic: Tidy-up calls to vgic_{get,set}_common_attr()
In reply to Marc ZyngierThe userspace accessors have an early call to vgic_{get,set}_common_attr() that makes the code hard to follow. Move it to the default: clause of the decoding switch statement, which results in a nice cleanup.
This requires us to move the handling of the pending table into the common handling, even if it is strictly a GICv3 feature (it has the benefit of keeping the whole control group handling in the same function).
Also cleanup vgic_v3_{get,set}_attr() while we're at it, deduplicating the calls to vgic_v3_attr_regs_access().
--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 78 +++++++++------------------ 1 file changed, 26 insertions(+), 52 deletions(-)
arch/arm64/kvm/vgic/vgic-kvm-device.c +26 -52
@@ -246,6 +246,24 @@ static int vgic_set_common_attr(struct kvm_device *dev, r =vgic_init (dev->kvm);mutex_unlock (&dev->kvm->lock);return r; +case KVM_DEV_ARM_VGIC_SAVE_PENDING_TABLES : +/* +* OK, this one isn't common at all, but we +* want to handle all control group attributes +* in a single place. +*/ +if (vgic_check_type (dev->kvm,KVM_DEV_TYPE_ARM_VGIC_V3 )) +return -ENXIO ; +mutex_lock (&dev->kvm->lock); + +if (!lock_all_vcpus (dev->kvm)) { +mutex_unlock (&dev->kvm->lock); +return -EBUSY ; + } + r =vgic_v3_save_pending_tables (dev->kvm); +unlock_all_vcpus (dev->kvm); +mutex_unlock (&dev->kvm->lock); +return r; }break ; }
@@ -427,37 +445,25 @@ static int vgic_v2_attr_regs_access(struct kvm_device *dev,static int vgic_v2_set_attr (struct kvm_device *dev,struct kvm_device_attr *attr) { -int ret; - - ret =vgic_set_common_attr (dev, attr); -if (ret != -ENXIO ) -return ret; -switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS :case KVM_DEV_ARM_VGIC_GRP_CPU_REGS :return vgic_v2_attr_regs_access (dev, attr, true); +default : +return vgic_set_common_attr (dev, attr); } - -return -ENXIO ; }static int vgic_v2_get_attr (struct kvm_device *dev,struct kvm_device_attr *attr) { -int ret; - - ret =vgic_get_common_attr (dev, attr); -if (ret != -ENXIO ) -return ret; -switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS :case KVM_DEV_ARM_VGIC_GRP_CPU_REGS :return vgic_v2_attr_regs_access (dev, attr, false); +default : +return vgic_get_common_attr (dev, attr); } - -return -ENXIO ; } static int vgic_v2_has_attr(struct kvm_device *dev,
@@ -618,61 +624,29 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev,static int vgic_v3_set_attr (struct kvm_device *dev,struct kvm_device_attr *attr) { -int ret; - - ret =vgic_set_common_attr (dev, attr); -if (ret != -ENXIO ) -return ret; -switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS :case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : -return vgic_v3_attr_regs_access (dev, attr, true);case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : -return vgic_v3_attr_regs_access (dev, attr, true);case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO :return vgic_v3_attr_regs_access (dev, attr, true); -case KVM_DEV_ARM_VGIC_GRP_CTRL : { -int ret; - -switch (attr->attr) { -case KVM_DEV_ARM_VGIC_SAVE_PENDING_TABLES : -mutex_lock (&dev->kvm->lock); - -if (!lock_all_vcpus (dev->kvm)) { -mutex_unlock (&dev->kvm->lock); -return -EBUSY ; - } - ret =vgic_v3_save_pending_tables (dev->kvm); -unlock_all_vcpus (dev->kvm); -mutex_unlock (&dev->kvm->lock); -return ret; - } -break ; - } +default : +return vgic_set_common_attr (dev, attr); } -return -ENXIO ; }static int vgic_v3_get_attr (struct kvm_device *dev,struct kvm_device_attr *attr) { -int ret; - - ret =vgic_get_common_attr (dev, attr); -if (ret != -ENXIO ) -return ret; -switch (attr->group) {case KVM_DEV_ARM_VGIC_GRP_DIST_REGS :case KVM_DEV_ARM_VGIC_GRP_REDIST_REGS : -return vgic_v3_attr_regs_access (dev, attr, false);case KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS : -return vgic_v3_attr_regs_access (dev, attr, false);case KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO :return vgic_v3_attr_regs_access (dev, attr, false); +default : +return vgic_get_common_attr (dev, attr); } -return -ENXIO ; } static int vgic_v3_has_attr(struct kvm_device *dev,
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 18/20 KVM: arm64: Get rid of find_reg_by_id()
In reply to Marc ZyngierThis helper doesn't have a user anymore, let's get rid of it.
--- arch/arm64/kvm/sys_regs.c | 11 ----------- arch/arm64/kvm/sys_regs.h | 5 ----- 2 files changed, 16 deletions(-)
arch/arm64/kvm/sys_regs.c +0 -11
@@ -2577,17 +2577,6 @@ static bool index_to_params(u64 id, struct sys_reg_params *params) } } -const struct sys_reg_desc *find_reg_by_id (u64 id, -struct sys_reg_params *params, -const struct sys_reg_desc table[], -unsigned int num) -{ -if (!index_to_params (id, params)) -return NULL ; - -return find_reg (params, table, num); -} -const struct sys_reg_desc *get_reg_by_id (u64 id,const struct sys_reg_desc table[],unsigned int num)
arch/arm64/kvm/sys_regs.h +0 -5
@@ -190,11 +190,6 @@ find_reg(const struct sys_reg_params *params, const struct sys_reg_desc table[],return __inline_bsearch ((void *)pval, table, num,sizeof (table[0 ]), match_sys_reg); } -const struct sys_reg_desc *find_reg_by_id (u64 id, -struct sys_reg_params *params, -const struct sys_reg_desc table[], -unsigned int num); -const struct sys_reg_desc *get_reg_by_id (u64 id,const struct sys_reg_desc table[],unsigned int num);
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 19/20 KVM: arm64: Descope kvm_arm_sys_reg_{get,set}_reg()
In reply to Marc ZyngierHaving kvm_arm_sys_reg_get_reg and co in kvm_host.h gives the impression that these functions are free to be called from anywhere.
Not quite. They really are tied to out internal sysreg handling, and they would be better off in the sys_regs.h header, which is private. kvm_host.h could also get a bit of a diet, so let's just do that.
--- arch/arm64/include/asm/kvm_host.h | 2 -- arch/arm64/kvm/sys_regs.h | 3 ++- 2 files changed, 2 insertions(+), 3 deletions(-)
arch/arm64/include/asm/kvm_host.h +0 -2
@@ -620,8 +620,6 @@ int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);unsigned long kvm_arm_num_sys_reg_descs (struct kvm_vcpu *vcpu);int kvm_arm_copy_sys_reg_indices (struct kvm_vcpu *vcpu,u64 __user *uindices); -int kvm_arm_sys_reg_get_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *); -int kvm_arm_sys_reg_set_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *);int __kvm_arm_vcpu_get_events (struct kvm_vcpu *vcpu,struct kvm_vcpu_events *events);
arch/arm64/kvm/sys_regs.h +2 -1
@@ -194,9 +194,10 @@ const struct sys_reg_desc *get_reg_by_id(u64 id,const struct sys_reg_desc table[], unsigned int num); +int kvm_arm_sys_reg_get_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *); +int kvm_arm_sys_reg_set_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *);int kvm_sys_reg_get_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg,const struct sys_reg_desc table[],unsigned int num); -int kvm_sys_reg_set_user (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg,const struct sys_reg_desc table[],unsigned int num);
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH v2 20/20 KVM: arm64: Get rid or outdated comments
In reply to Marc ZyngierOnce apon a time, the 32bit KVM/arm port was the reference, while the arm64 version was the new kid on the block, without a clear future... This was a long time ago.
"The times, they are a-changing."
--- arch/arm64/kvm/sys_regs.c | 5 ----- 1 file changed, 5 deletions(-)
arch/arm64/kvm/sys_regs.c +0 -5
@@ -34,11 +34,6 @@#include "trace.h" /* -* All of this file is extremely similar to the ARM coproc.c, but the -* types are different. My gut feeling is that it should be pretty -* easy to merge, but that would be an ABI breakage -- again. VFP -* would also need to be abstracted. -* * For AArch32, we only take care of what is being trapped. Anything * that has to do with init and userspace access has to go via the * 64bit interface.
Signature · 6 lines
2.34.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerQuoted 10 lines · Marc Zyngier
This is a follow-up to [1], which aims a performing a bunch of cleanups in the way we expose sysregs to userspace, with a particular focus on the GICv3 part of that code.
* From v1:
- A couple of extra cleanups thanks to Reiji's comments
- A fix for the breakage of the legacy GICv2 address setup
- Collected RBs from Reiji and Oliver, with thanks.[...]
Provisionally applied to -next in order to get some exposure during -rc7. No garantees I'll keep that in though.
[01/20] KVM: arm64: Add get_reg_by_id() as a sys_reg_desc retrieving helper
commit: da8d120fbafe1d3217d25ac45493538b37cff87c
[02/20] KVM: arm64: Reorder handling of invariant sysregs from userspace
commit: 1deeffb559663dc44e4b8a61fe7e271fe3b4b836
[03/20] KVM: arm64: Introduce generic get_user/set_user helpers for system registers
commit: ba23aec9f4f27c00ac7a504aae60cae8a4087a19
[04/20] KVM: arm64: Rely on index_to_param() for size checks on userspace access
commit: e48407ff9796529a1e5048b9e4d6ea8a0334468e
[05/20] KVM: arm64: Consolidate sysreg userspace accesses
commit: 978ceeb3e40a59973ff1d1c3d23484f71f141819
[06/20] KVM: arm64: Get rid of reg_from/to_user()
commit: 5a420ed9646a934e983358aeba1bf3cd993d1cc5
[07/20] KVM: arm64: vgic-v3: Simplify vgic_v3_has_cpu_sysregs_attr()
commit: b61fc0857a3ad4cdee44128ad13685033e237367
[08/20] KVM: arm64: vgic-v3: Push user access into vgic_v3_cpu_sysregs_uaccess()
commit: db25081e147c3cc496b8cd8c9d67f992546df6d5
[09/20] KVM: arm64: vgic-v3: Make the userspace accessors use sysreg API
commit: cbcf14dd23bcf228eb6061991acf3721506b97ae
[10/20] KVM: arm64: vgic-v3: Convert userspace accessors over to FIELD_GET/FIELD_PREP
commit: 71c3c7753c722b8b10566dcdf1ff0a2eaf33a9c1
[11/20] KVM: arm64: vgic-v3: Use u32 to manage the line level from userspace
commit: 38cf0bb7625a58625efeef9ec944671464ff7430
[12/20] KVM: arm64: vgic-v3: Consolidate userspace access for MMIO registers
commit: e1246f3f2df7aec025fd587ac3d7912007d1144d
[13/20] KVM: arm64: vgic-v2: Consolidate userspace access for MMIO registers
commit: 7e9f723c2a90e41407d5889700169be4797a2009
[14/20] KVM: arm64: vgic: Use {get, put}_user() instead of copy_{from.to}_user
commit: d7df6f282db67677c06456fd29d47eda0ba060b9
[15/20] KVM: arm64: vgic-v2: Add helper for legacy dist/cpuif base address setting
commit: 9f968c9266aa30b0e81be0c6a560e45b93bed3dc
[16/20] KVM: arm64: vgic: Consolidate userspace access for base address setting
commit: 4b85080f4e378f617f88964dec94fd282bcf2af4
[17/20] KVM: arm64: vgic: Tidy-up calls to vgic_{get,set}_common_attr()
commit: 619064afa9b6f0088b86a1fed20c049cfe94cdf7
[18/20] KVM: arm64: Get rid of find_reg_by_id()
commit: f6dddbb25572218d2e8ab93bfdad20cddeb99b5a
[19/20] KVM: arm64: Descope kvm_arm_sys_reg_{get,set}_reg()
commit: c5332898dc35bbed7d3aa02b491e3388315ee481
[20/20] KVM: arm64: Get rid or outdated comments
commit: 4274d42716d87d5301fdf67eb799e7db08fe73deCheers,
M.
Signature · 6 lines
Marc Zyngier <[email protected]> _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm