Commit 4ee602e7 authored by David Matlack's avatar David Matlack Committed by Paolo Bonzini
Browse files

KVM: selftests: Replace x86_page_size with PG_LEVEL_XX 



x86_page_size is an enum used to communicate the desired page size with
which to map a range of memory. Under the hood they just encode the
desired level at which to map the page. This ends up being clunky in a
few ways:

 - The name suggests it encodes the size of the page rather than the
   level.
 - In other places in x86_64/processor.c we just use a raw int to encode
   the level.

Simplify this by adopting the kernel style of PG_LEVEL_XX enums and pass
around raw ints when referring to the level. This makes the code easier
to understand since these macros are very common in KVM MMU code.

Signed-off-by: default avatarDavid Matlack <dmatlack@google.com>
Message-Id: <20220520233249.3776001-2-dmatlack@google.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent e3cdaab5

tools/testing/selftests/kvm/include/x86_64/processor.h

+12 −6
Original line number Diff line number Diff line
@@ -482,13 +482,19 @@ void vcpu_set_hv_cpuid(struct kvm_vm *vm, uint32_t vcpuid); 
struct kvm_cpuid2 *vcpu_get_supported_hv_cpuid(struct kvm_vm *vm, uint32_t vcpuid);

void vm_xsave_req_perm(int bit);



enum x86_page_size {

	X86_PAGE_SIZE_4K = 0,

	X86_PAGE_SIZE_2M,

	X86_PAGE_SIZE_1G,

enum pg_level {

	PG_LEVEL_NONE,

	PG_LEVEL_4K,

	PG_LEVEL_2M,

	PG_LEVEL_1G,

	PG_LEVEL_512G,

	PG_LEVEL_NUM

};

void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,

		   enum x86_page_size page_size);



#define PG_LEVEL_SHIFT(_level) ((_level - 1) * 9 + 12)

#define PG_LEVEL_SIZE(_level) (1ull << PG_LEVEL_SHIFT(_level))



void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, int level);



/*

 * Basic CPU control in CR0

tools/testing/selftests/kvm/lib/x86_64/processor.c

+15 −16
Original line number Diff line number Diff line
@@ -158,7 +158,7 @@ static void *virt_get_pte(struct kvm_vm *vm, uint64_t pt_pfn, uint64_t vaddr, 
			  int level)

{

	uint64_t *page_table = addr_gpa2hva(vm, pt_pfn << vm->page_shift);

	int index = vaddr >> (vm->page_shift + level * 9) & 0x1ffu;

	int index = (vaddr >> PG_LEVEL_SHIFT(level)) & 0x1ffu;



	return &page_table[index];

}
@@ -167,14 +167,14 @@ static uint64_t *virt_create_upper_pte(struct kvm_vm *vm, 
				       uint64_t pt_pfn,

				       uint64_t vaddr,

				       uint64_t paddr,

				       int level,

				       enum x86_page_size page_size)

				       int current_level,

				       int target_level)

{

	uint64_t *pte = virt_get_pte(vm, pt_pfn, vaddr, level);

	uint64_t *pte = virt_get_pte(vm, pt_pfn, vaddr, current_level);



	if (!(*pte & PTE_PRESENT_MASK)) {

		*pte = PTE_PRESENT_MASK | PTE_WRITABLE_MASK;

		if (level == page_size)

		if (current_level == target_level)

			*pte |= PTE_LARGE_MASK | (paddr & PHYSICAL_PAGE_MASK);

		else

			*pte |= vm_alloc_page_table(vm) & PHYSICAL_PAGE_MASK;
@@ -184,20 +184,19 @@ static uint64_t *virt_create_upper_pte(struct kvm_vm *vm, 
		 * a hugepage at this level, and that there isn't a hugepage at

		 * this level.

		 */

		TEST_ASSERT(level != page_size,

		TEST_ASSERT(current_level != target_level,

			    "Cannot create hugepage at level: %u, vaddr: 0x%lx\n",

			    page_size, vaddr);

			    current_level, vaddr);

		TEST_ASSERT(!(*pte & PTE_LARGE_MASK),

			    "Cannot create page table at level: %u, vaddr: 0x%lx\n",

			    level, vaddr);

			    current_level, vaddr);

	}

	return pte;

}



void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,

		   enum x86_page_size page_size)

void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, int level)

{

	const uint64_t pg_size = 1ull << ((page_size * 9) + 12);

	const uint64_t pg_size = PG_LEVEL_SIZE(level);

	uint64_t *pml4e, *pdpe, *pde;

	uint64_t *pte;
@@ -222,20 +221,20 @@ void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, 
	 * early if a hugepage was created.

	 */

	pml4e = virt_create_upper_pte(vm, vm->pgd >> vm->page_shift,

				      vaddr, paddr, 3, page_size);

				      vaddr, paddr, PG_LEVEL_512G, level);

	if (*pml4e & PTE_LARGE_MASK)

		return;



	pdpe = virt_create_upper_pte(vm, PTE_GET_PFN(*pml4e), vaddr, paddr, 2, page_size);

	pdpe = virt_create_upper_pte(vm, PTE_GET_PFN(*pml4e), vaddr, paddr, PG_LEVEL_1G, level);

	if (*pdpe & PTE_LARGE_MASK)

		return;



	pde = virt_create_upper_pte(vm, PTE_GET_PFN(*pdpe), vaddr, paddr, 1, page_size);

	pde = virt_create_upper_pte(vm, PTE_GET_PFN(*pdpe), vaddr, paddr, PG_LEVEL_2M, level);

	if (*pde & PTE_LARGE_MASK)

		return;



	/* Fill in page table entry. */

	pte = virt_get_pte(vm, PTE_GET_PFN(*pde), vaddr, 0);

	pte = virt_get_pte(vm, PTE_GET_PFN(*pde), vaddr, PG_LEVEL_4K);

	TEST_ASSERT(!(*pte & PTE_PRESENT_MASK),

		    "PTE already present for 4k page at vaddr: 0x%lx\n", vaddr);

	*pte = PTE_PRESENT_MASK | PTE_WRITABLE_MASK | (paddr & PHYSICAL_PAGE_MASK);
@@ -243,7 +242,7 @@ void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, 


void virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr)

{

	__virt_pg_map(vm, vaddr, paddr, X86_PAGE_SIZE_4K);

	__virt_pg_map(vm, vaddr, paddr, PG_LEVEL_4K);

}



static uint64_t *_vm_get_page_table_entry(struct kvm_vm *vm, int vcpuid,

tools/testing/selftests/kvm/max_guest_memory_test.c

+1 −1
Original line number Diff line number Diff line
@@ -244,7 +244,7 @@ int main(int argc, char *argv[]) 
#ifdef __x86_64__

		/* Identity map memory in the guest using 1gb pages. */

		for (i = 0; i < slot_size; i += size_1gb)

			__virt_pg_map(vm, gpa + i, gpa + i, X86_PAGE_SIZE_1G);

			__virt_pg_map(vm, gpa + i, gpa + i, PG_LEVEL_1G);

#else

		for (i = 0; i < slot_size; i += vm_get_page_size(vm))

			virt_pg_map(vm, gpa + i, gpa + i);

tools/testing/selftests/kvm/x86_64/mmu_role_test.c

+1 −1
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ static void mmu_role_test(u32 *cpuid_reg, u32 evil_cpuid_val) 
	run = vcpu_state(vm, VCPU_ID);



	/* Map 1gb page without a backing memlot. */

	__virt_pg_map(vm, MMIO_GPA, MMIO_GPA, X86_PAGE_SIZE_1G);

	__virt_pg_map(vm, MMIO_GPA, MMIO_GPA, PG_LEVEL_1G);



	r = _vcpu_run(vm, VCPU_ID);