On 02/04/2025 22:10, James Houghton wrote:
On Wed, Apr 2, 2025 at 9:08 AM Nikita Kalyazin kalyazin@amazon.com wrote:
The test demonstrates that a minor userfaultfd event in guest_memfd can be resolved via a memcpy followed by a UFFDIO_CONTINUE ioctl.
Signed-off-by: Nikita Kalyazin kalyazin@amazon.com
.../testing/selftests/kvm/guest_memfd_test.c | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+)
diff --git a/tools/testing/selftests/kvm/guest_memfd_test.c b/tools/testing/selftests/kvm/guest_memfd_test.c index 38c501e49e0e..9b47b796f3aa 100644 --- a/tools/testing/selftests/kvm/guest_memfd_test.c +++ b/tools/testing/selftests/kvm/guest_memfd_test.c @@ -10,12 +10,16 @@ #include <errno.h> #include <stdio.h> #include <fcntl.h> +#include <pthread.h>
#include <linux/bitmap.h> #include <linux/falloc.h> +#include <linux/userfaultfd.h> #include <sys/mman.h> #include <sys/types.h> #include <sys/stat.h> +#include <sys/syscall.h> +#include <sys/ioctl.h>
#include "kvm_util.h" #include "test_util.h" @@ -206,6 +210,93 @@ static void test_create_guest_memfd_multiple(struct kvm_vm *vm) close(fd1); }
+struct fault_args {
char *addr;volatile char value;I think you should/must put volatile on `addr` and not on `value`.
This was to prevent the compiler from omitting the write to the value, because it's never read later on.
+};
+static void *fault_thread_fn(void *arg) +{
struct fault_args *args = arg;/* Trigger page fault */args->value = *args->addr;return NULL;+}
+static void test_uffd_missing(int fd, size_t page_size, size_t total_size)
test_uffd_minor? :)
+{
struct uffdio_register uffd_reg;struct uffdio_continue uffd_cont;struct uffd_msg msg;struct fault_args args;pthread_t fault_thread;void *mem, *mem_nofault, *buf = NULL;int uffd, ret;off_t offset = page_size;void *fault_addr;ret = posix_memalign(&buf, page_size, total_size);TEST_ASSERT_EQ(ret, 0);uffd = syscall(__NR_userfaultfd, O_CLOEXEC);TEST_ASSERT(uffd != -1, "userfaultfd creation should succeed");struct uffdio_api uffdio_api = {.api = UFFD_API,.features = UFFD_FEATURE_MISSING_SHMEM,I think you mean UFFD_FEATURE_MINOR_SHMEM...?
And I'm trying to think through what feature we should expose for guest_memfd; UFFD_FEATURE_MINOR_SHMEM already indicates support for shmem.
We could have UFFD_FEATURE_MINOR_GUESTMEMFD, perhaps that's enough.
Yes, I will introduce UFFD_FEATURE_MINOR_GUEST_MEMFD in the next version.
Or we could have UFFD_FEATURE_MINOR_GENERIC (or nothing at all!). Some VMAs might not support the minor mode, and the user will figure that out when UFFDIO_REGISTER fails.
My concern is the exact reason of the failure may not be apparent to the caller in that case.
};ret = ioctl(uffd, UFFDIO_API, &uffdio_api);TEST_ASSERT(ret != -1, "ioctl(UFFDIO_API) should succeed");mem = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);TEST_ASSERT(mem != MAP_FAILED, "mmap should succeed");mem_nofault = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);TEST_ASSERT(mem_nofault != MAP_FAILED, "mmap should succeed");uffd_reg.range.start = (unsigned long)mem;uffd_reg.range.len = total_size;uffd_reg.mode = UFFDIO_REGISTER_MODE_MINOR;ret = ioctl(uffd, UFFDIO_REGISTER, &uffd_reg);TEST_ASSERT(ret != -1, "ioctl(UFFDIO_REGISTER) should succeed");ret = fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE,offset, page_size);TEST_ASSERT(!ret, "fallocate(PUNCH_HOLE) should succeed");fault_addr = mem + offset;args.addr = fault_addr;ret = pthread_create(&fault_thread, NULL, fault_thread_fn, &args);TEST_ASSERT(ret == 0, "pthread_create should succeed");ret = read(uffd, &msg, sizeof(msg));TEST_ASSERT(ret != -1, "read from userfaultfd should succeed");TEST_ASSERT(msg.event == UFFD_EVENT_PAGEFAULT, "event type should be pagefault");TEST_ASSERT((void *)(msg.arg.pagefault.address & ~(page_size - 1)) == fault_addr,"pagefault should occur at expected address");memcpy(mem_nofault + offset, buf + offset, page_size);uffd_cont.range.start = (unsigned long)fault_addr;uffd_cont.range.len = page_size;uffd_cont.mode = 0;ret = ioctl(uffd, UFFDIO_CONTINUE, &uffd_cont);TEST_ASSERT(ret != -1, "ioctl(UFFDIO_CONTINUE) should succeed");ret = pthread_join(fault_thread, NULL);TEST_ASSERT(ret == 0, "pthread_join should succeed");And maybe also:
/* Right value? */ TEST_ASSERT(args.value == *(char *)mem_nofault)); /* No second fault? */ TEST_ASSERT(args.value == *(char *)mem);
Good idea, thanks. I don't need the volatile anymore :)
ret = munmap(mem_nofault, total_size);TEST_ASSERT(!ret, "munmap should succeed");ret = munmap(mem, total_size);TEST_ASSERT(!ret, "munmap should succeed");free(buf);close(uffd);+}
- unsigned long get_shared_type(void) { #ifdef __x86_64__
@@ -244,6 +335,9 @@ void test_vm_type(unsigned long type, bool is_shared) test_fallocate(fd, page_size, total_size); test_invalid_punch_hole(fd, page_size, total_size);
if (is_shared)test_uffd_missing(fd, page_size, total_size);close(fd); kvm_vm_release(vm);-- 2.47.1