kselftest: mm: fix some failure of split_huge_page_test

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.

Suggested-by Kevin Brodsky <[email protected]>

Suggested-by Lorenzo Stoakes (ARM) <[email protected]>

Reviewed-by Lorenzo Stoakes (ARM) <[email protected]>

Reviewed-by Zi Yan <[email protected]>

Acked-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---
 tools/testing/selftests/mm/split_huge_page_test.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

tools/testing/selftests/mm/split_huge_page_test.c +0 -0

index c5d96a4b1db3..ef4058662b91 100644

tools/testing/selftests/mm/split_huge_page_test.c +9 -0

+}
+
 static void verify_rss_anon_split_huge_page_all_zeroes(char *one_page, int nr_hpages, size_t len)
 {
 	unsigned long rss_anon_before, rss_anon_after;

@@ -120,6 +132,8 @@ 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");
 
+	disable_khugepaged(one_page, len);
+
 	/* split all THPs */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
 		      (uint64_t)one_page + len, 0);

@@ -167,6 +181,8 @@ 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");
 
+	disable_khugepaged(one_page, len);
+
 	/* split all THPs */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
 		(uint64_t)one_page + len, order);

@@ -215,6 +231,8 @@ static void split_pte_mapped_thp(void)
 		goto out;
 	}
 
+	disable_khugepaged(thp_area, thp_area_size);
+
 	/*
 	 * To challenge spitting code, we will mremap a single page of each
 	 * THP (page[i] of thp[i]) in the thp_area into page_area. This will

@@ -482,6 +500,7 @@ 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;
 	}
+	disable_khugepaged(*addr, fd_size);
 	return 0;
 err_out_close:
 	close(*fd);

Quoted 24 lines

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.

Suggested-by Kevin Brodsky <[email protected]>

Suggested-by Lorenzo Stoakes (ARM) <[email protected]>

Reviewed-by Lorenzo Stoakes (ARM) <[email protected]>

Reviewed-by Zi Yan <[email protected]>

Acked-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---
 tools/testing/selftests/mm/split_huge_page_test.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

tools/testing/selftests/mm/split_huge_page_test.c +0 -0

index c5d96a4b1db3..ef4058662b91 100644
@@ -108,6 +108,18 @@ static char *allocate_zero_filled_hugepage(size_t len)
 	return result;
 }
 

tools/testing/selftests/mm/split_huge_page_test.c static char *allocate_zero_filled_hugepage(size_t len) · line 114

Quoted 4 lines

tools/testing/selftests/mm/split_huge_page_test.c +4 -0

+static void disable_khugepaged(void *addr, size_t len)
+{
+	/*
+	 * Disables khugepaged from collapsing THPs in range, existing THP

Should it be "collapsing pages in range into THPs" instead?

tools/testing/selftests/mm/split_huge_page_test.c static char *allocate_zero_filled_hugepage(size_t len) · line 120

Quoted 7 lines

tools/testing/selftests/mm/split_huge_page_test.c +6 -0

+	 * pages remain.
+	 */
+	if (!madvise(addr, len, MADV_NOHUGEPAGE))
+		return;
+
+	ksft_exit_fail_msg("MADV_NOHUGEPAGE failed, err=%d\n", errno);

I feel a ksft_exit_fail_perror() would be better here, since it will automatically print strerror(errno) as well. Still, it is not something that should require a respin of its own, so if you plan to respin for some other changes, you might fold these changes in as well.

Rest looks good, so:

Reviewed-by Sarthak Sharma <[email protected]>

Quoted 41 lines

tools/testing/selftests/mm/split_huge_page_test.c +9 -0

+}
+
 static void verify_rss_anon_split_huge_page_all_zeroes(char *one_page, int nr_hpages, size_t len)
 {
 	unsigned long rss_anon_before, rss_anon_after;

@@ -120,6 +132,8 @@ 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");
 
+	disable_khugepaged(one_page, len);
+
 	/* split all THPs */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
 		      (uint64_t)one_page + len, 0);

@@ -167,6 +181,8 @@ 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");
 
+	disable_khugepaged(one_page, len);
+
 	/* split all THPs */
 	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
 		(uint64_t)one_page + len, order);

@@ -215,6 +231,8 @@ static void split_pte_mapped_thp(void)
 		goto out;
 	}
 
+	disable_khugepaged(thp_area, thp_area_size);
+
 	/*
 	 * To challenge spitting code, we will mremap a single page of each
 	 * THP (page[i] of thp[i]) in the thp_area into page_area. This will

@@ -482,6 +500,7 @@ 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;
 	}
+	disable_khugepaged(*addr, fd_size);
 	return 0;
 err_out_close:
 	close(*fd);

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_pmd_huge() helpers incorrectly require the address returned by memalign() to match the VMA start address reported in /proc/self/smaps.

Instead of relying on /proc/self/smaps, use /proc/self/pagemap and /proc/kpageflags to detect huge-page mappings checking PAGE_IS_HUGE and PAGE_IS_FILE accroding to type of huge page.

Since shmem pages are also file-backed, simply check whether the page is file-backed.

Fixes 642bc52aed9 ("selftests: vm: bring common functions to a new file")

Suggested-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

Quoted 13 lines · 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_pmd_huge() helpers incorrectly require the address returned by memalign() to match the VMA start address reported in /proc/self/smaps.

Quoted 3 lines

Instead of relying on /proc/self/smaps, use /proc/self/pagemap and /proc/kpageflags to detect huge-page mappings checking PAGE_IS_HUGE and PAGE_IS_FILE accroding to type of huge page.

s/accroding/according

Quoted 6 lines

Since shmem pages are also file-backed, simply check whether the page is file-backed.

Fixes 642bc52aed9 ("selftests: vm: bring common functions to a new file")

Checkpatch gives a warning saying it requires atleast 12 characters of commit SHA.

Quoted 4 lines

Suggested-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

[...]

tools/testing/selftests/mm/vm_util.c static bool check_large_folios(void *addr, size_t len, int nr_hpages, · line 425

Quoted 12 lines

tools/testing/selftests/mm/vm_util.c +12 -0

+static bool __check_pmd_huge(void *addr, size_t len, int nr_hpages,
+		  uint64_t hpage_size, enum check_huge_type type)
+{
+	int pagemap_fd;
+	int nr_pmd_mappings = 0;
+	uint64_t categories;
+	char *start = addr;
+	char *end = start + len;
+
+	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
+	if (pagemap_fd < 0)
+		ksft_exit_fail_msg("open pagemap fail\n");

Can we use ksft_exit_fail_perror("open pagemap") here? Will help in diagnosing failures as well.

Apart from these nits, rest looks good.

Reviewed-by Sarthak Sharma <[email protected]>

Quoted 16 lines · Sarthak Sharma

Quoted 13 lines · 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_pmd_huge() helpers incorrectly require the address returned by memalign() to match the VMA start address reported in /proc/self/smaps.

Quoted 5 lines

Quoted 3 lines

Instead of relying on /proc/self/smaps, use /proc/self/pagemap and /proc/kpageflags to detect huge-page mappings checking PAGE_IS_HUGE and PAGE_IS_FILE accroding to type of huge page.

s/accroding/according

Okay.

Quoted 9 lines

Quoted 6 lines

Since shmem pages are also file-backed, simply check whether the page is file-backed.

Fixes 642bc52aed9 ("selftests: vm: bring common functions to a new file")

Checkpatch gives a warning saying it requires atleast 12 characters of commit SHA.

Oops. I'll update.

Quoted 7 lines

Quoted 4 lines

Suggested-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

[...]

Quoted 15 lines

tools/testing/selftests/mm/vm_util.c static bool check_large_folios(void *addr, size_t len, int nr_hpages, · line 425

Quoted 12 lines

tools/testing/selftests/mm/vm_util.c +12 -0

+static bool __check_pmd_huge(void *addr, size_t len, int nr_hpages,
+		  uint64_t hpage_size, enum check_huge_type type)
+{
+	int pagemap_fd;
+	int nr_pmd_mappings = 0;
+	uint64_t categories;
+	char *start = addr;
+	char *end = start + len;
+
+	pagemap_fd = open(PAGEMAP_PATH, O_RDONLY);
+	if (pagemap_fd < 0)
+		ksft_exit_fail_msg("open pagemap fail\n");

Can we use ksft_exit_fail_perror("open pagemap") here? Will help in diagnosing failures as well.

I see thanks!

Quoted 4 lines

Apart from these nits, rest looks good.

Reviewed-by Sarthak Sharma <[email protected]>

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_pmd_huge() helpers incorrectly require the address returned by memalign() to match the VMA start address reported in /proc/self/smaps.

Instead of relying on /proc/self/smaps, use /proc/self/pagemap and /proc/kpageflags to detect huge-page mappings checking PAGE_IS_HUGE and PAGE_IS_FILE accroding to type of huge page.

Since shmem pages are also file-backed, simply check whether the page is file-backed.

Fixes 642bc52aed9 ("selftests: vm: bring common functions to a new file")

Suggested-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

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_pmd_huge() helpers incorrectly require the address returned by memalign() to match the VMA start address reported in /proc/self/smaps.

Instead of relying on /proc/self/smaps, use /proc/self/pagemap and /proc/kpageflags to detect huge-page mappings checking PAGE_IS_HUGE and PAGE_IS_FILE accroding to type of huge page.

Since shmem pages are also file-backed, simply check whether the page is file-backed.

Fixes 642bc52aed9 ("selftests: vm: bring common functions to a new file")

Suggested-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---
 tools/testing/selftests/mm/vm_util.c | 78 ++++++++++++++++++++++--------------
 1 file changed, 49 insertions(+), 29 deletions(-)

check_large_folios() only checks for large folios without distinguishing between anonymous and file-backed huge pages.

To add huge page type checking, integrate the huge page checks into __check_huge():

1. If hpage_size == pmd_pagesize, check PAGE_IS_HUGE instead of using check_large_folios(), since only the mapping type matters. This identifies PMD-mapped huge pages.

2. Otherwise, use check_large_folios() to detect large folios. This covers mTHP cases.

3. Check the folio flags according to the huge page type.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Suggested-by Zi Yan <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

tools/testing/selftests/mm/vm_util.c +14 -3

-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;
+	bool ret = false;
+	int pagemap_fd, kpageflags_fd;
 	int nr_pmd_mappings = 0;
+	uint64_t pmd_pagesize, scan_mapping_size;
 	uint64_t categories;
+	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");
+
+	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. */

tools/testing/selftests/mm/vm_util.c +6 -0

+
+	if (!check_pmd_mapping &&
+	    !check_large_folios(pagemap_fd, kpageflags_fd,
+				addr, len, nr_hpages, hpage_size))
+		goto out;
+

tools/testing/selftests/mm/vm_util.c +13 -2

+				continue;
+		}
+		if (check_pmd_mapping && (categories & PAGE_IS_HUGE))
 			nr_pmd_mappings++;
+		if (!check_huge_type(categories, type))
+			goto out;
 	}
-	close(pagemap_fd);
 
-	return nr_hpages == nr_pmd_mappings;
+	if (check_pmd_mapping && (nr_pmd_mappings != nr_hpages))
+		goto out;
+	ret = true;
+
+out:
+	close(pagemap_fd);
+	close(kpageflags_fd);
+	return ret;
 }

check_large_folios() only checks for large folios without distinguishing between anonymous and file-backed huge pages.

To add huge page type checking, integrate the huge page checks into __check_huge():

1. If hpage_size == pmd_pagesize, check PAGE_IS_HUGE instead of using check_large_folios(), since only the mapping type matters. This identifies PMD-mapped huge pages.

2. Otherwise, use check_large_folios() to detect large folios. This covers mTHP cases.

3. Check the folio flags according to the huge page type.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Suggested-by Zi Yan <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

check_large_folios() only checks for large folios without distinguishing between anonymous and file-backed huge pages.

To add huge page type checking, integrate the huge page checks into __check_huge():

1. If hpage_size == pmd_pagesize, check PAGE_IS_HUGE instead of using check_large_folios(), since only the mapping type matters. This identifies PMD-mapped huge pages.

2. Otherwise, use check_large_folios() to detect large folios. This covers mTHP cases.

3. Check the folio flags according to the huge page type.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Suggested-by Zi Yan <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

Quoted 13 lines · Yeoreum Yun

check_large_folios() only checks for large folios without distinguishing between anonymous and file-backed huge pages.

To add huge page type checking, integrate the huge page checks into __check_huge():

1. If hpage_size == pmd_pagesize, check PAGE_IS_HUGE instead of using check_large_folios(), since only the mapping type matters. This identifies PMD-mapped huge pages.

2. Otherwise, use check_large_folios() to detect large folios. This covers mTHP cases.

Quoted 6 lines

3. Check the folio flags according to the huge page type.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Suggested-by Zi Yan <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

Instead of merging both things (detecting mapping vs. detecting anon vs. file), could we simply perform the anon vs. file change separately?

Doing another pagemap walk that focuses on that should end up with something that is easier to read.

Quoted 21 lines · David Hildenbrand (Arm)

Quoted 13 lines · Yeoreum Yun

check_large_folios() only checks for large folios without distinguishing between anonymous and file-backed huge pages.

To add huge page type checking, integrate the huge page checks into __check_huge():

1. If hpage_size == pmd_pagesize, check PAGE_IS_HUGE instead of using check_large_folios(), since only the mapping type matters. This identifies PMD-mapped huge pages.

2. Otherwise, use check_large_folios() to detect large folios. This covers mTHP cases.

Quoted 6 lines

3. Check the folio flags according to the huge page type.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Suggested-by Zi Yan <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

Quoted 5 lines

Instead of merging both things (detecting mapping vs. detecting anon vs. file), could we simply perform the anon vs. file change separately?

Doing another pagemap walk that focuses on that should end up with something that is easier to read.

Okay. I'll change like below in next-spin:

-------&<-------

tools/testing/selftests/mm/vm_util.c +39 -8

@@ -411,57 +400,78 @@ static bool check_huge_type(uint64_t categories, enum check_huge_type type)
        return false;
 }
 
-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;
+       bool ret = false;
+       int pagemap_fd, kpageflags_fd;
        int nr_pmd_mappings = 0;
+       uint64_t pmd_pagesize, scan_mapping_size;
        uint64_t categories;
+       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");
+
+       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_perror("open pagemap");
 
-       for (; start < end; start += hpage_size) {
+       kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
+       if (kpageflags_fd < 0)
+               ksft_exit_fail_perror("open kpageflags");
+
+       for (; start < end; start += scan_mapping_size) {
                categories = pagemap_scan_get_categories(pagemap_fd, start);
-               if (!(categories & PAGE_IS_HUGE))
+               pfn = pagemap_get_pfn(pagemap_fd, start);
+               if (pfn == -1UL) {
+                       if (!allow_nonpresent)
+                               goto out;
                        continue;
-               if (check_huge_type(categories, type))
+               }
+               if (!check_huge_type(categories, type))
+                       goto out;
+       }
+
+       if (!check_pmd_mapping) {
+               ret = check_large_folios(pagemap_fd, kpageflags_fd,
+                               addr, len, nr_hpages, hpage_size);
+               goto out;
+       }
+
+       for (start = addr; start < end; start += scan_mapping_size) {
+               categories = pagemap_scan_get_categories(pagemap_fd, start);
+               if (categories & PAGE_IS_HUGE)
                        nr_pmd_mappings++;
        }
-       close(pagemap_fd);
 
-       return nr_hpages == nr_pmd_mappings;

Quoted 99 lines · David Hildenbrand (Arm)

Quoted 21 lines · Yeoreum Yun

Quoted 13 lines

check_large_folios() only checks for large folios without distinguishing between anonymous and file-backed huge pages.

To add huge page type checking, integrate the huge page checks into __check_huge():

1. If hpage_size == pmd_pagesize, check PAGE_IS_HUGE instead of using check_large_folios(), since only the mapping type matters. This identifies PMD-mapped huge pages.

2. Otherwise, use check_large_folios() to detect large folios. This covers mTHP cases.

Quoted 6 lines

3. Check the folio flags according to the huge page type.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Suggested-by Zi Yan <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---

Quoted 5 lines

Instead of merging both things (detecting mapping vs. detecting anon vs. file), could we simply perform the anon vs. file change separately?

Doing another pagemap walk that focuses on that should end up with something that is easier to read.

Okay. I'll change like below in next-spin:

-------&<-------

tools/testing/selftests/mm/vm_util.c +39 -8

@@ -411,57 +400,78 @@ static bool check_huge_type(uint64_t categories, enum check_huge_type type)
        return false;
 }
 
-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;
+       bool ret = false;
+       int pagemap_fd, kpageflags_fd;
        int nr_pmd_mappings = 0;
+       uint64_t pmd_pagesize, scan_mapping_size;
        uint64_t categories;
+       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");
+
+       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_perror("open pagemap");
 
-       for (; start < end; start += hpage_size) {
+       kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
+       if (kpageflags_fd < 0)
+               ksft_exit_fail_perror("open kpageflags");
+
+       for (; start < end; start += scan_mapping_size) {
                categories = pagemap_scan_get_categories(pagemap_fd, start);
-               if (!(categories & PAGE_IS_HUGE))
+               pfn = pagemap_get_pfn(pagemap_fd, start);
+               if (pfn == -1UL) {
+                       if (!allow_nonpresent)
+                               goto out;
                        continue;
-               if (check_huge_type(categories, type))
+               }
+               if (!check_huge_type(categories, type))
+                       goto out;
+       }
+
+       if (!check_pmd_mapping) {
+               ret = check_large_folios(pagemap_fd, kpageflags_fd,
+                               addr, len, nr_hpages, hpage_size);
+               goto out;
+       }
+
+       for (start = addr; start < end; start += scan_mapping_size) {
+               categories = pagemap_scan_get_categories(pagemap_fd, start);
+               if (categories & PAGE_IS_HUGE)
                        nr_pmd_mappings++;
        }
-       close(pagemap_fd);
 
-       return nr_hpages == nr_pmd_mappings;

tools/testing/selftests/mm/vm_util.c static bool check_huge_type(uint64_t categories, enum check_huge_type type) · line 467

Quoted 10 lines

tools/testing/selftests/mm/vm_util.c +8 -0

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

I'd leave existing __check_huge() mostly alone, and instead have an additional function that checks the type.

Essentially a __check_type() or sth that we run after the large folio / pmd check.

Quoted 87 lines · Yeoreum Yun

Quoted 72 lines

Okay. I'll change like below in next-spin:

-------&<-------

tools/testing/selftests/mm/vm_util.c +39 -8

@@ -411,57 +400,78 @@ static bool check_huge_type(uint64_t categories, enum check_huge_type type)
        return false;
 }
 
-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;
+       bool ret = false;
+       int pagemap_fd, kpageflags_fd;
        int nr_pmd_mappings = 0;
+       uint64_t pmd_pagesize, scan_mapping_size;
        uint64_t categories;
+       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");
+
+       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_perror("open pagemap");
 
-       for (; start < end; start += hpage_size) {
+       kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
+       if (kpageflags_fd < 0)
+               ksft_exit_fail_perror("open kpageflags");
+
+       for (; start < end; start += scan_mapping_size) {
                categories = pagemap_scan_get_categories(pagemap_fd, start);
-               if (!(categories & PAGE_IS_HUGE))
+               pfn = pagemap_get_pfn(pagemap_fd, start);
+               if (pfn == -1UL) {
+                       if (!allow_nonpresent)
+                               goto out;
                        continue;
-               if (check_huge_type(categories, type))
+               }
+               if (!check_huge_type(categories, type))
+                       goto out;
+       }
+
+       if (!check_pmd_mapping) {
+               ret = check_large_folios(pagemap_fd, kpageflags_fd,
+                               addr, len, nr_hpages, hpage_size);
+               goto out;
+       }
+
+       for (start = addr; start < end; start += scan_mapping_size) {
+               categories = pagemap_scan_get_categories(pagemap_fd, start);
+               if (categories & PAGE_IS_HUGE)
                        nr_pmd_mappings++;
        }
-       close(pagemap_fd);
 
-       return nr_hpages == nr_pmd_mappings;

tools/testing/selftests/mm/vm_util.c static bool check_huge_type(uint64_t categories, enum check_huge_type type) · line 467

Quoted 10 lines

tools/testing/selftests/mm/vm_util.c +8 -0

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

I'd leave existing __check_huge() mostly alone, and instead have an additional function that checks the type.

Quoted 1 line

Essentially a __check_type() or sth that we run after the large folio / pmd check.

So, You mean like this?

-------&<-------

(quoted diff) +0 -1

-enum check_huge_type {

Quoted 101 lines

Quoted 87 lines · Yeoreum Yun

Quoted 72 lines

Okay. I'll change like below in next-spin:

-------&<-------

tools/testing/selftests/mm/vm_util.c +39 -8

@@ -411,57 +400,78 @@ static bool check_huge_type(uint64_t categories, enum check_huge_type type)
        return false;
 }
 
-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;
+       bool ret = false;
+       int pagemap_fd, kpageflags_fd;
        int nr_pmd_mappings = 0;
+       uint64_t pmd_pagesize, scan_mapping_size;
        uint64_t categories;
+       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");
+
+       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_perror("open pagemap");
 
-       for (; start < end; start += hpage_size) {
+       kpageflags_fd = open(KPAGEFLAGS_PATH, O_RDONLY);
+       if (kpageflags_fd < 0)
+               ksft_exit_fail_perror("open kpageflags");
+
+       for (; start < end; start += scan_mapping_size) {
                categories = pagemap_scan_get_categories(pagemap_fd, start);
-               if (!(categories & PAGE_IS_HUGE))
+               pfn = pagemap_get_pfn(pagemap_fd, start);
+               if (pfn == -1UL) {
+                       if (!allow_nonpresent)
+                               goto out;
                        continue;
-               if (check_huge_type(categories, type))
+               }
+               if (!check_huge_type(categories, type))
+                       goto out;
+       }
+
+       if (!check_pmd_mapping) {
+               ret = check_large_folios(pagemap_fd, kpageflags_fd,
+                               addr, len, nr_hpages, hpage_size);
+               goto out;
+       }
+
+       for (start = addr; start < end; start += scan_mapping_size) {
+               categories = pagemap_scan_get_categories(pagemap_fd, start);
+               if (categories & PAGE_IS_HUGE)
                        nr_pmd_mappings++;
        }
-       close(pagemap_fd);
 
-       return nr_hpages == nr_pmd_mappings;

tools/testing/selftests/mm/vm_util.c static bool check_huge_type(uint64_t categories, enum check_huge_type type) · line 467

Quoted 10 lines

tools/testing/selftests/mm/vm_util.c +8 -0

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

I'd leave existing __check_huge() mostly alone, and instead have an additional function that checks the type.

Quoted 1 line

Essentially a __check_type() or sth that we run after the large folio / pmd check.

So, You mean like this?

-------&<-------

(quoted diff) +3 -3

-enum check_huge_type {
-       CHECK_HUGE_ANON,
-       CHECK_HUGE_FILE,
+enum check_type {
+       CHECK_TYPE_ANON,
+       CHECK_TYPE_FILE,
 };

Review

Quoted 3 lines

(quoted diff) +2 -1

-static bool check_huge_type(uint64_t categories, enum check_huge_type type)
+static bool __check_type(void *addr, size_t len, uint64_t page_size,
+               bool allow_nonpresent, enum check_type type)

As discussed off-list, maybe we can avoid the allow_nonpresent handling!

check_huge_shmem() was required to distinguish shmem huge pages because /proc/self/smaps reports them using a dedicated “ShmemPmdMapped” entry, as opposed to “FilePmdMapped” for file-backed huge pages.

Now that /proc/self/smaps is no longer used to detect huge pages and /proc/kpageflags is used instead, it is sufficient to distinguish between file-backed and anonymous pages since the ShmemPmdMapped is also kind of file-backed.

Therefore, remove check_huge_shmem() and use check_huge_file() instead and cleanup khugepaged's check_huge operation in mem_ops.

Suggested-by David Hildenbrand (Arm) <[email protected]>

Reviewed-by Baolin Wang <[email protected]>

Acked-by Zi Yan <[email protected]>

Acked-by Lorenzo Stoakes (ARM) <[email protected]>

Acked-by David Hildenbrand (Arm) <[email protected]>

Signed-off-by Yeoreum Yun <[email protected]>

---