tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

KVM: selftests: Drop "vaddr_" from APIs that allocate memory for a given VM

Now that KVM selftests use gva_t instead of vm_vaddr_t, drop "vaddr_" from
the core memory allocation APIs as the information is extraneous and does
more harm than good. E.g. the APIs don't _just_ allocate virtual memory,
they allocate backing physical memory and install mappings in the guest
page tables. And as proven by kmalloc() and malloc(), developers generally
expect that allocations come with a working virtual address.

Opportunistically clean up the function comment for vm_alloc(), and drop
the misleading and superfluous comments for its wrappers.

No functional change intended.

Link: https://patch.msgid.link/20260420212004.3938325-12-seanjc@google.com
Signed-off-by: Sean Christopherson <seanjc@google.com>

Sean Christopherson 85819fa0 6ec982b5

+105 -145
+2 -2
tools/testing/selftests/kvm/arm64/vgic_irq.c
··· 771 771 vcpu_init_descriptor_tables(vcpu); 772 772 773 773 /* Setup the guest args page (so it gets the args). */ 774 - args_gva = vm_vaddr_alloc_page(vm); 774 + args_gva = vm_alloc_page(vm); 775 775 memcpy(addr_gva2hva(vm, args_gva), &args, sizeof(args)); 776 776 vcpu_args_set(vcpu, 1, args_gva); 777 777 ··· 997 997 vcpu_init_descriptor_tables(vcpus[1]); 998 998 999 999 /* Setup the guest args page (so it gets the args). */ 1000 - args_gva = vm_vaddr_alloc_page(vm); 1000 + args_gva = vm_alloc_page(vm); 1001 1001 memcpy(addr_gva2hva(vm, args_gva), &args, sizeof(args)); 1002 1002 vcpu_args_set(vcpus[0], 2, args_gva, 0); 1003 1003 vcpu_args_set(vcpus[1], 2, args_gva, 1);
+8 -8
tools/testing/selftests/kvm/include/kvm_util.h
··· 716 716 struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, u32 vcpu_id); 717 717 void vm_populate_vaddr_bitmap(struct kvm_vm *vm); 718 718 gva_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, gva_t vaddr_min); 719 - gva_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min); 720 - gva_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 721 - enum kvm_mem_region_type type); 722 - gva_t vm_vaddr_alloc_shared(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 723 - enum kvm_mem_region_type type); 724 - gva_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages); 725 - gva_t __vm_vaddr_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type); 726 - gva_t vm_vaddr_alloc_page(struct kvm_vm *vm); 719 + gva_t vm_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min); 720 + gva_t __vm_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 721 + enum kvm_mem_region_type type); 722 + gva_t vm_alloc_shared(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 723 + enum kvm_mem_region_type type); 724 + gva_t vm_alloc_pages(struct kvm_vm *vm, int nr_pages); 725 + gva_t __vm_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type); 726 + gva_t vm_alloc_page(struct kvm_vm *vm); 727 727 728 728 void virt_map(struct kvm_vm *vm, u64 vaddr, u64 paddr, 729 729 unsigned int npages);
+5 -5
tools/testing/selftests/kvm/lib/arm64/processor.c
··· 422 422 423 423 stack_size = vm->page_size == 4096 ? DEFAULT_STACK_PGS * vm->page_size : 424 424 vm->page_size; 425 - stack_vaddr = __vm_vaddr_alloc(vm, stack_size, 426 - DEFAULT_ARM64_GUEST_STACK_VADDR_MIN, 427 - MEM_REGION_DATA); 425 + stack_vaddr = __vm_alloc(vm, stack_size, 426 + DEFAULT_ARM64_GUEST_STACK_VADDR_MIN, 427 + MEM_REGION_DATA); 428 428 429 429 aarch64_vcpu_setup(vcpu, init); 430 430 ··· 536 536 537 537 void vm_init_descriptor_tables(struct kvm_vm *vm) 538 538 { 539 - vm->handlers = __vm_vaddr_alloc(vm, sizeof(struct handlers), 540 - vm->page_size, MEM_REGION_DATA); 539 + vm->handlers = __vm_alloc(vm, sizeof(struct handlers), vm->page_size, 540 + MEM_REGION_DATA); 541 541 542 542 *(gva_t *)addr_gva2hva(vm, (gva_t)(&exception_handlers)) = vm->handlers; 543 543 }
+1 -2
tools/testing/selftests/kvm/lib/elf.c
··· 162 162 seg_vend |= vm->page_size - 1; 163 163 size_t seg_size = seg_vend - seg_vstart + 1; 164 164 165 - gva_t vaddr = __vm_vaddr_alloc(vm, seg_size, seg_vstart, 166 - MEM_REGION_CODE); 165 + gva_t vaddr = __vm_alloc(vm, seg_size, seg_vstart, MEM_REGION_CODE); 167 166 TEST_ASSERT(vaddr == seg_vstart, "Unable to allocate " 168 167 "virtual memory for segment at requested min addr,\n" 169 168 " segment idx: %u\n"
+25 -65
tools/testing/selftests/kvm/lib/kvm_util.c
··· 1450 1450 return pgidx_start * vm->page_size; 1451 1451 } 1452 1452 1453 - static gva_t ____vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 1454 - enum kvm_mem_region_type type, bool protected) 1453 + static gva_t ____vm_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 1454 + enum kvm_mem_region_type type, bool protected) 1455 1455 { 1456 1456 u64 pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0); 1457 1457 ··· 1476 1476 return vaddr_start; 1477 1477 } 1478 1478 1479 - gva_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 1480 - enum kvm_mem_region_type type) 1479 + gva_t __vm_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 1480 + enum kvm_mem_region_type type) 1481 1481 { 1482 - return ____vm_vaddr_alloc(vm, sz, vaddr_min, type, 1483 - vm_arch_has_protected_memory(vm)); 1482 + return ____vm_alloc(vm, sz, vaddr_min, type, 1483 + vm_arch_has_protected_memory(vm)); 1484 1484 } 1485 1485 1486 - gva_t vm_vaddr_alloc_shared(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 1487 - enum kvm_mem_region_type type) 1486 + gva_t vm_alloc_shared(struct kvm_vm *vm, size_t sz, gva_t vaddr_min, 1487 + enum kvm_mem_region_type type) 1488 1488 { 1489 - return ____vm_vaddr_alloc(vm, sz, vaddr_min, type, false); 1490 - } 1491 - 1492 - /* 1493 - * VM Virtual Address Allocate 1494 - * 1495 - * Input Args: 1496 - * vm - Virtual Machine 1497 - * sz - Size in bytes 1498 - * vaddr_min - Minimum starting virtual address 1499 - * 1500 - * Output Args: None 1501 - * 1502 - * Return: 1503 - * Starting guest virtual address 1504 - * 1505 - * Allocates at least sz bytes within the virtual address space of the vm 1506 - * given by vm. The allocated bytes are mapped to a virtual address >= 1507 - * the address given by vaddr_min. Note that each allocation uses a 1508 - * a unique set of pages, with the minimum real allocation being at least 1509 - * a page. The allocated physical space comes from the TEST_DATA memory region. 1510 - */ 1511 - gva_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min) 1512 - { 1513 - return __vm_vaddr_alloc(vm, sz, vaddr_min, MEM_REGION_TEST_DATA); 1489 + return ____vm_alloc(vm, sz, vaddr_min, type, false); 1514 1490 } 1515 1491 1516 1492 /* 1517 - * VM Virtual Address Allocate Pages 1518 - * 1519 - * Input Args: 1520 - * vm - Virtual Machine 1521 - * 1522 - * Output Args: None 1523 - * 1524 - * Return: 1525 - * Starting guest virtual address 1526 - * 1527 - * Allocates at least N system pages worth of bytes within the virtual address 1528 - * space of the vm. 1493 + * Allocates at least sz bytes within the virtual address space of the VM 1494 + * given by @vm. The allocated bytes are mapped to a virtual address >= the 1495 + * address given by @vaddr_min. Note that each allocation uses a a unique set 1496 + * of pages, with the minimum real allocation being at least a page. The 1497 + * allocated physical space comes from the TEST_DATA memory region. 1529 1498 */ 1530 - gva_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages) 1499 + gva_t vm_alloc(struct kvm_vm *vm, size_t sz, gva_t vaddr_min) 1531 1500 { 1532 - return vm_vaddr_alloc(vm, nr_pages * getpagesize(), KVM_UTIL_MIN_VADDR); 1501 + return __vm_alloc(vm, sz, vaddr_min, MEM_REGION_TEST_DATA); 1533 1502 } 1534 1503 1535 - gva_t __vm_vaddr_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type) 1504 + gva_t vm_alloc_pages(struct kvm_vm *vm, int nr_pages) 1536 1505 { 1537 - return __vm_vaddr_alloc(vm, getpagesize(), KVM_UTIL_MIN_VADDR, type); 1506 + return vm_alloc(vm, nr_pages * getpagesize(), KVM_UTIL_MIN_VADDR); 1538 1507 } 1539 1508 1540 - /* 1541 - * VM Virtual Address Allocate Page 1542 - * 1543 - * Input Args: 1544 - * vm - Virtual Machine 1545 - * 1546 - * Output Args: None 1547 - * 1548 - * Return: 1549 - * Starting guest virtual address 1550 - * 1551 - * Allocates at least one system page worth of bytes within the virtual address 1552 - * space of the vm. 1553 - */ 1554 - gva_t vm_vaddr_alloc_page(struct kvm_vm *vm) 1509 + gva_t __vm_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type) 1555 1510 { 1556 - return vm_vaddr_alloc_pages(vm, 1); 1511 + return __vm_alloc(vm, getpagesize(), KVM_UTIL_MIN_VADDR, type); 1512 + } 1513 + 1514 + gva_t vm_alloc_page(struct kvm_vm *vm) 1515 + { 1516 + return vm_alloc_pages(vm, 1); 1557 1517 } 1558 1518 1559 1519 /*
+7 -6
tools/testing/selftests/kvm/lib/loongarch/processor.c
··· 206 206 { 207 207 void *addr; 208 208 209 - vm->handlers = __vm_vaddr_alloc(vm, sizeof(struct handlers), 210 - LOONGARCH_GUEST_STACK_VADDR_MIN, MEM_REGION_DATA); 209 + vm->handlers = __vm_alloc(vm, sizeof(struct handlers), 210 + LOONGARCH_GUEST_STACK_VADDR_MIN, 211 + MEM_REGION_DATA); 211 212 212 213 addr = addr_gva2hva(vm, vm->handlers); 213 214 memset(addr, 0, vm->page_size); ··· 355 354 loongarch_set_csr(vcpu, LOONGARCH_CSR_STLBPGSIZE, PS_DEFAULT_SIZE); 356 355 357 356 /* LOONGARCH_CSR_KS1 is used for exception stack */ 358 - val = __vm_vaddr_alloc(vm, vm->page_size, 359 - LOONGARCH_GUEST_STACK_VADDR_MIN, MEM_REGION_DATA); 357 + val = __vm_alloc(vm, vm->page_size, LOONGARCH_GUEST_STACK_VADDR_MIN, 358 + MEM_REGION_DATA); 360 359 TEST_ASSERT(val != 0, "No memory for exception stack"); 361 360 val = val + vm->page_size; 362 361 loongarch_set_csr(vcpu, LOONGARCH_CSR_KS1, val); ··· 379 378 380 379 vcpu = __vm_vcpu_add(vm, vcpu_id); 381 380 stack_size = vm->page_size; 382 - stack_vaddr = __vm_vaddr_alloc(vm, stack_size, 383 - LOONGARCH_GUEST_STACK_VADDR_MIN, MEM_REGION_DATA); 381 + stack_vaddr = __vm_alloc(vm, stack_size, 382 + LOONGARCH_GUEST_STACK_VADDR_MIN, MEM_REGION_DATA); 384 383 TEST_ASSERT(stack_vaddr != 0, "No memory for vm stack"); 385 384 386 385 loongarch_vcpu_setup(vcpu);
+3 -3
tools/testing/selftests/kvm/lib/riscv/processor.c
··· 322 322 323 323 stack_size = vm->page_size == 4096 ? DEFAULT_STACK_PGS * vm->page_size : 324 324 vm->page_size; 325 - stack_vaddr = __vm_vaddr_alloc(vm, stack_size, 325 + stack_vaddr = __vm_alloc(vm, stack_size, 326 326 DEFAULT_RISCV_GUEST_STACK_VADDR_MIN, 327 327 MEM_REGION_DATA); 328 328 ··· 449 449 450 450 void vm_init_vector_tables(struct kvm_vm *vm) 451 451 { 452 - vm->handlers = __vm_vaddr_alloc(vm, sizeof(struct handlers), 453 - vm->page_size, MEM_REGION_DATA); 452 + vm->handlers = __vm_alloc(vm, sizeof(struct handlers), vm->page_size, 453 + MEM_REGION_DATA); 454 454 455 455 *(gva_t *)addr_gva2hva(vm, (gva_t)(&exception_handlers)) = vm->handlers; 456 456 }
+1 -1
tools/testing/selftests/kvm/lib/s390/processor.c
··· 171 171 TEST_ASSERT(vm->page_size == PAGE_SIZE, "Unsupported page size: 0x%x", 172 172 vm->page_size); 173 173 174 - stack_vaddr = __vm_vaddr_alloc(vm, stack_size, 174 + stack_vaddr = __vm_alloc(vm, stack_size, 175 175 DEFAULT_GUEST_STACK_VADDR_MIN, 176 176 MEM_REGION_DATA); 177 177
+2 -2
tools/testing/selftests/kvm/lib/ucall_common.c
··· 32 32 gva_t vaddr; 33 33 int i; 34 34 35 - vaddr = vm_vaddr_alloc_shared(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR, 36 - MEM_REGION_DATA); 35 + vaddr = vm_alloc_shared(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR, 36 + MEM_REGION_DATA); 37 37 hdr = (struct ucall_header *)addr_gva2hva(vm, vaddr); 38 38 memset(hdr, 0, sizeof(*hdr)); 39 39
+4 -4
tools/testing/selftests/kvm/lib/x86/hyperv.c
··· 78 78 struct hyperv_test_pages *vcpu_alloc_hyperv_test_pages(struct kvm_vm *vm, 79 79 gva_t *p_hv_pages_gva) 80 80 { 81 - gva_t hv_pages_gva = vm_vaddr_alloc_page(vm); 81 + gva_t hv_pages_gva = vm_alloc_page(vm); 82 82 struct hyperv_test_pages *hv = addr_gva2hva(vm, hv_pages_gva); 83 83 84 84 /* Setup of a region of guest memory for the VP Assist page. */ 85 - hv->vp_assist = (void *)vm_vaddr_alloc_page(vm); 85 + hv->vp_assist = (void *)vm_alloc_page(vm); 86 86 hv->vp_assist_hva = addr_gva2hva(vm, (uintptr_t)hv->vp_assist); 87 87 hv->vp_assist_gpa = addr_gva2gpa(vm, (uintptr_t)hv->vp_assist); 88 88 89 89 /* Setup of a region of guest memory for the partition assist page. */ 90 - hv->partition_assist = (void *)vm_vaddr_alloc_page(vm); 90 + hv->partition_assist = (void *)vm_alloc_page(vm); 91 91 hv->partition_assist_hva = addr_gva2hva(vm, (uintptr_t)hv->partition_assist); 92 92 hv->partition_assist_gpa = addr_gva2gpa(vm, (uintptr_t)hv->partition_assist); 93 93 94 94 /* Setup of a region of guest memory for the enlightened VMCS. */ 95 - hv->enlightened_vmcs = (void *)vm_vaddr_alloc_page(vm); 95 + hv->enlightened_vmcs = (void *)vm_alloc_page(vm); 96 96 hv->enlightened_vmcs_hva = addr_gva2hva(vm, (uintptr_t)hv->enlightened_vmcs); 97 97 hv->enlightened_vmcs_gpa = addr_gva2gpa(vm, (uintptr_t)hv->enlightened_vmcs); 98 98
+6 -6
tools/testing/selftests/kvm/lib/x86/processor.c
··· 746 746 struct kvm_segment seg; 747 747 int i; 748 748 749 - vm->arch.gdt = __vm_vaddr_alloc_page(vm, MEM_REGION_DATA); 750 - vm->arch.idt = __vm_vaddr_alloc_page(vm, MEM_REGION_DATA); 751 - vm->handlers = __vm_vaddr_alloc_page(vm, MEM_REGION_DATA); 752 - vm->arch.tss = __vm_vaddr_alloc_page(vm, MEM_REGION_DATA); 749 + vm->arch.gdt = __vm_alloc_page(vm, MEM_REGION_DATA); 750 + vm->arch.idt = __vm_alloc_page(vm, MEM_REGION_DATA); 751 + vm->handlers = __vm_alloc_page(vm, MEM_REGION_DATA); 752 + vm->arch.tss = __vm_alloc_page(vm, MEM_REGION_DATA); 753 753 754 754 /* Handlers have the same address in both address spaces.*/ 755 755 for (i = 0; i < NUM_INTERRUPTS; i++) ··· 828 828 gva_t stack_vaddr; 829 829 struct kvm_vcpu *vcpu; 830 830 831 - stack_vaddr = __vm_vaddr_alloc(vm, DEFAULT_STACK_PGS * getpagesize(), 831 + stack_vaddr = __vm_alloc(vm, DEFAULT_STACK_PGS * getpagesize(), 832 832 DEFAULT_GUEST_STACK_VADDR_MIN, 833 833 MEM_REGION_DATA); 834 834 ··· 844 844 * may need to subtract 4 bytes instead of 8 bytes. 845 845 */ 846 846 TEST_ASSERT(IS_ALIGNED(stack_vaddr, PAGE_SIZE), 847 - "__vm_vaddr_alloc() did not provide a page-aligned address"); 847 + "__vm_alloc() did not provide a page-aligned address"); 848 848 stack_vaddr -= 8; 849 849 850 850 vcpu = __vm_vcpu_add(vm, vcpu_id);
+4 -4
tools/testing/selftests/kvm/lib/x86/svm.c
··· 30 30 struct svm_test_data * 31 31 vcpu_alloc_svm(struct kvm_vm *vm, gva_t *p_svm_gva) 32 32 { 33 - gva_t svm_gva = vm_vaddr_alloc_page(vm); 33 + gva_t svm_gva = vm_alloc_page(vm); 34 34 struct svm_test_data *svm = addr_gva2hva(vm, svm_gva); 35 35 36 - svm->vmcb = (void *)vm_vaddr_alloc_page(vm); 36 + svm->vmcb = (void *)vm_alloc_page(vm); 37 37 svm->vmcb_hva = addr_gva2hva(vm, (uintptr_t)svm->vmcb); 38 38 svm->vmcb_gpa = addr_gva2gpa(vm, (uintptr_t)svm->vmcb); 39 39 40 - svm->save_area = (void *)vm_vaddr_alloc_page(vm); 40 + svm->save_area = (void *)vm_alloc_page(vm); 41 41 svm->save_area_hva = addr_gva2hva(vm, (uintptr_t)svm->save_area); 42 42 svm->save_area_gpa = addr_gva2gpa(vm, (uintptr_t)svm->save_area); 43 43 44 - svm->msr = (void *)vm_vaddr_alloc_page(vm); 44 + svm->msr = (void *)vm_alloc_page(vm); 45 45 svm->msr_hva = addr_gva2hva(vm, (uintptr_t)svm->msr); 46 46 svm->msr_gpa = addr_gva2gpa(vm, (uintptr_t)svm->msr); 47 47 memset(svm->msr_hva, 0, getpagesize());
+8 -8
tools/testing/selftests/kvm/lib/x86/vmx.c
··· 81 81 struct vmx_pages * 82 82 vcpu_alloc_vmx(struct kvm_vm *vm, gva_t *p_vmx_gva) 83 83 { 84 - gva_t vmx_gva = vm_vaddr_alloc_page(vm); 84 + gva_t vmx_gva = vm_alloc_page(vm); 85 85 struct vmx_pages *vmx = addr_gva2hva(vm, vmx_gva); 86 86 87 87 /* Setup of a region of guest memory for the vmxon region. */ 88 - vmx->vmxon = (void *)vm_vaddr_alloc_page(vm); 88 + vmx->vmxon = (void *)vm_alloc_page(vm); 89 89 vmx->vmxon_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmxon); 90 90 vmx->vmxon_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmxon); 91 91 92 92 /* Setup of a region of guest memory for a vmcs. */ 93 - vmx->vmcs = (void *)vm_vaddr_alloc_page(vm); 93 + vmx->vmcs = (void *)vm_alloc_page(vm); 94 94 vmx->vmcs_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmcs); 95 95 vmx->vmcs_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmcs); 96 96 97 97 /* Setup of a region of guest memory for the MSR bitmap. */ 98 - vmx->msr = (void *)vm_vaddr_alloc_page(vm); 98 + vmx->msr = (void *)vm_alloc_page(vm); 99 99 vmx->msr_hva = addr_gva2hva(vm, (uintptr_t)vmx->msr); 100 100 vmx->msr_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->msr); 101 101 memset(vmx->msr_hva, 0, getpagesize()); 102 102 103 103 /* Setup of a region of guest memory for the shadow VMCS. */ 104 - vmx->shadow_vmcs = (void *)vm_vaddr_alloc_page(vm); 104 + vmx->shadow_vmcs = (void *)vm_alloc_page(vm); 105 105 vmx->shadow_vmcs_hva = addr_gva2hva(vm, (uintptr_t)vmx->shadow_vmcs); 106 106 vmx->shadow_vmcs_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->shadow_vmcs); 107 107 108 108 /* Setup of a region of guest memory for the VMREAD and VMWRITE bitmaps. */ 109 - vmx->vmread = (void *)vm_vaddr_alloc_page(vm); 109 + vmx->vmread = (void *)vm_alloc_page(vm); 110 110 vmx->vmread_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmread); 111 111 vmx->vmread_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmread); 112 112 memset(vmx->vmread_hva, 0, getpagesize()); 113 113 114 - vmx->vmwrite = (void *)vm_vaddr_alloc_page(vm); 114 + vmx->vmwrite = (void *)vm_alloc_page(vm); 115 115 vmx->vmwrite_hva = addr_gva2hva(vm, (uintptr_t)vmx->vmwrite); 116 116 vmx->vmwrite_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->vmwrite); 117 117 memset(vmx->vmwrite_hva, 0, getpagesize()); ··· 390 390 391 391 void prepare_virtualize_apic_accesses(struct vmx_pages *vmx, struct kvm_vm *vm) 392 392 { 393 - vmx->apic_access = (void *)vm_vaddr_alloc_page(vm); 393 + vmx->apic_access = (void *)vm_alloc_page(vm); 394 394 vmx->apic_access_hva = addr_gva2hva(vm, (uintptr_t)vmx->apic_access); 395 395 vmx->apic_access_gpa = addr_gva2gpa(vm, (uintptr_t)vmx->apic_access); 396 396 }
+6 -6
tools/testing/selftests/kvm/s390/memop.c
··· 880 880 struct test_default t = test_default_init(guest_copy_key_fetch_prot_override); 881 881 gva_t guest_0_page, guest_last_page; 882 882 883 - guest_0_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, 0); 884 - guest_last_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr); 883 + guest_0_page = vm_alloc(t.kvm_vm, PAGE_SIZE, 0); 884 + guest_last_page = vm_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr); 885 885 if (guest_0_page != 0 || guest_last_page != last_page_addr) { 886 886 print_skip("did not allocate guest pages at required positions"); 887 887 goto out; ··· 919 919 struct test_default t = test_default_init(guest_copy_key_fetch_prot_override); 920 920 gva_t guest_0_page, guest_last_page; 921 921 922 - guest_0_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, 0); 923 - guest_last_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr); 922 + guest_0_page = vm_alloc(t.kvm_vm, PAGE_SIZE, 0); 923 + guest_last_page = vm_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr); 924 924 if (guest_0_page != 0 || guest_last_page != last_page_addr) { 925 925 print_skip("did not allocate guest pages at required positions"); 926 926 goto out; ··· 940 940 struct test_default t = test_default_init(guest_copy_key_fetch_prot_override); 941 941 gva_t guest_0_page, guest_last_page; 942 942 943 - guest_0_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, 0); 944 - guest_last_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr); 943 + guest_0_page = vm_alloc(t.kvm_vm, PAGE_SIZE, 0); 944 + guest_last_page = vm_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr); 945 945 if (guest_0_page != 0 || guest_last_page != last_page_addr) { 946 946 print_skip("did not allocate guest pages at required positions"); 947 947 goto out;
+2 -2
tools/testing/selftests/kvm/s390/tprot.c
··· 146 146 /* 147 147 * Some fetch protection override tests require that page 0 148 148 * be mapped, however, when the hosts tries to map that page via 149 - * vm_vaddr_alloc, it may happen that some other page gets mapped 149 + * vm_alloc, it may happen that some other page gets mapped 150 150 * instead. 151 151 * In order to skip these tests we detect this inside the guest 152 152 */ ··· 219 219 mprotect(addr_gva2hva(vm, (gva_t)pages), PAGE_SIZE * 2, PROT_READ); 220 220 HOST_SYNC(vcpu, TEST_SIMPLE); 221 221 222 - guest_0_page = vm_vaddr_alloc(vm, PAGE_SIZE, 0); 222 + guest_0_page = vm_alloc(vm, PAGE_SIZE, 0); 223 223 if (guest_0_page != 0) { 224 224 /* Use NO_TAP so we don't get a PASS print */ 225 225 HOST_SYNC_NO_TAP(vcpu, STAGE_INIT_FETCH_PROT_OVERRIDE);
+3 -3
tools/testing/selftests/kvm/x86/amx_test.c
··· 263 263 vcpu_regs_get(vcpu, &regs1); 264 264 265 265 /* amx cfg for guest_code */ 266 - amx_cfg = vm_vaddr_alloc_page(vm); 266 + amx_cfg = vm_alloc_page(vm); 267 267 memset(addr_gva2hva(vm, amx_cfg), 0x0, getpagesize()); 268 268 269 269 /* amx tiledata for guest_code */ 270 - tiledata = vm_vaddr_alloc_pages(vm, 2); 270 + tiledata = vm_alloc_pages(vm, 2); 271 271 memset(addr_gva2hva(vm, tiledata), rand() | 1, 2 * getpagesize()); 272 272 273 273 /* XSAVE state for guest_code */ 274 - xstate = vm_vaddr_alloc_pages(vm, DIV_ROUND_UP(XSAVE_SIZE, PAGE_SIZE)); 274 + xstate = vm_alloc_pages(vm, DIV_ROUND_UP(XSAVE_SIZE, PAGE_SIZE)); 275 275 memset(addr_gva2hva(vm, xstate), 0, PAGE_SIZE * DIV_ROUND_UP(XSAVE_SIZE, PAGE_SIZE)); 276 276 vcpu_args_set(vcpu, 3, amx_cfg, tiledata, xstate); 277 277
+1 -1
tools/testing/selftests/kvm/x86/cpuid_test.c
··· 143 143 struct kvm_cpuid2 *vcpu_alloc_cpuid(struct kvm_vm *vm, gva_t *p_gva, struct kvm_cpuid2 *cpuid) 144 144 { 145 145 int size = sizeof(*cpuid) + cpuid->nent * sizeof(cpuid->entries[0]); 146 - gva_t gva = vm_vaddr_alloc(vm, size, KVM_UTIL_MIN_VADDR); 146 + gva_t gva = vm_alloc(vm, size, KVM_UTIL_MIN_VADDR); 147 147 struct kvm_cpuid2 *guest_cpuids = addr_gva2hva(vm, gva); 148 148 149 149 memcpy(guest_cpuids, cpuid, size);
+1 -1
tools/testing/selftests/kvm/x86/hyperv_clock.c
··· 218 218 219 219 vcpu_set_hv_cpuid(vcpu); 220 220 221 - tsc_page_gva = vm_vaddr_alloc_page(vm); 221 + tsc_page_gva = vm_alloc_page(vm); 222 222 memset(addr_gva2hva(vm, tsc_page_gva), 0x0, getpagesize()); 223 223 TEST_ASSERT((addr_gva2gpa(vm, tsc_page_gva) & (getpagesize() - 1)) == 0, 224 224 "TSC page has to be page aligned");
+1 -1
tools/testing/selftests/kvm/x86/hyperv_evmcs.c
··· 246 246 247 247 vm = vm_create_with_one_vcpu(&vcpu, guest_code); 248 248 249 - hcall_page = vm_vaddr_alloc_pages(vm, 1); 249 + hcall_page = vm_alloc_pages(vm, 1); 250 250 memset(addr_gva2hva(vm, hcall_page), 0x0, getpagesize()); 251 251 252 252 vcpu_set_hv_cpuid(vcpu);
+2 -2
tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c
··· 57 57 vcpu_set_hv_cpuid(vcpu); 58 58 59 59 /* Hypercall input */ 60 - hcall_in_page = vm_vaddr_alloc_pages(vm, 1); 60 + hcall_in_page = vm_alloc_pages(vm, 1); 61 61 memset(addr_gva2hva(vm, hcall_in_page), 0x0, vm->page_size); 62 62 63 63 /* Hypercall output */ 64 - hcall_out_page = vm_vaddr_alloc_pages(vm, 1); 64 + hcall_out_page = vm_alloc_pages(vm, 1); 65 65 memset(addr_gva2hva(vm, hcall_out_page), 0x0, vm->page_size); 66 66 67 67 vcpu_args_set(vcpu, 3, addr_gva2gpa(vm, hcall_in_page),
+3 -3
tools/testing/selftests/kvm/x86/hyperv_features.c
··· 141 141 while (true) { 142 142 vm = vm_create_with_one_vcpu(&vcpu, guest_msr); 143 143 144 - msr_gva = vm_vaddr_alloc_page(vm); 144 + msr_gva = vm_alloc_page(vm); 145 145 memset(addr_gva2hva(vm, msr_gva), 0x0, getpagesize()); 146 146 msr = addr_gva2hva(vm, msr_gva); 147 147 ··· 530 530 vm = vm_create_with_one_vcpu(&vcpu, guest_hcall); 531 531 532 532 /* Hypercall input/output */ 533 - hcall_page = vm_vaddr_alloc_pages(vm, 2); 533 + hcall_page = vm_alloc_pages(vm, 2); 534 534 memset(addr_gva2hva(vm, hcall_page), 0x0, 2 * getpagesize()); 535 535 536 - hcall_params = vm_vaddr_alloc_page(vm); 536 + hcall_params = vm_alloc_page(vm); 537 537 memset(addr_gva2hva(vm, hcall_params), 0x0, getpagesize()); 538 538 hcall = addr_gva2hva(vm, hcall_params); 539 539
+1 -1
tools/testing/selftests/kvm/x86/hyperv_ipi.c
··· 253 253 vm = vm_create_with_one_vcpu(&vcpu[0], sender_guest_code); 254 254 255 255 /* Hypercall input/output */ 256 - hcall_page = vm_vaddr_alloc_pages(vm, 2); 256 + hcall_page = vm_alloc_pages(vm, 2); 257 257 memset(addr_gva2hva(vm, hcall_page), 0x0, 2 * getpagesize()); 258 258 259 259
+1 -1
tools/testing/selftests/kvm/x86/hyperv_svm_test.c
··· 165 165 vcpu_alloc_svm(vm, &nested_gva); 166 166 vcpu_alloc_hyperv_test_pages(vm, &hv_pages_gva); 167 167 168 - hcall_page = vm_vaddr_alloc_pages(vm, 1); 168 + hcall_page = vm_alloc_pages(vm, 1); 169 169 memset(addr_gva2hva(vm, hcall_page), 0x0, getpagesize()); 170 170 171 171 vcpu_args_set(vcpu, 3, nested_gva, hv_pages_gva, addr_gva2gpa(vm, hcall_page));
+3 -3
tools/testing/selftests/kvm/x86/hyperv_tlb_flush.c
··· 593 593 vm = vm_create_with_one_vcpu(&vcpu[0], sender_guest_code); 594 594 595 595 /* Test data page */ 596 - test_data_page = vm_vaddr_alloc_page(vm); 596 + test_data_page = vm_alloc_page(vm); 597 597 data = (struct test_data *)addr_gva2hva(vm, test_data_page); 598 598 599 599 /* Hypercall input/output */ 600 - data->hcall_gva = vm_vaddr_alloc_pages(vm, 2); 600 + data->hcall_gva = vm_alloc_pages(vm, 2); 601 601 data->hcall_gpa = addr_gva2gpa(vm, data->hcall_gva); 602 602 memset(addr_gva2hva(vm, data->hcall_gva), 0x0, 2 * PAGE_SIZE); 603 603 ··· 606 606 * and the test will swap their mappings. The third page keeps the indication 607 607 * about the current state of mappings. 608 608 */ 609 - data->test_pages = vm_vaddr_alloc_pages(vm, NTEST_PAGES + 1); 609 + data->test_pages = vm_alloc_pages(vm, NTEST_PAGES + 1); 610 610 for (i = 0; i < NTEST_PAGES; i++) 611 611 memset(addr_gva2hva(vm, data->test_pages + PAGE_SIZE * i), 612 612 (u8)(i + 1), PAGE_SIZE);
+1 -1
tools/testing/selftests/kvm/x86/kvm_clock_test.c
··· 147 147 148 148 vm = vm_create_with_one_vcpu(&vcpu, guest_main); 149 149 150 - pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000); 150 + pvti_gva = vm_alloc(vm, getpagesize(), 0x10000); 151 151 pvti_gpa = addr_gva2gpa(vm, pvti_gva); 152 152 vcpu_args_set(vcpu, 2, pvti_gpa, pvti_gva); 153 153
+2 -2
tools/testing/selftests/kvm/x86/sev_smoke_test.c
··· 115 115 struct kvm_xsave __attribute__((aligned(64))) xsave = { 0 }; 116 116 117 117 vm = vm_sev_create_with_one_vcpu(type, guest_code_xsave, &vcpu); 118 - gva = vm_vaddr_alloc_shared(vm, PAGE_SIZE, KVM_UTIL_MIN_VADDR, 119 - MEM_REGION_TEST_DATA); 118 + gva = vm_alloc_shared(vm, PAGE_SIZE, KVM_UTIL_MIN_VADDR, 119 + MEM_REGION_TEST_DATA); 120 120 hva = addr_gva2hva(vm, gva); 121 121 122 122 vcpu_args_set(vcpu, 1, gva);
+1 -1
tools/testing/selftests/kvm/x86/svm_nested_soft_inject_test.c
··· 161 161 if (!is_nmi) { 162 162 void *idt, *idt_alt; 163 163 164 - idt_alt_vm = vm_vaddr_alloc_page(vm); 164 + idt_alt_vm = vm_alloc_page(vm); 165 165 idt_alt = addr_gva2hva(vm, idt_alt_vm); 166 166 idt = addr_gva2hva(vm, vm->arch.idt); 167 167 memcpy(idt_alt, idt, getpagesize());
+1 -1
tools/testing/selftests/kvm/x86/xapic_ipi_test.c
··· 414 414 415 415 params[1].vcpu = vm_vcpu_add(vm, 1, sender_guest_code); 416 416 417 - test_data_page_vaddr = vm_vaddr_alloc_page(vm); 417 + test_data_page_vaddr = vm_alloc_page(vm); 418 418 data = addr_gva2hva(vm, test_data_page_vaddr); 419 419 memset(data, 0, sizeof(*data)); 420 420 params[0].data = data;