KVM: selftests: Add helpers to allocate N pages of virtual memory

Add wrappers to allocate 1 and N pages of memory using de facto standard
values as the defaults for minimum virtual address, data memslot, and
page table memslot.  Convert all compatible users.

No functional change intended.

Signed-off-by: Sean Christopherson <seanjc@google.com>
Message-Id: <20210622200529.3650424-7-seanjc@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index 59608b17707d5f3dfdff5549df35b7661c6d6ed0..70385bf25446f40d45574123b4ef5bef59c617fa 100644 (file)
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -142,6 +142,9 @@ void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot);
 void vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpuid);
 vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min,
                          uint32_t data_memslot, uint32_t pgd_memslot);
+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);
+
 void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
              unsigned int npages, uint32_t pgd_memslot);
 void *addr_gpa2hva(struct kvm_vm *vm, vm_paddr_t gpa);

diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 52b9639b5d6de5fd23909051cd37d993ee61c63a..6401e04e22688e129c742572420fc032995b7e39 100644 (file)
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -1276,6 +1276,44 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min,
        return vaddr_start;
 }
 
+/*
+ * VM Virtual Address Allocate Pages
+ *
+ * Input Args:
+ *   vm - Virtual Machine
+ *
+ * Output Args: None
+ *
+ * Return:
+ *   Starting guest virtual address
+ *
+ * Allocates at least N system pages worth of bytes within the virtual address
+ * space of the vm.
+ */
+vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages)
+{
+       return vm_vaddr_alloc(vm, nr_pages * getpagesize(), 0x10000, 0, 0);
+}
+
+/*
+ * VM Virtual Address Allocate Page
+ *
+ * Input Args:
+ *   vm - Virtual Machine
+ *
+ * Output Args: None
+ *
+ * Return:
+ *   Starting guest virtual address
+ *
+ * Allocates at least one system page worth of bytes within the virtual address
+ * space of the vm.
+ */
+vm_vaddr_t vm_vaddr_alloc_page(struct kvm_vm *vm)
+{
+       return vm_vaddr_alloc_pages(vm, 1);
+}
+
 /*
  * Map a range of VM virtual address to the VM's physical address
  *

diff --git a/tools/testing/selftests/kvm/lib/x86_64/svm.c b/tools/testing/selftests/kvm/lib/x86_64/svm.c
index 827fe6028dd42674f82f023ccc240125596708f2..2ac98d70d02bdb273ab57ce8beaead42029751b1 100644 (file)
--- a/tools/testing/selftests/kvm/lib/x86_64/svm.c
+++ b/tools/testing/selftests/kvm/lib/x86_64/svm.c
@@ -30,17 +30,14 @@ u64 rflags;
 struct svm_test_data *
 vcpu_alloc_svm(struct kvm_vm *vm, vm_vaddr_t *p_svm_gva)
 {
-       vm_vaddr_t svm_gva = vm_vaddr_alloc(vm, getpagesize(),
-                                           0x10000, 0, 0);
+       vm_vaddr_t svm_gva = vm_vaddr_alloc_page(vm);
        struct svm_test_data *svm = addr_gva2hva(vm, svm_gva);
 
-       svm->vmcb = (void *)vm_vaddr_alloc(vm, getpagesize(),
-                                          0x10000, 0, 0);
+       svm->vmcb = (void *)vm_vaddr_alloc_page(vm);
        svm->vmcb_hva = addr_gva2hva(vm, (uintptr_t)svm->vmcb);
        svm->vmcb_gpa = addr_gva2gpa(vm, (uintptr_t)svm->vmcb);
 
-       svm->save_area = (void *)vm_vaddr_alloc(vm, getpagesize(),
-                                               0x10000, 0, 0);
+       svm->save_area = (void *)vm_vaddr_alloc_page(vm);
        svm->save_area_hva = addr_gva2hva(vm, (uintptr_t)svm->save_area);
        svm->save_area_gpa = addr_gva2gpa(vm, (uintptr_t)svm->save_area);
 

diff --git a/tools/testing/selftests/kvm/lib/x86_64/vmx.c b/tools/testing/selftests/kvm/lib/x86_64/vmx.c
index 2448b30e8efae6f7e6c65d201a0bf408225ab535..d568d8cfd44d3fa49dcec3c2111659de4105af41 100644 (file)
--- a/tools/testing/selftests/kvm/lib/x86_64/vmx.c
+++ b/tools/testing/selftests/kvm/lib/x86_64/vmx.c
@@ -77,50 +77,48 @@ int vcpu_enable_evmcs(struct kvm_vm *vm, int vcpu_id)
 struct vmx_pages *
 vcpu_alloc_vmx(struct kvm_vm *vm, vm_vaddr_t *p_vmx_gva)
 {
-       vm_vaddr_t vmx_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vm_vaddr_t vmx_gva = vm_vaddr_alloc_page(vm);
        struct vmx_pages *vmx = addr_gva2hva(vm, vmx_gva);
 
        /* Setup of a region of guest memory for the vmxon region. */
-       vmx->vmxon = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->vmxon = (void *)vm_vaddr_alloc_page(vm);
        vmx->vmxon_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmxon);
        vmx->vmxon_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmxon);
 
        /* Setup of a region of guest memory for a vmcs. */
-       vmx->vmcs = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->vmcs = (void *)vm_vaddr_alloc_page(vm);
        vmx->vmcs_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmcs);
        vmx->vmcs_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmcs);
 
        /* Setup of a region of guest memory for the MSR bitmap. */
-       vmx->msr = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->msr = (void *)vm_vaddr_alloc_page(vm);
        vmx->msr_hva = addr_gva2hva(vm, (uintptr_t)vmx->msr);
        vmx->msr_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->msr);
        memset(vmx->msr_hva, 0, getpagesize());
 
        /* Setup of a region of guest memory for the shadow VMCS. */
-       vmx->shadow_vmcs = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->shadow_vmcs = (void *)vm_vaddr_alloc_page(vm);
        vmx->shadow_vmcs_hva = addr_gva2hva(vm, (uintptr_t)vmx->shadow_vmcs);
        vmx->shadow_vmcs_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->shadow_vmcs);
 
        /* Setup of a region of guest memory for the VMREAD and VMWRITE bitmaps. */
-       vmx->vmread = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->vmread = (void *)vm_vaddr_alloc_page(vm);
        vmx->vmread_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmread);
        vmx->vmread_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmread);
        memset(vmx->vmread_hva, 0, getpagesize());
 
-       vmx->vmwrite = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->vmwrite = (void *)vm_vaddr_alloc_page(vm);
        vmx->vmwrite_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmwrite);
        vmx->vmwrite_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmwrite);
        memset(vmx->vmwrite_hva, 0, getpagesize());
 
        /* Setup of a region of guest memory for the VP Assist page. */
-       vmx->vp_assist = (void *)vm_vaddr_alloc(vm, getpagesize(),
-                                               0x10000, 0, 0);
+       vmx->vp_assist = (void *)vm_vaddr_alloc_page(vm);
        vmx->vp_assist_hva = addr_gva2hva(vm, (uintptr_t)vmx->vp_assist);
        vmx->vp_assist_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vp_assist);
 
        /* Setup of a region of guest memory for the enlightened VMCS. */
-       vmx->enlightened_vmcs = (void *)vm_vaddr_alloc(vm, getpagesize(),
-                                                      0x10000, 0, 0);
+       vmx->enlightened_vmcs = (void *)vm_vaddr_alloc_page(vm);
        vmx->enlightened_vmcs_hva =
                addr_gva2hva(vm, (uintptr_t)vmx->enlightened_vmcs);
        vmx->enlightened_vmcs_gpa =
@@ -538,7 +536,7 @@ void nested_map_memslot(struct vmx_pages *vmx, struct kvm_vm *vm,
 void prepare_eptp(struct vmx_pages *vmx, struct kvm_vm *vm,
                  uint32_t eptp_memslot)
 {
-       vmx->eptp = (void *)vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       vmx->eptp = (void *)vm_vaddr_alloc_page(vm);
        vmx->eptp_hva = addr_gva2hva(vm, (uintptr_t)vmx->eptp);
        vmx->eptp_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->eptp);
 }
@@ -546,8 +544,7 @@ void prepare_eptp(struct vmx_pages *vmx, struct kvm_vm *vm,
 void prepare_virtualize_apic_accesses(struct vmx_pages *vmx, struct kvm_vm *vm,
                                      uint32_t eptp_memslot)
 {
-       vmx->apic_access = (void *)vm_vaddr_alloc(vm, getpagesize(),
-                                                 0x10000, 0, 0);
+       vmx->apic_access = (void *)vm_vaddr_alloc_page(vm);
        vmx->apic_access_hva = addr_gva2hva(vm, (uintptr_t)vmx->apic_access);
        vmx->apic_access_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->apic_access);
 }

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_clock.c b/tools/testing/selftests/kvm/x86_64/hyperv_clock.c
index 489625acc9cfdd2965f6df284c566b3ec4905b39..bab10ae787b619fbf9a93893d0d1f4f8ec775290 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_clock.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_clock.c
@@ -214,7 +214,7 @@ int main(void)
 
        vcpu_set_hv_cpuid(vm, VCPU_ID);
 
-       tsc_page_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       tsc_page_gva = vm_vaddr_alloc_page(vm);
        memset(addr_gpa2hva(vm, tsc_page_gva), 0x0, getpagesize());
        TEST_ASSERT((addr_gva2gpa(vm, tsc_page_gva) & (getpagesize() - 1)) == 0,
                "TSC page has to be page aligned\n");

diff --git a/tools/testing/selftests/kvm/x86_64/hyperv_features.c b/tools/testing/selftests/kvm/x86_64/hyperv_features.c
index ad7ee06fa71e2b1304369aef1048940a29ca5074..42bd658f52a82774366d8201a2d5bc4456008ec6 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/hyperv_features.c
+++ b/tools/testing/selftests/kvm/x86_64/hyperv_features.c
@@ -604,7 +604,7 @@ int main(void)
        /* Test MSRs */
        vm = vm_create_default(VCPU_ID, 0, guest_msr);
 
-       msr_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       msr_gva = vm_vaddr_alloc_page(vm);
        memset(addr_gva2hva(vm, msr_gva), 0x0, getpagesize());
        vcpu_args_set(vm, VCPU_ID, 1, msr_gva);
        vcpu_enable_cap(vm, VCPU_ID, &cap);
@@ -626,10 +626,10 @@ int main(void)
        vm = vm_create_default(VCPU_ID, 0, guest_hcall);
 
        /* Hypercall input/output */
-       hcall_page = vm_vaddr_alloc(vm, 2 * getpagesize(), 0x10000, 0, 0);
+       hcall_page = vm_vaddr_alloc_pages(vm, 2);
        memset(addr_gva2hva(vm, hcall_page), 0x0, 2 * getpagesize());
 
-       hcall_params = vm_vaddr_alloc(vm, getpagesize(), 0x10000, 0, 0);
+       hcall_params = vm_vaddr_alloc_page(vm);
        memset(addr_gva2hva(vm, hcall_params), 0x0, getpagesize());
 
        vcpu_args_set(vm, VCPU_ID, 2, addr_gva2gpa(vm, hcall_page), hcall_params);