x86: Add test cases for LAM
v2 cover x86: Add test cases for LAM
Intel Linear-address masking (LAM) [1], modifies the checking that is applied to *64-bit* linear addresses, allowing software to use of the untranslated address bits for metadata.
The patch series add test cases for LAM:
Patch 1 makes change to HOST_CR3 tests in vmx.
If LAM is supported, VM entry allows CR3.LAM_U48 (bit 62) and CR3.LAM_U57 (bit 61) to be set in CR3 field. Change the test result expectations when setting CR3.LAM_U48 or CR3.LAM_U57 on vmlaunch tests when LAM is supported.
Patch 2~4 add test cases for LAM supervisor mode and user mode, including:
- For supervisor mode
CR4.LAM_SUP toggle
Memory/MMIO access with tagged pointer
INVLPG
INVPCID
INVVPID (also used to cover VMX instruction vmexit path)
- For user mode
CR3 LAM bits toggle
Memory/MMIO access with tagged pointer
[1] Intel ISE https://cdrdv2.intel.com/v1/dl/getContent/671368
Chapter Linear Address Masking (LAM)
---
Changelog
v1 --> v2:
Add cases to test INVLPG, INVPCID, INVVPID with LAM_SUP Add cases to test LAM_{U48,U57}
Binbin Wu (3):
x86: Allow setting of CR3 LAM bits if LAM supported
x86: Add test cases for LAM_{U48,U57}
x86: Add test case for INVVPID with LAM
Robert Hoo (1):
x86: Add test case for LAM_SUP
lib/x86/processor.h | 7 + x86/Makefile.x86_64 | 1 + x86/lam.c | 340 ++++++++++++++++++++++++++++++++++++++++++++ x86/unittests.cfg | 10 ++ x86/vmx_tests.c | 79 +++++++++- 5 files changed, 436 insertions(+), 1 deletion(-) create mode 100644 x86/lam.c
base-commit: e3c5c3ef2524c58023073c0fadde2e8ae3c04ec6
Signature · 1 line
2.25.1
PATCH v2 1/4 x86: Allow setting of CR3 LAM bits if LAM supported
If LAM is supported, VM entry allows CR3.LAM_U48 (bit 62) and CR3.LAM_U57 (bit 61) to be set in CR3 field.
Change the test result expectations when setting CR3.LAM_U48 or CR3.LAM_U57 on vmlaunch tests when LAM is supported.
--- lib/x86/processor.h | 2 ++ x86/vmx_tests.c | 6 +++++- 2 files changed, 7 insertions(+), 1 deletion(-)
lib/x86/processor.h +2 -0
@@ -55,6 +55,8 @@#define X86_CR0_PG BIT(X86_CR0_PG_BIT)#define X86_CR3_PCID_MASK GENMASK(11, 0) +#define X86_CR3_LAM_U57_BIT (61) +#define X86_CR3_LAM_U48_BIT (62)#define X86_CR4_VME_BIT (0)#define X86_CR4_VME BIT(X86_CR4_VME_BIT)
x86/vmx_tests.c +5 -1
@@ -7000,7 +7000,11 @@ static void test_host_ctl_regs(void) cr3 = cr3_saved | (1ul << i);vmcs_write (HOST_CR3 , cr3);report_prefix_pushf ("HOST_CR3 %lx" , cr3); -test_vmx_vmlaunch (VMXERR_ENTRY_INVALID_HOST_STATE_FIELD ); +if (this_cpu_has (X86_FEATURE_LAM ) && + ((i==X86_CR3_LAM_U57_BIT ) || (i==X86_CR3_LAM_U48_BIT ))) +test_vmx_vmlaunch (0 ); +else +test_vmx_vmlaunch (VMXERR_ENTRY_INVALID_HOST_STATE_FIELD );report_prefix_pop (); }
Signature · 1 line
2.25.1
PATCH v2 2/4 x86: Add test case for LAM_SUP
In reply to Binbin WuFrom: Robert Hoo <[email protected]>
This unit test covers:
1. CR4.LAM_SUP toggle has expected behavior according to LAM status.
2. Memory access (here is strcpy() for test example) with supervisor mode address containing LAM meta data, behave as expected per LAM status.
3. MMIO memory access with supervisor mode address containing LAM meta data, behave as expected per LAM status.
4. INVLPG memory operand doens't contain LAM meta data, if the address is non-canonical form then the INVLPG is the same as a NOP (no #GP).
5. INVPCID memory operand (descriptor pointer) could contain LAM meta data, however, the address in the descriptor should be canonical.
In x86/unittests.cfg, add 2 test cases/guest conf, with and without LAM.
LAM feature spec: https://cdrdv2.intel.com/v1/dl/getContent/671368, Chap 7 LINEAR ADDRESS MASKING (LAM)
--- lib/x86/processor.h | 3 + x86/Makefile.x86_64 | 1 + x86/lam.c | 296 ++++++++++++++++++++++++++++++++++++++++++++ x86/unittests.cfg | 10 ++ 4 files changed, 310 insertions(+) create mode 100644 x86/lam.c
lib/x86/processor.h +3 -0
@@ -107,6 +107,8 @@#define X86_CR4_CET BIT(X86_CR4_CET_BIT)#define X86_CR4_PKS_BIT (24)#define X86_CR4_PKS BIT(X86_CR4_PKS_BIT) +#define X86_CR4_LAM_SUP_BIT (28) +#define X86_CR4_LAM_SUP BIT(X86_CR4_LAM_SUP_BIT)#define X86_EFLAGS_CF_BIT (0)#define X86_EFLAGS_CF BIT(X86_EFLAGS_CF_BIT)
@@ -250,6 +252,7 @@ static inline bool is_intel(void)#define X86_FEATURE_SPEC_CTRL (CPUID(0x7, 0, EDX, 26))#define X86_FEATURE_ARCH_CAPABILITIES (CPUID(0x7, 0, EDX, 29))#define X86_FEATURE_PKS (CPUID(0x7, 0, ECX, 31)) +#define X86_FEATURE_LAM (CPUID(0x7, 1, EAX, 26))/* * Extended Leafs, a.k.a. AMD defined
x86/Makefile.x86_64 +1 -0
@@ -34,6 +34,7 @@ tests += $(TEST_DIR)/rdpru.$(exe) tests += $(TEST_DIR)/pks.$(exe) tests += $(TEST_DIR)/pmu_lbr.$(exe) tests += $(TEST_DIR)/pmu_pebs.$(exe) +tests += $(TEST_DIR)/lam.$(exe) ifeq ($(CONFIG_EFI),y) tests += $(TEST_DIR)/amd_sev.$(exe)
x86/lam.c new file +296 -0
296 lines not on this page · raw message
x86/unittests.cfg +10 -0
@@ -478,3 +478,13 @@ file = cet.flat arch = x86_64 smp = 2 extra_params = -enable-kvm -m 2048 -cpu host + +[intel-lam] +file = lam.flat +arch = x86_64 +extra_params = -enable-kvm -cpu host + +[intel-no-lam] +file = lam.flat +arch = x86_64 +extra_params = -enable-kvm -cpu host,-lam
Signature · 1 line
2.25.1
Re: [PATCH v2 2/4] x86: Add test case for LAM_SUP
x86/lam.c line 30
Quoted 9 lines · Binbin Wu
x86/lam.c new file +9
-0+#define LAM57_BITS 6 +#define LAM48_BITS 15 +#define LAM57_MASK GENMASK_ULL(62, 57) +#define LAM48_MASK GENMASK_ULL(62, 48) + +struct invpcid_desc { +u64 pcid :12 ; +u64 rsv :52 ; +u64 addr :64 ;
u64 addr;
Quoted 9 lines
x86/lam.c new file +9
-0+ +}; +static int get_sup_lam_bits (void ) +{ +if (this_cpu_has (X86_FEATURE_LA57 ) &&read_cr4 () &X86_CR4_LA57 ) +return LAM57_BITS ; +else +return LAM48_BITS ; +}
x86/lam.c line 49
Quoted 10 lines
x86/lam.c new file +10
-0+ +/* According to LAM mode, set metadata in high bits */ +static u64 set_metadata (u64 src,unsigned long lam) +{ +u64 metadata; + +switch (lam) { +case LAM57_BITS :/* Set metadata in bits 62:57 */ + metadata = (NONCANONICAL & ((1UL <<LAM57_BITS ) -1 )) <<57 ; + metadata |= (src & ~(LAM57_MASK ));
this can be simplified to
return (src & ~LAM47_MASK) | (NONCANONICAL & LAM47_MASK);
and you can pass a mask to set_metadata() and set mask to 0 if LAM isn't enabled. Then set_metadata() can be further simplified to
return (src & ~mask) | (NONCANONICAL & mask);
Quoted 67 lines
x86/lam.c new file +67
-0+break ; +case LAM48_BITS :/* Set metadata in bits 62:48 */ + metadata = (NONCANONICAL & ((1UL <<LAM48_BITS ) -1 )) <<48 ; + metadata |= (src & ~(LAM48_MASK )); +break ; +default : + metadata = src; +break ; + } + +return metadata; +} + +static void cr4_set_lam_sup (void *data) +{ +unsigned long cr4; + + cr4 =read_cr4 (); +write_cr4_safe (cr4 |X86_CR4_LAM_SUP ); +} + +static void cr4_clear_lam_sup (void *data) +{ +unsigned long cr4; + + cr4 =read_cr4 (); +write_cr4_safe (cr4 & ~X86_CR4_LAM_SUP ); +} + +static void test_cr4_lam_set_clear (bool lam_enumerated) +{ +bool fault; + + fault =test_for_exception (GP_VECTOR , &cr4_set_lam_sup,NULL ); +if (lam_enumerated) +report (!fault && (read_cr4 () &X86_CR4_LAM_SUP ), +"Set CR4.LAM_SUP" ); +else +report (fault,"Set CR4.LAM_SUP causes #GP" ); + + fault =test_for_exception (GP_VECTOR , &cr4_clear_lam_sup,NULL ); +report (!fault,"Clear CR4.LAM_SUP" ); +} + +static void do_strcpy (void *mem) +{ +strcpy ((char *)mem,"LAM SUP Test string." ); +} + +static inline uint64_t test_tagged_ptr (uint64_t arg1,uint64_t arg2, +uint64_t arg3,uint64_t arg4) +{ +bool lam_enumerated = !!arg1; +int lam_bits = (int )arg2; +u64 *ptr = (u64 *)arg3; +bool la_57 = !!arg4; +bool fault; + + fault =test_for_exception (GP_VECTOR , do_strcpy, ptr); +report (!fault,"strcpy to untagged addr" ); + + ptr = (u64 *)set_metadata ((u64 )ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_strcpy, ptr); +if (lam_enumerated) +report (!fault,"strcpy to tagged addr" ); +else +report (fault,"strcpy to tagged addr causes #GP" );
...
Quoted 32 lines
x86/lam.c new file +32
-0+ +if (lam_enumerated && (lam_bits==LAM57_BITS ) && !la_57) { + ptr = (u64 *)set_metadata ((u64 )ptr,LAM48_BITS ); + fault =test_for_exception (GP_VECTOR , do_strcpy, ptr); +report (fault,"strcpy to non-LAM-canonical addr causes #GP" ); + } + +return 0 ; +} + +/* Refer to emulator.c */ +static void do_mov_mmio (void *mem) +{ +unsigned long t1, t2; + +// test mov reg, r/m and mov r/m, reg + t1 =0x123456789abcdefull &-1ul ; + asmvolatile ("mov %[t1], (%[mem])\n\t" +"mov (%[mem]), %[t2]" + : [t2]"=r" (t2) + : [t1]"r" (t1), [mem]"r" (mem) + :"memory" ); +} + +static inline uint64_t test_tagged_mmio_ptr (uint64_t arg1,uint64_t arg2, +uint64_t arg3,uint64_t arg4) +{ +bool lam_enumerated = !!arg1; +int lam_bits = (int )arg2; +u64 *ptr = (u64 *)arg3; +bool la_57 = !!arg4; +bool fault;
x86/lam.c line 158
Quoted 10 lines
x86/lam.c new file +10
-0+ + fault =test_for_exception (GP_VECTOR , do_mov_mmio, ptr); +report (!fault,"Access MMIO with untagged addr" ); + + ptr = (u64 *)set_metadata ((u64 )ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_mov_mmio, ptr); +if (lam_enumerated) +report (!fault,"Access MMIO with tagged addr" ); +else +report (fault,"Access MMIO with tagged addr causes #GP" );
Maybe make this (and other similar changes) more dense, e.g.,
report(fault != lam_enumerated, "Access MMIO with tagged addr")
x86/lam.c line 164
Quoted 5 lines
x86/lam.c new file +5
-0+if (lam_enumerated && (lam_bits==LAM57_BITS ) && !la_57) { + ptr = (u64 *)set_metadata ((u64 )ptr,LAM48_BITS ); + fault =test_for_exception (GP_VECTOR , do_mov_mmio, ptr); +report (fault,"Access MMIO with non-LAM-canonical addr" +" causes #GP" );
don't break long strings.
Review
Quoted 1 line
(quoted diff) +1
-0+ }
please add a comment to explain the intention of this test.
Quoted 43 lines
x86/lam.c new file +43
-0+ +return 0 ; +} + +static void do_invlpg (void *mem) +{ +invlpg (mem); +} + +static void do_invlpg_fep (void *mem) +{ + asmvolatile (KVM_FEP "invlpg (%0)" ::"r" (mem) :"memory" ); +} + +/* invlpg with tagged address is same as NOP, no #GP */ +static void test_invlpg (void *va,bool fep) +{ +bool fault; +u64 *ptr; + + ptr = (u64 *)set_metadata ((u64 )va,get_sup_lam_bits ()); +if (fep) + fault =test_for_exception (GP_VECTOR , do_invlpg_fep, ptr); +else + fault =test_for_exception (GP_VECTOR , do_invlpg, ptr); + +report (!fault,"%sINVLPG with tagged addr" , fep?"fep: " :"" ); +} + +static void do_invpcid (void *desc) +{ +unsigned long type =0 ; +struct invpcid_desc *desc_ptr = (struct invpcid_desc *)desc; + + asmvolatile ("invpcid %0, %1" : + :"m" (*desc_ptr),"r" (type) + :"memory" ); +} + +static void test_invpcid (bool lam_enumerated,void *data) +{ +struct invpcid_desc *desc_ptr = (struct invpcid_desc *) data; +int lam_bits =get_sup_lam_bits ();
x86/lam.c line 218
Quoted 10 lines
x86/lam.c new file +10
-0+bool fault; + +if (!this_cpu_has (X86_FEATURE_PCID ) || + !this_cpu_has (X86_FEATURE_INVPCID )) { +report_skip ("INVPCID not supported" ); +return ; + } + +memset (desc_ptr,0 ,sizeof (struct invpcid_desc )); + desc_ptr->addr = (u64 )data +16 ;
why "+16"? looks you try to avoid invalidating mapping for the descriptor itself.
how about using a local invpcid_desc?
struct invpcid_desc desc = { .addr = data };Quoted 55 lines
x86/lam.c new file +55
-0+ + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +report (!fault,"INVPCID: untagged pointer + untagged addr" ); + + desc_ptr->addr =set_metadata (desc_ptr->addr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +report (fault,"INVPCID: untagged pointer + tagged addr causes #GP" ); + + desc_ptr->addr = (u64 )data +16 ; + desc_ptr = (struct invpcid_desc *)set_metadata ((u64 )desc_ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +if (lam_enumerated && (read_cr4 () &X86_CR4_LAM_SUP )) +report (!fault,"INVPCID: tagged pointer + untagged addr" ); +else +report (fault,"INVPCID: tagged pointer + untagged addr" +" causes #GP" ); + + desc_ptr = (struct invpcid_desc *)data; + desc_ptr->addr = (u64 )data +16 ; + desc_ptr->addr =set_metadata (desc_ptr->addr, lam_bits); + desc_ptr = (struct invpcid_desc *)set_metadata ((u64 )desc_ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +report (fault,"INVPCID: tagged pointer + tagged addr causes #GP" ); +} + +static void test_lam_sup (bool lam_enumerated,bool fep_available) +{ +void *vaddr, *vaddr_mmio; +phys_addr_t paddr; +bool fault; +bool la_57 =read_cr4 () &X86_CR4_LA57 ; +int lam_bits =get_sup_lam_bits (); + + vaddr =alloc_vpage (); + vaddr_mmio =alloc_vpage (); + paddr =virt_to_phys (alloc_page ()); +install_page (current_page_table (), paddr, vaddr); +install_page (current_page_table (),IORAM_BASE_PHYS , vaddr_mmio); + +test_cr4_lam_set_clear (lam_enumerated); + +/* Set for the following LAM_SUP tests */ +if (lam_enumerated) { + fault =test_for_exception (GP_VECTOR , &cr4_set_lam_sup,NULL ); +report (!fault && (read_cr4 () &X86_CR4_LAM_SUP ), +"Set CR4.LAM_SUP" ); + } + +test_tagged_ptr (lam_enumerated, lam_bits, (u64 )vaddr, la_57); +test_tagged_mmio_ptr (lam_enumerated, lam_bits, (u64 )vaddr_mmio, la_57); +test_invlpg (vaddr, false); +test_invpcid (lam_enumerated, vaddr); + +if (fep_available) +test_invlpg (vaddr, true);
x86/lam.c line 283
Quoted 10 lines
x86/lam.c new file +10
-0+} + +int main (int ac,char **av) +{ +bool lam_enumerated; +bool fep_available =is_fep_available (); + +setup_vm (); + + lam_enumerated =this_cpu_has (X86_FEATURE_LAM );
has_lam?
Quoted 34 lines
x86/lam.c new file +13
-0+if (!lam_enumerated) +report_info ("This CPU doesn't support LAM feature\n" ); +else +report_info ("This CPU supports LAM feature\n" ); + +if (!fep_available) +report_skip ("Skipping tests the forced emulation, " +"use kvm.force_emulation_prefix=1 to enable\n" ); + +test_lam_sup (lam_enumerated, fep_available); + +return report_summary (); +}x86/unittests.cfg +0
-0@@ -478,3 +478,13 @@ file = cet.flatarch =
x86_64
smp = 2extra_params= -enable-kvm -m 2048 -cpu hostx86/unittests.cfg +10
-0+ +[intel-lam] +file = lam.flat +arch = x86_64 +extra_params = -enable-kvm -cpu host + +[intel-no-lam] +file = lam.flat +arch = x86_64 +extra_params = -enable-kvm -cpu host,-lamSignature · 1 line
2.25.1
Re: [PATCH v2 2/4] x86: Add test case for LAM_SUP
Quoted 211 lines · Chao Gao
x86/lam.c line 30
Quoted 9 lines · Binbin Wu
x86/lam.c new file +9
-0+#define LAM57_BITS 6 +#define LAM48_BITS 15 +#define LAM57_MASK GENMASK_ULL(62, 57) +#define LAM48_MASK GENMASK_ULL(62, 48) + +struct invpcid_desc { +u64 pcid :12 ; +u64 rsv :52 ; +u64 addr :64 ;u64 addr;
Quoted 9 lines
x86/lam.c new file +9
-0+ +}; +static int get_sup_lam_bits (void ) +{ +if (this_cpu_has (X86_FEATURE_LA57 ) &&read_cr4 () &X86_CR4_LA57 ) +return LAM57_BITS ; +else +return LAM48_BITS ; +}x86/lam.c line 49
Quoted 10 lines
x86/lam.c new file +10
-0+ +/* According to LAM mode, set metadata in high bits */ +static u64 set_metadata (u64 src,unsigned long lam) +{ +u64 metadata; + +switch (lam) { +case LAM57_BITS :/* Set metadata in bits 62:57 */ + metadata = (NONCANONICAL & ((1UL <<LAM57_BITS ) -1 )) <<57 ; + metadata |= (src & ~(LAM57_MASK ));this can be simplified to
return (src & ~LAM47_MASK) | (NONCANONICAL & LAM47_MASK);and you can pass a mask to
set_metadata()and set mask to 0 if LAM isn't enabled. Thenset_metadata()can be further simplified toreturn (src & ~mask) | (NONCANONICAL & mask);Quoted 67 lines
x86/lam.c new file +67
-0+break ; +case LAM48_BITS :/* Set metadata in bits 62:48 */ + metadata = (NONCANONICAL & ((1UL <<LAM48_BITS ) -1 )) <<48 ; + metadata |= (src & ~(LAM48_MASK )); +break ; +default : + metadata = src; +break ; + } + +return metadata; +} + +static void cr4_set_lam_sup (void *data) +{ +unsigned long cr4; + + cr4 =read_cr4 (); +write_cr4_safe (cr4 |X86_CR4_LAM_SUP ); +} + +static void cr4_clear_lam_sup (void *data) +{ +unsigned long cr4; + + cr4 =read_cr4 (); +write_cr4_safe (cr4 & ~X86_CR4_LAM_SUP ); +} + +static void test_cr4_lam_set_clear (bool lam_enumerated) +{ +bool fault; + + fault =test_for_exception (GP_VECTOR , &cr4_set_lam_sup,NULL ); +if (lam_enumerated) +report (!fault && (read_cr4 () &X86_CR4_LAM_SUP ), +"Set CR4.LAM_SUP" ); +else +report (fault,"Set CR4.LAM_SUP causes #GP" ); + + fault =test_for_exception (GP_VECTOR , &cr4_clear_lam_sup,NULL ); +report (!fault,"Clear CR4.LAM_SUP" ); +} + +static void do_strcpy (void *mem) +{ +strcpy ((char *)mem,"LAM SUP Test string." ); +} + +static inline uint64_t test_tagged_ptr (uint64_t arg1,uint64_t arg2, +uint64_t arg3,uint64_t arg4) +{ +bool lam_enumerated = !!arg1; +int lam_bits = (int )arg2; +u64 *ptr = (u64 *)arg3; +bool la_57 = !!arg4; +bool fault; + + fault =test_for_exception (GP_VECTOR , do_strcpy, ptr); +report (!fault,"strcpy to untagged addr" ); + + ptr = (u64 *)set_metadata ((u64 )ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_strcpy, ptr); +if (lam_enumerated) +report (!fault,"strcpy to tagged addr" ); +else +report (fault,"strcpy to tagged addr causes #GP" );...
Quoted 32 lines
x86/lam.c new file +32
-0+ +if (lam_enumerated && (lam_bits==LAM57_BITS ) && !la_57) { + ptr = (u64 *)set_metadata ((u64 )ptr,LAM48_BITS ); + fault =test_for_exception (GP_VECTOR , do_strcpy, ptr); +report (fault,"strcpy to non-LAM-canonical addr causes #GP" ); + } + +return 0 ; +} + +/* Refer to emulator.c */ +static void do_mov_mmio (void *mem) +{ +unsigned long t1, t2; + +// test mov reg, r/m and mov r/m, reg + t1 =0x123456789abcdefull &-1ul ; + asmvolatile ("mov %[t1], (%[mem])\n\t" +"mov (%[mem]), %[t2]" + : [t2]"=r" (t2) + : [t1]"r" (t1), [mem]"r" (mem) + :"memory" ); +} + +static inline uint64_t test_tagged_mmio_ptr (uint64_t arg1,uint64_t arg2, +uint64_t arg3,uint64_t arg4) +{ +bool lam_enumerated = !!arg1; +int lam_bits = (int )arg2; +u64 *ptr = (u64 *)arg3; +bool la_57 = !!arg4; +bool fault;x86/lam.c line 158
Quoted 10 lines
x86/lam.c new file +10
-0+ + fault =test_for_exception (GP_VECTOR , do_mov_mmio, ptr); +report (!fault,"Access MMIO with untagged addr" ); + + ptr = (u64 *)set_metadata ((u64 )ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_mov_mmio, ptr); +if (lam_enumerated) +report (!fault,"Access MMIO with tagged addr" ); +else +report (fault,"Access MMIO with tagged addr causes #GP" );Maybe make this (and other similar changes) more dense, e.g.,
report(fault != lam_enumerated, "Access MMIO with tagged addr")x86/lam.c line 164
Quoted 5 lines
x86/lam.c new file +5
-0+if (lam_enumerated && (lam_bits==LAM57_BITS ) && !la_57) { + ptr = (u64 *)set_metadata ((u64 )ptr,LAM48_BITS ); + fault =test_for_exception (GP_VECTOR , do_mov_mmio, ptr); +report (fault,"Access MMIO with non-LAM-canonical addr" +" causes #GP" );don't break long strings.
Review
Quoted 1 line
(quoted diff) +1
-0+ }please add a comment to explain the intention of this test.
Quoted 46 lines
x86/lam.c new file +46
-0+ +return 0 ; +} + +static void do_invlpg (void *mem) +{ +invlpg (mem); +} + +static void do_invlpg_fep (void *mem) +{ + asmvolatile (KVM_FEP "invlpg (%0)" ::"r" (mem) :"memory" ); +} + +/* invlpg with tagged address is same as NOP, no #GP */ +static void test_invlpg (void *va,bool fep) +{ +bool fault; +u64 *ptr; + + ptr = (u64 *)set_metadata ((u64 )va,get_sup_lam_bits ()); +if (fep) + fault =test_for_exception (GP_VECTOR , do_invlpg_fep, ptr); +else + fault =test_for_exception (GP_VECTOR , do_invlpg, ptr); + +report (!fault,"%sINVLPG with tagged addr" , fep?"fep: " :"" ); +} + +static void do_invpcid (void *desc) +{ +unsigned long type =0 ; +struct invpcid_desc *desc_ptr = (struct invpcid_desc *)desc; + + asmvolatile ("invpcid %0, %1" : + :"m" (*desc_ptr),"r" (type) + :"memory" ); +} + +static void test_invpcid (bool lam_enumerated,void *data) +{ +struct invpcid_desc *desc_ptr = (struct invpcid_desc *) data; +int lam_bits =get_sup_lam_bits (); +bool fault; + + if (!this_cpu_has(X86_FEATURE_PCID) ||
Quoted 8 lines
x86/lam.c line 218
Quoted 7 lines
x86/lam.c new file +7
-0+ !this_cpu_has(X86_FEATURE_INVPCID)) { +report_skip ("INVPCID not supported" ); +return ; + } + +memset (desc_ptr,0 ,sizeof (struct invpcid_desc )); + desc_ptr->addr = (u64 )data +16 ;why "+16"? looks you try to avoid invalidating mapping for the descriptor itself.
It's ture, no need to "+16".
Quoted 4 lines
how about using a local
invpcid_desc?struct invpcid_desc desc = { .addr = data };
The test case is for LAM_SUP, I also want to test the pointer of the descriptor. But in kvm-unit-tests, the stack memory address doesn't obey the rule of kernel space address, so I reuse the memory address.
Maybe I can add a comment to explain why.
Other advices are accepted.
Quoted 102 lines
Quoted 56 lines
x86/lam.c new file +55
-0+ + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +report (!fault,"INVPCID: untagged pointer + untagged addr" ); + + desc_ptr->addr =set_metadata (desc_ptr->addr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +report (fault,"INVPCID: untagged pointer + tagged addr causes #GP" ); + + desc_ptr->addr = (u64 )data +16 ; + desc_ptr = (struct invpcid_desc *)set_metadata ((u64 )desc_ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +if (lam_enumerated && (read_cr4 () &X86_CR4_LAM_SUP )) +report (!fault,"INVPCID: tagged pointer + untagged addr" ); +else +report (fault,"INVPCID: tagged pointer + untagged addr" +" causes #GP" ); + + desc_ptr = (struct invpcid_desc *)data; + desc_ptr->addr = (u64 )data +16 ; + desc_ptr->addr =set_metadata (desc_ptr->addr, lam_bits); + desc_ptr = (struct invpcid_desc *)set_metadata ((u64 )desc_ptr, lam_bits); + fault =test_for_exception (GP_VECTOR , do_invpcid, desc_ptr); +report (fault,"INVPCID: tagged pointer + tagged addr causes #GP" ); +} + +static void test_lam_sup (bool lam_enumerated,bool fep_available) +{ +void *vaddr, *vaddr_mmio; +phys_addr_t paddr; +bool fault; +bool la_57 =read_cr4 () &X86_CR4_LA57 ; +int lam_bits =get_sup_lam_bits (); + + vaddr =alloc_vpage (); + vaddr_mmio =alloc_vpage (); + paddr =virt_to_phys (alloc_page ()); +install_page (current_page_table (), paddr, vaddr); +install_page (current_page_table (),IORAM_BASE_PHYS , vaddr_mmio); + +test_cr4_lam_set_clear (lam_enumerated); + +/* Set for the following LAM_SUP tests */ +if (lam_enumerated) { + fault =test_for_exception (GP_VECTOR , &cr4_set_lam_sup,NULL ); +report (!fault && (read_cr4 () &X86_CR4_LAM_SUP ), +"Set CR4.LAM_SUP" ); + } + +test_tagged_ptr (lam_enumerated, lam_bits, (u64 )vaddr, la_57); +test_tagged_mmio_ptr (lam_enumerated, lam_bits, (u64 )vaddr_mmio, la_57); +test_invlpg (vaddr, false); +test_invpcid (lam_enumerated, vaddr); + +if (fep_available) +test_invlpg (vaddr, true);x86/lam.c line 283
Quoted 10 lines
x86/lam.c new file +10
-0+} + +int main (int ac,char **av) +{ +bool lam_enumerated; +bool fep_available =is_fep_available (); + +setup_vm (); + + lam_enumerated =this_cpu_has (X86_FEATURE_LAM );
has_lam?Quoted 34 lines
x86/lam.c new file +13
-0+if (!lam_enumerated) +report_info ("This CPU doesn't support LAM feature\n" ); +else +report_info ("This CPU supports LAM feature\n" ); + +if (!fep_available) +report_skip ("Skipping tests the forced emulation, " +"use kvm.force_emulation_prefix=1 to enable\n" ); + +test_lam_sup (lam_enumerated, fep_available); + +return report_summary (); +}x86/unittests.cfg +0
-0@@ -478,3 +478,13 @@ file = cet.flatarch =
x86_64
smp = 2extra_params= -enable-kvm -m 2048 -cpu hostx86/unittests.cfg +10
-0+ +[intel-lam] +file = lam.flat +arch = x86_64 +extra_params = -enable-kvm -cpu host + +[intel-no-lam] +file = lam.flat +arch = x86_64 +extra_params = -enable-kvm -cpu host,-lamSignature · 1 line
2.25.1
PATCH v2 3/4 x86: Add test cases for LAM_{U48,U57}
In reply to Binbin WuThis unit test covers:
1. CR3 LAM bits toggle has expected behavior according to LAM status.
2. Memory access using strcpy() with user mode address containing LAM meta data, behave as expected per LAM status.
3. MMIO memory access with user mode address containing LAM meta data, behave as expected per LAM status.
--- lib/x86/processor.h | 2 ++ x86/lam.c | 46 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 47 insertions(+), 1 deletion(-)
lib/x86/processor.h +2 -0
@@ -56,7 +56,9 @@#define X86_CR3_PCID_MASK GENMASK(11, 0)#define X86_CR3_LAM_U57_BIT (61) +#define X86_CR3_LAM_U57 BIT_ULL(X86_CR3_LAM_U57_BIT)#define X86_CR3_LAM_U48_BIT (62) +#define X86_CR3_LAM_U48 BIT_ULL(X86_CR3_LAM_U48_BIT)#define X86_CR4_VME_BIT (0)#define X86_CR4_VME BIT(X86_CR4_VME_BIT)
x86/lam.c +45 -1
73 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v2 4/4 x86: Add test case for INVVPID with LAM
In reply to Binbin WuWhen LAM is on, the linear address of INVVPID operand can contain metadata, and the linear address in the INVVPID descriptor can caontain metadata.
The added cases use tagged descriptor address or/and tagged target invalidation address to make sure the behaviors are expected when LAM is on.
Also, INVVPID cases can be used as the common test cases for VMX instruction vmexits.
--- x86/vmx_tests.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+)
x86/vmx_tests.c +73 -0
@@ -3225,6 +3225,78 @@ static void invvpid_test_not_in_vmx_operation(void)TEST_ASSERT (!vmx_on ()); } +#define LAM57_BITS 6 +#define LAM48_BITS 15 +#define LAM57_MASK GENMASK_ULL(62, 57) +#define LAM48_MASK GENMASK_ULL(62, 48) + +/* According to LAM mode, set metadata in high bits */ +static u64 set_metadata (u64 src,unsigned long lam) +{ +u64 metadata; + +switch (lam) { +case LAM57_BITS :/* Set metadata in bits 62:57 */ + metadata = (NONCANONICAL & ((1UL <<LAM57_BITS ) -1 )) <<57 ; + metadata |= (src & ~(LAM57_MASK )); +break ; +case LAM48_BITS :/* Set metadata in bits 62:48 */ + metadata = (NONCANONICAL & ((1UL <<LAM48_BITS ) -1 )) <<48 ; + metadata |= (src & ~(LAM48_MASK )); +break ; +default : + metadata = src; +break ; + } + +return metadata; +} + +static void invvpid_test_lam (void ) +{ +void *vaddr; +struct invvpid_operand *operand; +int lam_bits =LAM48_BITS ; +bool fault; + +if (!this_cpu_has (X86_FEATURE_LAM )) { +report_skip ("LAM is not supported, skip INVVPID with LAM" ); +return ; + } + +if (this_cpu_has (X86_FEATURE_LA57 ) &&read_cr4 () &X86_CR4_LA57 ) + lam_bits =LAM57_BITS ; + + vaddr =alloc_vpage (); +install_page (current_page_table (),virt_to_phys (alloc_page ()), vaddr); + operand = (struct invvpid_operand *)vaddr; + operand->vpid =0xffff ; + operand->gla = (u64 )vaddr; + +write_cr4_safe (read_cr4 () |X86_CR4_LAM_SUP ); +if (!(read_cr4 () &X86_CR4_LAM_SUP )) { +report_skip ("Failed to enable LAM_SUP" ); +return ; + } + + operand = (struct invvpid_operand *)vaddr; + operand->gla =set_metadata (operand->gla, lam_bits); + fault =test_for_exception (GP_VECTOR , ds_invvpid, operand); +report (!fault,"INVVPID (LAM on): untagged pointer + tagged addr" ); + + operand = (struct invvpid_operand *)set_metadata ((u64 )operand, lam_bits); + operand->gla = (u64 )vaddr; + fault =test_for_exception (GP_VECTOR , ds_invvpid, operand); +report (!fault,"INVVPID (LAM on): tagged pointer + untagged addr" ); + + operand = (struct invvpid_operand *)set_metadata ((u64 )operand, lam_bits); + operand->gla =set_metadata (operand->gla, lam_bits); + fault =test_for_exception (GP_VECTOR , ds_invvpid, operand); +report (!fault,"INVVPID (LAM on): tagged pointer + tagged addr" ); + +write_cr4_safe (read_cr4 () & ~X86_CR4_LAM_SUP ); +} +/* * This does not test real-address mode, virtual-8086 mode, protected mode, * or CPL > 0.
@@ -3282,6 +3354,7 @@ static void invvpid_test(void)invvpid_test_pf ();invvpid_test_compatibility_mode ();invvpid_test_not_in_vmx_operation (); +invvpid_test_lam (); }/*
Signature · 1 line
2.25.1
Sorry for forgetting adding kvm-unit-test prefix. I will resend with the patch series with the right prefix.
Quoted 49 lines · Binbin Wu
Intel Linear-address masking (LAM) [1], modifies the checking that is applied to *64-bit* linear addresses, allowing software to use of the untranslated address bits for metadata.
The patch series add test cases for LAM:
Patch 1 makes change to
HOST_CR3tests in vmx.
If LAM is supported, VM entry allows CR3.LAM_U48 (bit 62) and CR3.LAM_U57 (bit 61) to be set in CR3 field. Change the test result expectations when setting CR3.LAM_U48 or CR3.LAM_U57 on vmlaunch tests when LAM is supported.Patch 2~4 add test cases for LAM supervisor mode and user mode, including:
- For supervisor mode
CR4.LAM_SUP toggle
Memory/MMIO access with tagged pointer
INVLPG
INVPCID
INVVPID (also used to cover VMX instruction vmexit path)
- For user mode
CR3 LAM bits toggle
Memory/MMIO access with tagged pointer[1] Intel ISE https://cdrdv2.intel.com/v1/dl/getContent/671368
Chapter Linear Address Masking (LAM)---
Changelog
v1 --> v2:
Add cases to test INVLPG, INVPCID, INVVPID withLAM_SUPAdd cases to test LAM_{U48,U57}Binbin Wu (3):
x86: Allow setting of CR3 LAM bits if LAM supported
x86: Add test cases for LAM_{U48,U57}
x86: Add test case for INVVPID with LAMRobert Hoo (1):
x86: Add test case forLAM_SUPlib/x86/processor.h | 7 + x86/Makefile.x86_64 | 1 + x86/lam.c | 340 ++++++++++++++++++++++++++++++++++++++++++++ x86/unittests.cfg | 10 ++ x86/vmx_tests.c | 79 +++++++++- 5 files changed, 436 insertions(+), 1 deletion(-)create mode 100644
x86/lam.cbase-commit:
e3c5c3ef2524c58023073c0fadde2e8ae3c04ec6
Quoted 6 lines · Binbin Wu
Intel Linear-address masking (LAM) [1], modifies the checking that is applied to *64-bit* linear addresses, allowing software to use of the untranslated address bits for metadata.
The patch series add test cases for LAM:
I think you should just merge this series to the patchset which enables LAM feature?
Sean Christopherson
reviewerQuoted 10 lines · Kai
Quoted 6 lines · Binbin Wu
Intel Linear-address masking (LAM) [1], modifies the checking that is applied to *64-bit* linear addresses, allowing software to use of the untranslated address bits for metadata.
The patch series add test cases for LAM:
I think you should just merge this series to the patchset which enables LAM feature?
No, please keep them separate. A lore link in the KUT series is more than sufficient, and even that isn't really necesary. b4 and other tooling get confused by series that contain patches for two (or more) different repositories, i.e. posting everything in one bundle makes my life harder, not easier.
Quoted 9 lines · Sean Christopherson
Quoted 8 lines · Kai
Quoted 6 lines · Binbin Wu
Intel Linear-address masking (LAM) [1], modifies the checking that is applied to *64-bit* linear addresses, allowing software to use of the untranslated address bits for metadata.
The patch series add test cases for LAM:
Quoted 7 lines
Quoted 2 lines
I think you should just merge this series to the patchset which enables LAM feature?
No, please keep them separate. A lore link in the KUT series is more than sufficient, and even that isn't really necesary. b4 and other tooling get confused by series that contain patches for two (or more) different repositories, i.e. posting everything in one bundle makes my life harder, not easier.
Sorry I missed this is for KUT.
Quoted 9 lines · Kai
Quoted 6 lines · Binbin Wu
Intel Linear-address masking (LAM) [1], modifies the checking that is applied to *64-bit* linear addresses, allowing software to use of the untranslated address bits for metadata.
The patch series add test cases for LAM:
I think you should just merge this series to the patchset which enables LAM feature?
These are kvm-unit-tests cases, I forgot to add the prefix when I sent the patch set. I then resent the patch set with the kvm-unit-tests prefix.