KVM: x86: Fix unpermitted XTILE CPUID reporting
Sean Christopherson
maintainerv4 cover KVM: x86: Fix unpermitted XTILE CPUID reporting
This is v4 of Aaron's "Clean up the supported xfeatures" series.
Fix a bug where KVM treats/reports XTILE_CFG as supported without XTILE_DATA being supported if userspace queries the supported CPUID but doesn't request access to AMX, a.k.a. XTILE_DATA. If userspace reflects that CPUID info back into KVM, the resulting VM may use it verbatim and attempt to shove bad data into XCR0: XTILE_CFG and XTILE_DATA must be set/cleared as a pair in XCR0, despite being enumerated separately.
This is effectively compile-tested only on my end.
v4:
- Apply the massaging _only to the XTILE case.
- Add a build-time assertion to trigger a failure if a new dynamic XFeature comes along without updating kvm_get_filtered_xcr0().
v3: https://lore.kernel.org/all/[email protected]
Aaron Lewis (4):
KVM: x86: Add a helper to handle filtering of unpermitted XCR0
features
KVM: selftests: Move XGETBV and XSETBV helpers to common code
KVM: selftests: Add all known XFEATURE masks to common code
KVM: selftests: Add test to verify KVM's supported XCR0
Sean Christopherson (2):
KVM: x86: Filter out XTILE_CFG if XTILE_DATA isn't permitted
KVM: selftests: Rework dynamic XFeature helper to take mask, not bit
arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/x86.c | 4 +- arch/x86/kvm/x86.h | 29 ++++ tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/include/x86_64/processor.h | 69 +++++++-- .../selftests/kvm/lib/x86_64/processor.c | 17 ++- tools/testing/selftests/kvm/x86_64/amx_test.c | 62 +++----- .../selftests/kvm/x86_64/xcr0_cpuid_test.c | 132 ++++++++++++++++++ 8 files changed, 251 insertions(+), 65 deletions(-) create mode 100644 tools/testing/selftests/kvm/x86_64/xcr0_cpuid_test.c
base-commit: 27d6845d258b67f4eb3debe062b7dacc67e0c393
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerPATCH v4 1/6 KVM: x86: Add a helper to handle filtering of unpermitted XCR0 features
From: Aaron Lewis <[email protected]>
Add a helper, kvm_get_filtered_xcr0(), to dedup code that needs to account for XCR0 features that require explicit opt-in on a per-process basis. In addition to documenting when KVM should/shouldn't consult xstate_get_guest_group_perm(), the helper will also allow sanitizing the filtered XCR0 to avoid enumerating architecturally illegal XCR0 values, e.g. XTILE_CFG without XTILE_DATA.
No functional changes intended.
--- arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/x86.c | 4 +--- arch/x86/kvm/x86.h | 13 +++++++++++++ 3 files changed, 15 insertions(+), 4 deletions(-)
arch/x86/kvm/cpuid.c +1 -1
@@ -996,7 +996,7 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) entry->eax = entry->ebx = entry->ecx =0 ;break ;case 0xd : { -u64 permitted_xcr0 = kvm_caps.supported_xcr0 &xstate_get_guest_group_perm (); +u64 permitted_xcr0 =kvm_get_filtered_xcr0 ();u64 permitted_xss = kvm_caps.supported_xss; entry->eax &= permitted_xcr0;
arch/x86/kvm/x86.c +1 -3
@@ -4567,9 +4567,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) r =0 ;break ;case KVM_CAP_XSAVE2 : { -u64 guest_perm =xstate_get_guest_group_perm (); - - r =xstate_required_size (kvm_caps.supported_xcr0 & guest_perm, false); + r =xstate_required_size (kvm_get_filtered_xcr0 (), false);if (r <sizeof (struct kvm_xsave )) r =sizeof (struct kvm_xsave );break ;
arch/x86/kvm/x86.h +13 -0
@@ -315,6 +315,19 @@ extern struct kvm_caps kvm_caps;extern bool enable_pmu; +/* +* Get a filtered version of KVM's supported XCR0 that strips out dynamic +* features for which the current process doesn't (yet) have permission to use. +* This is intended to be used only when enumerating support to userspace, +* e.g. in KVM_GET_SUPPORTED_CPUID and KVM_CAP_XSAVE2, it does NOT need to be +* used to check/restrict guest behavior as KVM rejects KVM_SET_CPUID{2} if +* userspace attempts to enable unpermitted features. +*/ +static inline u64 kvm_get_filtered_xcr0 (void ) +{ +return kvm_caps.supported_xcr0 &xstate_get_guest_group_perm (); +} +static inline bool kvm_mpx_supported (void ) {return (kvm_caps.supported_xcr0 & (XFEATURE_MASK_BNDREGS |XFEATURE_MASK_BNDCSR ))
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerPATCH v4 2/6 KVM: x86: Filter out XTILE_CFG if XTILE_DATA isn't permitted
In reply to Sean ChristophersonFilter out XTILE_CFG from the supported XCR0 reported to userspace if the current process doesn't have access to XTILE_DATA. Attempting to set XTILE_CFG in XCR0 will #GP if XTILE_DATA is also not set, and so keeping XTILE_CFG as supported results in explosions if userspace feeds KVM_GET_SUPPORTED_CPUID back into KVM and the guest doesn't sanity check CPUID.
--- arch/x86/kvm/x86.h | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-)
arch/x86/kvm/x86.h +17 -1
@@ -3,6 +3,7 @@#define ARCH_X86_KVM_X86_H #include <linux/kvm_host.h> +#include <asm/fpu/xstate.h> #include <asm/mce.h> #include <asm/pvclock.h> #include "kvm_cache_regs.h"
@@ -325,7 +326,22 @@ extern bool enable_pmu;*/ static inline u64 kvm_get_filtered_xcr0 (void ) { -return kvm_caps.supported_xcr0 &xstate_get_guest_group_perm (); +u64 permitted_xcr0 = kvm_caps.supported_xcr0; + +BUILD_BUG_ON (XFEATURE_MASK_USER_DYNAMIC !=XFEATURE_MASK_XTILE_DATA ); + +if (permitted_xcr0 &XFEATURE_MASK_USER_DYNAMIC ) { + permitted_xcr0 &=xstate_get_guest_group_perm (); + +/* +* Treat XTILE_CFG as unsupported if the current process isn't +* allowed to use XTILE_DATA, as attempting to set XTILE_CFG in +* XCR0 without setting XTILE_DATA is architecturally illegal. +*/ +if (!(permitted_xcr0 &XFEATURE_MASK_XTILE_DATA )) + permitted_xcr0 &= ~XFEATURE_MASK_XTILE_CFG ; + } +return permitted_xcr0; }static inline bool kvm_mpx_supported (void )
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerPATCH v4 3/6 KVM: selftests: Move XGETBV and XSETBV helpers to common code
In reply to Sean ChristophersonFrom: Aaron Lewis <[email protected]>
The instructions XGETBV and XSETBV are useful to other tests. Move them to processor.h to make them more broadly available.
No functional change intended.
--- .../selftests/kvm/include/x86_64/processor.h | 18 ++++++++++++++ tools/testing/selftests/kvm/x86_64/amx_test.c | 24 +++---------------- 2 files changed, 21 insertions(+), 21 deletions(-)
tools/testing/selftests/kvm/include/x86_64/processor.h +18 -0
@@ -510,6 +510,24 @@ static inline void set_cr4(uint64_t val) __asm__ __volatile__("mov %0, %%cr4" : :"r" (val) :"memory" ); } +static inline u64 xgetbv (u32 index) +{ +u32 eax, edx; + + __asm__ __volatile__("xgetbv;" + :"=a" (eax),"=d" (edx) + :"c" (index)); +return eax | ((u64 )edx <<32 ); +} + +static inline void xsetbv (u32 index,u64 value) +{ +u32 eax = value; +u32 edx = value >>32 ; + + __asm__ __volatile__("xsetbv" ::"a" (eax),"d" (edx),"c" (index)); +} +static inline struct desc_ptr get_gdt (void ) {struct desc_ptr gdt;
tools/testing/selftests/kvm/x86_64/amx_test.c +3 -21
@@ -65,24 +65,6 @@ struct xtile_info {static struct xtile_info xtile; -static inline u64 __xgetbv (u32 index) -{ -u32 eax, edx; - - asmvolatile ("xgetbv;" - :"=a" (eax),"=d" (edx) - :"c" (index)); -return eax + ((u64 )edx <<32 ); -} - -static inline void __xsetbv (u32 index,u64 value) -{ -u32 eax = value; -u32 edx = value >>32 ; - - asmvolatile ("xsetbv" ::"a" (eax),"d" (edx),"c" (index)); -} -static inline void __ldtilecfg (void *cfg) { asm volatile(".byte 0xc4,0xe2,0x78,0x49,0x00"
@@ -160,10 +142,10 @@ static void init_regs(void)set_cr4 (cr4);GUEST_ASSERT (this_cpu_has (X86_FEATURE_OSXSAVE )); - xcr0 =__xgetbv (0 ); + xcr0 =xgetbv (0 ); xcr0 |=XFEATURE_MASK_XTILE ; -__xsetbv (0x0 , xcr0); -GUEST_ASSERT ((__xgetbv (0 ) &XFEATURE_MASK_XTILE ) ==XFEATURE_MASK_XTILE ); +xsetbv (0x0 , xcr0); +GUEST_ASSERT ((xgetbv (0 ) &XFEATURE_MASK_XTILE ) ==XFEATURE_MASK_XTILE ); } static void __attribute__((__flatten__)) guest_code(struct tile_config *amx_cfg,
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerPATCH v4 4/6 KVM: selftests: Rework dynamic XFeature helper to take mask, not bit
In reply to Sean ChristophersonTake the XFeature mask in __vm_xsave_require_permission() instead of the bit so that there's no need to define macros for both the bit and the mask. Asserting that only a single bit is set and retrieving said bit is easy enough via log2 helpers.
Opportunistically clean up the error message for the ARCH_REQ_XCOMP_GUEST_PERM sanity check.
--- .../selftests/kvm/include/x86_64/processor.h | 6 +++--- .../selftests/kvm/lib/x86_64/processor.c | 17 ++++++++++------- tools/testing/selftests/kvm/x86_64/amx_test.c | 2 +- 3 files changed, 14 insertions(+), 11 deletions(-)
tools/testing/selftests/kvm/include/x86_64/processor.h +3 -3
@@ -1098,10 +1098,10 @@ uint64_t kvm_hypercall(uint64_t nr, uint64_t a0, uint64_t a1, uint64_t a2,uint64_t __xen_hypercall (uint64_t nr,uint64_t a0,void *a1);void xen_hypercall (uint64_t nr,uint64_t a0,void *a1); -void __vm_xsave_require_permission (int bit,const char *name); +void __vm_xsave_require_permission (uint64_t xfeature,const char *name); -#define vm_xsave_require_permission (perm) \ - __vm_xsave_require_permission(perm, #perm) +#define vm_xsave_require_permission (xfeature) \ + __vm_xsave_require_permission(xfeature, #xfeature)enum pg_level {PG_LEVEL_NONE ,
tools/testing/selftests/kvm/lib/x86_64/processor.c +10 -7
@@ -697,7 +697,7 @@ uint64_t kvm_get_feature_msr(uint64_t msr_index)return buffer.entry.data; } -void __vm_xsave_require_permission (int bit,const char *name) +void __vm_xsave_require_permission (uint64_t xfeature,const char *name) {int kvm_fd;u64 bitmask;
@@ -705,12 +705,15 @@ void __vm_xsave_require_permission(int bit, const char *name)struct kvm_device_attr attr = { .group =0 , .attr =KVM_X86_XCOMP_GUEST_SUPP , - .addr = (unsigned long ) &bitmask + .addr = (unsigned long ) &bitmask, };TEST_ASSERT (!kvm_supported_cpuid,"kvm_get_supported_cpuid() cannot be used before ARCH_REQ_XCOMP_GUEST_PERM" ); +TEST_ASSERT (is_power_of_2 (xfeature), +"Dynamic XFeatures must be enabled one at a time" ); + kvm_fd =open_kvm_dev_path_or_exit (); rc =__kvm_ioctl (kvm_fd,KVM_GET_DEVICE_ATTR , &attr);close (kvm_fd);
@@ -720,16 +723,16 @@ void __vm_xsave_require_permission(int bit, const char *name)TEST_ASSERT (rc ==0 ,"KVM_GET_DEVICE_ATTR(0, KVM_X86_XCOMP_GUEST_SUPP) error: %ld" , rc); -__TEST_REQUIRE (bitmask & (1ULL << bit), +__TEST_REQUIRE (bitmask & xfeature,"Required XSAVE feature '%s' not supported" , name); -TEST_REQUIRE (!syscall (SYS_arch_prctl,ARCH_REQ_XCOMP_GUEST_PERM , bit)); +TEST_REQUIRE (!syscall (SYS_arch_prctl,ARCH_REQ_XCOMP_GUEST_PERM ,ilog2 (xfeature))); rc =syscall (SYS_arch_prctl,ARCH_GET_XCOMP_GUEST_PERM , &bitmask);TEST_ASSERT (rc ==0 ,"prctl(ARCH_GET_XCOMP_GUEST_PERM) error: %ld" , rc); -TEST_ASSERT (bitmask & (1ULL << bit), -"prctl(ARCH_REQ_XCOMP_GUEST_PERM) failure bitmask=0x%lx" , - bitmask); +TEST_ASSERT (bitmask & xfeature, +"'%s' (0x%lx) not permitted after prctl(ARCH_REQ_XCOMP_GUEST_PERM) perrmited=0x%lx" , + name, xfeature, bitmask); }void vcpu_init_cpuid (struct kvm_vcpu *vcpu,const struct kvm_cpuid2 *cpuid)
tools/testing/selftests/kvm/x86_64/amx_test.c +1 -1
@@ -233,7 +233,7 @@ int main(int argc, char *argv[])* Note, all off-by-default features must be enabled before anything * caches KVM_GET_SUPPORTED_CPUID, e.g. before using kvm_cpu_has(). */ -vm_xsave_require_permission (XSTATE_XTILE_DATA_BIT ); +vm_xsave_require_permission (XFEATURE_MASK_XTILEDATA );TEST_REQUIRE (kvm_cpu_has (X86_FEATURE_XFD ));TEST_REQUIRE (kvm_cpu_has (X86_FEATURE_XSAVE ));
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerPATCH v4 5/6 KVM: selftests: Add all known XFEATURE masks to common code
In reply to Sean ChristophersonFrom: Aaron Lewis <[email protected]>
Add all known XFEATURE masks to processor.h to make them more broadly available in KVM selftests. Relocate and clean up the exiting AMX (XTILE) defines in processor.h, e.g. drop the intermediate define and use BIT_ULL.
--- .../selftests/kvm/include/x86_64/processor.h | 25 ++++++++---- tools/testing/selftests/kvm/x86_64/amx_test.c | 38 ++++++++----------- 2 files changed, 33 insertions(+), 30 deletions(-)
tools/testing/selftests/kvm/include/x86_64/processor.h +17 -8
@@ -60,6 +60,23 @@ struct xstate {u8 extended_state_area[0 ]; } __attribute__ ((packed, aligned (64))); +#define XFEATURE_MASK_FP BIT_ULL(0) +#define XFEATURE_MASK_SSE BIT_ULL(1) +#define XFEATURE_MASK_YMM BIT_ULL(2) +#define XFEATURE_MASK_BNDREGS BIT_ULL(3) +#define XFEATURE_MASK_BNDCSR BIT_ULL(4) +#define XFEATURE_MASK_OPMASK BIT_ULL(5) +#define XFEATURE_MASK_ZMM_Hi256 BIT_ULL(6) +#define XFEATURE_MASK_Hi16_ZMM BIT_ULL(7) +#define XFEATURE_MASK_XTILE_CFG BIT_ULL(17) +#define XFEATURE_MASK_XTILE_DATA BIT_ULL(18) + +#define XFEATURE_MASK_AVX512 (XFEATURE_MASK_OPMASK | \ + XFEATURE_MASK_ZMM_Hi256 | \ + XFEATURE_MASK_Hi16_ZMM) +#define XFEATURE_MASK_XTILE (XFEATURE_MASK_XTILE_DATA | \ + XFEATURE_MASK_XTILE_CFG) +/* Note, these are ordered alphabetically to match kvm_cpuid_entry2. Eww. */ enum cpuid_output_regs {KVM_CPUID_EAX ,
@@ -1138,14 +1155,6 @@ void virt_map_level(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,#define X86_CR0_CD (1UL<<30)/* Cache Disable */ #define X86_CR0_PG (1UL<<31)/* Paging */ -#define XSTATE_XTILE_CFG_BIT 17 -#define XSTATE_XTILE_DATA_BIT 18 - -#define XSTATE_XTILE_CFG_MASK (1ULL << XSTATE_XTILE_CFG_BIT) -#define XSTATE_XTILE_DATA_MASK (1ULL << XSTATE_XTILE_DATA_BIT) -#define XFEATURE_XTILE_MASK (XSTATE_XTILE_CFG_MASK | \ - XSTATE_XTILE_DATA_MASK) -#define PFERR_PRESENT_BIT 0#define PFERR_WRITE_BIT 1#define PFERR_USER_BIT 2
tools/testing/selftests/kvm/x86_64/amx_test.c +16 -22
@@ -34,12 +34,6 @@#define MAX_TILES 16#define RESERVED_BYTES 14 -#define XFEATURE_XTILECFG 17 -#define XFEATURE_XTILEDATA 18 -#define XFEATURE_MASK_XTILECFG (1 << XFEATURE_XTILECFG) -#define XFEATURE_MASK_XTILEDATA (1 << XFEATURE_XTILEDATA) -#define XFEATURE_MASK_XTILE (XFEATURE_MASK_XTILECFG | XFEATURE_MASK_XTILEDATA) -#define XSAVE_HDR_OFFSET 512struct tile_config {
@@ -172,25 +166,25 @@ static void __attribute__((__flatten__)) guest_code(struct tile_config *amx_cfg,* After XSAVEC, XTILEDATA is cleared in the xstate_bv but is set in * the xcomp_bv. */ - xstate->header.xstate_bv =XFEATURE_MASK_XTILEDATA ; -__xsavec (xstate,XFEATURE_MASK_XTILEDATA ); -GUEST_ASSERT (!(xstate->header.xstate_bv &XFEATURE_MASK_XTILEDATA )); -GUEST_ASSERT (xstate->header.xcomp_bv &XFEATURE_MASK_XTILEDATA ); + xstate->header.xstate_bv =XFEATURE_MASK_XTILE_DATA ; +__xsavec (xstate,XFEATURE_MASK_XTILE_DATA ); +GUEST_ASSERT (!(xstate->header.xstate_bv &XFEATURE_MASK_XTILE_DATA )); +GUEST_ASSERT (xstate->header.xcomp_bv &XFEATURE_MASK_XTILE_DATA );/* xfd=0x40000, disable amx tiledata */ -wrmsr (MSR_IA32_XFD ,XFEATURE_MASK_XTILEDATA ); +wrmsr (MSR_IA32_XFD ,XFEATURE_MASK_XTILE_DATA );/* * XTILEDATA is cleared in xstate_bv but set in xcomp_bv, this property * remains the same even when amx tiledata is disabled by IA32_XFD. */ - xstate->header.xstate_bv =XFEATURE_MASK_XTILEDATA ; -__xsavec (xstate,XFEATURE_MASK_XTILEDATA ); -GUEST_ASSERT (!(xstate->header.xstate_bv &XFEATURE_MASK_XTILEDATA )); -GUEST_ASSERT ((xstate->header.xcomp_bv &XFEATURE_MASK_XTILEDATA )); + xstate->header.xstate_bv =XFEATURE_MASK_XTILE_DATA ; +__xsavec (xstate,XFEATURE_MASK_XTILE_DATA ); +GUEST_ASSERT (!(xstate->header.xstate_bv &XFEATURE_MASK_XTILE_DATA )); +GUEST_ASSERT ((xstate->header.xcomp_bv &XFEATURE_MASK_XTILE_DATA ));GUEST_SYNC (6 ); -GUEST_ASSERT (rdmsr (MSR_IA32_XFD ) ==XFEATURE_MASK_XTILEDATA ); +GUEST_ASSERT (rdmsr (MSR_IA32_XFD ) ==XFEATURE_MASK_XTILE_DATA );set_tilecfg (amx_cfg);__ldtilecfg (amx_cfg);/* Trigger #NM exception */
@@ -202,14 +196,14 @@ static void __attribute__((__flatten__)) guest_code(struct tile_config *amx_cfg,void guest_nm_handler (struct ex_regs *regs) { -/* Check if #NM is triggered by XFEATURE_MASK_XTILEDATA */ +/* Check if #NM is triggered by XFEATURE_MASK_XTILE_DATA */ GUEST_SYNC (7 );GUEST_ASSERT (!(get_cr0 () &X86_CR0_TS )); -GUEST_ASSERT (rdmsr (MSR_IA32_XFD_ERR ) ==XFEATURE_MASK_XTILEDATA ); -GUEST_ASSERT (rdmsr (MSR_IA32_XFD ) ==XFEATURE_MASK_XTILEDATA ); +GUEST_ASSERT (rdmsr (MSR_IA32_XFD_ERR ) ==XFEATURE_MASK_XTILE_DATA ); +GUEST_ASSERT (rdmsr (MSR_IA32_XFD ) ==XFEATURE_MASK_XTILE_DATA );GUEST_SYNC (8 ); -GUEST_ASSERT (rdmsr (MSR_IA32_XFD_ERR ) ==XFEATURE_MASK_XTILEDATA ); -GUEST_ASSERT (rdmsr (MSR_IA32_XFD ) ==XFEATURE_MASK_XTILEDATA ); +GUEST_ASSERT (rdmsr (MSR_IA32_XFD_ERR ) ==XFEATURE_MASK_XTILE_DATA ); +GUEST_ASSERT (rdmsr (MSR_IA32_XFD ) ==XFEATURE_MASK_XTILE_DATA );/* Clear xfd_err */ wrmsr (MSR_IA32_XFD_ERR ,0 );/* xfd=0, enable amx */
@@ -233,7 +227,7 @@ int main(int argc, char *argv[])* Note, all off-by-default features must be enabled before anything * caches KVM_GET_SUPPORTED_CPUID, e.g. before using kvm_cpu_has(). */ -vm_xsave_require_permission (XFEATURE_MASK_XTILEDATA ); +vm_xsave_require_permission (XFEATURE_MASK_XTILE_DATA );TEST_REQUIRE (kvm_cpu_has (X86_FEATURE_XFD ));TEST_REQUIRE (kvm_cpu_has (X86_FEATURE_XSAVE ));
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerPATCH v4 6/6 KVM: selftests: Add test to verify KVM's supported XCR0
In reply to Sean ChristophersonFrom: Aaron Lewis <[email protected]>
Check both architectural rules and KVM's ABI for KVM_GET_SUPPORTED_CPUID to ensure the supported xfeatures[1] don't violate any of them.
The architectural rules[2] and KVM's contract with userspace ensure for a given feature, e.g. sse, avx, amx, etc... their associated xfeatures are either all sets or none of them are set, and any dependencies are enabled if needed.
[1] EDX:EAX of CPUID.(EAX=0DH,ECX=0)
[2] SDM vol 1, 13.3 ENABLING THE XSAVE FEATURE SET AND XSAVE-ENABLED FEATURES
--- tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/include/x86_64/processor.h | 20 +++ .../selftests/kvm/x86_64/xcr0_cpuid_test.c | 132 ++++++++++++++++++ 3 files changed, 153 insertions(+) create mode 100644 tools/testing/selftests/kvm/x86_64/xcr0_cpuid_test.c
tools/testing/selftests/kvm/Makefile +1 -0
@@ -105,6 +105,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/vmx_tsc_adjust_test TEST_GEN_PROGS_x86_64 += x86_64/vmx_nested_tsc_scaling_test TEST_GEN_PROGS_x86_64 += x86_64/xapic_ipi_test TEST_GEN_PROGS_x86_64 += x86_64/xapic_state_test +TEST_GEN_PROGS_x86_64 += x86_64/xcr0_cpuid_test TEST_GEN_PROGS_x86_64 += x86_64/xss_msr_test TEST_GEN_PROGS_x86_64 += x86_64/debug_regs TEST_GEN_PROGS_x86_64 += x86_64/tsc_msrs_test
tools/testing/selftests/kvm/include/x86_64/processor.h +20 -0
@@ -241,8 +241,11 @@ struct kvm_x86_cpu_property {#define X86_PROPERTY_PMU_NR_GP_COUNTERS KVM_X86_CPU_PROPERTY(0xa, 0, EAX, 8, 15)#define X86_PROPERTY_PMU_EBX_BIT_VECTOR_LENGTH KVM_X86_CPU_PROPERTY(0xa, 0, EAX, 24, 31) +#define X86_PROPERTY_SUPPORTED_XCR0_LO KVM_X86_CPU_PROPERTY(0xd, 0, EAX, 0, 31)#define X86_PROPERTY_XSTATE_MAX_SIZE_XCR0 KVM_X86_CPU_PROPERTY(0xd, 0, EBX, 0, 31)#define X86_PROPERTY_XSTATE_MAX_SIZE KVM_X86_CPU_PROPERTY(0xd, 0, ECX, 0, 31) +#define X86_PROPERTY_SUPPORTED_XCR0_HI KVM_X86_CPU_PROPERTY(0xd, 0, EDX, 0, 31) +#define X86_PROPERTY_XSTATE_TILE_SIZE KVM_X86_CPU_PROPERTY(0xd, 18, EAX, 0, 31)#define X86_PROPERTY_XSTATE_TILE_OFFSET KVM_X86_CPU_PROPERTY(0xd, 18, EBX, 0, 31)#define X86_PROPERTY_AMX_MAX_PALETTE_TABLES KVM_X86_CPU_PROPERTY(0x1d, 0, EAX, 0, 31)
@@ -681,6 +684,15 @@ static inline bool this_pmu_has(struct kvm_x86_pmu_feature feature) !this_cpu_has (feature.anti_feature); } +static __always_inline uint64_t this_cpu_supported_xcr0(void) +{ +if (!this_cpu_has_p (X86_PROPERTY_SUPPORTED_XCR0_LO )) +return 0 ; + +return this_cpu_property (X86_PROPERTY_SUPPORTED_XCR0_LO ) | + ((uint64_t )this_cpu_property (X86_PROPERTY_SUPPORTED_XCR0_HI ) <<32 ); +} + typedef u32 __attribute__((vector_size(16))) sse128_t;#define __sse128_u union { sse128_t vec; u64 as_u64[2]; u32 as_u32[4]; }#define sse128_lo (x) ({ __sse128_u t; t.vec = x; t.as_u64[0]; })
@@ -1104,6 +1116,14 @@ static inline uint8_t wrmsr_safe(uint32_t msr, uint64_t val)return kvm_asm_safe ("wrmsr" ,"a" (val &-1u ),"d" (val >>32 ),"c" (msr)); } +static inline uint8_t xsetbv_safe (uint32_t index,uint64_t value) +{ +u32 eax = value; +u32 edx = value >>32 ; + +return kvm_asm_safe ("xsetbv" ,"a" (eax),"d" (edx),"c" (index)); +} +bool kvm_is_tdp_enabled (void ); uint64_t *__vm_get_page_table_entry(struct kvm_vm *vm, uint64_t vaddr,
tools/testing/selftests/kvm/x86_64/xcr0_cpuid_test.c new file +132 -0
132 lines not on this page · raw message
Signature · 1 line
2.40.0.348.gf938b09366-goog
Sean Christopherson
maintainerQuoted 10 lines · Sean Christopherson
This is v4 of Aaron's "Clean up the supported xfeatures" series.
Fix a bug where KVM treats/reports
XTILE_CFGas supported withoutXTILE_DATAbeing supported if userspace queries the supported CPUID but doesn't request access to AMX, a.k.a.XTILE_DATA. If userspace reflects that CPUID info back into KVM, the resulting VM may use it verbatim and attempt to shove bad data into XCR0:XTILE_CFGandXTILE_DATAmust be set/cleared as a pair in XCR0, despite being enumerated separately.This is effectively compile-tested only on my end.
Aaron, can you give this series a quick spin (and review) to make sure it works as intended? I'd like to get this into 6.4, but I'd really like it to be tested on AMX hardware first.
Quoted 11 lines · Sean Christopherson
Quoted 9 lines · Sean Christopherson
This is v4 of Aaron's "Clean up the supported xfeatures" series.
Fix a bug where KVM treats/reports
XTILE_CFGas supported withoutXTILE_DATAbeing supported if userspace queries the supported CPUID but doesn't request access to AMX, a.k.a.XTILE_DATA. If userspace reflects that CPUID info back into KVM, the resulting VM may use it verbatim and attempt to shove bad data into XCR0:XTILE_CFGandXTILE_DATAmust be set/cleared as a pair in XCR0, despite being enumerated separately.
Quoted 5 lines
Quoted 1 line
This is effectively compile-tested only on my end.
Aaron, can you give this series a quick spin (and review) to make sure it works as intended? I'd like to get this into 6.4, but I'd really like it to be tested on AMX hardware first.
LGTM. I ran the test on SPR and it worked as intended. I also tried it with the dynamic feature enabled, i.e. XTILEDATA, and that also worked as expected.
The first run the guest XCR0 was 0x2e7 and all tests passed. The second run the guest XCR0 was 0x602e7 and all tests passed again.
Sean Christopherson
maintainerQuoted 10 lines · Sean Christopherson
This is v4 of Aaron's "Clean up the supported xfeatures" series.
Fix a bug where KVM treats/reports
XTILE_CFGas supported withoutXTILE_DATAbeing supported if userspace queries the supported CPUID but doesn't request access to AMX, a.k.a.XTILE_DATA. If userspace reflects that CPUID info back into KVM, the resulting VM may use it verbatim and attempt to shove bad data into XCR0:XTILE_CFGandXTILE_DATAmust be set/cleared as a pair in XCR0, despite being enumerated separately.[...]
Applied to kvm-x86 selftests (due to the dependencies on the earlier AMX selftests rework). Thanks!
[1/6] KVM: x86: Add a helper to handle filtering of unpermitted XCR0 features
https://github.com/kvm-x86/linux/commit/6be3ae45f567 [2/6] KVM: x86: Filter out XTILE_CFG if XTILE_DATA isn't permitted https://github.com/kvm-x86/linux/commit/55cd57b596e8 [3/6] KVM: selftests: Move XGETBV and XSETBV helpers to common code https://github.com/kvm-x86/linux/commit/b213812d3f4c [4/6] KVM: selftests: Rework dynamic XFeature helper to take mask, not bit https://github.com/kvm-x86/linux/commit/7040e54fddf6 [5/6] KVM: selftests: Add all known XFEATURE masks to common code https://github.com/kvm-x86/linux/commit/28f2302584af [6/6] KVM: selftests: Add test to verify KVM's supported XCR0 https://github.com/kvm-x86/linux/commit/03a405b7a522
--
https://github.com/kvm-x86/linux/tree/next
https://github.com/kvm-x86/linux/tree/fixes