KVM: arm64: Enable 'writable' ID registers
Subsystems (5)
v10 cover KVM: arm64: Enable 'writable' ID registers
Hi folks,
This is hopefully the last take on the 'writable' ID registers series. The patches have been sitting on the mailing list for years in some form and it seems like we're approaching critical mass in terms of interest in the feature.
I've taken Jing's series and applied some cleanups to get things in order for 6.7.
v9 -> v10:
- Picked up the latest KVM_ARM_GET_REG_WRITABLE_MASKS patch
- Cleaned up the initializer macros for sys_reg_descs
- Aggressively masked-out features that make no sense to modify
- Added ZFR0 and the ISAR registers to the mix
- Added documentation on how userspace is expected to use all the UAPI
v9: https://lore.kernel.org/kvmarm/[email protected]/
Jing Zhang (7):
KVM: arm64: Allow userspace to get the writable masks for feature ID
registers
KVM: arm64: Document KVM_ARM_GET_REG_WRITABLE_MASKS
KVM: arm64: Use guest ID register values for the sake of emulation
KVM: arm64: Allow userspace to change ID_AA64MMFR{0-2}_EL1
KVM: arm64: Allow userspace to change ID_AA64PFR0_EL1
KVM: arm64: selftests: Import automatic generation of sysreg defs
KVM: arm64: selftests: Test for setting ID register from usersapce
Oliver Upton (5):
KVM: arm64: Reject attempts to set invalid debug arch version
KVM: arm64: Bump up the default KVM sanitised debug version to v8p8
KVM: arm64: Allow userspace to change ID_AA64ISAR{0-2}_EL1
KVM: arm64: Allow userspace to change ID_AA64ZFR0_EL1
KVM: arm64: Document vCPU feature selection UAPIs
Documentation/virt/kvm/api.rst | 43 + Documentation/virt/kvm/arm/index.rst | 1 + Documentation/virt/kvm/arm/vcpu-features.rst | 47 + arch/arm64/include/asm/kvm_host.h | 2 + arch/arm64/include/uapi/asm/kvm.h | 32 + arch/arm64/kvm/arm.c | 10 + arch/arm64/kvm/sys_regs.c | 185 +- include/uapi/linux/kvm.h | 2 + tools/arch/arm64/include/.gitignore | 1 + tools/arch/arm64/include/asm/gpr-num.h | 26 + tools/arch/arm64/include/asm/sysreg.h | 839 ++---- tools/arch/arm64/tools/gen-sysreg.awk | 336 +++ tools/arch/arm64/tools/sysreg | 2497 +++++++++++++++++ tools/testing/selftests/kvm/Makefile | 15 +- .../selftests/kvm/aarch64/aarch32_id_regs.c | 4 +- .../selftests/kvm/aarch64/debug-exceptions.c | 12 +- .../selftests/kvm/aarch64/page_fault_test.c | 6 +- .../selftests/kvm/aarch64/set_id_regs.c | 478 ++++ .../selftests/kvm/lib/aarch64/processor.c | 6 +- 19 files changed, 3853 insertions(+), 689 deletions(-) create mode 100644 Documentation/virt/kvm/arm/vcpu-features.rst create mode 100644 tools/arch/arm64/include/.gitignore create mode 100644 tools/arch/arm64/include/asm/gpr-num.h create mode 100755 tools/arch/arm64/tools/gen-sysreg.awk create mode 100644 tools/arch/arm64/tools/sysreg create mode 100644 tools/testing/selftests/kvm/aarch64/set_id_regs.c
base-commit: ce9ecca0238b140b88f43859b211c9fdfd8e5b70
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 1/12 KVM: arm64: Allow userspace to get the writable masks for feature ID registers
From: Jing Zhang <[email protected]>
While the Feature ID range is well defined and pretty large, it isn't inconceivable that the architecture will eventually grow some other ranges that will need to similarly be described to userspace.
Add a VM ioctl to allow userspace to get writable masks for feature ID registers in below system register space:
op0 = 3, op1 = {0, 1, 3}, CRn = 0, CRm = {0 - 7}, op2 = {0 - 7} This is used to support mix-and-match userspace and kernels for writable ID registers, where userspace may want to know upfront whether it can actually tweak the contents of an idreg or not.
Add a new capability (KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES) that returns a bitmap of the valid ranges, which can subsequently be retrieved, one at a time by setting the index of the set bit as the range identifier.
--- arch/arm64/include/asm/kvm_host.h | 2 + arch/arm64/include/uapi/asm/kvm.h | 32 +++++++++++++++ arch/arm64/kvm/arm.c | 10 +++++ arch/arm64/kvm/sys_regs.c | 66 +++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 2 + 5 files changed, 112 insertions(+)
arch/arm64/include/asm/kvm_host.h +2 -0
@@ -1078,6 +1078,8 @@ int kvm_vm_ioctl_mte_copy_tags(struct kvm *kvm, struct kvm_arm_copy_mte_tags *copy_tags);int kvm_vm_ioctl_set_counter_offset (struct kvm *kvm,struct kvm_arm_counter_offset *offset); +int kvm_vm_ioctl_get_reg_writable_masks (struct kvm *kvm, +struct reg_mask_range *range);/* Guest/host FPSIMD coordination helpers */ int kvm_arch_vcpu_run_map_fp (struct kvm_vcpu *vcpu);
arch/arm64/include/uapi/asm/kvm.h +32 -0
@@ -505,6 +505,38 @@ struct kvm_smccc_filter {#define KVM_HYPERCALL_EXIT_SMC (1U << 0)#define KVM_HYPERCALL_EXIT_16BIT (1U << 1) +/* +* Get feature ID registers userspace writable mask. +* +* From DDI0487J.a, D19.2.66 ("ID_AA64MMFR2_EL1, AArch64 Memory Model +* Feature Register 2"): +* +* "The Feature ID space is defined as the System register space in +* AArch64 with op0==3, op1=={0, 1, 3}, CRn==0, CRm=={0-7}, +* op2=={0-7}." +* +* This covers all currently known R/O registers that indicate +* anything useful feature wise, including the ID registers. +* +* If we ever need to introduce a new range, it will be described as +* such in the range field. +*/ +#define ARM64_FEATURE_ID_SPACE_IDX (op0, op1, crn, crm, op2) \ + ({ \ + __u64 __op1 = (op1) & 3; \ + __op1 -= (__op1 == 3); \ + (__op1 << 6 | ((crm) & 7) << 3 | (op2)); \ + }) + +#define ARM64_FEATURE_ID_SPACE_SIZE (3 * 8 * 8) +#define ARM64_FEATURE_ID_RANGE_IDREGS BIT(0) + +struct reg_mask_range { +__u64 addr;/* Pointer to mask array */ +__u32 range;/* Requested range */ +__u32 reserved[13 ]; +}; +#endif #endif /* __ARM_KVM_H__ */
arch/arm64/kvm/arm.c +10 -0
@@ -317,6 +317,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_ARM_SUPPORTED_BLOCK_SIZES : r =kvm_supported_block_sizes ();break ; +case KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES : + r =ARM64_FEATURE_ID_RANGE_IDREGS ; +break ;default : r =0 ; }
@@ -1629,6 +1632,13 @@ int kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg)return kvm_vm_set_attr (kvm, &attr); } +case KVM_ARM_GET_REG_WRITABLE_MASKS : { +struct reg_mask_range range; + +if (copy_from_user (&range, argp,sizeof (range))) +return -EFAULT ; +return kvm_vm_ioctl_get_reg_writable_masks (kvm, &range); + }default :return -EINVAL ; }
arch/arm64/kvm/sys_regs.c +66 -0
78 lines not on this page · raw message
include/uapi/linux/kvm.h +2 -0
@@ -1192,6 +1192,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_COUNTER_OFFSET 227#define KVM_CAP_ARM_EAGER_SPLIT_CHUNK_SIZE 228#define KVM_CAP_ARM_SUPPORTED_BLOCK_SIZES 229 +#define KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES 230#ifdef KVM_CAP_IRQ_ROUTING
@@ -1562,6 +1563,7 @@ struct kvm_s390_ucas_mapping {#define KVM_ARM_MTE_COPY_TAGS _IOR(KVMIO, 0xb4, struct kvm_arm_copy_mte_tags)/* Available with KVM_CAP_COUNTER_OFFSET */ #define KVM_ARM_SET_COUNTER_OFFSET _IOW(KVMIO, 0xb5, struct kvm_arm_counter_offset) +#define KVM_ARM_GET_REG_WRITABLE_MASKS _IOR(KVMIO, 0xb6, struct reg_mask_range)/* ioctl for vm fd */ #define KVM_CREATE_DEVICE _IOWR(KVMIO, 0xe0, struct kvm_create_device)
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 2/12 KVM: arm64: Document KVM_ARM_GET_REG_WRITABLE_MASKS
In reply to Oliver UptonFrom: Jing Zhang <[email protected]>
Add some basic documentation on how to get feature ID register writable masks from userspace.
--- Documentation/virt/kvm/api.rst | 43 ++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
Documentation/virt/kvm/api.rst +43 -0
@@ -6070,6 +6070,49 @@ writes to the CNTVCT_EL0 and CNTPCT_EL0 registers using the SET_ONE_REG interface. No error will be returned, but the resulting offset will not be applied. +4.139 KVM_ARM_GET_REG_WRITABLE_MASKS +------------------------------------------- + +:Capability: KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES +:Architectures: arm64 +:Type: vm ioctl +:Parameters: struct reg_mask_range (in/out) +:Returns: 0 on success, < 0 on error + + +:: + + #define ARM64_FEATURE_ID_SPACE_SIZE (3 * 8 * 8) + #define ARM64_FEATURE_ID_RANGE_IDREGS BIT(0) + + struct reg_mask_range { + __u64 addr; /* Pointer to mask array */ + __u32 range; /* Requested range */ + __u32 reserved[13]; + }; + +This ioctl copies the writable masks for Feature ID registers to userspace. +The Feature ID space is defined as the AArch64 System register space with +op0==3, op1=={0, 1, 3}, CRn==0, CRm=={0-7}, op2=={0-7}. + +The mask array pointed to by ``addr`` is indexed by the macro +``ARM64_FEATURE_ID_SPACE_IDX(op0, op1, crn, crm, op2)``, allowing userspace +to know what fields can be changed for the system register described by +``op0, op1, crn, crm, op2``. KVM rejects ID register values that describe a +superset of the features supported by the system. + +The ``range`` field describes the requested range of registers. The valid +ranges can be retrieved by checking the return value of +KVM_CAP_CHECK_EXTENSION_VM for the KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES +capability, which will return a bitmask of the supported ranges. Each bit +set in the return value represents a possible value for the ``range`` +field. At the time of writing, only bit 0 is returned set by the +capability, meaning that only the value ``ARM64_FEATURE_ID_RANGE_IDREGS`` +is valid for ``range``. + +The ``reserved[13]`` array is reserved for future use and should be 0, or +KVM may return an error. + 5. The kvm_run structure ========================
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 3/12 KVM: arm64: Use guest ID register values for the sake of emulation
In reply to Oliver UptonFrom: Jing Zhang <[email protected]>
Since KVM now supports per-VM ID registers, use per-VM ID register values for the sake of emulation for DBGDIDR and LORegion.
--- arch/arm64/kvm/sys_regs.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/arm64/kvm/sys_regs.c +3 -3
@@ -379,7 +379,7 @@ static bool trap_loregion(struct kvm_vcpu *vcpu,struct sys_reg_params *p, const struct sys_reg_desc *r) { - u64 val = read_sanitised_ftr_reg(SYS_ID_AA64MMFR1_EL1); + u64 val = IDREG(vcpu->kvm, SYS_ID_AA64MMFR1_EL1);u32 sr =reg_to_encoding (r);if (!(val & (0xfUL <<ID_AA64MMFR1_EL1_LO_SHIFT ))) {
@@ -2445,8 +2445,8 @@ static bool trap_dbgdidr(struct kvm_vcpu *vcpu,if (p->is_write) {return ignore_write (vcpu, p); }else { -u64 dfr =read_sanitised_ftr_reg (SYS_ID_AA64DFR0_EL1 ); -u64 pfr =read_sanitised_ftr_reg (SYS_ID_AA64PFR0_EL1 ); +u64 dfr =IDREG (vcpu->kvm,SYS_ID_AA64DFR0_EL1 ); +u64 pfr =IDREG (vcpu->kvm,SYS_ID_AA64PFR0_EL1 );u32 el3 = !!cpuid_feature_extract_unsigned_field (pfr,ID_AA64PFR0_EL1_EL3_SHIFT ); p->regval = ((((dfr >> ID_AA64DFR0_EL1_WRPs_SHIFT) & 0xf) << 28) |
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 4/12 KVM: arm64: Reject attempts to set invalid debug arch version
In reply to Oliver UptonThe debug architecture is mandatory in ARMv8, so KVM should not allow userspace to configure a vCPU with less than that. Of course, this isn't handled elegantly by the generic ID register plumbing, as the respective ID register fields have a nonzero starting value.
Add an explicit check for debug versions less than v8 of the architecture.
--- arch/arm64/kvm/sys_regs.c | 32 +++++++++++++++++++++++++++++--- 1 file changed, 29 insertions(+), 3 deletions(-)
arch/arm64/kvm/sys_regs.c +29 -3
@@ -1216,8 +1216,14 @@ static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,/* Some features have different safe value type in KVM than host features */ switch (id) {case SYS_ID_AA64DFR0_EL1 : -if (kvm_ftr.shift == ID_AA64DFR0_EL1_PMUVer_SHIFT) +switch (kvm_ftr.shift) { +case ID_AA64DFR0_EL1_PMUVer_SHIFT: kvm_ftr.type =FTR_LOWER_SAFE ; +break ; +case ID_AA64DFR0_EL1_DebugVer_SHIFT: + kvm_ftr.type =FTR_LOWER_SAFE ; +break ; + }break ;case SYS_ID_DFR0_EL1 :if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT)
@@ -1476,14 +1482,22 @@ static u64 read_sanitised_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,return val; } +#define ID_REG_LIMIT_FIELD_ENUM (val, reg, field, limit) \ +({ \ + u64 __f_val = FIELD_GET(reg##_##field##_MASK, val); \ + (val) &= ~reg##_##field##_MASK; \ + (val) |= FIELD_PREP(reg##_##field##_MASK, \ + min(__f_val, (u64)reg##_##field##_##limit)); \ + (val); \ +}) +static u64 read_sanitised_id_aa64dfr0_el1 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd) {u64 val =read_sanitised_ftr_reg (SYS_ID_AA64DFR0_EL1 );/* Limit debug to ARMv8.0 */ - val &= ~ID_AA64DFR0_EL1_DebugVer_MASK; - val |=SYS_FIELD_PREP_ENUM (ID_AA64DFR0_EL1 , DebugVer,IMP ); + val =ID_REG_LIMIT_FIELD_ENUM (val,ID_AA64DFR0_EL1 , DebugVer,IMP );/* * Only initialize the PMU version if the vCPU was configured with one.
@@ -1503,6 +1517,7 @@ static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,const struct sys_reg_desc *rd, u64 val) { + u8 debugver = SYS_FIELD_GET(ID_AA64DFR0_EL1, DebugVer, val);u8 pmuver =SYS_FIELD_GET (ID_AA64DFR0_EL1 , PMUVer, val);/*
@@ -1522,6 +1537,13 @@ static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF) val &= ~ID_AA64DFR0_EL1_PMUVer_MASK; +/* +* ID_AA64DFR0_EL1.DebugVer is one of those awkward fields with a +* nonzero minimum safe value. +*/ +if (debugver < ID_AA64DFR0_EL1_DebugVer_IMP) +return -EINVAL ; +return set_id_reg (vcpu, rd, val); }
@@ -1543,6 +1565,7 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu, u64 val) {u8 perfmon =SYS_FIELD_GET (ID_DFR0_EL1 , PerfMon, val); +u8 copdbg =SYS_FIELD_GET (ID_DFR0_EL1 , CopDbg, val);if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF) { val &= ~ID_DFR0_EL1_PerfMon_MASK;
@@ -1558,6 +1581,9 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,if (perfmon !=0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3)return -EINVAL ; +if (copdbg < ID_DFR0_EL1_CopDbg_Armv8) +return -EINVAL ; +return set_id_reg (vcpu, rd, val); }
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 5/12 KVM: arm64: Bump up the default KVM sanitised debug version to v8p8
In reply to Oliver UptonSince ID_AA64DFR0_EL1 and ID_DFR0_EL1 are now writable from userspace, it is safe to bump up the default KVM sanitised debug version to v8p8.
--- arch/arm64/kvm/sys_regs.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
arch/arm64/kvm/sys_regs.c +7 -4
@@ -1496,8 +1496,7 @@ static u64 read_sanitised_id_aa64dfr0_el1(struct kvm_vcpu *vcpu, {u64 val =read_sanitised_ftr_reg (SYS_ID_AA64DFR0_EL1 ); -/* Limit debug to ARMv8.0 */ - val =ID_REG_LIMIT_FIELD_ENUM (val,ID_AA64DFR0_EL1 , DebugVer,IMP ); + val =ID_REG_LIMIT_FIELD_ENUM (val,ID_AA64DFR0_EL1 , DebugVer,V8P8 );/* * Only initialize the PMU version if the vCPU was configured with one.
@@ -1557,6 +1556,8 @@ static u64 read_sanitised_id_dfr0_el1(struct kvm_vcpu *vcpu,if (kvm_vcpu_has_pmu (vcpu)) val |=SYS_FIELD_PREP (ID_DFR0_EL1 , PerfMon, perfmon); + val =ID_REG_LIMIT_FIELD_ENUM (val,ID_DFR0_EL1 , CopDbg, Debugv8p8); +return val; }
@@ -2013,7 +2014,8 @@ static const struct sys_reg_desc sys_reg_descs[] = { .set_user = set_id_dfr0_el1, .visibility = aa32_id_visibility, .reset = read_sanitised_id_dfr0_el1, - .val = ID_DFR0_EL1_PerfMon_MASK, }, + .val = ID_DFR0_EL1_PerfMon_MASK | + ID_DFR0_EL1_CopDbg_MASK, },ID_HIDDEN (ID_AFR0_EL1 ),AA32_ID_SANITISED (ID_MMFR0_EL1 ), AA32_ID_SANITISED(ID_MMFR1_EL1),
@@ -2062,7 +2064,8 @@ static const struct sys_reg_desc sys_reg_descs[] = { .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, .reset = read_sanitised_id_aa64dfr0_el1, - .val = ID_AA64DFR0_EL1_PMUVer_MASK, }, + .val = ID_AA64DFR0_EL1_PMUVer_MASK | + ID_AA64DFR0_EL1_DebugVer_MASK, },ID_SANITISED (ID_AA64DFR1_EL1 ),ID_UNALLOCATED (5 ,2 ), ID_UNALLOCATED(5,3),
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 6/12 KVM: arm64: Allow userspace to change ID_AA64ISAR{0-2}_EL1
In reply to Oliver UptonAlmost all of the features described by the ISA registers have no KVM involvement. Allow userspace to change the value of these registers with a couple exceptions:
- MOPS is not writable as KVM does not currently virtualize FEAT_MOPS.
- The PAuth fields are not writable as KVM requires both address and generic authentication be enabled.
- Override the kernel's handling of BC to LOWER_SAFE.
--- arch/arm64/kvm/sys_regs.c | 42 ++++++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 12 deletions(-)
arch/arm64/kvm/sys_regs.c +30 -12
@@ -1225,6 +1225,10 @@ static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,break ; }break ; +case SYS_ID_AA64ISAR2_EL1 : +if (kvm_ftr.shift ==ID_AA64ISAR2_EL1_BC_SHIFT ) + kvm_ftr.type =FTR_LOWER_SAFE ; +break ;case SYS_ID_DFR0_EL1 :if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT) kvm_ftr.type =FTR_LOWER_SAFE ;
@@ -1851,11 +1855,14 @@ static unsigned int elx2_visibility(const struct kvm_vcpu *vcpu,* from userspace. */ -/* sys_reg_desc initialiser for known cpufeature ID registers */ -#define ID_SANITISED (name) { \ +#define ID_DESC (name) \ SYS_DESC(SYS_##name), \ .access = access_id_reg, \ - .get_user = get_id_reg, \ + .get_user = get_id_reg \ + +/* sys_reg_desc initialiser for known cpufeature ID registers */ +#define ID_SANITISED (name) { \ + ID_DESC(name), \ .set_user = set_id_reg, \ .visibility = id_visibility, \ .reset = kvm_read_sanitised_id_reg, \
@@ -1864,15 +1871,22 @@ static unsigned int elx2_visibility(const struct kvm_vcpu *vcpu,/* sys_reg_desc initialiser for known cpufeature ID registers */ #define AA32_ID_SANITISED (name) { \ - SYS_DESC(SYS_##name), \ - .access = access_id_reg, \ - .get_user = get_id_reg, \ + ID_DESC(name), \ .set_user = set_id_reg, \ .visibility = aa32_id_visibility, \ .reset = kvm_read_sanitised_id_reg, \ .val = 0, \ } +/* sys_reg_desc initialiser for writable ID registers */ +#define ID_WRITABLE (name, mask) { \ + ID_DESC(name), \ + .set_user = set_id_reg, \ + .visibility = id_visibility, \ + .reset = kvm_read_sanitised_id_reg, \ + .val = mask, \ +} +/* * sys_reg_desc initialiser for architecturally unallocated cpufeature ID * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
@@ -1894,9 +1908,7 @@ static unsigned int elx2_visibility(const struct kvm_vcpu *vcpu,* RAZ for the guest. */ #define ID_HIDDEN (name) { \ - SYS_DESC(SYS_##name), \ - .access = access_id_reg, \ - .get_user = get_id_reg, \ + ID_DESC(name), \ .set_user = set_id_reg, \ .visibility = raz_visibility, \ .reset = kvm_read_sanitised_id_reg, \
@@ -2075,9 +2087,15 @@ static const struct sys_reg_desc sys_reg_descs[] = {ID_UNALLOCATED (5 ,7 ),/* CRm=6 */ -ID_SANITISED (ID_AA64ISAR0_EL1 ), -ID_SANITISED (ID_AA64ISAR1_EL1 ), -ID_SANITISED (ID_AA64ISAR2_EL1 ), +ID_WRITABLE (ID_AA64ISAR0_EL1 , ~ID_AA64ISAR0_EL1_RES0 ), +ID_WRITABLE (ID_AA64ISAR1_EL1 , ~(ID_AA64ISAR1_EL1_GPI | +ID_AA64ISAR1_EL1_GPA | +ID_AA64ISAR1_EL1_API | +ID_AA64ISAR1_EL1_APA )), +ID_WRITABLE (ID_AA64ISAR2_EL1 , ~(ID_AA64ISAR2_EL1_RES0 | +ID_AA64ISAR2_EL1_MOPS | +ID_AA64ISAR2_EL1_APA3 | +ID_AA64ISAR2_EL1_GPA3 )),ID_UNALLOCATED (6 ,3 ),ID_UNALLOCATED (6 ,4 ), ID_UNALLOCATED(6,5),
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 7/12 KVM: arm64: Allow userspace to change ID_AA64MMFR{0-2}_EL1
In reply to Oliver UptonFrom: Jing Zhang <[email protected]>
Allow userspace to modify the guest-visible values of these ID registers. Prevent changes to any of the virtualization features until KVM picks up support for nested and we have a handle on managing NV features.
--- arch/arm64/kvm/sys_regs.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-)
arch/arm64/kvm/sys_regs.c +17 -3
@@ -2103,9 +2103,23 @@ static const struct sys_reg_desc sys_reg_descs[] = {ID_UNALLOCATED (6 ,7 ),/* CRm=7 */ -ID_SANITISED (ID_AA64MMFR0_EL1 ), -ID_SANITISED (ID_AA64MMFR1_EL1 ), -ID_SANITISED (ID_AA64MMFR2_EL1 ), +ID_WRITABLE (ID_AA64MMFR0_EL1 , ~(ID_AA64MMFR0_EL1_RES0 | +ID_AA64MMFR0_EL1_TGRAN4_2 | +ID_AA64MMFR0_EL1_TGRAN64_2 | +ID_AA64MMFR0_EL1_TGRAN16_2 )), +ID_WRITABLE (ID_AA64MMFR1_EL1 , ~(ID_AA64MMFR1_EL1_RES0 | +ID_AA64MMFR1_EL1_HCX | +ID_AA64MMFR1_EL1_XNX | +ID_AA64MMFR1_EL1_TWED | +ID_AA64MMFR1_EL1_XNX | +ID_AA64MMFR1_EL1_VH | + ID_AA64MMFR1_EL1_VMIDBits)), +ID_WRITABLE (ID_AA64MMFR2_EL1 , ~(ID_AA64MMFR2_EL1_RES0 | +ID_AA64MMFR2_EL1_EVT | +ID_AA64MMFR2_EL1_FWB | +ID_AA64MMFR2_EL1_IDS | +ID_AA64MMFR2_EL1_NV | +ID_AA64MMFR2_EL1_CCIDX )),ID_SANITISED (ID_AA64MMFR3_EL1 ),ID_UNALLOCATED (7 ,4 ), ID_UNALLOCATED(7,5),
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 8/12 KVM: arm64: Allow userspace to change ID_AA64PFR0_EL1
In reply to Oliver UptonFrom: Jing Zhang <[email protected]>
Allow userspace to change the guest-visible value of the register with some severe limitation:
- No changes to features not virtualized by KVM (AMU, MPAM, RAS)
- Short of full GICv2 emulation in kernel, hiding GICv3 from the guest makes absolutely no sense.
- FP is effectively assumed for KVM VMs.
--- arch/arm64/kvm/sys_regs.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
arch/arm64/kvm/sys_regs.c +7 -1
@@ -2061,7 +2061,13 @@ static const struct sys_reg_desc sys_reg_descs[] = { .get_user = get_id_reg, .set_user = set_id_reg, .reset = read_sanitised_id_aa64pfr0_el1, - .val = ID_AA64PFR0_EL1_CSV2_MASK | ID_AA64PFR0_EL1_CSV3_MASK, }, + .val = ~(ID_AA64PFR0_EL1_AMU | +ID_AA64PFR0_EL1_MPAM | +ID_AA64PFR0_EL1_SVE | +ID_AA64PFR0_EL1_RAS | +ID_AA64PFR0_EL1_GIC | + ID_AA64PFR0_EL1_AdvSIMD | + ID_AA64PFR0_EL1_FP), },ID_SANITISED (ID_AA64PFR1_EL1 ),ID_UNALLOCATED (4 ,2 ), ID_UNALLOCATED(4,3),
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 9/12 KVM: arm64: Allow userspace to change ID_AA64ZFR0_EL1
In reply to Oliver UptonAll known fields in ID_AA64ZFR0_EL1 describe the unprivileged instructions supported by the PE's SVE implementation. Allow userspace to pick and choose the advertised feature set, though nothing stops the guest from using undisclosed instructions.
--- arch/arm64/kvm/sys_regs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm64/kvm/sys_regs.c +1 -1
@@ -2071,7 +2071,7 @@ static const struct sys_reg_desc sys_reg_descs[] = {ID_SANITISED (ID_AA64PFR1_EL1 ),ID_UNALLOCATED (4 ,2 ),ID_UNALLOCATED (4 ,3 ), -ID_SANITISED (ID_AA64ZFR0_EL1 ), +ID_WRITABLE (ID_AA64ZFR0_EL1 , ~ID_AA64ZFR0_EL1_RES0 ),ID_HIDDEN (ID_AA64SMFR0_EL1 ),ID_UNALLOCATED (4 ,6 ), ID_UNALLOCATED(4,7),
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 10/12 KVM: arm64: Document vCPU feature selection UAPIs
In reply to Oliver UptonKVM/arm64 has a couple schemes for handling vCPU feature selection now, which is a lot to put on userspace. Add some documentation about how these interact and provide some recommendations for how to use the writable ID register scheme.
--- Documentation/virt/kvm/arm/index.rst | 1 + Documentation/virt/kvm/arm/vcpu-features.rst | 48 ++++++++++++++++++++ 2 files changed, 49 insertions(+) create mode 100644 Documentation/virt/kvm/arm/vcpu-features.rst
Documentation/virt/kvm/arm/index.rst +1 -0
@@ -11,3 +11,4 @@ ARM hypercalls pvtime ptp_kvm + vcpu-features
Documentation/virt/kvm/arm/vcpu-features.rst new file +48 -0
48 lines not on this page · raw message
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
PATCH v10 11/12 KVM: arm64: selftests: Import automatic generation of sysreg defs
In reply to Oliver UptonFrom: Jing Zhang <[email protected]>
Import automatic system register definition generation from kernel and update system register usage accordingly.
--- tools/arch/arm64/include/.gitignore | 1 + tools/arch/arm64/include/asm/gpr-num.h | 26 + tools/arch/arm64/include/asm/sysreg.h | 839 ++---- tools/arch/arm64/tools/gen-sysreg.awk | 336 +++ tools/arch/arm64/tools/sysreg | 2497 +++++++++++++++++ tools/testing/selftests/kvm/Makefile | 14 +- .../selftests/kvm/aarch64/aarch32_id_regs.c | 4 +- .../selftests/kvm/aarch64/debug-exceptions.c | 12 +- .../selftests/kvm/aarch64/page_fault_test.c | 6 +- .../selftests/kvm/lib/aarch64/processor.c | 6 +- 10 files changed, 3078 insertions(+), 663 deletions(-) create mode 100644 tools/arch/arm64/include/.gitignore create mode 100644 tools/arch/arm64/include/asm/gpr-num.h create mode 100755 tools/arch/arm64/tools/gen-sysreg.awk create mode 100644 tools/arch/arm64/tools/sysreg
tools/arch/arm64/include/.gitignore new file +1 -0
@@ -0,0 +1 @@ +generated/
tools/arch/arm64/include/asm/gpr-num.h new file +26 -0
@@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef __ASM_GPR_NUM_H +#define __ASM_GPR_NUM_H + +#ifdef __ASSEMBLY__ + + .irp num,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30 + .equ .L__gpr_num_x\num, \num + .equ .L__gpr_num_w\num, \num + .endr + .equ .L__gpr_num_xzr, 31 + .equ .L__gpr_num_wzr, 31 + +#else /* __ASSEMBLY__ */ + +#define __DEFINE_ASM_GPR_NUMS \ +" .irp num,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30\n" \ +" .equ .L__gpr_num_x\\num, \\num\n" \ +" .equ .L__gpr_num_w\\num, \\num\n" \ +" .endr\n" \ +" .equ .L__gpr_num_xzr, 31\n" \ +" .equ .L__gpr_num_wzr, 31\n" + +#endif /* __ASSEMBLY__ */ + +#endif /* __ASM_GPR_NUM_H */
tools/arch/arm64/include/asm/sysreg.h +192 -647
1,107 lines not on this page · raw message
tools/arch/arm64/tools/gen-sysreg.awk new file +336 -0
336 lines not on this page · raw message
tools/arch/arm64/tools/sysreg new file +2497 -0
1,530 lines not on this page · raw message
tools/testing/selftests/kvm/aarch64/aarch32_id_regs.c +2 -2
Lines of this file are not shown. View the raw message.
tools/testing/selftests/kvm/aarch64/debug-exceptions.c +6 -6
Lines of this file are not shown. View the raw message.
tools/testing/selftests/kvm/aarch64/page_fault_test.c +3 -3
Lines of this file are not shown. View the raw message.
tools/testing/selftests/kvm/lib/aarch64/processor.c +3 -3
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
Part of the diff is not shown here. View the raw message.
PATCH v10 12/12 KVM: arm64: selftests: Test for setting ID register from usersapce
In reply to Oliver UptonFrom: Jing Zhang <[email protected]>
Add tests to verify setting ID registers from userspace is handled correctly by KVM. Also add a test case to use ioctl KVM_ARM_GET_REG_WRITABLE_MASKS to get writable masks.
--- tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/aarch64/set_id_regs.c | 478 ++++++++++++++++++ 2 files changed, 479 insertions(+) create mode 100644 tools/testing/selftests/kvm/aarch64/set_id_regs.c
tools/testing/selftests/kvm/Makefile +1 -0
@@ -145,6 +145,7 @@ TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions TEST_GEN_PROGS_aarch64 += aarch64/hypercalls TEST_GEN_PROGS_aarch64 += aarch64/page_fault_test TEST_GEN_PROGS_aarch64 += aarch64/psci_test +TEST_GEN_PROGS_aarch64 += aarch64/set_id_regs TEST_GEN_PROGS_aarch64 += aarch64/smccc_filter TEST_GEN_PROGS_aarch64 += aarch64/vcpu_width_config TEST_GEN_PROGS_aarch64 += aarch64/vgic_init
tools/testing/selftests/kvm/aarch64/set_id_regs.c new file +478 -0
478 lines not on this page · raw message
Signature · 1 line
2.42.0.515.g380fc7ccd1-goog
Re: [PATCH v10 01/12] KVM: arm64: Allow userspace to get the writable masks for feature ID registers
In reply to Oliver UptonQuoted 13 lines · Oliver Upton
From: Jing Zhang <[email protected]>
While the Feature ID range is well defined and pretty large, it isn't inconceivable that the architecture will eventually grow some other ranges that will need to similarly be described to userspace.
Add a VM ioctl to allow userspace to get writable masks for feature ID registers in below system register space:
op0 = 3, op1 = {0, 1, 3}, CRn = 0, CRm = {0 - 7}, op2 = {0 - 7} This is used to support mix-and-match userspace and kernels for writable ID registers, where userspace may want to know upfront whether it can actually tweak the contents of an idreg or not.
Quoted 8 lines
Add a new capability (
KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES) that returns a bitmap of the valid ranges, which can subsequently be retrieved, one at a time by setting the index of the set bit as the range identifier.Suggested-by Marc Zyngier <[email protected]>Suggested-by Cornelia Huck <[email protected]>Signed-off-by Jing Zhang <[email protected]>
<process>I think you need to add your s-o-b here.</process>
Quoted 7 lines
--- arch/arm64/include/asm/kvm_host.h | 2 + arch/arm64/include/uapi/asm/kvm.h | 32 +++++++++++++++ arch/arm64/kvm/arm.c | 10 +++++ arch/arm64/kvm/sys_regs.c | 66 +++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 2 + 5 files changed, 112 insertions(+)
Re: [PATCH v10 02/12] KVM: arm64: Document KVM_ARM_GET_REG_WRITABLE_MASKS
In reply to Oliver UptonQuoted 9 lines · Oliver Upton
From: Jing Zhang <[email protected]>
Add some basic documentation on how to get feature ID register writable masks from userspace.
Signed-off-by Jing Zhang <[email protected]>--- Documentation/virt/kvm/api.rst | 43 ++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
Re: [PATCH v10 01/12] KVM: arm64: Allow userspace to get the writable masks for feature ID registers
In reply to Cornelia HuckQuoted 20 lines · Cornelia Huck
Quoted 18 lines · Oliver Upton
From: Jing Zhang <[email protected]>
While the Feature ID range is well defined and pretty large, it isn't inconceivable that the architecture will eventually grow some other ranges that will need to similarly be described to userspace.
Add a VM ioctl to allow userspace to get writable masks for feature ID registers in below system register space:
op0 = 3, op1 = {0, 1, 3}, CRn = 0, CRm = {0 - 7}, op2 = {0 - 7} This is used to support mix-and-match userspace and kernels for writable ID registers, where userspace may want to know upfront whether it can actually tweak the contents of an idreg or not.Add a new capability (
KVM_CAP_ARM_SUPPORTED_FEATURE_ID_RANGES) that returns a bitmap of the valid ranges, which can subsequently be retrieved, one at a time by setting the index of the set bit as the range identifier.
Quoted 5 lines
Quoted 3 lines
Suggested-by Marc Zyngier <[email protected]>Suggested-by Cornelia Huck <[email protected]>Signed-off-by Jing Zhang <[email protected]><process>I think you need to add your s-o-b here.</process>
Whoops, I thought I gave the right mix of flags to b4... clearly not.
Quoted 10 lines
Quoted 7 lines
--- arch/arm64/include/asm/kvm_host.h | 2 + arch/arm64/include/uapi/asm/kvm.h | 32 +++++++++++++++ arch/arm64/kvm/arm.c | 10 +++++ arch/arm64/kvm/sys_regs.c | 66 +++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 2 + 5 files changed, 112 insertions(+)Reviewed-by Cornelia Huck <[email protected]>
Appreciated!
Signature · 2 lines
Thanks, Oliver
Re: [PATCH v10 06/12] KVM: arm64: Allow userspace to change ID_AA64ISAR{0-2}_EL1
In reply to Oliver UptonQuoted 23 lines · Oliver Upton
Almost all of the features described by the ISA registers have no KVM involvement. Allow userspace to change the value of these registers with a couple exceptions:
- MOPS is not writable as KVM does not currently virtualize
FEAT_MOPS.- The PAuth fields are not writable as KVM requires both address and generic authentication be enabled.
- Override the kernel's handling of BC to
LOWER_SAFE.Co-developed-by Jing Zhang <[email protected]>Signed-off-by Jing Zhang <[email protected]>Signed-off-by Oliver Upton <[email protected]>--- arch/arm64/kvm/sys_regs.c | 42 ++++++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 12 deletions(-)arch/arm64/kvm/sys_regs.c +0
-0
arch/arm64/kvm/sys_regs.c static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp, · line 1234
Quoted 10 lines
arch/arm64/kvm/sys_regs.c +4
-0@@ -1225,6 +1225,10 @@ static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,break ; }break ; +case SYS_ID_AA64ISAR2_EL1 : +if (kvm_ftr.shift ==ID_AA64ISAR2_EL1_BC_SHIFT ) + kvm_ftr.type =FTR_LOWER_SAFE ; +break ;case SYS_ID_DFR0_EL1 :if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT) kvm_ftr.type =FTR_LOWER_SAFE ;
Nit: it shouldn't be necessary to override BC anymore, as it was recently fixed in the arm64 code:
https://lore.kernel.org/linux-arm-kernel/[email protected]/
Kristina
IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you.
Re: [PATCH v10 06/12] KVM: arm64: Allow userspace to change ID_AA64ISAR{0-2}_EL1
Quoted 39 lines · Kristina Martsenko
Quoted 23 lines · Oliver Upton
Almost all of the features described by the ISA registers have no KVM involvement. Allow userspace to change the value of these registers with a couple exceptions:
- MOPS is not writable as KVM does not currently virtualize
FEAT_MOPS.- The PAuth fields are not writable as KVM requires both address and generic authentication be enabled.
- Override the kernel's handling of BC to
LOWER_SAFE.Co-developed-by Jing Zhang <[email protected]>Signed-off-by Jing Zhang <[email protected]>Signed-off-by Oliver Upton <[email protected]>--- arch/arm64/kvm/sys_regs.c | 42 ++++++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 12 deletions(-)arch/arm64/kvm/sys_regs.c +0
-0arch/arm64/kvm/sys_regs.c static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp, · line 1234
Quoted 10 lines
arch/arm64/kvm/sys_regs.c +4
-0@@ -1225,6 +1225,10 @@ static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,break ; }break ; +case SYS_ID_AA64ISAR2_EL1 : +if (kvm_ftr.shift ==ID_AA64ISAR2_EL1_BC_SHIFT ) + kvm_ftr.type =FTR_LOWER_SAFE ; +break ;case SYS_ID_DFR0_EL1 :if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT) kvm_ftr.type =FTR_LOWER_SAFE ;Nit: it shouldn't be necessary to override BC anymore, as it was recently fixed in the arm64 code:
https://lore.kernel.org/linux-arm-kernel/[email protected]/
Quoted 3 lines
Kristina
IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you.
Sorry, please ignore this disclaimer, I messed up my mail setup.
Kristina
Re: [PATCH v10 06/12] KVM: arm64: Allow userspace to change ID_AA64ISAR{0-2}_EL1
In reply to Kristina MartsenkoQuoted 30 lines · Kristina Martsenko
Quoted 29 lines · Oliver Upton
Almost all of the features described by the ISA registers have no KVM involvement. Allow userspace to change the value of these registers with a couple exceptions:
- MOPS is not writable as KVM does not currently virtualize
FEAT_MOPS.- The PAuth fields are not writable as KVM requires both address and generic authentication be enabled.
- Override the kernel's handling of BC to
LOWER_SAFE.Co-developed-by Jing Zhang <[email protected]>Signed-off-by Jing Zhang <[email protected]>Signed-off-by Oliver Upton <[email protected]>--- arch/arm64/kvm/sys_regs.c | 42 ++++++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 12 deletions(-)arch/arm64/kvm/sys_regs.c +3
-0@@ -1225,6 +1225,10 @@ static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,break ; }break ; +case SYS_ID_AA64ISAR2_EL1 : +if (kvm_ftr.shift ==ID_AA64ISAR2_EL1_BC_SHIFT ) + kvm_ftr.type =FTR_LOWER_SAFE ;
Quoted 8 lines
arch/arm64/kvm/sys_regs.c static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp, · line 1234
Quoted 4 lines
arch/arm64/kvm/sys_regs.c +1
-0+break ;case SYS_ID_DFR0_EL1 :if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT) kvm_ftr.type =FTR_LOWER_SAFE ;Nit: it shouldn't be necessary to override BC anymore, as it was recently fixed in the arm64 code:
https://lore.kernel.org/linux-arm-kernel/[email protected]/
Perfect, looks like that patch should go in 6.6 too. Thanks for the fix!
Signature · 2 lines
Thanks, Oliver
kernel test robot
build botRe: [PATCH v10 10/12] KVM: arm64: Document vCPU feature selection UAPIs
In reply to Oliver Uptonkernel test robot noticed the following build warnings:
Hi Oliver,
kernel test robot noticed the following build warnings:
[auto build test WARNING on ce9ecca0238b140b88f43859b211c9fdfd8e5b70]
url: https://github.com/intel-lab-lkp/linux/commits/Oliver-Upton/KVM-arm64-Allow-userspace-to-get-the-writable-masks-for-feature-ID-registers/20230921-023547 base: ce9ecca0238b140b88f43859b211c9fdfd8e5b70 patch link: https://lore.kernel.org/r/20230920183310.1163034-11-oliver.upton%40linux.dev patch subject: [PATCH v10 10/12] KVM: arm64: Document vCPU feature selection UAPIs reproduce: (https://download.01.org/0day-ci/archive/20230927/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All warnings (new ones prefixed by >>):
>> Documentation/virt/kvm/arm/vcpu-features.rst:13: WARNING: undefined label: kvm_arm_vcpu_init (if the link has no caption the label must precede a section header) >> Documentation/virt/kvm/arm/vcpu-features.rst:30: WARNING: undefined label: kvm_arm_get_reg_writable_masks (if the link has no caption the label must precede a section header)
vim +13 Documentation/virt/kvm/arm/vcpu-features.rst
12
> 13 The ``KVM_ARM_VCPU_INIT`` ioctl accepts a bitmap of feature flags
14 (``struct kvm_vcpu_init::features``). Features enabled by this interface are
15 *opt-in* and may change/extend UAPI. See :ref:`KVM_ARM_VCPU_INIT` for complete
16 documentation of the features controlled by the ioctl.
17
18 Otherwise, all CPU features supported by KVM are described by the architected
19 ID registers.
20
21 The ID Registers
22 ================
23
24 The Arm architecture specifies a range of *ID Registers* that describe the set
25 of architectural features supported by the CPU implementation. KVM initializes
26 the guest's ID registers to the maximum set of CPU features supported by the
27 system. The ID register values are VM-scoped in KVM, meaning that the values
28 are identical for all vCPUs in a VM.
29
> 30 KVM allows userspace to *opt-out* of certain CPU features described by the ID 31 registers by writing values to them via the ``KVM_SET_ONE_REG`` ioctl. The ID
32 registers are mutable until the VM has started, i.e. userspace has called
33 ``KVM_RUN`` on at least one vCPU in the VM. Userspace can discover what fields
34 are mutable in the ID registers using the ``KVM_ARM_GET_REG_WRITABLE_MASKS``.
35 See the :ref:ioctl documentation <KVM_ARM_GET_REG_WRITABLE_MASKS> for more
36 details.
37
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
Re: [PATCH v10 10/12] KVM: arm64: Document vCPU feature selection UAPIs
Quoted 3 lines · kernel test robot
Hi Oliver,
kernel test robot noticed the following build warnings:
Looks like I failed to include the diff that adds the labels I'm referencing, which is addressed with the following:
Documentation/virt/kvm/api.rst +4 -0
@@ -3370,6 +3370,8 @@ return indicates the attribute is implemented. It does not necessarily indicate that the attribute can be read or written in the device's current state. "addr" is ignored. +.. _KVM_ARM_VCPU_INIT: + 4.82 KVM_ARM_VCPU_INIT ----------------------
@@ -6070,6 +6072,8 @@ writes to the CNTVCT_EL0 and CNTPCT_EL0 registers using the SET_ONE_REG interface. No error will be returned, but the resulting offset will not be applied. +.. _KVM_ARM_GET_REG_WRITABLE_MASKS: + 4.139 KVM_ARM_GET_REG_WRITABLE_MASKS -------------------------------------------
Signature · 2 lines
Thanks, Oliver
Re: [PATCH v10 06/12] KVM: arm64: Allow userspace to change ID_AA64ISAR{0-2}_EL1
In reply to Oliver UptonQuoted 5 lines · Oliver Upton
Quoted 3 lines
Nit: it shouldn't be necessary to override BC anymore, as it was recently fixed in the arm64 code:
https://lore.kernel.org/linux-arm-kernel/[email protected]/Perfect, looks like that patch should go in 6.6 too. Thanks for the fix!
Going to squash the following into the patch:
arch/arm64/kvm/sys_regs.c +0 -4
@@ -1225,10 +1225,6 @@ static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,break ; }break ; -case SYS_ID_AA64ISAR2_EL1 : -if (kvm_ftr.shift ==ID_AA64ISAR2_EL1_BC_SHIFT ) - kvm_ftr.type =FTR_LOWER_SAFE ; -break ;case SYS_ID_DFR0_EL1 :if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT) kvm_ftr.type =FTR_LOWER_SAFE ;
Signature · 2 lines
Thanks, Oliver