x86/sev: Unroll string mmio with CC_ATTR_GUEST_UNROLL_STRING_IO
Subsystems (2)
PATCH v3 1/1 x86/sev: Unroll string mmio with CC_ATTR_GUEST_UNROLL_STRING_IO
From: Joerg Roedel <[email protected]>
The io specific memcpy/memset functions use string mmio accesses to do their work. Under SEV the hypervisor can't emulate these instructions, because they read/write directly from/to encrypted memory.
KVM will inject a page fault exception into the guest when it is asked to emulate string mmio instructions for an SEV guest:
BUG: unable to handle page fault for address: ffffc90000065068 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 8000100000067 P4D 8000100000067 PUD 80001000fb067 PMD 80001000fc067 PTE 80000000fed40173 Oops: 0000 [#1] PREEMPT SMP NOPTI CPU: 0 PID: 1 Comm: swapper/0 Not tainted 5.17.0-rc7 #3
As string mmio for an SEV guest can not be supported by the hypervisor, unroll the instructions for CC_ATTR_GUEST_UNROLL_STRING_IO enabled kernels.
This issue appears when kernels are launched in recent libvirt-managed SEV virtual machines, because libvirt started to add a tpm-crb device to the guest by default.
The kernel driver for tpm-crb uses memcpy_to/from_io() functions to access MMIO memory, resulting in a page-fault injected by KVM and crashing the kernel at boot.
---
Changes v2->v3:
- Fix sparse warnings introduced by v2
arch/x86/lib/iomem.c | 65 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 57 insertions(+), 8 deletions(-)
arch/x86/lib/iomem.c +57 -8
@@ -22,7 +22,7 @@ static __always_inline void rep_movs(void *to, const void *from, size_t n) : "memory"); } -void memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) +static void string_memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) {if (unlikely (!n))return ;
@@ -38,9 +38,8 @@ void memcpy_fromio(void *to, const volatile void __iomem *from, size_t n) }rep_movs (to, (const void *)from, n); } -EXPORT_SYMBOL (memcpy_fromio); -void memcpy_toio (volatile void __iomem *to,const void *from,size_t n) +static void string_memcpy_toio (volatile void __iomem *to,const void *from,size_t n) {if (unlikely (!n))return ;
@@ -56,14 +55,64 @@ void memcpy_toio(volatile void __iomem *to, const void *from, size_t n) }rep_movs ((void *)to, (const void *) from, n); } + +static void unrolled_memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) +{ +const volatile char __iomem *in = from; +char *out = to; +int i; + +for (i =0 ; i < n; ++i) + out[i] =readb (&in[i]); +} + +static void unrolled_memcpy_toio (volatile void __iomem *to,const void *from,size_t n) +{ +volatile char __iomem *out = to; +const char *in = from; +int i; + +for (i =0 ; i < n; ++i) +writeb (in[i], &out[i]); +} + +static void unrolled_memset_io (volatile void __iomem *a,int b,size_t c) +{ +volatile char __iomem *mem = a; +int i; + +for (i =0 ; i < c; ++i) +writeb (b, &mem[i]); +} + +void memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) +{ +if (cc_platform_has (CC_ATTR_GUEST_UNROLL_STRING_IO )) +unrolled_memcpy_fromio (to, from, n); +else +string_memcpy_fromio (to, from, n); +} +EXPORT_SYMBOL (memcpy_fromio); + +void memcpy_toio (volatile void __iomem *to,const void *from,size_t n) +{ +if (cc_platform_has (CC_ATTR_GUEST_UNROLL_STRING_IO )) +unrolled_memcpy_toio (to, from, n); +else +string_memcpy_toio (to, from, n); +}EXPORT_SYMBOL (memcpy_toio);void memset_io (volatile void __iomem *a,int b,size_t c) { -/* -* TODO: memset can mangle the IO patterns quite a bit. -* perhaps it would be better to use a dumb one: -*/ -memset ((void *)a, b, c); +if (cc_platform_has (CC_ATTR_GUEST_UNROLL_STRING_IO )) { +unrolled_memset_io (a, b, c); + }else { +/* +* TODO: memset can mangle the IO patterns quite a bit. +* perhaps it would be better to use a dumb one: +*/ +memset ((void *)a, b, c); + } }EXPORT_SYMBOL (memset_io);
Signature · 1 line
2.35.1
From: Joerg Roedel <[email protected]>
Quoted 67 lines
Sent: 26 March 2022 14:41
The io specific memcpy/memset functions use string mmio accesses to do their work. Under SEV the hypervisor can't emulate these instructions, because they read/write directly from/to encrypted memory.
KVM will inject a page fault exception into the guest when it is asked to emulate string mmio instructions for an SEV guest:
BUG: unable to handle page fault for address: ffffc90000065068 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 8000100000067 P4D 8000100000067 PUD 80001000fb067 PMD 80001000fc067 PTE 80000000fed40173 Oops: 0000 [#1] PREEMPT SMP NOPTI CPU: 0 PID: 1 Comm: swapper/0 Not tainted 5.17.0-rc7 #3As string mmio for an SEV guest can not be supported by the hypervisor, unroll the instructions for
CC_ATTR_GUEST_UNROLL_STRING_IOenabled kernels.This issue appears when kernels are launched in recent libvirt-managed SEV virtual machines, because libvirt started to add a tpm-crb device to the guest by default.
The kernel driver for tpm-crb uses memcpy_to/from_io() functions to access MMIO memory, resulting in a page-fault injected by KVM and crashing the kernel at boot.
Cc [email protected] #4.15+Fixes d8aa7eea78a1 ('x86/mm: Add Secure Encrypted Virtualization (SEV) support')Reviewed-by Tom Lendacky <[email protected]>Signed-off-by Joerg Roedel <[email protected]>---
Changesv2->v3:
- Fix sparse warnings introduced by v2arch/x86/lib/iomem.c | 65 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 57 insertions(+), 8 deletions(-)arch/x86/lib/iomem.c +2
-3@@ -22,7 +22,7 @@ static __always_inline void rep_movs(void *to, const void *from, size_t n) : "memory"); } -void memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) +static void string_memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) {if (unlikely (!n))return ;@@ -38,9 +38,8 @@ void memcpy_fromio(void *to, const volatile void __iomem *from, size_t n) }rep_movs (to, (const void *)from, n); } -EXPORT_SYMBOL (memcpy_fromio); -void memcpy_toio (volatile void __iomem *to,const void *from,size_t n) +static void string_memcpy_toio (volatile void __iomem *to,const void *from,size_t n) {if (unlikely (!n))return ;@@ -56,14 +55,64 @@ void memcpy_toio(volatile void __iomem *to, const void *from, size_t n) }rep_movs ((void *)to, (const void *) from, n); }
arch/x86/lib/iomem.c void memcpy_toio(volatile void __iomem *to, const void *from, size_t n) · line 67
Quoted 10 lines
arch/x86/lib/iomem.c +10
-0+ +static void unrolled_memcpy_fromio (void *to,const volatile void __iomem *from,size_t n) +{ +const volatile char __iomem *in = from; +char *out = to; +int i; + +for (i =0 ; i < n; ++i) + out[i] =readb (&in[i]); +}
Wait a minute....
Aren't these functions supposed to be doing 'memory' copies? In which case they need to be using 64bit IO accesses where appropriate - otherwise the performance is horrid.
I thought the x86 memcpy_to/from_io() had been changed to always use a software loop rather than using whatever memcpy() ended up using.
In particular the 'rep movsb' ERMS (EMRS?) copy that is fast (on some cpu) for memory-memory copies is always a byte copy on uncached locations typical for io addresses.
PIO reads from PCIe can be spectacularly slow. You really do want to use the largest register available.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)