Userfaultfd minor faults provides userspace with the ability to manually install PTEs with UFFDIO_CONTINUE. Right now, MADV_COLLAPSE can map holes in the VMA when a naturally-aligned THP is present. This is not true for khugepaged collapse: the PTEs will be retracted, but a PMD will not be installed. When MADV_COLLAPSE installs a PMD that mapped holes in the VMA, userspace is likely to expect UFFDIO_CONTINUE to succeed on the should-be holes. UFFDIO_CONTINUE will fail and return EEXIST. This is not inherently a problem, as MADV_COLLAPSE is an explicit userspace action. But, especially because MADV_COLLAPSE can be invoked by an external process via process_madvise(), a rogue caller could break a userfaultfd-minor resolver thread. If khugepaged is later updated to install PMDs for khugepaged collapsing, that would be a genuine problem. Userspace cannot generally use MADV_COLLAPSE to resolve userfault minor faults, as MADV_COLLAPSE will only resolve such faults if a naturally-aligned THP is present. The naturally-aligned THP case is the only case where this quirk exists. Collapsing otherwise requires all PTEs to be present for userfaultfd-registered VMAs (i.e., max none PTEs is 0), which is correct. This check is essentially bypassed for naturally-aligned THPs. Suggested-by: Lance Yang Tested-by: Lance Yang Signed-off-by: James Houghton --- v2: https://lore.kernel.org/linux-mm/20260828222640.1638457-1-jthoughton@google.com/ Changes since v2: - Drop cc:stable and update the changelog for the main patch. khugepaged doesn't actually install PMDs, so it is impossible for the kernel to silently install mappings that userspace didn't ask for. Therefore this patch does not need to be backported. - Update the uffd-unit-tests selftest to account for the new behavior (new patch). This patched selftest is equivalent to the reproducer I provided in v1. v1: https://lore.kernel.org/linux-mm/20260828005004.2870750-1-jthoughton@google.com/ --- mm/khugepaged.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mm/khugepaged.c b/mm/khugepaged.c index 75639298efc2..e6947fe142ee 100644 --- a/mm/khugepaged.c +++ b/mm/khugepaged.c @@ -1894,6 +1894,13 @@ static enum scan_result try_collapse_pte_mapped_thp(struct mm_struct *mm, unsign if (userfaultfd_protected(vma)) return SCAN_PTE_UFFD; + /* + * Userfaultfd-minor-registered VMAs should not be collapsed, as + * userspace is expecting to explicitly install PTEs. + */ + if (userfaultfd_minor(vma)) + return SCAN_PTE_UFFD; + folio = filemap_lock_folio(vma->vm_file->f_mapping, linear_page_index(vma, haddr)); if (IS_ERR(folio)) base-commit: 5acbae5f7eb3d5275120abfe698c394b7325dcec -- 2.55.0.1007.g17ff1f9808-goog The behavior of MADV_COLLAPSE with uffd-minor VMAs has changed: MADV_COLLAPSE will no longer install PTEs where none existed before. Update the selftest to demonstrate this new behavior. On an unpatched kernel, the test will hit "unexpected memory contents after collapse". If the selftest is left unpatched but the kernel is patched, the selftest will SKIP when it gets EINVAL back from MADV_COLLAPSE. Signed-off-by: James Houghton --- tools/testing/selftests/mm/uffd-unit-tests.c | 75 ++++++++++++++++++-- 1 file changed, 68 insertions(+), 7 deletions(-) diff --git a/tools/testing/selftests/mm/uffd-unit-tests.c b/tools/testing/selftests/mm/uffd-unit-tests.c index ef9b3956bdcf..6f2360f9b75d 100644 --- a/tools/testing/selftests/mm/uffd-unit-tests.c +++ b/tools/testing/selftests/mm/uffd-unit-tests.c @@ -518,19 +518,34 @@ static void uffd_wp_fork_pin_with_event_test(uffd_global_test_opts_t *gopts, uff uffd_wp_fork_pin_test_common(gopts, args, true); } -static void check_memory_contents(uffd_global_test_opts_t *gopts, char *p) +static int __check_memory_contents(unsigned long offset, + unsigned long nr_pages, + uffd_global_test_opts_t *gopts, + char *p) { unsigned long i, j; uint8_t expected_byte; - for (i = 0; i < gopts->nr_pages; ++i) { + if (nr_pages + offset < nr_pages) + err("overflow in memory check"); + if (nr_pages + offset > gopts->nr_pages) + err("out of bounds memory check"); + + for (i = offset; i < offset + nr_pages; ++i) { expected_byte = ~((uint8_t)(i % ((uint8_t)-1))); for (j = 0; j < gopts->page_size; j++) { uint8_t v = *(uint8_t *)(p + (i * gopts->page_size) + j); if (v != expected_byte) - err("unexpected page contents"); + return 1; } } + + return 0; +} + +static int check_memory_contents(uffd_global_test_opts_t *gopts, char *p) +{ + return __check_memory_contents(0, gopts->nr_pages, gopts, p); } static void uffd_minor_test_common(uffd_global_test_opts_t *gopts, bool test_collapse, bool test_wp) @@ -539,6 +554,8 @@ static void uffd_minor_test_common(uffd_global_test_opts_t *gopts, bool test_col pthread_t uffd_mon; char c = '\0'; struct uffd_args args = { 0 }; + unsigned long checked = 0; + bool bad_contents; args.gopts = gopts; /* @@ -564,24 +581,65 @@ static void uffd_minor_test_common(uffd_global_test_opts_t *gopts, bool test_col if (pthread_create(&uffd_mon, NULL, uffd_poll_thread, &args)) err("uffd_poll_thread create"); + if (test_collapse) { + /* + * Read just a single page and try collapsing. The collapse + * should either be rejected or be a no-op. + */ + if (__check_memory_contents(0, 1, gopts, gopts->area_dst_alias)) + err("unexpected memory contents before collapse"); + + /* MADV_COLLAPSE might return EINVAL for uffd-minor VMAs. */ + madvise(gopts->area_dst_alias, gopts->nr_pages * gopts->page_size, + MADV_COLLAPSE); + /* + * If the above collapse mapped pages that were not explicitly + * CONTINUE'd, the below __check_memory_contents() will not + * fault on some pages, resulting in incorrect contents. The + * PTE for the first page may get retracted, so avoid checking + * that page, as we might take a second fault, flipping the + * contents a second time. + */ + checked = 1; + } + /* * Read each of the pages back using the UFFD-registered mapping. We * expect that the first time we touch a page, it will result in a minor * fault. uffd_poll_thread will resolve the fault by bit-flipping the * page's contents, and then issuing a CONTINUE ioctl. */ - check_memory_contents(gopts, gopts->area_dst_alias); + bad_contents = !!__check_memory_contents(checked, gopts->nr_pages - checked, + gopts, gopts->area_dst_alias); if (write(gopts->pipefd[1], &c, sizeof(c)) != sizeof(c)) err("pipe write"); if (pthread_join(uffd_mon, NULL)) err("join() failed"); + if (bad_contents && test_collapse) { + uffd_test_fail("unexpected memory contents after collapse"); + return; + } + + if (bad_contents) { + uffd_test_fail("unexpected memory contents"); + return; + } + if (test_collapse) { + /* + * MADV_COLLAPSE will fail unless userfaultfd-minor is + * unregistered. + */ + if (uffd_unregister(gopts->uffd, gopts->area_dst_alias, + gopts->nr_pages * gopts->page_size)) + err("uffd_unregister before MADV_COLLAPSE failed"); + + /* MADV_COLLAPSE should succeed with userfaultfd unregistered. */ if (madvise(gopts->area_dst_alias, gopts->nr_pages * gopts->page_size, MADV_COLLAPSE)) { - /* It's fine to fail for this one... */ - uffd_test_skip("MADV_COLLAPSE failed"); + uffd_test_fail("MADV_COLLAPSE failed"); return; } @@ -593,7 +651,10 @@ static void uffd_minor_test_common(uffd_global_test_opts_t *gopts, bool test_col * This won't cause uffd-fault - it purely just makes sure there * was no corruption. */ - check_memory_contents(gopts, gopts->area_dst_alias); + if (check_memory_contents(gopts, gopts->area_dst_alias)) { + uffd_test_fail("unexpected memory contents"); + return; + } } if (args.missing_faults != 0 || args.minor_faults != gopts->nr_pages) -- 2.55.0.1007.g17ff1f9808-goog