selftests/mm: allow PUD-level entries in compound testcase of hmm tests

Patch series "selftests/mm: assorted fixes for hmm-tests", v3.

This series fixes a few issues in hmm-tests that show up when page-size
and huge-page configuration differ from the hardcoded assumptions the
tests were written for (PMD/THP sizing, default hugepage size, and related
cases).

It also includes a fix to exclusive_cow: the test ignored the return value
of fork(), so both parent and child ran the same teardown path.

This patch (of 3):

The HMM compound testcase currently assumes only PMD-level mappings and
fails on systems where default_hugepagesz=1G is set, because the region is
then reported by the device at PUD level.

Determine the mapping level (PMD or PUD) the device reports for the first
page of the range and require every page to match that level exactly via
ASSERT_EQ().  This accepts PUD-level mappings while preserving the
expected/observed protection values printed on failure, and rejects a
fragmented mapping that mixes PMD- and PUD-level entries within the same
range (which a per-page OR check would have let pass).

Link: https://lore.kernel.org/20260611034102.1030738-1-aboorvad@linux.ibm.com
Link: https://lore.kernel.org/20260611034102.1030738-2-aboorvad@linux.ibm.com
Fixes: e478425bec93 ("mm/hmm: add tests for hmm_pfn_to_map_order()")
Signed-off-by: Sayali Patil <sayalip@linux.ibm.com>
Co-developed-by: Aboorva Devarajan <aboorvad@linux.ibm.com>
Signed-off-by: Aboorva Devarajan <aboorvad@linux.ibm.com>
Cc: Alex Sierra <alex.sierra@amd.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Balbir Singh <balbirs@nvidia.com>
Cc: David Hildenbrand <david@kernel.org>
Cc: Jason Gunthorpe <jgg@ziepe.ca>
Cc: Leon Romanovsky <leon@kernel.org>
Cc: Liam R. Howlett <liam@infradead.org>
Cc: Lorenzo Stoakes <ljs@kernel.org>
Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/mm/hmm-tests.c b/tools/testing/selftests/mm/hmm-tests.c
index 46e0c8c921c3d37bc29afb757b4f3be94b549a1c..deb6a7485650f23120ff3fc3f03bc33e43265e1f 100644 (file)
--- a/tools/testing/selftests/mm/hmm-tests.c
+++ b/tools/testing/selftests/mm/hmm-tests.c
@@ -1602,8 +1602,8 @@ TEST_F(hmm2, snapshot)
 }
 
 /*
- * Test the hmm_range_fault() HMM_PFN_PMD flag for large pages that
- * should be mapped by a large page table entry.
+ * Test the hmm_range_fault() handling of large pages (PMD or PUD)
+ * that should be mapped by a large page table entry.
  */
 TEST_F(hmm, compound)
 {
@@ -1613,6 +1613,7 @@ TEST_F(hmm, compound)
        unsigned long default_hsize = default_huge_page_size();
        int *ptr;
        unsigned char *m;
+       unsigned char prot;
        int ret;
        unsigned long i;
 
@@ -1648,11 +1649,20 @@ TEST_F(hmm, compound)
        ASSERT_EQ(ret, 0);
        ASSERT_EQ(buffer->cpages, npages);
 
-       /* Check what the device saw. */
+       /*
+        * Check what the device saw.  The region is backed by a single huge
+        * page that the device reports either at PMD or at PUD level depending
+        * on the configured default hugepage size.  Determine that level from
+        * the first page and require every page in the range to match it
+        * exactly, so that a fragmented mapping mixing levels (or a missing
+        * large-page bit) is still caught and reported with its actual value.
+        */
        m = buffer->mirror;
+       prot = HMM_DMIRROR_PROT_WRITE |
+              ((m[0] & HMM_DMIRROR_PROT_PUD) ? HMM_DMIRROR_PROT_PUD :
+                                               HMM_DMIRROR_PROT_PMD);
        for (i = 0; i < npages; ++i)
-               ASSERT_EQ(m[i], HMM_DMIRROR_PROT_WRITE |
-                               HMM_DMIRROR_PROT_PMD);
+               ASSERT_EQ(m[i], prot);
 
        /* Make the region read-only. */
        ret = mprotect(buffer->ptr, size, PROT_READ);
@@ -1663,11 +1673,17 @@ TEST_F(hmm, compound)
        ASSERT_EQ(ret, 0);
        ASSERT_EQ(buffer->cpages, npages);
 
-       /* Check what the device saw. */
+       /*
+        * Check what the device saw after mprotect(PROT_READ).  Same
+        * approach as above: determine the mapping level from the first
+        * page and require every page to match it exactly.
+        */
        m = buffer->mirror;
+       prot = HMM_DMIRROR_PROT_READ |
+              ((m[0] & HMM_DMIRROR_PROT_PUD) ? HMM_DMIRROR_PROT_PUD :
+                                               HMM_DMIRROR_PROT_PMD);
        for (i = 0; i < npages; ++i)
-               ASSERT_EQ(m[i], HMM_DMIRROR_PROT_READ |
-                               HMM_DMIRROR_PROT_PMD);
+               ASSERT_EQ(m[i], prot);
 
        munmap(buffer->ptr, buffer->size);
        buffer->ptr = NULL;