kvm: s390: Add PV dump support
Subsystems (4)
Janosch Frank
maintainerv6 cover kvm: s390: Add PV dump support
Sometimes dumping inside of a VM fails, is unavailable or doesn't yield the required data. For these occasions we dump the VM from the outside, writing memory and cpu data to a file.
Up to now PV guests only supported dumping from the inside of the guest through dumpers like KDUMP. A PV guest can be dumped from the hypervisor but the data will be stale and / or encrypted.
To get the actual state of the PV VM we need the help of the Ultravisor who safeguards the VM state. New UV calls have been added to initialize the dump, dump storage state data, dump cpu data and complete the dump process.
I chose not to document the dump data provided by the Ultravisor since KVM doesn't interprete it in any way. We're currently searching for a location and enough cycles to make it available to all.
v6:
* Added patch that explains KVM's rc/rrc writes
* Added rev-bys
* Improved documentation
* Reworked capability indication
* Moved the dump completion into a new function
v5:
* v4 went out without a version
* Fixed spelling mistake in query
* Improved the storage state dump code
* Switched to the scheduling uv call for all dump commands
* Fixed the documentation formatting
* Moved the capability into its own patch it shouldn't be part of patch #6
v4:
* Rebased and fixed up conflicts due to the Documentation changes and new KVM capabilities
* Fixed the dump facility check, now we check for all 4 calls
Janosch Frank (11):
s390x: Add SE hdr query information
s390: uv: Add dump fields to query
KVM: s390: pv: Add query interface
KVM: s390: pv: Add dump support definitions
KVM: s390: pv: Add query dump information
kvm: s390: Add configuration dump functionality
kvm: s390: Add CPU dump functionality
kvm: s390: Add KVM_CAP_S390_PROTECTED_DUMP
Documentation: virt: Protected virtual machine dumps Documentation/virt/kvm/api.rst: Add protvirt dump/info api
descriptions
Documentation/virt/kvm/api.rst: Explain rc/rrc delivery
Documentation/virt/kvm/api.rst | 163 ++++++++++- Documentation/virt/kvm/s390/index.rst | 1 + Documentation/virt/kvm/s390/s390-pv-dump.rst | 64 +++++ arch/s390/boot/uv.c | 4 + arch/s390/include/asm/kvm_host.h | 1 + arch/s390/include/asm/uv.h | 45 +++- arch/s390/kernel/uv.c | 53 ++++ arch/s390/kvm/kvm-s390.c | 269 +++++++++++++++++++ arch/s390/kvm/kvm-s390.h | 5 + arch/s390/kvm/pv.c | 199 ++++++++++++++ include/uapi/linux/kvm.h | 55 ++++ 11 files changed, 856 insertions(+), 3 deletions(-) create mode 100644 Documentation/virt/kvm/s390/s390-pv-dump.rst
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 1/11 s390x: Add SE hdr query information
We have information about the supported se header version and pcf bits so let's expose it via the sysfs files.
--- arch/s390/boot/uv.c | 2 ++ arch/s390/include/asm/uv.h | 7 ++++++- arch/s390/kernel/uv.c | 20 ++++++++++++++++++++ 3 files changed, 28 insertions(+), 1 deletion(-)
arch/s390/boot/uv.c +2 -0
@@ -41,6 +41,8 @@ void uv_query_info(void) uv_info.max_num_sec_conf = uvcb.max_num_sec_conf; uv_info.max_guest_cpu_id = uvcb.max_guest_cpu_id; uv_info.uv_feature_indications = uvcb.uv_feature_indications; + uv_info.supp_se_hdr_ver = uvcb.supp_se_hdr_versions; + uv_info.supp_se_hdr_pcf = uvcb.supp_se_hdr_pcf; }#ifdef CONFIG_PROTECTED_VIRTUALIZATION_GUEST
arch/s390/include/asm/uv.h +6 -1
@@ -110,7 +110,10 @@ struct uv_cb_qui {u8 reserved88[158 -136 ];/* 0x0088 */ u16 max_guest_cpu_id;/* 0x009e */ u64 uv_feature_indications;/* 0x00a0 */ -u8 reserveda8[200 -168 ];/* 0x00a8 */ +u64 reserveda8;/* 0x00a8 */ +u64 supp_se_hdr_versions;/* 0x00b0 */ +u64 supp_se_hdr_pcf;/* 0x00b8 */ +u64 reservedc0;/* 0x00c0 */ } __packed__aligned(8) ;/* Initialize Ultravisor */
@@ -307,6 +310,8 @@ struct uv_info {unsigned int max_num_sec_conf;unsigned short max_guest_cpu_id;unsigned long uv_feature_indications; +unsigned long supp_se_hdr_ver; +unsigned long supp_se_hdr_pcf; };extern struct uv_info uv_info;
arch/s390/kernel/uv.c +20 -0
@@ -392,6 +392,24 @@ static ssize_t uv_query_facilities(struct kobject *kobj,static struct kobj_attribute uv_query_facilities_attr =__ATTR (facilities,0444 , uv_query_facilities,NULL ); +static ssize_t uv_query_supp_se_hdr_ver (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"%lx\n" , uv_info.supp_se_hdr_ver); +} + +static struct kobj_attribute uv_query_supp_se_hdr_ver_attr = +__ATTR (supp_se_hdr_ver,0444 , uv_query_supp_se_hdr_ver,NULL ); + +static ssize_t uv_query_supp_se_hdr_pcf (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"%lx\n" , uv_info.supp_se_hdr_pcf); +} + +static struct kobj_attribute uv_query_supp_se_hdr_pcf_attr = +__ATTR (supp_se_hdr_pcf,0444 , uv_query_supp_se_hdr_pcf,NULL ); +static ssize_t uv_query_feature_indications (struct kobject *kobj,struct kobj_attribute *attr,char *buf) {
@@ -437,6 +455,8 @@ static struct attribute *uv_query_attrs[] = { &uv_query_max_guest_cpus_attr.attr, &uv_query_max_guest_vms_attr.attr, &uv_query_max_guest_addr_attr.attr, + &uv_query_supp_se_hdr_ver_attr.attr, + &uv_query_supp_se_hdr_pcf_attr.attr, NULL, };
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 2/11 s390: uv: Add dump fields to query
In reply to Janosch FrankThe new dump feature requires us to know how much memory is needed for the "dump storage state" and "dump finalize" ultravisor call. These values are reported via the UV query call.
--- arch/s390/boot/uv.c | 2 ++ arch/s390/include/asm/uv.h | 5 +++++ arch/s390/kernel/uv.c | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 40 insertions(+)
arch/s390/boot/uv.c +2 -0
@@ -43,6 +43,8 @@ void uv_query_info(void) uv_info.uv_feature_indications = uvcb.uv_feature_indications; uv_info.supp_se_hdr_ver = uvcb.supp_se_hdr_versions; uv_info.supp_se_hdr_pcf = uvcb.supp_se_hdr_pcf; + uv_info.conf_dump_storage_state_len = uvcb.conf_dump_storage_state_len; + uv_info.conf_dump_finalize_len = uvcb.conf_dump_finalize_len; }#ifdef CONFIG_PROTECTED_VIRTUALIZATION_GUEST
arch/s390/include/asm/uv.h +5 -0
@@ -114,6 +114,9 @@ struct uv_cb_qui {u64 supp_se_hdr_versions;/* 0x00b0 */ u64 supp_se_hdr_pcf;/* 0x00b8 */ u64 reservedc0;/* 0x00c0 */ +u64 conf_dump_storage_state_len;/* 0x00c8 */ +u64 conf_dump_finalize_len;/* 0x00d0 */ +u8 reservedd8[256 -216 ];/* 0x00d8 */ } __packed__aligned(8) ;/* Initialize Ultravisor */
@@ -312,6 +315,8 @@ struct uv_info {unsigned long uv_feature_indications;unsigned long supp_se_hdr_ver;unsigned long supp_se_hdr_pcf; +unsigned long conf_dump_storage_state_len; +unsigned long conf_dump_finalize_len; };extern struct uv_info uv_info;
arch/s390/kernel/uv.c +33 -0
@@ -410,6 +410,36 @@ static ssize_t uv_query_supp_se_hdr_pcf(struct kobject *kobj,static struct kobj_attribute uv_query_supp_se_hdr_pcf_attr =__ATTR (supp_se_hdr_pcf,0444 , uv_query_supp_se_hdr_pcf,NULL ); +static ssize_t uv_query_dump_cpu_len (struct kobject *kobj, +struct kobj_attribute *attr,char *page) +{ +return scnprintf (page,PAGE_SIZE ,"%lx\n" , + uv_info.guest_cpu_stor_len); +} + +static struct kobj_attribute uv_query_dump_cpu_len_attr = +__ATTR (uv_query_dump_cpu_len,0444 , uv_query_dump_cpu_len,NULL ); + +static ssize_t uv_query_dump_storage_state_len (struct kobject *kobj, +struct kobj_attribute *attr,char *page) +{ +return scnprintf (page,PAGE_SIZE ,"%lx\n" , + uv_info.conf_dump_storage_state_len); +} + +static struct kobj_attribute uv_query_dump_storage_state_len_attr = +__ATTR (dump_storage_state_len,0444 , uv_query_dump_storage_state_len,NULL ); + +static ssize_t uv_query_dump_finalize_len (struct kobject *kobj, +struct kobj_attribute *attr,char *page) +{ +return scnprintf (page,PAGE_SIZE ,"%lx\n" , + uv_info.conf_dump_finalize_len); +} + +static struct kobj_attribute uv_query_dump_finalize_len_attr = +__ATTR (dump_finalize_len,0444 , uv_query_dump_finalize_len,NULL ); +static ssize_t uv_query_feature_indications (struct kobject *kobj,struct kobj_attribute *attr,char *buf) {
@@ -457,6 +487,9 @@ static struct attribute *uv_query_attrs[] = { &uv_query_max_guest_addr_attr.attr, &uv_query_supp_se_hdr_ver_attr.attr, &uv_query_supp_se_hdr_pcf_attr.attr, + &uv_query_dump_storage_state_len_attr.attr, + &uv_query_dump_finalize_len_attr.attr, + &uv_query_dump_cpu_len_attr.attr, NULL, };
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 3/11 KVM: s390: pv: Add query interface
In reply to Janosch FrankSome of the query information is already available via sysfs but having a IOCTL makes the information easier to retrieve.
--- arch/s390/kvm/kvm-s390.c | 76 ++++++++++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 25 +++++++++++++ 2 files changed, 101 insertions(+)
arch/s390/kvm/kvm-s390.c +76 -0
@@ -2224,6 +2224,42 @@ static int kvm_s390_cpus_to_pv(struct kvm *kvm, u16 *rc, u16 *rrc)return r; } +/* +* Here we provide user space with a direct interface to query UV +* related data like UV maxima and available features as well as +* feature specific data. +* +* To facilitate future extension of the data structures we'll try to +* write data up to the maximum requested length. +*/ +static ssize_t kvm_s390_handle_pv_info (struct kvm_s390_pv_info *info) +{ +ssize_t len_min; + +switch (info->header.id) { +case KVM_PV_INFO_VM : { + len_min =sizeof (info->header) +sizeof (info->vm); + +if (info->header.len_max < len_min) +return -EINVAL ; + +memcpy (info->vm.inst_calls_list, + uv_info.inst_calls_list, +sizeof (uv_info.inst_calls_list)); + +/* It's max cpuid not max cpus, so it's off by one */ + info->vm.max_cpus = uv_info.max_guest_cpu_id +1 ; + info->vm.max_guests = uv_info.max_num_sec_conf; + info->vm.max_guest_addr = uv_info.max_sec_stor_addr; + info->vm.feature_indication = uv_info.uv_feature_indications; + +return len_min; + } +default : +return -EINVAL ; + } +} +static int kvm_s390_handle_pv (struct kvm *kvm,struct kvm_pv_cmd *cmd) {int r =0 ;
@@ -2360,6 +2396,46 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd) cmd->rc, cmd->rrc);break ; } +case KVM_PV_INFO : { +struct kvm_s390_pv_info info = {}; +ssize_t data_len; + +/* +* No need to check the VM protection here. +* +* Maybe user space wants to query some of the data +* when the VM is still unprotected. If we see the +* need to fence a new data command we can still +* return an error in the info handler. +*/ + + r = -EFAULT ; +if (copy_from_user (&info, argp,sizeof (info.header))) +break ; + + r = -EINVAL ; +if (info.header.len_max <sizeof (info.header)) +break ; + + data_len =kvm_s390_handle_pv_info (&info); +if (data_len <0 ) { + r = data_len; +break ; + } +/* +* If a data command struct is extended (multiple +* times) this can be used to determine how much of it +* is valid. +*/ + info.header.len_written = data_len; + + r = -EFAULT ; +if (copy_to_user (argp, &info, data_len)) +break ; + + r =0 ; +break ; + }default : r = -ENOTTY ; }
include/uapi/linux/kvm.h +25 -0
@@ -1645,6 +1645,30 @@ struct kvm_s390_pv_unp {__u64 tweak; }; +enum pv_cmd_info_id { +KVM_PV_INFO_VM , +}; + +struct kvm_s390_pv_info_vm { +__u64 inst_calls_list[4 ]; +__u64 max_cpus; +__u64 max_guests; +__u64 max_guest_addr; +__u64 feature_indication; +}; + +struct kvm_s390_pv_info_header { +__u32 id; +__u32 len_max; +__u32 len_written; +__u32 reserved; +}; + +struct kvm_s390_pv_info { +struct kvm_s390_pv_info_header header; +struct kvm_s390_pv_info_vm vm; +}; +enum pv_cmd_id {KVM_PV_ENABLE ,KVM_PV_DISABLE ,
@@ -1653,6 +1677,7 @@ enum pv_cmd_id {KVM_PV_VERIFY ,KVM_PV_PREP_RESET ,KVM_PV_UNSHARE_ALL , + KVM_PV_INFO, }; struct kvm_pv_cmd {
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 4/11 KVM: s390: pv: Add dump support definitions
In reply to Janosch FrankLet's add the constants and structure definitions needed for the dump support.
--- arch/s390/include/asm/uv.h | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
arch/s390/include/asm/uv.h +33 -0
@@ -50,6 +50,10 @@#define UVC_CMD_SET_UNSHARE_ALL 0x0340#define UVC_CMD_PIN_PAGE_SHARED 0x0341#define UVC_CMD_UNPIN_PAGE_SHARED 0x0342 +#define UVC_CMD_DUMP_INIT 0x0400 +#define UVC_CMD_DUMP_CONF_STOR_STATE 0x0401 +#define UVC_CMD_DUMP_CPU 0x0402 +#define UVC_CMD_DUMP_COMPLETE 0x0403#define UVC_CMD_SET_SHARED_ACCESS 0x1000#define UVC_CMD_REMOVE_SHARED_ACCESS 0x1001#define UVC_CMD_RETR_ATTEST 0x1020
@@ -77,6 +81,10 @@ enum uv_cmds_inst {BIT_UVC_CMD_UNSHARE_ALL =20 ,BIT_UVC_CMD_PIN_PAGE_SHARED =21 ,BIT_UVC_CMD_UNPIN_PAGE_SHARED =22 , +BIT_UVC_CMD_DUMP_INIT =24 , +BIT_UVC_CMD_DUMP_CONFIG_STOR_STATE =25 , +BIT_UVC_CMD_DUMP_CPU =26 , +BIT_UVC_CMD_DUMP_COMPLETE =27 , BIT_UVC_CMD_RETR_ATTEST = 28, };
@@ -246,6 +254,31 @@ struct uv_cb_attest {u64 reserved168[4 ];/* 0x0168 */ } __packed__aligned(8) ; +struct uv_cb_dump_cpu { +struct uv_cb_header header; +u64 reserved08[2 ]; +u64 cpu_handle; +u64 dump_area_origin; +u64 reserved28[5 ]; +} __packed__aligned(8) ; + +struct uv_cb_dump_stor_state { +struct uv_cb_header header; +u64 reserved08[2 ]; +u64 config_handle; +u64 dump_area_origin; +u64 gaddr; +u64 reserved28[4 ]; +} __packed__aligned(8) ; + +struct uv_cb_dump_complete { +struct uv_cb_header header; +u64 reserved08[2 ]; +u64 config_handle; +u64 dump_area_origin; +u64 reserved30[5 ]; +} __packed__aligned(8) ; +static inline int __uv_call (unsigned long r1,unsigned long r2) {int cc;
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 5/11 KVM: s390: pv: Add query dump information
In reply to Janosch FrankThe dump API requires userspace to provide buffers into which we will store data. The dump information added in this patch tells userspace how big those buffers need to be.
--- arch/s390/kvm/kvm-s390.c | 11 +++++++++++ include/uapi/linux/kvm.h | 12 +++++++++++- 2 files changed, 22 insertions(+), 1 deletion(-)
arch/s390/kvm/kvm-s390.c +11 -0
@@ -2255,6 +2255,17 @@ static ssize_t kvm_s390_handle_pv_info(struct kvm_s390_pv_info *info)return len_min; } +case KVM_PV_INFO_DUMP : { + len_min =sizeof (info->header) +sizeof (info->dump); + +if (info->header.len_max < len_min) +return -EINVAL ; + + info->dump.dump_cpu_buffer_len = uv_info.guest_cpu_stor_len; + info->dump.dump_config_mem_buffer_per_1m = uv_info.conf_dump_storage_state_len; + info->dump.dump_config_finalize_len = uv_info.conf_dump_finalize_len; +return len_min; + }default :return -EINVAL ; }
include/uapi/linux/kvm.h +11 -1
@@ -1647,6 +1647,13 @@ struct kvm_s390_pv_unp {enum pv_cmd_info_id {KVM_PV_INFO_VM , +KVM_PV_INFO_DUMP , +}; + +struct kvm_s390_pv_info_dump { +__u64 dump_cpu_buffer_len; +__u64 dump_config_mem_buffer_per_1m; +__u64 dump_config_finalize_len; };struct kvm_s390_pv_info_vm {
@@ -1666,7 +1673,10 @@ struct kvm_s390_pv_info_header {struct kvm_s390_pv_info {struct kvm_s390_pv_info_header header; -struct kvm_s390_pv_info_vm vm; +union { +struct kvm_s390_pv_info_dump dump; +struct kvm_s390_pv_info_vm vm; + }; };enum pv_cmd_id {
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 6/11 kvm: s390: Add configuration dump functionality
In reply to Janosch FrankSometimes dumping inside of a VM fails, is unavailable or doesn't yield the required data. For these occasions we dump the VM from the outside, writing memory and cpu data to a file.
Up to now PV guests only supported dumping from the inside of the guest through dumpers like KDUMP. A PV guest can be dumped from the hypervisor but the data will be stale and / or encrypted.
To get the actual state of the PV VM we need the help of the Ultravisor who safeguards the VM state. New UV calls have been added to initialize the dump, dump storage state data, dump cpu data and complete the dump process. We expose these calls in this patch via a new UV ioctl command.
The sensitive parts of the dump data are encrypted, the dump key is derived from the Customer Communication Key (CCK). This ensures that only the owner of the VM who has the CCK can decrypt the dump data.
The memory is dumped / read via a normal export call and a re-import after the dump initialization is not needed (no re-encryption with a dump key).
--- arch/s390/include/asm/kvm_host.h | 1 + arch/s390/kvm/kvm-s390.c | 93 ++++++++++++++++ arch/s390/kvm/kvm-s390.h | 4 + arch/s390/kvm/pv.c | 183 +++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 15 +++ 5 files changed, 296 insertions(+)
arch/s390/include/asm/kvm_host.h +1 -0
@@ -923,6 +923,7 @@ struct kvm_s390_pv {u64 guest_len;unsigned long stor_base;void *stor_var; +bool dumping; };struct kvm_arch {
arch/s390/kvm/kvm-s390.c +93 -0
111 lines not on this page · raw message
arch/s390/kvm/kvm-s390.h +4 -0
@@ -250,6 +250,10 @@ int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc,int kvm_s390_pv_unpack (struct kvm *kvm,unsigned long addr,unsigned long size,unsigned long tweak,u16 *rc,u16 *rrc);int kvm_s390_pv_set_cpu_state (struct kvm_vcpu *vcpu,u8 state); +int kvm_s390_pv_dump_stor_state (struct kvm *kvm,void __user *buff_user, +u64 *gaddr,u64 buff_user_len,u16 *rc,u16 *rrc); +int kvm_s390_pv_dump_complete (struct kvm *kvm,void __user *buff_user, +u16 *rc,u16 *rrc);static inline u64 kvm_s390_pv_get_handle (struct kvm *kvm) {
arch/s390/kvm/pv.c +183 -0
192 lines not on this page · raw message
include/uapi/linux/kvm.h +15 -0
@@ -1645,6 +1645,20 @@ struct kvm_s390_pv_unp {__u64 tweak; }; +enum pv_cmd_dmp_id { +KVM_PV_DUMP_INIT , +KVM_PV_DUMP_CONFIG_STOR_STATE , +KVM_PV_DUMP_COMPLETE , +}; + +struct kvm_s390_pv_dmp { +__u64 subcmd; +__u64 buff_addr; +__u64 buff_len; +__u64 gaddr;/* For dump storage state */ +__u64 reserved[4 ]; +}; +enum pv_cmd_info_id {KVM_PV_INFO_VM ,KVM_PV_INFO_DUMP ,
@@ -1688,6 +1702,7 @@ enum pv_cmd_id {KVM_PV_PREP_RESET ,KVM_PV_UNSHARE_ALL ,KVM_PV_INFO , + KVM_PV_DUMP, }; struct kvm_pv_cmd {
Signature · 1 line
2.34.1
Re: [PATCH v6 06/11] kvm: s390: Add configuration dump functionality
Quoted 335 lines · On Tue, 17 May 2022 16:36:24 +0000 Janosch Frank <[email protected]> wrote:
Sometimes dumping inside of a VM fails, is unavailable or doesn't yield the required data. For these occasions we dump the VM from the outside, writing memory and cpu data to a file.
Up to now PV guests only supported dumping from the inside of the guest through dumpers like KDUMP. A PV guest can be dumped from the hypervisor but the data will be stale and / or encrypted.
To get the actual state of the PV VM we need the help of the Ultravisor who safeguards the VM state. New UV calls have been added to initialize the dump, dump storage state data, dump cpu data and complete the dump process. We expose these calls in this patch via a new UV ioctl command.
The sensitive parts of the dump data are encrypted, the dump key is derived from the Customer Communication Key (CCK). This ensures that only the owner of the VM who has the CCK can decrypt the dump data.
The memory is dumped / read via a normal export call and a re-import after the dump initialization is not needed (no re-encryption with a dump key).
Signed-off-by Janosch Frank <[email protected]>--- arch/s390/include/asm/kvm_host.h | 1 + arch/s390/kvm/kvm-s390.c | 93 ++++++++++++++++ arch/s390/kvm/kvm-s390.h | 4 + arch/s390/kvm/pv.c | 183 +++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 15 +++ 5 files changed, 296 insertions(+)arch/s390/include/asm/kvm_host.h +1
-0@@ -923,6 +923,7 @@ struct kvm_s390_pv {u64 guest_len;unsigned long stor_base;void *stor_var; +bool dumping; };struct kvm_arch {arch/s390/kvm/kvm-s390.c +93
-0@@ -2271,6 +2271,68 @@ static ssize_t kvm_s390_handle_pv_info(struct kvm_s390_pv_info *info) } } +static int kvm_s390_pv_dmp (struct kvm *kvm,struct kvm_pv_cmd *cmd, +struct kvm_s390_pv_dmp dmp) +{ +int r = -EINVAL ; +void __user *result_buff = (void __user *)dmp.buff_addr; + +switch (dmp.subcmd) { +case KVM_PV_DUMP_INIT : { +if (kvm->arch.pv.dumping) +break ; + +/* +* Block SIE entry as concurrent dump UVCs could lead +* to validities. +*/ +kvm_s390_vcpu_block_all (kvm); + + r =uv_cmd_nodata (kvm_s390_pv_get_handle (kvm), +UVC_CMD_DUMP_INIT , &cmd->rc, &cmd->rrc); +KVM_UV_EVENT (kvm,3 ,"PROTVIRT DUMP INIT: rc %x rrc %x" , + cmd->rc, cmd->rrc); +if (!r) { + kvm->arch.pv.dumping = true; + }else { +kvm_s390_vcpu_unblock_all (kvm); + r = -EINVAL ; + } +break ; + } +case KVM_PV_DUMP_CONFIG_STOR_STATE : { +if (!kvm->arch.pv.dumping) +break ; + +/* +* gaddr is an output parameter since we might stop +* early. As dmp will be copied back in our caller, we +* don't need to do it ourselves. +*/ + r =kvm_s390_pv_dump_stor_state (kvm, result_buff, &dmp.gaddr, dmp.buff_len, + &cmd->rc, &cmd->rrc); +break ; + } +case KVM_PV_DUMP_COMPLETE : { +if (!kvm->arch.pv.dumping) +break ; + + r = -EINVAL ; +if (dmp.buff_len < uv_info.conf_dump_finalize_len) +break ; + + r =kvm_s390_pv_dump_complete (kvm, result_buff, + &cmd->rc, &cmd->rrc); +break ; + } +default : + r = -ENOTTY ; +break ; + } + +return r; +} +static int kvm_s390_handle_pv (struct kvm *kvm,struct kvm_pv_cmd *cmd) {int r =0 ;@@ -2447,6 +2509,28 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd) r =0 ;break ; } +case KVM_PV_DUMP : { +struct kvm_s390_pv_dmp dmp; + + r = -EINVAL ; +if (!kvm_s390_pv_is_protected (kvm)) +break ; + + r = -EFAULT ; +if (copy_from_user (&dmp, argp,sizeof (dmp))) +break ; + + r =kvm_s390_pv_dmp (kvm, cmd, dmp); +if (r) +break ; + +if (copy_to_user (argp, &dmp,sizeof (dmp))) { + r = -EFAULT ; +break ; + } + +break ; + }default : r = -ENOTTY ; }@@ -4555,6 +4639,15 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)struct kvm_run *kvm_run = vcpu->run;int rc; +/* +* Running a VM while dumping always has the potential to +* produce inconsistent dump data. But for PV vcpus a SIE +* entry while dumping could also lead to a fatal validity +* intercept which we absolutely want to avoid. +*/ +if (vcpu->kvm->arch.pv.dumping) +return -EINVAL ; +if (kvm_run->immediate_exit)return -EINTR ;arch/s390/kvm/kvm-s390.h +4
-0@@ -250,6 +250,10 @@ int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc,int kvm_s390_pv_unpack (struct kvm *kvm,unsigned long addr,unsigned long size,unsigned long tweak,u16 *rc,u16 *rrc);int kvm_s390_pv_set_cpu_state (struct kvm_vcpu *vcpu,u8 state); +int kvm_s390_pv_dump_stor_state (struct kvm *kvm,void __user *buff_user, +u64 *gaddr,u64 buff_user_len,u16 *rc,u16 *rrc); +int kvm_s390_pv_dump_complete (struct kvm *kvm,void __user *buff_user, +u16 *rc,u16 *rrc);static inline u64 kvm_s390_pv_get_handle (struct kvm *kvm) {arch/s390/kvm/pv.c +144
-0@@ -7,6 +7,7 @@*/ #include <linux/kvm.h> #include <linux/kvm_host.h> +#include <linux/minmax.h> #include <linux/pagemap.h> #include <linux/sched/signal.h> #include <asm/gmap.h> @@ -303,3 +304,185 @@ int kvm_s390_pv_set_cpu_state(struct kvm_vcpu *vcpu, u8 state)return -EINVAL ;return 0 ; } + +/* Size of the cache for the storage state dump data. 1MB for now */ +#define DUMP_BUFF_LEN HPAGE_SIZE + +/** +* kvm_s390_pv_dump_stor_state +* +* @kvm: pointer to the guest's KVM struct +* @buff_user: Userspace pointer where we will write the results to +* @gaddr: Starting absolute guest address for which the storage state +* is requested. +* @buff_user_len: Length of the buff_user buffer +* @rc: Pointer to where the uvcb return code is stored +* @rrc: Pointer to where the uvcb return reason code is stored +* +* Stores buff_len bytes of tweak component values to buff_user +* starting with the 1MB block specified by the absolute guest address +* (gaddr). The gaddr pointer will be updated with the last address +* for which data was written when returning to userspace. buff_user +* might be written to even if an error rc is returned. For instance +* if we encounter a fault after writing the first page of data. +* +* Context: kvm->lock needs to be held +* +* Return: +* 0 on success +* -ENOMEM if allocating the cache fails +* -EINVAL if gaddr is not aligned to 1MB +* -EINVAL if buff_user_len is not aligned to uv_info.conf_dump_storage_state_len +* -EINVAL if the UV call fails, rc and rrc will be set in this case +* -EFAULT if copying the result to buff_user failed +*/ +int kvm_s390_pv_dump_stor_state (struct kvm *kvm,void __user *buff_user, +u64 *gaddr,u64 buff_user_len,u16 *rc,u16 *rrc) +{ +struct uv_cb_dump_stor_state uvcb = { + .header.cmd =UVC_CMD_DUMP_CONF_STOR_STATE , + .header.len =sizeof (uvcb), + .config_handle = kvm->arch.pv.handle, + .gaddr = *gaddr, + .dump_area_origin =0 , + }; +const u64 increment_len = uv_info.conf_dump_storage_state_len; +size_t buff_kvm_size; +size_t size_done =0 ; +u8 *buff_kvm =NULL ; +int cc, ret; + + ret = -EINVAL ; +/* UV call processes 1MB guest storage chunks at a time */ +if (!IS_ALIGNED (*gaddr,HPAGE_SIZE )) + goto out; + +/* +* We provide the storage state for 1MB chunks of guest +* storage. The buffer will need to be aligned to +* conf_dump_storage_state_len so we don't end on a partial +* chunk. +*/ +if (!buff_user_len || + !IS_ALIGNED (buff_user_len, increment_len)) + goto out; + +/* +* Allocate a buffer from which we will later copy to the user +* process. We don't want userspace to dictate our buffer size +* so we limit it to DUMP_BUFF_LEN. +*/ + ret = -ENOMEM ; + buff_kvm_size =min_t (u64, buff_user_len,DUMP_BUFF_LEN ); + buff_kvm =vzalloc (buff_kvm_size); +if (!buff_kvm) + goto out; + + ret =0 ; + uvcb.dump_area_origin = (u64 )buff_kvm; +/* We will loop until the user buffer is filled or an error occurs */ +do { +/* Get 1MB worth of guest storage state data */ + cc =uv_call_sched (0 , (u64)&uvcb); + +/* All or nothing */ +if (cc) { + ret = -EINVAL ; +break ; + } + + size_done += increment_len; + uvcb.dump_area_origin += increment_len; + buff_user_len -= increment_len; + uvcb.gaddr +=HPAGE_SIZE ; + +/* KVM Buffer full, time to copy to the process */ +if (!buff_user_len || size_done ==DUMP_BUFF_LEN ) { +if (copy_to_user (buff_user, buff_kvm, size_done)) { + ret = -EFAULT ; +break ; + } + + buff_user += size_done; + size_done =0 ; + uvcb.dump_area_origin = (u64 )buff_kvm; + } + }while (buff_user_len); + +/* Report back where we ended dumping */ + *gaddr = uvcb.gaddr; + +/* Lets only log errors, we don't want to spam */ +out: +if (ret) +KVM_UV_EVENT (kvm,3 , +"PROTVIRT DUMP STORAGE STATE: addr %llx ret %d, uvcb rc %x rrc %x" , + uvcb.gaddr, ret, uvcb.header.rc, uvcb.header.rrc); + *rc = uvcb.header.rc; + *rrc = uvcb.header.rrc; +vfree (buff_kvm); + +return ret; +} + +/** +* kvm_s390_pv_dump_complete +* +* @kvm: pointer to the guest's KVM struct +* @buff_user: Userspace pointer where we will write the results to +* @rc: Pointer to where the uvcb return code is stored +* @rrc: Pointer to where the uvcb return reason code is stored +* +* Completes the dumping operation and writes the completion data to +* user space. +* +* Context: kvm->lock needs to be held +* +* Return: +* 0 on success +* -ENOMEM if allocating the completion buffer fails +* -EINVAL if the UV call fails, rc and rrc will be set in this case +* -EFAULT if copying the result to buff_user failed +*/ +int kvm_s390_pv_dump_complete (struct kvm *kvm,void __user *buff_user, +u16 *rc,u16 *rrc) +{
arch/s390/kvm/pv.c int kvm_s390_pv_set_cpu_state(struct kvm_vcpu *vcpu, u8 state) · line 459
Quoted 10 lines
arch/s390/kvm/pv.c +10
-0+struct uv_cb_dump_complete complete = { + .header.len =sizeof (complete), + .header.cmd =UVC_CMD_DUMP_COMPLETE , + .config_handle =kvm_s390_pv_get_handle (kvm), + }; +u64 *compl_data; +int ret; + +/* Allocate dump area */ + ret = -ENOMEM ;
you can remove this ^
arch/s390/kvm/pv.c int kvm_s390_pv_set_cpu_state(struct kvm_vcpu *vcpu, u8 state) · line 462
Quoted 3 lines
arch/s390/kvm/pv.c +3
-0+ compl_data =vzalloc (uv_info.conf_dump_finalize_len); +if (!compl_data) +return ret;
and just return -ENOMEM here ^
with that fixed:
Quoted 59 lines
arch/s390/kvm/pv.c +26
-0+ complete.dump_area_origin = (u64 )compl_data; + + ret =uv_call_sched (0 , (u64)&complete); + *rc = complete.header.rc; + *rrc = complete.header.rrc; +KVM_UV_EVENT (kvm,3 ,"PROTVIRT DUMP COMPLETE: rc %x rrc %x" , + complete.header.rc, complete.header.rrc); + +if (!ret) { +/* +* kvm_s390_pv_dealloc_vm() will also (mem)set +* this to false on a reboot or other destroy +* operation for this vm. +*/ + kvm->arch.pv.dumping = false; +kvm_s390_vcpu_unblock_all (kvm); + ret =copy_to_user (buff_user, compl_data, uv_info.conf_dump_finalize_len); +if (ret) + ret = -EFAULT ; + } +vfree (compl_data); +/* If the UVC returned an error, translate it to -EINVAL */ +if (ret >0 ) + ret = -EINVAL ; +return ret; +}include/uapi/linux/kvm.h +15
-0@@ -1645,6 +1645,20 @@ struct kvm_s390_pv_unp {__u64 tweak; }; +enum pv_cmd_dmp_id { +KVM_PV_DUMP_INIT , +KVM_PV_DUMP_CONFIG_STOR_STATE , +KVM_PV_DUMP_COMPLETE , +}; + +struct kvm_s390_pv_dmp { +__u64 subcmd; +__u64 buff_addr; +__u64 buff_len; +__u64 gaddr;/* For dump storage state */ +__u64 reserved[4 ]; +}; +enum pv_cmd_info_id {KVM_PV_INFO_VM ,KVM_PV_INFO_DUMP ,@@ -1688,6 +1702,7 @@ enum pv_cmd_id {KVM_PV_PREP_RESET ,KVM_PV_UNSHARE_ALL ,KVM_PV_INFO , + KVM_PV_DUMP, }; struct kvm_pv_cmd {
Janosch Frank
maintainerPATCH v6 7/11 kvm: s390: Add CPU dump functionality
In reply to Janosch FrankThe previous patch introduced the per-VM dump functions now let's focus on dumping the VCPU state via the newly introduced KVM_S390_PV_CPU_COMMAND ioctl which mirrors the VM UV ioctl and can be extended with new commands later.
--- arch/s390/kvm/kvm-s390.c | 69 ++++++++++++++++++++++++++++++++++++++++ arch/s390/kvm/kvm-s390.h | 1 + arch/s390/kvm/pv.c | 16 ++++++++++ include/uapi/linux/kvm.h | 4 +++ 4 files changed, 90 insertions(+)
arch/s390/kvm/kvm-s390.c +69 -0
@@ -5087,6 +5087,48 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,return -ENOIOCTLCMD ; } +static int kvm_s390_handle_pv_vcpu_dump (struct kvm_vcpu *vcpu, +struct kvm_pv_cmd *cmd) +{ +struct kvm_s390_pv_dmp dmp; +void *data; +int ret; + +/* Dump initialization is a prerequisite */ +if (!vcpu->kvm->arch.pv.dumping) +return -EINVAL ; + +if (copy_from_user (&dmp, (__u8 __user *)cmd->data,sizeof (dmp))) +return -EFAULT ; + +/* We only handle this subcmd right now */ +if (dmp.subcmd !=KVM_PV_DUMP_CPU ) +return -EINVAL ; + +/* CPU dump length is the same as create cpu storage donation. */ +if (dmp.buff_len != uv_info.guest_cpu_stor_len) +return -EINVAL ; + + data =kvzalloc (uv_info.guest_cpu_stor_len,GFP_KERNEL ); +if (!data) +return -ENOMEM ; + + ret =kvm_s390_pv_dump_cpu (vcpu, data, &cmd->rc, &cmd->rrc); + +VCPU_EVENT (vcpu,3 ,"PROTVIRT DUMP CPU %d rc %x rrc %x" , + vcpu->vcpu_id, cmd->rc, cmd->rrc); + +if (ret) + ret = -EINVAL ; + +/* On success copy over the dump data */ +if (!ret &©_to_user ((__u8 __user *)dmp.buff_addr, data, uv_info.guest_cpu_stor_len)) + ret = -EFAULT ; + +kvfree (data); +return ret; +} +long kvm_arch_vcpu_ioctl (struct file *filp,unsigned int ioctl,unsigned long arg) {
@@ -5251,6 +5293,33 @@ long kvm_arch_vcpu_ioctl(struct file *filp, irq_state.len);break ; } +case KVM_S390_PV_CPU_COMMAND : { +struct kvm_pv_cmd cmd; + + r = -EINVAL ; +if (!is_prot_virt_host ()) +break ; + + r = -EFAULT ; +if (copy_from_user (&cmd, argp,sizeof (cmd))) +break ; + + r = -EINVAL ; +if (cmd.flags) +break ; + +/* We only handle this cmd right now */ +if (cmd.cmd !=KVM_PV_DUMP ) +break ; + + r =kvm_s390_handle_pv_vcpu_dump (vcpu, &cmd); + +/* Always copy over UV rc / rrc data */ +if (copy_to_user ((__u8 __user *)argp, &cmd.rc, +sizeof (cmd.rc) +sizeof (cmd.rrc))) + r = -EFAULT ; +break ; + }default : r = -ENOTTY ; }
arch/s390/kvm/kvm-s390.h +1 -0
@@ -250,6 +250,7 @@ int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc,int kvm_s390_pv_unpack (struct kvm *kvm,unsigned long addr,unsigned long size,unsigned long tweak,u16 *rc,u16 *rrc);int kvm_s390_pv_set_cpu_state (struct kvm_vcpu *vcpu,u8 state); +int kvm_s390_pv_dump_cpu (struct kvm_vcpu *vcpu,void *buff,u16 *rc,u16 *rrc);int kvm_s390_pv_dump_stor_state (struct kvm *kvm,void __user *buff_user,u64 *gaddr,u64 buff_user_len,u16 *rc,u16 *rrc); int kvm_s390_pv_dump_complete(struct kvm *kvm, void __user *buff_user,
arch/s390/kvm/pv.c +16 -0
@@ -305,6 +305,22 @@ int kvm_s390_pv_set_cpu_state(struct kvm_vcpu *vcpu, u8 state)return 0 ; } +int kvm_s390_pv_dump_cpu (struct kvm_vcpu *vcpu,void *buff,u16 *rc,u16 *rrc) +{ +struct uv_cb_dump_cpu uvcb = { + .header.cmd =UVC_CMD_DUMP_CPU , + .header.len =sizeof (uvcb), + .cpu_handle = vcpu->arch.pv.handle, + .dump_area_origin = (u64 )buff, + }; +int cc; + + cc =uv_call_sched (0 , (u64)&uvcb); + *rc = uvcb.header.rc; + *rrc = uvcb.header.rrc; +return cc; +} +/* Size of the cache for the storage state dump data. 1MB for now */ #define DUMP_BUFF_LEN HPAGE_SIZE
include/uapi/linux/kvm.h +4 -0
@@ -1649,6 +1649,7 @@ enum pv_cmd_dmp_id {KVM_PV_DUMP_INIT ,KVM_PV_DUMP_CONFIG_STOR_STATE ,KVM_PV_DUMP_COMPLETE , + KVM_PV_DUMP_CPU, }; struct kvm_s390_pv_dmp {
@@ -2110,4 +2111,7 @@ struct kvm_stats_desc {/* Available with KVM_CAP_XSAVE2 */ #define KVM_GET_XSAVE2 _IOR(KVMIO, 0xcf, struct kvm_xsave) +/* Available with KVM_CAP_S390_PROTECTED_DUMP */ +#define KVM_S390_PV_CPU_COMMAND _IOWR(KVMIO, 0xd0, struct kvm_pv_cmd) +#endif /* __LINUX_KVM_H */
Signature · 1 line
2.34.1
Re: [PATCH v6 07/11] kvm: s390: Add CPU dump functionality
Quoted 6 lines · On Tue, 17 May 2022 16:36:25 +0000 Janosch Frank <[email protected]> wrote:
The previous patch introduced the per-VM dump functions now let's focus on dumping the VCPU state via the newly introduced
KVM_S390_PV_CPU_COMMANDioctl which mirrors the VM UV ioctl and can be extended with new commands later.Signed-off-by Janosch Frank <[email protected]>
Quoted 153 lines
--- arch/s390/kvm/kvm-s390.c | 69 ++++++++++++++++++++++++++++++++++++++++ arch/s390/kvm/kvm-s390.h | 1 + arch/s390/kvm/pv.c | 16 ++++++++++ include/uapi/linux/kvm.h | 4 +++ 4 files changed, 90 insertions(+)arch/s390/kvm/kvm-s390.c +69
-0@@ -5087,6 +5087,48 @@ long kvm_arch_vcpu_async_ioctl(struct file *filp,return -ENOIOCTLCMD ; } +static int kvm_s390_handle_pv_vcpu_dump (struct kvm_vcpu *vcpu, +struct kvm_pv_cmd *cmd) +{ +struct kvm_s390_pv_dmp dmp; +void *data; +int ret; + +/* Dump initialization is a prerequisite */ +if (!vcpu->kvm->arch.pv.dumping) +return -EINVAL ; + +if (copy_from_user (&dmp, (__u8 __user *)cmd->data,sizeof (dmp))) +return -EFAULT ; + +/* We only handle this subcmd right now */ +if (dmp.subcmd !=KVM_PV_DUMP_CPU ) +return -EINVAL ; + +/* CPU dump length is the same as create cpu storage donation. */ +if (dmp.buff_len != uv_info.guest_cpu_stor_len) +return -EINVAL ; + + data =kvzalloc (uv_info.guest_cpu_stor_len,GFP_KERNEL ); +if (!data) +return -ENOMEM ; + + ret =kvm_s390_pv_dump_cpu (vcpu, data, &cmd->rc, &cmd->rrc); + +VCPU_EVENT (vcpu,3 ,"PROTVIRT DUMP CPU %d rc %x rrc %x" , + vcpu->vcpu_id, cmd->rc, cmd->rrc); + +if (ret) + ret = -EINVAL ; + +/* On success copy over the dump data */ +if (!ret &©_to_user ((__u8 __user *)dmp.buff_addr, data, uv_info.guest_cpu_stor_len)) + ret = -EFAULT ; + +kvfree (data); +return ret; +} +long kvm_arch_vcpu_ioctl (struct file *filp,unsigned int ioctl,unsigned long arg) {@@ -5251,6 +5293,33 @@ long kvm_arch_vcpu_ioctl(struct file *filp, irq_state.len);break ; } +case KVM_S390_PV_CPU_COMMAND : { +struct kvm_pv_cmd cmd; + + r = -EINVAL ; +if (!is_prot_virt_host ()) +break ; + + r = -EFAULT ; +if (copy_from_user (&cmd, argp,sizeof (cmd))) +break ; + + r = -EINVAL ; +if (cmd.flags) +break ; + +/* We only handle this cmd right now */ +if (cmd.cmd !=KVM_PV_DUMP ) +break ; + + r =kvm_s390_handle_pv_vcpu_dump (vcpu, &cmd); + +/* Always copy over UV rc / rrc data */ +if (copy_to_user ((__u8 __user *)argp, &cmd.rc, +sizeof (cmd.rc) +sizeof (cmd.rrc))) + r = -EFAULT ; +break ; + }default : r = -ENOTTY ; }arch/s390/kvm/kvm-s390.h +1
-0@@ -250,6 +250,7 @@ int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc,int kvm_s390_pv_unpack (struct kvm *kvm,unsigned long addr,unsigned long size,unsigned long tweak,u16 *rc,u16 *rrc);int kvm_s390_pv_set_cpu_state (struct kvm_vcpu *vcpu,u8 state); +int kvm_s390_pv_dump_cpu (struct kvm_vcpu *vcpu,void *buff,u16 *rc,u16 *rrc);int kvm_s390_pv_dump_stor_state (struct kvm *kvm,void __user *buff_user,u64 *gaddr,u64 buff_user_len,u16 *rc,u16 *rrc); int kvm_s390_pv_dump_complete(struct kvm *kvm, void __user *buff_user,arch/s390/kvm/pv.c +16
-0@@ -305,6 +305,22 @@ int kvm_s390_pv_set_cpu_state(struct kvm_vcpu *vcpu, u8 state)return 0 ; } +int kvm_s390_pv_dump_cpu (struct kvm_vcpu *vcpu,void *buff,u16 *rc,u16 *rrc) +{ +struct uv_cb_dump_cpu uvcb = { + .header.cmd =UVC_CMD_DUMP_CPU , + .header.len =sizeof (uvcb), + .cpu_handle = vcpu->arch.pv.handle, + .dump_area_origin = (u64 )buff, + }; +int cc; + + cc =uv_call_sched (0 , (u64)&uvcb); + *rc = uvcb.header.rc; + *rrc = uvcb.header.rrc; +return cc; +} +/* Size of the cache for the storage state dump data. 1MB for now */ #define DUMP_BUFF_LEN HPAGE_SIZEinclude/uapi/linux/kvm.h +4
-0@@ -1649,6 +1649,7 @@ enum pv_cmd_dmp_id {KVM_PV_DUMP_INIT ,KVM_PV_DUMP_CONFIG_STOR_STATE ,KVM_PV_DUMP_COMPLETE , + KVM_PV_DUMP_CPU, }; struct kvm_s390_pv_dmp {@@ -2110,4 +2111,7 @@ struct kvm_stats_desc {/* Available with KVM_CAP_XSAVE2 */ #define KVM_GET_XSAVE2 _IOR(KVMIO, 0xcf, struct kvm_xsave) +/* Available with KVM_CAP_S390_PROTECTED_DUMP */ +#define KVM_S390_PV_CPU_COMMAND _IOWR(KVMIO, 0xd0, struct kvm_pv_cmd) +#endif /* __LINUX_KVM_H */
Janosch Frank
maintainerPATCH v6 8/11 kvm: s390: Add KVM_CAP_S390_PROTECTED_DUMP
In reply to Janosch FrankThe capability indicates dump support for protected VMs.
--- arch/s390/kvm/kvm-s390.c | 20 ++++++++++++++++++++ include/uapi/linux/kvm.h | 1 + 2 files changed, 21 insertions(+)
arch/s390/kvm/kvm-s390.c +20 -0
@@ -606,6 +606,26 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_S390_PROTECTED : r =is_prot_virt_host ();break ; +case KVM_CAP_S390_PROTECTED_DUMP : { +u64 pv_cmds_dump[] = { +BIT_UVC_CMD_DUMP_INIT , +BIT_UVC_CMD_DUMP_CONFIG_STOR_STATE , +BIT_UVC_CMD_DUMP_CPU , +BIT_UVC_CMD_DUMP_COMPLETE , + }; +int i; + + r =is_prot_virt_host (); + +for (i =0 ; i <ARRAY_SIZE (pv_cmds_dump); i++) { +if (!test_bit_inv (pv_cmds_dump[i], + (unsigned long *)&uv_info.inst_calls_list)) { + r =0 ; +break ; + } + } +break ; + }default : r =0 ; }
include/uapi/linux/kvm.h +1 -0
@@ -1144,6 +1144,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_S390_MEM_OP_EXTENSION 211#define KVM_CAP_PMU_CAPABILITY 212#define KVM_CAP_DISABLE_QUIRKS2 213 +#define KVM_CAP_S390_PROTECTED_DUMP 214#ifdef KVM_CAP_IRQ_ROUTING
Signature · 1 line
2.34.1
Re: [PATCH v6 08/11] kvm: s390: Add KVM_CAP_S390_PROTECTED_DUMP
Quoted 3 lines · On Tue, 17 May 2022 16:36:26 +0000 Janosch Frank <[email protected]> wrote:
The capability indicates dump support for protected VMs.
Signed-off-by Janosch Frank <[email protected]>
Quoted 48 lines
--- arch/s390/kvm/kvm-s390.c | 20 ++++++++++++++++++++ include/uapi/linux/kvm.h | 1 + 2 files changed, 21 insertions(+)arch/s390/kvm/kvm-s390.c +20
-0@@ -606,6 +606,26 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_S390_PROTECTED : r =is_prot_virt_host ();break ; +case KVM_CAP_S390_PROTECTED_DUMP : { +u64 pv_cmds_dump[] = { +BIT_UVC_CMD_DUMP_INIT , +BIT_UVC_CMD_DUMP_CONFIG_STOR_STATE , +BIT_UVC_CMD_DUMP_CPU , +BIT_UVC_CMD_DUMP_COMPLETE , + }; +int i; + + r =is_prot_virt_host (); + +for (i =0 ; i <ARRAY_SIZE (pv_cmds_dump); i++) { +if (!test_bit_inv (pv_cmds_dump[i], + (unsigned long *)&uv_info.inst_calls_list)) { + r =0 ; +break ; + } + } +break ; + }default : r =0 ; }include/uapi/linux/kvm.h +1
-0@@ -1144,6 +1144,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_S390_MEM_OP_EXTENSION 211#define KVM_CAP_PMU_CAPABILITY 212#define KVM_CAP_DISABLE_QUIRKS2 213 +#define KVM_CAP_S390_PROTECTED_DUMP 214#ifdef KVM_CAP_IRQ_ROUTING
Janosch Frank
maintainerPATCH v6 9/11 Documentation: virt: Protected virtual machine dumps
In reply to Janosch FrankLet's add a documentation file which describes the dump process. Since we only copy the UV dump data from the UV to userspace we'll not go into detail here and let the party which processes the data describe its structure.
--- Documentation/virt/kvm/s390/index.rst | 1 + Documentation/virt/kvm/s390/s390-pv-dump.rst | 64 ++++++++++++++++++++ 2 files changed, 65 insertions(+) create mode 100644 Documentation/virt/kvm/s390/s390-pv-dump.rst
Documentation/virt/kvm/s390/index.rst +1 -0
@@ -10,3 +10,4 @@ KVM for s390 systems s390-diag s390-pv s390-pv-boot + s390-pv-dump
Documentation/virt/kvm/s390/s390-pv-dump.rst new file +64 -0
64 lines not on this page · raw message
Signature · 1 line
2.34.1
Janosch Frank
maintainerPATCH v6 10/11 Documentation/virt/kvm/api.rst: Add protvirt dump/info api descriptions
In reply to Janosch FrankTime to add the dump API changes to the api documentation file. Also some minor cleanup.
--- Documentation/virt/kvm/api.rst | 155 ++++++++++++++++++++++++++++++++- 1 file changed, 153 insertions(+), 2 deletions(-)
Documentation/virt/kvm/api.rst +153 -2
@@ -5067,7 +5067,7 @@ into ESA mode. This reset is a superset of the initial reset. __u32 reserved[3]; }; -cmd values: +**cmd values:** KVM_PV_ENABLE Allocate memory and register the VM with the Ultravisor, thereby
@@ -5083,7 +5083,6 @@ KVM_PV_ENABLE ===== ============================= KVM_PV_DISABLE - Deregister the VM from the Ultravisor and reclaim the memory that had been donated to the Ultravisor, making it usable by the kernel again. All registered VCPUs are converted back to non-protected
@@ -5100,6 +5099,117 @@ KVM_PV_VM_VERIFY Verify the integrity of the unpacked image. Only if this succeeds, KVM is allowed to start protected VCPUs. +KVM_PV_INFO + :Capability: KVM_CAP_S390_PROTECTED_DUMP + + Presents an API that provides Ultravisor related data to userspace + via subcommands. len_max is the size of the user space buffer, + len_written is KVM's indication of how much bytes of that buffer + were actually written to. len_written can be used to determine the + valid fields if more response fields are added in the future. + + :: + + enum pv_cmd_info_id { + KVM_PV_INFO_VM, + KVM_PV_INFO_DUMP, + }; + + struct kvm_s390_pv_info_header { + __u32 id; + __u32 len_max; + __u32 len_written; + __u32 reserved; + }; + + struct kvm_s390_pv_info { + struct kvm_s390_pv_info_header header; + struct kvm_s390_pv_info_dump dump; + struct kvm_s390_pv_info_vm vm; + }; + +**subcommands:** + + KVM_PV_INFO_VM + This subcommand provides basic Ultravisor information for PV + hosts. These values are likely also exported as files in the sysfs + firmware UV query interface but they are more easily available to + programs in this API. + + The installed calls and feature_indication members provide the + installed UV calls and the UV's other feature indications. + + The max_* members provide information about the maximum number of PV + vcpus, PV guests and PV guest memory size. + + :: + + struct kvm_s390_pv_info_vm { + __u64 inst_calls_list[4]; + __u64 max_cpus; + __u64 max_guests; + __u64 max_guest_addr; + __u64 feature_indication; + }; + + + KVM_PV_INFO_DUMP + This subcommand provides information related to dumping PV guests. + + :: + + struct kvm_s390_pv_info_dump { + __u64 dump_cpu_buffer_len; + __u64 dump_config_mem_buffer_per_1m; + __u64 dump_config_finalize_len; + }; + +KVM_PV_DUMP + :Capability: KVM_CAP_S390_PROTECTED_DUMP + + Presents an API that provides calls which facilitate dumping a + protected VM. + + :: + + struct kvm_s390_pv_dmp { + __u64 subcmd; + __u64 buff_addr; + __u64 buff_len; + __u64 gaddr; /* For dump storage state */ + }; + + **subcommands:** + + KVM_PV_DUMP_INIT + Initializes the dump process of a protected VM. If this call does + not succeed all other subcommands will fail with -EINVAL. This + subcommand will return -EINVAL if a dump process has not yet been + completed. + + Not all PV vms can be dumped, the owner needs to set `dump + allowed` PCF bit 34 in the SE header to allow dumping. + + KVM_PV_DUMP_CONFIG_STOR_STATE + Stores `buff_len` bytes of tweak component values starting with + the 1MB block specified by the absolute guest address + (`gaddr`). `buff_len` needs to be `conf_dump_storage_state_len` + aligned and at least >= the `conf_dump_storage_state_len` value + provided by the dump uv_info data. buff_user might be written to + even if an error rc is returned. For instance if we encounter a + fault after writing the first page of data. + + KVM_PV_DUMP_COMPLETE + If the subcommand succeeds it completes the dump process and lets + KVM_PV_DUMP_INIT be called again. + + On success `conf_dump_finalize_len` bytes of completion data will be + stored to the `buff_addr`. The completion data contains a key + derivation seed, IV, tweak nonce and encryption keys as well as an + authentication tag all of which are needed to decrypt the dump at a + later time. + + 4.126 KVM_X86_SET_MSR_FILTER ----------------------------
@@ -5652,6 +5762,32 @@ The offsets of the state save areas in struct kvm_xsave follow the contents of CPUID leaf 0xD on the host. +4.135 KVM_S390_PV_CPU_COMMAND +----------------------------- + +:Capability: KVM_CAP_S390_PROTECTED_DUMP +:Architectures: s390 +:Type: vcpu ioctl +:Parameters: none +:Returns: 0 on success, < 0 on error + +This ioctl closely mirrors `KVM_S390_PV_COMMAND` but handles requests +for vcpus. It re-uses the kvm_s390_pv_dmp struct and hence also shares +the command ids. + +**command:** + +KVM_PV_DUMP + Presents an API that provides calls which facilitate dumping a vcpu + of a protected VM. + +**subcommand:** + +KVM_PV_DUMP_CPU + Provides encrypted dump data like register values. + The length of the returned data is provided by uv_info.guest_cpu_stor_len. + + 5. The kvm_run structure ========================
@@ -7729,6 +7865,21 @@ At this time, KVM_PMU_CAP_DISABLE is the only capability. Setting this capability will disable PMU virtualization for that VM. Usermode should adjust CPUID leaf 0xA to reflect that the PMU is disabled. + +8.36 KVM_CAP_S390_PROTECTED_DUMP +-------------------------------- + +:Capability: KVM_CAP_S390_PROTECTED_DUMP +:Architectures: s390 +:Type: vm + +This capability indicates that KVM and the Ultravisor support dumping +PV guests. The `KVM_PV_DUMP` command is available for the +`KVM_S390_PV_COMMAND` ioctl and the `KVM_PV_INFO` command provides +dump related UV data. Also the vcpu ioctl `KVM_S390_PV_CPU_COMMAND` is +available and supports the `KVM_PV_DUMP_CPU` subcommand. + + 9. Known KVM API problems =========================
Signature · 1 line
2.34.1
Re: [PATCH v6 10/11] Documentation/virt/kvm/api.rst: Add protvirt dump/info api descriptions
Quoted 4 lines · On Tue, 17 May 2022 16:36:28 +0000 Janosch Frank <[email protected]> wrote:
Time to add the dump API changes to the api documentation file. Also some minor cleanup.
Signed-off-by Janosch Frank <[email protected]>
Quoted 198 lines
--- Documentation/virt/kvm/api.rst | 155 ++++++++++++++++++++++++++++++++- 1 file changed, 153 insertions(+), 2 deletions(-)Documentation/virt/kvm/api.rst +153
-2@@ -5067,7 +5067,7 @@ into ESA mode. This reset is a superset of the initial reset. __u32 reserved[3]; }; -cmd values: +**cmd values:** KVM_PV_ENABLE Allocate memory and register the VM with the Ultravisor, thereby@@ -5083,7 +5083,6 @@ KVM_PV_ENABLE ===== ============================= KVM_PV_DISABLE - Deregister the VM from the Ultravisor and reclaim the memory that had been donated to the Ultravisor, making it usable by the kernel again. All registered VCPUs are converted back to non-protected@@ -5100,6 +5099,117 @@ KVM_PV_VM_VERIFY Verify the integrity of the unpacked image. Only if this succeeds, KVM is allowed to start protected VCPUs. +KVM_PV_INFO + :Capability: KVM_CAP_S390_PROTECTED_DUMP + + Presents an API that provides Ultravisor related data to userspace + via subcommands. len_max is the size of the user space buffer, + len_written is KVM's indication of how much bytes of that buffer + were actually written to. len_written can be used to determine the + valid fields if more response fields are added in the future. + + :: + + enum pv_cmd_info_id { + KVM_PV_INFO_VM, + KVM_PV_INFO_DUMP, + }; + + struct kvm_s390_pv_info_header { + __u32 id; + __u32 len_max; + __u32 len_written; + __u32 reserved; + }; + + struct kvm_s390_pv_info { + struct kvm_s390_pv_info_header header; + struct kvm_s390_pv_info_dump dump; + struct kvm_s390_pv_info_vm vm; + }; + +**subcommands:** + + KVM_PV_INFO_VM + This subcommand provides basic Ultravisor information for PV + hosts. These values are likely also exported as files in the sysfs + firmware UV query interface but they are more easily available to + programs in this API. + + The installed calls and feature_indication members provide the + installed UV calls and the UV's other feature indications. + + The max_* members provide information about the maximum number of PV + vcpus, PV guests and PV guest memory size. + + :: + + struct kvm_s390_pv_info_vm { + __u64 inst_calls_list[4]; + __u64 max_cpus; + __u64 max_guests; + __u64 max_guest_addr; + __u64 feature_indication; + }; + + + KVM_PV_INFO_DUMP + This subcommand provides information related to dumping PV guests. + + :: + + struct kvm_s390_pv_info_dump { + __u64 dump_cpu_buffer_len; + __u64 dump_config_mem_buffer_per_1m; + __u64 dump_config_finalize_len; + }; + +KVM_PV_DUMP + :Capability: KVM_CAP_S390_PROTECTED_DUMP + + Presents an API that provides calls which facilitate dumping a + protected VM. + + :: + + struct kvm_s390_pv_dmp { + __u64 subcmd; + __u64 buff_addr; + __u64 buff_len; + __u64 gaddr; /* For dump storage state */ + }; + + **subcommands:** + + KVM_PV_DUMP_INIT + Initializes the dump process of a protected VM. If this call does + not succeed all other subcommands will fail with -EINVAL. This + subcommand will return -EINVAL if a dump process has not yet been + completed. + + Not all PV vms can be dumped, the owner needs to set `dump + allowed` PCF bit 34 in the SE header to allow dumping. + + KVM_PV_DUMP_CONFIG_STOR_STATE + Stores `buff_len` bytes of tweak component values starting with + the 1MB block specified by the absolute guest address + (`gaddr`). `buff_len` needs to be `conf_dump_storage_state_len` + aligned and at least >= the `conf_dump_storage_state_len` value + provided by the dump uv_info data. buff_user might be written to + even if an error rc is returned. For instance if we encounter a + fault after writing the first page of data. + + KVM_PV_DUMP_COMPLETE + If the subcommand succeeds it completes the dump process and lets + KVM_PV_DUMP_INIT be called again. + + On success `conf_dump_finalize_len` bytes of completion data will be + stored to the `buff_addr`. The completion data contains a key + derivation seed, IV, tweak nonce and encryption keys as well as an + authentication tag all of which are needed to decrypt the dump at a + later time. + + 4.126 KVM_X86_SET_MSR_FILTER ----------------------------@@ -5652,6 +5762,32 @@ The offsets of the state save areas in struct kvm_xsave follow the contents of CPUID leaf 0xD on the host. +4.135 KVM_S390_PV_CPU_COMMAND +----------------------------- + +:Capability: KVM_CAP_S390_PROTECTED_DUMP +:Architectures: s390 +:Type: vcpu ioctl +:Parameters: none +:Returns: 0 on success, < 0 on error + +This ioctl closely mirrors `KVM_S390_PV_COMMAND` but handles requests +for vcpus. It re-uses the kvm_s390_pv_dmp struct and hence also shares +the command ids. + +**command:** + +KVM_PV_DUMP + Presents an API that provides calls which facilitate dumping a vcpu + of a protected VM. + +**subcommand:** + +KVM_PV_DUMP_CPU + Provides encrypted dump data like register values. + The length of the returned data is provided by uv_info.guest_cpu_stor_len. + + 5. The kvm_run structure ========================@@ -7729,6 +7865,21 @@ At this time, KVM_PMU_CAP_DISABLE is the only capability. Setting this capability will disable PMU virtualization for that VM. Usermode should adjust CPUID leaf 0xA to reflect that the PMU is disabled. + +8.36 KVM_CAP_S390_PROTECTED_DUMP +-------------------------------- + +:Capability: KVM_CAP_S390_PROTECTED_DUMP +:Architectures: s390 +:Type: vm + +This capability indicates that KVM and the Ultravisor support dumping +PV guests. The `KVM_PV_DUMP` command is available for the +`KVM_S390_PV_COMMAND` ioctl and the `KVM_PV_INFO` command provides +dump related UV data. Also the vcpu ioctl `KVM_S390_PV_CPU_COMMAND` is +available and supports the `KVM_PV_DUMP_CPU` subcommand. + + 9. Known KVM API problems =========================
Janosch Frank
maintainerPATCH v6 11/11 Documentation/virt/kvm/api.rst: Explain rc/rrc delivery
In reply to Janosch FrankLet's explain in which situations the rc/rrc will set in struct kvm_pv_cmd so it's clear that the struct members should be set to
0. rc/rrc are independent of the IOCTL return code.
--- Documentation/virt/kvm/api.rst | 8 ++++++++ 1 file changed, 8 insertions(+)
Documentation/virt/kvm/api.rst +8 -0
@@ -5067,6 +5067,14 @@ into ESA mode. This reset is a superset of the initial reset. __u32 reserved[3]; }; +**Ultravisor return codes** +The Ultravisor return (reason) codes are provided by the kernel if a +Ultravisor call has been executed to achieve the results expected by +the command. Therefore they are independent of the IOCTL return +code. If KVM changes `rc`, its value will always be greater than 0 +hence setting it to 0 before issuing a PV command is advised to be +able to detect a change of `rc`. + **cmd values:** KVM_PV_ENABLE
Signature · 1 line
2.34.1
Re: [PATCH v6 11/11] Documentation/virt/kvm/api.rst: Explain rc/rrc delivery
Quoted 5 lines · On Tue, 17 May 2022 16:36:29 +0000 Janosch Frank <[email protected]> wrote:
Let's explain in which situations the rc/rrc will set in struct
kvm_pv_cmdso it's clear that the struct members should be set to
0. rc/rrc are independent of the IOCTL return code.Signed-off-by Janosch Frank <[email protected]>
Quoted 23 lines
--- Documentation/virt/kvm/api.rst | 8 ++++++++ 1 file changed, 8 insertions(+)Documentation/virt/kvm/api.rst +8
-0@@ -5067,6 +5067,14 @@ into ESA mode. This reset is a superset of the initial reset. __u32 reserved[3]; }; +**Ultravisor return codes** +The Ultravisor return (reason) codes are provided by the kernel if a +Ultravisor call has been executed to achieve the results expected by +the command. Therefore they are independent of the IOCTL return +code. If KVM changes `rc`, its value will always be greater than 0 +hence setting it to 0 before issuing a PV command is advised to be +able to detect a change of `rc`. + **cmd values:** KVM_PV_ENABLE
Christian Borntraeger
maintainerAm 17.05.22 um 18:36 schrieb Janosch Frank:
Quoted 17 lines
Sometimes dumping inside of a VM fails, is unavailable or doesn't yield the required data. For these occasions we dump the VM from the outside, writing memory and cpu data to a file.
Up to now PV guests only supported dumping from the inside of the guest through dumpers like KDUMP. A PV guest can be dumped from the hypervisor but the data will be stale and / or encrypted.
To get the actual state of the PV VM we need the help of the Ultravisor who safeguards the VM state. New UV calls have been added to initialize the dump, dump storage state data, dump cpu data and complete the dump process.
I chose not to document the dump data provided by the Ultravisor since KVM doesn't interprete it in any way. We're currently searching for a location and enough cycles to make it available to all.
Quoted 6 lines
v6:
* Added patch that explains KVM's rc/rrc writes
* Added rev-bys
* Improved documentation
* Reworked capability indication
* Moved the dump completion into a new function
I queued this now for kvms390/next. Its likely too late for this merge window, though. (I also applied the fixup proposed by Claudio in patch 6).