KVM: s390: Do storage key checking
Subsystems (5)
cover KVM: s390: Do storage key checking
Check keys when emulating instructions and let user space do key checked accesses.
User space can do so via an extension of the MEMOP IOCTL:
* allow optional key checking
* allow MEMOP on vm fd, so key checked accesses on absolute memory become possible
TODO:
* Documentation changes for MEMOP
* Consider redesign of capability for MEMOP
Janis Schoetterl-Glausch (10):
s390/uaccess: Add storage key checked access to user memory
KVM: s390: Honor storage keys when accessing guest memory
KVM: s390: handle_tprot: Honor storage keys
KVM: s390: selftests: Test TEST PROTECTION emulation
KVM: s390: Add optional storage key checking to MEMOP IOCTL
KVM: s390: Add vm IOCTL for key checked guest absolute memory access
KVM: s390: Rename existing vcpu memop functions
KVM: s390: selftests: Test memops with storage keys
KVM: s390: Add capability for storage key extension of MEM_OP IOCTL
KVM: s390: selftests: Make use of capability in MEM_OP test
arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/include/asm/uaccess.h | 32 ++ arch/s390/kvm/gaccess.c | 237 ++++++++- arch/s390/kvm/gaccess.h | 85 +++- arch/s390/kvm/intercept.c | 12 +- arch/s390/kvm/kvm-s390.c | 122 ++++- arch/s390/kvm/priv.c | 66 +-- arch/s390/lib/uaccess.c | 57 ++- include/uapi/linux/kvm.h | 4 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/s390x/memop.c | 560 +++++++++++++++++++--- tools/testing/selftests/kvm/s390x/tprot.c | 184 +++++++ 14 files changed, 1207 insertions(+), 158 deletions(-) create mode 100644 tools/testing/selftests/kvm/s390x/tprot.c
base-commit: bad13799e0305deb258372b7298a86be4c78aaba
prerequisite-patch-id: 5f8ae41bde2fa5717a775e17c08239ed1ddbcc83
Signature · 1 line
2.32.0
RFC PATCH 1/10 s390/uaccess: Add storage key checked access to user memory
KVM needs a mechanism to do accesses to guest memory that honor storage key protection.
Since the copy_to/from_user implementation makes use of move instructions that support having an additional access key supplied, we can implement __copy_from/to_user_with_key by enhancing the existing implementation.
--- arch/s390/include/asm/uaccess.h | 32 ++++++++++++++++++ arch/s390/lib/uaccess.c | 57 +++++++++++++++++++++++---------- 2 files changed, 72 insertions(+), 17 deletions(-)
arch/s390/include/asm/uaccess.h +32 -0
@@ -33,6 +33,38 @@ static inline int __range_ok(unsigned long addr, unsigned long size)#define access_ok (addr, size) __access_ok(addr, size) +unsigned long __must_check +raw_copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key); + +unsigned long __must_check +raw_copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key); + +static __always_inline __must_check unsigned long +__copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_from_user (to, from, n); +check_object_size (to, n, false); +return raw_copy_from_user_with_key (to, from, n, key); +} + +static __always_inline __must_check unsigned long +__copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_to_user (to, from, n); +check_object_size (from, n, true); +return raw_copy_to_user_with_key (to, from, n, key); +} +unsigned long __must_check raw_copy_from_user (void *to,const void __user *from,unsigned long n);
arch/s390/lib/uaccess.c +40 -17
144 lines not on this page · raw message
Signature · 1 line
2.32.0
Re: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 8 lines · Janis Schoetterl-Glausch
KVM needs a mechanism to do accesses to guest memory that honor storage key protection.
Since the copy_to/from_user implementation makes use of move instructions that support having an additional access key supplied, we can implement __copy_from/to_user_with_key by enhancing the existing implementation.Signed-off-by Janis Schoetterl-Glausch <[email protected]>
For this I'd like to have buy-in from the kernel maintainers.
The patch looks good to me but currently I don't understand all of the background so:
Quoted 204 lines
--- arch/s390/include/asm/uaccess.h | 32 ++++++++++++++++++ arch/s390/lib/uaccess.c | 57 +++++++++++++++++++++++---------- 2 files changed, 72 insertions(+), 17 deletions(-)arch/s390/include/asm/uaccess.h +32
-0@@ -33,6 +33,38 @@ static inline int __range_ok(unsigned long addr, unsigned long size)#define access_ok (addr, size) __access_ok(addr, size) +unsigned long __must_check +raw_copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key); + +unsigned long __must_check +raw_copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key); + +static __always_inline __must_check unsigned long +__copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_from_user (to, from, n); +check_object_size (to, n, false); +return raw_copy_from_user_with_key (to, from, n, key); +} + +static __always_inline __must_check unsigned long +__copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_to_user (to, from, n); +check_object_size (from, n, true); +return raw_copy_to_user_with_key (to, from, n, key); +} +unsigned long __must_check raw_copy_from_user (void *to,const void __user *from,unsigned long n);arch/s390/lib/uaccess.c +40
-17@@ -59,11 +59,13 @@ static inline int copy_with_mvcos(void)#endif static inline unsigned long copy_from_user_mvcos (void *x,const void __user *ptr, -unsigned long size) +unsigned long size,char key) {unsigned long tmp1, tmp2;union oac spec = { + .oac2.key = key, .oac2.as =PSW_BITS_AS_SECONDARY , + .oac2.k =1 , .oac2.a =1 , };@@ -94,19 +96,19 @@ static inline unsigned long copy_from_user_mvcos(void *x, const void __user *ptr }static inline unsigned long copy_from_user_mvcp (void *x,const void __user *ptr, -unsigned long size) +unsigned long size,char key) {unsigned long tmp1, tmp2; tmp1 =-256UL ; asmvolatile (" sacf 0\n" -"0: mvcp 0(%0,%2),0(%1),%3\n" +"0: mvcp 0(%0,%2),0(%1),%[key]\n" "7: jz 5f\n" "1: algr %0,%3\n" " la %1,256(%1)\n" " la %2,256(%2)\n" -"2: mvcp 0(%0,%2),0(%1),%3\n" +"2: mvcp 0(%0,%2),0(%1),%[key]\n" "8: jnz 1b\n" " j 5f\n" "3: la %4,255(%1)\n" /* %4 = ptr + 255 */@@ -115,7 +117,7 @@ static inline unsigned long copy_from_user_mvcp(void *x, const void __user *ptr," slgr %4,%1\n" " clgr %0,%4\n" /* copy crosses next page boundary? */ " jnh 6f\n" -"4: mvcp 0(%4,%2),0(%1),%3\n" +"4: mvcp 0(%4,%2),0(%1),%[key]\n" "9: slgr %0,%4\n" " j 6f\n" "5: slgr %0,%0\n" @@ -123,24 +125,36 @@ static inline unsigned long copy_from_user_mvcp(void *x, const void __user *ptr, EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b) EX_TABLE(7b,3b) EX_TABLE(8b,3b) EX_TABLE(9b,6b) : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2) - : : "cc", "memory"); + : [key] "d" (key << 4) + : "cc", "memory");return size; }unsigned long raw_copy_from_user (void *to,const void __user *from,unsigned long n) {if (copy_with_mvcos ()) -return copy_from_user_mvcos (to, from, n); -return copy_from_user_mvcp (to, from, n); +return copy_from_user_mvcos (to, from, n,0 ); +return copy_from_user_mvcp (to, from, n,0 ); }EXPORT_SYMBOL (raw_copy_from_user); -static inline unsigned long copy_to_user_mvcos (void __user *ptr,const void *x, -unsigned long size) +unsigned long raw_copy_from_user_with_key (void *to,const void __user *from, +unsigned long n,char key) +{ +if (copy_with_mvcos ()) +return copy_from_user_mvcos (to, from, n, key); +return copy_from_user_mvcp (to, from, n, key); +} +EXPORT_SYMBOL (raw_copy_from_user_with_key); + +inline unsigned long copy_to_user_mvcos (void __user *ptr,const void *x, +unsigned long size,char key) {unsigned long tmp1, tmp2;union oac spec = { + .oac1.key = key, .oac1.as =PSW_BITS_AS_SECONDARY , + .oac1.k =1 , .oac1.a =1 , };@@ -171,19 +185,19 @@ static inline unsigned long copy_to_user_mvcos(void __user *ptr, const void *x, }static inline unsigned long copy_to_user_mvcs (void __user *ptr,const void *x, -unsigned long size) +unsigned long size,char key) {unsigned long tmp1, tmp2; tmp1 =-256UL ; asmvolatile (" sacf 0\n" -"0: mvcs 0(%0,%1),0(%2),%3\n" +"0: mvcs 0(%0,%1),0(%2),%[key]\n" "7: jz 5f\n" "1: algr %0,%3\n" " la %1,256(%1)\n" " la %2,256(%2)\n" -"2: mvcs 0(%0,%1),0(%2),%3\n" +"2: mvcs 0(%0,%1),0(%2),%[key]\n" "8: jnz 1b\n" " j 5f\n" "3: la %4,255(%1)\n" /* %4 = ptr + 255 */@@ -192,7 +206,7 @@ static inline unsigned long copy_to_user_mvcs(void __user *ptr, const void *x," slgr %4,%1\n" " clgr %0,%4\n" /* copy crosses next page boundary? */ " jnh 6f\n" -"4: mvcs 0(%4,%1),0(%2),%3\n" +"4: mvcs 0(%4,%1),0(%2),%[key]\n" "9: slgr %0,%4\n" " j 6f\n" "5: slgr %0,%0\n" @@ -200,17 +214,26 @@ static inline unsigned long copy_to_user_mvcs(void __user *ptr, const void *x, EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b) EX_TABLE(7b,3b) EX_TABLE(8b,3b) EX_TABLE(9b,6b) : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2) - : : "cc", "memory"); + : [key] "d" (key << 4) + : "cc", "memory");return size; }unsigned long raw_copy_to_user (void __user *to,const void *from,unsigned long n) {if (copy_with_mvcos ()) -return copy_to_user_mvcos (to, from, n); -return copy_to_user_mvcs (to, from, n); +return copy_to_user_mvcos (to, from, n,0 ); +return copy_to_user_mvcs (to, from, n,0 ); }EXPORT_SYMBOL (raw_copy_to_user); +unsigned long raw_copy_to_user_with_key (void __user *to,const void *from, +unsigned long n,char key) +{ +if (copy_with_mvcos ()) +return copy_to_user_mvcos (to, from, n, key); +return copy_to_user_mvcs (to, from, n, key); +} +EXPORT_SYMBOL (raw_copy_to_user_with_key);static inline unsigned long clear_user_mvcos (void __user *to,unsigned long size) {
Re: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
In reply to Janis Schoetterl-GlauschHi Janis,
Quoted 8 lines · Janis Schoetterl-Glausch
KVM needs a mechanism to do accesses to guest memory that honor storage key protection.
Since the copy_to/from_user implementation makes use of move instructions that support having an additional access key supplied, we can implement __copy_from/to_user_with_key by enhancing the existing implementation.Signed-off-by Janis Schoetterl-Glausch <[email protected]>
This doesn't apply to my master branch.
Quoted 20 lines
arch/s390/lib/uaccess.c +3
-1@@ -59,11 +59,13 @@ static inline int copy_with_mvcos(void)#endif static inline unsigned long copy_from_user_mvcos (void *x,const void __user *ptr, -unsigned long size) +unsigned long size,char key) {unsigned long tmp1, tmp2;union oac spec = { + .oac2.key = key, .oac2.as =PSW_BITS_AS_SECONDARY , + .oac2.k =1 , .oac2.a =1 , };
arch/s390/lib/uaccess.c static inline unsigned long copy_from_user_mvcos(void *x, const void __user *ptr · line 99
Quoted 5 lines
arch/s390/lib/uaccess.c +1
-1@@ -94,19 +96,19 @@ static inline unsigned long copy_from_user_mvcos(void *x, const void __user *ptr }static inline unsigned long copy_from_user_mvcp (void *x,const void __user *ptr, -unsigned long size) +unsigned long size,char key)
Any special reason for using 'char' as type for key here? Given the left shift below i would prefer 'unsigned char' to avoid having to think about whether this can overflow. The end result wouldn't look different, so more or less a cosmetic issue.
Quoted 27 lines
arch/s390/lib/uaccess.c +3
-3{unsigned long tmp1, tmp2; tmp1 =-256UL ; asmvolatile (" sacf 0\n" -"0: mvcp 0(%0,%2),0(%1),%3\n" +"0: mvcp 0(%0,%2),0(%1),%[key]\n" "7: jz 5f\n" "1: algr %0,%3\n" " la %1,256(%1)\n" " la %2,256(%2)\n" -"2: mvcp 0(%0,%2),0(%1),%3\n" +"2: mvcp 0(%0,%2),0(%1),%[key]\n" "8: jnz 1b\n" " j 5f\n" "3: la %4,255(%1)\n" /* %4 = ptr + 255 */@@ -115,7 +117,7 @@ static inline unsigned long copy_from_user_mvcp(void *x, const void __user *ptr," slgr %4,%1\n" " clgr %0,%4\n" /* copy crosses next page boundary? */ " jnh 6f\n" -"4: mvcp 0(%4,%2),0(%1),%3\n" +"4: mvcp 0(%4,%2),0(%1),%[key]\n" "9: slgr %0,%4\n" " j 6f\n" "5: slgr %0,%0\n"
arch/s390/lib/uaccess.c static inline unsigned long copy_from_user_mvcp(void *x, const void __user *ptr, · line 132
Quoted 9 lines
arch/s390/lib/uaccess.c +2
-1@@ -123,24 +125,36 @@ static inline unsigned long copy_from_user_mvcp(void *x, const void __user *ptr, EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b) EX_TABLE(7b,3b) EX_TABLE(8b,3b) EX_TABLE(9b,6b) : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2) - : : "cc", "memory"); + : [key] "d" (key << 4) + : "cc", "memory");return size; }
With that minor nitpick:
Re: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 11 lines · Sven Schnelle
Hi Janis,
Quoted 7 lines · Janis Schoetterl-Glausch
KVM needs a mechanism to do accesses to guest memory that honor storage key protection.
Since the copy_to/from_user implementation makes use of move instructions that support having an additional access key supplied, we can implement __copy_from/to_user_with_key by enhancing the existing implementation.
Quoted 3 lines
Quoted 1 line
Signed-off-by Janis Schoetterl-Glausch <[email protected]>This doesn't apply to my master branch.
Maybe it's due to the prerequisite patch missing?
https://lore.kernel.org/linux-s390/YeGBmPBJ8NMi0Rkp@osiris/T/#t
Quoted 23 lines
Quoted 23 lines
arch/s390/lib/uaccess.c +3
-1@@ -59,11 +59,13 @@ static inline int copy_with_mvcos(void)#endif static inline unsigned long copy_from_user_mvcos (void *x,const void __user *ptr, -unsigned long size) +unsigned long size,char key) {unsigned long tmp1, tmp2;union oac spec = { + .oac2.key = key, .oac2.as =PSW_BITS_AS_SECONDARY , + .oac2.k =1 , .oac2.a =1 , };@@ -94,19 +96,19 @@ static inline unsigned long copy_from_user_mvcos(void *x, const void __user *ptr }
Quoted 8 lines
arch/s390/lib/uaccess.c static inline unsigned long copy_from_user_mvcos(void *x, const void __user *ptr · line 99
Quoted 3 lines
arch/s390/lib/uaccess.c +1
-1static inline unsigned long copy_from_user_mvcp (void *x,const void __user *ptr, -unsigned long size) +unsigned long size,char key)Any special reason for using 'char' as type for key here? Given the left shift below i would prefer 'unsigned char' to avoid having to think about whether this can overflow. The end result wouldn't look different, so more or less a cosmetic issue.
Will do.
[...]
Quoted 4 lines
With that minor nitpick:
Reviewed-by Sven Schnelle <[email protected]>
Thanks!
Heiko Carstens
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
In reply to Janis Schoetterl-GlauschQuoted 45 lines · Janis Schoetterl-Glausch
KVM needs a mechanism to do accesses to guest memory that honor storage key protection.
Since the copy_to/from_user implementation makes use of move instructions that support having an additional access key supplied, we can implement __copy_from/to_user_with_key by enhancing the existing implementation.Signed-off-by Janis Schoetterl-Glausch <[email protected]>--- arch/s390/include/asm/uaccess.h | 32 ++++++++++++++++++ arch/s390/lib/uaccess.c | 57 +++++++++++++++++++++++---------- 2 files changed, 72 insertions(+), 17 deletions(-)arch/s390/include/asm/uaccess.h +24
-0@@ -33,6 +33,38 @@ static inline int __range_ok(unsigned long addr, unsigned long size)#define access_ok (addr, size) __access_ok(addr, size) +unsigned long __must_check +raw_copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key); + +unsigned long __must_check +raw_copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key); + +static __always_inline __must_check unsigned long +__copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_from_user (to, from, n); +check_object_size (to, n, false); +return raw_copy_from_user_with_key (to, from, n, key); +} + +static __always_inline __must_check unsigned long +__copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key) +{
arch/s390/include/asm/uaccess.h static inline int __range_ok(unsigned long addr, unsigned long size) · line 69
Quoted 10 lines
arch/s390/include/asm/uaccess.h +8
-0+might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_to_user (to, from, n); +check_object_size (from, n, true); +return raw_copy_to_user_with_key (to, from, n, key); +} +unsigned long __must_check raw_copy_from_user (void *to,const void __user *from,unsigned long n);
That's a lot of code churn... I would have expected that the existing functions will be renamed, get an additional key parameter, and the current API is implemented by defines which map copy_to_user() & friends to the new functions, and add a zero key.
This would avoid a lot of code duplication, even though the kernel image would get slightly larger.
Could you do that, please, and also provide bloat-a-meter results?
And as already mentioned: please don't use "char" for passing a key. Besides that this leads to the overflow question as pointed out by Sven, this might as usual also raise the question if there might be any bugs wrt to sign extension. That is: for anything but characters, please always explicitely use signed or unsigned char (or u8/s8), so nobody has to think about this.
Thanks!
Re: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 54 lines · Heiko Carstens
Quoted 52 lines · Janis Schoetterl-Glausch
KVM needs a mechanism to do accesses to guest memory that honor storage key protection.
Since the copy_to/from_user implementation makes use of move instructions that support having an additional access key supplied, we can implement __copy_from/to_user_with_key by enhancing the existing implementation.Signed-off-by Janis Schoetterl-Glausch <[email protected]>--- arch/s390/include/asm/uaccess.h | 32 ++++++++++++++++++ arch/s390/lib/uaccess.c | 57 +++++++++++++++++++++++---------- 2 files changed, 72 insertions(+), 17 deletions(-)arch/s390/include/asm/uaccess.h +31
-0@@ -33,6 +33,38 @@ static inline int __range_ok(unsigned long addr, unsigned long size)#define access_ok (addr, size) __access_ok(addr, size) +unsigned long __must_check +raw_copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key); + +unsigned long __must_check +raw_copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key); + +static __always_inline __must_check unsigned long +__copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_from_user (to, from, n); +check_object_size (to, n, false); +return raw_copy_from_user_with_key (to, from, n, key); +} + +static __always_inline __must_check unsigned long +__copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +char key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_to_user (to, from, n); +check_object_size (from, n, true); +return raw_copy_to_user_with_key (to, from, n, key); +}
Quoted 8 lines
arch/s390/include/asm/uaccess.h static inline int __range_ok(unsigned long addr, unsigned long size) · line 69
Quoted 3 lines
arch/s390/include/asm/uaccess.h +1
-0+unsigned long __must_check raw_copy_from_user (void *to,const void __user *from,unsigned long n);That's a lot of code churn... I would have expected that the existing functions will be renamed, get an additional key parameter, and the current API is implemented by defines which map
copy_to_user()& friends to the new functions, and add a zero key.
I don't think I understand you. I can implement raw_copy_from/to_user in terms of raw_copy_from/to_user_with_key, which does save a few lines, but that's it, isn't it?
Thanks!
Quoted 4 lines
This would avoid a lot of code duplication, even though the kernel image would get slightly larger.
Quoted 8 lines
Could you do that, please, and also provide bloat-a-meter results?
And as already mentioned: please don't use "char" for passing a key. Besides that this leads to the overflow question as pointed out by Sven, this might as usual also raise the question if there might be any bugs wrt to sign extension. That is: for anything but characters, please always explicitely use signed or unsigned char (or u8/s8), so nobody has to think about this.
Will do.
Quoted 2 lines
Thanks!
Heiko Carstens
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 8 lines · Janis Schoetterl-Glausch
Quoted 4 lines
That's a lot of code churn... I would have expected that the existing functions will be renamed, get an additional key parameter, and the current API is implemented by defines which map
copy_to_user()& friends to the new functions, and add a zero key.I don't think I understand you. I can implement raw_copy_from/to_user in terms of raw_copy_from/to_user_with_key, which does save a few lines, but that's it, isn't it?
Right you are. I only looked at your patch, and forgot about that all the wrapping is nowadays done in common code.
So what I really don't like about this approach is that we get an arch specific copy_to_user() implementation back. This means that all those extra calls like might_fault(), instrument_copy_to_user(), and friends now have to be kept in sync by us again, if new instrumentation or security options are added to common code.
Given that this is manual work / monitoring I'm sure this will not work in the mid or long term, like it has been proven several times in the past for other features. We need something better, which works out-of-the-box wrt common code changes / enhancements.
Re: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 19 lines · Heiko Carstens
Quoted 8 lines · Janis Schoetterl-Glausch
Quoted 4 lines
That's a lot of code churn... I would have expected that the existing functions will be renamed, get an additional key parameter, and the current API is implemented by defines which map
copy_to_user()& friends to the new functions, and add a zero key.I don't think I understand you. I can implement raw_copy_from/to_user in terms of raw_copy_from/to_user_with_key, which does save a few lines, but that's it, isn't it?
Right you are. I only looked at your patch, and forgot about that all the wrapping is nowadays done in common code.
So what I really don't like about this approach is that we get an arch specific
copy_to_user()implementation back. This means that all those extra calls likemight_fault(),instrument_copy_to_user(), and friends now have to be kept in sync by us again, if new instrumentation or security options are added to common code.
Quoted 4 lines
Given that this is manual work / monitoring I'm sure this will not work in the mid or long term, like it has been proven several times in the past for other features. We need something better, which works out-of-the-box wrt common code changes / enhancements.
What are our options?
1. Tooling
1.1 Automatic monitoring
1.2 ?
2. Implementation changes
2.1 Modify common code
2.2 Don't modify common code, pass key argument via well known location 2.3 ?
Neither of 2.1 and 2.2 seem great.
How might 1.1 work? A build error if they are out of sync?
Heiko Carstens
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 25 lines · Janis Schoetterl-Glausch
Quoted 19 lines · Heiko Carstens
Quoted 8 lines · Janis Schoetterl-Glausch
Quoted 4 lines
That's a lot of code churn... I would have expected that the existing functions will be renamed, get an additional key parameter, and the current API is implemented by defines which map
copy_to_user()& friends to the new functions, and add a zero key.I don't think I understand you. I can implement raw_copy_from/to_user in terms of raw_copy_from/to_user_with_key, which does save a few lines, but that's it, isn't it?
Right you are. I only looked at your patch, and forgot about that all the wrapping is nowadays done in common code.
So what I really don't like about this approach is that we get an arch specific
copy_to_user()implementation back. This means that all those extra calls likemight_fault(),instrument_copy_to_user(), and friends now have to be kept in sync by us again, if new instrumentation or security options are added to common code.Quoted 4 lines
Given that this is manual work / monitoring I'm sure this will not work in the mid or long term, like it has been proven several times in the past for other features. We need something better, which works out-of-the-box wrt common code changes / enhancements.
Quoted 5 lines
What are our options?
1. Tooling
1.1 Automatic monitoring
1.2 ?
No tooling please.
Quoted 2 lines
2. Implementation changes
2.1 Modify common code
In general such changes are done in way that common code is or _may_ be modified to fulfill our needs. Common code header file explicitely states that architectures should get rid of private instances of copy_{to,from}_user() and __copy_{to,from}_user{,_inatomic}().
So we should not add anything like that to arch code again, since nobody would expect that.
Quoted 1 line
2.2 Don't modify common code, pass key argument via well known location
This might also break, and adds complex code and dependencies which should be avoided.
But maybe you find something else which is nice and easily maintainable.
Heiko Carstens
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 10 lines · Heiko Carstens
Quoted 2 lines
2. Implementation changes
2.1 Modify common codeIn general such changes are done in way that common code is or _may_ be modified to fulfill our needs. Common code header file explicitely states that architectures should get rid of private instances of copy_{to,from}_user() and __copy_{to,from}_user{,_inatomic}().
So we should not add anything like that to arch code again, since nobody would expect that.
Or to be more specific: I think the most simple solution would be to try to get the new *key variants into include/linux/uaccess.h, and add the raw variants in architecture code, similar to the rest of the uaccess functions.
There is some (sort of) prior art with copy_mc_to_kernel() even, though that can only partially be compared.
Christian Borntraeger
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Am 20.01.22 um 19:19 schrieb Heiko Carstens:
Quoted 12 lines · Heiko Carstens
Quoted 10 lines
Quoted 2 lines
2. Implementation changes
2.1 Modify common codeIn general such changes are done in way that common code is or _may_ be modified to fulfill our needs. Common code header file explicitely states that architectures should get rid of private instances of copy_{to,from}_user() and __copy_{to,from}_user{,_inatomic}().
So we should not add anything like that to arch code again, since nobody would expect that.
Quoted 6 lines
Or to be more specific: I think the most simple solution would be to try to get the new *key variants into
include/linux/uaccess.h, and add the raw variants in architecture code, similar to the rest of the uaccess functions.
There is some (sort of) prior art withcopy_mc_to_kernel()even, though that can only partially be compared.
So in essence adding something like this and then providing raw_copy_from/to_user_key? (whitespace damaged, just pasted in)
include/linux/uaccess.h +53 -0
@@ -201,6 +201,59 @@ copy_to_user(void __user *to, const void *from, unsigned long n)return n; } + +#if defined(__s390x__) && defined(CONFIG_KVM ) +/* +* Variants that pass along an access key. Uses by KVM on s390x to implement +* key checks for guests that use storage keys Must be kept in sync with the +* non-key variants from above. The only difference is the _key suffix when +* calling raw_copy_from/to_user_key. +*/ +static inline __must_check unsigned long +_copy_from_user_key (void *to,const void __user *from,unsigned long n,u8 key) +{ +unsigned long res = n; +might_fault (); +if (!should_fail_usercopy () &&likely (access_ok (from, n))) { +instrument_copy_from_user (to, from, n); + res =raw_copy_from_user_key (to, from, n, key); + } +if (unlikely (res)) +memset (to + (n - res),0 , res); +return res; +} + +static inline __must_check unsigned long +_copy_to_user_key (void __user *to,const void *from,unsigned long n,u8 key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +if (access_ok (to, n)) { +instrument_copy_to_user (to, from, n); + n =raw_copy_to_user_key (to, from, n, key); + } +return n; +} + +static __always_inline unsigned long __must_check +copy_from_user_key (void *to,const void __user *from,unsigned long n,u8 key) +{ +if (likely (check_copy_size (to, n, false))) + n =_copy_from_user_key (to, from, n, key); +return n; +} + +static __always_inline unsigned long __must_check +copy_to_user_key (void __user *to,const void *from,unsigned long n,u8 key) +{ +if (likely (check_copy_size (from, n, true))) + n =_copy_to_user_key (to, from, n); +return n; +} +#endif + +#ifndef copy_mc_to_kernel/* * Without arch opt-in this generic copy_mc_to_kernel() will not handle
Heiko Carstens
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 8 lines · Christian Borntraeger
So in essence adding something like this and then providing raw_copy_from/to_user_key? (whitespace damaged, just pasted in)
include/linux/uaccess.h +0
-0
include/linux/uaccess.h copy_to_user(void __user *to, const void *from, unsigned long n) · line 210
Quoted 10 lines
include/linux/uaccess.h +8
-0@@ -201,6 +201,59 @@ copy_to_user(void __user *to, const void *from, unsigned long n)return n; } + +#if defined(__s390x__) && defined(CONFIG_KVM ) +/* +* Variants that pass along an access key. Uses by KVM on s390x to implement +* key checks for guests that use storage keys Must be kept in sync with the +* non-key variants from above. The only difference is the _key suffix when +* calling raw_copy_from/to_user_key. +*/
This is too architecture specific, I wouldn't like to see __s390__ or KVM dependencies. This should be a bit more generic, so other architectures _might_ also make use of this interface that is:
include/linux/uaccess.h copy_to_user(void __user *to, const void *from, unsigned long n) · line 213
Quoted 2 lines
include/linux/uaccess.h +2
-0+static inline __must_check unsigned long +_copy_from_user_key (void *to,const void __user *from,unsigned long n,u8 key)
Make key unsigned long, add support for INLINE_COPY_TO_USER, and maybe add a wrapper, so this works on all architectures, e.g. if raw_copy_to_user_key() is not defined, then fall back to raw_copy_to_user() and ignore the key parameter.
Just some ideas. The _only_ concern about the previous implementation I have, is that we could run out-of-sync with common code wrt instrumentation and other options. Given how sensitive uaccess ops are, I think we should try to avoid that by all cost, if possible.
Does that make sense?
Re: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 24 lines · Heiko Carstens
Quoted 8 lines · Christian Borntraeger
So in essence adding something like this and then providing raw_copy_from/to_user_key? (whitespace damaged, just pasted in)
include/linux/uaccess.h +0
-0include/linux/uaccess.h copy_to_user(void __user *to, const void *from, unsigned long n) · line 210
Quoted 10 lines
include/linux/uaccess.h +8
-0@@ -201,6 +201,59 @@ copy_to_user(void __user *to, const void *from, unsigned long n)return n; } + +#if defined(__s390x__) && defined(CONFIG_KVM ) +/* +* Variants that pass along an access key. Uses by KVM on s390x to implement +* key checks for guests that use storage keys Must be kept in sync with the +* non-key variants from above. The only difference is the _key suffix when +* calling raw_copy_from/to_user_key. +*/ This is too architecture specific, I wouldn't like to see
__s390__or KVM dependencies. This should be a bit more generic, so other architectures _might_ also make use of this interface that is:
Quoted 8 lines
include/linux/uaccess.h copy_to_user(void __user *to, const void *from, unsigned long n) · line 213
Quoted 2 lines
include/linux/uaccess.h +2
-0+static inline __must_check unsigned long +_copy_from_user_key (void *to,const void __user *from,unsigned long n,u8 key)Make key unsigned long, add support for
INLINE_COPY_TO_USER, and maybe add a wrapper, so this works on all architectures, e.g. ifraw_copy_to_user_key()is not defined, then fall back toraw_copy_to_user()and ignore the key parameter.
Since we only need the double underscore variants, even if we're going to be more general than we need to be, we can restrict ourselves to those, can't we?
I don't understand your comment about the wrapper. You'd want an error on misuse, that is, if you try to use a _with_key function if the functionality is not defined, no?
I see the following possibilities:
1. raw_copy_from/to_user is declared by each architecture. Mirror that for raw_copy_from/to_user_with_key.
Linker error on misuse.
2. Opt in with #define UACCESS_WITH_KEY or similar. Undeclared function on misuse.
3. Opt in by requiring that raw_copy_from/to_user_with_key are macros. Undeclared function on misuse.
4. Declare raw_copy_from/to_user_with_key in include/linux/uacess.h. Linker error on misuse.
Heiko Carstens
maintainerRe: [RFC PATCH v1 01/10] s390/uaccess: Add storage key checked access to user memory
Quoted 11 lines · Janis Schoetterl-Glausch
Quoted 8 lines
include/linux/uaccess.h copy_to_user(void __user *to, const void *from, unsigned long n) · line 213
Quoted 2 lines
include/linux/uaccess.h +2
-0+static inline __must_check unsigned long +_copy_from_user_key (void *to,const void __user *from,unsigned long n,u8 key)Make key unsigned long, add support for
INLINE_COPY_TO_USER, and maybe add a wrapper, so this works on all architectures, e.g. ifraw_copy_to_user_key()is not defined, then fall back toraw_copy_to_user()and ignore the key parameter.Since we only need the double underscore variants, even if we're going to be more general than we need to be, we can restrict ourselves to those, can't we?
I don't think that works with INLINE_COPY_TO_USER. The reason for the single underline variants is being able to have an out-line-implementation in lib/usercopy.c, isn't it?
Quoted 2 lines
I don't understand your comment about the wrapper. You'd want an error on misuse, that is, if you try to use a
_with_keyfunction if the functionality is not defined, no?
No. My intention was that it should simply work/compile by default for architectures which do not support a key mechanism:
something like
#ifndef raw_copy_to_user_key
static inline unsigned long raw_copy_to_user_key(..., unsigned long key)
{
return raw_copy_to_user(...);
}#endif
Again, this is just a proposal and might be turned down by common code guys. Just trying to come up with something which could also work on other architectures, and which does not cause pain because architectures don't really need it.
RFC PATCH 1/1 uaccess: Add mechanism for key checked access to user memory
KVM on s390 needs a mechanism to do accesses to guest memory that honors storage key protection. __copy_from/to_user_with_key is implemented by introducing raw_copy_from/to_user_with_key.
Since the existing uaccess implementation on s390 makes use of move instructions that support having an additional access key supplied, we can implement raw_copy_from/to_user_with_key by enhancing the existing implementation.
---
This works for us and compiles on other architectures (tested x86). The patch only implements __copy_from/to_user_with_key, since those are the ones we actually need. On other architectures those functions don't exists, but they aren't used either, so it's not a problem.
Should we also implement single and no underscore variants? Why? Completeness?
arch/s390/include/asm/uaccess.h | 20 +++++++++++-- arch/s390/lib/uaccess.c | 50 +++++++++++++++++++-------------- include/linux/uaccess.h | 28 ++++++++++++++++++ 3 files changed, 75 insertions(+), 23 deletions(-)
arch/s390/include/asm/uaccess.h +18 -2
@@ -33,11 +33,27 @@ static inline int __range_ok(unsigned long addr, unsigned long size)#define access_ok (addr, size) __access_ok(addr, size) +#define raw_copy_from_user_with_key raw_copy_from_user_with_keyunsigned long __must_check -raw_copy_from_user (void *to,const void __user *from,unsigned long n); +raw_copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +unsigned long key); +#define raw_copy_to_user_with_key raw_copy_to_user_with_keyunsigned long __must_check -raw_copy_to_user (void __user *to,const void *from,unsigned long n); +raw_copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +unsigned long key); + +static __always_inline unsigned long __must_check +raw_copy_from_user (void *to,const void __user *from,unsigned long n) +{ +return raw_copy_from_user_with_key (to, from, n,0 ); +} + +static __always_inline unsigned long __must_check +raw_copy_to_user (void __user *to,const void *from,unsigned long n) +{ +return raw_copy_to_user_with_key (to, from, n,0 ); +}#ifndef CONFIG_KASAN #define INLINE_COPY_FROM_USER
arch/s390/lib/uaccess.c +29 -21
133 lines not on this page · raw message
include/linux/uaccess.h +28 -0
@@ -114,6 +114,20 @@ __copy_from_user(void *to, const void __user *from, unsigned long n)return raw_copy_from_user (to, from, n); } +#ifdef raw_copy_from_user_with_key +static __always_inline __must_check unsigned long +__copy_from_user_with_key (void *to,const void __user *from,unsigned long n, +unsigned long key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_from_user (to, from, n); +check_object_size (to, n, false); +return raw_copy_from_user_with_key (to, from, n, key); +} +#endif /* raw_copy_from_user_with_key */ +/** * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking. * @to: Destination address, in user space.
@@ -148,6 +162,20 @@ __copy_to_user(void __user *to, const void *from, unsigned long n)return raw_copy_to_user (to, from, n); } +#ifdef raw_copy_to_user_with_key +static __always_inline __must_check unsigned long +__copy_to_user_with_key (void __user *to,const void *from,unsigned long n, +unsigned long key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +instrument_copy_to_user (to, from, n); +check_object_size (from, n, true); +return raw_copy_to_user_with_key (to, from, n, key); +} +#endif /* raw_copy_to_user_with_key */ +#ifdef INLINE_COPY_FROM_USER static inline __must_check unsigned long _copy_from_user (void *to,const void __user *from,unsigned long n)
base-commit: bad13799e0305deb258372b7298a86be4c78aaba
prerequisite-patch-id: 5f8ae41bde2fa5717a775e17c08239ed1ddbcc83
Signature · 1 line
2.32.0
Heiko Carstens
maintainerRe: [RFC PATCH] uaccess: Add mechanism for key checked access to user memory
Quoted 9 lines · Janis Schoetterl-Glausch
KVM on s390 needs a mechanism to do accesses to guest memory that honors storage key protection. __copy_from/to_user_with_key is implemented by introducing raw_copy_from/to_user_with_key.
Since the existing uaccess implementation on s390 makes use of move instructions that support having an additional access key supplied, we can implement raw_copy_from/to_user_with_key by enhancing the existing implementation.
Quoted 7 lines
Signed-off-by Janis Schoetterl-Glausch <[email protected]>---
This works for us and compiles on other architectures (tested x86). The patch only implements __copy_from/to_user_with_key, since those are the ones we actually need. On other architectures those functions don't exists, but they aren't used either, so it's not a problem.
Adding an API where only underscored function names are to be used can be considered suboptimal.
Quoted 2 lines
Should we also implement single and no underscore variants? Why? Completeness?
Please make this _fully_ symmetrical to the existing copy_to/from_user() implementations, like I tried to say several times. Maybe I wasn't clear enough about this. Also the default implementation - that is if an architecture makes use of copy_to_user_key() without providing a raw_copy_from_user_key() implementation - should fallback to regular copy_to_user() semantics, like I tried to outline with the ifndef example of raw_copy_from_user_key() previously.
Furthermore this should be splitted into two patches: one which adds the common code infrastructure, like described above; and a second patch which adds the actual s390 architecture backend/override.
The patches should contain a _detailed_ description why the first patch, aka API, should probably be in common code (staying in sync with code instrumentation, etc.); and of course it should contain enough information for people not familiar with s390's storage keys so they can figure out what this is about.
Hopefully we get some feedback and either this is acceptable for common code one way or the other, or we have to maintain this on our own, and get the additional maintenance cost for free.
Please make sure to add Al Viro, Kees Cook, Arnd Bergmann, and Andrew Morton to cc on your next version, so we hopefully come to a conclusion and can move on.
Re: [RFC PATCH] uaccess: Add mechanism for key checked access to user memory
Quoted 24 lines · Heiko Carstens
Quoted 9 lines · Janis Schoetterl-Glausch
KVM on s390 needs a mechanism to do accesses to guest memory that honors storage key protection. __copy_from/to_user_with_key is implemented by introducing raw_copy_from/to_user_with_key.
Since the existing uaccess implementation on s390 makes use of move instructions that support having an additional access key supplied, we can implement raw_copy_from/to_user_with_key by enhancing the existing implementation.Quoted 7 lines
Signed-off-by Janis Schoetterl-Glausch <[email protected]>---
This works for us and compiles on other architectures (tested x86). The patch only implements __copy_from/to_user_with_key, since those are the ones we actually need. On other architectures those functions don't exists, but they aren't used either, so it's not a problem.
Adding an API where only underscored function names are to be used can be considered suboptimal.
Quoted 2 lines
Should we also implement single and no underscore variants? Why? Completeness?
Quoted 7 lines
Please make this _fully_ symmetrical to the existing copy_to/from_user() implementations, like I tried to say several times. Maybe I wasn't clear enough about this. Also the default implementation - that is if an architecture makes use of
copy_to_user_key()without providing araw_copy_from_user_key()implementation - should fallback to regularcopy_to_user()semantics, like I tried to outline with the ifndef example ofraw_copy_from_user_key()previously.
That does help. One thing I'm still confused about is the rational for the default implementation.
Are you suggesting that copy_from/to_user be implemented in terms of copy_from/to_user_with_key? I didn't think so, even tho you said something along those lines, because I assumed you were referring to the architecture specific implementations for copy_from/to_user, since we weren't talking about common code changes back then and Christian's suggestion didn't feature it either.
When you say "fully symmetrical" do you mean all functions that wrap architecture defined access to user space:__copy_from_user_inatomic__copy_from_user__copy_to_user_inatomic__copy_to_user_copy_from_user_copy_to_usercopy_from_usercopy_to_user__copy_from_user_inatomic_nocachecopy_struct_from_usercopy_from_user_nofaultcopy_to_user_nofaultstrncpy_from_user_nofaultstrnlen_user_nofault
Quoted 11 lines
Furthermore this should be splitted into two patches: one which adds the common code infrastructure, like described above; and a second patch which adds the actual s390 architecture backend/override.
The patches should contain a _detailed_ description why the first patch, aka API, should probably be in common code (staying in sync with code instrumentation, etc.); and of course it should contain enough information for people not familiar with s390's storage keys so they can figure out what this is about.
Quoted 7 lines
Hopefully we get some feedback and either this is acceptable for common code one way or the other, or we have to maintain this on our own, and get the additional maintenance cost for free.
Please make sure to add Al Viro, Kees Cook, Arnd Bergmann, and Andrew Morton to cc on your next version, so we hopefully come to a conclusion and can move on.
Thanks, will do.
Heiko Carstens
maintainerRe: [RFC PATCH] uaccess: Add mechanism for key checked access to user memory
Quoted 10 lines
Quoted 7 lines
Please make this _fully_ symmetrical to the existing copy_to/from_user() implementations, like I tried to say several times. Maybe I wasn't clear enough about this. Also the default implementation - that is if an architecture makes use of
copy_to_user_key()without providing araw_copy_from_user_key()implementation - should fallback to regularcopy_to_user()semantics, like I tried to outline with the ifndef example ofraw_copy_from_user_key()previously.That does help. One thing I'm still confused about is the rational for the default implementation.
This is to avoid link errors, and potentially having something that works everywhere without having to add ifdefs everywhere in case this needs to be used in common code.
Again: this is just a proposal, nothing else.
Quoted 6 lines
Are you suggesting that copy_from/to_user be implemented in terms of copy_from/to_user_with_key? I didn't think so, even tho you said something along those lines, because I assumed you were referring to the architecture specific implementations for copy_from/to_user, since we weren't talking about common code changes back then and Christian's suggestion didn't feature it either.
Quoted 16 lines
When you say "fully symmetrical" do you mean all functions that wrap architecture defined access to user space:
__copy_from_user_inatomic__copy_from_user__copy_to_user_inatomic__copy_to_user_copy_from_user_copy_to_usercopy_from_usercopy_to_user__copy_from_user_inatomic_nocachecopy_struct_from_usercopy_from_user_nofaultcopy_to_user_nofaultstrncpy_from_user_nofaultstrnlen_user_nofault
I meant something like below - not even compile tested. It is missing any comments, commit message and sanity checks. That's up to you.
Patch is on top of your patch, and of course needs to be splitted.
arch/s390/include/asm/uaccess.h +10 -8
@@ -33,31 +33,33 @@ static inline int __range_ok(unsigned long addr, unsigned long size)#define access_ok (addr, size) __access_ok(addr, size) -#define raw_copy_from_user_with_key raw_copy_from_user_with_key +#define raw_copy_from_user_key raw_copy_from_user_keyunsigned long __must_check -raw_copy_from_user_with_key (void *to,const void __user *from,unsigned long n, -unsigned long key); +raw_copy_from_user_key (void *to,const void __user *from,unsigned long n, +unsigned long key); -#define raw_copy_to_user_with_key raw_copy_to_user_with_key +#define raw_copy_to_user_key raw_copy_to_user_keyunsigned long __must_check -raw_copy_to_user_with_key (void __user *to,const void *from,unsigned long n, -unsigned long key); +raw_copy_to_user_key (void __user *to,const void *from,unsigned long n, +unsigned long key);static __always_inline unsigned long __must_check raw_copy_from_user (void *to,const void __user *from,unsigned long n) { -return raw_copy_from_user_with_key (to, from, n,0 ); +return raw_copy_from_user_key (to, from, n,0 ); }static __always_inline unsigned long __must_check raw_copy_to_user (void __user *to,const void *from,unsigned long n) { -return raw_copy_to_user_with_key (to, from, n,0 ); +return raw_copy_to_user_key (to, from, n,0 ); }#ifndef CONFIG_KASAN #define INLINE_COPY_FROM_USER #define INLINE_COPY_TO_USER +#define INLINE_COPY_FROM_USER_KEY +#define INLINE_COPY_TO_USER_KEY #endif int __put_user_bad (void ) __attribute__((noreturn));
arch/s390/lib/uaccess.c +15 -15
@@ -59,7 +59,7 @@ static inline int copy_with_mvcos(void)#endif static inline unsigned long copy_from_user_mvcos (void *x,const void __user *ptr, -unsigned long size,u8 key) +unsigned long size,unsigned long key) {unsigned long tmp1, tmp2;union oac spec = {
@@ -96,7 +96,7 @@ static inline unsigned long copy_from_user_mvcos(void *x, const void __user *ptr }static inline unsigned long copy_from_user_mvcp (void *x,const void __user *ptr, -unsigned long size,u8 key) +unsigned long size,unsigned long key) {unsigned long tmp1, tmp2;
@@ -130,17 +130,17 @@ static inline unsigned long copy_from_user_mvcp(void *x, const void __user *ptr,return size; } -unsigned long raw_copy_from_user_with_key (void *to,const void __user *from, -unsigned long n,unsigned long key) +unsigned long raw_copy_from_user_key (void *to,const void __user *from, +unsigned long n,unsigned long key) {if (copy_with_mvcos ()) -return copy_from_user_mvcos (to, from, n, (u8 )key); -return copy_from_user_mvcp (to, from, n, (u8 )key); +return copy_from_user_mvcos (to, from, n, key); +return copy_from_user_mvcp (to, from, n, key); } -EXPORT_SYMBOL (raw_copy_from_user_with_key); +EXPORT_SYMBOL (raw_copy_from_user_key); -inline unsigned long copy_to_user_mvcos (void __user *ptr,const void *x, -unsigned long size,u8 key) +static inline unsigned long copy_to_user_mvcos (void __user *ptr,const void *x, +unsigned long size,unsigned long key) {unsigned long tmp1, tmp2;union oac spec = {
@@ -177,7 +177,7 @@ inline unsigned long copy_to_user_mvcos(void __user *ptr, const void *x, }static inline unsigned long copy_to_user_mvcs (void __user *ptr,const void *x, -unsigned long size,u8 key) +unsigned long size,unsigned long key) {unsigned long tmp1, tmp2;
@@ -211,14 +211,14 @@ static inline unsigned long copy_to_user_mvcs(void __user *ptr, const void *x,return size; } -unsigned long raw_copy_to_user_with_key (void __user *to,const void *from, -unsigned long n,unsigned long key) +unsigned long raw_copy_to_user_key (void __user *to,const void *from, +unsigned long n,unsigned long key) {if (copy_with_mvcos ()) -return copy_to_user_mvcos (to, from, n, (u8 )key); -return copy_to_user_mvcs (to, from, n, (u8 )key); +return copy_to_user_mvcos (to, from, n, key); +return copy_to_user_mvcs (to, from, n, key); } -EXPORT_SYMBOL (raw_copy_to_user_with_key); +EXPORT_SYMBOL (raw_copy_to_user_key);static inline unsigned long clear_user_mvcos (void __user *to,unsigned long size) {
include/linux/uaccess.h +75 -28
121 lines not on this page · raw message
lib/usercopy.c +33 -0
@@ -37,6 +37,39 @@ unsigned long _copy_to_user(void __user *to, const void *from, unsigned long n)EXPORT_SYMBOL (_copy_to_user);#endif +#ifndef INLINE_COPY_FROM_USER_KEY +unsigned long _copy_from_user_key (void *to,const void __user *from, +unsigned long n,unsigned long key) +{ +unsigned long res = n; +might_fault (); +if (!should_fail_usercopy () &&likely (access_ok (from, n))) { +instrument_copy_from_user (to, from, n); + res =raw_copy_from_user_key (to, from, n, key); + } +if (unlikely (res)) +memset (to + (n - res),0 , res); +return res; +} +EXPORT_SYMBOL (_copy_from_user_key); +#endif + +#ifndef INLINE_COPY_TO_USER_KEY +unsigned long _copy_to_user_key (void __user *to,const void *from, +unsigned long n,unsigned long key) +{ +might_fault (); +if (should_fail_usercopy ()) +return n; +if (likely (access_ok (to, n))) { +instrument_copy_to_user (to, from, n); + n =raw_copy_to_user_key (to, from, n, key); + } +return n; +} +EXPORT_SYMBOL (_copy_to_user_key); +#endif +/** * check_zeroed_user: check if a userspace buffer only contains zero bytes * @from: Source address, in userspace.
RFC PATCH 2/10 KVM: s390: Honor storage keys when accessing guest memory
In reply to Janis Schoetterl-GlauschStorage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of access_guest which has been renamed to access_guest_with_key.
Accesses via access_guest_real should not be key checked.
For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.
--- arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +- 6 files changed, 241 insertions(+), 31 deletions(-)
arch/s390/include/asm/ctl_reg.h +2 -0
@@ -12,6 +12,8 @@#define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10)#define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39)#define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49)#define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50)#define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)
arch/s390/include/asm/page.h +2 -0
@@ -20,6 +20,8 @@#define PAGE_SIZE _PAGE_SIZE#define PAGE_MASK _PAGE_MASK#define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9#define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4)#define HPAGE_SHIFT 20
arch/s390/kvm/gaccess.c +162 -12
268 lines not on this page · raw message
arch/s390/kvm/gaccess.h +67 -11
130 lines not on this page · raw message
arch/s390/kvm/intercept.c +6 -6
@@ -331,18 +331,18 @@ static int handle_mvpg_pei(struct kvm_vcpu *vcpu)kvm_s390_get_regs_rre (vcpu, ®1, ®2); -/* Make sure that the source is paged-in */ - rc =guest_translate_address (vcpu, vcpu->run->s.regs.gprs[reg2], - reg2, &srcaddr,GACC_FETCH ); +/* Ensure that the source is paged-in, no actual access -> no key checking */ + rc =guest_translate_address_with_key (vcpu, vcpu->run->s.regs.gprs[reg2], + reg2, &srcaddr,GACC_FETCH ,0 );if (rc)return kvm_s390_inject_prog_cond (vcpu, rc); rc =kvm_arch_fault_in_page (vcpu, srcaddr,0 );if (rc !=0 )return rc; -/* Make sure that the destination is paged-in */ - rc =guest_translate_address (vcpu, vcpu->run->s.regs.gprs[reg1], - reg1, &dstaddr,GACC_STORE ); +/* Ensure that the source is paged-in, no actual access -> no key checking */ + rc =guest_translate_address_with_key (vcpu, vcpu->run->s.regs.gprs[reg1], + reg1, &dstaddr,GACC_STORE ,0 );if (rc)return kvm_s390_inject_prog_cond (vcpu, rc); rc =kvm_arch_fault_in_page (vcpu, dstaddr,1 );
arch/s390/kvm/kvm-s390.c +2 -2
@@ -4750,7 +4750,7 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,case KVM_S390_MEMOP_LOGICAL_READ :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_FETCH ); + mop->size,GACC_FETCH ,0 );break ; } r =read_guest (vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size);
@@ -4762,7 +4762,7 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,case KVM_S390_MEMOP_LOGICAL_WRITE :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_STORE ); + mop->size,GACC_STORE ,0 );break ; }if (copy_from_user (tmpbuf, uaddr, mop->size)) {
Signature · 1 line
2.32.0
Re: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Quoted 14 lines · Janis Schoetterl-Glausch
Storage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of
access_guestwhich has been renamed toaccess_guest_with_key.
Accesses viaaccess_guest_realshould not be key checked.For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.
Quoted 1 line
Signed-off-by Janis Schoetterl-Glausch <[email protected]>
Once you've fixed my nits:
Quoted 102 lines
--- arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +- 6 files changed, 241 insertions(+), 31 deletions(-)arch/s390/include/asm/ctl_reg.h +2
-0@@ -12,6 +12,8 @@#define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10)#define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39)#define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49)#define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50)#define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)arch/s390/include/asm/page.h +2
-0@@ -20,6 +20,8 @@#define PAGE_SIZE _PAGE_SIZE#define PAGE_MASK _PAGE_MASK#define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9#define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4)#define HPAGE_SHIFT 20arch/s390/kvm/gaccess.c +52
-0@@ -10,6 +10,7 @@#include <linux/mm_types.h> #include <linux/err.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/gmap.h> #include "kvm-s390.h" @@ -794,6 +795,79 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu,return 1 ; } +static bool fetch_prot_override_applicable (struct kvm_vcpu *vcpu,enum gacc_mode mode, +union asce asce) +{ +psw_t *psw = &vcpu->arch.sie_block->gpsw; +unsigned long override; + +if (mode ==GACC_FETCH || mode ==GACC_IFETCH ) { +/* check if fetch protection override enabled */ + override = vcpu->arch.sie_block->gcr[0 ]; + override &=CR0_FETCH_PROTECTION_OVERRIDE ; +/* not applicable if subject to DAT && private space */ + override = override && !(psw_bits (*psw).dat && asce.p); +return override; + } +return false; +} + +static bool fetch_prot_override_applies (unsigned long ga,unsigned int len) +{ +return ga <2048 && ga + len <=2048 ; +} + +static bool storage_prot_override_applicable (struct kvm_vcpu *vcpu) +{ +/* check if storage protection override enabled */ +return vcpu->arch.sie_block->gcr[0 ] &CR0_STORAGE_PROTECTION_OVERRIDE ; +} + +static bool storage_prot_override_applies (char access_control) +{ +/* matches special storage protection override key (9) -> allow */ +return access_control ==PAGE_SPO_ACC ; +} + +static int vcpu_check_access_key (struct kvm_vcpu *vcpu,char access_key, +enum gacc_mode mode,union asce asce,gpa_t gpa, +unsigned long ga,unsigned int len) +{ +unsigned char storage_key, access_control; +unsigned long hva; +int r; + +/* access key 0 matches any storage key -> allow */ +if (access_key ==0 ) +return 0 ; +/* +* caller needs to ensure that gfn is accessible, so we can +* assume that this cannot fail +*/ + hva =gfn_to_hva (vcpu->kvm,gpa_to_gfn (gpa)); +mmap_read_lock (current->mm);
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 858
Quoted 10 lines
arch/s390/kvm/gaccess.c +10
-0+ r =get_guest_storage_key (current->mm, hva, &storage_key); +mmap_read_unlock (current->mm); +if (r) +return r; + access_control =FIELD_GET (_PAGE_ACC_BITS, storage_key); +/* access key matches storage key -> allow */ +if (access_control == access_key) +return 0 ; +if (mode ==GACC_FETCH || mode ==GACC_IFETCH ) { +/* mismatching keys, no fetch protection -> allowed */
we want to fetch and fetch protection is off -> allow access
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 862
Quoted 4 lines
arch/s390/kvm/gaccess.c +4
-0+if (!(storage_key & _PAGE_FP_BIT)) +return 0 ; +if (fetch_prot_override_applicable (vcpu, mode, asce)) +if (fetch_prot_override_applies (ga, len))
Personally I'd prefer a "&&" at the end of the first if and then a \n
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 869
Quoted 7 lines
arch/s390/kvm/gaccess.c +7
-0+return 0 ; + } +if (storage_prot_override_applicable (vcpu)) +if (storage_prot_override_applies (access_control)) +return 0 ; +return PGM_PROTECTION ; +}
Everything above looks like I'd expect it to
Quoted 47 lines
arch/s390/kvm/gaccess.c +16
-3+/** * guest_range_to_gpas() - Calculate guest physical addresses of page fragments * covering a logical range @@ -804,6 +878,7 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu,* @len: length of range in bytes * @asce: address-space-control element to use for translation * @mode: access mode +* @access_key: access key to mach the range's storage keys against * * Translate a logical range to a series of guest absolute addresses, * such that the concatenation of page fragments starting at each gpa make up @@ -830,7 +905,8 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu,*/ static int guest_range_to_gpas (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,unsigned long *gpas,unsigned long len, -const union asce asce,enum gacc_mode mode) +const union asce asce,enum gacc_mode mode, +char access_key) {psw_t *psw = &vcpu->arch.sie_block->gpsw;unsigned int offset =offset_in_page (ga);@@ -857,6 +933,10 @@ static int guest_range_to_gpas(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, }if (rc)return trans_exc (vcpu, rc, ga, ar, mode, prot); + rc =vcpu_check_access_key (vcpu, access_key, mode, asce, gpa, ga, + fragment_len); +if (rc) +return trans_exc (vcpu, rc, ga, ar, mode,PROT_TYPE_KEYC );if (gpas) *gpas++ = gpa; offset =0 ;@@ -880,16 +960,50 @@ static int access_guest_page(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,return rc; } -int access_guest (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data, -unsigned long len,enum gacc_mode mode) +static int +access_guest_page_with_key (struct kvm *kvm,enum gacc_mode mode,gpa_t gpa, +void *data,unsigned int len,char key) +{ +struct kvm_memory_slot *slot; +bool writable; +gfn_t gfn; +hva_t hva;
arch/s390/kvm/gaccess.c static int access_guest_page(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa, · line 980
Quoted 10 lines
arch/s390/kvm/gaccess.c +10
-0+int rc; + + gfn = gpa >>PAGE_SHIFT ; + slot =gfn_to_memslot (kvm, gfn); + hva =gfn_to_hva_memslot_prot (slot, gfn, &writable); + +if (kvm_is_error_hva (hva)) +return PGM_ADDRESSING ; +if (!writable && mode ==GACC_STORE ) +return -EOPNOTSUPP ;
/* We don't support ro memslots so this should suffice */
Quoted 30 lines
arch/s390/kvm/gaccess.c +18
-0+ hva +=offset_in_page (gpa); +if (mode ==GACC_STORE ) + rc =__copy_to_user_with_key ((void __user *)hva, data, len, key); +else + rc =__copy_from_user_with_key (data, (void __user *)hva, len, key); +if (rc) +return PGM_PROTECTION ; +if (mode ==GACC_STORE ) +mark_page_dirty_in_slot (kvm, slot, gfn); +return 0 ; +} + +int access_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar, +void *data,unsigned long len,enum gacc_mode mode, +char access_key) {psw_t *psw = &vcpu->arch.sie_block->gpsw;unsigned long nr_pages, idx;unsigned long gpa_array[2 ];unsigned int fragment_len;unsigned long *gpas; +enum prot_type prot;int need_ipte_lock;union asce asce; +bool try_storage_prot_override; +bool try_fetch_prot_override;int rc;if (!len)
arch/s390/kvm/gaccess.c int access_guest(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, void *data, · line 911
Quoted 10 lines
arch/s390/kvm/gaccess.c +2
-2@@ -904,16 +1018,37 @@ int access_guest(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, void *data, gpas =vmalloc (array_size (nr_pages,sizeof (unsigned long )));if (!gpas)return -ENOMEM ; + try_fetch_prot_override =fetch_prot_override_applicable (vcpu, mode, asce); + try_storage_prot_override =storage_prot_override_applicable (vcpu); need_ipte_lock =psw_bits (*psw).dat && !asce.r;if (need_ipte_lock)ipte_lock (vcpu); - rc =guest_range_to_gpas (vcpu, ga, ar, gpas, len, asce, mode); -for (idx =0 ; idx < nr_pages && !rc; idx++) {
/*
We'll do an actual access via the mv instruction which will return access errors to us so we don't need to check here. */
Quoted 114 lines
arch/s390/kvm/gaccess.c +43
-7+ rc =guest_range_to_gpas (vcpu, ga, ar, gpas, len, asce, mode,0 ); +if (rc) + goto out_unlock; +for (idx =0 ; idx < nr_pages; idx++) { fragment_len =min (PAGE_SIZE -offset_in_page (gpas[idx]), len); - rc =access_guest_page (vcpu->kvm, mode, gpas[idx], data, fragment_len); +if (try_fetch_prot_override &&fetch_prot_override_applies (ga, fragment_len)) { + rc =access_guest_page (vcpu->kvm, mode, gpas[idx], + data, fragment_len); + }else { + rc =access_guest_page_with_key (vcpu->kvm, mode, gpas[idx], + data, fragment_len, access_key); + } +if (rc ==PGM_PROTECTION && try_storage_prot_override) + rc =access_guest_page_with_key (vcpu->kvm, mode, gpas[idx], + data, fragment_len,PAGE_SPO_ACC ); +if (rc ==PGM_PROTECTION ) + prot =PROT_TYPE_KEYC ; +if (rc) +break ; len -= fragment_len; data += fragment_len; + ga =kvm_s390_logical_to_effective (vcpu, ga + fragment_len); } +if (rc >0 ) + rc =trans_exc (vcpu, rc, ga,0 , mode, prot); +out_unlock:if (need_ipte_lock)ipte_unlock (vcpu);if (nr_pages >ARRAY_SIZE (gpa_array))@@ -940,12 +1075,13 @@ int access_guest_real(struct kvm_vcpu *vcpu, unsigned long gra, }/** -* guest_translate_address - translate guest logical into guest absolute address +* guest_translate_address_with_key - translate guest logical into guest absolute address * @vcpu: virtual cpu * @gva: Guest virtual address * @ar: Access register * @gpa: Guest physical address * @mode: Translation access mode +* @access_key: access key to mach the storage key with * * Parameter semantics are the same as the ones from guest_translate. * The memory contents at the guest address are not changed. @@ -953,8 +1089,9 @@ int access_guest_real(struct kvm_vcpu *vcpu, unsigned long gra,* Note: The IPTE lock is not taken during this function, so the caller * has to take care of this. */ -int guest_translate_address (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, -unsigned long *gpa,enum gacc_mode mode) +int guest_translate_address_with_key (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, +unsigned long *gpa,enum gacc_mode mode, +char access_key) {union asce asce;int rc;@@ -963,7 +1100,17 @@ int guest_translate_address(struct kvm_vcpu *vcpu, unsigned long gva, u8 ar, rc =get_vcpu_asce (vcpu, &asce, gva, ar, mode);if (rc)return rc; -return guest_range_to_gpas (vcpu, gva, ar, gpa,1 , asce, mode); +return guest_range_to_gpas (vcpu, gva, ar, gpa,1 , asce, mode, + access_key); +} + +int guest_translate_address (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, +unsigned long *gpa,enum gacc_mode mode) +{ +char access_key =psw_bits (vcpu->arch.sie_block->gpsw).key; + +return guest_translate_address_with_key (vcpu, gva, ar, gpa, mode, + access_key); }/** @@ -973,9 +1120,11 @@ int guest_translate_address(struct kvm_vcpu *vcpu, unsigned long gva, u8 ar,* @ar: Access register * @length: Length of test range * @mode: Translation access mode +* @access_key: access key to mach the storage keys with */ int check_gva_range (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, -unsigned long length,enum gacc_mode mode) +unsigned long length,enum gacc_mode mode, +char access_key) {union asce asce;int rc =0 ;@@ -984,7 +1133,8 @@ int check_gva_range(struct kvm_vcpu *vcpu, unsigned long gva, u8 ar,if (rc)return rc;ipte_lock (vcpu); - rc =guest_range_to_gpas (vcpu, gva, ar,NULL , length, asce, mode); + rc =guest_range_to_gpas (vcpu, gva, ar,NULL , length, asce, mode, + access_key);ipte_unlock (vcpu);return rc;arch/s390/kvm/gaccess.h +5
-0@@ -186,24 +186,32 @@ enum gacc_mode { GACC_IFETCH, }; +int guest_translate_address_with_key (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, +unsigned long *gpa,enum gacc_mode mode, +char access_key); +int guest_translate_address (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar,unsigned long *gpa,enum gacc_mode mode); +
arch/s390/kvm/gaccess.h enum gacc_mode { · line 202
Quoted 10 lines
arch/s390/kvm/gaccess.h +5
-3int check_gva_range (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, -unsigned long length,enum gacc_mode mode); +unsigned long length,enum gacc_mode mode, +char access_key); -int access_guest (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data, -unsigned long len,enum gacc_mode mode); +int access_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar, +void *data,unsigned long len,enum gacc_mode mode, +char access_key);
Normally we group them without \n.
Yes this was already inconsistent before you added your changes :)
Quoted 166 lines
arch/s390/kvm/gaccess.h +57
-8int access_guest_real (struct kvm_vcpu *vcpu,unsigned long gra,void *data,unsigned long len,enum gacc_mode mode);/** -* write_guest - copy data from kernel space to guest space +* write_guest_with_key - copy data from kernel space to guest space * @vcpu: virtual cpu * @ga: guest address * @ar: access register * @data: source address in kernel space * @len: number of bytes to copy +* @access_key: access key the storage key needs to match * * Copy @len bytes from @data (kernel space) to @ga (guest address). * In order to copy data to guest space the PSW of the vcpu is inspected: @@ -214,8 +222,8 @@ int access_guest_real(struct kvm_vcpu *vcpu, unsigned long gra,* The addressing mode of the PSW is also inspected, so that address wrap * around is taken into account for 24-, 31- and 64-bit addressing mode, * if the to be copied data crosses page boundaries in guest address space. -* In addition also low address and DAT protection are inspected before -* copying any data (key protection is currently not implemented). +* In addition low address, DAT and key protection checks are performed before +* copying any data. * * This function modifies the 'struct kvm_s390_pgm_info pgm' member of @vcpu. * In case of an access exception (e.g. protection exception) pgm will contain @@ -243,10 +251,53 @@ int access_guest_real(struct kvm_vcpu *vcpu, unsigned long gra,* if data has been changed in guest space in case of an exception. */ static inline __must_check +int write_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar, +void *data,unsigned long len,char access_key) +{ +return access_guest_with_key (vcpu, ga, ar, data, len,GACC_STORE , + access_key); +} + +/** +* write_guest - copy data from kernel space to guest space +* @vcpu: virtual cpu +* @ga: guest address +* @ar: access register +* @data: source address in kernel space +* @len: number of bytes to copy +* +* The behaviour of write_guest is identical to write_guest_with_key, except +* that the PSW access key is used instead of an explicit argument. +*/ +static inline __must_check int write_guest (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data,unsigned long len) { -return access_guest (vcpu, ga, ar, data, len,GACC_STORE ); +char access_key =psw_bits (vcpu->arch.sie_block->gpsw).key; + +return write_guest_with_key (vcpu, ga, ar, data, len, access_key); +} + +/** +* read_guest_with_key - copy data from guest space to kernel space +* @vcpu: virtual cpu +* @ga: guest address +* @ar: access register +* @data: destination address in kernel space +* @len: number of bytes to copy +* @access_key: access key the storage key needs to match +* +* Copy @len bytes from @ga (guest address) to @data (kernel space). +* +* The behaviour of read_guest_with_key is identical to write_guest_with_key, +* except that data will be copied from guest space to kernel space. +*/ +static inline __must_check +int read_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar, +void *data,unsigned long len,char access_key) +{ +return access_guest_with_key (vcpu, ga, ar, data, len,GACC_FETCH , + access_key); }/** @@ -259,14 +310,16 @@ int write_guest(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, void *data,* * Copy @len bytes from @ga (guest address) to @data (kernel space). * -* The behaviour of read_guest is identical to write_guest, except that -* data will be copied from guest space to kernel space. +* The behaviour of read_guest is identical to read_guest_with_key, except +* that the PSW access key is used instead of an explicit argument. */ static inline __must_check int read_guest (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data,unsigned long len) { -return access_guest (vcpu, ga, ar, data, len,GACC_FETCH ); +char access_key =psw_bits (vcpu->arch.sie_block->gpsw).key; + +return read_guest_with_key (vcpu, ga, ar, data, len, access_key); }/** @@ -287,7 +340,10 @@ static inline __must_checkint read_guest_instr (struct kvm_vcpu *vcpu,unsigned long ga,void *data,unsigned long len) { -return access_guest (vcpu, ga,0 , data, len,GACC_IFETCH ); +char access_key =psw_bits (vcpu->arch.sie_block->gpsw).key; + +return access_guest_with_key (vcpu, ga,0 , data, len,GACC_IFETCH , + access_key); }/** arch/s390/kvm/intercept.c +6
-6@@ -331,18 +331,18 @@ static int handle_mvpg_pei(struct kvm_vcpu *vcpu)kvm_s390_get_regs_rre (vcpu, ®1, ®2); -/* Make sure that the source is paged-in */ - rc =guest_translate_address (vcpu, vcpu->run->s.regs.gprs[reg2], - reg2, &srcaddr,GACC_FETCH ); +/* Ensure that the source is paged-in, no actual access -> no key checking */ + rc =guest_translate_address_with_key (vcpu, vcpu->run->s.regs.gprs[reg2], + reg2, &srcaddr,GACC_FETCH ,0 );if (rc)return kvm_s390_inject_prog_cond (vcpu, rc); rc =kvm_arch_fault_in_page (vcpu, srcaddr,0 );if (rc !=0 )return rc; -/* Make sure that the destination is paged-in */ - rc =guest_translate_address (vcpu, vcpu->run->s.regs.gprs[reg1], - reg1, &dstaddr,GACC_STORE ); +/* Ensure that the source is paged-in, no actual access -> no key checking */ + rc =guest_translate_address_with_key (vcpu, vcpu->run->s.regs.gprs[reg1], + reg1, &dstaddr,GACC_STORE ,0 );if (rc)return kvm_s390_inject_prog_cond (vcpu, rc); rc =kvm_arch_fault_in_page (vcpu, dstaddr,1 );arch/s390/kvm/kvm-s390.c +2
-2@@ -4750,7 +4750,7 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,case KVM_S390_MEMOP_LOGICAL_READ :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_FETCH ); + mop->size,GACC_FETCH ,0 );break ; } r =read_guest (vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size);@@ -4762,7 +4762,7 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,case KVM_S390_MEMOP_LOGICAL_WRITE :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_STORE ); + mop->size,GACC_STORE ,0 );break ; }if (copy_from_user (tmpbuf, uaddr, mop->size)) {
Christian Borntraeger
maintainerRe: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Am 18.01.22 um 15:38 schrieb Janosch Frank:
[...]
Quoted 3 lines
/*
We'll do an actual access via the mv instruction which will return access errors to us so we don't need to check here. */
Be slightly more verbose I guess. Something like
We'll do an actual access via the mv instruction which will return access errors to us so we don't need to check here. By using key 0 all checks are skipped and no performance overhead occurs.
?
Quoted 1 line
Quoted 1 line
+ rc =
guest_range_to_gpas(vcpu, ga, ar, gpas, len, asce, mode, 0);
Re: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Quoted 8 lines · Christian Borntraeger
Am 18.01.22 um 15:38 schrieb Janosch Frank:
[...]Quoted 3 lines
/*
We'll do an actual access via the mv instruction which will return access errors to us so we don't need to check here. */
Quoted 5 lines
Be slightly more verbose I guess. Something like
We'll do an actual access via the mv instruction which will return access errors to us so we don't need to check here. By using key 0 all checks are skipped and no performance overhead occurs.?
Yes, I'll also mention that we implement storage protection override by retrying.
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
+ rc =
guest_range_to_gpas(vcpu, ga, ar, gpas, len, asce, mode, 0);
Christian Borntraeger
maintainerRe: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
In reply to Janis Schoetterl-GlauschAm 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 128 lines
Storage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of
access_guestwhich has been renamed toaccess_guest_with_key.
Accesses viaaccess_guest_realshould not be key checked.For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.Signed-off-by Janis Schoetterl-Glausch <[email protected]>--- arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +- 6 files changed, 241 insertions(+), 31 deletions(-)arch/s390/include/asm/ctl_reg.h +2
-0@@ -12,6 +12,8 @@#define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10)#define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39)#define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49)#define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50)#define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)arch/s390/include/asm/page.h +2
-0@@ -20,6 +20,8 @@#define PAGE_SIZE _PAGE_SIZE#define PAGE_MASK _PAGE_MASK#define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9#define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4)#define HPAGE_SHIFT 20arch/s390/kvm/gaccess.c +63
-0@@ -10,6 +10,7 @@#include <linux/mm_types.h> #include <linux/err.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/gmap.h> #include "kvm-s390.h" @@ -794,6 +795,79 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu,return 1 ; } +static bool fetch_prot_override_applicable (struct kvm_vcpu *vcpu,enum gacc_mode mode, +union asce asce) +{ +psw_t *psw = &vcpu->arch.sie_block->gpsw; +unsigned long override; + +if (mode ==GACC_FETCH || mode ==GACC_IFETCH ) { +/* check if fetch protection override enabled */ + override = vcpu->arch.sie_block->gcr[0 ]; + override &=CR0_FETCH_PROTECTION_OVERRIDE ; +/* not applicable if subject to DAT && private space */ + override = override && !(psw_bits (*psw).dat && asce.p); +return override; + } +return false; +} + +static bool fetch_prot_override_applies (unsigned long ga,unsigned int len) +{ +return ga <2048 && ga + len <=2048 ; +} + +static bool storage_prot_override_applicable (struct kvm_vcpu *vcpu) +{ +/* check if storage protection override enabled */ +return vcpu->arch.sie_block->gcr[0 ] &CR0_STORAGE_PROTECTION_OVERRIDE ; +} + +static bool storage_prot_override_applies (char access_control) +{ +/* matches special storage protection override key (9) -> allow */ +return access_control ==PAGE_SPO_ACC ; +} + +static int vcpu_check_access_key (struct kvm_vcpu *vcpu,char access_key, +enum gacc_mode mode,union asce asce,gpa_t gpa, +unsigned long ga,unsigned int len) +{ +unsigned char storage_key, access_control; +unsigned long hva; +int r; + +/* access key 0 matches any storage key -> allow */ +if (access_key ==0 ) +return 0 ; +/* +* caller needs to ensure that gfn is accessible, so we can +* assume that this cannot fail +*/ + hva =gfn_to_hva (vcpu->kvm,gpa_to_gfn (gpa)); +mmap_read_lock (current->mm); + r =get_guest_storage_key (current->mm, hva, &storage_key); +mmap_read_unlock (current->mm); +if (r) +return r; + access_control =FIELD_GET (_PAGE_ACC_BITS, storage_key); +/* access key matches storage key -> allow */ +if (access_control == access_key) +return 0 ; +if (mode ==GACC_FETCH || mode ==GACC_IFETCH ) { +/* mismatching keys, no fetch protection -> allowed */ +if (!(storage_key & _PAGE_FP_BIT))
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 869
Quoted 10 lines
arch/s390/kvm/gaccess.c +10
-0+return 0 ; +if (fetch_prot_override_applicable (vcpu, mode, asce)) +if (fetch_prot_override_applies (ga, len)) +return 0 ; + } +if (storage_prot_override_applicable (vcpu)) +if (storage_prot_override_applies (access_control)) +return 0 ; +return PGM_PROTECTION ; +}
This function is just a pre-check (and early-exit) and we do an additional final check in the MVCOS routing later on, correct? It might actually be faster to get rid of this pre-test and simply rely on MVCOS. MVCOS is usually just some cycles while ISKE to read the key is really slow path and take hundreds of cycles. This would even simplify the patch (assuming that we do proper key checking all the time).
Re: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Quoted 130 lines · Christian Borntraeger
Am 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 129 lines
Storage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of
access_guestwhich has been renamed toaccess_guest_with_key.
Accesses viaaccess_guest_realshould not be key checked.For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.Signed-off-by Janis Schoetterl-Glausch <[email protected]>---
arch/s390/include/asm/ctl_reg.h| 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +-6 files changed, 241 insertions(+), 31 deletions(-)arch/s390/include/asm/ctl_reg.h +2
-0@@ -12,6 +12,8 @@ #define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10) #define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39) #define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49) #define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50) #define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)arch/s390/include/asm/page.h +2
-0@@ -20,6 +20,8 @@ #define PAGE_SIZE _PAGE_SIZE #define PAGE_MASK _PAGE_MASK #define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9 #define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4) #define HPAGE_SHIFT 20arch/s390/kvm/gaccess.c +67
-0@@ -10,6 +10,7 @@ #include <linux/mm_types.h> #include <linux/err.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/gmap.h> #include "kvm-s390.h"@@ -794,6 +795,79 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu, return 1; } +static bool fetch_prot_override_applicable(struct kvm_vcpu *vcpu, enum gacc_mode mode, + union asce asce) +{ + psw_t *psw = &vcpu->arch.sie_block->gpsw; + unsigned long override; + + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* check if fetch protection override enabled */ + override = vcpu->arch.sie_block->gcr[0]; + override &= CR0_FETCH_PROTECTION_OVERRIDE; + /* not applicable if subject to DAT && private space */ + override = override && !(psw_bits(*psw).dat && asce.p); + return override; + } + return false; +} + +static bool fetch_prot_override_applies (unsigned long ga,unsigned int len) +{ + return ga < 2048 && ga + len <= 2048; +} + +static bool storage_prot_override_applicable (struct kvm_vcpu *vcpu) +{ + /* check if storage protection override enabled */ + return vcpu->arch.sie_block->gcr[0] & CR0_STORAGE_PROTECTION_OVERRIDE; +} + +static bool storage_prot_override_applies (char access_control) +{ + /* matches special storage protection override key (9) -> allow */ + return access_control == PAGE_SPO_ACC; +} + +static int vcpu_check_access_key (struct kvm_vcpu *vcpu,char access_key, + enum gacc_mode mode, union asce asce, gpa_t gpa, + unsigned long ga, unsigned int len) +{ + unsigned char storage_key, access_control; + unsigned long hva; + int r; + + /* access key 0 matches any storage key -> allow */ + if (access_key == 0) + return 0; + /* + * caller needs to ensure that gfn is accessible, so we can + * assume that this cannot fail + */ + hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(gpa)); + mmap_read_lock(current->mm); + r = get_guest_storage_key(current->mm, hva, &storage_key); + mmap_read_unlock(current->mm); + if (r) + return r; + access_control = FIELD_GET(_PAGE_ACC_BITS, storage_key); + /* access key matches storage key -> allow */ + if (access_control == access_key) + return 0; + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* mismatching keys, no fetch protection -> allowed */ + if (!(storage_key & _PAGE_FP_BIT)) + return 0; + if (fetch_prot_override_applicable(vcpu, mode, asce)) + if (fetch_prot_override_applies(ga, len)) + return 0; + }
Quoted 8 lines
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 869
Quoted 5 lines
arch/s390/kvm/gaccess.c +5
-0+ if (storage_prot_override_applicable(vcpu)) + if (storage_prot_override_applies(access_control)) + return 0; + return PGM_PROTECTION; +}This function is just a pre-check (and early-exit) and we do an additional final check in the MVCOS routing later on, correct? It might actually be faster to get rid of this
No, this exists for those cases that do not do an actual access, that is MEMOPs with the check only flag, as well as the TEST PROTECTION emulation. access_guest_with_key passes key 0 so we take the early return. It's easy to miss so Janosch suggested a comment there.
Quoted 3 lines
pre-test and simply rely on MVCOS. MVCOS is usually just some cycles while ISKE to read the key is really slow path and take hundreds of cycles. This would even simplify the patch (assuming that we do proper key checking all the time).
Christian Borntraeger
maintainerRe: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Am 20.01.22 um 09:11 schrieb Janis Schoetterl-Glausch:
Quoted 140 lines · Christian Borntraeger
Quoted 130 lines
Am 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 129 lines
Storage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of
access_guestwhich has been renamed toaccess_guest_with_key.
Accesses viaaccess_guest_realshould not be key checked.For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.Signed-off-by Janis Schoetterl-Glausch <[email protected]>--- arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +- 6 files changed, 241 insertions(+), 31 deletions(-)arch/s390/include/asm/ctl_reg.h +2
-0@@ -12,6 +12,8 @@ #define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10) #define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39) #define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49) #define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50) #define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)arch/s390/include/asm/page.h +2
-0@@ -20,6 +20,8 @@ #define PAGE_SIZE _PAGE_SIZE #define PAGE_MASK _PAGE_MASK #define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9 #define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4) #define HPAGE_SHIFT 20arch/s390/kvm/gaccess.c +67
-0@@ -10,6 +10,7 @@ #include <linux/mm_types.h> #include <linux/err.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/gmap.h> #include "kvm-s390.h"@@ -794,6 +795,79 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu, return 1; } +static bool fetch_prot_override_applicable(struct kvm_vcpu *vcpu, enum gacc_mode mode, + union asce asce) +{ + psw_t *psw = &vcpu->arch.sie_block->gpsw; + unsigned long override; + + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* check if fetch protection override enabled */ + override = vcpu->arch.sie_block->gcr[0]; + override &= CR0_FETCH_PROTECTION_OVERRIDE; + /* not applicable if subject to DAT && private space */ + override = override && !(psw_bits(*psw).dat && asce.p); + return override; + } + return false; +} + +static bool fetch_prot_override_applies (unsigned long ga,unsigned int len) +{ + return ga < 2048 && ga + len <= 2048; +} + +static bool storage_prot_override_applicable (struct kvm_vcpu *vcpu) +{ + /* check if storage protection override enabled */ + return vcpu->arch.sie_block->gcr[0] & CR0_STORAGE_PROTECTION_OVERRIDE; +} + +static bool storage_prot_override_applies (char access_control) +{ + /* matches special storage protection override key (9) -> allow */ + return access_control == PAGE_SPO_ACC; +} + +static int vcpu_check_access_key (struct kvm_vcpu *vcpu,char access_key, + enum gacc_mode mode, union asce asce, gpa_t gpa, + unsigned long ga, unsigned int len) +{ + unsigned char storage_key, access_control; + unsigned long hva; + int r; + + /* access key 0 matches any storage key -> allow */ + if (access_key == 0) + return 0; + /* + * caller needs to ensure that gfn is accessible, so we can + * assume that this cannot fail + */ + hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(gpa)); + mmap_read_lock(current->mm); + r = get_guest_storage_key(current->mm, hva, &storage_key); + mmap_read_unlock(current->mm); + if (r) + return r; + access_control = FIELD_GET(_PAGE_ACC_BITS, storage_key); + /* access key matches storage key -> allow */ + if (access_control == access_key) + return 0; + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* mismatching keys, no fetch protection -> allowed */ + if (!(storage_key & _PAGE_FP_BIT)) + return 0; + if (fetch_prot_override_applicable(vcpu, mode, asce)) + if (fetch_prot_override_applies(ga, len)) + return 0; + }Quoted 8 lines
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 869
Quoted 5 lines
arch/s390/kvm/gaccess.c +5
-0+ if (storage_prot_override_applicable(vcpu)) + if (storage_prot_override_applies(access_control)) + return 0; + return PGM_PROTECTION; +}This function is just a pre-check (and early-exit) and we do an additional final check in the MVCOS routing later on, correct? It might actually be faster to get rid of this
Quoted 3 lines
No, this exists for those cases that do not do an actual access, that is MEMOPs with the check only flag, as well as the TEST PROTECTION emulation.
access_guest_with_keypasses key 0 so we take the early return. It's easy to miss so Janosch suggested a comment there.
Dont we always call it in guest_range_to_gpas, which is also called for the memory access in access_guest_with_key?
Quoted 5 lines
Quoted 4 lines
pre-test and simply rely on MVCOS. MVCOS is usually just some cycles while ISKE to read the key is really slow path and take hundreds of cycles. This would even simplify the patch (assuming that we do proper key checking all the time).
Re: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Quoted 143 lines · Christian Borntraeger
Am 20.01.22 um 09:11 schrieb Janis Schoetterl-Glausch:
Quoted 140 lines · Christian Borntraeger
Quoted 138 lines
Am 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 124 lines
Storage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of
access_guestwhich has been renamed toaccess_guest_with_key.
Accesses viaaccess_guest_realshould not be key checked.For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.Signed-off-by Janis Schoetterl-Glausch <[email protected]>---
arch/s390/include/asm/ctl_reg.h| 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +-6 files changed, 241 insertions(+), 31 deletions(-)arch/s390/include/asm/ctl_reg.h +2
-0@@ -12,6 +12,8 @@ #define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10) #define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39) #define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49) #define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50) #define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)arch/s390/include/asm/page.h +2
-0@@ -20,6 +20,8 @@ #define PAGE_SIZE _PAGE_SIZE #define PAGE_MASK _PAGE_MASK #define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9 #define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4) #define HPAGE_SHIFT 20arch/s390/kvm/gaccess.c +62
-0@@ -10,6 +10,7 @@ #include <linux/mm_types.h> #include <linux/err.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/gmap.h> #include "kvm-s390.h"@@ -794,6 +795,79 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu, return 1; } +static bool fetch_prot_override_applicable(struct kvm_vcpu *vcpu, enum gacc_mode mode, + union asce asce) +{ + psw_t *psw = &vcpu->arch.sie_block->gpsw; + unsigned long override; + + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* check if fetch protection override enabled */ + override = vcpu->arch.sie_block->gcr[0]; + override &= CR0_FETCH_PROTECTION_OVERRIDE; + /* not applicable if subject to DAT && private space */ + override = override && !(psw_bits(*psw).dat && asce.p); + return override; + } + return false; +} + +static bool fetch_prot_override_applies (unsigned long ga,unsigned int len) +{ + return ga < 2048 && ga + len <= 2048; +} + +static bool storage_prot_override_applicable (struct kvm_vcpu *vcpu) +{ + /* check if storage protection override enabled */ + return vcpu->arch.sie_block->gcr[0] & CR0_STORAGE_PROTECTION_OVERRIDE; +} + +static bool storage_prot_override_applies (char access_control) +{ + /* matches special storage protection override key (9) -> allow */ + return access_control == PAGE_SPO_ACC; +} + +static int vcpu_check_access_key (struct kvm_vcpu *vcpu,char access_key, + enum gacc_mode mode, union asce asce, gpa_t gpa, + unsigned long ga, unsigned int len) +{ + unsigned char storage_key, access_control; + unsigned long hva; + int r; + + /* access key 0 matches any storage key -> allow */ + if (access_key == 0) + return 0; + /* + * caller needs to ensure that gfn is accessible, so we can + * assume that this cannot fail + */ + hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(gpa)); + mmap_read_lock(current->mm); + r = get_guest_storage_key(current->mm, hva, &storage_key); + mmap_read_unlock(current->mm); + if (r) + return r; + access_control = FIELD_GET(_PAGE_ACC_BITS, storage_key); + /* access key matches storage key -> allow */ + if (access_control == access_key) + return 0; + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* mismatching keys, no fetch protection -> allowed */ + if (!(storage_key & _PAGE_FP_BIT))arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 868
Quoted 10 lines
arch/s390/kvm/gaccess.c +10
-0+ return 0; + if (fetch_prot_override_applicable(vcpu, mode, asce)) + if (fetch_prot_override_applies(ga, len)) + return 0; + } + if (storage_prot_override_applicable(vcpu)) + if (storage_prot_override_applies(access_control)) + return 0; + return PGM_PROTECTION; +}This function is just a pre-check (and early-exit) and we do an additional final check in the MVCOS routing later on, correct? It might actually be faster to get rid of this
Quoted 6 lines
Quoted 3 lines
No, this exists for those cases that do not do an actual access, that is MEMOPs with the check only flag, as well as the TEST PROTECTION emulation.
access_guest_with_keypasses key 0 so we take the early return. It's easy to miss so Janosch suggested a comment there.Dont we always call it in
guest_range_to_gpas, which is also called for the memory access inaccess_guest_with_key?
@@ -904,16 +1018,37 @@ int access_guest(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, void *data,
gpas = vmalloc(array_size(nr_pages, sizeof(unsigned long)));
if (!gpas)
return -ENOMEM;
+ try_fetch_prot_override = fetch_prot_override_applicable(vcpu, mode, asce);
+ try_storage_prot_override = storage_prot_override_applicable(vcpu);
need_ipte_lock = psw_bits(*psw).dat && !asce.r;
if (need_ipte_lock)
ipte_lock(vcpu);
- rc = guest_range_to_gpas(vcpu, ga, ar, gpas, len, asce, mode);
- for (idx = 0; idx < nr_pages && !rc; idx++) {
+ rc = guest_range_to_gpas(vcpu, ga, ar, gpas, len, asce, mode, 0);
Yes, but the key is 0 in that case, so we don't do any key checking. ^
Quoted 6 lines
Quoted 6 lines
Quoted 5 lines
pre-test and simply rely on MVCOS. MVCOS is usually just some cycles while ISKE to read the key is really slow path and take hundreds of cycles. This would even simplify the patch (assuming that we do proper key checking all the time).
Christian Borntraeger
maintainerRe: [RFC PATCH v1 02/10] KVM: s390: Honor storage keys when accessing guest memory
Am 20.01.22 um 09:58 schrieb Janis Schoetterl-Glausch:
Quoted 163 lines · Christian Borntraeger
Quoted 149 lines
Am 20.01.22 um 09:11 schrieb Janis Schoetterl-Glausch:
Quoted 140 lines · Christian Borntraeger
Quoted 130 lines
Am 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 129 lines
Storage key checking had not been implemented for instructions emulated by KVM. Implement it by enhancing the functions used for guest access, in particular those making use of
access_guestwhich has been renamed toaccess_guest_with_key.
Accesses viaaccess_guest_realshould not be key checked.For actual accesses, key checking is done by __copy_from/to_user_with_key (which internally uses MVCOS/MVCP/MVCS).
In cases where accessibility is checked without an actual access, this is performed by getting the storage key and checking
if the access key matches.
In both cases, if applicable, storage and fetch protection override are honored.Signed-off-by Janis Schoetterl-Glausch <[email protected]>--- arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/kvm/gaccess.c | 174 +++++++++++++++++++++++++++++--- arch/s390/kvm/gaccess.h | 78 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +-- arch/s390/kvm/kvm-s390.c | 4 +- 6 files changed, 241 insertions(+), 31 deletions(-)arch/s390/include/asm/ctl_reg.h +2
-0@@ -12,6 +12,8 @@ #define CR0_CLOCK_COMPARATOR_SIGN BIT(63 - 10) #define CR0_LOW_ADDRESS_PROTECTION BIT(63 - 35) +#define CR0_FETCH_PROTECTION_OVERRIDE BIT(63 - 38) +#define CR0_STORAGE_PROTECTION_OVERRIDE BIT(63 - 39) #define CR0_EMERGENCY_SIGNAL_SUBMASK BIT(63 - 49) #define CR0_EXTERNAL_CALL_SUBMASK BIT(63 - 50) #define CR0_CLOCK_COMPARATOR_SUBMASK BIT(63 - 52)arch/s390/include/asm/page.h +2
-0@@ -20,6 +20,8 @@ #define PAGE_SIZE _PAGE_SIZE #define PAGE_MASK _PAGE_MASK #define PAGE_DEFAULT_ACC 0 +/* storage-protection override */ +#define PAGE_SPO_ACC 9 #define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4) #define HPAGE_SHIFT 20arch/s390/kvm/gaccess.c +67
-0@@ -10,6 +10,7 @@ #include <linux/mm_types.h> #include <linux/err.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/gmap.h> #include "kvm-s390.h"@@ -794,6 +795,79 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu, return 1; } +static bool fetch_prot_override_applicable(struct kvm_vcpu *vcpu, enum gacc_mode mode, + union asce asce) +{ + psw_t *psw = &vcpu->arch.sie_block->gpsw; + unsigned long override; + + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* check if fetch protection override enabled */ + override = vcpu->arch.sie_block->gcr[0]; + override &= CR0_FETCH_PROTECTION_OVERRIDE; + /* not applicable if subject to DAT && private space */ + override = override && !(psw_bits(*psw).dat && asce.p); + return override; + } + return false; +} + +static bool fetch_prot_override_applies (unsigned long ga,unsigned int len) +{ + return ga < 2048 && ga + len <= 2048; +} + +static bool storage_prot_override_applicable (struct kvm_vcpu *vcpu) +{ + /* check if storage protection override enabled */ + return vcpu->arch.sie_block->gcr[0] & CR0_STORAGE_PROTECTION_OVERRIDE; +} + +static bool storage_prot_override_applies (char access_control) +{ + /* matches special storage protection override key (9) -> allow */ + return access_control == PAGE_SPO_ACC; +} + +static int vcpu_check_access_key (struct kvm_vcpu *vcpu,char access_key, + enum gacc_mode mode, union asce asce, gpa_t gpa, + unsigned long ga, unsigned int len) +{ + unsigned char storage_key, access_control; + unsigned long hva; + int r; + + /* access key 0 matches any storage key -> allow */ + if (access_key == 0) + return 0; + /* + * caller needs to ensure that gfn is accessible, so we can + * assume that this cannot fail + */ + hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(gpa)); + mmap_read_lock(current->mm); + r = get_guest_storage_key(current->mm, hva, &storage_key); + mmap_read_unlock(current->mm); + if (r) + return r; + access_control = FIELD_GET(_PAGE_ACC_BITS, storage_key); + /* access key matches storage key -> allow */ + if (access_control == access_key) + return 0; + if (mode == GACC_FETCH || mode == GACC_IFETCH) { + /* mismatching keys, no fetch protection -> allowed */ + if (!(storage_key & _PAGE_FP_BIT)) + return 0; + if (fetch_prot_override_applicable(vcpu, mode, asce)) + if (fetch_prot_override_applies(ga, len)) + return 0; + }Quoted 8 lines
arch/s390/kvm/gaccess.c static int low_address_protection_enabled(struct kvm_vcpu *vcpu, · line 869
Quoted 5 lines
arch/s390/kvm/gaccess.c +5
-0+ if (storage_prot_override_applicable(vcpu)) + if (storage_prot_override_applies(access_control)) + return 0; + return PGM_PROTECTION; +}This function is just a pre-check (and early-exit) and we do an additional final check in the MVCOS routing later on, correct? It might actually be faster to get rid of this
Quoted 3 lines
No, this exists for those cases that do not do an actual access, that is MEMOPs with the check only flag, as well as the TEST PROTECTION emulation.
access_guest_with_keypasses key 0 so we take the early return. It's easy to miss so Janosch suggested a comment there.Dont we always call it in
guest_range_to_gpas, which is also called for the memory access inaccess_guest_with_key?arch/s390/kvm/gaccess.c +3
-2@@ -904,16 +1018,37 @@ int access_guest(struct kvm_vcpu *vcpu, unsigned long ga, u8 ar, void *data, gpas =vmalloc (array_size (nr_pages,sizeof (unsigned long )));if (!gpas)return -ENOMEM ; + try_fetch_prot_override =fetch_prot_override_applicable (vcpu, mode, asce); + try_storage_prot_override =storage_prot_override_applicable (vcpu); need_ipte_lock =psw_bits (*psw).dat && !asce.r;if (need_ipte_lock)ipte_lock (vcpu); - rc =guest_range_to_gpas (vcpu, ga, ar, gpas, len, asce, mode); -for (idx =0 ; idx < nr_pages && !rc; idx++) { + rc =guest_range_to_gpas (vcpu, ga, ar, gpas, len, asce, mode,0 );
Quoted 1 line
Yes, but the key is 0 in that case, so we don't do any key checking. ^
So yes, we need a comment :-)
RFC PATCH 3/10 KVM: s390: handle_tprot: Honor storage keys
In reply to Janis Schoetterl-GlauschUse the access key operand to check for key protection when translating guest addresses.
Since the translation code checks for accessing exceptions/error hvas, we can remove the check here and simplify the control flow. Keep checking if the memory is read-only even if such memslots are currently not supported.
handle_tprot was the last user of guest_translate_address, so remove it.
--- arch/s390/kvm/gaccess.c | 9 ------ arch/s390/kvm/gaccess.h | 3 -- arch/s390/kvm/priv.c | 66 ++++++++++++++++++++++------------------- 3 files changed, 35 insertions(+), 43 deletions(-)
arch/s390/kvm/gaccess.c +0 -9
@@ -1104,15 +1104,6 @@ int guest_translate_address_with_key(struct kvm_vcpu *vcpu, unsigned long gva, u access_key); } -int guest_translate_address (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar, -unsigned long *gpa,enum gacc_mode mode) -{ -char access_key =psw_bits (vcpu->arch.sie_block->gpsw).key; - -return guest_translate_address_with_key (vcpu, gva, ar, gpa, mode, - access_key); -} -/** * check_gva_range - test a range of guest virtual addresses for accessibility * @vcpu: virtual cpu
arch/s390/kvm/gaccess.h +0 -3
@@ -190,9 +190,6 @@ int guest_translate_address_with_key(struct kvm_vcpu *vcpu, unsigned long gva, u unsigned long *gpa, enum gacc_mode mode, char access_key); -int guest_translate_address (struct kvm_vcpu *vcpu,unsigned long gva, -u8 ar,unsigned long *gpa,enum gacc_mode mode); -int check_gva_range (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar,unsigned long length,enum gacc_mode mode,char access_key);
arch/s390/kvm/priv.c +35 -31
88 lines not on this page · raw message
Signature · 1 line
2.32.0
RFC PATCH 4/10 KVM: s390: selftests: Test TEST PROTECTION emulation
In reply to Janis Schoetterl-GlauschTest the emulation of TEST PROTECTION in the presence of storage keys. Emulation only occurs under certain conditions, one of which is the host page being protected.
Trigger this by protecting the test pages via mprotect.
--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/s390x/tprot.c | 184 ++++++++++++++++++++++ 3 files changed, 186 insertions(+) create mode 100644 tools/testing/selftests/kvm/s390x/tprot.c
tools/testing/selftests/kvm/.gitignore +1 -0
@@ -7,6 +7,7 @@ /s390x/memop /s390x/resets /s390x/sync_regs_test +/s390x/tprot /x86_64/cr4_cpuid_sync_test /x86_64/debug_regs /x86_64/evmcs_test
tools/testing/selftests/kvm/Makefile +1 -0
@@ -109,6 +109,7 @@ TEST_GEN_PROGS_aarch64 += kvm_binary_stats_test TEST_GEN_PROGS_s390x = s390x/memop TEST_GEN_PROGS_s390x += s390x/resets TEST_GEN_PROGS_s390x += s390x/sync_regs_test +TEST_GEN_PROGS_s390x += s390x/tprot TEST_GEN_PROGS_s390x += demand_paging_test TEST_GEN_PROGS_s390x += dirty_log_test TEST_GEN_PROGS_s390x += kvm_create_max_vcpus
tools/testing/selftests/kvm/s390x/tprot.c new file +184 -0
184 lines not on this page · raw message
Signature · 1 line
2.32.0
Janosch Frank
maintainerRe: [RFC PATCH v1 04/10] KVM: s390: selftests: Test TEST PROTECTION emulation
Quoted 62 lines · Janis Schoetterl-Glausch
Test the emulation of TEST PROTECTION in the presence of storage keys. Emulation only occurs under certain conditions, one of which is the host page being protected.
Trigger this by protecting the test pages via mprotect.Signed-off-by Janis Schoetterl-Glausch <[email protected]>--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/s390x/tprot.c | 184 ++++++++++++++++++++++ 3 files changed, 186 insertions(+)create mode 100644
tools/testing/selftests/kvm/s390x/tprot.ctools/testing/selftests/kvm/.gitignore +1
-0@@ -7,6 +7,7 @@ /s390x/memop /s390x/resets /s390x/sync_regs_test +/s390x/tprot /x86_64/cr4_cpuid_sync_test /x86_64/debug_regs /x86_64/evmcs_testtools/testing/selftests/kvm/Makefile +1
-0@@ -109,6 +109,7 @@ TEST_GEN_PROGS_aarch64 += kvm_binary_stats_test TEST_GEN_PROGS_s390x = s390x/memop TEST_GEN_PROGS_s390x += s390x/resets TEST_GEN_PROGS_s390x += s390x/sync_regs_test +TEST_GEN_PROGS_s390x += s390x/tprot TEST_GEN_PROGS_s390x += demand_paging_test TEST_GEN_PROGS_s390x += dirty_log_test TEST_GEN_PROGS_s390x += kvm_create_max_vcpustools/testing/selftests/kvm/s390x/tprot.c new file +19
-0@@ -0,0 +1,184 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Test TEST PROTECTION emulation. +* In order for emulation occur the target page has to be DAT protected in the +* host mappings. Since the page tables are shared, we can use mprotect +* to achieve this. +* +* Copyright IBM Corp. 2021 +*/ + +#include <sys/mman.h> +#include "test_util.h" +#include "kvm_util.h" + +#define PAGE_SHIFT 12 +#define PAGE_SIZE (1 << PAGE_SHIFT) +#define CR0_FETCH_PROTECTION_OVERRIDE (1UL << (63 - 38)) +#define CR0_STORAGE_PROTECTION_OVERRIDE (1UL << (63 - 39)) +
tools/testing/selftests/kvm/s390x/tprot.c line 29
Quoted 10 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+#define VCPU_ID 1 + +static __aligned(PAGE_SIZE) uint8_t pages[2 ][PAGE_SIZE ]; +static uint8_t *const page_store_prot = pages[0 ]; +static uint8_t *const page_fetch_prot = pages[1 ]; + +static int set_storage_key (void *addr,uint8_t key) +{ +int not_mapped =0 ; +
Maybe add a short comment:
Check if address is mapped via lra and set the storage key if it is.
tools/testing/selftests/kvm/s390x/tprot.c line 37
Quoted 8 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +8
-0+ asmvolatile ( +"lra %[addr], 0(0,%[addr])\n" +" jz 0f\n" +" llill %[not_mapped],1\n" +" j 1f\n" +"0: sske %[key], %[addr]\n" +"1:" + : [addr] "+&a" (addr), [not_mapped] "+r" (not_mapped)
Shouldn't this be a "=r" instead of a "+r" for not_mapped?
tools/testing/selftests/kvm/s390x/tprot.c line 48
Quoted 11 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +11
-0+ : [key] "r" (key) + : "cc" + ); +return -not_mapped; +} + +enum permission { +READ_WRITE =0 , +READ =1 , +NONE =2 , +UNAVAILABLE =3 ,
TRANSLATION_NA ?
I'm not completely happy with these names but I've yet to come up with a better naming scheme here.
Quoted 6 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +6
-0+}; + +static enum permission test_protection (void *addr,uint8_t key) +{ +uint64_t mask; +
tools/testing/selftests/kvm/s390x/tprot.c line 64
Quoted 10 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+ asmvolatile ( +"tprot %[addr], 0(%[key])\n" +" ipm %[mask]\n" + : [mask]"=r" (mask) + : [addr]"Q" (*(char *)addr), + [key]"a" (key) + :"cc" + ); + +return (enum permission )mask >>28 ;
You could replace the shift with the "srl" that we normally do.
Quoted 12 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +12
-0+} + +enum stage { +STAGE_END , +STAGE_INIT_SIMPLE , +TEST_SIMPLE , +STAGE_INIT_FETCH_PROT_OVERRIDE , +TEST_FETCH_PROT_OVERRIDE , +TEST_STORAGE_PROT_OVERRIDE , +}; + +struct test {
tools/testing/selftests/kvm/s390x/tprot.c line 86
Quoted 10 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+enum stage stage; +void *addr; +uint8_t key; +enum permission expected; +} tests[] = { +/* Those which result in NONE/UNAVAILABLE will be interpreted by SIE, +* not KVM, but there is no harm in testing them also. +* See Enhanced Suppression-on-Protection Facilities in the +* Interpretive-Execution Mode +*/
Outside of net/ we put the first line on "*" not on "/*"
s/Those which result in/Tests resulting in/ ?
Quoted 18 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +18
-0+ { TEST_SIMPLE, page_store_prot, 0x00, READ_WRITE }, + { TEST_SIMPLE, page_store_prot, 0x10, READ_WRITE }, + { TEST_SIMPLE, page_store_prot, 0x20, READ }, + { TEST_SIMPLE, page_fetch_prot, 0x00, READ_WRITE }, + { TEST_SIMPLE, page_fetch_prot, 0x90, READ_WRITE }, + { TEST_SIMPLE, page_fetch_prot, 0x10, NONE }, + { TEST_SIMPLE, (void *)0x00, 0x10, UNAVAILABLE }, +/* Fetch-protection override */ + { TEST_FETCH_PROT_OVERRIDE, (void *)0x00, 0x10, READ }, + { TEST_FETCH_PROT_OVERRIDE, (void *)2049, 0x10, NONE }, +/* Storage-protection override */ + { TEST_STORAGE_PROT_OVERRIDE, page_fetch_prot, 0x10, READ_WRITE }, + { TEST_STORAGE_PROT_OVERRIDE, page_store_prot, 0x20, READ }, + { TEST_STORAGE_PROT_OVERRIDE, (void *)2049, 0x10, READ_WRITE }, +/* End marker */ + { STAGE_END, 0, 0, 0 }, +}; +
tools/testing/selftests/kvm/s390x/tprot.c line 114
Quoted 10 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+static enum stage perform_next_stage (int *i,bool mapped_0) +{ +enum stage stage = tests[*i].stage; +enum permission result; +bool skip; + +for (; tests[*i].stage == stage; (*i)++) { + skip = tests[*i].addr < (void *)4096 && + !mapped_0 && + tests[*i].expected !=UNAVAILABLE ;
Time for a comment?
tools/testing/selftests/kvm/s390x/tprot.c line 127
Quoted 13 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +13
-0+if (!skip) { + result =test_protection (tests[*i].addr, tests[*i].key); +GUEST_ASSERT_2 (result == tests[*i].expected, *i, result); + } + } +return stage; +} + +static void guest_code (void ) +{ +bool mapped_0; +int i =0 ; +
It's __really__ hard to understand this since the state is changed both by the guest and host. Please add comments to this and maybe also add some to the test struct explaining why you expect the results for each test.
Quoted 58 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +57
-0+GUEST_ASSERT_EQ (set_storage_key (page_store_prot,0x10 ),0 ); +GUEST_ASSERT_EQ (set_storage_key (page_fetch_prot,0x98 ),0 ); +GUEST_SYNC (STAGE_INIT_SIMPLE ); +GUEST_SYNC (perform_next_stage (&i, false)); + +/* Fetch-protection override */ + mapped_0 = !set_storage_key ((void *)0 ,0x98 ); +GUEST_SYNC (STAGE_INIT_FETCH_PROT_OVERRIDE ); +GUEST_SYNC (perform_next_stage (&i, mapped_0)); + +/* Storage-protection override */ +GUEST_SYNC (perform_next_stage (&i, mapped_0)); +} + +#define HOST_SYNC (vmp, stage) \ +({ \ + struct kvm_vm *__vm = (vmp); \ + struct ucall uc; \ + int __stage = (stage); \ + \ + vcpu_run(__vm, VCPU_ID); \ + get_ucall(__vm, VCPU_ID, &uc); \ + if (uc.cmd == UCALL_ABORT) { \ + TEST_FAIL("line %lu: %s, hints: %lu, %lu", uc.args[1], \ + (const char *)uc.args[0], uc.args[2], uc.args[3]); \ + } \ + ASSERT_EQ(uc.cmd, UCALL_SYNC); \ + ASSERT_EQ(uc.args[1], __stage); \ +}) + +int main (int argc,char *argv[]) +{ +struct kvm_vm *vm; +struct kvm_run *run; +vm_vaddr_t guest_0_page; + + vm =vm_create_default (VCPU_ID ,0 , guest_code); + run =vcpu_state (vm,VCPU_ID ); + +HOST_SYNC (vm,STAGE_INIT_SIMPLE ); +mprotect (addr_gva2hva (vm, (vm_vaddr_t )pages),PAGE_SIZE *2 ,PROT_READ ); +HOST_SYNC (vm,TEST_SIMPLE ); + + guest_0_page =vm_vaddr_alloc (vm,PAGE_SIZE ,0 ); +if (guest_0_page !=0 ) +print_skip ("Did not allocate page at 0 for fetch protection override tests" ); +HOST_SYNC (vm,STAGE_INIT_FETCH_PROT_OVERRIDE ); +if (guest_0_page ==0 ) +mprotect (addr_gva2hva (vm, (vm_vaddr_t )0 ),PAGE_SIZE ,PROT_READ ); + run->s.regs.crs[0 ] |=CR0_FETCH_PROTECTION_OVERRIDE ; + run->kvm_dirty_regs =KVM_SYNC_CRS ; +HOST_SYNC (vm,TEST_FETCH_PROT_OVERRIDE ); + + run->s.regs.crs[0 ] |=CR0_STORAGE_PROTECTION_OVERRIDE ; + run->kvm_dirty_regs =KVM_SYNC_CRS ; +HOST_SYNC (vm,TEST_STORAGE_PROT_OVERRIDE ); +}
Re: [RFC PATCH v1 04/10] KVM: s390: selftests: Test TEST PROTECTION emulation
Quoted 43 lines · Janosch Frank
Quoted 42 lines · Janis Schoetterl-Glausch
Test the emulation of TEST PROTECTION in the presence of storage keys. Emulation only occurs under certain conditions, one of which is the host page being protected.
Trigger this by protecting the test pages via mprotect.Signed-off-by Janis Schoetterl-Glausch <[email protected]>---
tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 +tools/testing/selftests/kvm/s390x/tprot.c| 184 ++++++++++++++++++++++3 files changed, 186 insertions(+)create mode 100644
tools/testing/selftests/kvm/s390x/tprot.ctools/testing/selftests/kvm/.gitignore +0
-0@@ -7,6 +7,7 @@/s390x/memop
/s390x/resets
/s390x/sync_regs_test
+/s390x/tprot
/x86_64/cr4_cpuid_sync_test
/x86_64/debug_regs
/x86_64/evmcs_testtools/testing/selftests/kvm/Makefile +0
-0@@ -109,6 +109,7 @@ TEST_GEN_PROGS_aarch64 += kvm_binary_stats_test
TEST_GEN_PROGS_s390x= s390x/memop
TEST_GEN_PROGS_s390x+= s390x/resets
TEST_GEN_PROGS_s390x+= s390x/sync_regs_test
+TEST_GEN_PROGS_s390x += s390x/tprot
TEST_GEN_PROGS_s390x+=demand_paging_test
TEST_GEN_PROGS_s390x+=dirty_log_test
TEST_GEN_PROGS_s390x+=kvm_create_max_vcpustools/testing/selftests/kvm/s390x/tprot.c new file +0
-0
[...]
Quoted 18 lines
tools/testing/selftests/kvm/s390x/tprot.c line 29
Quoted 5 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +5
-0+ +static int set_storage_key (void *addr,uint8_t key) +{ + int not_mapped = 0; +Maybe add a short comment:
Check if address is mapped via lra and set the storage key if it is.Quoted 8 lines
+ asm volatile (
+ "lra %[addr], 0(0,%[addr])\n"
+ " jz 0f\n"
+ " llill %[not_mapped],1\n"
+ " j 1f\n"
+ "0: sske %[key], %[addr]\n"
+ "1:"
+ : [addr] "+&a" (addr), [not_mapped] "+r" (not_mapped)
Quoted 1 line
Shouldn't this be a "=r" instead of a "+r" for
not_mapped?
I don't think so. We only write to it on one code path and the compiler mustn't conclude that it can remove the = 0 assignment because the value gets overwritten anyway.
Initially I tried to implement the function like this:
static int set_storage_key(void *addr, uint8_t key)
{
asm goto ("lra %[addr], 0(0,%[addr])\n\t"
"jnz %l[not_mapped]\n\t"
"sske %[key], %[addr]\n"
: [addr] "+&a" (addr)
: [key] "r" (key)
: "cc", "memory"
: not_mapped
);
return 0;
not_mapped:
return -1;
}Which I think is nicer, but the compiler just optimized that completely away. I have no clue why it (thinks it) is allowed to do that.
Quoted 15 lines
tools/testing/selftests/kvm/s390x/tprot.c line 48
Quoted 12 lines
+ : [key] "r" (key)
+ : "cc"
+ );
+ return -not_mapped;tools/testing/selftests/kvm/s390x/tprot.c new file +7
-0+} + +enum permission { + READ_WRITE = 0, + READ = 1, + NONE = 2, + UNAVAILABLE = 3,
TRANSLATION_NA?
I'm not completely happy with these names but I've yet to come up with a better naming scheme here.
Mentioning translation is a good idea. Don't think there is any harm in using TRANSLATION_NOT_AVAILABLE or TRANSLATION_UNAVAILABLE.
Quoted 11 lines
Quoted 11 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+}; + +static enum permission test_protection (void *addr,uint8_t key) +{ + uint64_t mask; + + asm volatile ( + "tprot %[addr], 0(%[key])\n" + " ipm %[mask]\n" + : [mask] "=r" (mask)
Quoted 8 lines
Quoted 6 lines
+ : [addr] "Q" (*(char *)addr),
+ [key] "a" (key)
+ : "cc"
+ );
+
+ return (enum permission)mask >> 28;You could replace the shift with the "srl" that we normally do.
I prefer keeping the asm as small as possible, C is just so much easier to understand.
[...]
Quoted 2 lines
It's
__really__hard to understand this since the state is changed both by the guest and host. Please add comments to this and maybe also add some to the test struct explaining why you expect the results for each test.
I think I'll concentrate the comments at the tests array so we have one location that lays out the complete logic and then one only has to check if the guest and host match up with that, respectively, instead of having to model their interaction in ones head.
I'll incorporate your other feedback, too.
Thanks!
Claudio Imbrenda
maintainerRe: [RFC PATCH v1 04/10] KVM: s390: selftests: Test TEST PROTECTION emulation
On Fri, 21 Jan 2022 12:03:20 +0100
Janis Schoetterl-Glausch <[email protected]> wrote:
[...]
Quoted 59 lines
Quoted 18 lines
tools/testing/selftests/kvm/s390x/tprot.c line 29
Quoted 5 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +5
-0+ +static int set_storage_key (void *addr,uint8_t key) +{ + int not_mapped = 0; +Maybe add a short comment:
Check if address is mapped via lra and set the storage key if it is.Quoted 8 lines
+ asm volatile (
+ "lra %[addr], 0(0,%[addr])\n"
+ " jz 0f\n"
+ " llill %[not_mapped],1\n"
+ " j 1f\n"
+ "0: sske %[key], %[addr]\n"
+ "1:"
+ : [addr] "+&a" (addr), [not_mapped] "+r" (not_mapped)Quoted 1 line
Shouldn't this be a "=r" instead of a "+r" for
not_mapped?I don't think so. We only write to it on one code path and the compiler mustn't conclude that it can remove the = 0 assignment because the value gets overwritten anyway.
Initially I tried to implement the function like this:
static int
set_storage_key(void *addr, uint8_t key){ asm goto ("lra %[addr], 0(0,%[addr])\n\t" "jnz %l[not_mapped]\n\t" "sske %[key], %[addr]\n" : [addr] "+&a" (addr) : [key] "r" (key) : "cc", "memory" : not_mapped ); return 0; not_mapped: return -1; }Which I think is nicer, but the compiler just optimized that completely away. I have no clue why it (thinks it) is allowed to do that.
Quoted 15 lines
tools/testing/selftests/kvm/s390x/tprot.c line 48
Quoted 12 lines
+ : [key] "r" (key)
+ : "cc"
+ );
+ return -not_mapped;tools/testing/selftests/kvm/s390x/tprot.c new file +7
-0+} + +enum permission { + READ_WRITE = 0, + READ = 1, + NONE = 2, + UNAVAILABLE = 3,
TRANSLATION_NA?
I'm not completely happy with these names but I've yet to come up with a better naming scheme here.
Quoted 2 lines
Mentioning translation is a good idea. Don't think there is any harm in using
TRANSLATION_NOT_AVAILABLEorTRANSLATION_UNAVAILABLE.
it's too long, it actually makes the code harder to read when used
maybe consider something like TRANSL_UNAVAIL as well
Quoted 20 lines
Quoted 11 lines
Quoted 11 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+}; + +static enum permission test_protection (void *addr,uint8_t key) +{ + uint64_t mask; + + asm volatile ( + "tprot %[addr], 0(%[key])\n" + " ipm %[mask]\n" + : [mask] "=r" (mask)Quoted 8 lines
Quoted 6 lines
+ : [addr] "Q" (*(char *)addr),
+ [key] "a" (key)
+ : "cc"
+ );
+
+ return (enum permission)mask >> 28;You could replace the shift with the "srl" that we normally do.
Quoted 1 line
I prefer keeping the asm as small as possible, C is just so much easier to understand.
we use srl everywhere, but I agree that explicitly using C makes it less obscure. and in the end the compiler should generate the same instructions anyway.
my only comment about the above code is that you are casting the uint64_t to enum permission _and then_ shifting. _technically_ it should still work (enums are just ints), but I think it would look cleaner if you write
return (enum permission)(mask >> 28);
Quoted 14 lines
[...]
Quoted 2 lines
It's
__really__hard to understand this since the state is changed both by the guest and host. Please add comments to this and maybe also add some to the test struct explaining why you expect the results for each test.I think I'll concentrate the comments at the tests array so we have one location that lays out the complete logic and then one only has to check if the guest and host match up with that, respectively, instead of having to model their interaction in ones head.
I'll incorporate your other feedback, too.
Thanks!
Re: [RFC PATCH v1 04/10] KVM: s390: selftests: Test TEST PROTECTION emulation
Quoted 64 lines · Claudio Imbrenda
On Fri, 21 Jan 2022 12:03:20 +0100
Janis Schoetterl-Glausch <[email protected]> wrote:[...]
Quoted 59 lines
Quoted 18 lines
tools/testing/selftests/kvm/s390x/tprot.c line 29
Quoted 5 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +5
-0+ +static int set_storage_key (void *addr,uint8_t key) +{ + int not_mapped = 0; +Maybe add a short comment:
Check if address is mapped via lra and set the storage key if it is.Quoted 8 lines
+ asm volatile (
+ "lra %[addr], 0(0,%[addr])\n"
+ " jz 0f\n"
+ " llill %[not_mapped],1\n"
+ " j 1f\n"
+ "0: sske %[key], %[addr]\n"
+ "1:"
+ : [addr] "+&a" (addr), [not_mapped] "+r" (not_mapped)Quoted 1 line
Shouldn't this be a "=r" instead of a "+r" for
not_mapped?I don't think so. We only write to it on one code path and the compiler mustn't conclude that it can remove the = 0 assignment because the value gets overwritten anyway.
Initially I tried to implement the function like this:
static int
set_storage_key(void *addr, uint8_t key){ asm goto ("lra %[addr], 0(0,%[addr])\n\t" "jnz %l[not_mapped]\n\t" "sske %[key], %[addr]\n" : [addr] "+&a" (addr) : [key] "r" (key) : "cc", "memory" : not_mapped ); return 0; not_mapped: return -1; }Which I think is nicer, but the compiler just optimized that completely away. I have no clue why it (thinks it) is allowed to do that.
Quoted 15 lines
tools/testing/selftests/kvm/s390x/tprot.c line 48
Quoted 12 lines
+ : [key] "r" (key)
+ : "cc"
+ );
+ return -not_mapped;tools/testing/selftests/kvm/s390x/tprot.c new file +7
-0+} + +enum permission { + READ_WRITE = 0, + READ = 1, + NONE = 2, + UNAVAILABLE = 3,
TRANSLATION_NA?
I'm not completely happy with these names but I've yet to come up with a better naming scheme here.
Quoted 6 lines
Quoted 2 lines
Mentioning translation is a good idea. Don't think there is any harm in using
TRANSLATION_NOT_AVAILABLEorTRANSLATION_UNAVAILABLE.it's too long, it actually makes the code harder to read when used
maybe consider something like
TRANSL_UNAVAILas well
Fine with me. I'll rename NONE to RW_PROTECTED. NONE is too nondescript.
Quoted 27 lines
Quoted 21 lines
Quoted 12 lines
Quoted 12 lines
tools/testing/selftests/kvm/s390x/tprot.c new file +10
-0+}; + +static enum permission test_protection (void *addr,uint8_t key) +{ + uint64_t mask; + + asm volatile ( + "tprot %[addr], 0(%[key])\n" + " ipm %[mask]\n" + : [mask] "=r" (mask)Quoted 8 lines
Quoted 6 lines
+ : [addr] "Q" (*(char *)addr),
+ [key] "a" (key)
+ : "cc"
+ );
+
+ return (enum permission)mask >> 28;You could replace the shift with the "srl" that we normally do.
Quoted 1 line
I prefer keeping the asm as small as possible, C is just so much easier to understand.
we use srl everywhere, but I agree that explicitly using C makes it less obscure. and in the end the compiler should generate the same instructions anyway.
Quoted 6 lines
my only comment about the above code is that you are casting the
uint64_tto enum permission_andthen_shifting. _technically_ it should still work (enums are just ints), but I think it would look cleaner if you writereturn (enum permission)(mask >> 28);
That is better indeed.
[...]
RFC PATCH 5/10 KVM: s390: Add optional storage key checking to MEMOP IOCTL
In reply to Janis Schoetterl-GlauschUser space needs a mechanism to perform key checked accesses when emulating instructions.
The key can be passed as an additional argument via the flags field. As reserved flags need to be 0, and key 0 matches all storage keys, by default no key checking is performed, as before.
Having an additional argument is flexible, as user space can pass the guest PSW's key, in order to make an access the same way the CPU would, or pass another key if necessary.
--- arch/s390/kvm/kvm-s390.c | 21 ++++++++++++++------- include/uapi/linux/kvm.h | 1 + 2 files changed, 15 insertions(+), 7 deletions(-)
arch/s390/kvm/kvm-s390.c +14 -7
@@ -32,6 +32,7 @@#include <linux/sched/signal.h> #include <linux/string.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/asm-offsets.h> #include <asm/lowcore.h>
@@ -4727,9 +4728,11 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, {void __user *uaddr = (void __user *)mop->buf;void *tmpbuf =NULL ; +char access_key =0 ;int r =0 ;const u64 supported_flags =KVM_S390_MEMOP_F_INJECT_EXCEPTION - |KVM_S390_MEMOP_F_CHECK_ONLY ; + |KVM_S390_MEMOP_F_CHECK_ONLY + |KVM_S390_MEMOP_F_SKEYS_ACC ;if (mop->flags & ~supported_flags || mop->ar >=NUM_ACRS || !mop->size)return -EINVAL ;
@@ -4746,14 +4749,17 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,return -ENOMEM ; } + access_key =FIELD_GET (KVM_S390_MEMOP_F_SKEYS_ACC , mop->flags); +switch (mop->op) {case KVM_S390_MEMOP_LOGICAL_READ :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { - r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_FETCH ,0 ); + r =check_gva_range (vcpu, mop->gaddr, mop->ar, mop->size, +GACC_FETCH , access_key);break ; } - r =read_guest (vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); + r =read_guest_with_key (vcpu, mop->gaddr, mop->ar, tmpbuf, + mop->size, access_key);if (r ==0 ) {if (copy_to_user (uaddr, tmpbuf, mop->size)) r = -EFAULT ;
@@ -4761,15 +4767,16 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,break ;case KVM_S390_MEMOP_LOGICAL_WRITE :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { - r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_STORE ,0 ); + r =check_gva_range (vcpu, mop->gaddr, mop->ar, mop->size, +GACC_STORE , access_key);break ; }if (copy_from_user (tmpbuf, uaddr, mop->size)) { r = -EFAULT ;break ; } - r =write_guest (vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); + r =write_guest_with_key (vcpu, mop->gaddr, mop->ar, tmpbuf, + mop->size, access_key);break ; }
include/uapi/linux/kvm.h +1 -0
@@ -575,6 +575,7 @@ struct kvm_s390_mem_op {/* flags for kvm_s390_mem_op->flags */ #define KVM_S390_MEMOP_F_CHECK_ONLY (1ULL << 0)#define KVM_S390_MEMOP_F_INJECT_EXCEPTION (1ULL << 1) +#define KVM_S390_MEMOP_F_SKEYS_ACC 0x0f00ULL/* for KVM_INTERRUPT */ struct kvm_interrupt {
Signature · 1 line
2.32.0
Christian Borntraeger
maintainerRe: [RFC PATCH v1 05/10] KVM: s390: Add optional storage key checking to MEMOP IOCTL
Am 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 31 lines
User space needs a mechanism to perform key checked accesses when emulating instructions.
The key can be passed as an additional argument via the flags field. As reserved flags need to be 0, and key 0 matches all storage keys, by default no key checking is performed, as before.
Having an additional argument is flexible, as user space can pass the guest PSW's key, in order to make an access the same way the CPU would, or pass another key if necessary.Signed-off-by Janis Schoetterl-Glausch <[email protected]>Acked-by Janosch Frank <[email protected]>Reviewed-by Claudio Imbrenda <[email protected]>--- arch/s390/kvm/kvm-s390.c | 21 ++++++++++++++------- include/uapi/linux/kvm.h | 1 + 2 files changed, 15 insertions(+), 7 deletions(-)arch/s390/kvm/kvm-s390.c +1
-0@@ -32,6 +32,7 @@#include <linux/sched/signal.h> #include <linux/string.h> #include <linux/pgtable.h> +#include <linux/bitfield.h> #include <asm/asm-offsets.h> #include <asm/lowcore.h>
arch/s390/kvm/kvm-s390.c static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, · line 4735
Quoted 9 lines
arch/s390/kvm/kvm-s390.c +3
-1@@ -4727,9 +4728,11 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu, {void __user *uaddr = (void __user *)mop->buf;void *tmpbuf =NULL ; +char access_key =0 ;int r =0 ;const u64 supported_flags =KVM_S390_MEMOP_F_INJECT_EXCEPTION - |KVM_S390_MEMOP_F_CHECK_ONLY ; + |KVM_S390_MEMOP_F_CHECK_ONLY + |KVM_S390_MEMOP_F_SKEYS_ACC ;
I think it would be better to just have a flag here (single bit) to check the key and then embed the key value in the payload.
union {
__u8 ar; /* the access register number */
__u32 sida_offset; /* offset into the sida */
__u8 reserved[32]; /* should be set to 0 */
};There are cases when we need both, AR and key so maybe an unname struct is the easiest.
include/uapi/linux/kvm.h +4 -1
@@ -562,7 +562,10 @@ struct kvm_s390_mem_op {__u32 op;/* type of operation */ __u64 buf;/* buffer in userspace */ union { -__u8 ar;/* the access register number */ +struct { +__u8 ar;/* the access register number */ +__u8 key;/* effective storage key */ + };__u32 sida_offset;/* offset into the sida */ __u8 reserved[32 ];/* should be set to 0 */ };
(or acc instead of key)
Quoted 56 lines
arch/s390/kvm/kvm-s390.c +10
-6if (mop->flags & ~supported_flags || mop->ar >=NUM_ACRS || !mop->size)return -EINVAL ;@@ -4746,14 +4749,17 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,return -ENOMEM ; } + access_key =FIELD_GET (KVM_S390_MEMOP_F_SKEYS_ACC , mop->flags); +switch (mop->op) {case KVM_S390_MEMOP_LOGICAL_READ :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { - r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_FETCH ,0 ); + r =check_gva_range (vcpu, mop->gaddr, mop->ar, mop->size, +GACC_FETCH , access_key);break ; } - r =read_guest (vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); + r =read_guest_with_key (vcpu, mop->gaddr, mop->ar, tmpbuf, + mop->size, access_key);if (r ==0 ) {if (copy_to_user (uaddr, tmpbuf, mop->size)) r = -EFAULT ;@@ -4761,15 +4767,16 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,break ;case KVM_S390_MEMOP_LOGICAL_WRITE :if (mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY ) { - r =check_gva_range (vcpu, mop->gaddr, mop->ar, - mop->size,GACC_STORE ,0 ); + r =check_gva_range (vcpu, mop->gaddr, mop->ar, mop->size, +GACC_STORE , access_key);break ; }if (copy_from_user (tmpbuf, uaddr, mop->size)) { r = -EFAULT ;break ; } - r =write_guest (vcpu, mop->gaddr, mop->ar, tmpbuf, mop->size); + r =write_guest_with_key (vcpu, mop->gaddr, mop->ar, tmpbuf, + mop->size, access_key);break ; }include/uapi/linux/kvm.h +1
-0@@ -575,6 +575,7 @@ struct kvm_s390_mem_op {/* flags for kvm_s390_mem_op->flags */ #define KVM_S390_MEMOP_F_CHECK_ONLY (1ULL << 0)#define KVM_S390_MEMOP_F_INJECT_EXCEPTION (1ULL << 1) +#define KVM_S390_MEMOP_F_SKEYS_ACC 0x0f00ULL/* for KVM_INTERRUPT */ struct kvm_interrupt {
RFC PATCH 6/10 KVM: s390: Add vm IOCTL for key checked guest absolute memory access
In reply to Janis Schoetterl-GlauschChannel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed.
--- arch/s390/kvm/gaccess.c | 72 +++++++++++++++++++++++++++++++++++ arch/s390/kvm/gaccess.h | 6 +++ arch/s390/kvm/kvm-s390.c | 81 ++++++++++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 2 + 4 files changed, 161 insertions(+)
arch/s390/kvm/gaccess.c +72 -0
@@ -795,6 +795,35 @@ static int low_address_protection_enabled(struct kvm_vcpu *vcpu,return 1 ; } +static int vm_check_access_key (struct kvm *kvm,char access_key, +enum gacc_mode mode,gpa_t gpa) +{ +unsigned long hva; +unsigned char storage_key, access_control; +bool fetch_protected; +int r; + +if (access_key ==0 ) +return 0 ; + + hva =gfn_to_hva (kvm,gpa_to_gfn (gpa)); +if (kvm_is_error_hva (hva)) +return PGM_ADDRESSING ; + +mmap_read_lock (current->mm); + r =get_guest_storage_key (current->mm, hva, &storage_key); +mmap_read_unlock (current->mm); +if (r) +return r; + access_control =FIELD_GET (_PAGE_ACC_BITS, storage_key); +if (access_control == access_key) +return 0 ; + fetch_protected = storage_key & _PAGE_FP_BIT; +if ((mode ==GACC_FETCH || mode ==GACC_IFETCH ) && !fetch_protected) +return 0 ; +return PGM_PROTECTION ; +} +static bool fetch_prot_override_applicable (struct kvm_vcpu *vcpu,enum gacc_mode mode,union asce asce) {
@@ -990,6 +1019,26 @@ access_guest_page_with_key(struct kvm *kvm, enum gacc_mode mode, gpa_t gpa,return 0 ; } +int access_guest_abs_with_key (struct kvm *kvm,gpa_t gpa,void *data, +unsigned long len,enum gacc_mode mode,char key) +{ +int offset =offset_in_page (gpa); +int fragment_len; +int rc; + +while (min (PAGE_SIZE - offset, len) >0 ) { + fragment_len =min (PAGE_SIZE - offset, len); + rc =access_guest_page_with_key (kvm, mode, gpa, data, fragment_len, key); +if (rc) +return rc; + offset =0 ; + len -= fragment_len; + data += fragment_len; + gpa += fragment_len; + } +return 0 ; +} +int access_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data,unsigned long len,enum gacc_mode mode,char access_key)
@@ -1131,6 +1180,29 @@ int check_gva_range(struct kvm_vcpu *vcpu, unsigned long gva, u8 ar,return rc; } +/** +* check_gpa_range - test a range of guest physical addresses for accessibility +* @kvm: virtual machine instance +* @gpa: guest physical address +* @length: length of test range +* @mode: access mode to test, relevant for storage keys +* @access_key: access key to mach the storage keys with +*/ +int check_gpa_range (struct kvm *kvm,unsigned long gpa,unsigned long length, +enum gacc_mode mode,char access_key) +{ +unsigned int fragment_len; +int rc =0 ; + +while (length && !rc) { + fragment_len =min (PAGE_SIZE -offset_in_page (gpa), length); + rc =vm_check_access_key (kvm, access_key, mode, gpa); + length -= fragment_len; + gpa += fragment_len; + } +return rc; +} +/** * kvm_s390_check_low_addr_prot_real - check for low-address protection * @vcpu: virtual cpu
arch/s390/kvm/gaccess.h +6 -0
@@ -194,6 +194,12 @@ int check_gva_range(struct kvm_vcpu *vcpu, unsigned long gva, u8 ar, unsigned long length, enum gacc_mode mode, char access_key); +int check_gpa_range (struct kvm *kvm,unsigned long gpa,unsigned long length, +enum gacc_mode mode,char access_key); + +int access_guest_abs_with_key (struct kvm *kvm,gpa_t gpa,void *data, +unsigned long len,enum gacc_mode mode,char key); +int access_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data,unsigned long len,enum gacc_mode mode,char access_key);
arch/s390/kvm/kvm-s390.c +81 -0
93 lines not on this page · raw message
include/uapi/linux/kvm.h +2 -0
@@ -572,6 +572,8 @@ struct kvm_s390_mem_op {#define KVM_S390_MEMOP_LOGICAL_WRITE 1#define KVM_S390_MEMOP_SIDA_READ 2#define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5/* flags for kvm_s390_mem_op->flags */ #define KVM_S390_MEMOP_F_CHECK_ONLY (1ULL << 0)#define KVM_S390_MEMOP_F_INJECT_EXCEPTION (1ULL << 1)
Signature · 1 line
2.32.0
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Quoted 3 lines · Janis Schoetterl-Glausch
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
Can't we do the checking in userspace? We already have functions for handling the storage keys there (see hw/s390x/s390-skeys-kvm.c), so why can't we do the checking in QEMU?
Thomas
Christian Borntraeger
maintainerRe: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Am 19.01.22 um 12:52 schrieb Thomas Huth:
Quoted 6 lines · Janis Schoetterl-Glausch
Quoted 3 lines
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
Can't we do the checking in userspace? We already have functions for handling the storage keys there (see
hw/s390x/s390-skeys-kvm.c), so why can't we do the checking in QEMU?
That would separate the key check from the memory operation. Potentially for a long time.
Wenn we piggy back on access_guest_abs_with_key we use mvcos in the host and thus do the key check in lockstep with the keycheck which is the preferrable solution.
I would also like to avoid reading guest storage keys via the ioctl that was done for migration in the I/O path just to do a single key check. This has peformance concerns.
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Quoted 4 lines · Christian Borntraeger
Am 19.01.22 um 12:52 schrieb Thomas Huth:
Quoted 1 line · Janis Schoetterl-Glausch
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
Can't we do the checking in userspace? We already have functions for handling the storage keys there (see
hw/s390x/s390-skeys-kvm.c), so why can't we do the checking in QEMU?That would separate the key check from the memory operation. Potentially for a long time.
Wenn we piggy back onaccess_guest_abs_with_keywe use mvcos in the host and thus do the key check in lockstep with the keycheck which is the preferrable solution.
Ok, makes sense - Janis, could you please add this rationale to the patch description?
Thomas
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Quoted 9 lines · Thomas Huth
Quoted 8 lines · Christian Borntraeger
Am 19.01.22 um 12:52 schrieb Thomas Huth:
Quoted 5 lines · Janis Schoetterl-Glausch
Quoted 3 lines
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
Can't we do the checking in userspace? We already have functions for handling the storage keys there (see
hw/s390x/s390-skeys-kvm.c), so why can't we do the checking in QEMU?That would separate the key check from the memory operation. Potentially for a long time.
Wenn we piggy back onaccess_guest_abs_with_keywe use mvcos in the host and thus do the key check in lockstep with the keycheck which is the preferrable solution.Ok, makes sense - Janis, could you please add this rationale to the patch description?
Will do.
Quoted 3 lines
Thomas
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
In reply to Janis Schoetterl-GlauschQuoted 5 lines · Janis Schoetterl-Glausch
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed.
...
include/uapi/linux/kvm.h struct kvm_s390_mem_op { · line 576
Quoted 10 lines
include/uapi/linux/kvm.h +2
-0@@ -572,6 +572,8 @@ struct kvm_s390_mem_op {#define KVM_S390_MEMOP_LOGICAL_WRITE 1#define KVM_S390_MEMOP_SIDA_READ 2#define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5
Not quite sure about this - maybe it is, but at least I'd like to see this discussed: Do we really want to re-use the same ioctl layout for both, the VM and the VCPU file handles? Where the userspace developer has to know that the *_ABSOLUTE_* ops only work with VM handles, and the others only work with the VCPU handles? A CPU can also address absolute memory, so why not adding the *_ABSOLUTE_* ops there, too? And if we'd do that, wouldn't it be sufficient to have the VCPU ioctls only - or do you want to call these ioctls from spots in QEMU where you do not have a VCPU handle available? (I/O instructions are triggered from a CPU, so I'd assume that you should have a VCPU handle around?)
Thomas
Christian Borntraeger
maintainerRe: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Am 20.01.22 um 11:38 schrieb Thomas Huth:
Quoted 7 lines · Janis Schoetterl-Glausch
Quoted 5 lines
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed....
Quoted 12 lines
include/uapi/linux/kvm.h struct kvm_s390_mem_op { · line 576
Quoted 10 lines
include/uapi/linux/kvm.h +2
-0@@ -572,6 +572,8 @@ struct kvm_s390_mem_op { #define KVM_S390_MEMOP_LOGICAL_WRITE 1 #define KVM_S390_MEMOP_SIDA_READ 2 #define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5Not quite sure about this - maybe it is, but at least I'd like to see this discussed: Do we really want to re-use the same ioctl layout for both, the VM and the VCPU file handles? Where the userspace developer has to know that the *_ABSOLUTE_* ops only work with VM handles, and the others only work with the VCPU handles? A CPU can also address absolute memory, so why not adding the *_ABSOLUTE_* ops there, too? And if we'd do that, wouldn't it be sufficient to have the VCPU ioctls only - or do you want to call these ioctls from spots in QEMU where you do not have a VCPU handle available? (I/O instructions are triggered from a CPU, so I'd assume that you should have a VCPU handle around?)
I paritally agree. the ABSOLUTE calls should also work from a VCPU handle. But you also want to be able to call this from a different thread than the vpcu threads as you do not want to kick a CPU out of the kernel just for that. So it makes sense to have this ioctl also for the VM fd.
Quoted 4 lines
Thomas
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
In reply to Thomas HuthQuoted 7 lines · Thomas Huth
Quoted 5 lines · Janis Schoetterl-Glausch
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed....
Quoted 12 lines
include/uapi/linux/kvm.h struct kvm_s390_mem_op { · line 576
Quoted 10 lines
include/uapi/linux/kvm.h +2
-0@@ -572,6 +572,8 @@ struct kvm_s390_mem_op { #define KVM_S390_MEMOP_LOGICAL_WRITE 1 #define KVM_S390_MEMOP_SIDA_READ 2 #define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5Not quite sure about this - maybe it is, but at least I'd like to see this discussed: Do we really want to re-use the same ioctl layout for both, the VM and the VCPU file handles? Where the userspace developer has to know that the *_ABSOLUTE_* ops only work with VM handles, and the others only work with the VCPU handles? A CPU can also address absolute memory, so why not adding the *_ABSOLUTE_* ops there, too? And if we'd do that, wouldn't it be sufficient to have the VCPU ioctls only - or do you want to call these ioctls from spots in QEMU where you do not have a VCPU handle available? (I/O instructions are triggered from a CPU, so I'd assume that you should have a VCPU handle around?)
There are some differences between the vm and the vcpu memops.
No storage or fetch protection overrides apply to IO/vm memops, after all there is no control register to enable them. Additionally, quiescing is not required for IO, tho in practice we use the same code path for the vcpu and the vm here. Allowing absolute accesses with a vcpu is doable, but I'm not sure what the use case for it would be, I'm not aware of a precedence in the architecture. Of course the vcpu memop already supports logical=real accesses.
Quoted 4 lines
Thomas
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Quoted 21 lines · Janis Schoetterl-Glausch
Quoted 7 lines · Thomas Huth
Quoted 5 lines · Janis Schoetterl-Glausch
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed....
Quoted 12 lines
include/uapi/linux/kvm.h struct kvm_s390_mem_op { · line 576
Quoted 10 lines
include/uapi/linux/kvm.h +2
-0@@ -572,6 +572,8 @@ struct kvm_s390_mem_op { #define KVM_S390_MEMOP_LOGICAL_WRITE 1 #define KVM_S390_MEMOP_SIDA_READ 2 #define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5Not quite sure about this - maybe it is, but at least I'd like to see this discussed: Do we really want to re-use the same ioctl layout for both, the VM and the VCPU file handles? Where the userspace developer has to know that the *_ABSOLUTE_* ops only work with VM handles, and the others only work with the VCPU handles? A CPU can also address absolute memory, so why not adding the *_ABSOLUTE_* ops there, too? And if we'd do that, wouldn't it be sufficient to have the VCPU ioctls only - or do you want to call these ioctls from spots in QEMU where you do not have a VCPU handle available? (I/O instructions are triggered from a CPU, so I'd assume that you should have a VCPU handle around?)
Quoted 5 lines
There are some differences between the vm and the vcpu memops.
No storage or fetch protection overrides apply to IO/vm memops, after all there is no control register to enable them. Additionally, quiescing is not required for IO, tho in practice we use the same code path for the vcpu and the vm here. Allowing absolute accesses with a vcpu is doable, but I'm not sure what the use case for it would be, I'm not aware of a precedence in the architecture. Of course the vcpu memop already supports logical=real accesses.
Ok. Maybe it then would be better to call new ioctl and the new op defines differently, to avoid confusion? E.g. call it "vmmemop" and use:
#define KVM_S390_VMMEMOP_ABSOLUTE_READ 1
#define KVM_S390_VMMEMOP_ABSOLUTE_WRITE 2
?
Thomas
Re: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Quoted 28 lines · Thomas Huth
Quoted 21 lines · Janis Schoetterl-Glausch
Quoted 7 lines · Thomas Huth
Quoted 5 lines · Janis Schoetterl-Glausch
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed....
Quoted 12 lines
include/uapi/linux/kvm.h struct kvm_s390_mem_op { · line 576
Quoted 10 lines
include/uapi/linux/kvm.h +2
-0@@ -572,6 +572,8 @@ struct kvm_s390_mem_op { #define KVM_S390_MEMOP_LOGICAL_WRITE 1 #define KVM_S390_MEMOP_SIDA_READ 2 #define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5Not quite sure about this - maybe it is, but at least I'd like to see this discussed: Do we really want to re-use the same ioctl layout for both, the VM and the VCPU file handles? Where the userspace developer has to know that the *_ABSOLUTE_* ops only work with VM handles, and the others only work with the VCPU handles? A CPU can also address absolute memory, so why not adding the *_ABSOLUTE_* ops there, too? And if we'd do that, wouldn't it be sufficient to have the VCPU ioctls only - or do you want to call these ioctls from spots in QEMU where you do not have a VCPU handle available? (I/O instructions are triggered from a CPU, so I'd assume that you should have a VCPU handle around?)
Quoted 5 lines
There are some differences between the vm and the vcpu memops.
No storage or fetch protection overrides apply to IO/vm memops, after all there is no control register to enable them. Additionally, quiescing is not required for IO, tho in practice we use the same code path for the vcpu and the vm here. Allowing absolute accesses with a vcpu is doable, but I'm not sure what the use case for it would be, I'm not aware of a precedence in the architecture. Of course the vcpu memop already supports logical=real accesses.
Quoted 9 lines
Ok. Maybe it then would be better to call new ioctl and the new op defines differently, to avoid confusion? E.g. call it "vmmemop" and use:
#define KVM_S390_VMMEMOP_ABSOLUTE_READ 1
#define KVM_S390_VMMEMOP_ABSOLUTE_WRITE 2?
Thomas
Thanks for the suggestion, I had to think about it for a while :). Here are my thoughts:
The ioctl type (vm/vcpu) and the operations cannot be completely orthogonal (vm + logical cannot work), but with regards to the absolute operations they could be. We don't have a use case for that right now and the semantics are a bit unclear, so I think we should choose a design now that leaves us space for future extension. If we need to, we can add a NON_QUIESCING flag backwards compatibly (tho it seems a rather unlikely requirement to me), that would behave the same for vm/vcpu memops. We could also have a NO_PROT_OVERRIDE flag, which the vm memop would ignore.
Whether override is possible is dependent on the vcpu state, so user space leaves the exact behavior to KVM anyway. If you wanted to enforce that protection override occurs, you would have to adjust
the vcpu state and therefore there should be no confusion about whether to use a vcpu or vm ioctl.
So I'm inclined to have one ioctl code and keep the operations as they are.
I moved the key to the union. One question that remains is whether to enforce that reserved bytes must be 0. In general I think that it is a good idea, since it leaves a bigger design space for future extensions. However the vcpu memop has not done that. I think it should be enforced for new functionality (operations, flags), any objections?
I'll try to be thorough in documenting the currently supported behavior.
Claudio Imbrenda
maintainerRe: [RFC PATCH v1 06/10] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
Quoted 50 lines · On Thu, 27 Jan 2022 17:29:44 +0100 Janis Schoetterl-Glausch…
Quoted 28 lines · Thomas Huth
Quoted 21 lines · Janis Schoetterl-Glausch
Quoted 7 lines · Thomas Huth
Quoted 5 lines · Janis Schoetterl-Glausch
Channel I/O honors storage keys and is performed on absolute memory. For I/O emulation user space therefore needs to be able to do key checked accesses.
The vm IOCTL supports read/write accesses, as well as checking if an access would succeed....
Quoted 12 lines
include/uapi/linux/kvm.h struct kvm_s390_mem_op { · line 576
Quoted 10 lines
include/uapi/linux/kvm.h +2
-0@@ -572,6 +572,8 @@ struct kvm_s390_mem_op { #define KVM_S390_MEMOP_LOGICAL_WRITE 1 #define KVM_S390_MEMOP_SIDA_READ 2 #define KVM_S390_MEMOP_SIDA_WRITE 3 +#define KVM_S390_MEMOP_ABSOLUTE_READ 4 +#define KVM_S390_MEMOP_ABSOLUTE_WRITE 5Not quite sure about this - maybe it is, but at least I'd like to see this discussed: Do we really want to re-use the same ioctl layout for both, the VM and the VCPU file handles? Where the userspace developer has to know that the *_ABSOLUTE_* ops only work with VM handles, and the others only work with the VCPU handles? A CPU can also address absolute memory, so why not adding the *_ABSOLUTE_* ops there, too? And if we'd do that, wouldn't it be sufficient to have the VCPU ioctls only - or do you want to call these ioctls from spots in QEMU where you do not have a VCPU handle available? (I/O instructions are triggered from a CPU, so I'd assume that you should have a VCPU handle around?)
Quoted 5 lines
There are some differences between the vm and the vcpu memops.
No storage or fetch protection overrides apply to IO/vm memops, after all there is no control register to enable them. Additionally, quiescing is not required for IO, tho in practice we use the same code path for the vcpu and the vm here. Allowing absolute accesses with a vcpu is doable, but I'm not sure what the use case for it would be, I'm not aware of a precedence in the architecture. Of course the vcpu memop already supports logical=real accesses.Quoted 9 lines
Ok. Maybe it then would be better to call new ioctl and the new op defines differently, to avoid confusion? E.g. call it "vmmemop" and use:
#define KVM_S390_VMMEMOP_ABSOLUTE_READ 1
#define KVM_S390_VMMEMOP_ABSOLUTE_WRITE 2?
Thomas
Thanks for the suggestion, I had to think about it for a while :). Here are my thoughts:
The ioctl type (vm/vcpu) and the operations cannot be completely orthogonal (vm + logical cannot work), but with regards to the absolute operations they could be. We don't have a use case for that right now and the semantics are a bit unclear, so I think we should choose a design now that leaves us space for future extension. If we need to, we can add aNON_QUIESCINGflag backwards compatibly (tho it seems a rather unlikely requirement to me), that would behave the same for vm/vcpu memops. We could also have aNO_PROT_OVERRIDEflag, which the vm memop would ignore.
Whether override is possible is dependent on the vcpu state, so user space leaves the exact behavior to KVM anyway. If you wanted to enforce that protection override occurs, you would have to adjust
the vcpu state and therefore there should be no confusion about whether to use a vcpu or vm ioctl.
Quoted 4 lines
So I'm inclined to have one ioctl code and keep the operations as they are.
I moved the key to the union. One question that remains is whether to enforce that reserved bytes must be 0. In general I think that it is a good idea, since it leaves a bigger design space for future extensions. However the vcpu memop has not done that. I think it should be enforced for new functionality (operations, flags),
I agree with enforcing that unused bits should be 0
Quoted 3 lines
any objections?
I'll try to be thorough in documenting the currently supported behavior.
this is also a good idea :)
RFC PATCH 7/10 KVM: s390: Rename existing vcpu memop functions
In reply to Janis Schoetterl-GlauschMakes the naming consistent, now that we also have a vm ioctl.
--- arch/s390/kvm/kvm-s390.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-)
arch/s390/kvm/kvm-s390.c +10 -9
@@ -4776,8 +4776,8 @@ static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,return r; } -static long kvm_s390_guest_sida_op (struct kvm_vcpu *vcpu, -struct kvm_s390_mem_op *mop) +static long kvm_s390_vcpu_sida_op (struct kvm_vcpu *vcpu, +struct kvm_s390_mem_op *mop) {void __user *uaddr = (void __user *)mop->buf;int r =0 ;
@@ -4804,8 +4804,9 @@ static long kvm_s390_guest_sida_op(struct kvm_vcpu *vcpu, }return r; } -static long kvm_s390_guest_mem_op (struct kvm_vcpu *vcpu, -struct kvm_s390_mem_op *mop) + +static long kvm_s390_vcpu_mem_op (struct kvm_vcpu *vcpu, +struct kvm_s390_mem_op *mop) {void __user *uaddr = (void __user *)mop->buf;void *tmpbuf =NULL ;
@@ -4868,8 +4869,8 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,return r; } -static long kvm_s390_guest_memsida_op (struct kvm_vcpu *vcpu, -struct kvm_s390_mem_op *mop) +static long kvm_s390_vcpu_memsida_op (struct kvm_vcpu *vcpu, +struct kvm_s390_mem_op *mop) {int r, srcu_idx;
@@ -4878,12 +4879,12 @@ static long kvm_s390_guest_memsida_op(struct kvm_vcpu *vcpu,switch (mop->op) {case KVM_S390_MEMOP_LOGICAL_READ :case KVM_S390_MEMOP_LOGICAL_WRITE : - r =kvm_s390_guest_mem_op (vcpu, mop); + r =kvm_s390_vcpu_mem_op (vcpu, mop);break ;case KVM_S390_MEMOP_SIDA_READ :case KVM_S390_MEMOP_SIDA_WRITE :/* we are locked against sida going away by the vcpu->mutex */ - r =kvm_s390_guest_sida_op (vcpu, mop); + r =kvm_s390_vcpu_sida_op (vcpu, mop);break ;default : r = -EINVAL ;
@@ -5046,7 +5047,7 @@ long kvm_arch_vcpu_ioctl(struct file *filp,struct kvm_s390_mem_op mem_op;if (copy_from_user (&mem_op, argp,sizeof (mem_op)) ==0 ) - r =kvm_s390_guest_memsida_op (vcpu, &mem_op); + r =kvm_s390_vcpu_memsida_op (vcpu, &mem_op);else r = -EFAULT ;break ;
Signature · 1 line
2.32.0
RFC PATCH 8/10 KVM: s390: selftests: Test memops with storage keys
In reply to Janis Schoetterl-GlauschTest vm and vcpu memops with storage keys, both successful accesses as well as various exception conditions.
--- tools/testing/selftests/kvm/s390x/memop.c | 548 +++++++++++++++++++--- 1 file changed, 485 insertions(+), 63 deletions(-)
tools/testing/selftests/kvm/s390x/memop.c +485 -63
@@ -13,28 +13,305 @@#include "test_util.h" #include "kvm_util.h" +#define PAGE_SHIFT 12 +#define PAGE_SIZE (1 << PAGE_SHIFT) +#define PAGE_MASK (~(PAGE_SIZE - 1)) +#define CR0_FETCH_PROTECTION_OVERRIDE (1UL << (63 - 38)) +#define CR0_STORAGE_PROTECTION_OVERRIDE (1UL << (63 - 39)) +#define VCPU_ID 1 +const uint64_t last_page_addr =UINT64_MAX -PAGE_SIZE +1 ; +const unsigned int key_shift =ffs (KVM_S390_MEMOP_F_SKEYS_ACC ) -1 ; +static uint8_t mem1[65536 ];static uint8_t mem2[65536 ]; +static void set_storage_key_range (void *addr,size_t len,char key) +{ +uintptr_t _addr, abs, i; + + _addr = (uintptr_t )addr; +for (i = _addr &PAGE_MASK ; i < _addr + len; i +=PAGE_SIZE ) { + abs = i; + asmvolatile ( +"lra %[abs], 0(0,%[abs])\n" +" sske %[key], %[abs]\n" + : [abs]"+&a" (abs) + : [key]"r" (key) + :"cc" + ); + } +} +static void guest_code (void ) +{ +/* Set storage key */ +set_storage_key_range (mem1,sizeof (mem1),0x90 ); +set_storage_key_range (mem2,sizeof (mem2),0x90 ); +GUEST_SYNC (0 ); + +/* Write, read back, without keys */ +memcpy (mem2, mem1,sizeof (mem2)); +GUEST_SYNC (10 ); + +/* Write, read back, key 0 */ +memcpy (mem2, mem1,sizeof (mem2)); +GUEST_SYNC (20 ); + +/* Write, read back, matching key, 1 page */ +memcpy (mem2, mem1,sizeof (mem2)); +GUEST_SYNC (30 ); + +/* Write, read back, matching key, all pages */ +memcpy (mem2, mem1,sizeof (mem2)); +GUEST_SYNC (40 ); + +/* Set fetch protection */ +set_storage_key_range (0 ,1 ,0x18 ); +GUEST_SYNC (50 ); + +/* Enable fetch protection override */ +GUEST_SYNC (60 ); + +/* Enable storage protection override, set fetch protection*/ +set_storage_key_range (mem1,sizeof (mem1),0x98 ); +set_storage_key_range (mem2,sizeof (mem2),0x98 ); +GUEST_SYNC (70 ); + +/* Write, read back, mismatching key, +* storage protection override, all pages +*/ +memcpy (mem2, mem1,sizeof (mem2)); +GUEST_SYNC (80 ); + +/* VM memop, write, read back, matching key */ +memcpy (mem2, mem1,sizeof (mem2)); +GUEST_SYNC (90 ); + +/* VM memop, write, read back, key 0 */ +memcpy (mem2, mem1,sizeof (mem2)); +/* VM memop, fail to read from 0 absolute/virtual, mismatching key, +* fetch protection override does not apply to VM memops +*/ + asmvolatile ("sske %1,%0\n" + : :"r" (0 ),"r" (0x18 ) :"cc" + ); +GUEST_SYNC (100 ); + +/* Enable AR mode */ +GUEST_SYNC (110 ); + +/* Disable AR mode */ +GUEST_SYNC (120 ); +} + +static void reroll_mem1 (void ) {int i; -for (;;) { -for (i =0 ; i <sizeof (mem2); i++) - mem2[i] = mem1[i]; -GUEST_SYNC (0 ); - } +for (i =0 ; i <sizeof (mem1); i++) + mem1[i] =rand (); +} + +static int _vcpu_read_guest (struct kvm_vm *vm,void *host_addr, +uintptr_t guest_addr,size_t len) +{ +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags =0 , + .size = len, + .op =KVM_S390_MEMOP_LOGICAL_READ , + .buf = (uintptr_t )host_addr, + .ar =0 , + }; + +return _vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +} + +static void vcpu_read_guest (struct kvm_vm *vm,void *host_addr, +uintptr_t guest_addr,size_t len) +{ +int rv; + + rv =_vcpu_read_guest (vm, host_addr, guest_addr, len); +TEST_ASSERT (rv ==0 ,"vcpu memop read failed: reason = %d\n" , rv); +} + +static int _vcpu_read_guest_key (struct kvm_vm *vm,void *host_addr, +uintptr_t guest_addr,size_t len,char key) +{ +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags = key << key_shift, + .size = len, + .op =KVM_S390_MEMOP_LOGICAL_READ , + .buf = (uintptr_t )host_addr, + .ar =0 , + }; + +return _vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +} + +static void vcpu_read_guest_key (struct kvm_vm *vm,void *host_addr, +uintptr_t guest_addr,size_t len,char key) +{ +int rv; + + rv =_vcpu_read_guest_key (vm, host_addr, guest_addr, len, key); +TEST_ASSERT (rv ==0 ,"vcpu memop read failed: reason = %d\n" , rv); +} + +static int _vcpu_write_guest (struct kvm_vm *vm,uintptr_t guest_addr, +void *host_addr,size_t len) +{ +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags =0 , + .size = len, + .op =KVM_S390_MEMOP_LOGICAL_WRITE , + .buf = (uintptr_t )host_addr, + .ar =0 , + }; +return _vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +} + +static void vcpu_write_guest (struct kvm_vm *vm,uintptr_t guest_addr, +void *host_addr,size_t len) +{ +int rv; + + rv =_vcpu_write_guest (vm, guest_addr, host_addr, len); +TEST_ASSERT (rv ==0 ,"vcpu memop write failed: reason = %d\n" , rv); +} + +static int _vcpu_write_guest_key (struct kvm_vm *vm,uintptr_t guest_addr, +void *host_addr,size_t len,char key) +{ +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags = key << key_shift, + .size = len, + .op =KVM_S390_MEMOP_LOGICAL_WRITE , + .buf = (uintptr_t )host_addr, + .ar =0 , + }; + +return _vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +} + +static void vcpu_write_guest_key (struct kvm_vm *vm,uintptr_t guest_addr, +void *host_addr,size_t len,char key) +{ +int rv; + + rv =_vcpu_write_guest_key (vm, guest_addr, host_addr, len, key); +TEST_ASSERT (rv ==0 ,"vcpu memop write failed: reason = %d\n" , rv); +} + +static int _vm_read_guest_key (struct kvm_vm *vm,void *host_addr, +uintptr_t guest_addr,size_t len,char key) +{ +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags = key << key_shift, + .size = len, + .op =KVM_S390_MEMOP_ABSOLUTE_READ , + .buf = (uintptr_t )host_addr, + .reserved = {0 }, + }; + +return _vm_ioctl (vm,KVM_S390_MEM_OP , &ksmo); +} + +static void vm_read_guest_key (struct kvm_vm *vm,void *host_addr, +uintptr_t guest_addr,size_t len,char key) +{ +int rv; + + rv =_vm_read_guest_key (vm, host_addr, guest_addr, len, key); +TEST_ASSERT (rv ==0 ,"vm memop read failed: reason = %d\n" , rv); +} + +static int _vm_write_guest_key (struct kvm_vm *vm,uintptr_t guest_addr, +void *host_addr,size_t len,char key) +{ +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags = key << key_shift, + .size = len, + .op =KVM_S390_MEMOP_ABSOLUTE_WRITE , + .buf = (uintptr_t )host_addr, + .reserved = {0 }, + }; + +return _vm_ioctl (vm,KVM_S390_MEM_OP , &ksmo); +} + +static void vm_write_guest_key (struct kvm_vm *vm,uintptr_t guest_addr, +void *host_addr,size_t len,char key) +{ +int rv; + + rv =_vm_write_guest_key (vm, guest_addr, host_addr, len, key); +TEST_ASSERT (rv ==0 ,"vm memop write failed: reason = %d\n" , rv); +} + +enum access_mode { +ACCESS_READ , +ACCESS_WRITE +}; + +static int _vm_check_guest_key (struct kvm_vm *vm,enum access_mode mode, +uintptr_t guest_addr,size_t len,char key) +{ +int op; + +if (mode ==ACCESS_READ ) + op =KVM_S390_MEMOP_ABSOLUTE_READ ; +else + op =KVM_S390_MEMOP_ABSOLUTE_WRITE ; +struct kvm_s390_mem_op ksmo = { + .gaddr = guest_addr, + .flags = key << key_shift |KVM_S390_MEMOP_F_CHECK_ONLY , + .size = len, + .op = op, + .reserved = {0 }, + }; + +return _vm_ioctl (vm,KVM_S390_MEM_OP , &ksmo); } +static void vm_check_guest_key (struct kvm_vm *vm,enum access_mode mode, +uintptr_t guest_addr,size_t len,char key) +{ +int rv; + + rv =_vm_check_guest_key (vm, mode, guest_addr, len, key); +TEST_ASSERT (rv ==0 ,"vm memop write failed: reason = %d\n" , rv); +} + +#define HOST_SYNC (vmp, stage) \ +({ \ + struct kvm_vm *__vm = (vmp); \ + struct ucall uc; \ + int __stage = (stage); \ + \ + vcpu_run(__vm, VCPU_ID); \ + get_ucall(__vm, VCPU_ID, &uc); \ + ASSERT_EQ(uc.cmd, UCALL_SYNC); \ + ASSERT_EQ(uc.args[1], __stage); \ +}) \ +int main (int argc,char *argv[]) {struct kvm_vm *vm;struct kvm_run *run;struct kvm_s390_mem_op ksmo; -int rv, i, maxsize; +vm_vaddr_t guest_mem1; +vm_vaddr_t guest_mem2; +vm_paddr_t guest_mem1_abs; +int rv, maxsize;setbuf (stdout,NULL );/* Tell stdout not to buffer its content */
@@ -49,63 +326,210 @@ int main(int argc, char *argv[])/* Create VM */ vm =vm_create_default (VCPU_ID ,0 , guest_code); run =vcpu_state (vm,VCPU_ID ); + guest_mem1 = (uintptr_t )mem1; + guest_mem2 = (uintptr_t )mem2; + guest_mem1_abs =addr_gva2gpa (vm, guest_mem1); -for (i =0 ; i <sizeof (mem1); i++) - mem1[i] = i * i + i; +/* Set storage key */ +HOST_SYNC (vm,0 ); -/* Set the first array */ - ksmo.gaddr =addr_gva2gpa (vm, (uintptr_t )mem1); - ksmo.flags =0 ; - ksmo.size = maxsize; - ksmo.op =KVM_S390_MEMOP_LOGICAL_WRITE ; - ksmo.buf = (uintptr_t )mem1; - ksmo.ar =0 ; -vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +/* Write, read back, without keys */ +reroll_mem1 (); +vcpu_write_guest (vm, guest_mem1, mem1, maxsize); +HOST_SYNC (vm,10 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vcpu_read_guest (vm, mem2, guest_mem2, maxsize); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); -/* Let the guest code copy the first array to the second */ -vcpu_run (vm,VCPU_ID ); -TEST_ASSERT (run->exit_reason ==KVM_EXIT_S390_SIEIC , -"Unexpected exit reason: %u (%s)\n" , - run->exit_reason, -exit_reason_str (run->exit_reason)); + { +vm_vaddr_t guest_0_page =vm_vaddr_alloc (vm,PAGE_SIZE ,0 ); +vm_vaddr_t guest_last_page =vm_vaddr_alloc (vm,PAGE_SIZE , last_page_addr); +vm_paddr_t guest_mem2_abs =addr_gva2gpa (vm, guest_mem2); -memset (mem2,0xaa ,sizeof (mem2)); +/* Write, read back, key 0 */ +reroll_mem1 (); +vcpu_write_guest_key (vm, guest_mem1, mem1, maxsize,0 ); +HOST_SYNC (vm,20 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vcpu_read_guest_key (vm, mem2, guest_mem2, maxsize,0 ); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); -/* Get the second array */ - ksmo.gaddr = (uintptr_t )mem2; - ksmo.flags =0 ; - ksmo.size = maxsize; - ksmo.op =KVM_S390_MEMOP_LOGICAL_READ ; - ksmo.buf = (uintptr_t )mem2; - ksmo.ar =0 ; -vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +/* Write, read back, matching key, 1 page */ +reroll_mem1 (); +vcpu_write_guest_key (vm, guest_mem1, mem1,PAGE_SIZE ,9 ); +HOST_SYNC (vm,30 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vcpu_read_guest_key (vm, mem2, guest_mem2,PAGE_SIZE ,9 ); +TEST_ASSERT (!memcmp (mem1, mem2,PAGE_SIZE ), +"Memory contents do not match!" ); -TEST_ASSERT (!memcmp (mem1, mem2, maxsize), -"Memory contents do not match!" ); +/* Write, read back, matching key, all pages */ +reroll_mem1 (); +vcpu_write_guest_key (vm, guest_mem1, mem1, maxsize,9 ); +HOST_SYNC (vm,40 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vcpu_read_guest_key (vm, mem2, guest_mem2, maxsize,9 ); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); -/* Check error conditions - first bad size: */ - ksmo.gaddr = (uintptr_t )mem1; - ksmo.flags =0 ; - ksmo.size =-1 ; - ksmo.op =KVM_S390_MEMOP_LOGICAL_WRITE ; - ksmo.buf = (uintptr_t )mem1; - ksmo.ar =0 ; - rv =_vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +/* Fail to write, read back old value, mismatching key */ + rv =_vcpu_write_guest_key (vm, guest_mem1, mem1, maxsize,2 ); +TEST_ASSERT (rv ==4 ,"Store should result in protection exception" ); +memset (mem2,0xaa ,sizeof (mem2)); +vcpu_read_guest_key (vm, mem2, guest_mem2, maxsize,2 ); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); + +/* Set fetch protection */ +HOST_SYNC (vm,50 ); + +/* Write without key, read back, machting key, fetch protection */ +reroll_mem1 (); +vcpu_write_guest (vm, guest_0_page, mem1,PAGE_SIZE ); +memset (mem2,0xaa ,sizeof (mem2)); +/* Lets not copy in the guest, in case guest_0_page != 0 */ +vcpu_read_guest_key (vm, mem2, guest_0_page,PAGE_SIZE ,1 ); +TEST_ASSERT (!memcmp (mem1, mem2,PAGE_SIZE ), +"Memory contents do not match!" ); + +/* Fail to read, mismatching key, fetch protection */ + rv =_vcpu_read_guest_key (vm, mem2, guest_0_page,PAGE_SIZE ,2 ); +TEST_ASSERT (rv ==4 ,"Fetch should result in protection exception" ); + +/* Enable fetch protection override */ + run->s.regs.crs[0 ] |=CR0_FETCH_PROTECTION_OVERRIDE ; + run->kvm_dirty_regs =KVM_SYNC_CRS ; +HOST_SYNC (vm,60 ); + +if (guest_0_page !=0 ) +print_skip ("Did not allocate page at 0 for fetch protection override test" ); + +/* Write without key, read back, mismachting key, +* fetch protection override, 1 page +*/ +if (guest_0_page ==0 ) { +reroll_mem1 (); +vcpu_write_guest (vm, guest_0_page, mem1,PAGE_SIZE ); +memset (mem2,0xaa ,sizeof (mem2)); +/* Lets not copy in the guest, in case guest_0_page != 0 */ +vcpu_read_guest_key (vm, mem2, guest_0_page,2048 ,2 ); +TEST_ASSERT (!memcmp (mem1, mem2,2048 ), +"Memory contents do not match!" ); + } + +/* Fail to read, mismatching key, +* fetch protection override address exceeded, 1 page +*/ +if (guest_0_page ==0 ) { + rv =_vcpu_read_guest_key (vm, mem2,0 ,2048 +1 ,2 ); +TEST_ASSERT (rv ==4 , +"Fetch should result in protection exception" ); + } + +if (guest_last_page != last_page_addr) +print_skip ("Did not allocate last page for fetch protection override test" ); + +/* Write without key, read back, mismachting key, +* fetch protection override, 2 pages, last page not fetch protected +*/ +reroll_mem1 (); +vcpu_write_guest (vm, guest_last_page, mem1,PAGE_SIZE ); +vcpu_write_guest (vm, guest_0_page, mem1 +PAGE_SIZE ,PAGE_SIZE ); +if (guest_0_page ==0 && guest_last_page == last_page_addr) { +memset (mem2,0xaa ,sizeof (mem2)); +/* Lets not copy in the guest, in case guest_0_page != 0 */ +vcpu_read_guest_key (vm, mem2, last_page_addr, +PAGE_SIZE +2048 ,2 ); +TEST_ASSERT (!memcmp (mem1, mem2,PAGE_SIZE +2048 ), +"Memory contents do not match!" ); + } + +/* Fail to read, mismatching key, fetch protection override address +* exceeded, 2 pages, last page not fetch protected +*/ +if (guest_0_page ==0 && guest_last_page == last_page_addr) { + rv =_vcpu_read_guest_key (vm, mem2, last_page_addr, +PAGE_SIZE +2048 +1 ,2 ); +TEST_ASSERT (rv ==4 , +"Fetch should result in protection exception" ); + } + +/* Enable storage protection override, set fetch protection*/ + run->s.regs.crs[0 ] |=CR0_STORAGE_PROTECTION_OVERRIDE ; + run->kvm_dirty_regs =KVM_SYNC_CRS ; +HOST_SYNC (vm,70 ); + +/* Write, read back, mismatching key, +* storage protection override, all pages +*/ +reroll_mem1 (); +vcpu_write_guest_key (vm, guest_mem1, mem1, maxsize,2 ); +HOST_SYNC (vm,80 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vcpu_read_guest_key (vm, mem2, guest_mem2, maxsize,2 ); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); + +/* VM memop, write, read back, matching key */ +reroll_mem1 (); +vm_write_guest_key (vm, guest_mem1_abs, mem1, maxsize,9 ); +HOST_SYNC (vm,90 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vm_read_guest_key (vm, mem2, guest_mem2_abs, maxsize,9 ); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); +vm_check_guest_key (vm,ACCESS_WRITE , guest_mem1_abs, maxsize,9 ); +vm_check_guest_key (vm,ACCESS_READ , guest_mem2_abs, maxsize,9 ); + +/* VM memop, write, read back, key 0 */ +reroll_mem1 (); +vm_write_guest_key (vm, guest_mem1_abs, mem1, maxsize,0 ); +HOST_SYNC (vm,100 );// Copy in vm +memset (mem2,0xaa ,sizeof (mem2)); +vm_read_guest_key (vm, mem2, guest_mem2_abs, maxsize,0 ); +TEST_ASSERT (!memcmp (mem1, mem2, maxsize), +"Memory contents do not match!" ); + rv =_vm_check_guest_key (vm,ACCESS_READ , guest_mem1_abs, maxsize,9 ); +TEST_ASSERT (rv ==0 ,"Check should succeed" ); +vm_check_guest_key (vm,ACCESS_WRITE , guest_mem1_abs, maxsize,0 ); +vm_check_guest_key (vm,ACCESS_READ , guest_mem2_abs, maxsize,0 ); + +/* VM memop, fail to write, fail to read, mismatching key, +* storage protection override does not apply to VM memops +*/ + rv =_vm_write_guest_key (vm, guest_mem1_abs, mem1, maxsize,2 ); +TEST_ASSERT (rv ==4 ,"Store should result in protection exception" ); + rv =_vm_read_guest_key (vm, mem2, guest_mem2_abs, maxsize,2 ); +TEST_ASSERT (rv ==4 ,"Fetch should result in protection exception" ); + rv =_vm_check_guest_key (vm,ACCESS_WRITE , guest_mem1_abs, maxsize,2 ); +TEST_ASSERT (rv ==4 ,"Check should indicate protection exception" ); + rv =_vm_check_guest_key (vm,ACCESS_READ , guest_mem2_abs, maxsize,2 ); +TEST_ASSERT (rv ==4 ,"Check should indicate protection exception" ); + +/* VM memop, fail to read from 0 absolute/virtual, mismatching key, +* fetch protection override does not apply to VM memops +*/ + rv =_vm_read_guest_key (vm, mem2,0 ,2048 ,2 ); +TEST_ASSERT (rv !=0 ,"Fetch should result in exception" ); + rv =_vm_read_guest_key (vm, mem2,addr_gva2gpa (vm,0 ),2048 ,2 ); +TEST_ASSERT (rv ==4 ,"Fetch should result in protection exception" ); + } + +/* Check error conditions */ + +/* Bad size: */ + rv =_vcpu_write_guest (vm, (uintptr_t )mem1, mem1,-1 );TEST_ASSERT (rv ==-1 && errno ==E2BIG ,"ioctl allows insane sizes" );/* Zero size: */ - ksmo.gaddr = (uintptr_t )mem1; - ksmo.flags =0 ; - ksmo.size =0 ; - ksmo.op =KVM_S390_MEMOP_LOGICAL_WRITE ; - ksmo.buf = (uintptr_t )mem1; - ksmo.ar =0 ; - rv =_vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); + rv =_vcpu_write_guest (vm, (uintptr_t )mem1, mem1,0 );TEST_ASSERT (rv ==-1 && (errno ==EINVAL || errno ==ENOMEM ),"ioctl allows 0 as size" );/* Bad flags: */ - ksmo.gaddr = (uintptr_t )mem1; + ksmo.gaddr = guest_mem1; ksmo.flags =-1 ; ksmo.size = maxsize; ksmo.op =KVM_S390_MEMOP_LOGICAL_WRITE ;
@@ -115,7 +539,7 @@ int main(int argc, char *argv[])TEST_ASSERT (rv ==-1 && errno ==EINVAL ,"ioctl allows all flags" );/* Bad operation: */ - ksmo.gaddr = (uintptr_t )mem1; + ksmo.gaddr = guest_mem1; ksmo.flags =0 ; ksmo.size = maxsize; ksmo.op =-1 ;
@@ -135,21 +559,17 @@ int main(int argc, char *argv[])TEST_ASSERT (rv >0 ,"ioctl does not report bad guest memory access" );/* Bad host address: */ - ksmo.gaddr = (uintptr_t )mem1; - ksmo.flags =0 ; - ksmo.size = maxsize; - ksmo.op =KVM_S390_MEMOP_LOGICAL_WRITE ; - ksmo.buf =0 ; - ksmo.ar =0 ; - rv =_vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); + rv =_vcpu_write_guest (vm, guest_mem1,0 , maxsize);TEST_ASSERT (rv ==-1 && errno ==EFAULT ,"ioctl does not report bad host memory address" ); -/* Bad access register: */ +/* Enable AR mode */ run->psw_mask &= ~(3UL << (63 -17 )); - run->psw_mask |=1UL << (63 -17 );/* Enable AR mode */ -vcpu_run (vm,VCPU_ID );/* To sync new state to SIE block */ - ksmo.gaddr = (uintptr_t )mem1; + run->psw_mask |=1UL << (63 -17 ); +HOST_SYNC (vm,110 ); + +/* Bad access register: */ + ksmo.gaddr = guest_mem1; ksmo.flags =0 ; ksmo.size = maxsize; ksmo.op =KVM_S390_MEMOP_LOGICAL_WRITE ;
@@ -157,8 +577,10 @@ int main(int argc, char *argv[]) ksmo.ar =17 ; rv =_vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo);TEST_ASSERT (rv ==-1 && errno ==EINVAL ,"ioctl allows ARs > 15" ); - run->psw_mask &= ~(3UL << (63 -17 ));/* Disable AR mode */ -vcpu_run (vm,VCPU_ID );/* Run to sync new state */ + +/* Disable AR mode */ + run->psw_mask &= ~(3UL << (63 -17 )); +HOST_SYNC (vm,120 );kvm_vm_free (vm);
Signature · 1 line
2.32.0
RFC PATCH 9/10 KVM: s390: Add capability for storage key extension of MEM_OP IOCTL
In reply to Janis Schoetterl-GlauschAvailability of the KVM_CAP_S390_MEM_OP_SKEY capability signals that:
* The vcpu MEM_OP IOCTL supports storage key checking.
* The vm MEM_OP IOCTL exists.
---
Maybe this should be redesigned. As is, the capability mixes support of storage keys for the vcpu ioctl with the availability of the vm ioctl (which always supports storage keys).
We could have two capabilities, one to indicate the availability of the vm memop and another used to derive the available functionality. Janosch suggested that the second capability indicates the availability of a "query" memop operation.
arch/s390/kvm/kvm-s390.c | 1 + include/uapi/linux/kvm.h | 1 + 2 files changed, 2 insertions(+)
arch/s390/kvm/kvm-s390.c +1 -0
@@ -565,6 +565,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_S390_VCPU_RESETS :case KVM_CAP_SET_GUEST_DEBUG :case KVM_CAP_S390_DIAG318 : +case KVM_CAP_S390_MEM_OP_SKEY : r =1 ;break ;case KVM_CAP_SET_GUEST_DEBUG2 :
include/uapi/linux/kvm.h +1 -0
@@ -1134,6 +1134,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_EXIT_ON_EMULATION_FAILURE 204#define KVM_CAP_ARM_MTE 205#define KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM 206 +#define KVM_CAP_S390_MEM_OP_SKEY 209#ifdef KVM_CAP_IRQ_ROUTING
Signature · 1 line
2.32.0
Christian Borntraeger
maintainerRe: [RFC PATCH v1 09/10] KVM: s390: Add capability for storage key extension of MEM_OP IOCTL
Am 18.01.22 um 10:52 schrieb Janis Schoetterl-Glausch:
Quoted 10 lines
Availability of the
KVM_CAP_S390_MEM_OP_SKEYcapability signals that:
* The vcpuMEM_OPIOCTL supports storage key checking.
* The vmMEM_OPIOCTL exists.Signed-off-by Janis Schoetterl-Glausch <[email protected]>---
Maybe this should be redesigned. As is, the capability mixes support of storage keys for the vcpu ioctl with the availability of the vm ioctl (which always supports storage keys).
Quoted 4 lines
We could have two capabilities, one to indicate the availability of the vm memop and another used to derive the available functionality. Janosch suggested that the second capability indicates the availability of a "query" memop operation.
I think one capability covering both changes is totally fine as long as we document that in api.rst.
Quoted 29 lines
arch/s390/kvm/kvm-s390.c | 1 + include/uapi/linux/kvm.h | 1 + 2 files changed, 2 insertions(+)arch/s390/kvm/kvm-s390.c +1
-0@@ -565,6 +565,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_S390_VCPU_RESETS :case KVM_CAP_SET_GUEST_DEBUG :case KVM_CAP_S390_DIAG318 : +case KVM_CAP_S390_MEM_OP_SKEY : r =1 ;break ;case KVM_CAP_SET_GUEST_DEBUG2 :include/uapi/linux/kvm.h +1
-0@@ -1134,6 +1134,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_EXIT_ON_EMULATION_FAILURE 204#define KVM_CAP_ARM_MTE 205#define KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM 206 +#define KVM_CAP_S390_MEM_OP_SKEY 209#ifdef KVM_CAP_IRQ_ROUTING
RFC PATCH 10/10 KVM: s390: selftests: Make use of capability in MEM_OP test
In reply to Janis Schoetterl-GlauschOnly test the functionality whose availability is indicated by KVM_CAP_S390_MEM_OP_SKEY if the capability indicates support.
--- tools/testing/selftests/kvm/s390x/memop.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)
tools/testing/selftests/kvm/s390x/memop.c +13 -1
@@ -308,6 +308,7 @@ int main(int argc, char *argv[])struct kvm_vm *vm;struct kvm_run *run;struct kvm_s390_mem_op ksmo; +bool has_skey_ext;vm_vaddr_t guest_mem1;vm_vaddr_t guest_mem2;vm_paddr_t guest_mem1_abs;
@@ -322,6 +323,9 @@ int main(int argc, char *argv[]) }if (maxsize >sizeof (mem1)) maxsize =sizeof (mem1); + has_skey_ext =kvm_check_cap (KVM_CAP_S390_MEM_OP_SKEY ); +if (!has_skey_ext) +print_skip ("CAP_S390_MEM_OP_SKEY not supported" );/* Create VM */ vm =vm_create_default (VCPU_ID ,0 , guest_code);
@@ -342,7 +346,7 @@ int main(int argc, char *argv[])TEST_ASSERT (!memcmp (mem1, mem2, maxsize),"Memory contents do not match!" ); - { +if (has_skey_ext) {vm_vaddr_t guest_0_page =vm_vaddr_alloc (vm,PAGE_SIZE ,0 );vm_vaddr_t guest_last_page =vm_vaddr_alloc (vm,PAGE_SIZE , last_page_addr);vm_paddr_t guest_mem2_abs =addr_gva2gpa (vm, guest_mem2);
@@ -515,6 +519,14 @@ int main(int argc, char *argv[])TEST_ASSERT (rv !=0 ,"Fetch should result in exception" ); rv =_vm_read_guest_key (vm, mem2,addr_gva2gpa (vm,0 ),2048 ,2 );TEST_ASSERT (rv ==4 ,"Fetch should result in protection exception" ); + }else { +struct ucall uc; + +do { +vcpu_run (vm,VCPU_ID ); +get_ucall (vm,VCPU_ID , &uc); +ASSERT_EQ (uc.cmd,UCALL_SYNC ); + }while (uc.args[1 ] <100 ); }/* Check error conditions */
Signature · 1 line
2.32.0