Commit 3a6c0853 authored by Sean Christopherson's avatar Sean Christopherson
Browse files

KVM: selftests: Stash the host page size in a global in the guest_memfd test 



Use a global variable to track the host page size in the guest_memfd test
so that the information doesn't need to be constantly passed around.  The
state is purely a reflection of the underlying system, i.e. can't be set
by the test and is constant for a given invocation of the test, and thus
explicitly passing the host page size to individual testcases adds no
value, e.g. doesn't allow testing different combinations.

Making page_size a global will simplify an upcoming change to create a new
guest_memfd instance per testcase.

No functional change intended.

Reviewed-by: default avatarFuad Tabba <tabba@google.com>
Tested-by: default avatarFuad Tabba <tabba@google.com>
Reviewed-by: default avatarDavid Hildenbrand <david@redhat.com>
Reviewed-by: default avatarAckerley Tng <ackerleytng@google.com>
Tested-by: default avatarAckerley Tng <ackerleytng@google.com>
Link: https://lore.kernel.org/r/20251003232606.4070510-7-seanjc@google.com


Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
parent 44c6cb9f

tools/testing/selftests/kvm/guest_memfd_test.c

+18 −19
Original line number Diff line number Diff line
@@ -24,6 +24,8 @@ 
#include "test_util.h"

#include "ucall_common.h"



static size_t page_size;



static void test_file_read_write(int fd)

{

	char buf[64];
@@ -38,7 +40,7 @@ static void test_file_read_write(int fd) 
		    "pwrite on a guest_mem fd should fail");

}



static void test_mmap_supported(int fd, size_t page_size, size_t total_size)

static void test_mmap_supported(int fd, size_t total_size)

{

	const char val = 0xaa;

	char *mem;
@@ -78,7 +80,7 @@ void fault_sigbus_handler(int signum) 
	siglongjmp(jmpbuf, 1);

}



static void test_fault_overflow(int fd, size_t page_size, size_t total_size)

static void test_fault_overflow(int fd, size_t total_size)

{

	struct sigaction sa_old, sa_new = {

		.sa_handler = fault_sigbus_handler,
@@ -106,7 +108,7 @@ static void test_fault_overflow(int fd, size_t page_size, size_t total_size) 
	TEST_ASSERT(!ret, "munmap() should succeed.");

}



static void test_mmap_not_supported(int fd, size_t page_size, size_t total_size)

static void test_mmap_not_supported(int fd, size_t total_size)

{

	char *mem;
@@ -117,7 +119,7 @@ static void test_mmap_not_supported(int fd, size_t page_size, size_t total_size) 
	TEST_ASSERT_EQ(mem, MAP_FAILED);

}



static void test_file_size(int fd, size_t page_size, size_t total_size)

static void test_file_size(int fd, size_t total_size)

{

	struct stat sb;

	int ret;
@@ -128,7 +130,7 @@ static void test_file_size(int fd, size_t page_size, size_t total_size) 
	TEST_ASSERT_EQ(sb.st_blksize, page_size);

}



static void test_fallocate(int fd, size_t page_size, size_t total_size)

static void test_fallocate(int fd, size_t total_size)

{

	int ret;
@@ -165,7 +167,7 @@ static void test_fallocate(int fd, size_t page_size, size_t total_size) 
	TEST_ASSERT(!ret, "fallocate to restore punched hole should succeed");

}



static void test_invalid_punch_hole(int fd, size_t page_size, size_t total_size)

static void test_invalid_punch_hole(int fd, size_t total_size)

{

	struct {

		off_t offset;
@@ -196,8 +198,7 @@ static void test_invalid_punch_hole(int fd, size_t page_size, size_t total_size) 
}



static void test_create_guest_memfd_invalid_sizes(struct kvm_vm *vm,

						  uint64_t guest_memfd_flags,

						  size_t page_size)

						  uint64_t guest_memfd_flags)

{

	size_t size;

	int fd;
@@ -214,7 +215,6 @@ static void test_create_guest_memfd_multiple(struct kvm_vm *vm) 
{

	int fd1, fd2, ret;

	struct stat st1, st2;

	size_t page_size = getpagesize();



	fd1 = __vm_create_guest_memfd(vm, page_size, 0);

	TEST_ASSERT(fd1 != -1, "memfd creation should succeed");
@@ -242,7 +242,6 @@ static void test_create_guest_memfd_multiple(struct kvm_vm *vm) 
static void test_guest_memfd_flags(struct kvm_vm *vm)

{

	uint64_t valid_flags = vm_check_cap(vm, KVM_CAP_GUEST_MEMFD_FLAGS);

	size_t page_size = getpagesize();

	uint64_t flag;

	int fd;
@@ -265,11 +264,9 @@ static void test_guest_memfd(unsigned long vm_type) 
{

	struct kvm_vm *vm;

	size_t total_size;

	size_t page_size;

	uint64_t flags;

	int fd;



	page_size = getpagesize();

	total_size = page_size * 4;



	vm = vm_create_barebones_type(vm_type);
@@ -280,22 +277,22 @@ static void test_guest_memfd(unsigned long vm_type) 
		flags &= ~GUEST_MEMFD_FLAG_MMAP;



	test_create_guest_memfd_multiple(vm);

	test_create_guest_memfd_invalid_sizes(vm, flags, page_size);

	test_create_guest_memfd_invalid_sizes(vm, flags);



	fd = vm_create_guest_memfd(vm, total_size, flags);



	test_file_read_write(fd);



	if (flags & GUEST_MEMFD_FLAG_MMAP) {

		test_mmap_supported(fd, page_size, total_size);

		test_fault_overflow(fd, page_size, total_size);

		test_mmap_supported(fd, total_size);

		test_fault_overflow(fd, total_size);

	} else {

		test_mmap_not_supported(fd, page_size, total_size);

		test_mmap_not_supported(fd, total_size);

	}



	test_file_size(fd, page_size, total_size);

	test_fallocate(fd, page_size, total_size);

	test_invalid_punch_hole(fd, page_size, total_size);

	test_file_size(fd, total_size);

	test_fallocate(fd, total_size);

	test_invalid_punch_hole(fd, total_size);



	test_guest_memfd_flags(vm);
@@ -374,6 +371,8 @@ int main(int argc, char *argv[]) 


	TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD));



	page_size = getpagesize();



	/*

	 * Not all architectures support KVM_CAP_VM_TYPES. However, those that

	 * support guest_memfd have that support for the default VM type.