selftests: KVM: SEV: selftests for fd-based private memory
v2 cover selftests: KVM: SEV: selftests for fd-based private memory
This series implements selftests executing SEV VMs to target the feature floated by Chao via:
https://lore.kernel.org/linux-mm/[email protected]/T/
Below changes aim to test the fd based approach for guest private memory in context of SEV VMs executing on AMD SEV compatible platforms.
sev_private_mem_test.c file adds selftest to access private memory from the guest via private/shared accesses and checking if the contents can be leaked to/accessed by vmm via shared memory view before/after conversions.
To allow SEV/SEV-ES VMs to toggle the encryption bit during memory conversion, support is added for mapping guest pagetables to guest va ranges and passing the mapping information to guests via shared pages.
This series has dependency on following patch series:
1) V7 series patches from Chao mentioned above.
2) https://lore.kernel.org/lkml/[email protected]/T/#u
- Series posted by Peter containing patches from Michael and Sean
3) https://lore.kernel.org/lkml/Ywa9T+jKUpaHLu%[email protected]/T/
- Series posted for similar selftests executing non-confidential VMs.
Github link for the patches posted as part of this series:
https://github.com/vishals4gh/linux/commits/sev_upm_selftests_rfcv2
Vishal Annapurve (8):
selftests: kvm: x86_64: Add support for pagetable tracking
kvm: Add HVA range operator
arch: x86: sev: Populate private memory fd during LAUNCH_UPDATE_DATA
selftests: kvm: sev: Support memslots with private memory
selftests: kvm: Update usage of private mem lib for SEV VMs
selftests: kvm: Support executing SEV VMs with private memory
selftests: kvm: Refactor testing logic for private memory
selftests: kvm: Add private memory test for SEV VMs
arch/x86/kvm/svm/sev.c | 99 ++++++- include/linux/kvm_host.h | 8 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 2 + .../selftests/kvm/include/kvm_util_base.h | 105 +++++++ .../kvm/include/x86_64/private_mem.h | 10 +- .../include/x86_64/private_mem_test_helper.h | 13 + .../selftests/kvm/include/x86_64/sev.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 78 ++++- .../selftests/kvm/lib/x86_64/private_mem.c | 189 ++++++++++-- .../kvm/lib/x86_64/private_mem_test_helper.c | 273 ++++++++++++++++++ .../selftests/kvm/lib/x86_64/processor.c | 32 ++ tools/testing/selftests/kvm/lib/x86_64/sev.c | 15 +- .../selftests/kvm/x86_64/private_mem_test.c | 246 +--------------- .../kvm/x86_64/sev_private_mem_test.c | 21 ++ virt/kvm/kvm_main.c | 87 +++++- 16 files changed, 880 insertions(+), 301 deletions(-) create mode 100644 tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c create mode 100644 tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 1/8 selftests: kvm: x86_64: Add support for pagetable tracking
Add support for mapping guest pagetable pages to a contiguous guest virtual address range and sharing the physical to virtual mappings with the guest in a pre-defined format.
This functionality will allow the guests to modify their page table entries. One such usecase for CC VMs is to toggle encryption bit in their ptes to switch from encrypted to shared memory and vice a versa.
--- .../selftests/kvm/include/kvm_util_base.h | 105 ++++++++++++++++++ tools/testing/selftests/kvm/lib/kvm_util.c | 78 ++++++++++++- .../selftests/kvm/lib/x86_64/processor.c | 32 ++++++ 3 files changed, 214 insertions(+), 1 deletion(-)
tools/testing/selftests/kvm/include/kvm_util_base.h +105 -0
@@ -74,6 +74,11 @@ struct vm_memcrypt {int8_t enc_bit; }; +struct pgt_page { +vm_paddr_t paddr; +struct list_head list; +}; +struct kvm_vm {int mode;unsigned long type;
@@ -98,6 +103,10 @@ struct kvm_vm {vm_vaddr_t handlers;uint32_t dirty_ring_size;struct vm_memcrypt memcrypt; +struct list_head pgt_pages; +bool track_pgt_pages; +uint32_t num_pgt_pages; +vm_vaddr_t pgt_vaddr_start;/* Cache of information for binary stats interface */ int stats_fd;
@@ -184,6 +193,23 @@ struct vm_guest_mode_params {unsigned int page_size;unsigned int page_shift; }; + +/* +* Structure shared with the guest containing information about: +* - Starting virtual address for num_pgt_pages physical pagetable +* page addresses tracked via paddrs array +* - page size of the guest +* +* Guest can walk through its pagetables using this information to +* read/modify pagetable attributes. +*/ +struct guest_pgt_info { +uint64_t num_pgt_pages; +uint64_t pgt_vaddr_start; +uint64_t page_size; +uint64_t paddrs[]; +}; +extern const struct vm_guest_mode_params vm_guest_mode_params[];int open_path_or_exit (const char *path,int flags);
@@ -394,6 +420,49 @@ void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot);struct kvm_vcpu *__vm_vcpu_add (struct kvm_vm *vm,uint32_t vcpu_id);vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min); +void vm_map_page_table (struct kvm_vm *vm,vm_vaddr_t vaddr_min); + +/* +* function called by guest code to translate physical address of a pagetable +* page to guest virtual address. +* +* input args: +* gpgt_info - pointer to the guest_pgt_info structure containing info +* about guest virtual address mappings for guest physical +* addresses of page table pages. +* pgt_pa - physical address of guest page table page to be translated +* to a virtual address. +* +* output args: none +* +* return: +* pointer to the pagetable page, null in case physical address is not +* tracked via given guest_pgt_info structure. +*/ +void *guest_code_get_pgt_vaddr (struct guest_pgt_info *gpgt_info,uint64_t pgt_pa); + +/* +* Allocate and setup a page to be shared with guest containing guest_pgt_info +* structure. +* +* Note: +* 1) vm_set_pgt_alloc_tracking function should be used to start tracking +* of physical page table page allocation. +* 2) This function should be invoked after needed pagetable pages are +* mapped to the VM using virt_pg_map. +* +* input args: +* vm - virtual machine +* vaddr_min - Minimum guest virtual address to start mapping the +* guest_pgt_info structure page(s). +* +* output args: none +* +* return: +* virtual address mapping guest_pgt_info structure. +*/ +vm_vaddr_t vm_setup_pgt_info_buf (struct kvm_vm *vm,vm_vaddr_t vaddr_min); +vm_vaddr_t vm_vaddr_alloc_shared (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min);vm_vaddr_t vm_vaddr_alloc_pages (struct kvm_vm *vm,int nr_pages);vm_vaddr_t vm_vaddr_alloc_page (struct kvm_vm *vm);
@@ -647,10 +716,46 @@ void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing);const char *exit_reason_str (unsigned int exit_reason); +#ifdef __x86_64__ +/* +* Guest called function to get a pointer to pte corresponding to a given +* guest virtual address and pointer to the guest_pgt_info structure. +* +* input args: +* gpgt_info - pointer to guest_pgt_info structure containing information +* about guest virtual addresses mapped to pagetable physical +* addresses. +* vaddr - guest virtual address +* +* output args: none +* +* return: +* pointer to the pte corresponding to guest virtual address, +* Null if pte is not found +*/ +uint64_t *guest_code_get_pte (struct guest_pgt_info *gpgt_info,uint64_t vaddr); +#endif +vm_paddr_t vm_phy_page_alloc (struct kvm_vm *vm,vm_paddr_t paddr_min,uint32_t memslot);vm_paddr_t vm_phy_pages_alloc (struct kvm_vm *vm,size_t num,vm_paddr_t paddr_min,uint32_t memslot); + +/* +* Enable tracking of physical guest pagetable pages for the given vm. +* This function should be called right after vm creation before any pages are +* mapped into the VM using vm_alloc_* / vm_vaddr_alloc* functions. +* +* input args: +* vm - virtual machine +* +* output args: none +* +* return: +* None +*/ +void vm_set_pgt_alloc_tracking (struct kvm_vm *vm); +vm_paddr_t vm_alloc_page_table (struct kvm_vm *vm);/*
tools/testing/selftests/kvm/lib/kvm_util.c +77 -1
116 lines not on this page · raw message
tools/testing/selftests/kvm/lib/x86_64/processor.c +32 -0
@@ -217,6 +217,38 @@ void virt_arch_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr)__virt_pg_map (vm, vaddr, paddr,PG_LEVEL_4K ); } +uint64_t *guest_code_get_pte (struct guest_pgt_info *gpgt_info,uint64_t vaddr) +{ +uint16_t index[4 ]; +uint64_t *pml4e, *pdpe, *pde, *pte; +uint64_t pgt_paddr =get_cr3 (); +uint64_t page_size = gpgt_info->page_size; + + index[0 ] = (vaddr >>12 ) &0x1ffu ; + index[1 ] = (vaddr >>21 ) &0x1ffu ; + index[2 ] = (vaddr >>30 ) &0x1ffu ; + index[3 ] = (vaddr >>39 ) &0x1ffu ; + + pml4e =guest_code_get_pgt_vaddr (gpgt_info, pgt_paddr); +GUEST_ASSERT (pml4e && (pml4e[index[3 ]] &PTE_PRESENT_MASK )); + + pgt_paddr = (PTE_GET_PFN (pml4e[index[3 ]]) * page_size); + pdpe =guest_code_get_pgt_vaddr (gpgt_info, pgt_paddr); +GUEST_ASSERT (pdpe && (pdpe[index[2 ]] &PTE_PRESENT_MASK ) && + !(pdpe[index[2 ]] &PTE_LARGE_MASK )); + + pgt_paddr = (PTE_GET_PFN (pdpe[index[2 ]]) * page_size); + pde =guest_code_get_pgt_vaddr (gpgt_info, pgt_paddr); +GUEST_ASSERT (pde && (pde[index[1 ]] &PTE_PRESENT_MASK ) && + !(pde[index[1 ]] &PTE_LARGE_MASK )); + + pgt_paddr = (PTE_GET_PFN (pde[index[1 ]]) * page_size); + pte =guest_code_get_pgt_vaddr (gpgt_info, pgt_paddr); +GUEST_ASSERT (pte && (pte[index[0 ]] &PTE_PRESENT_MASK )); + +return (uint64_t *)&pte[index[0 ]]; +} +static uint64_t *_vm_get_page_table_entry (struct kvm_vm *vm,struct kvm_vcpu *vcpu,uint64_t vaddr)
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 2/8 kvm: Add HVA range operator
In reply to Vishal AnnapurveIntroduce HVA range operator so that other KVM subsystems can operate on HVA range.
--- include/linux/kvm_host.h | 6 +++++ virt/kvm/kvm_main.c | 48 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+)
include/linux/kvm_host.h +6 -0
@@ -1398,6 +1398,12 @@ void *kvm_mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc);void kvm_mmu_updating_begin (struct kvm *kvm,gfn_t start,gfn_t end);void kvm_mmu_updating_end (struct kvm *kvm,gfn_t start,gfn_t end); +typedef int (*kvm_hva_range_op_t )(struct kvm *kvm, +struct kvm_gfn_range *range,void *data); + +int kvm_vm_do_hva_range_op (struct kvm *kvm,unsigned long hva_start, +unsigned long hva_end,kvm_hva_range_op_t handler,void *data); +long kvm_arch_dev_ioctl (struct file *filp,unsigned int ioctl,unsigned long arg); long kvm_arch_vcpu_ioctl(struct file *filp,
virt/kvm/kvm_main.c +48 -0
54 lines not on this page · raw message
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 3/8 arch: x86: sev: Populate private memory fd during LAUNCH_UPDATE_DATA
In reply to Vishal AnnapurveThis change adds handling of HVA ranges to copy contents to private memory while doing sev launch update data.
mem_attr array is updated during LAUNCH_UPDATE_DATA to ensure that encrypted memory is marked as private.
--- arch/x86/kvm/svm/sev.c | 99 ++++++++++++++++++++++++++++++++++++---- include/linux/kvm_host.h | 2 + virt/kvm/kvm_main.c | 39 ++++++++++------ 3 files changed, 116 insertions(+), 24 deletions(-)
arch/x86/kvm/svm/sev.c +90 -9
@@ -492,23 +492,22 @@ static unsigned long get_num_contig_pages(unsigned long idx,return pages; } -static int sev_launch_update_data (struct kvm *kvm,struct kvm_sev_cmd *argp) +int sev_launch_update_shared_gfn_handler (struct kvm *kvm, +struct kvm_gfn_range *range,struct kvm_sev_cmd *argp) {unsigned long vaddr, vaddr_end, next_vaddr, npages, pages, size, i;struct kvm_sev_info *sev = &to_kvm_svm (kvm)->sev_info; -struct kvm_sev_launch_update_data params;struct sev_data_launch_update_data data;struct page **inpages;int ret; -if (!sev_guest (kvm)) -return -ENOTTY ; - -if (copy_from_user (¶ms, (void __user *)(uintptr_t )argp->data,sizeof (params))) -return -EFAULT ; + vaddr =gfn_to_hva_memslot (range->slot, range->start); +if (kvm_is_error_hva (vaddr)) { +pr_err ("vaddr is erroneous 0x%lx\n" , vaddr); +return -EINVAL ; + } - vaddr = params.uaddr; - size = params.len; + size = (range->end - range->start) <<PAGE_SHIFT ; vaddr_end = vaddr + size;/* Lock the user memory. */
@@ -560,6 +559,88 @@ static int sev_launch_update_data(struct kvm *kvm, struct kvm_sev_cmd *argp)return ret; } +int sev_launch_update_priv_gfn_handler (struct kvm *kvm, +struct kvm_gfn_range *range,struct kvm_sev_cmd *argp) +{ +struct sev_data_launch_update_data data; +struct kvm_sev_info *sev = &to_kvm_svm (kvm)->sev_info; +gfn_t gfn; +kvm_pfn_t pfn; +struct kvm_memory_slot *memslot = range->slot; +int ret =0 ; + + data.reserved =0 ; + data.handle = sev->handle; + +for (gfn = range->start; gfn < range->end; gfn++) { +int order; +void *kvaddr; + + ret =kvm_private_mem_get_pfn (memslot, + gfn, &pfn, &order); +if (ret) +return ret; + + kvaddr =pfn_to_kaddr (pfn); +if (!virt_addr_valid (kvaddr)) { +pr_err ("Invalid kvaddr 0x%lx\n" , (uint64_t )kvaddr); + ret = -EINVAL ; + goto e_ret; + } + + ret =kvm_read_guest_page (kvm, gfn, kvaddr,0 ,PAGE_SIZE ); +if (ret) { +pr_err ("guest read failed 0x%lx\n" , ret); + goto e_ret; + } + +if (!this_cpu_has (X86_FEATURE_SME_COHERENT )) +clflush_cache_range (kvaddr,PAGE_SIZE ); + + data.len =PAGE_SIZE ; + data.address =__sme_set (pfn <<PAGE_SHIFT ); + ret =sev_issue_cmd (kvm,SEV_CMD_LAUNCH_UPDATE_DATA , &data, &argp->error); +if (ret) + goto e_ret; + +kvm_private_mem_put_pfn (memslot, pfn); + } +kvm_vm_set_region_attr (kvm, range->start, range->end, + true/* priv_attr */ ); + +return ret; + +e_ret: +kvm_private_mem_put_pfn (memslot, pfn); +return ret; +} + +int sev_launch_update_gfn_handler (struct kvm *kvm, +struct kvm_gfn_range *range,void *data) +{ +struct kvm_sev_cmd *argp = (struct kvm_sev_cmd *)data; + +if (kvm_slot_can_be_private (range->slot)) +return sev_launch_update_priv_gfn_handler (kvm, range, argp); + +return sev_launch_update_shared_gfn_handler (kvm, range, argp); +} + +static int sev_launch_update_data (struct kvm *kvm, +struct kvm_sev_cmd *argp) +{ +struct kvm_sev_launch_update_data params; + +if (!sev_guest (kvm)) +return -ENOTTY ; + +if (copy_from_user (¶ms, (void __user *)(uintptr_t )argp->data,sizeof (params))) +return -EFAULT ; + +return kvm_vm_do_hva_range_op (kvm, params.uaddr, params.uaddr + params.len, + sev_launch_update_gfn_handler, argp); +} +static int sev_es_sync_vmsa (struct vcpu_svm *svm) {struct sev_es_save_area *save = svm->sev_es.vmsa;
include/linux/kvm_host.h +2 -0
@@ -980,6 +980,8 @@ int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,void kvm_exit (void );void kvm_get_kvm (struct kvm *kvm); +int kvm_vm_set_region_attr (struct kvm *kvm,unsigned long gfn_start, +unsigned long gfn_end,bool priv_attr);bool kvm_get_kvm_safe (struct kvm *kvm);void kvm_put_kvm (struct kvm *kvm);bool file_is_kvm (struct file *file);
virt/kvm/kvm_main.c +24 -15
@@ -981,7 +981,7 @@ static int kvm_vm_populate_private_mem(struct kvm *kvm, unsigned long gfn_start, }mutex_lock (&kvm->slots_lock); -for (gfn = gfn_start; gfn <= gfn_end; gfn++) { +for (gfn = gfn_start; gfn < gfn_end; gfn++) {int order;void *kvaddr;
@@ -1012,12 +1012,29 @@ static int kvm_vm_populate_private_mem(struct kvm *kvm, unsigned long gfn_start, }#endif +int kvm_vm_set_region_attr (struct kvm *kvm,unsigned long gfn_start, +unsigned long gfn_end,bool priv_attr) +{ +int r; +void *entry; +unsigned long index; + + entry = priv_attr ?xa_mk_value (KVM_MEM_ATTR_PRIVATE ) :NULL ; + +for (index = gfn_start; index < gfn_end; index++) { + r =xa_err (xa_store (&kvm->mem_attr_array, index, entry, +GFP_KERNEL_ACCOUNT )); +if (r) +break ; + } + +return r; +} +static int kvm_vm_ioctl_set_encrypted_region (struct kvm *kvm,unsigned int ioctl,struct kvm_enc_region *region) {unsigned long start, end; -unsigned long index; -void *entry;int r;if (region->size ==0 || region->addr + region->size < region->addr)
@@ -1026,22 +1043,14 @@ static int kvm_vm_ioctl_set_encrypted_region(struct kvm *kvm, unsigned int ioctlreturn -EINVAL ; start = region->addr >>PAGE_SHIFT ; - end = (region->addr + region->size -1 ) >>PAGE_SHIFT ; - - entry = ioctl ==KVM_MEMORY_ENCRYPT_REG_REGION ? -xa_mk_value (KVM_MEM_ATTR_PRIVATE ) :NULL ; - -for (index = start; index <= end; index++) { - r =xa_err (xa_store (&kvm->mem_attr_array, index, entry, -GFP_KERNEL_ACCOUNT )); -if (r) -break ; - } + end = (region->addr + region->size) >>PAGE_SHIFT ; + r =kvm_vm_set_region_attr (kvm, start, end, + (ioctl ==KVM_MEMORY_ENCRYPT_REG_REGION ));kvm_zap_gfn_range (kvm, start, end +1 );#ifdef CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING -if (!kvm->vm_entry_attempted && (ioctl ==KVM_MEMORY_ENCRYPT_REG_REGION )) +if (!r && !kvm->vm_entry_attempted && (ioctl ==KVM_MEMORY_ENCRYPT_REG_REGION )) r =kvm_vm_populate_private_mem (kvm, start, end);#endif
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 4/8 selftests: kvm: sev: Support memslots with private memory
In reply to Vishal AnnapurveIntroduce an additional helper API to create a SEV VM with private memory memslots.
--- tools/testing/selftests/kvm/include/x86_64/sev.h | 2 ++ tools/testing/selftests/kvm/lib/x86_64/sev.c | 15 ++++++++++++--- 2 files changed, 14 insertions(+), 3 deletions(-)
tools/testing/selftests/kvm/include/x86_64/sev.h +2 -0
@@ -38,6 +38,8 @@ void kvm_sev_ioctl(struct sev_vm *sev, int cmd, void *data);struct kvm_vm *sev_get_vm (struct sev_vm *sev);uint8_t sev_get_enc_bit (struct sev_vm *sev); +struct sev_vm *sev_vm_create_with_flags (uint32_t policy,uint64_t npages, +uint32_t memslot_flags);struct sev_vm *sev_vm_create (uint32_t policy,uint64_t npages);void sev_vm_free (struct sev_vm *sev);void sev_vm_launch (struct sev_vm *sev);
tools/testing/selftests/kvm/lib/x86_64/sev.c +12 -3
@@ -171,7 +171,8 @@ void sev_vm_free(struct sev_vm *sev)free (sev); } -struct sev_vm *sev_vm_create (uint32_t policy,uint64_t npages) +struct sev_vm *sev_vm_create_with_flags (uint32_t policy,uint64_t npages, +uint32_t memslot_flags) {struct sev_vm *sev;struct kvm_vm *vm;
@@ -188,9 +189,12 @@ struct sev_vm *sev_vm_create(uint32_t policy, uint64_t npages) vm->vpages_mapped =sparsebit_alloc ();vm_set_memory_encryption (vm, true, true, sev->enc_bit);pr_info ("SEV cbit: %d\n" , sev->enc_bit); -vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,0 , npages,0 ); -sev_register_user_region (sev,addr_gpa2hva (vm,0 ), +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,0 , npages, + memslot_flags); +if (!(memslot_flags &KVM_MEM_PRIVATE )) { +sev_register_user_region (sev,addr_gpa2hva (vm,0 ), npages * vm->page_size); + }pr_info ("SEV guest created, policy: 0x%x, size: %lu KB\n" , sev->sev_policy, npages * vm->page_size /1024 );
@@ -198,6 +202,11 @@ struct sev_vm *sev_vm_create(uint32_t policy, uint64_t npages)return sev; } +struct sev_vm *sev_vm_create (uint32_t policy,uint64_t npages) +{ +return sev_vm_create_with_flags (policy, npages,0 ); +} +void sev_vm_launch (struct sev_vm *sev) {struct kvm_sev_launch_start ksev_launch_start = {0 };
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 5/8 selftests: kvm: Update usage of private mem lib for SEV VMs
In reply to Vishal AnnapurveAdd/update APIs to allow reusing private mem lib for SEV VMs. Memory conversion for SEV VMs includes updating guest pagetables based on virtual addresses to toggle C-bit.
--- .../kvm/include/x86_64/private_mem.h | 9 +- .../selftests/kvm/lib/x86_64/private_mem.c | 103 +++++++++++++----- 2 files changed, 83 insertions(+), 29 deletions(-)
tools/testing/selftests/kvm/include/x86_64/private_mem.h +5 -4
@@ -14,10 +14,10 @@ enum mem_conversion_type { TO_SHARED }; -void guest_update_mem_access (enum mem_conversion_type type,uint64_t gpa, -uint64_t size); -void guest_update_mem_map (enum mem_conversion_type type,uint64_t gpa, -uint64_t size); +void guest_update_mem_access (enum mem_conversion_type type,uint64_t gva, +uint64_t gpa,uint64_t size); +void guest_update_mem_map (enum mem_conversion_type type,uint64_t gva, +uint64_t gpa,uint64_t size);void guest_map_ucall_page_shared (void );
@@ -45,6 +45,7 @@ struct vm_setup_info {struct test_setup_info test_info;guest_code_fn guest_fn;io_exit_handler ioexit_cb; +uint32_t policy;/* Used for Sev VMs */ };void execute_vm_with_private_mem (struct vm_setup_info *info);
tools/testing/selftests/kvm/lib/x86_64/private_mem.c +78 -25
156 lines not on this page · raw message
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 6/8 selftests: kvm: Support executing SEV VMs with private memory
In reply to Vishal AnnapurveAdd support of executing SEV VMs for testing private memory conversion scenarios.
--- .../kvm/include/x86_64/private_mem.h | 1 + .../selftests/kvm/lib/x86_64/private_mem.c | 86 +++++++++++++++++++ 2 files changed, 87 insertions(+)
tools/testing/selftests/kvm/include/x86_64/private_mem.h +1 -0
@@ -49,5 +49,6 @@ struct vm_setup_info { };void execute_vm_with_private_mem (struct vm_setup_info *info); +void execute_sev_vm_with_private_mem (struct vm_setup_info *info);#endif /* SELFTEST_KVM_PRIVATE_MEM_H */
tools/testing/selftests/kvm/lib/x86_64/private_mem.c +86 -0
89 lines not on this page · raw message
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 7/8 selftests: kvm: Refactor testing logic for private memory
In reply to Vishal AnnapurveMove all of the logic to execute memory conversion tests into library to allow sharing the logic between normal non-confidential VMs and SEV VMs.
--- tools/testing/selftests/kvm/Makefile | 1 + .../include/x86_64/private_mem_test_helper.h | 13 + .../kvm/lib/x86_64/private_mem_test_helper.c | 273 ++++++++++++++++++ .../selftests/kvm/x86_64/private_mem_test.c | 246 +--------------- 4 files changed, 289 insertions(+), 244 deletions(-) create mode 100644 tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c
tools/testing/selftests/kvm/Makefile +1 -0
@@ -52,6 +52,7 @@ LIBKVM_x86_64 += lib/x86_64/apic.c LIBKVM_x86_64 += lib/x86_64/handlers.S LIBKVM_x86_64 += lib/x86_64/perf_test_util.c LIBKVM_x86_64 += lib/x86_64/private_mem.c +LIBKVM_x86_64 += lib/x86_64/private_mem_test_helper.c LIBKVM_x86_64 += lib/x86_64/processor.c LIBKVM_x86_64 += lib/x86_64/svm.c LIBKVM_x86_64 += lib/x86_64/ucall.c
tools/testing/selftests/kvm/include/x86_64/private_mem_test_helper.h new file +13 -0
@@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2022, Google LLC. +*/ + +#ifndef SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H +#define SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H + +void execute_memory_conversion_tests (void ); + +void execute_sev_memory_conversion_tests (void ); + +#endif // SELFTEST_KVM_PRIVATE_MEM_TEST_HELPER_H
tools/testing/selftests/kvm/lib/x86_64/private_mem_test_helper.c new file +273 -0
273 lines not on this page · raw message
tools/testing/selftests/kvm/x86_64/private_mem_test.c +2 -244
265 lines not on this page · raw message
Signature · 1 line
2.37.2.672.g94769d06f0-goog
RFC PATCH v2 8/8 selftests: kvm: Add private memory test for SEV VMs
In reply to Vishal AnnapurveAdd a selftest placeholder for executing private memory conversion tests with SEV VMs.
--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../kvm/x86_64/sev_private_mem_test.c | 21 +++++++++++++++++++ 3 files changed, 23 insertions(+) create mode 100644 tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c
tools/testing/selftests/kvm/.gitignore +1 -0
@@ -37,6 +37,7 @@ /x86_64/set_sregs_test /x86_64/sev_all_boot_test /x86_64/sev_migrate_tests +/x86_64/sev_private_mem_test /x86_64/smm_test /x86_64/state_test /x86_64/svm_vmcall_test
tools/testing/selftests/kvm/Makefile +1 -0
@@ -98,6 +98,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/pmu_event_filter_test TEST_GEN_PROGS_x86_64 += x86_64/private_mem_test TEST_GEN_PROGS_x86_64 += x86_64/set_boot_cpu_id TEST_GEN_PROGS_x86_64 += x86_64/set_sregs_test +TEST_GEN_PROGS_x86_64 += x86_64/sev_private_mem_test TEST_GEN_PROGS_x86_64 += x86_64/smm_test TEST_GEN_PROGS_x86_64 += x86_64/state_test TEST_GEN_PROGS_x86_64 += x86_64/vmx_preemption_timer_test
tools/testing/selftests/kvm/x86_64/sev_private_mem_test.c new file +21 -0
@@ -0,0 +1,21 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2022, Google LLC. +*/ +#define _GNU_SOURCE/* for program_invocation_short_name */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <test_util.h> +#include <kvm_util.h> +#include <private_mem_test_helper.h> + +int main (int argc,char *argv[]) +{ +/* Tell stdout not to buffer its content */ +setbuf (stdout,NULL ); + +execute_sev_memory_conversion_tests (); +return 0 ; +}
Signature · 1 line
2.37.2.672.g94769d06f0-goog