[PATCH v3 0/2] kselftest: mm: fix some failure of split_huge_page_test

[PATCH v3 0/2] kselftest: mm: fix some failure of split_huge_page_test

[Yeoreum Yun]

split_huge_page_test can fail for the following reasons:

  1. During the test, khugepaged may collapse previously split pages again,
     causing intermittent failures.

  2. Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
     glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
     made by memalign(). The underlying VMA may start at a different address
     from the aligned address returned by memalign(). Moreover, a subsequent
     madvise(MADV_HUGEPAGE) call does not split the VMA because it already
     has the same advice.

     This causes the test to fail because the check_huge_xxx() helpers
     incorrectly require the address returned by memalign() to match the
     VMA start address reported in /proc/self/smaps.

Address these issues by applying MADV_NOHUGEPAGE after faulting in the
huge page, preventing khugepaged from collapsing it again, and by replacing
the use of /proc/self/smaps in the check_huge_xxx() helpers with
/proc/self/pagemap and /proc/kpageflags.

This patch based on mm-unstable

---
Changes in v3:
  - change  message in case of failure of madvise() with MADV_NOHUGEPAGE.
  - fix collapse_single_mthp (mthp_khugepaged:anon) test case failure.
  - Link to v2: https://lore.kernel.org/all/20260826-fix_split-v2-0-71153c7f579a@arm.com/

Changes in v2:
  - rebase to mm-unstable.
  - add message in case of failure of madvise() with MADV_NOHUGEPAGE.
  - fix wrong setup expected_huge in check_huge_shmem().
  - Link to v1: https://lore.kernel.org/r/20260820-fix_split-v1-0-ab430c58c7cf@arm.com

---
Yeoreum Yun (2):
      kselftest: mm: prevent random failure of huge page split for khugepaged
      kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

 tools/testing/selftests/mm/split_huge_page_test.c |  15 +++
 tools/testing/selftests/mm/vm_util.c              | 145 ++++++++++++++--------
 tools/testing/selftests/mm/vm_util.h              |   1 +
 3 files changed, 107 insertions(+), 54 deletions(-)
---
base-commit: 234e77148199ae43b83a0a03a3f481e03460a286
change-id: 20260820-fix_split-f44939ec44b8

Best regards,
-- 
Sincerely,
Yeoreum Yun

[PATCH v3 1/2] kselftest: mm: prevent random failure of huge page split for khugepaged

[Yeoreum Yun]

There're some random failure for split_huge_page_test when khugepaged
collapses pages into pmd again which had split by the test.

Prevent the khugepaged's collapses for split page by setting the
mapped pmd-huge-page with MADV_NOHUGEPAGE before split.

Reported-by: Kevin Brodsky <kevin.brodsky@arm.com>
Reviewed-by: Zi Yan <ziy@nvidia.com>
Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
---
 tools/testing/selftests/mm/split_huge_page_test.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tools/testing/selftests/mm/split_huge_page_test.c b/tools/testing/selftests/mm/split_huge_page_test.c
index 86a603692826..c718269a291f 100644
--- a/tools/testing/selftests/mm/split_huge_page_test.c
+++ b/tools/testing/selftests/mm/split_huge_page_test.c
@@ -180,6 +180,10 @@ static void verify_rss_anon_split_huge_page_all_zeroes(char *one_page, int nr_hp
 	if (!rss_anon_before)
 		ksft_exit_fail_msg("No RssAnon is allocated before split\n");
 
+	/* Prevent khugepaged from collapsing the pages. */
+	if (madvise(one_page, len, MADV_NOHUGEPAGE))
+		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
+
 	/* split all THPs */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
 		      (uint64_t)one_page + len, 0);
@@ -227,6 +231,10 @@ static void split_pmd_thp_to_order(int order)
 	if (!check_huge_anon(one_page, 4 * pmd_pagesize, 4, pmd_pagesize))
 		ksft_exit_fail_msg("No THP is allocated\n");
 
+	/* Prevent khugepaged from collapsing the pages. */
+	if (madvise(one_page, len, MADV_NOHUGEPAGE))
+		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
+
 	/* split all THPs */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
 		(uint64_t)one_page + len, order);
@@ -313,6 +321,10 @@ static void split_pte_mapped_thp(void)
 		goto out;
 	}
 
+	/* Prevent khugepaged from collapsing the pages. */
+	if (madvise(thp_area, thp_area_size, MADV_NOHUGEPAGE))
+		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
+
 	/* Split all THPs through the remapped pages. */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)page_area,
 		      (uint64_t)page_area + page_area_size, 0);
@@ -542,6 +554,9 @@ static int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size,
 		ksft_test_result_skip("Pagecache folio split skipped\n");
 		return -2;
 	}
+	/* Prevent khugepaged from collapsing the pages. */
+	if (madvise(*addr, fd_size, MADV_NOHUGEPAGE))
+		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
 	return 0;
 err_out_close:
 	close(*fd);

-- 
2.43.0

[PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Yeoreum Yun]

Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
made by memalign().

The underlying VMA may start at a different address from the aligned
address returned by memalign(). Furthermore, a subsequent
madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
already set.

This causes split_huge_page_test to fail because the check_huge_xxx()
helpers incorrectly require the address returned by memalign() to
match the VMA start address reported in /proc/self/smaps.

Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
/proc/self/smaps to detect huge pages.

Reported-by: David Hildenbrand (Arm) <david@kernel.org>
Suggested-by: Zi Yan <ziy@nvidia.com>
Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
---
 tools/testing/selftests/mm/vm_util.c | 145 ++++++++++++++++++++++-------------
 tools/testing/selftests/mm/vm_util.h |   1 +
 2 files changed, 92 insertions(+), 54 deletions(-)

diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c
index 4821a3563036..083b72d92b14 100644
--- a/tools/testing/selftests/mm/vm_util.c
+++ b/tools/testing/selftests/mm/vm_util.c
@@ -351,31 +351,13 @@ char *__get_smap_entry(void *addr, const char *pattern, char *buf, size_t len)
 	return entry;
 }
 
-static bool __check_pmd_huge(void *addr, char *pattern, int nr_hpages,
-		  uint64_t hpage_size)
-{
-	char buffer[MAX_LINE_LENGTH];
-	uint64_t thp = -1;
-	char *entry;
-
-	entry = __get_smap_entry(addr, pattern, buffer, sizeof(buffer));
-	if (!entry)
-		goto err_out;
-
-	if (sscanf(entry, "%9" SCNu64 " kB", &thp) != 1)
-		ksft_exit_fail_msg("Reading smap error\n");
-
-err_out:
-	return thp == (nr_hpages * (hpage_size >> 10));
-}
-
-static bool check_large_folios(void *addr, size_t len, int nr_hpages,
-		uint64_t hpage_size)
+static bool check_large_folios(int pagemap_fd, int kpageflags_fd,
+			       void *addr, size_t len, int nr_hpages,
+			       uint64_t hpage_size)
 {
 	int order = 0, pagesize = getpagesize();
 	unsigned int nr_pages = hpage_size / pagesize;
 	int orders[MAX_NR_ORDERS], status;
-	int pagemap_fd, kpageflags_fd;
 	bool ret = false;
 
 	if (!nr_pages)
@@ -386,15 +368,6 @@ static bool check_large_folios(void *addr, size_t len, int nr_hpages,
 		ksft_exit_fail_msg("invalid order\n");
 
 	memset(orders, 0, sizeof(int) * MAX_NR_ORDERS);
-	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
-	if (pagemap_fd == -1)
-		ksft_exit_fail_msg("read pagemap fail\n");
-
-	kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
-	if (kpageflags_fd == -1) {
-		close(pagemap_fd);
-		ksft_exit_fail_msg("read kpageflags fail\n");
-	}
 
 	status = gather_folio_orders(addr, len, pagemap_fd,
 			kpageflags_fd, orders, MAX_NR_ORDERS);
@@ -405,48 +378,112 @@ static bool check_large_folios(void *addr, size_t len, int nr_hpages,
 		ret = true;
 
 out:
-	close(pagemap_fd);
-	close(kpageflags_fd);
 	return ret;
 }
 
-bool check_huge_anon(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
-{
-	uint64_t pmd_pagesize = read_pmd_pagesize();
-
-	if (!pmd_pagesize)
-		ksft_exit_fail_msg("reading PMD pagesize failed\n");
+enum check_huge_type {
+	CHECK_HUGE_ANON,
+	CHECK_HUGE_FILE,
+	CHECK_HUGE_SHMEM,
+};
 
-	if (hpage_size == pmd_pagesize)
-		return __check_pmd_huge(addr, "AnonHugePages: ", nr_hpages, hpage_size);
+static bool check_huge_type(uint64_t categories, uint64_t kpageflags,
+			    enum check_huge_type type)
+{
+	bool file = categories & PAGE_IS_FILE;
+	bool swapbacked = kpageflags & KPF_SWAPBACKED;
+
+	switch (type) {
+	case CHECK_HUGE_ANON:
+		return !file;
+	case CHECK_HUGE_FILE:
+		return file && !swapbacked;
+	case CHECK_HUGE_SHMEM:
+		return file & swapbacked;
+	}
 
-	return check_large_folios(addr, len, nr_hpages, hpage_size);
+	return false;
 }
 
-bool check_huge_file(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
+static bool __check_huge(void *addr, size_t len, int nr_hpages,
+			 uint64_t hpage_size, enum check_huge_type type)
 {
-	uint64_t pmd_pagesize = read_pmd_pagesize();
+	bool ret = false;
+	int pagemap_fd, kpageflags_fd;
+	int nr_pmd_mappings = 0;
+	uint64_t pmd_pagesize, scan_mapping_size;
+	uint64_t categories, kpf;
+	unsigned long pfn;
+	bool check_pmd_mapping, allow_nonpresent;
+	char *start = addr;
+	char *end = start + len;
 
+	pmd_pagesize = read_pmd_pagesize();
 	if (!pmd_pagesize)
 		ksft_exit_fail_msg("reading PMD pagesize failed\n");
 
-	if (hpage_size == pmd_pagesize)
-		return __check_pmd_huge(addr, "FilePmdMapped:", nr_hpages, hpage_size);
+	check_pmd_mapping = (hpage_size == pmd_pagesize);
+	scan_mapping_size = (nr_hpages > 0) ? hpage_size : psize();
+	/* Some mTHP tests check a partially populated PMD-sized range. */
+	allow_nonpresent = (uint64_t)nr_hpages * hpage_size < len;
 
-	return check_large_folios(addr, len, nr_hpages, hpage_size);
+	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
+	if (pagemap_fd < 0)
+		ksft_exit_fail_msg("open pagemap fail\n");
+
+	kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
+	if (kpageflags_fd < 0) {
+		close(pagemap_fd);
+		ksft_exit_fail_msg("open kpageflags fail\n");
+	}
+
+	if (!check_pmd_mapping &&
+	    !check_large_folios(pagemap_fd, kpageflags_fd,
+				addr, len, nr_hpages, hpage_size))
+		goto out;
+
+	for (; start < end; start += scan_mapping_size) {
+		categories = pagemap_scan_get_categories(pagemap_fd, start);
+		pfn = pagemap_get_pfn(pagemap_fd, start);
+		if (pfn == -1UL) {
+			if (!allow_nonpresent)
+				goto out;
+			else
+				continue;
+		}
+		if (pageflags_get(pfn, kpageflags_fd, &kpf))
+			ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
+		if (check_pmd_mapping && (categories & PAGE_IS_HUGE))
+			nr_pmd_mappings++;
+		if (kpf & KPF_COMPOUND_TAIL)
+			continue;
+		if (!check_huge_type(categories, kpf, type))
+			goto out;
+	}
+	
+	if (check_pmd_mapping && (nr_pmd_mappings != nr_hpages))
+		goto out;
+	ret = true;
+
+out:
+	close(pagemap_fd);
+	close(kpageflags_fd);
+	return ret;
 }
 
-bool check_huge_shmem(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
+bool check_huge_anon(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
 {
-	uint64_t pmd_pagesize = read_pmd_pagesize();
-
-	if (!pmd_pagesize)
-		ksft_exit_fail_msg("reading PMD pagesize failed\n");
+	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_ANON);
+}
 
-	if (hpage_size == pmd_pagesize)
-		return __check_pmd_huge(addr, "ShmemPmdMapped:", nr_hpages, hpage_size);
+bool check_huge_file(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
+{
+	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_FILE);
+}
 
-	return check_large_folios(addr, len, nr_hpages, hpage_size);
+bool check_huge_shmem(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
+{
+	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_SHMEM);
 }
 
 int64_t allocate_transhuge(void *ptr, int pagemap_fd)
diff --git a/tools/testing/selftests/mm/vm_util.h b/tools/testing/selftests/mm/vm_util.h
index 9a49af88702e..f19bd17817e5 100644
--- a/tools/testing/selftests/mm/vm_util.h
+++ b/tools/testing/selftests/mm/vm_util.h
@@ -18,6 +18,7 @@
 #define PM_SWAP                       BIT_ULL(62)
 #define PM_PRESENT                    BIT_ULL(63)
 
+#define KPF_SWAPBACKED                BIT_ULL(14)
 #define KPF_COMPOUND_HEAD             BIT_ULL(15)
 #define KPF_COMPOUND_TAIL             BIT_ULL(16)
 #define KPF_HWPOISON                  BIT_ULL(19)

-- 
2.43.0

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Lorenzo Stoakes (ARM)]

On Fri, Aug 28, 2026 at 09:11:34AM +0100, Yeoreum Yun wrote:
> Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> made by memalign().
>
> The underlying VMA may start at a different address from the aligned
> address returned by memalign(). Furthermore, a subsequent
> madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> already set.
>
> This causes split_huge_page_test to fail because the check_huge_xxx()
> helpers incorrectly require the address returned by memalign() to
> match the VMA start address reported in /proc/self/smaps.

Hmm, is the test correctly putting sentinels either side of the VMA? Any test
that doesn't risks flaking due to unwanted VMA merges.

>
> Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> /proc/self/smaps to detect huge pages.

You should probably call out the fact you're doing some refactoring here
also!

>
> Reported-by: David Hildenbrand (Arm) <david@kernel.org>

Should always have a Closes: tag if Reported-by: ideally.

> Suggested-by: Zi Yan <ziy@nvidia.com>
> Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>

Generally looks reasonable to me, some nits above and below though :)

Acked-by: Lorenzo Stoakes (ARM) <ljs@kernel.org>

> ---
>  tools/testing/selftests/mm/vm_util.c | 145 ++++++++++++++++++++++-------------
>  tools/testing/selftests/mm/vm_util.h |   1 +
>  2 files changed, 92 insertions(+), 54 deletions(-)
>
> diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c
> index 4821a3563036..083b72d92b14 100644
> --- a/tools/testing/selftests/mm/vm_util.c
> +++ b/tools/testing/selftests/mm/vm_util.c
> @@ -351,31 +351,13 @@ char *__get_smap_entry(void *addr, const char *pattern, char *buf, size_t len)
>  	return entry;
>  }
>
> -static bool __check_pmd_huge(void *addr, char *pattern, int nr_hpages,
> -		  uint64_t hpage_size)
> -{
> -	char buffer[MAX_LINE_LENGTH];
> -	uint64_t thp = -1;
> -	char *entry;
> -
> -	entry = __get_smap_entry(addr, pattern, buffer, sizeof(buffer));
> -	if (!entry)
> -		goto err_out;
> -
> -	if (sscanf(entry, "%9" SCNu64 " kB", &thp) != 1)
> -		ksft_exit_fail_msg("Reading smap error\n");
> -
> -err_out:
> -	return thp == (nr_hpages * (hpage_size >> 10));
> -}
> -
> -static bool check_large_folios(void *addr, size_t len, int nr_hpages,
> -		uint64_t hpage_size)
> +static bool check_large_folios(int pagemap_fd, int kpageflags_fd,
> +			       void *addr, size_t len, int nr_hpages,
> +			       uint64_t hpage_size)
>  {
>  	int order = 0, pagesize = getpagesize();
>  	unsigned int nr_pages = hpage_size / pagesize;
>  	int orders[MAX_NR_ORDERS], status;
> -	int pagemap_fd, kpageflags_fd;
>  	bool ret = false;
>
>  	if (!nr_pages)
> @@ -386,15 +368,6 @@ static bool check_large_folios(void *addr, size_t len, int nr_hpages,
>  		ksft_exit_fail_msg("invalid order\n");
>
>  	memset(orders, 0, sizeof(int) * MAX_NR_ORDERS);
> -	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
> -	if (pagemap_fd == -1)
> -		ksft_exit_fail_msg("read pagemap fail\n");
> -
> -	kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
> -	if (kpageflags_fd == -1) {
> -		close(pagemap_fd);
> -		ksft_exit_fail_msg("read kpageflags fail\n");
> -	}
>
>  	status = gather_folio_orders(addr, len, pagemap_fd,
>  			kpageflags_fd, orders, MAX_NR_ORDERS);
> @@ -405,48 +378,112 @@ static bool check_large_folios(void *addr, size_t len, int nr_hpages,
>  		ret = true;
>
>  out:
> -	close(pagemap_fd);
> -	close(kpageflags_fd);
>  	return ret;
>  }
>
> -bool check_huge_anon(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> -{
> -	uint64_t pmd_pagesize = read_pmd_pagesize();
> -
> -	if (!pmd_pagesize)
> -		ksft_exit_fail_msg("reading PMD pagesize failed\n");
> +enum check_huge_type {
> +	CHECK_HUGE_ANON,
> +	CHECK_HUGE_FILE,
> +	CHECK_HUGE_SHMEM,
> +};
>
> -	if (hpage_size == pmd_pagesize)
> -		return __check_pmd_huge(addr, "AnonHugePages: ", nr_hpages, hpage_size);
> +static bool check_huge_type(uint64_t categories, uint64_t kpageflags,
> +			    enum check_huge_type type)
> +{
> +	bool file = categories & PAGE_IS_FILE;
> +	bool swapbacked = kpageflags & KPF_SWAPBACKED;

NIT: nice to const these :)

> +
> +	switch (type) {
> +	case CHECK_HUGE_ANON:
> +		return !file;
> +	case CHECK_HUGE_FILE:
> +		return file && !swapbacked;
> +	case CHECK_HUGE_SHMEM:
> +		return file & swapbacked;
> +	}
>
> -	return check_large_folios(addr, len, nr_hpages, hpage_size);
> +	return false;
>  }
>
> -bool check_huge_file(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> +static bool __check_huge(void *addr, size_t len, int nr_hpages,
> +			 uint64_t hpage_size, enum check_huge_type type)
>  {
> -	uint64_t pmd_pagesize = read_pmd_pagesize();
> +	bool ret = false;
> +	int pagemap_fd, kpageflags_fd;
> +	int nr_pmd_mappings = 0;
> +	uint64_t pmd_pagesize, scan_mapping_size;
> +	uint64_t categories, kpf;
> +	unsigned long pfn;
> +	bool check_pmd_mapping, allow_nonpresent;
> +	char *start = addr;
> +	char *end = start + len;
>
> +	pmd_pagesize = read_pmd_pagesize();
>  	if (!pmd_pagesize)
>  		ksft_exit_fail_msg("reading PMD pagesize failed\n");
>
> -	if (hpage_size == pmd_pagesize)
> -		return __check_pmd_huge(addr, "FilePmdMapped:", nr_hpages, hpage_size);
> +	check_pmd_mapping = (hpage_size == pmd_pagesize);
> +	scan_mapping_size = (nr_hpages > 0) ? hpage_size : psize();
> +	/* Some mTHP tests check a partially populated PMD-sized range. */
> +	allow_nonpresent = (uint64_t)nr_hpages * hpage_size < len;
>
> -	return check_large_folios(addr, len, nr_hpages, hpage_size);
> +	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
> +	if (pagemap_fd < 0)
> +		ksft_exit_fail_msg("open pagemap fail\n");
> +
> +	kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
> +	if (kpageflags_fd < 0) {
> +		close(pagemap_fd);
> +		ksft_exit_fail_msg("open kpageflags fail\n");
> +	}
> +
> +	if (!check_pmd_mapping &&
> +	    !check_large_folios(pagemap_fd, kpageflags_fd,
> +				addr, len, nr_hpages, hpage_size))
> +		goto out;
> +
> +	for (; start < end; start += scan_mapping_size) {
> +		categories = pagemap_scan_get_categories(pagemap_fd, start);
> +		pfn = pagemap_get_pfn(pagemap_fd, start);
> +		if (pfn == -1UL) {
> +			if (!allow_nonpresent)
> +				goto out;
> +			else
> +				continue;
> +		}
> +		if (pageflags_get(pfn, kpageflags_fd, &kpf))
> +			ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
> +		if (check_pmd_mapping && (categories & PAGE_IS_HUGE))
> +			nr_pmd_mappings++;
> +		if (kpf & KPF_COMPOUND_TAIL)
> +			continue;
> +		if (!check_huge_type(categories, kpf, type))
> +			goto out;
> +	}
> +
> +	if (check_pmd_mapping && (nr_pmd_mappings != nr_hpages))
> +		goto out;
> +	ret = true;
> +
> +out:
> +	close(pagemap_fd);
> +	close(kpageflags_fd);
> +	return ret;
>  }
>
> -bool check_huge_shmem(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> +bool check_huge_anon(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
>  {
> -	uint64_t pmd_pagesize = read_pmd_pagesize();
> -
> -	if (!pmd_pagesize)
> -		ksft_exit_fail_msg("reading PMD pagesize failed\n");
> +	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_ANON);
> +}
>
> -	if (hpage_size == pmd_pagesize)
> -		return __check_pmd_huge(addr, "ShmemPmdMapped:", nr_hpages, hpage_size);
> +bool check_huge_file(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> +{
> +	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_FILE);
> +}
>
> -	return check_large_folios(addr, len, nr_hpages, hpage_size);
> +bool check_huge_shmem(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> +{
> +	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_SHMEM);
>  }
>
>  int64_t allocate_transhuge(void *ptr, int pagemap_fd)
> diff --git a/tools/testing/selftests/mm/vm_util.h b/tools/testing/selftests/mm/vm_util.h
> index 9a49af88702e..f19bd17817e5 100644
> --- a/tools/testing/selftests/mm/vm_util.h
> +++ b/tools/testing/selftests/mm/vm_util.h
> @@ -18,6 +18,7 @@
>  #define PM_SWAP                       BIT_ULL(62)
>  #define PM_PRESENT                    BIT_ULL(63)
>
> +#define KPF_SWAPBACKED                BIT_ULL(14)
>  #define KPF_COMPOUND_HEAD             BIT_ULL(15)
>  #define KPF_COMPOUND_TAIL             BIT_ULL(16)
>  #define KPF_HWPOISON                  BIT_ULL(19)
>
> --
> 2.43.0
>

--
Cheers, Lorenzo

Re: [PATCH v3 1/2] kselftest: mm: prevent random failure of huge page split for khugepaged

[Lorenzo Stoakes (ARM)]

On Fri, Aug 28, 2026 at 09:11:33AM +0100, Yeoreum Yun wrote:
> There're some random failure for split_huge_page_test when khugepaged
> collapses pages into pmd again which had split by the test.
>
> Prevent the khugepaged's collapses for split page by setting the
> mapped pmd-huge-page with MADV_NOHUGEPAGE before split.
>
> Reported-by: Kevin Brodsky <kevin.brodsky@arm.com>
> Reviewed-by: Zi Yan <ziy@nvidia.com>
> Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
> ---
>  tools/testing/selftests/mm/split_huge_page_test.c | 15 +++++++++++++++
>  1 file changed, 15 insertions(+)
>
> diff --git a/tools/testing/selftests/mm/split_huge_page_test.c b/tools/testing/selftests/mm/split_huge_page_test.c
> index 86a603692826..c718269a291f 100644
> --- a/tools/testing/selftests/mm/split_huge_page_test.c
> +++ b/tools/testing/selftests/mm/split_huge_page_test.c
> @@ -180,6 +180,10 @@ static void verify_rss_anon_split_huge_page_all_zeroes(char *one_page, int nr_hp
>  	if (!rss_anon_before)
>  		ksft_exit_fail_msg("No RssAnon is allocated before split\n");
>
> +	/* Prevent khugepaged from collapsing the pages. */
> +	if (madvise(one_page, len, MADV_NOHUGEPAGE))
> +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");

This should probably terminate the test no? There's no reason to expect this to
fail and it's better to fail then to risk a flake :)

> +
>  	/* split all THPs */
>  	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
>  		      (uint64_t)one_page + len, 0);
> @@ -227,6 +231,10 @@ static void split_pmd_thp_to_order(int order)
>  	if (!check_huge_anon(one_page, 4 * pmd_pagesize, 4, pmd_pagesize))
>  		ksft_exit_fail_msg("No THP is allocated\n");
>
> +	/* Prevent khugepaged from collapsing the pages. */
> +	if (madvise(one_page, len, MADV_NOHUGEPAGE))
> +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
> +

Same comment as above, also since this is a repeated pattern, I think it's worth
abstracting it like:

	static void madv_nohuge(char *ptr, size_t len)
	{
		if (!madvise(ptr, len, MADV_NOHUGEPAGE))
			return;

		ksft_exit_fail_msg("MADV_NOHUGEPAGE failed, err=%d\n", errno);
	}

>  	/* split all THPs */
>  	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
>  		(uint64_t)one_page + len, order);
> @@ -313,6 +321,10 @@ static void split_pte_mapped_thp(void)
>  		goto out;
>  	}
>
> +	/* Prevent khugepaged from collapsing the pages. */
> +	if (madvise(thp_area, thp_area_size, MADV_NOHUGEPAGE))
> +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
> +
>  	/* Split all THPs through the remapped pages. */
>  	write_debugfs(PID_FMT, getpid(), (uint64_t)page_area,
>  		      (uint64_t)page_area + page_area_size, 0);
> @@ -542,6 +554,9 @@ static int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size,
>  		ksft_test_result_skip("Pagecache folio split skipped\n");
>  		return -2;
>  	}
> +	/* Prevent khugepaged from collapsing the pages. */
> +	if (madvise(*addr, fd_size, MADV_NOHUGEPAGE))
> +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");

Obviously same comments re: this and above

>  	return 0;
>  err_out_close:
>  	close(*fd);
>
> --
> 2.43.0
>

--
Cheers, Lorenzo

Re: [PATCH v3 1/2] kselftest: mm: prevent random failure of huge page split for khugepaged

[Yeoreum Yun]

Hi Lorenzo,
> >  	if (!rss_anon_before)
> >  		ksft_exit_fail_msg("No RssAnon is allocated before split\n");
> >
> > +	/* Prevent khugepaged from collapsing the pages. */
> > +	if (madvise(one_page, len, MADV_NOHUGEPAGE))
> > +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
> 
> This should probably terminate the test no? There's no reason to expect this to
> fail and it's better to fail then to risk a flake :)

Okay. I thought it was rare, it seemed enough with just message.
I'll change with your suggesttion.

> 
> > +
> >  	/* split all THPs */
> >  	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
> >  		      (uint64_t)one_page + len, 0);
> > @@ -227,6 +231,10 @@ static void split_pmd_thp_to_order(int order)
> >  	if (!check_huge_anon(one_page, 4 * pmd_pagesize, 4, pmd_pagesize))
> >  		ksft_exit_fail_msg("No THP is allocated\n");
> >
> > +	/* Prevent khugepaged from collapsing the pages. */
> > +	if (madvise(one_page, len, MADV_NOHUGEPAGE))
> > +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
> > +
> 
> Same comment as above, also since this is a repeated pattern, I think it's worth
> abstracting it like:
> 
> 	static void madv_nohuge(char *ptr, size_t len)
> 	{
> 		if (!madvise(ptr, len, MADV_NOHUGEPAGE))
> 			return;
> 
> 		ksft_exit_fail_msg("MADV_NOHUGEPAGE failed, err=%d\n", errno);
> 	}

Acked.

> 
> >  	/* split all THPs */
> >  	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
> >  		(uint64_t)one_page + len, order);
> > @@ -313,6 +321,10 @@ static void split_pte_mapped_thp(void)
> >  		goto out;
> >  	}
> >
> > +	/* Prevent khugepaged from collapsing the pages. */
> > +	if (madvise(thp_area, thp_area_size, MADV_NOHUGEPAGE))
> > +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
> > +
> >  	/* Split all THPs through the remapped pages. */
> >  	write_debugfs(PID_FMT, getpid(), (uint64_t)page_area,
> >  		      (uint64_t)page_area + page_area_size, 0);
> > @@ -542,6 +554,9 @@ static int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size,
> >  		ksft_test_result_skip("Pagecache folio split skipped\n");
> >  		return -2;
> >  	}
> > +	/* Prevent khugepaged from collapsing the pages. */
> > +	if (madvise(*addr, fd_size, MADV_NOHUGEPAGE))
> > +		ksft_print_msg("madvise(MADV_NOHUGEPAGE) failed\n");
> 
> Obviously same comments re: this and above
> 

Thanks!

[...]

-- 
Sincerely,
Yeoreum Yun

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Yeoreum Yun]

> On Fri, Aug 28, 2026 at 09:11:34AM +0100, Yeoreum Yun wrote:
> > Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> > glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> > made by memalign().
> >
> > The underlying VMA may start at a different address from the aligned
> > address returned by memalign(). Furthermore, a subsequent
> > madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> > already set.
> >
> > This causes split_huge_page_test to fail because the check_huge_xxx()
> > helpers incorrectly require the address returned by memalign() to
> > match the VMA start address reported in /proc/self/smaps.
> 
> Hmm, is the test correctly putting sentinels either side of the VMA? Any test
> that doesn't risks flaking due to unwanted VMA merges.

I believe that with this change, we don’t need to worry about unwanted
VMA merges when checking for huge pages, since the test no longer relies
on VMA sentinels but directly checks whether the mapping is huge or not.

Also, this flaky failure was not caused by a VMA merge, but by a change
in glibc’s behavior that sets HUGEPAGE for sufficiently large areas.

Might for the *NO_HUGEPAGE* setup, there would be a chance to merge
VMA area, But since it seraches the mapping directly, it's fine.

> 
> >
> > Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> > /proc/self/smaps to detect huge pages.
> 
> You should probably call out the fact you're doing some refactoring here
> also!

Okay. I'll spell out with some detail. Thanks!

> 
> >
> > Reported-by: David Hildenbrand (Arm) <david@kernel.org>
> 
> Should always have a Closes: tag if Reported-by: ideally.

Yes. but talked with personally nothing to close. So Reported-by tag
only. Would it be better to remove?

> 
> > Suggested-by: Zi Yan <ziy@nvidia.com>
> > Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
> 
> Generally looks reasonable to me, some nits above and below though :)
> 
> Acked-by: Lorenzo Stoakes (ARM) <ljs@kernel.org>
> 
> > ---
> >  tools/testing/selftests/mm/vm_util.c | 145 ++++++++++++++++++++++-------------
> >  tools/testing/selftests/mm/vm_util.h |   1 +
> >  2 files changed, 92 insertions(+), 54 deletions(-)
> >
> > diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c
> > index 4821a3563036..083b72d92b14 100644
> > --- a/tools/testing/selftests/mm/vm_util.c
> > +++ b/tools/testing/selftests/mm/vm_util.c
> > @@ -351,31 +351,13 @@ char *__get_smap_entry(void *addr, const char *pattern, char *buf, size_t len)
> >  	return entry;
> >  }
> >
> > -static bool __check_pmd_huge(void *addr, char *pattern, int nr_hpages,
> > -		  uint64_t hpage_size)
> > -{
> > -	char buffer[MAX_LINE_LENGTH];
> > -	uint64_t thp = -1;
> > -	char *entry;
> > -
> > -	entry = __get_smap_entry(addr, pattern, buffer, sizeof(buffer));
> > -	if (!entry)
> > -		goto err_out;
> > -
> > -	if (sscanf(entry, "%9" SCNu64 " kB", &thp) != 1)
> > -		ksft_exit_fail_msg("Reading smap error\n");
> > -
> > -err_out:
> > -	return thp == (nr_hpages * (hpage_size >> 10));
> > -}
> > -
> > -static bool check_large_folios(void *addr, size_t len, int nr_hpages,
> > -		uint64_t hpage_size)
> > +static bool check_large_folios(int pagemap_fd, int kpageflags_fd,
> > +			       void *addr, size_t len, int nr_hpages,
> > +			       uint64_t hpage_size)
> >  {
> >  	int order = 0, pagesize = getpagesize();
> >  	unsigned int nr_pages = hpage_size / pagesize;
> >  	int orders[MAX_NR_ORDERS], status;
> > -	int pagemap_fd, kpageflags_fd;
> >  	bool ret = false;
> >
> >  	if (!nr_pages)
> > @@ -386,15 +368,6 @@ static bool check_large_folios(void *addr, size_t len, int nr_hpages,
> >  		ksft_exit_fail_msg("invalid order\n");
> >
> >  	memset(orders, 0, sizeof(int) * MAX_NR_ORDERS);
> > -	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
> > -	if (pagemap_fd == -1)
> > -		ksft_exit_fail_msg("read pagemap fail\n");
> > -
> > -	kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
> > -	if (kpageflags_fd == -1) {
> > -		close(pagemap_fd);
> > -		ksft_exit_fail_msg("read kpageflags fail\n");
> > -	}
> >
> >  	status = gather_folio_orders(addr, len, pagemap_fd,
> >  			kpageflags_fd, orders, MAX_NR_ORDERS);
> > @@ -405,48 +378,112 @@ static bool check_large_folios(void *addr, size_t len, int nr_hpages,
> >  		ret = true;
> >
> >  out:
> > -	close(pagemap_fd);
> > -	close(kpageflags_fd);
> >  	return ret;
> >  }
> >
> > -bool check_huge_anon(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> > -{
> > -	uint64_t pmd_pagesize = read_pmd_pagesize();
> > -
> > -	if (!pmd_pagesize)
> > -		ksft_exit_fail_msg("reading PMD pagesize failed\n");
> > +enum check_huge_type {
> > +	CHECK_HUGE_ANON,
> > +	CHECK_HUGE_FILE,
> > +	CHECK_HUGE_SHMEM,
> > +};
> >
> > -	if (hpage_size == pmd_pagesize)
> > -		return __check_pmd_huge(addr, "AnonHugePages: ", nr_hpages, hpage_size);
> > +static bool check_huge_type(uint64_t categories, uint64_t kpageflags,
> > +			    enum check_huge_type type)
> > +{
> > +	bool file = categories & PAGE_IS_FILE;
> > +	bool swapbacked = kpageflags & KPF_SWAPBACKED;
> 
> NIT: nice to const these :)
> 
> > +
> > +	switch (type) {
> > +	case CHECK_HUGE_ANON:
> > +		return !file;
> > +	case CHECK_HUGE_FILE:
> > +		return file && !swapbacked;
> > +	case CHECK_HUGE_SHMEM:
> > +		return file & swapbacked;
> > +	}
> >
> > -	return check_large_folios(addr, len, nr_hpages, hpage_size);
> > +	return false;
> >  }
> >
> > -bool check_huge_file(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> > +static bool __check_huge(void *addr, size_t len, int nr_hpages,
> > +			 uint64_t hpage_size, enum check_huge_type type)
> >  {
> > -	uint64_t pmd_pagesize = read_pmd_pagesize();
> > +	bool ret = false;
> > +	int pagemap_fd, kpageflags_fd;
> > +	int nr_pmd_mappings = 0;
> > +	uint64_t pmd_pagesize, scan_mapping_size;
> > +	uint64_t categories, kpf;
> > +	unsigned long pfn;
> > +	bool check_pmd_mapping, allow_nonpresent;
> > +	char *start = addr;
> > +	char *end = start + len;
> >
> > +	pmd_pagesize = read_pmd_pagesize();
> >  	if (!pmd_pagesize)
> >  		ksft_exit_fail_msg("reading PMD pagesize failed\n");
> >
> > -	if (hpage_size == pmd_pagesize)
> > -		return __check_pmd_huge(addr, "FilePmdMapped:", nr_hpages, hpage_size);
> > +	check_pmd_mapping = (hpage_size == pmd_pagesize);
> > +	scan_mapping_size = (nr_hpages > 0) ? hpage_size : psize();
> > +	/* Some mTHP tests check a partially populated PMD-sized range. */
> > +	allow_nonpresent = (uint64_t)nr_hpages * hpage_size < len;
> >
> > -	return check_large_folios(addr, len, nr_hpages, hpage_size);
> > +	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
> > +	if (pagemap_fd < 0)
> > +		ksft_exit_fail_msg("open pagemap fail\n");
> > +
> > +	kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
> > +	if (kpageflags_fd < 0) {
> > +		close(pagemap_fd);
> > +		ksft_exit_fail_msg("open kpageflags fail\n");
> > +	}
> > +
> > +	if (!check_pmd_mapping &&
> > +	    !check_large_folios(pagemap_fd, kpageflags_fd,
> > +				addr, len, nr_hpages, hpage_size))
> > +		goto out;
> > +
> > +	for (; start < end; start += scan_mapping_size) {
> > +		categories = pagemap_scan_get_categories(pagemap_fd, start);
> > +		pfn = pagemap_get_pfn(pagemap_fd, start);
> > +		if (pfn == -1UL) {
> > +			if (!allow_nonpresent)
> > +				goto out;
> > +			else
> > +				continue;
> > +		}
> > +		if (pageflags_get(pfn, kpageflags_fd, &kpf))
> > +			ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
> > +		if (check_pmd_mapping && (categories & PAGE_IS_HUGE))
> > +			nr_pmd_mappings++;
> > +		if (kpf & KPF_COMPOUND_TAIL)
> > +			continue;
> > +		if (!check_huge_type(categories, kpf, type))
> > +			goto out;
> > +	}
> > +
> > +	if (check_pmd_mapping && (nr_pmd_mappings != nr_hpages))
> > +		goto out;
> > +	ret = true;
> > +
> > +out:
> > +	close(pagemap_fd);
> > +	close(kpageflags_fd);
> > +	return ret;
> >  }
> >
> > -bool check_huge_shmem(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> > +bool check_huge_anon(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> >  {
> > -	uint64_t pmd_pagesize = read_pmd_pagesize();
> > -
> > -	if (!pmd_pagesize)
> > -		ksft_exit_fail_msg("reading PMD pagesize failed\n");
> > +	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_ANON);
> > +}
> >
> > -	if (hpage_size == pmd_pagesize)
> > -		return __check_pmd_huge(addr, "ShmemPmdMapped:", nr_hpages, hpage_size);
> > +bool check_huge_file(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> > +{
> > +	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_FILE);
> > +}
> >
> > -	return check_large_folios(addr, len, nr_hpages, hpage_size);
> > +bool check_huge_shmem(void *addr, size_t len, int nr_hpages, uint64_t hpage_size)
> > +{
> > +	return __check_huge(addr, len, nr_hpages, hpage_size, CHECK_HUGE_SHMEM);
> >  }
> >
> >  int64_t allocate_transhuge(void *ptr, int pagemap_fd)
> > diff --git a/tools/testing/selftests/mm/vm_util.h b/tools/testing/selftests/mm/vm_util.h
> > index 9a49af88702e..f19bd17817e5 100644
> > --- a/tools/testing/selftests/mm/vm_util.h
> > +++ b/tools/testing/selftests/mm/vm_util.h
> > @@ -18,6 +18,7 @@
> >  #define PM_SWAP                       BIT_ULL(62)
> >  #define PM_PRESENT                    BIT_ULL(63)
> >
> > +#define KPF_SWAPBACKED                BIT_ULL(14)
> >  #define KPF_COMPOUND_HEAD             BIT_ULL(15)
> >  #define KPF_COMPOUND_TAIL             BIT_ULL(16)
> >  #define KPF_HWPOISON                  BIT_ULL(19)
> >
> > --
> > 2.43.0
> >
> 
> --
> Cheers, Lorenzo

-- 
Sincerely,
Yeoreum Yun

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Lorenzo Stoakes (ARM)]

On Fri, Aug 28, 2026 at 11:17:58AM +0100, Yeoreum Yun wrote:
> > On Fri, Aug 28, 2026 at 09:11:34AM +0100, Yeoreum Yun wrote:
> > > Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> > > glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> > > made by memalign().
> > >
> > > The underlying VMA may start at a different address from the aligned
> > > address returned by memalign(). Furthermore, a subsequent
> > > madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> > > already set.
> > >
> > > This causes split_huge_page_test to fail because the check_huge_xxx()
> > > helpers incorrectly require the address returned by memalign() to
> > > match the VMA start address reported in /proc/self/smaps.
> >
> > Hmm, is the test correctly putting sentinels either side of the VMA? Any test
> > that doesn't risks flaking due to unwanted VMA merges.
>
> I believe that with this change, we don’t need to worry about unwanted
> VMA merges when checking for huge pages, since the test no longer relies
> on VMA sentinels but directly checks whether the mapping is huge or not.

We always need to worry about that though, anything that asserts stuff on a
VMA level must prevent unwanted merges first.

I guess I'm asking you in a roundabout way to go check and if there isn't
isolation like that (i.e. mapping PROT_NONE VMAs around the VMA you want)
then to go do that :)

I think glibc going off and mapping a bigger VMA is possibly a symptom
of this not being done.

>
> Also, this flaky failure was not caused by a VMA merge, but by a change
> in glibc’s behavior that sets HUGEPAGE for sufficiently large areas.

Yep your change is worthwhile reagrdless! :)

>
> Might for the *NO_HUGEPAGE* setup, there would be a chance to merge
> VMA area, But since it seraches the mapping directly, it's fine.

As above, generally we should put this protection in case, even if it's
unlikely for a VMA with VMA_NOHUGEPAGE_BIT set!

>
> >
> > >
> > > Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> > > /proc/self/smaps to detect huge pages.
> >
> > You should probably call out the fact you're doing some refactoring here
> > also!
>
> Okay. I'll spell out with some detail. Thanks!

Thnks!

>
> >
> > >
> > > Reported-by: David Hildenbrand (Arm) <david@kernel.org>
> >
> > Should always have a Closes: tag if Reported-by: ideally.
>
> Yes. but talked with personally nothing to close. So Reported-by tag
> only. Would it be better to remove?

Yeah or Suggested-by maybe? If he said it to you on-list then a Closes:
<lore link> works also!

--
Cheers, Lorenzo

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Yeoreum Yun]

> On Fri, Aug 28, 2026 at 11:17:58AM +0100, Yeoreum Yun wrote:
> > > On Fri, Aug 28, 2026 at 09:11:34AM +0100, Yeoreum Yun wrote:
> > > > Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> > > > glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> > > > made by memalign().
> > > >
> > > > The underlying VMA may start at a different address from the aligned
> > > > address returned by memalign(). Furthermore, a subsequent
> > > > madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> > > > already set.
> > > >
> > > > This causes split_huge_page_test to fail because the check_huge_xxx()
> > > > helpers incorrectly require the address returned by memalign() to
> > > > match the VMA start address reported in /proc/self/smaps.
> > >
> > > Hmm, is the test correctly putting sentinels either side of the VMA? Any test
> > > that doesn't risks flaking due to unwanted VMA merges.
> >
> > I believe that with this change, we don’t need to worry about unwanted
> > VMA merges when checking for huge pages, since the test no longer relies
> > on VMA sentinels but directly checks whether the mapping is huge or not.
> 
> We always need to worry about that though, anything that asserts stuff on a
> VMA level must prevent unwanted merges first.
> 
> I guess I'm asking you in a roundabout way to go check and if there isn't
> isolation like that (i.e. mapping PROT_NONE VMAs around the VMA you want)
> then to go do that :)

Oh. Sorry not to catch your intend. not for only this series but for
the future usage, might it sound reasonable to add some mem alloca
fucntion for the test which could replace memalign() with above concept.

> I think glibc going off and mapping a bigger VMA is possibly a symptom
> of this not being done.

TBH, what user would generally care whether VMAs are merged or not?
Anyway, it would be better to add a helper with some PROT_NONE guards
to prevent unwanted VMA merges while testing.

> 
> >
> > Also, this flaky failure was not caused by a VMA merge, but by a change
> > in glibc’s behavior that sets HUGEPAGE for sufficiently large areas.
> 
> Yep your change is worthwhile reagrdless! :)

Thanks :)

> 
> >
> > Might for the *NO_HUGEPAGE* setup, there would be a chance to merge
> > VMA area, But since it seraches the mapping directly, it's fine.
> 
> As above, generally we should put this protection in case, even if it's
> unlikely for a VMA with VMA_NOHUGEPAGE_BIT set!

Agree. let me add one for this and replace memalign() used in
khugepagd and split_huge_page_test at first.
> 
> >
> > >
> > > >
> > > > Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> > > > /proc/self/smaps to detect huge pages.
> > >
> > > You should probably call out the fact you're doing some refactoring here
> > > also!
> >
> > Okay. I'll spell out with some detail. Thanks!
> 
> Thnks!
> 
> >
> > >
> > > >
> > > > Reported-by: David Hildenbrand (Arm) <david@kernel.org>
> > >
> > > Should always have a Closes: tag if Reported-by: ideally.
> >
> > Yes. but talked with personally nothing to close. So Reported-by tag
> > only. Would it be better to remove?
> 
> Yeah or Suggested-by maybe? If he said it to you on-list then a Closes:
> <lore link> works also!

Okay. I'll drop the Reported-by: and change to Suggseted-by.

Thanks!

-- 
Sincerely,
Yeoreum Yun

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Zi Yan]

On Fri Aug 28, 2026 at 4:11 AM EDT, Yeoreum Yun wrote:
> Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> made by memalign().
>
> The underlying VMA may start at a different address from the aligned
> address returned by memalign(). Furthermore, a subsequent
> madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> already set.
>
> This causes split_huge_page_test to fail because the check_huge_xxx()
> helpers incorrectly require the address returned by memalign() to
> match the VMA start address reported in /proc/self/smaps.
>
> Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> /proc/self/smaps to detect huge pages.
>
> Reported-by: David Hildenbrand (Arm) <david@kernel.org>
> Suggested-by: Zi Yan <ziy@nvidia.com>
> Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
> ---
>  tools/testing/selftests/mm/vm_util.c | 145 ++++++++++++++++++++++-------------
>  tools/testing/selftests/mm/vm_util.h |   1 +
>  2 files changed, 92 insertions(+), 54 deletions(-)
>
> diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c
> index 4821a3563036..083b72d92b14 100644
> --- a/tools/testing/selftests/mm/vm_util.c
> +++ b/tools/testing/selftests/mm/vm_util.c
> @@ -351,31 +351,13 @@ char *__get_smap_entry(void *addr, const char *pattern, char *buf, size_t len)
>  	return entry;
>  }
>  

<snip>

> +	for (; start < end; start += scan_mapping_size) {
> +		categories = pagemap_scan_get_categories(pagemap_fd, start);
> +		pfn = pagemap_get_pfn(pagemap_fd, start);
> +		if (pfn == -1UL) {
> +			if (!allow_nonpresent)
> +				goto out;
> +			else
> +				continue;
> +		}
> +		if (pageflags_get(pfn, kpageflags_fd, &kpf))
> +			ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
> +		if (check_pmd_mapping && (categories & PAGE_IS_HUGE))
> +			nr_pmd_mappings++;
> +		if (kpf & KPF_COMPOUND_TAIL)
> +			continue;
> +		if (!check_huge_type(categories, kpf, type))
> +			goto out;
> +	}
> +	

There is a trailing tab.

> +	if (check_pmd_mapping && (nr_pmd_mappings != nr_hpages))
> +		goto out;
> +	ret = true;
> +
> +out:
> +	close(pagemap_fd);
> +	close(kpageflags_fd);
> +	return ret;
>  }
>  

Otherwise, LGTM. I assume the replacement of memalign(), from the
discussion between you and Lorenzo, will be added in a separate patch.
For this patch,

Reviewed-by: Zi Yan <ziy@nvidia.com>

Thanks.

-- 
Best Regards,
Yan, Zi

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Yeoreum Yun]

On Fri, Aug 28, 2026 at 11:13:00AM -0400, Zi Yan wrote:
> On Fri Aug 28, 2026 at 4:11 AM EDT, Yeoreum Yun wrote:
> > Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> > glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> > made by memalign().
> >
> > The underlying VMA may start at a different address from the aligned
> > address returned by memalign(). Furthermore, a subsequent
> > madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> > already set.
> >
> > This causes split_huge_page_test to fail because the check_huge_xxx()
> > helpers incorrectly require the address returned by memalign() to
> > match the VMA start address reported in /proc/self/smaps.
> >
> > Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> > /proc/self/smaps to detect huge pages.
> >
> > Reported-by: David Hildenbrand (Arm) <david@kernel.org>
> > Suggested-by: Zi Yan <ziy@nvidia.com>
> > Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
> > ---
> >  tools/testing/selftests/mm/vm_util.c | 145 ++++++++++++++++++++++-------------
> >  tools/testing/selftests/mm/vm_util.h |   1 +
> >  2 files changed, 92 insertions(+), 54 deletions(-)
> >
> > diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c
> > index 4821a3563036..083b72d92b14 100644
> > --- a/tools/testing/selftests/mm/vm_util.c
> > +++ b/tools/testing/selftests/mm/vm_util.c
> > @@ -351,31 +351,13 @@ char *__get_smap_entry(void *addr, const char *pattern, char *buf, size_t len)
> >  	return entry;
> >  }
> >  
> 
> <snip>
> 
> > +	for (; start < end; start += scan_mapping_size) {
> > +		categories = pagemap_scan_get_categories(pagemap_fd, start);
> > +		pfn = pagemap_get_pfn(pagemap_fd, start);
> > +		if (pfn == -1UL) {
> > +			if (!allow_nonpresent)
> > +				goto out;
> > +			else
> > +				continue;
> > +		}
> > +		if (pageflags_get(pfn, kpageflags_fd, &kpf))
> > +			ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
> > +		if (check_pmd_mapping && (categories & PAGE_IS_HUGE))
> > +			nr_pmd_mappings++;
> > +		if (kpf & KPF_COMPOUND_TAIL)
> > +			continue;
> > +		if (!check_huge_type(categories, kpf, type))
> > +			goto out;
> > +	}
> > +	
> 
> There is a trailing tab.
> 
> > +	if (check_pmd_mapping && (nr_pmd_mappings != nr_hpages))
> > +		goto out;
> > +	ret = true;
> > +
> > +out:
> > +	close(pagemap_fd);
> > +	close(kpageflags_fd);
> > +	return ret;
> >  }
> >  
> 
> Otherwise, LGTM. I assume the replacement of memalign(), from the
> discussion between you and Lorenzo, will be added in a separate patch.
> For this patch,

Yeap. I'll post with the separated one.

> 
> Reviewed-by: Zi Yan <ziy@nvidia.com>

Thanks!

-- 
Sincerely,
Yeoreum Yun

Re: [PATCH v3 2/2] kselftest: mm: replace usage of /proc/self/smaps for check_huge_xxx() helper

[Lorenzo Stoakes (ARM)]

On Fri, Aug 28, 2026 at 03:35:39PM +0100, Yeoreum Yun wrote:
> > On Fri, Aug 28, 2026 at 11:17:58AM +0100, Yeoreum Yun wrote:
> > > > On Fri, Aug 28, 2026 at 09:11:34AM +0100, Yeoreum Yun wrote:
> > > > > Since glibc commit 321e1fc73f (“malloc: Enable 2MB THP by default on AArch64”),
> > > > > glibc may call madvise(MADV_HUGEPAGE) for sufficiently large allocations
> > > > > made by memalign().
> > > > >
> > > > > The underlying VMA may start at a different address from the aligned
> > > > > address returned by memalign(). Furthermore, a subsequent
> > > > > madvise(MADV_HUGEPAGE) call does not split the VMA because the flag is
> > > > > already set.
> > > > >
> > > > > This causes split_huge_page_test to fail because the check_huge_xxx()
> > > > > helpers incorrectly require the address returned by memalign() to
> > > > > match the VMA start address reported in /proc/self/smaps.
> > > >
> > > > Hmm, is the test correctly putting sentinels either side of the VMA? Any test
> > > > that doesn't risks flaking due to unwanted VMA merges.
> > >
> > > I believe that with this change, we don’t need to worry about unwanted
> > > VMA merges when checking for huge pages, since the test no longer relies
> > > on VMA sentinels but directly checks whether the mapping is huge or not.
> >
> > We always need to worry about that though, anything that asserts stuff on a
> > VMA level must prevent unwanted merges first.
> >
> > I guess I'm asking you in a roundabout way to go check and if there isn't
> > isolation like that (i.e. mapping PROT_NONE VMAs around the VMA you want)
> > then to go do that :)
>
> Oh. Sorry not to catch your intend. not for only this series but for
> the future usage, might it sound reasonable to add some mem alloca
> fucntion for the test which could replace memalign() with above concept.
>
> > I think glibc going off and mapping a bigger VMA is possibly a symptom
> > of this not being done.
>
> TBH, what user would generally care whether VMAs are merged or not?
> Anyway, it would be better to add a helper with some PROT_NONE guards
> to prevent unwanted VMA merges while testing.

It's been known to make tests fail, more so obviously when you assert VMA
ranges, but in general it's good practice just to ensure the test is
isolated :)

>
> >
> > >
> > > Also, this flaky failure was not caused by a VMA merge, but by a change
> > > in glibc’s behavior that sets HUGEPAGE for sufficiently large areas.
> >
> > Yep your change is worthwhile reagrdless! :)
>
> Thanks :)
>
> >
> > >
> > > Might for the *NO_HUGEPAGE* setup, there would be a chance to merge
> > > VMA area, But since it seraches the mapping directly, it's fine.
> >
> > As above, generally we should put this protection in case, even if it's
> > unlikely for a VMA with VMA_NOHUGEPAGE_BIT set!
>
> Agree. let me add one for this and replace memalign() used in
> khugepagd and split_huge_page_test at first.

Great thanks!

> >
> > >
> > > >
> > > > >
> > > > > Fix this by using /proc/self/pagemap and /proc/kpageflags instead of
> > > > > /proc/self/smaps to detect huge pages.
> > > >
> > > > You should probably call out the fact you're doing some refactoring here
> > > > also!
> > >
> > > Okay. I'll spell out with some detail. Thanks!
> >
> > Thnks!
> >
> > >
> > > >
> > > > >
> > > > > Reported-by: David Hildenbrand (Arm) <david@kernel.org>
> > > >
> > > > Should always have a Closes: tag if Reported-by: ideally.
> > >
> > > Yes. but talked with personally nothing to close. So Reported-by tag
> > > only. Would it be better to remove?
> >
> > Yeah or Suggested-by maybe? If he said it to you on-list then a Closes:
> > <lore link> works also!
>
> Okay. I'll drop the Reported-by: and change to Suggseted-by.
>
> Thanks!

Thank you! :)

>
> --
> Sincerely,
> Yeoreum Yun

--
Cheers, Lorenzo