Commit a11d7124 authored by Fuad Tabba's avatar Fuad Tabba Committed by Paolo Bonzini
Browse files

KVM: selftests: guest_memfd mmap() test when mmap is supported 



Expand the guest_memfd selftests to comprehensively test host userspace
mmap functionality for guest_memfd-backed memory when supported by the
VM type.

Introduce new test cases to verify the following:

* Successful mmap operations: Ensure that MAP_SHARED mappings succeed
  when guest_memfd mmap is enabled.

* Data integrity: Validate that data written to the mmap'd region is
  correctly persistent and readable.

* fallocate interaction: Test that fallocate(FALLOC_FL_PUNCH_HOLE)
  correctly zeros out mapped pages.

* Out-of-bounds access: Verify that accessing memory beyond the
  guest_memfd's size correctly triggers a SIGBUS signal.

* Unsupported mmap: Confirm that mmap attempts fail as expected when
  guest_memfd mmap support is not enabled for the specific guest_memfd
  instance or VM type.

* Flag validity: Introduce test_vm_type_gmem_flag_validity() to
  systematically test that only allowed guest_memfd creation flags are
  accepted for different VM types (e.g., GUEST_MEMFD_FLAG_MMAP for
  default VMs, no flags for CoCo VMs).

The existing tests for guest_memfd creation (multiple instances, invalid
sizes), file read/write, file size, and invalid punch hole operations
are integrated into the new test_with_type() framework to allow testing
across different VM types.

Cc: James Houghton <jthoughton@google.com>
Cc: Gavin Shan <gshan@redhat.com>
Cc: Shivank Garg <shivankg@amd.com>
Co-developed-by: default avatarAckerley Tng <ackerleytng@google.com>
Signed-off-by: default avatarAckerley Tng <ackerleytng@google.com>
Signed-off-by: default avatarFuad Tabba <tabba@google.com>
Co-developed-by: default avatarSean Christopherson <seanjc@google.com>
Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
Message-ID: <20250729225455.670324-24-seanjc@google.com>
[Fix default vm_types to use BIT() - Paolo]
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 692f6ecf

tools/testing/selftests/kvm/guest_memfd_test.c

+139 −22
Original line number Diff line number Diff line
@@ -13,6 +13,8 @@ 


#include <linux/bitmap.h>

#include <linux/falloc.h>

#include <setjmp.h>

#include <signal.h>

#include <sys/mman.h>

#include <sys/types.h>

#include <sys/stat.h>
@@ -34,12 +36,83 @@ static void test_file_read_write(int fd) 
		    "pwrite on a guest_mem fd should fail");

}



static void test_mmap(int fd, size_t page_size)

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

{

	const char val = 0xaa;

	char *mem;

	size_t i;

	int ret;



	mem = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);

	TEST_ASSERT(mem == MAP_FAILED, "Copy-on-write not allowed by guest_memfd.");



	mem = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	TEST_ASSERT(mem != MAP_FAILED, "mmap() for guest_memfd should succeed.");



	memset(mem, val, total_size);

	for (i = 0; i < total_size; i++)

		TEST_ASSERT_EQ(READ_ONCE(mem[i]), val);



	ret = fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0,

			page_size);

	TEST_ASSERT(!ret, "fallocate the first page should succeed.");



	for (i = 0; i < page_size; i++)

		TEST_ASSERT_EQ(READ_ONCE(mem[i]), 0x00);

	for (; i < total_size; i++)

		TEST_ASSERT_EQ(READ_ONCE(mem[i]), val);



	memset(mem, val, page_size);

	for (i = 0; i < total_size; i++)

		TEST_ASSERT_EQ(READ_ONCE(mem[i]), val);



	ret = munmap(mem, total_size);

	TEST_ASSERT(!ret, "munmap() should succeed.");

}



static sigjmp_buf jmpbuf;

void fault_sigbus_handler(int signum)

{

	siglongjmp(jmpbuf, 1);

}



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

{

	struct sigaction sa_old, sa_new = {

		.sa_handler = fault_sigbus_handler,

	};

	size_t map_size = total_size * 4;

	const char val = 0xaa;

	char *mem;

	size_t i;

	int ret;



	mem = mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	TEST_ASSERT(mem != MAP_FAILED, "mmap() for guest_memfd should succeed.");



	sigaction(SIGBUS, &sa_new, &sa_old);

	if (sigsetjmp(jmpbuf, 1) == 0) {

		memset(mem, 0xaa, map_size);

		TEST_ASSERT(false, "memset() should have triggered SIGBUS.");

	}

	sigaction(SIGBUS, &sa_old, NULL);



	for (i = 0; i < total_size; i++)

		TEST_ASSERT_EQ(READ_ONCE(mem[i]), val);



	ret = munmap(mem, map_size);

	TEST_ASSERT(!ret, "munmap() should succeed.");

}



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

{

	char *mem;



	mem = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	TEST_ASSERT_EQ(mem, MAP_FAILED);



	mem = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	TEST_ASSERT_EQ(mem, MAP_FAILED);

}



static void test_file_size(int fd, size_t page_size, size_t total_size)
@@ -120,26 +193,19 @@ static void test_invalid_punch_hole(int fd, size_t page_size, size_t total_size) 
	}

}



static void test_create_guest_memfd_invalid(struct kvm_vm *vm)

static void test_create_guest_memfd_invalid_sizes(struct kvm_vm *vm,

						  uint64_t guest_memfd_flags,

						  size_t page_size)

{

	size_t page_size = getpagesize();

	uint64_t flag;

	size_t size;

	int fd;



	for (size = 1; size < page_size; size++) {

		fd = __vm_create_guest_memfd(vm, size, 0);

		TEST_ASSERT(fd == -1 && errno == EINVAL,

		fd = __vm_create_guest_memfd(vm, size, guest_memfd_flags);

		TEST_ASSERT(fd < 0 && errno == EINVAL,

			    "guest_memfd() with non-page-aligned page size '0x%lx' should fail with EINVAL",

			    size);

	}



	for (flag = BIT(0); flag; flag <<= 1) {

		fd = __vm_create_guest_memfd(vm, page_size, flag);

		TEST_ASSERT(fd == -1 && errno == EINVAL,

			    "guest_memfd() with flag '0x%lx' should fail with EINVAL",

			    flag);

	}

}



static void test_create_guest_memfd_multiple(struct kvm_vm *vm)
@@ -171,30 +237,81 @@ static void test_create_guest_memfd_multiple(struct kvm_vm *vm) 
	close(fd1);

}



int main(int argc, char *argv[])

static void test_guest_memfd_flags(struct kvm_vm *vm, uint64_t valid_flags)

{

	size_t page_size;

	size_t total_size;

	size_t page_size = getpagesize();

	uint64_t flag;

	int fd;

	struct kvm_vm *vm;



	TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD));

	for (flag = BIT(0); flag; flag <<= 1) {

		fd = __vm_create_guest_memfd(vm, page_size, flag);

		if (flag & valid_flags) {

			TEST_ASSERT(fd >= 0,

				    "guest_memfd() with flag '0x%lx' should succeed",

				    flag);

			close(fd);

		} else {

			TEST_ASSERT(fd < 0 && errno == EINVAL,

				    "guest_memfd() with flag '0x%lx' should fail with EINVAL",

				    flag);

		}

	}

}



static void test_guest_memfd(unsigned long vm_type)

{

	uint64_t flags = 0;

	struct kvm_vm *vm;

	size_t total_size;

	size_t page_size;

	int fd;



	page_size = getpagesize();

	total_size = page_size * 4;



	vm = vm_create_barebones();

	vm = vm_create_barebones_type(vm_type);



	if (vm_check_cap(vm, KVM_CAP_GUEST_MEMFD_MMAP))

		flags |= GUEST_MEMFD_FLAG_MMAP;



	test_create_guest_memfd_invalid(vm);

	test_create_guest_memfd_multiple(vm);

	test_create_guest_memfd_invalid_sizes(vm, flags, page_size);



	fd = vm_create_guest_memfd(vm, total_size, 0);

	fd = vm_create_guest_memfd(vm, total_size, flags);



	test_file_read_write(fd);

	test_mmap(fd, page_size);



	if (flags & GUEST_MEMFD_FLAG_MMAP) {

		test_mmap_supported(fd, page_size, total_size);

		test_fault_overflow(fd, page_size, total_size);

	} else {

		test_mmap_not_supported(fd, page_size, 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_guest_memfd_flags(vm, flags);



	close(fd);

	kvm_vm_free(vm);

}



int main(int argc, char *argv[])

{

	unsigned long vm_types, vm_type;



	TEST_REQUIRE(kvm_has_cap(KVM_CAP_GUEST_MEMFD));



	/*

	 * Not all architectures support KVM_CAP_VM_TYPES. However, those that

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

	 */

	vm_types = kvm_check_cap(KVM_CAP_VM_TYPES);

	if (!vm_types)

		vm_types = BIT(VM_TYPE_DEFAULT);



	for_each_set_bit(vm_type, &vm_types, BITS_PER_TYPE(vm_types))

		test_guest_memfd(vm_type);

}