KVM: arm64: emulation for CTR_EL0
v4 cover KVM: arm64: emulation for CTR_EL0
Hej folks,
I'm looking into supporting migration between 2 Ampere Altra (Max) machines (using Neoverse-N1). They are almost identical regarding their feature id register state except for CTR_EL0.DIC which is set on one machine but not the other.
CTR_EL0 is currently marked as invariant and migrating a VM between those 2 machines using qemu fails.
Changes RFC [0] -> V1 [1]:
* store the emulated value per VM and not per VCPU
* allow to change more values than just the DIC bit
* only trap guest access to that reg when needed
* make sure to not present the guest with an inconsistent register set
Changes V1 -> V2 [2]:
* implemented Marc's suggestion for keeping registers consistent while not breaking userspace ABI / expectations (I hope correctly this time)
* keep the shadowed value valid at all time
* unify the code to setup traps
Changes V2 -> V3 [3]:
* rebased to kvm-arm-next (to include Olivers idreg fixes)
* fixed VM ops trapping for non-FWB CPUs
* fixed writable mask for CLIDR_EL1
* re-added manual ctr validation (using arm64_check_features() had a side effect with the way .reset is working for these registers)
* added a testcase
Changes V3 -> V4:
* incorporated feedback from Shaoqin and Eric
Thanks,
Sebastian
[0]: https://lore.kernel.org/all/[email protected]/T/
[1]: https://lore.kernel.org/lkml/[email protected]/T/
[2]: https://lore.kernel.org/lkml/[email protected]/T/
[3]: https://lore.kernel.org/lkml/[email protected]/T/
Sebastian Ott (6):
KVM: arm64: unify code to prepare traps
KVM: arm64: maintain per VM value for CTR_EL0
KVM: arm64: add emulation for CTR_EL0 register
KVM: arm64: show writable masks for feature registers
KVM: arm64: rename functions for invariant sys regs
KVM: selftests: arm64: Test writes to CTR_EL0
arch/arm64/include/asm/kvm_emulate.h | 40 +--- arch/arm64/include/asm/kvm_host.h | 4 +- arch/arm64/kvm/arm.c | 2 +- arch/arm64/kvm/sys_regs.c | 214 ++++++++++++++---- .../selftests/kvm/aarch64/set_id_regs.c | 16 ++ 5 files changed, 201 insertions(+), 75 deletions(-)
Signature · 1 line
2.42.0
PATCH v4 1/6 KVM: arm64: unify code to prepare traps
There are 2 functions to calculate traps via HCR_EL2:
* kvm_init_sysreg() called via KVM_RUN (before the 1st run or when the pid changes)
* vcpu_reset_hcr() called via KVM_ARM_VCPU_INIT
To unify these 2 and to support traps that are dependent on the ID register configuration, move the code from vcpu_reset_hcr() to sys_regs.c and call it via kvm_init_sysreg().
We still have to keep the non-FWB handling stuff in vcpu_reset_hcr(). Also the initialization with HCR_GUEST_FLAGS is kept there but guarded by !vcpu_has_run_once() to ensure that previous calculated values don't get overwritten.
While at it rename kvm_init_sysreg() to kvm_calculate_traps() to better reflect what it's doing.
--- arch/arm64/include/asm/kvm_emulate.h | 40 +++++++--------------------- arch/arm64/include/asm/kvm_host.h | 2 +- arch/arm64/kvm/arm.c | 2 +- arch/arm64/kvm/sys_regs.c | 34 +++++++++++++++++++++-- 4 files changed, 43 insertions(+), 35 deletions(-)
arch/arm64/include/asm/kvm_emulate.h +9 -31
@@ -69,39 +69,17 @@ static __always_inline bool vcpu_el1_is_32bit(struct kvm_vcpu *vcpu)static inline void vcpu_reset_hcr (struct kvm_vcpu *vcpu) { - vcpu->arch.hcr_el2 =HCR_GUEST_FLAGS ; -if (has_vhe () ||has_hvhe ()) - vcpu->arch.hcr_el2 |=HCR_E2H ; -if (cpus_have_final_cap (ARM64_HAS_RAS_EXTN )) { -/* route synchronous external abort exceptions to EL2 */ - vcpu->arch.hcr_el2 |=HCR_TEA ; -/* trap error record accesses */ - vcpu->arch.hcr_el2 |=HCR_TERR ; - } +if (!vcpu_has_run_once (vcpu)) + vcpu->arch.hcr_el2 =HCR_GUEST_FLAGS ; -if (cpus_have_final_cap (ARM64_HAS_STAGE2_FWB )) { - vcpu->arch.hcr_el2 |=HCR_FWB ; - }else { -/* -* For non-FWB CPUs, we trap VM ops (HCR_EL2.TVM) until M+C -* get set in SCTLR_EL1 such that we can detect when the guest -* MMU gets turned on and do the necessary cache maintenance -* then. -*/ +/* +* For non-FWB CPUs, we trap VM ops (HCR_EL2.TVM) until M+C +* get set in SCTLR_EL1 such that we can detect when the guest +* MMU gets turned on and do the necessary cache maintenance +* then. +*/ +if (!cpus_have_final_cap (ARM64_HAS_STAGE2_FWB )) vcpu->arch.hcr_el2 |=HCR_TVM ; - } - -if (cpus_have_final_cap (ARM64_HAS_EVT ) && - !cpus_have_final_cap (ARM64_MISMATCHED_CACHE_TYPE )) - vcpu->arch.hcr_el2 |=HCR_TID4 ; -else - vcpu->arch.hcr_el2 |=HCR_TID2 ; - -if (vcpu_el1_is_32bit (vcpu)) - vcpu->arch.hcr_el2 &= ~HCR_RW ; - -if (kvm_has_mte (vcpu->kvm)) - vcpu->arch.hcr_el2 |=HCR_ATA ; }static inline unsigned long *vcpu_hcr (struct kvm_vcpu *vcpu)
arch/arm64/include/asm/kvm_host.h +1 -1
@@ -1122,7 +1122,7 @@ int __init populate_nv_trap_config(void);bool lock_all_vcpus (struct kvm *kvm);void unlock_all_vcpus (struct kvm *kvm); -void kvm_init_sysreg (struct kvm_vcpu *); +void kvm_calculate_traps (struct kvm_vcpu *);/* MMIO helpers */ void kvm_mmio_write_buf (void *buf,unsigned int len,unsigned long data);
arch/arm64/kvm/arm.c +1 -1
@@ -797,7 +797,7 @@ int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu)* This needs to happen after NV has imposed its own restrictions on * the feature set */ -kvm_init_sysreg (vcpu); +kvm_calculate_traps (vcpu); ret =kvm_timer_enable (vcpu);if (ret)
arch/arm64/kvm/sys_regs.c +32 -2
@@ -4041,11 +4041,33 @@ int kvm_vm_ioctl_get_reg_writable_masks(struct kvm *kvm, struct reg_mask_range *return 0 ; } -void kvm_init_sysreg (struct kvm_vcpu *vcpu) +static void vcpu_set_hcr (struct kvm_vcpu *vcpu) {struct kvm *kvm = vcpu->kvm; -mutex_lock (&kvm->arch.config_lock); +if (has_vhe () ||has_hvhe ()) + vcpu->arch.hcr_el2 |=HCR_E2H ; +if (cpus_have_final_cap (ARM64_HAS_RAS_EXTN )) { +/* route synchronous external abort exceptions to EL2 */ + vcpu->arch.hcr_el2 |=HCR_TEA ; +/* trap error record accesses */ + vcpu->arch.hcr_el2 |=HCR_TERR ; + } + +if (cpus_have_final_cap (ARM64_HAS_STAGE2_FWB )) + vcpu->arch.hcr_el2 |=HCR_FWB ; + +if (cpus_have_final_cap (ARM64_HAS_EVT ) && + !cpus_have_final_cap (ARM64_MISMATCHED_CACHE_TYPE )) + vcpu->arch.hcr_el2 |=HCR_TID4 ; +else + vcpu->arch.hcr_el2 |=HCR_TID2 ; + +if (vcpu_el1_is_32bit (vcpu)) + vcpu->arch.hcr_el2 &= ~HCR_RW ; + +if (kvm_has_mte (vcpu->kvm)) + vcpu->arch.hcr_el2 |=HCR_ATA ;/* * In the absence of FGT, we cannot independently trap TLBI
@@ -4054,6 +4076,14 @@ void kvm_init_sysreg(struct kvm_vcpu *vcpu)*/ if (!kvm_has_feat (kvm,ID_AA64ISAR0_EL1 ,TLB ,OS )) vcpu->arch.hcr_el2 |=HCR_TTLBOS ; +} + +void kvm_calculate_traps (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; + +mutex_lock (&kvm->arch.config_lock); +vcpu_set_hcr (vcpu);if (cpus_have_final_cap (ARM64_HAS_HCX )) { vcpu->arch.hcrx_el2 =HCRX_GUEST_FLAGS ;
Signature · 1 line
2.42.0
PATCH v4 2/6 KVM: arm64: maintain per VM value for CTR_EL0
In reply to Sebastian OttIn preparation for CTR_EL0 emulation maintain a per VM value for this register and use it where appropriate.
--- arch/arm64/include/asm/kvm_host.h | 2 ++ arch/arm64/kvm/sys_regs.c | 21 ++++++++++++++------- 2 files changed, 16 insertions(+), 7 deletions(-)
arch/arm64/include/asm/kvm_host.h +2 -0
@@ -331,6 +331,8 @@ struct kvm_arch {#define KVM_ARM_ID_REG_NUM (IDREG_IDX(sys_reg(3, 0, 0, 7, 7)) + 1)u64 id_regs[KVM_ARM_ID_REG_NUM ]; +u64 ctr_el0; +/* Masks for VNCR-baked sysregs */ struct kvm_sysreg_masks *sysreg_masks;
arch/arm64/kvm/sys_regs.c +14 -7
@@ -219,9 +219,9 @@ void vcpu_write_sys_reg(struct kvm_vcpu *vcpu, u64 val, int reg)* Returns the minimum line size for the selected cache, expressed as * Log2(bytes). */ -static u8 get_min_cache_line_size (bool icache) +static u8 get_min_cache_line_size (struct kvm *kvm,bool icache) { -u64 ctr =read_sanitised_ftr_reg (SYS_CTR_EL0 ); +u64 ctr = kvm->arch.ctr_el0;u8 field;if (icache)
@@ -248,7 +248,7 @@ static u32 get_ccsidr(struct kvm_vcpu *vcpu, u32 csselr)if (vcpu->arch.ccsidr)return vcpu->arch.ccsidr[csselr]; - line_size =get_min_cache_line_size (csselr & CSSELR_EL1_InD); + line_size =get_min_cache_line_size (vcpu->kvm, csselr & CSSELR_EL1_InD);/* * Fabricate a CCSIDR value as the overriding value does not exist.
@@ -283,7 +283,7 @@ static int set_ccsidr(struct kvm_vcpu *vcpu, u32 csselr, u32 val)u32 i;if ((val &CCSIDR_EL1_RES0 ) || - line_size <get_min_cache_line_size (csselr & CSSELR_EL1_InD)) + line_size <get_min_cache_line_size (vcpu->kvm, csselr & CSSELR_EL1_InD))return -EINVAL ;if (!ccsidr) {
@@ -1886,7 +1886,7 @@ static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,if (p->is_write)return write_to_read_only (vcpu, p, r); - p->regval =read_sanitised_ftr_reg (SYS_CTR_EL0 ); + p->regval = vcpu->kvm->arch.ctr_el0;return true; }
@@ -1906,7 +1906,7 @@ static bool access_clidr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,*/ static u64 reset_clidr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r) { -u64 ctr_el0 =read_sanitised_ftr_reg (SYS_CTR_EL0 ); +u64 ctr_el0 = vcpu->kvm->arch.ctr_el0;u64 clidr;u8 loc;
@@ -1959,8 +1959,8 @@ static u64 reset_clidr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)static int set_clidr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd,u64 val) { -u64 ctr_el0 =read_sanitised_ftr_reg (SYS_CTR_EL0 );u64 idc = !CLIDR_LOC (val) || (!CLIDR_LOUIS (val) && !CLIDR_LOUU (val)); +u64 ctr_el0 = vcpu->kvm->arch.ctr_el0;if ((val &CLIDR_EL1_RES0 ) || (!(ctr_el0 &CTR_EL0_IDC ) && idc))return -EINVAL ;
@@ -3557,6 +3557,13 @@ void kvm_reset_sys_regs(struct kvm_vcpu *vcpu)struct kvm *kvm = vcpu->kvm;unsigned long i; +if (!kvm_vcpu_initialized (vcpu)) +/* +* Make sure CTR_EL0 is initialized before registers +* that depend on it are reset. +*/ + kvm->arch.ctr_el0 =read_sanitised_ftr_reg (SYS_CTR_EL0 ); +for (i =0 ; i <ARRAY_SIZE (sys_reg_descs); i++) {const struct sys_reg_desc *r = &sys_reg_descs[i];
Signature · 1 line
2.42.0
PATCH v4 3/6 KVM: arm64: add emulation for CTR_EL0 register
In reply to Sebastian OttCTR_EL0 is currently handled as an invariant register, thus guests will be presented with the host value of that register.
Add emulation for CTR_EL0 based on a per VM value. Userspace can switch off DIC and IDC bits and reduce DminLine and IminLine sizes.
When CTR_EL0 is changed validate that against CLIDR_EL1 and CCSIDR_EL1 to make sure we present the guest with consistent register values. Changes that affect the generated cache topology values are allowed if they don't clash with previous register writes.
--- arch/arm64/kvm/sys_regs.c | 134 +++++++++++++++++++++++++++++++++----- 1 file changed, 118 insertions(+), 16 deletions(-)
arch/arm64/kvm/sys_regs.c +118 -16
@@ -215,13 +215,8 @@ void vcpu_write_sys_reg(struct kvm_vcpu *vcpu, u64 val, int reg)/* CSSELR values; used to index KVM_REG_ARM_DEMUX_ID_CCSIDR */ #define CSSELR_MAX 14 -/* -* Returns the minimum line size for the selected cache, expressed as -* Log2(bytes). -*/ -static u8 get_min_cache_line_size (struct kvm *kvm,bool icache) +static u8 __get_min_cache_line_size (u64 ctr,bool icache) { -u64 ctr = kvm->arch.ctr_el0;u8 field;if (icache)
@@ -240,6 +235,15 @@ static u8 get_min_cache_line_size(struct kvm *kvm, bool icache)return field +2 ; } +/* +* Returns the minimum line size for the selected cache, expressed as +* Log2(bytes). +*/ +static u8 get_min_cache_line_size (struct kvm *kvm,bool icache) +{ +return __get_min_cache_line_size (kvm->arch.ctr_el0, icache); +} +/* Which cache CCSIDR represents depends on CSSELR value. */ static u32 get_ccsidr (struct kvm_vcpu *vcpu,u32 csselr) {
@@ -1880,6 +1884,49 @@ static int set_wi_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,return 0 ; } +static const struct sys_reg_desc *get_sys_reg_desc (u32 encoding); + +static int validate_clidr_el1 (u64 clidr_el1,u64 ctr_el0) +{ +u64 idc = !CLIDR_LOC (clidr_el1) || + (!CLIDR_LOUIS (clidr_el1) && !CLIDR_LOUU (clidr_el1)); + +if ((clidr_el1 &CLIDR_EL1_RES0 ) || (!(ctr_el0 &CTR_EL0_IDC ) && idc)) +return -EINVAL ; + +return 0 ; +} + +static int validate_cache_topology (struct kvm_vcpu *vcpu,u64 ctr_el0) +{ +const struct sys_reg_desc *clidr_el1; +unsigned int i; +int ret; + + clidr_el1 =get_sys_reg_desc (SYS_CLIDR_EL1 ); +if (!clidr_el1) +return -ENOENT ; + + ret =validate_clidr_el1 (__vcpu_sys_reg (vcpu, clidr_el1->reg), ctr_el0); +if (ret) +return ret; + +if (!vcpu->arch.ccsidr) +return 0 ; + +/* +* Make sure the cache line size per level obeys the minimum +* cache line setting. +*/ +for (i =0 ; i <CSSELR_MAX ; i++) { +if ((FIELD_GET (CCSIDR_EL1_LineSize,get_ccsidr (vcpu, i)) +4 ) + <__get_min_cache_line_size (ctr_el0, i & CSSELR_EL1_InD)) +return -EINVAL ; + } + +return 0 ; +} +static bool access_ctr (struct kvm_vcpu *vcpu,struct sys_reg_params *p,const struct sys_reg_desc *r) {
@@ -1890,6 +1937,55 @@ static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,return true; } +static u64 reset_ctr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd) +{ + vcpu->kvm->arch.ctr_el0 =read_sanitised_ftr_reg (SYS_CTR_EL0 ); +return vcpu->kvm->arch.ctr_el0; +} + +static int get_ctr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, +u64 *val) +{ + *val = vcpu->kvm->arch.ctr_el0; +return 0 ; +} + +static int set_ctr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, +u64 val) +{ +u64 ctr, writable_mask = rd->val; +int ret =0 ; + +mutex_lock (&vcpu->kvm->arch.config_lock); + ctr = vcpu->kvm->arch.ctr_el0; +if (val == ctr) + goto out_unlock; + + ret = -EBUSY ; +if (kvm_vm_has_ran_once (vcpu->kvm)) + goto out_unlock; + + ret = -EINVAL ; +if ((ctr & ~writable_mask) != (val & ~writable_mask)) + goto out_unlock; + +if (((ctr &CTR_EL0_DIC_MASK ) < (val &CTR_EL0_DIC_MASK )) || + ((ctr &CTR_EL0_IDC_MASK ) < (val &CTR_EL0_IDC_MASK )) || + ((ctr & CTR_EL0_DminLine_MASK) < (val & CTR_EL0_DminLine_MASK)) || + ((ctr & CTR_EL0_IminLine_MASK) < (val & CTR_EL0_IminLine_MASK))) { + goto out_unlock; + } + ret =validate_cache_topology (vcpu, val); +if (ret) + goto out_unlock; + + vcpu->kvm->arch.ctr_el0 = val; +out_unlock: +mutex_unlock (&vcpu->kvm->arch.config_lock); + +return ret; +} +static bool access_clidr (struct kvm_vcpu *vcpu,struct sys_reg_params *p,const struct sys_reg_desc *r) {
@@ -1959,10 +2055,9 @@ static u64 reset_clidr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)static int set_clidr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd,u64 val) { -u64 idc = !CLIDR_LOC (val) || (!CLIDR_LOUIS (val) && !CLIDR_LOUU (val));u64 ctr_el0 = vcpu->kvm->arch.ctr_el0; -if ((val &CLIDR_EL1_RES0 ) || (!(ctr_el0 &CTR_EL0_IDC ) && idc)) +if (validate_clidr_el1 (val, ctr_el0))return -EINVAL ;__vcpu_sys_reg (vcpu, rd->reg) = val;
@@ -2475,7 +2570,11 @@ static const struct sys_reg_desc sys_reg_descs[] = { { SYS_DESC(SYS_CCSIDR2_EL1), undef_access }, { SYS_DESC(SYS_SMIDR_EL1), undef_access }, { SYS_DESC(SYS_CSSELR_EL1), access_csselr, reset_unknown, CSSELR_EL1 }, - { SYS_DESC(SYS_CTR_EL0), access_ctr }, + { SYS_DESC(SYS_CTR_EL0), access_ctr, .reset = reset_ctr, + .get_user = get_ctr, .set_user = set_ctr, .val = (CTR_EL0_DIC_MASK | +CTR_EL0_IDC_MASK | + CTR_EL0_DminLine_MASK | + CTR_EL0_IminLine_MASK)}, { SYS_DESC(SYS_SVCR), undef_access }, { PMU_SYS_REG(PMCR_EL0), .access = access_pmcr, .reset = reset_pmcr,
@@ -3651,6 +3750,13 @@ static bool index_to_params(u64 id, struct sys_reg_params *params) } } +static const struct sys_reg_desc *get_sys_reg_desc (u32 encoding) +{ +struct sys_reg_params params =encoding_to_params (encoding); + +return find_reg (¶ms, sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); +} +const struct sys_reg_desc *get_reg_by_id (u64 id,const struct sys_reg_desc table[],unsigned int num)
@@ -3704,18 +3810,11 @@ FUNCTION_INVARIANT(midr_el1)FUNCTION_INVARIANT (revidr_el1)FUNCTION_INVARIANT (aidr_el1 ) -static u64 get_ctr_el0(struct kvm_vcpu *v, const struct sys_reg_desc *r) -{ - ((struct sys_reg_desc *)r)->val = read_sanitised_ftr_reg(SYS_CTR_EL0); - return ((struct sys_reg_desc *)r)->val; -} -/* ->val is filled in by kvm_sys_reg_table_init() */ static struct sys_reg_desc invariant_sys_regs[]__ro_after_init = { {SYS_DESC (SYS_MIDR_EL1 ),NULL , get_midr_el1 }, {SYS_DESC (SYS_REVIDR_EL1 ),NULL , get_revidr_el1 }, {SYS_DESC (SYS_AIDR_EL1 ),NULL , get_aidr_el1 }, - { SYS_DESC(SYS_CTR_EL0), NULL, get_ctr_el0 }, };static int get_invariant_sys_reg (u64 id,u64 __user *uaddr)
@@ -4083,6 +4182,9 @@ static void vcpu_set_hcr(struct kvm_vcpu *vcpu)*/ if (!kvm_has_feat (kvm,ID_AA64ISAR0_EL1 ,TLB ,OS )) vcpu->arch.hcr_el2 |=HCR_TTLBOS ; + +if (kvm->arch.ctr_el0 !=read_sanitised_ftr_reg (SYS_CTR_EL0 )) + vcpu->arch.hcr_el2 |=HCR_TID2 ; }void kvm_calculate_traps (struct kvm_vcpu *vcpu)
Signature · 1 line
2.42.0
Re: [PATCH v4 3/6] KVM: arm64: add emulation for CTR_EL0 register
Hi Sebastian,
On Mon, Jun 03, 2024 at 03:05:04PM +0200, Sebastian Ott wrote:
[...]
arch/arm64/kvm/sys_regs.c static int set_wi_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd, · line 1908
Quoted 9 lines
arch/arm64/kvm/sys_regs.c +9
-0+static int validate_cache_topology (struct kvm_vcpu *vcpu,u64 ctr_el0) +{ +const struct sys_reg_desc *clidr_el1; +unsigned int i; +int ret; + + clidr_el1 =get_sys_reg_desc (SYS_CLIDR_EL1 ); +if (!clidr_el1) +return -ENOENT ;
This doesn't actually matter if we agree on dropping the cross-checking, but if this lookup fails it is 100% a KVM bug. Returning ENOENT isn't exactly right here, since it gives userspace the impression that the sysreg index it tried to access does not exist.
So in the future it'd be good to return EINVAL in places where the kernel did something stupid, probably with a warning for good measure.
Quoted 14 lines
arch/arm64/kvm/sys_regs.c +14
-0+static int set_ctr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, +u64 val) +{ +u64 ctr, writable_mask = rd->val; +int ret =0 ; + +mutex_lock (&vcpu->kvm->arch.config_lock); + ctr = vcpu->kvm->arch.ctr_el0; +if (val == ctr) + goto out_unlock; + + ret = -EBUSY ; +if (kvm_vm_has_ran_once (vcpu->kvm)) + goto out_unlock;
arch/arm64/kvm/sys_regs.c static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p, · line 1976
Quoted 10 lines
arch/arm64/kvm/sys_regs.c +10
-0+ + ret = -EINVAL ; +if ((ctr & ~writable_mask) != (val & ~writable_mask)) + goto out_unlock; + +if (((ctr &CTR_EL0_DIC_MASK ) < (val &CTR_EL0_DIC_MASK )) || + ((ctr &CTR_EL0_IDC_MASK ) < (val &CTR_EL0_IDC_MASK )) || + ((ctr & CTR_EL0_DminLine_MASK) < (val & CTR_EL0_DminLine_MASK)) || + ((ctr & CTR_EL0_IminLine_MASK) < (val & CTR_EL0_IminLine_MASK))) { + goto out_unlock;
I'd prefer if we addressed the issue w/ arm64_check_features() by making CTR_EL0 behave like the other registers in the ID space instead of open-coding these sorts of checks.
I believe that can be accomplished by using kvm_read_sanitised_id_reg() as the ::reset() function in the descriptor and initializing kvm->arch.ctr_el0 in kvm_reset_id_regs().
arch/arm64/kvm/sys_regs.c static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p, · line 1980
Quoted 4 lines
arch/arm64/kvm/sys_regs.c +4
-0+ } + ret =validate_cache_topology (vcpu, val); +if (ret) + goto out_unlock;
My concerns about adding these sort of cross-checks remains. The sysreg code will become exponentially more messy with each cross-register check we add, given the complete lack of ordering on the UAPI.
So long as KVM has independently tested the validity of the cache hierarchy and CTR_EL0 against the capabilities of hardware, we know that userspace cannot advertise more than what's supported in hardware.
If CLIDR_EL1 doesn't line up with the value of CTR_EL0 exposed to the guest then it is a userspace bug. There simply is no amount of foolproofing that can be done in KVM to protect against a buggy VMM.
Signature · 2 lines
Thanks, Oliver
Re: [PATCH v4 3/6] KVM: arm64: add emulation for CTR_EL0 register
Quoted 53 lines · Oliver Upton
Hi Sebastian,
On Mon, Jun 03, 2024 at 03:05:04PM +0200, Sebastian Ott wrote:
[...]
arch/arm64/kvm/sys_regs.c static int set_wi_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd, · line 1908
Quoted 9 lines
arch/arm64/kvm/sys_regs.c +9
-0+static int validate_cache_topology (struct kvm_vcpu *vcpu,u64 ctr_el0) +{ +const struct sys_reg_desc *clidr_el1; +unsigned int i; +int ret; + + clidr_el1 =get_sys_reg_desc (SYS_CLIDR_EL1 ); +if (!clidr_el1) +return -ENOENT ;This doesn't actually matter if we agree on dropping the cross-checking, but if this lookup fails it is 100% a KVM bug. Returning ENOENT isn't exactly right here, since it gives userspace the impression that the sysreg index it tried to access does not exist.
So in the future it'd be good to return EINVAL in places where the kernel did something stupid, probably with a warning for good measure.
Quoted 14 lines
arch/arm64/kvm/sys_regs.c +14
-0+static int set_ctr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, +u64 val) +{ +u64 ctr, writable_mask = rd->val; +int ret =0 ; + +mutex_lock (&vcpu->kvm->arch.config_lock); + ctr = vcpu->kvm->arch.ctr_el0; +if (val == ctr) + goto out_unlock; + + ret = -EBUSY ; +if (kvm_vm_has_ran_once (vcpu->kvm)) + goto out_unlock;arch/arm64/kvm/sys_regs.c static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p, · line 1976
Quoted 10 lines
arch/arm64/kvm/sys_regs.c +10
-0+ + ret = -EINVAL ; +if ((ctr & ~writable_mask) != (val & ~writable_mask)) + goto out_unlock; + +if (((ctr &CTR_EL0_DIC_MASK ) < (val &CTR_EL0_DIC_MASK )) || + ((ctr &CTR_EL0_IDC_MASK ) < (val &CTR_EL0_IDC_MASK )) || + ((ctr & CTR_EL0_DminLine_MASK) < (val & CTR_EL0_DminLine_MASK)) || + ((ctr & CTR_EL0_IminLine_MASK) < (val & CTR_EL0_IminLine_MASK))) { + goto out_unlock;I'd prefer if we addressed the issue w/
arm64_check_features()by makingCTR_EL0behave like the other registers in the ID space instead of open-coding these sorts of checks.
Quoted 3 lines
I believe that can be accomplished by using
kvm_read_sanitised_id_reg()as the ::reset() function in the descriptor and initializingkvm->arch.ctr_el0inkvm_reset_id_regs().
Durr, I got rid of kvm_reset_id_regs() in commit 44cbe80b7616 ("KVM: arm64:
Reset VM feature ID regs from kvm_reset_sys_regs()"), I should engage brain before responding.
Adding a check for encoding == CTR_EL0 to is_vm_ftr_id_reg() seems to be the best way out.
Signature · 2 lines
Thanks, Oliver
Re: [PATCH v4 3/6] KVM: arm64: add emulation for CTR_EL0 register
Hi Oliver,
Quoted 17 lines · Oliver Upton
Quoted 16 lines · Oliver Upton
arch/arm64/kvm/sys_regs.c static int set_wi_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd, · line 1908
Quoted 9 lines · Sebastian Ott
arch/arm64/kvm/sys_regs.c +9
-0+static int validate_cache_topology (struct kvm_vcpu *vcpu,u64 ctr_el0) +{ +const struct sys_reg_desc *clidr_el1; +unsigned int i; +int ret; + + clidr_el1 =get_sys_reg_desc (SYS_CLIDR_EL1 ); +if (!clidr_el1) +return -ENOENT ;This doesn't actually matter if we agree on dropping the cross-checking, but if this lookup fails it is 100% a KVM bug. Returning ENOENT isn't exactly right here, since it gives userspace the impression that the sysreg index it tried to access does not exist.
Quoted 2 lines
Quoted 2 lines
So in the future it'd be good to return EINVAL in places where the kernel did something stupid, probably with a warning for good measure.
OK.
Quoted 33 lines
Quoted 29 lines
Quoted 14 lines
arch/arm64/kvm/sys_regs.c +14
-0+static int set_ctr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, +u64 val) +{ +u64 ctr, writable_mask = rd->val; +int ret =0 ; + +mutex_lock (&vcpu->kvm->arch.config_lock); + ctr = vcpu->kvm->arch.ctr_el0; +if (val == ctr) + goto out_unlock; + + ret = -EBUSY ; +if (kvm_vm_has_ran_once (vcpu->kvm)) + goto out_unlock;arch/arm64/kvm/sys_regs.c static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p, · line 1976
Quoted 10 lines
arch/arm64/kvm/sys_regs.c +10
-0+ + ret = -EINVAL ; +if ((ctr & ~writable_mask) != (val & ~writable_mask)) + goto out_unlock; + +if (((ctr &CTR_EL0_DIC_MASK ) < (val &CTR_EL0_DIC_MASK )) || + ((ctr &CTR_EL0_IDC_MASK ) < (val &CTR_EL0_IDC_MASK )) || + ((ctr & CTR_EL0_DminLine_MASK) < (val & CTR_EL0_DminLine_MASK)) || + ((ctr & CTR_EL0_IminLine_MASK) < (val & CTR_EL0_IminLine_MASK))) { + goto out_unlock;I'd prefer if we addressed the issue w/
arm64_check_features()by makingCTR_EL0behave like the other registers in the ID space instead of open-coding these sorts of checks.Quoted 3 lines
I believe that can be accomplished by using
kvm_read_sanitised_id_reg()as the ::reset() function in the descriptor and initializingkvm->arch.ctr_el0inkvm_reset_id_regs().
Quoted 6 lines
Durr, I got rid of
kvm_reset_id_regs()in commit44cbe80b7616("KVM: arm64:
Reset VM feature ID regs fromkvm_reset_sys_regs()"), I should engage brain before responding.Adding a check for encoding ==
CTR_EL0tois_vm_ftr_id_reg()seems to be the best way out.
Hm, but in that case we'd use reset_vm_ftr_id_reg() meaning we would have to make IDREG() work for this reg. Either by adding special handling to that macro or by increasing kvm->arch.id_regs[] a lot - both options don't sound very appealing.
I'll think of smth to make arm64_check_features() work for this.
Thanks,
Sebastian
Oliver Upton
Reviewed-by Shaoqin HuangRe: [PATCH v4 3/6] KVM: arm64: add emulation for CTR_EL0 register
On Fri, Jun 14, 2024 at 05:31:37PM +0200, Sebastian Ott wrote:
[...]
Quoted 4 lines
Hm, but in that case we'd use
reset_vm_ftr_id_reg()meaning we would have to makeIDREG()work for this reg. Either by adding special handling to that macro or by increasing kvm->arch.id_regs[] a lot - both options don't sound very appealing.
Hiding some of the ugly details behind IDREG() isn't the worst thing, IMO. The feature ID registers are not laid out contiguously in the architecture, so it'd make sense that the corresponding KVM code not be brittle to this.
The other benefit is we initialize kvm->arch.ctr_el0 exactly once, just like the other ID registers. I believe there's a quirk with this patch where an initialization that happens after a KVM_SET_ONE_REG on CTR_EL0 will clobber the userspace value.
So, here's where I'm at locally, I'll work it a bit more and try to densely pack CTR_EL0 into the id_regs array. I also have some (untested) changes to get CTR_EL0 to show up in the debugfs interface we now have.
Mind if I post what I have afterwards?
commit 6bf81bd50dc16309a627863948d49cfeeb00897e
Author: Sebastian Ott <[email protected]> Date: Mon Jun 3 15:05:03 2024 +0200
KVM: arm64: Treat CTR_EL0 as a VM feature ID register
arch/arm64/include/asm/kvm_host.h +11 -1
@@ -327,10 +327,20 @@ struct kvm_arch {*/ #define IDREG_IDX (id) (((sys_reg_CRm(id) - 1) << 3) | sys_reg_Op2(id))#define IDX_IDREG (idx) sys_reg(3, 0, 0, ((idx) >> 3) + 1, (idx) & Op2_mask) -#define IDREG (kvm, id) ((kvm)->arch.id_regs[IDREG_IDX(id)]) +#define IDREG (kvm, id) \ +(*({ \ + u64 *__reg; \ + if ((id) == SYS_CTR_EL0) \ + __reg = &(kvm)->arch.ctr_el0; \ + else \ + __reg = &((kvm)->arch.id_regs[IDREG_IDX(id)]); \ + __reg; \ +}))#define KVM_ARM_ID_REG_NUM (IDREG_IDX(sys_reg(3, 0, 0, 7, 7)) + 1)u64 id_regs[KVM_ARM_ID_REG_NUM ]; +u64 ctr_el0; +/* Masks for VNCR-baked sysregs */ struct kvm_sysreg_masks *sysreg_masks;
arch/arm64/kvm/sys_regs.c +8 -9
@@ -1583,6 +1583,9 @@ static bool is_feature_id_reg(u32 encoding)*/ static inline bool is_vm_ftr_id_reg (u32 id) { +if (id ==SYS_CTR_EL0 ) +return true; +return (sys_reg_Op0 (id) ==3 &&sys_reg_Op1 (id) ==0 &&sys_reg_CRn (id) ==0 &&sys_reg_CRm (id) >=1 &&sys_reg_CRm (id) <8 );
@@ -1886,7 +1889,7 @@ static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,if (p->is_write)return write_to_read_only (vcpu, p, r); - p->regval =read_sanitised_ftr_reg (SYS_CTR_EL0 ); + p->regval =IDREG (vcpu->kvm,SYS_CTR_EL0 );return true; }
@@ -2475,7 +2478,10 @@ static const struct sys_reg_desc sys_reg_descs[] = { { SYS_DESC(SYS_CCSIDR2_EL1), undef_access }, { SYS_DESC(SYS_SMIDR_EL1), undef_access }, { SYS_DESC(SYS_CSSELR_EL1), access_csselr, reset_unknown, CSSELR_EL1 }, - { SYS_DESC(SYS_CTR_EL0), access_ctr }, +ID_WRITABLE (CTR_EL0 ,CTR_EL0_DIC_MASK | +CTR_EL0_IDC_MASK | + CTR_EL0_DminLine_MASK | + CTR_EL0_IminLine_MASK), { SYS_DESC(SYS_SVCR), undef_access }, { PMU_SYS_REG(PMCR_EL0), .access = access_pmcr, .reset = reset_pmcr,
@@ -3714,18 +3720,11 @@ FUNCTION_INVARIANT(midr_el1)FUNCTION_INVARIANT (revidr_el1)FUNCTION_INVARIANT (aidr_el1 ) -static u64 get_ctr_el0(struct kvm_vcpu *v, const struct sys_reg_desc *r) -{ - ((struct sys_reg_desc *)r)->val = read_sanitised_ftr_reg(SYS_CTR_EL0); - return ((struct sys_reg_desc *)r)->val; -} -/* ->val is filled in by kvm_sys_reg_table_init() */ static struct sys_reg_desc invariant_sys_regs[]__ro_after_init = { {SYS_DESC (SYS_MIDR_EL1 ),NULL , get_midr_el1 }, {SYS_DESC (SYS_REVIDR_EL1 ),NULL , get_revidr_el1 }, {SYS_DESC (SYS_AIDR_EL1 ),NULL , get_aidr_el1 }, - { SYS_DESC(SYS_CTR_EL0), NULL, get_ctr_el0 }, };static int get_invariant_sys_reg (u64 id,u64 __user *uaddr)
Signature · 2 lines
Thanks, Oliver
Re: [PATCH v4 3/6] KVM: arm64: add emulation for CTR_EL0 register
Quoted 19 lines · Oliver Upton
On Fri, Jun 14, 2024 at 05:31:37PM +0200, Sebastian Ott wrote:
[...]
Quoted 4 lines
Hm, but in that case we'd use
reset_vm_ftr_id_reg()meaning we would have to makeIDREG()work for this reg. Either by adding special handling to that macro or by increasing kvm->arch.id_regs[] a lot - both options don't sound very appealing.Hiding some of the ugly details behind
IDREG()isn't the worst thing, IMO. The feature ID registers are not laid out contiguously in the architecture, so it'd make sense that the corresponding KVM code not be brittle to this.The other benefit is we initialize
kvm->arch.ctr_el0exactly once, just like the other ID registers. I believe there's a quirk with this patch where an initialization that happens after aKVM_SET_ONE_REGonCTR_EL0will clobber the userspace value.
Quoted 5 lines
So, here's where I'm at locally, I'll work it a bit more and try to densely pack
CTR_EL0into theid_regsarray. I also have some (untested) changes to getCTR_EL0to show up in the debugfs interface we now have.Mind if I post what I have afterwards?
Sure go ahead.
Thanks,
Sebastian
Quoted 97 lines
commit
6bf81bd50dc16309a627863948d49cfeeb00897eAuthor: Sebastian Ott <[email protected]> Date: Mon Jun 3 15:05:03 2024 +0200KVM: arm64: Treat
CTR_EL0as a VM feature ID registerSigned-off-by Sebastian Ott <[email protected]>Reviewed-by Shaoqin Huang <[email protected]>Signed-off-by Oliver Upton <[email protected]>arch/arm64/include/asm/kvm_host.h +11
-1@@ -327,10 +327,20 @@ struct kvm_arch {*/ #define IDREG_IDX (id) (((sys_reg_CRm(id) - 1) << 3) | sys_reg_Op2(id))#define IDX_IDREG (idx) sys_reg(3, 0, 0, ((idx) >> 3) + 1, (idx) & Op2_mask) -#define IDREG (kvm, id) ((kvm)->arch.id_regs[IDREG_IDX(id)]) +#define IDREG (kvm, id) \ +(*({ \ + u64 *__reg; \ + if ((id) == SYS_CTR_EL0) \ + __reg = &(kvm)->arch.ctr_el0; \ + else \ + __reg = &((kvm)->arch.id_regs[IDREG_IDX(id)]); \ + __reg; \ +}))#define KVM_ARM_ID_REG_NUM (IDREG_IDX(sys_reg(3, 0, 0, 7, 7)) + 1)u64 id_regs[KVM_ARM_ID_REG_NUM ]; +u64 ctr_el0; +/* Masks for VNCR-baked sysregs */ struct kvm_sysreg_masks *sysreg_masks;arch/arm64/kvm/sys_regs.c +8
-9@@ -1583,6 +1583,9 @@ static bool is_feature_id_reg(u32 encoding)*/ static inline bool is_vm_ftr_id_reg (u32 id) { +if (id ==SYS_CTR_EL0 ) +return true; +return (sys_reg_Op0 (id) ==3 &&sys_reg_Op1 (id) ==0 &&sys_reg_CRn (id) ==0 &&sys_reg_CRm (id) >=1 &&sys_reg_CRm (id) <8 );@@ -1886,7 +1889,7 @@ static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,if (p->is_write)return write_to_read_only (vcpu, p, r); - p->regval =read_sanitised_ftr_reg (SYS_CTR_EL0 ); + p->regval =IDREG (vcpu->kvm,SYS_CTR_EL0 );return true; }@@ -2475,7 +2478,10 @@ static const struct sys_reg_desc sys_reg_descs[] = { { SYS_DESC(SYS_CCSIDR2_EL1), undef_access }, { SYS_DESC(SYS_SMIDR_EL1), undef_access }, { SYS_DESC(SYS_CSSELR_EL1), access_csselr, reset_unknown, CSSELR_EL1 }, - { SYS_DESC(SYS_CTR_EL0), access_ctr }, +ID_WRITABLE (CTR_EL0 ,CTR_EL0_DIC_MASK | +CTR_EL0_IDC_MASK | + CTR_EL0_DminLine_MASK | + CTR_EL0_IminLine_MASK), { SYS_DESC(SYS_SVCR), undef_access }, { PMU_SYS_REG(PMCR_EL0), .access = access_pmcr, .reset = reset_pmcr,@@ -3714,18 +3720,11 @@ FUNCTION_INVARIANT(midr_el1)FUNCTION_INVARIANT (revidr_el1)FUNCTION_INVARIANT (aidr_el1 ) -static u64 get_ctr_el0(struct kvm_vcpu *v, const struct sys_reg_desc *r) -{ - ((struct sys_reg_desc *)r)->val = read_sanitised_ftr_reg(SYS_CTR_EL0); - return ((struct sys_reg_desc *)r)->val; -} -/* ->val is filled in by kvm_sys_reg_table_init() */ static struct sys_reg_desc invariant_sys_regs[]__ro_after_init = { {SYS_DESC (SYS_MIDR_EL1 ),NULL , get_midr_el1 }, {SYS_DESC (SYS_REVIDR_EL1 ),NULL , get_revidr_el1 }, {SYS_DESC (SYS_AIDR_EL1 ),NULL , get_aidr_el1 }, - { SYS_DESC(SYS_CTR_EL0), NULL, get_ctr_el0 }, };static int get_invariant_sys_reg (u64 id,u64 __user *uaddr)Signature · 3 lines
-- Thanks, Oliver
PATCH v4 4/6 KVM: arm64: show writable masks for feature registers
In reply to Sebastian OttInstead of using ~0UL provide the actual writable mask for non-id feature registers in the output of the KVM_ARM_GET_REG_WRITABLE_MASKS ioctl.
This changes the mask for the CTR_EL0 and CLIDR_EL1 registers.
--- arch/arm64/kvm/sys_regs.c | 19 +++++-------------- 1 file changed, 5 insertions(+), 14 deletions(-)
arch/arm64/kvm/sys_regs.c +5 -14
@@ -2566,7 +2566,7 @@ static const struct sys_reg_desc sys_reg_descs[] = { { SYS_DESC(SYS_CCSIDR_EL1), access_ccsidr }, { SYS_DESC(SYS_CLIDR_EL1), access_clidr, reset_clidr, CLIDR_EL1, - .set_user = set_clidr }, + .set_user = set_clidr, .val = ~CLIDR_EL1_RES0 }, { SYS_DESC(SYS_CCSIDR2_EL1), undef_access }, { SYS_DESC(SYS_SMIDR_EL1), undef_access }, { SYS_DESC(SYS_CSSELR_EL1), access_csselr, reset_unknown, CSSELR_EL1 },
@@ -4125,20 +4125,11 @@ int kvm_vm_ioctl_get_reg_writable_masks(struct kvm *kvm, struct reg_mask_range *if (!is_feature_id_reg (encoding) || !reg->set_user)continue ; -/* -* For ID registers, we return the writable mask. Other feature -* registers return a full 64bit mask. That's not necessary -* compliant with a given revision of the architecture, but the -* RES0/RES1 definitions allow us to do that. -*/ -if (is_vm_ftr_id_reg (encoding)) { -if (!reg->val || - (is_aa32_id_reg (encoding) && !kvm_supports_32bit_el0 ())) -continue ; - val = reg->val; - }else { - val = ~0UL ; +if (!reg->val || + (is_aa32_id_reg (encoding) && !kvm_supports_32bit_el0 ())) { +continue ; } + val = reg->val;if (put_user (val, (masks +KVM_ARM_FEATURE_ID_RANGE_INDEX (encoding))))return -EFAULT ;
Signature · 1 line
2.42.0
PATCH v4 5/6 KVM: arm64: rename functions for invariant sys regs
In reply to Sebastian OttInvariant system id registers are populated with host values at initialization time using their .reset function cb.
These are currently called get_* which is usually used by the functions implementing the .get_user callback.
Change their function names to reset_* to reflect what they are used for.
--- arch/arm64/kvm/sys_regs.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/arm64/kvm/sys_regs.c +5 -5
@@ -3799,8 +3799,8 @@ id_to_sys_reg_desc(struct kvm_vcpu *vcpu, u64 id,*/ #define FUNCTION_INVARIANT (reg) \ - static u64 get_##reg(struct kvm_vcpu *v, \ - const struct sys_reg_desc *r) \ + static u64 reset_##reg(struct kvm_vcpu *v, \ + const struct sys_reg_desc *r) \ { \ ((struct sys_reg_desc *)r)->val = read_sysreg(reg); \ return ((struct sys_reg_desc *)r)->val; \
@@ -3812,9 +3812,9 @@ FUNCTION_INVARIANT(aidr_el1)/* ->val is filled in by kvm_sys_reg_table_init() */ static struct sys_reg_desc invariant_sys_regs[]__ro_after_init = { - {SYS_DESC (SYS_MIDR_EL1 ),NULL , get_midr_el1 }, - {SYS_DESC (SYS_REVIDR_EL1 ),NULL , get_revidr_el1 }, - {SYS_DESC (SYS_AIDR_EL1 ),NULL , get_aidr_el1 }, + {SYS_DESC (SYS_MIDR_EL1 ),NULL , reset_midr_el1 }, + {SYS_DESC (SYS_REVIDR_EL1 ),NULL , reset_revidr_el1 }, + {SYS_DESC (SYS_AIDR_EL1 ),NULL , reset_aidr_el1 }, };static int get_invariant_sys_reg (u64 id,u64 __user *uaddr)
Signature · 1 line
2.42.0
PATCH v4 6/6 KVM: selftests: arm64: Test writes to CTR_EL0
In reply to Sebastian OttTest that CTR_EL0 is modifiable from userspace, that changes are visible to guests, and that they are preserved across a vCPU reset.
--- .../testing/selftests/kvm/aarch64/set_id_regs.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
tools/testing/selftests/kvm/aarch64/set_id_regs.c +16 -0
@@ -219,6 +219,7 @@ static void guest_code(void)GUEST_REG_SYNC (SYS_ID_AA64MMFR1_EL1 );GUEST_REG_SYNC (SYS_ID_AA64MMFR2_EL1 );GUEST_REG_SYNC (SYS_ID_AA64ZFR0_EL1 ); +GUEST_REG_SYNC (SYS_CTR_EL0 );GUEST_DONE (); }
@@ -490,11 +491,25 @@ static void test_clidr(struct kvm_vcpu *vcpu) test_reg_vals[encoding_to_range_idx (SYS_CLIDR_EL1 )] = clidr; } +static void test_ctr (struct kvm_vcpu *vcpu) +{ +u64 ctr; + +vcpu_get_reg (vcpu,KVM_ARM64_SYS_REG (SYS_CTR_EL0 ), &ctr); + ctr &= ~CTR_EL0_DIC_MASK ; +if (ctr & CTR_EL0_IminLine_MASK) + ctr--; + +vcpu_set_reg (vcpu,KVM_ARM64_SYS_REG (SYS_CTR_EL0 ), ctr); + test_reg_vals[encoding_to_range_idx (SYS_CTR_EL0 )] = ctr; +} +static void test_vcpu_ftr_id_regs (struct kvm_vcpu *vcpu) {u64 val;test_clidr (vcpu); +test_ctr (vcpu);vcpu_get_reg (vcpu,KVM_ARM64_SYS_REG (SYS_MPIDR_EL1 ), &val); val++;
@@ -525,6 +540,7 @@ static void test_reset_preserves_id_regs(struct kvm_vcpu *vcpu)test_assert_id_reg_unchanged (vcpu, test_regs[i].reg);test_assert_id_reg_unchanged (vcpu,SYS_CLIDR_EL1 ); +test_assert_id_reg_unchanged (vcpu,SYS_CTR_EL0 );ksft_test_result_pass ("%s\n" , __func__); }
Signature · 1 line
2.42.0
Hi Marc, Oliver
anything else I should change here?
Sebastian