KVM: s390: Changes for 5.18 part1
Subsystems (5)
Christian Borntraeger
maintainerPaolo,
first part of the s390 parts of KVM for 5.18. This is on top of the fix that went into Linus tree, so it will move kvm/next to something between rc3 and rc4.
I added 2 later fixups for the storage key patches on top. Let me know if you prefer them folded in.
We might do a 2nd pull request later on depending on timing, review and other constraints
with
- rewritten selftest for memop
- ultravisor device (could also go via s390 tree)
- parts/all of Claudios lazy destroy
- parts/all of PCI passthru (could be later and might go via s390 tree as well via a topic branch)
- followup to guest entry/exit work if we find a small solution
- adapter interruption virtualization facility for secure guests
The following changes since commit 09a93c1df3eafa43bcdfd7bf837c574911f12f55:
Merge tag 'kvm-s390-kernel-access' from emailed bundle (2022-02-09 09:14:22 -0800)
are available in the Git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux.git tags/kvm-s390-next-5.18-1
for you to fetch changes up to 3d9042f8b923810c169ece02d91c70ec498eff0b:
KVM: s390: Add missing vm MEM_OP size check (2022-02-22 09:16:18 +0100)
----------------------------------------------------------------
KVM: s390: Changes for 5.18 part1
- add Claudio as Maintainer
- first step to do proper storage key checking
- testcase for missing memop check
----------------------------------------------------------------
Christian Borntraeger (1):
KVM: s390: MAINTAINERS: promote Claudio Imbrenda
Janis Schoetterl-Glausch (11):
s390/uaccess: Add copy_from/to_user_key functions
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: Add capability for storage key extension of MEM_OP IOCTL
KVM: s390: Update api documentation for memop ioctl
KVM: s390: Clarify key argument for MEM_OP in api docs
KVM: s390: Add missing vm MEM_OP size check
Thomas Huth (1):
selftests: kvm: Check whether SIDA memop fails for normal guests
Documentation/virt/kvm/api.rst | 112 ++++++++++--- MAINTAINERS | 2 +- arch/s390/include/asm/ctl_reg.h | 2 + arch/s390/include/asm/page.h | 2 + arch/s390/include/asm/uaccess.h | 22 +++ arch/s390/kvm/gaccess.c | 250 ++++++++++++++++++++++++++++-- arch/s390/kvm/gaccess.h | 86 ++++++++-- arch/s390/kvm/intercept.c | 12 +- arch/s390/kvm/kvm-s390.c | 132 +++++++++++++--- arch/s390/kvm/priv.c | 66 ++++---- arch/s390/lib/uaccess.c | 81 +++++++--- include/uapi/linux/kvm.h | 11 +- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/s390x/memop.c | 15 ++ tools/testing/selftests/kvm/s390x/tprot.c | 227 +++++++++++++++++++++++++++ 16 files changed, 897 insertions(+), 125 deletions(-) create mode 100644 tools/testing/selftests/kvm/s390x/tprot.c
Christian Borntraeger
maintainer[GIT PULL 01/13] KVM: s390: MAINTAINERS: promote Claudio Imbrenda
Claudio has volunteered to be more involved in the maintainership of s390 KVM.
--- MAINTAINERS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
MAINTAINERS +1 -1
@@ -10547,8 +10547,8 @@ F: arch/riscv/kvm/ KERNEL VIRTUAL MACHINE for s390 (KVM/s390) M: Christian Borntraeger <[email protected]> M: Janosch Frank <[email protected]> +M: Claudio Imbrenda <[email protected]> R: David Hildenbrand <[email protected]> -R: Claudio Imbrenda <[email protected]> L: [email protected] S: Supported W: http://www.ibm.com/developerworks/linux/linux390/
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 02/13] s390/uaccess: Add copy_from/to_user_key functions
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Add copy_from/to_user_key functions, which perform storage key checking. These functions can be used by KVM for emulating instructions that need to be key checked.
These functions differ from their non _key counterparts in include/linux/uaccess.h only in the additional key argument and must be kept in sync with those.
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_key by enhancing the existing implementation.
--- arch/s390/include/asm/uaccess.h | 22 +++++++++ arch/s390/lib/uaccess.c | 81 +++++++++++++++++++++++++-------- 2 files changed, 85 insertions(+), 18 deletions(-)
arch/s390/include/asm/uaccess.h +22 -0
@@ -44,6 +44,28 @@ raw_copy_to_user(void __user *to, const void *from, unsigned long n);#define INLINE_COPY_TO_USER #endif +unsigned long __must_check +_copy_from_user_key (void *to,const void __user *from,unsigned long n,unsigned long key); + +static __always_inline unsigned long __must_check +copy_from_user_key (void *to,const void __user *from,unsigned long n,unsigned long key) +{ +if (likely (check_copy_size (to, n, false))) + n =_copy_from_user_key (to, from, n, key); +return n; +} + +unsigned long __must_check +_copy_to_user_key (void __user *to,const void *from,unsigned long n,unsigned long key); + +static __always_inline unsigned long __must_check +copy_to_user_key (void __user *to,const void *from,unsigned long n,unsigned long key) +{ +if (likely (check_copy_size (from, n, true))) + n =_copy_to_user_key (to, from, n, key); +return n; +} +int __put_user_bad (void ) __attribute__((noreturn));int __get_user_bad (void ) __attribute__((noreturn));
arch/s390/lib/uaccess.c +63 -18
168 lines not on this page · raw message
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 04/13] KVM: s390: handle_tprot: Honor storage keys
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Use 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
@@ -1118,15 +1118,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) -{ -u8 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, u8 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,u8 access_key);
arch/s390/kvm/priv.c +35 -31
88 lines not on this page · raw message
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 10/13] KVM: s390: Update api documentation for memop ioctl
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Document all currently existing operations, flags and explain under which circumstances they are available. Document the recently introduced absolute operations and the storage key protection flag, as well as the existing SIDA operations.
--- Documentation/virt/kvm/api.rst | 112 ++++++++++++++++++++++++++------- include/uapi/linux/kvm.h | 2 +- 2 files changed, 91 insertions(+), 23 deletions(-)
Documentation/virt/kvm/api.rst +90 -22
@@ -3683,15 +3683,17 @@ The fields in each entry are defined as follows: 4.89 KVM_S390_MEM_OP -------------------- -:Capability: KVM_CAP_S390_MEM_OP +:Capability: KVM_CAP_S390_MEM_OP, KVM_CAP_S390_PROTECTED, KVM_CAP_S390_MEM_OP_EXTENSION :Architectures: s390 -:Type: vcpu ioctl +:Type: vm ioctl, vcpu ioctl :Parameters: struct kvm_s390_mem_op (in) :Returns: = 0 on success, < 0 on generic error (e.g. -EFAULT or -ENOMEM), > 0 if an exception occurred while walking the page tables -Read or write data from/to the logical (virtual) memory of a VCPU. +Read or write data from/to the VM's memory. +The KVM_CAP_S390_MEM_OP_EXTENSION capability specifies what functionality is +supported. Parameters are specified via the following structure::
@@ -3701,33 +3703,99 @@ Parameters are specified via the following structure:: __u32 size; /* amount of bytes */ __u32 op; /* type of operation */ __u64 buf; /* buffer in userspace */ - __u8 ar; /* the access register number */ - __u8 reserved[31]; /* should be set to 0 */ + union { + struct { + __u8 ar; /* the access register number */ + __u8 key; /* access key, ignored if flag unset */ + }; + __u32 sida_offset; /* offset into the sida */ + __u8 reserved[32]; /* ignored */ + }; }; -The type of operation is specified in the "op" field. It is either -KVM_S390_MEMOP_LOGICAL_READ for reading from logical memory space or -KVM_S390_MEMOP_LOGICAL_WRITE for writing to logical memory space. The -KVM_S390_MEMOP_F_CHECK_ONLY flag can be set in the "flags" field to check -whether the corresponding memory access would create an access exception -(without touching the data in the memory at the destination). In case an -access exception occurred while walking the MMU tables of the guest, the -ioctl returns a positive error number to indicate the type of exception. -This exception is also raised directly at the corresponding VCPU if the -flag KVM_S390_MEMOP_F_INJECT_EXCEPTION is set in the "flags" field. - The start address of the memory region has to be specified in the "gaddr" field, and the length of the region in the "size" field (which must not be 0). The maximum value for "size" can be obtained by checking the KVM_CAP_S390_MEM_OP capability. "buf" is the buffer supplied by the userspace application where the read data should be written to for -KVM_S390_MEMOP_LOGICAL_READ, or where the data that should be written is -stored for a KVM_S390_MEMOP_LOGICAL_WRITE. When KVM_S390_MEMOP_F_CHECK_ONLY -is specified, "buf" is unused and can be NULL. "ar" designates the access -register number to be used; the valid range is 0..15. +a read access, or where the data that should be written is stored for +a write access. The "reserved" field is meant for future extensions. +Reserved and unused values are ignored. Future extension that add members must +introduce new flags. -The "reserved" field is meant for future extensions. It is not used by -KVM with the currently defined set of flags. +The type of operation is specified in the "op" field. Flags modifying +their behavior can be set in the "flags" field. Undefined flag bits must +be set to 0. + +Possible operations are: + * ``KVM_S390_MEMOP_LOGICAL_READ`` + * ``KVM_S390_MEMOP_LOGICAL_WRITE`` + * ``KVM_S390_MEMOP_ABSOLUTE_READ`` + * ``KVM_S390_MEMOP_ABSOLUTE_WRITE`` + * ``KVM_S390_MEMOP_SIDA_READ`` + * ``KVM_S390_MEMOP_SIDA_WRITE`` + +Logical read/write: +^^^^^^^^^^^^^^^^^^^ + +Access logical memory, i.e. translate the given guest address to an absolute +address given the state of the VCPU and use the absolute address as target of +the access. "ar" designates the access register number to be used; the valid +range is 0..15. +Logical accesses are permitted for the VCPU ioctl only. +Logical accesses are permitted for non-protected guests only. + +Supported flags: + * ``KVM_S390_MEMOP_F_CHECK_ONLY`` + * ``KVM_S390_MEMOP_F_INJECT_EXCEPTION`` + * ``KVM_S390_MEMOP_F_SKEY_PROTECTION`` + +The KVM_S390_MEMOP_F_CHECK_ONLY flag can be set to check whether the +corresponding memory access would cause an access exception; however, +no actual access to the data in memory at the destination is performed. +In this case, "buf" is unused and can be NULL. + +In case an access exception occurred during the access (or would occur +in case of KVM_S390_MEMOP_F_CHECK_ONLY), the ioctl returns a positive +error number indicating the type of exception. This exception is also +raised directly at the corresponding VCPU if the flag +KVM_S390_MEMOP_F_INJECT_EXCEPTION is set. + +If the KVM_S390_MEMOP_F_SKEY_PROTECTION flag is set, storage key +protection is also in effect and may cause exceptions if accesses are +prohibited given the access key passed in "key". +KVM_S390_MEMOP_F_SKEY_PROTECTION is available if KVM_CAP_S390_MEM_OP_EXTENSION +is > 0. + +Absolute read/write: +^^^^^^^^^^^^^^^^^^^^ + +Access absolute memory. This operation is intended to be used with the +KVM_S390_MEMOP_F_SKEY_PROTECTION flag, to allow accessing memory and performing +the checks required for storage key protection as one operation (as opposed to +user space getting the storage keys, performing the checks, and accessing +memory thereafter, which could lead to a delay between check and access). +Absolute accesses are permitted for the VM ioctl if KVM_CAP_S390_MEM_OP_EXTENSION +is > 0. +Currently absolute accesses are not permitted for VCPU ioctls. +Absolute accesses are permitted for non-protected guests only. + +Supported flags: + * ``KVM_S390_MEMOP_F_CHECK_ONLY`` + * ``KVM_S390_MEMOP_F_SKEY_PROTECTION`` + +The semantics of the flags are as for logical accesses. + +SIDA read/write: +^^^^^^^^^^^^^^^^ + +Access the secure instruction data area which contains memory operands necessary +for instruction emulation for protected guests. +SIDA accesses are available if the KVM_CAP_S390_PROTECTED capability is available. +SIDA accesses are permitted for the VCPU ioctl only. +SIDA accesses are permitted for protected guests only. + +No flags are supported. 4.90 KVM_S390_GET_SKEYS -----------------------
include/uapi/linux/kvm.h +1 -1
@@ -567,7 +567,7 @@ struct kvm_s390_mem_op {__u8 key;/* access key, ignored if flag unset */ };__u32 sida_offset;/* offset into the sida */ -__u8 reserved[32 ];/* should be set to 0 */ +__u8 reserved[32 ];/* ignored */ }; };/* types for kvm_s390_mem_op->op */
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 05/13] KVM: s390: selftests: Test TEST PROTECTION emulation
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
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.
--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/s390x/tprot.c | 227 ++++++++++++++++++++++ 3 files changed, 229 insertions(+) create mode 100644 tools/testing/selftests/kvm/s390x/tprot.c
tools/testing/selftests/kvm/.gitignore +1 -0
@@ -8,6 +8,7 @@ /s390x/memop /s390x/resets /s390x/sync_regs_test +/s390x/tprot /x86_64/amx_test /x86_64/cpuid_test /x86_64/cr4_cpuid_sync_test
tools/testing/selftests/kvm/Makefile +1 -0
@@ -121,6 +121,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 +227 -0
227 lines not on this page · raw message
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 06/13] KVM: s390: Add optional storage key checking to MEMOP IOCTL
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
User space needs a mechanism to perform key checked accesses when emulating instructions.
The key can be passed as an additional argument.
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 | 31 +++++++++++++++++++++---------- include/uapi/linux/kvm.h | 6 +++++- 2 files changed, 26 insertions(+), 11 deletions(-)
arch/s390/kvm/kvm-s390.c +21 -10
@@ -2359,6 +2359,11 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd)return r; } +static bool access_key_invalid (u8 access_key) +{ +return access_key >0xf ; +} +long kvm_arch_vm_ioctl (struct file *filp,unsigned int ioctl,unsigned long arg) {
@@ -4692,17 +4697,21 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,void *tmpbuf =NULL ;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_SKEY_PROTECTION ;if (mop->flags & ~supported_flags || mop->ar >=NUM_ACRS || !mop->size)return -EINVAL ; -if (mop->size >MEM_OP_MAX_SIZE )return -E2BIG ; -if (kvm_s390_pv_cpu_is_protected (vcpu))return -EINVAL ; - +if (mop->flags &KVM_S390_MEMOP_F_SKEY_PROTECTION ) { +if (access_key_invalid (mop->key)) +return -EINVAL ; + }else { + mop->key =0 ; + }if (!(mop->flags &KVM_S390_MEMOP_F_CHECK_ONLY )) { tmpbuf =vmalloc (mop->size);if (!tmpbuf)
@@ -4712,11 +4721,12 @@ static long kvm_s390_guest_mem_op(struct kvm_vcpu *vcpu,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 , mop->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, mop->key);if (r ==0 ) {if (copy_to_user (uaddr, tmpbuf, mop->size)) r = -EFAULT ;
@@ -4724,15 +4734,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 , mop->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, mop->key);break ; }
include/uapi/linux/kvm.h +5 -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;/* access key, ignored if flag unset */ + };__u32 sida_offset;/* offset into the sida */ __u8 reserved[32 ];/* should be set to 0 */ };
@@ -575,6 +578,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_SKEY_PROTECTION (1ULL << 2)/* for KVM_INTERRUPT */ struct kvm_interrupt {
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 11/13] selftests: kvm: Check whether SIDA memop fails for normal guests
In reply to Christian BorntraegerFrom: Thomas Huth <[email protected]>
Commit 2c212e1baedc ("KVM: s390: Return error on SIDA memop on normal guest") fixed the behavior of the SIDA memops for normal guests. It would be nice to have a way to test whether the current kernel has the fix applied or not. Thus add a check to the KVM selftests for these two memops.
--- tools/testing/selftests/kvm/s390x/memop.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
tools/testing/selftests/kvm/s390x/memop.c +15 -0
@@ -160,6 +160,21 @@ int main(int argc, char *argv[]) run->psw_mask &= ~(3UL << (63 -17 ));/* Disable AR mode */ vcpu_run (vm,VCPU_ID );/* Run to sync new state */ +/* Check that the SIDA calls are rejected for non-protected guests */ + ksmo.gaddr =0 ; + ksmo.flags =0 ; + ksmo.size =8 ; + ksmo.op =KVM_S390_MEMOP_SIDA_READ ; + ksmo.buf = (uintptr_t )mem1; + ksmo.sida_offset =0x1c0 ; + rv =_vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +TEST_ASSERT (rv ==-1 && errno ==EINVAL , +"ioctl does not reject SIDA_READ in non-protected mode" ); + ksmo.op =KVM_S390_MEMOP_SIDA_WRITE ; + rv =_vcpu_ioctl (vm,VCPU_ID ,KVM_S390_MEM_OP , &ksmo); +TEST_ASSERT (rv ==-1 && errno ==EINVAL , +"ioctl does not reject SIDA_WRITE in non-protected mode" ); +kvm_vm_free (vm);return 0 ;
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 13/13] KVM: s390: Add missing vm MEM_OP size check
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Check that size is not zero, preventing the following warning:
WARNING: CPU: 0 PID: 9692 at mm/vmalloc.c:3059 __vmalloc_node_range+0x528/0x648
Modules linked in:
CPU: 0 PID: 9692 Comm: memop Not tainted 5.17.0-rc3-e4+ #80
Hardware name: IBM 8561 T01 701 (LPAR)
Krnl PSW : 0704c00180000000 0000000082dc584c (__vmalloc_node_range+0x52c/0x648)
R:0 T:1 IO:1 EX:1 Key:0 M:1 W:0 P:0 AS:3 CC:0 PM:0 RI:0 EA:3
Krnl GPRS: 0000000000000083 ffffffffffffffff 0000000000000000 0000000000000001
0000038000000000 000003ff80000000 0000000000000cc0 000000008ebb8000
0000000087a8a700 000000004040aeb1 000003ffd9f7dec8 000000008ebb8000
000000009d9b8000 000000000102a1b4 00000380035afb68 00000380035afaa8
Krnl Code: 0000000082dc583e: d028a7f4ff80 trtr 2036(41,%r10),3968(%r15)
0000000082dc5844: af000000 mc 0,0
#0000000082dc5848: af000000 mc 0,0
>0000000082dc584c: a7d90000 lghi %r13,0
0000000082dc5850: b904002d lgr %r2,%r13
0000000082dc5854: eb6ff1080004 lmg %r6,%r15,264(%r15)
0000000082dc585a: 07fe bcr 15,%r14
0000000082dc585c: 47000700 bc 0,1792
Call Trace:
[<0000000082dc584c>] __vmalloc_node_range+0x52c/0x648
[<0000000082dc5b62>] vmalloc+0x5a/0x68
[<000003ff8067f4ca>] kvm_arch_vm_ioctl+0x2da/0x2a30 [kvm]
[<000003ff806705bc>] kvm_vm_ioctl+0x4ec/0x978 [kvm]
[<0000000082e562fe>] __s390x_sys_ioctl+0xbe/0x100
[<000000008360a9bc>] __do_syscall+0x1d4/0x200
[<0000000083618bd2>] system_call+0x82/0xb0Last Breaking-Event-Address:
[<0000000082dc5348>] __vmalloc_node_range+0x28/0x648
Other than the warning, there is no ill effect from the missing check, the condition is detected by subsequent code and causes a return with ENOMEM.
--- arch/s390/kvm/kvm-s390.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/s390/kvm/kvm-s390.c +1 -1
@@ -2374,7 +2374,7 @@ static int kvm_s390_vm_mem_op(struct kvm *kvm, struct kvm_s390_mem_op *mop) supported_flags =KVM_S390_MEMOP_F_SKEY_PROTECTION |KVM_S390_MEMOP_F_CHECK_ONLY ; -if (mop->flags & ~supported_flags) +if (mop->flags & ~supported_flags || !mop->size)return -EINVAL ;if (mop->size >MEM_OP_MAX_SIZE )return -E2BIG ;
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 12/13] KVM: s390: Clarify key argument for MEM_OP in api docs
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Clarify that the key argument represents the access key, not the whole storage key.
--- Documentation/virt/kvm/api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +1 -1
@@ -3763,7 +3763,7 @@ KVM_S390_MEMOP_F_INJECT_EXCEPTION is set. If the KVM_S390_MEMOP_F_SKEY_PROTECTION flag is set, storage key protection is also in effect and may cause exceptions if accesses are -prohibited given the access key passed in "key". +prohibited given the access key designated by "key"; the valid range is 0..15. KVM_S390_MEMOP_F_SKEY_PROTECTION is available if KVM_CAP_S390_MEM_OP_EXTENSION is > 0.
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 08/13] KVM: s390: Rename existing vcpu memop functions
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Makes 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
@@ -4741,8 +4741,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 ;
@@ -4771,8 +4771,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 ;
@@ -4835,8 +4836,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;
@@ -4845,12 +4846,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 ;
@@ -5013,7 +5014,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.35.1
Christian Borntraeger
maintainer[GIT PULL 09/13] KVM: s390: Add capability for storage key extension of MEM_OP IOCTL
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
Availability of the KVM_CAP_S390_MEM_OP_EXTENSION capability signals that:
* The vcpu MEM_OP IOCTL supports storage key checking.
* The vm MEM_OP IOCTL exists.
--- 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
@@ -564,6 +564,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_EXTENSION : r =1 ;break ;case KVM_CAP_SET_GUEST_DEBUG2 :
include/uapi/linux/kvm.h +1 -0
@@ -1140,6 +1140,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_VM_GPA_BITS 207#define KVM_CAP_XSAVE2 208#define KVM_CAP_SYS_ATTRIBUTES 209 +#define KVM_CAP_S390_MEM_OP_EXTENSION 210#ifdef KVM_CAP_IRQ_ROUTING
Signature · 1 line
2.35.1
Christian Borntraeger
maintainer[GIT PULL 03/13] KVM: s390: Honor storage keys when accessing guest memory
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
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_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_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 | 187 ++++++++++++++++++++++++++++++-- arch/s390/kvm/gaccess.h | 79 ++++++++++++-- arch/s390/kvm/intercept.c | 12 +- arch/s390/kvm/kvm-s390.c | 4 +- 6 files changed, 254 insertions(+), 32 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 +175 -12
281 lines not on this page · raw message
arch/s390/kvm/gaccess.h +67 -12
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
@@ -4713,7 +4713,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);
@@ -4725,7 +4725,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.35.1
Christian Borntraeger
maintainer[GIT PULL 07/13] KVM: s390: Add vm IOCTL for key checked guest absolute memory access
In reply to Christian BorntraegerFrom: Janis Schoetterl-Glausch <[email protected]>
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.
Unlike relying on KVM_S390_GET_SKEYS for key checking would, the vm IOCTL performs the check in lockstep with the read or write, by, ultimately, mapping the access to move instructions that support key protection checking with a supplied key.
Fetch and storage protection override are not applicable to absolute accesses and so are not applied as they are when using the vcpu memop.
--- 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,u8 access_key, +enum gacc_mode mode,gpa_t gpa) +{ +u8 storage_key, access_control; +bool fetch_protected; +unsigned long hva; +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) {
@@ -994,6 +1023,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,u8 access_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, access_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,u8 access_key)
@@ -1144,6 +1193,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,u8 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
@@ -193,6 +193,12 @@ int guest_translate_address_with_key(struct kvm_vcpu *vcpu, unsigned long gva, uint check_gva_range (struct kvm_vcpu *vcpu,unsigned long gva,u8 ar,unsigned long length,enum gacc_mode mode,u8 access_key); +int check_gpa_range (struct kvm *kvm,unsigned long gpa,unsigned long length, +enum gacc_mode mode,u8 access_key); + +int access_guest_abs_with_key (struct kvm *kvm,gpa_t gpa,void *data, +unsigned long len,enum gacc_mode mode,u8 access_key); +int access_guest_with_key (struct kvm_vcpu *vcpu,unsigned long ga,u8 ar,void *data,unsigned long len,enum gacc_mode mode,u8 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
@@ -575,6 +575,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.35.1
Christian Borntraeger
maintainerAm 22.02.22 um 10:48 schrieb Christian Borntraeger:
Quoted 6 lines
----------------------------------------------------------------
Christian Borntraeger (1):
KVM: s390:MAINTAINERS: promote Claudio ImbrendaJanis Schoetterl-Glausch (11):
s390/uaccess: Add copy_from/to_user_key functions
Forgot to mention this: this contains one s390 patch that is acked by the s390 maintainer.
Paolo Bonzini
maintainerQuoted 24 lines · Christian Borntraeger
Paolo,
first part of the s390 parts of KVM for 5.18. This is on top of the fix that went into Linus tree, so it will move kvm/next to something between rc3 and rc4.
I added 2 later fixups for the storage key patches on top. Let me know if you prefer them folded in.
We might do a 2nd pull request later on depending on timing, review and other constraints
with
- rewritten selftest for memop
- ultravisor device (could also go via s390 tree)
- parts/all of Claudios lazy destroy
- parts/all of PCI passthru (could be later and might go via s390 tree as well via a topic branch)
- followup to guest entry/exit work if we find a small solution
- adapter interruption virtualization facility for secure guestsThe following changes since commit
09a93c1df3eafa43bcdfd7bf837c574911f12f55:Merge tag 'kvm-s390-kernel-access' from emailed bundle (2022-02-09 09:14:22 -0800)
Quoted 7 lines
are available in the Git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux.git tags/kvm-s390-next-5.18-1for you to fetch changes up to
3d9042f8b923810c169ece02d91c70ec498eff0b:KVM: s390: Add missing vm MEM_OP size check (2022-02-22 09:16:18 +0100)
Pulled, thanks.
Paolo