On 8/28/26 12:54 AM, Yeoreum Yun wrote:
On Thu, Aug 27, 2026 at 11:03:17AM -0400, Zi Yan wrote:On Thu Aug 27, 2026 at 6:44 AM EDT, Yeoreum Yun wrote:Hi Baolin,On 8/26/26 8:24 PM, 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) <[email protected]> Signed-off-by: Yeoreum Yun <[email protected]> --- tools/testing/selftests/mm/vm_util.c | 130 ++++++++++++++++++++--------------- tools/testing/selftests/mm/vm_util.h | 1 + 2 files changed, 77 insertions(+), 54 deletions(-) diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c index 4821a3563036..1d0959b3b9e8 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,97 @@ 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) +enum check_huge_type { + CHECK_HUGE_ANON, + CHECK_HUGE_FILE, + CHECK_HUGE_SHMEM, +}; + +static bool __check_pmd_huge(void *addr, size_t len, int nr_hpages, + uint64_t hpage_size, enum check_huge_type type)The original __check_pmd_huge() is only for PMD-sized large folios, but now it not only checks PMD-sized large folios but also mTHP large folios, which I find confusing. Please keep its original semantics, and only check PMD-sized large folios.But, It seems to valuable to check other page-flags than checking the large-folio only.{ - uint64_t pmd_pagesize = read_pmd_pagesize(); + int pagemap_fd, kpageflags_fd; + uint64_t pmd_pagesize, granule; + uint64_t categories, kpf; + unsigned long pfn; + bool check_large, huge_mapped; + 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, "AnonHugePages: ", nr_hpages, hpage_size); + if (nr_hpages > 0) { + check_large = true; + granule = hpage_size; + } else { + check_large = false; + granule = psize(); + }This is incorrect for the mTHP large folio check. I already hit a selftest failure. Please test your patches before sending them out.Since for a split case, large folio can be as-is but only remove the PMD mapping only, skipping the large_folio checking seems valid when nr_hpage is 0.What split care are you referring to? split_huge_page_test() always splits the folio.Not for split_huge_page_test case but for khugepage testcase like collapse_full_of_compound() test.And the failure of test seems because of unmapped area after changinng the collapse-order. Therefore, it seems to fine with below patch: ---------------&<---------------------- diff --git a/tools/testing/selftests/mm/vm_util.c b/tools/testing/selftests/mm/vm_util.c index 1d0959b3b9e8..f174a76d2310 100644 --- a/tools/testing/selftests/mm/vm_util.c +++ b/tools/testing/selftests/mm/vm_util.c @@ -387,14 +387,14 @@ enum check_huge_type { CHECK_HUGE_SHMEM, }; -static bool __check_pmd_huge(void *addr, size_t len, int nr_hpages, - uint64_t hpage_size, enum check_huge_type type) +static bool __check_huge(void *addr, size_t len, int nr_hpages, + uint64_t hpage_size, enum check_huge_type type) { int pagemap_fd, kpageflags_fd; uint64_t pmd_pagesize, granule; uint64_t categories, kpf; unsigned long pfn; - bool check_large, huge_mapped; + bool check_large, check_huge_mapped, allow_nomap; char *start = addr; char *end = start + len; @@ -405,11 +405,20 @@ static bool __check_pmd_huge(void *addr, size_t len, int nr_hpages, if (nr_hpages > 0) { check_large = true; granule = hpage_size; + if (granule == pmd_pagesize) + check_huge_mapped = true; + else + check_huge_mapped = false; } else { check_large = false; granule = psize(); }The else is for nr_hpages == 0? But it looks like we allow negative nr_hpages. Maybe add a bool expect_huge = nr_hpages > 0 to make it explicit.Fair enough. I'll change.granule is an optimization for PAGE_IS_HUGE scanning? When we expect a PMD mapping, we just scan at pmd_pagesize granularity, otherwise we check every single page? At the high level, the function looks good to me, the rules are: 1. if hpage_size == pmd_pagesize, we need to check PAGE_IS_HUGE and check_large_folio() can be skipped, since we only care about mappings. This checks for PMD mappings. 2. in other cases, check_large_folios() is always needed. This is for mTHP checks.
Yes, this is also what I thought. And the following code looks good to me. Thanks.
Exactly, but for some testcase where use this function, doesn't trigger split of large _folio but only check the HUGE MAP is removed (nr_hpage == 0), it skips the chekc_large_folio().I think the ifs at the beginning is confusing. Can we do something like below to get rid of the ifs? I also moved KPF_* checks in a separate function. Feel free to make changes if you find any issue there. 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 false; } static bool __check_huge(void *addr, size_t len, int nr_hpages, uint64_t hpage_size, enum check_huge_type type) { 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; bool allow_nonpresent; bool ret = false; char *start = addr; char *end = start + len; pmd_pagesize = read_pmd_pagesize(); if (!pmd_pagesize) ksft_exit_fail_msg("reading PMD pagesize failed\n"); 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; 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"); } /* PTE-mapped large folios cannot be identified by PAGE_IS_HUGE. */ 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; 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;Again, because of collapse_full_of_compound() testcase, it would be failed for this. so, it would better to skip check_large_folioes() when nr_hpages is 0.
IIUC, when nr_hpages is 0, we should also call check_large_folios() to verify that there are no large folios within this address range, which is also what the previous code did.
Also, I tried Zi's code, and it passed all my khugepaged selftests. I'm not sure why you saw the collapse_full_of_compound() test case fail.
