selftests/mm: check after-split folio orders in split_huge_page_test

Instead of just checking the existence of PMD folios before and after folio
split tests, use check_folio_orders() to check after-split folio orders.

The split ranges in split_thp_in_pagecache_to_order_at() are changed to
[addr, addr + pagesize) for every pmd_pagesize. It prevents folios within
the range being split multiple times due to debugfs split function always
perform splits with a pagesize step for a given range.

The following tests are not changed:
1. split_pte_mapped_thp: the test already uses kpageflags to check;
2. split_file_backed_thp: no vaddr available.

Link: https://lkml.kernel.org/r/20250818184622.1521620-6-ziy@nvidia.com
Signed-off-by: Zi Yan <ziy@nvidia.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: David Hildenbrand <david@redhat.com>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Donet Tom <donettom@linux.ibm.com>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Cc: Mariano Pache <npache@redhat.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Ryan Roberts <ryan.roberts@arm.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: wang lian <lianux.mm@gmail.com>
Cc: Wei Yang <richard.weiyang@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/mm/split_huge_page_test.c b/tools/testing/selftests/mm/split_huge_page_test.c
index cd90e8ed8dd151d35eb38f39a0083aa46f34278f..10ae65ea032f612157a51e1eafbe6ac0855c505a 100644 (file)
--- a/tools/testing/selftests/mm/split_huge_page_test.c
+++ b/tools/testing/selftests/mm/split_huge_page_test.c
@@ -26,6 +26,7 @@ uint64_t pagesize;
 unsigned int pageshift;
 uint64_t pmd_pagesize;
 unsigned int pmd_order;
+int *expected_orders;
 
 #define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages"
 #define SMAP_PATH "/proc/self/smaps"
@@ -35,6 +36,11 @@ unsigned int pmd_order;
 #define PID_FMT_OFFSET "%d,0x%lx,0x%lx,%d,%d"
 #define PATH_FMT "%s,0x%lx,0x%lx,%d"
 
+const char *pagemap_proc = "/proc/self/pagemap";
+const char *kpageflags_proc = "/proc/kpageflags";
+int pagemap_fd;
+int kpageflags_fd;
+
 static bool is_backed_by_folio(char *vaddr, int order, int pagemap_fd,
                int kpageflags_fd)
 {
@@ -367,6 +373,13 @@ static void split_pmd_thp_to_order(int order)
                if (one_page[i] != (char)i)
                        ksft_exit_fail_msg("%ld byte corrupted\n", i);
 
+       memset(expected_orders, 0, sizeof(int) * (pmd_order + 1));
+       expected_orders[order] = 4 << (pmd_order - order);
+
+       if (check_after_split_folio_orders(one_page, len, pagemap_fd,
+                                          kpageflags_fd, expected_orders,
+                                          (pmd_order + 1)))
+               ksft_exit_fail_msg("Unexpected THP split\n");
 
        if (!check_huge_anon(one_page, 0, pmd_pagesize))
                ksft_exit_fail_msg("Still AnonHugePages not split\n");
@@ -381,22 +394,6 @@ static void split_pte_mapped_thp(void)
        size_t len = 4 * pmd_pagesize;
        uint64_t thp_size;
        size_t i;
-       const char *pagemap_template = "/proc/%d/pagemap";
-       const char *kpageflags_proc = "/proc/kpageflags";
-       char pagemap_proc[255];
-       int pagemap_fd;
-       int kpageflags_fd;
-
-       if (snprintf(pagemap_proc, 255, pagemap_template, getpid()) < 0)
-               ksft_exit_fail_msg("get pagemap proc error: %s\n", strerror(errno));
-
-       pagemap_fd = open(pagemap_proc, O_RDONLY);
-       if (pagemap_fd == -1)
-               ksft_exit_fail_msg("read pagemap: %s\n", strerror(errno));
-
-       kpageflags_fd = open(kpageflags_proc, O_RDONLY);
-       if (kpageflags_fd == -1)
-               ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
 
        one_page = mmap((void *)(1UL << 30), len, PROT_READ | PROT_WRITE,
                        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
@@ -454,8 +451,6 @@ static void split_pte_mapped_thp(void)
 
        ksft_test_result_pass("Split PTE-mapped huge pages successful\n");
        munmap(one_page, len);
-       close(pagemap_fd);
-       close(kpageflags_fd);
 }
 
 static void split_file_backed_thp(int order)
@@ -660,6 +655,7 @@ static void split_thp_in_pagecache_to_order_at(size_t fd_size,
                const char *fs_loc, int order, int offset)
 {
        int fd;
+       char *split_addr;
        char *addr;
        size_t i;
        char testfile[INPUT_MAX];
@@ -673,14 +669,33 @@ static void split_thp_in_pagecache_to_order_at(size_t fd_size,
        err = create_pagecache_thp_and_fd(testfile, fd_size, &fd, &addr);
        if (err)
                return;
+
        err = 0;
 
-       if (offset == -1)
-               write_debugfs(PID_FMT, getpid(), (uint64_t)addr,
-                             (uint64_t)addr + fd_size, order);
-       else
-               write_debugfs(PID_FMT_OFFSET, getpid(), (uint64_t)addr,
-                             (uint64_t)addr + fd_size, order, offset);
+       memset(expected_orders, 0, sizeof(int) * (pmd_order + 1));
+       /*
+        * use [split_addr, split_addr + pagesize) range to split THPs, since
+        * the debugfs function always split a range with pagesize step and
+        * providing a full [addr, addr + fd_size) range can trigger multiple
+        * splits, complicating after-split result checking.
+        */
+       if (offset == -1) {
+               for (split_addr = addr; split_addr < addr + fd_size; split_addr += pmd_pagesize)
+                       write_debugfs(PID_FMT, getpid(), (uint64_t)split_addr,
+                                     (uint64_t)split_addr + pagesize, order);
+
+               expected_orders[order] = fd_size / (pagesize << order);
+       } else {
+               int times = fd_size / pmd_pagesize;
+
+               for (split_addr = addr; split_addr < addr + fd_size; split_addr += pmd_pagesize)
+                       write_debugfs(PID_FMT_OFFSET, getpid(), (uint64_t)split_addr,
+                                     (uint64_t)split_addr + pagesize, order, offset);
+
+               for (i = order + 1; i < pmd_order; i++)
+                       expected_orders[i] = times;
+               expected_orders[order] = 2 * times;
+       }
 
        for (i = 0; i < fd_size; i++)
                if (*(addr + i) != (char)i) {
@@ -689,6 +704,14 @@ static void split_thp_in_pagecache_to_order_at(size_t fd_size,
                        goto out;
                }
 
+       if (check_after_split_folio_orders(addr, fd_size, pagemap_fd,
+                                          kpageflags_fd, expected_orders,
+                                          (pmd_order + 1))) {
+               ksft_print_msg("Unexpected THP split\n");
+               err = 1;
+               goto out;
+       }
+
        if (!check_huge_file(addr, 0, pmd_pagesize)) {
                ksft_print_msg("Still FilePmdMapped not split\n");
                err = EXIT_FAILURE;
@@ -740,9 +763,22 @@ int main(int argc, char **argv)
 
        nr_pages = pmd_pagesize / pagesize;
        pmd_order = sz2ord(pmd_pagesize, pagesize);
+
+       expected_orders = (int *)malloc(sizeof(int) * (pmd_order + 1));
+       if (!expected_orders)
+               ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno));
+
        tests = 2 + (pmd_order - 1) + (2 * pmd_order) + (pmd_order - 1) * 4 + 2;
        ksft_set_plan(tests);
 
+       pagemap_fd = open(pagemap_proc, O_RDONLY);
+       if (pagemap_fd == -1)
+               ksft_exit_fail_msg("read pagemap: %s\n", strerror(errno));
+
+       kpageflags_fd = open(kpageflags_proc, O_RDONLY);
+       if (kpageflags_fd == -1)
+               ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
+
        fd_size = 2 * pmd_pagesize;
 
        split_pmd_zero_pages();
@@ -767,6 +803,10 @@ int main(int argc, char **argv)
                        split_thp_in_pagecache_to_order_at(fd_size, fs_loc, i, offset);
        cleanup_thp_fs(fs_loc, created_tmp);
 
+       close(pagemap_fd);
+       close(kpageflags_fd);
+       free(expected_orders);
+
        ksft_finished();
 
        return 0;