Re: [PATCH 3/4] selftests/mm: add check_folio_orders() helper.

On 2025/8/6 10:20, Zi Yan wrote:

The helper gathers an folio order statistics of folios within a virtual address range and checks it against a given order list. It aims to provide a more precise folio order check instead of just checking the existence of PMD folios.

Signed-off-by: Zi Yan ziy@nvidia.com

tools/testing/selftests/mm/vm_util.c | 139 +++++++++++++++++++++++++++ tools/testing/selftests/mm/vm_util.h | 2 + 2 files changed, 141 insertions(+)

diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c index 9dafa7669ef9..373621145b2a 100644 --- a/tools/testing/selftests/mm/vm_util.c +++ b/tools/testing/selftests/mm/vm_util.c @@ -17,6 +17,12 @@ #define STATUS_FILE_PATH "/proc/self/status" #define MAX_LINE_LENGTH 500 +#define PGMAP_PRESENT (1UL << 63) +#define KPF_COMPOUND_HEAD (1UL << 15) +#define KPF_COMPOUND_TAIL (1UL << 16) +#define KPF_THP (1UL << 22) +#define PFN_MASK ((1UL<<55)-1)

• unsigned int __page_size; unsigned int __page_shift;

@@ -338,6 +344,139 @@ int detect_hugetlb_page_sizes(size_t sizes[], int max) return count; } +static int get_page_flags(uint64_t vpn, int pagemap_file, int kpageflags_file,

• 	  uint64_t *flags)
  

+{

• uint64_t pfn;
• size_t count;
• count = pread(pagemap_file, &pfn, sizeof(pfn),

•       vpn * sizeof(pfn));
  

• if (count != sizeof(pfn))

• return -1;
  

• /*

• * Treat non-present page as a page without any flag, so that
  

• * gather_folio_orders() just record the current folio order.
  

• */
  

• if (!(pfn & PGMAP_PRESENT)) {

• *flags = 0;
  

• return 0;
  

• }

It looks like you can reuse the helper pagemap_get_pfn() in this file?

• count = pread(kpageflags_file, flags, sizeof(*flags),

•       (pfn & PFN_MASK) * sizeof(*flags));
  

• if (count != sizeof(*flags))

• return -1;
  

• return 0;

+}

+static int gather_folio_orders(uint64_t vpn_start, size_t nr_pages,

In this file, other helper functions use userspace virtual address as parameters, so can we consistently use virtual address for calculations instead of the 'vpn_start'?

• 	       int pagemap_file, int kpageflags_file,
  

• 	       int orders[], int nr_orders)
  

+{

• uint64_t page_flags = 0;
• int cur_order = -1;
• uint64_t vpn;
• if (!pagemap_file || !kpageflags_file)

• return -1;
  

• if (nr_orders <= 0)

• return -1;
  

• for (vpn = vpn_start; vpn < vpn_start + nr_pages; ) {

• uint64_t next_folio_vpn;
  

• int status;
  

• if (get_page_flags(vpn, pagemap_file, kpageflags_file, &page_flags))
  

• 	return -1;
  

• /* all order-0 pages with possible false postive (non folio) */
  

• if (!(page_flags & (KPF_COMPOUND_HEAD | KPF_COMPOUND_TAIL))) {
  

• 	orders[0]++;
  

• 	vpn++;
  

• 	continue;
  

• }
  

• /* skip non thp compound pages */
  

• if (!(page_flags & KPF_THP)) {
  

• 	vpn++;
  

• 	continue;
  

• }
  

• /* vpn points to part of a THP at this point */
  

• if (page_flags & KPF_COMPOUND_HEAD)
  

• 	cur_order = 1;
  

• else {
  

• 	/* not a head nor a tail in a THP? */
  

• 	if (!(page_flags & KPF_COMPOUND_TAIL))
  

• 		return -1;
  

• 	continue;
  

• }
  

• next_folio_vpn = vpn + (1 << cur_order);
  

• if (next_folio_vpn >= vpn_start + nr_pages)
  

• 	break;
  

• while (!(status = get_page_flags(next_folio_vpn, pagemap_file,
  

• 				 kpageflags_file,
  

• 				 &page_flags))) {
  

• 	/* next compound head page or order-0 page */
  

• 	if ((page_flags & KPF_COMPOUND_HEAD) ||
  

• 	    !(page_flags & (KPF_COMPOUND_HEAD |
  

• 	      KPF_COMPOUND_TAIL))) {
  

• 		if (cur_order < nr_orders) {
  

• 			orders[cur_order]++;
  

• 			cur_order = -1;
  

• 			vpn = next_folio_vpn;
  

• 		}
  

• 		break;
  

• 	}
  

• 	/* not a head nor a tail in a THP? */
  

• 	if (!(page_flags & KPF_COMPOUND_TAIL))
  

• 		return -1;
  

• 	cur_order++;
  

• 	next_folio_vpn = vpn + (1 << cur_order);
  

• }
  

• if (status)
  

• 	return status;
  

• }
• if (cur_order > 0 && cur_order < nr_orders)

• orders[cur_order]++;
  

• return 0;

+}

+int check_folio_orders(uint64_t vpn_start, size_t nr_pages, int pagemap_file,

• 	int kpageflags_file, int orders[], int nr_orders)
  

+{

• int vpn_orders[nr_orders];

IIRC, we should avoid using VLA (variable length arrays)?

• int status;
• int i;
• memset(vpn_orders, 0, sizeof(int) * nr_orders);
• status = gather_folio_orders(vpn_start, nr_pages, pagemap_file,

• 		     kpageflags_file, vpn_orders, nr_orders);
  

• if (status)

• return status;
  

• status = 0;
• for (i = 0; i < nr_orders; i++)

• if (vpn_orders[i] != orders[i]) {
  

• 	ksft_print_msg("order %d: expected: %d got %d\n", i,
  

• 		       orders[i], vpn_orders[i]);
  

• 	status = -1;
  

• }
  

• return status;

+}

• /* 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 b55d1809debc..dee9504a6129 100644 --- a/tools/testing/selftests/mm/vm_util.h +++ b/tools/testing/selftests/mm/vm_util.h @@ -85,6 +85,8 @@ 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 check_folio_orders(uint64_t vpn_start, size_t nr_pages, int pagemap_file,

• 	int kpageflags_file, int orders[], int nr_orders);
  

int uffd_register(int uffd, void *addr, uint64_t len, bool miss, bool wp, bool minor);