selftests/mm: reimplement is_backed_by_thp() with more precise check

and rename it to is_backed_by_folio().

is_backed_by_folio() checks if the given vaddr is backed a folio with
a given order. It does so by:
1. getting the pfn of the vaddr;
2. checking kpageflags of the pfn;

if order is greater than 0:
3. checking kpageflags of the head pfn;
4. checking kpageflags of all tail pfns.

pmd_order is added to split_huge_page_test.c and replaces max_order.

Link: https://lkml.kernel.org/r/20250818184622.1521620-4-ziy@nvidia.com
Signed-off-by: Zi Yan <ziy@nvidia.com>
Reviewed-by: Wei Yang <richard.weiyang@gmail.com>
Reviewed-by: wang lian <lianux.mm@gmail.com>
Acked-by: David Hildenbrand <david@redhat.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
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>
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 001a6ff24bf72b79e22d882cd3cd0f5c6ebf2a5d..432cf434ca961c085adb60ee2d3bd24cdcb3df8f 100644 (file)
--- a/tools/testing/selftests/mm/split_huge_page_test.c
+++ b/tools/testing/selftests/mm/split_huge_page_test.c
@@ -25,6 +25,7 @@
 uint64_t pagesize;
 unsigned int pageshift;
 uint64_t pmd_pagesize;
+unsigned int pmd_order;
 
 #define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages"
 #define SMAP_PATH "/proc/self/smaps"
@@ -34,26 +35,66 @@ uint64_t pmd_pagesize;
 #define PID_FMT_OFFSET "%d,0x%lx,0x%lx,%d,%d"
 #define PATH_FMT "%s,0x%lx,0x%lx,%d"
 
-#define PFN_MASK     ((1UL<<55)-1)
-#define KPF_THP      (1UL<<22)
-
-static int is_backed_by_thp(char *vaddr, int pagemap_file, int kpageflags_file)
+static bool is_backed_by_folio(char *vaddr, int order, int pagemap_fd,
+               int kpageflags_fd)
 {
-       uint64_t paddr;
-       uint64_t page_flags;
+       unsigned long pfn_head;
+       uint64_t pfn_flags;
+       unsigned long pfn;
+       unsigned long i;
 
-       if (pagemap_file) {
-               pread(pagemap_file, &paddr, sizeof(paddr),
-                       ((long)vaddr >> pageshift) * sizeof(paddr));
+       pfn = pagemap_get_pfn(pagemap_fd, vaddr);
 
-               if (kpageflags_file) {
-                       pread(kpageflags_file, &page_flags, sizeof(page_flags),
-                               (paddr & PFN_MASK) * sizeof(page_flags));
+       /* non present page */
+       if (pfn == -1UL)
+               return false;
 
-                       return !!(page_flags & KPF_THP);
-               }
+       if (pageflags_get(pfn, kpageflags_fd, &pfn_flags))
+               goto fail;
+
+       /* check for order-0 pages */
+       if (!order) {
+               if (pfn_flags & (KPF_THP | KPF_COMPOUND_HEAD | KPF_COMPOUND_TAIL))
+                       return false;
+               return true;
        }
-       return 0;
+
+       /* non THP folio */
+       if (!(pfn_flags & KPF_THP))
+               return false;
+
+       pfn_head = pfn & ~((1 << order) - 1);
+
+       if (pageflags_get(pfn_head, kpageflags_fd, &pfn_flags))
+               goto fail;
+
+       /* head PFN has no compound_head flag set */
+       if (!(pfn_flags & (KPF_THP | KPF_COMPOUND_HEAD)))
+               return false;
+
+       /* check all tail PFN flags */
+       for (i = 1; i < 1UL << order; i++) {
+               if (pageflags_get(pfn_head + i, kpageflags_fd, &pfn_flags))
+                       goto fail;
+               if (!(pfn_flags & (KPF_THP | KPF_COMPOUND_TAIL)))
+                       return false;
+       }
+
+       /*
+        * check the PFN after this folio, but if its flags cannot be obtained,
+        * assume this folio has the expected order
+        */
+       if (pageflags_get(pfn_head + (1UL << order), kpageflags_fd, &pfn_flags))
+               return true;
+
+       /* this folio is bigger than the given order */
+       if (pfn_flags & (KPF_THP | KPF_COMPOUND_TAIL))
+               return false;
+
+       return true;
+fail:
+       ksft_exit_fail_msg("Failed to get folio info\n");
+       return false;
 }
 
 static void write_file(const char *path, const char *buf, size_t buflen)
@@ -234,7 +275,7 @@ static void split_pte_mapped_thp(void)
        thp_size = 0;
        for (i = 0; i < pagesize * 4; i++)
                if (i % pagesize == 0 &&
-                   is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
+                   is_backed_by_folio(&pte_mapped[i], pmd_order, pagemap_fd, kpageflags_fd))
                        thp_size++;
 
        if (thp_size != 4)
@@ -251,7 +292,7 @@ static void split_pte_mapped_thp(void)
                        ksft_exit_fail_msg("%ld byte corrupted\n", i);
 
                if (i % pagesize == 0 &&
-                   is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
+                   !is_backed_by_folio(&pte_mapped[i], 0, pagemap_fd, kpageflags_fd))
                        thp_size++;
        }
 
@@ -525,7 +566,6 @@ int main(int argc, char **argv)
        const char *fs_loc;
        bool created_tmp;
        int offset;
-       unsigned int max_order;
        unsigned int nr_pages;
        unsigned int tests;
 
@@ -546,28 +586,28 @@ int main(int argc, char **argv)
                ksft_exit_fail_msg("Reading PMD pagesize failed\n");
 
        nr_pages = pmd_pagesize / pagesize;
-       max_order =  sz2ord(pmd_pagesize, pagesize);
-       tests = 2 + (max_order - 1) + (2 * max_order) + (max_order - 1) * 4 + 2;
+       pmd_order = sz2ord(pmd_pagesize, pagesize);
+       tests = 2 + (pmd_order - 1) + (2 * pmd_order) + (pmd_order - 1) * 4 + 2;
        ksft_set_plan(tests);
 
        fd_size = 2 * pmd_pagesize;
 
        split_pmd_zero_pages();
 
-       for (i = 0; i < max_order; i++)
+       for (i = 0; i < pmd_order; i++)
                if (i != 1)
                        split_pmd_thp_to_order(i);
 
        split_pte_mapped_thp();
-       for (i = 0; i < max_order; i++)
+       for (i = 0; i < pmd_order; i++)
                split_file_backed_thp(i);
 
        created_tmp = prepare_thp_fs(optional_xfs_path, fs_loc_template,
                        &fs_loc);
-       for (i = max_order - 1; i >= 0; i--)
+       for (i = pmd_order - 1; i >= 0; i--)
                split_thp_in_pagecache_to_order_at(fd_size, fs_loc, i, -1);
 
-       for (i = 0; i < max_order; i++)
+       for (i = 0; i < pmd_order; i++)
                for (offset = 0;
                     offset < nr_pages;
                     offset += MAX(nr_pages / 4, 1 << i))

diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c
index 6a239aa413e23b1f888520494c2cd628f7ad7996..741fc129313dcc52521056b6ec3b15a647b5b669 100644 (file)
--- a/tools/testing/selftests/mm/vm_util.c
+++ b/tools/testing/selftests/mm/vm_util.c
@@ -338,6 +338,19 @@ int detect_hugetlb_page_sizes(size_t sizes[], int max)
        return count;
 }
 
+int pageflags_get(unsigned long pfn, int kpageflags_fd, uint64_t *flags)
+{
+       size_t count;
+
+       count = pread(kpageflags_fd, flags, sizeof(*flags),
+                     pfn * sizeof(*flags));
+
+       if (count != sizeof(*flags))
+               return -1;
+
+       return 0;
+}
+
 /* If `ioctls' non-NULL, the allowed ioctls will be returned into the var */
 int uffd_register_with_ioctls(int uffd, void *addr, uint64_t len,
                              bool miss, bool wp, bool minor, uint64_t *ioctls)

diff --git a/tools/testing/selftests/mm/vm_util.h b/tools/testing/selftests/mm/vm_util.h
index 3da56feeb9442a8b1c4437cea83f635e7f30fbb8..ab8722f482aedb11156a69e16b66611474079809 100644 (file)
--- a/tools/testing/selftests/mm/vm_util.h
+++ b/tools/testing/selftests/mm/vm_util.h
@@ -18,6 +18,9 @@
 #define PM_SWAP                       BIT_ULL(62)
 #define PM_PRESENT                    BIT_ULL(63)
 
+#define KPF_COMPOUND_HEAD             BIT_ULL(15)
+#define KPF_COMPOUND_TAIL             BIT_ULL(16)
+#define KPF_THP                       BIT_ULL(22)
 /*
  * Ignore the checkpatch warning, we must read from x but don't want to do
  * anything with it in order to trigger a read page fault. We therefore must use
@@ -85,6 +88,7 @@ bool check_huge_shmem(void *addr, int nr_hpages, uint64_t hpage_size);
 int64_t allocate_transhuge(void *ptr, int pagemap_fd);
 unsigned long default_huge_page_size(void);
 int detect_hugetlb_page_sizes(size_t sizes[], int max);
+int pageflags_get(unsigned long pfn, int kpageflags_fd, uint64_t *flags);
 
 int uffd_register(int uffd, void *addr, uint64_t len,
                  bool miss, bool wp, bool minor);