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: Ackerley Tng <ackerleytng@google.com>
Signed-off-by: Ackerley Tng <ackerleytng@google.com>
Signed-off-by: Fuad Tabba <tabba@google.com>
Co-developed-by: Sean Christopherson <seanjc@google.com>
Signed-off-by: Sean Christopherson <seanjc@google.com>
Message-ID: <20250729225455.670324-24-seanjc@google.com>
[Fix default vm_types to use BIT() - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/guest_memfd_test.c b/tools/testing/selftests/kvm/guest_memfd_test.c
index 341ba616cf554e8e320d1d44a2dfb5c03a7ebc5d..b88f580b2fd69c06e5e78ca64475f615fc397891 100644 (file)
--- a/tools/testing/selftests/kvm/guest_memfd_test.c
+++ b/tools/testing/selftests/kvm/guest_memfd_test.c
@@ -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);
 }