archives/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-03-08 03:24:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

selftests/mm: split_huge_page_test: cleanups for split_pte_mapped_thp test

Browse source 
There is room for improvement, so let's clean up a bit:

(1) Define "4" as a constant.

(2) SKIP if we fail to allocate all THPs (e.g., fragmented) and add
    recovery code for all other failure cases: no need to exit the test.

(3) Rename "len" to thp_area_size, and "one_page" to "thp_area".

(4) Allocate a new area "page_area" into which we will mremap the
    pages; add "page_area_size". Now we can easily merge the two
    mremap instances into a single one.

(5) Iterate THPs instead of bytes when checking for missed THPs after
    mremap.

(6) Rename "pte_mapped2" to "tmp", used to verify mremap(MAP_FIXED)
    result.

(7) Split the corruption test from the failed-split test, so we can just
    iterate bytes vs. thps naturally.

(8) Extend comments and clarify why we are using mremap in the first
    place.

Link: https://lkml.kernel.org/r/20250903070253.34556-3-david@redhat.com
Signed-off-by: David Hildenbrand <david@redhat.com>
Reviewed-by: Zi Yan <ziy@nvidia.com>
Reviewed-by: Wei Yang <richard.weiyang@gmail.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Cc: Mariano Pache <npache@redhat.com>
Cc: Ryan Roberts <ryan.roberts@arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
David Hildenbrand 2025-09-03 09:02:53 +02:00 • committed by Andrew Morton
parent 0d0e03d5b8
commit 24a3c7af3b
1 changed files with 75 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

125
tools/testing/selftests/mm/split_huge_page_test.c
View file

@ -389,67 +389,92 @@ static void split_pmd_thp_to_order(int order)
static void split_pte_mapped_thp(void)
{
char *one_page, *pte_mapped, *pte_mapped2;
size_t len = 4 * pmd_pagesize;
uint64_t thp_size;
const size_t nr_thps = 4;
const size_t thp_area_size = nr_thps * pmd_pagesize;
const size_t page_area_size = nr_thps * pagesize;
char *thp_area, *tmp, *page_area = MAP_FAILED;
size_t i;
one_page = mmap((void *)(1UL << 30), len, PROT_READ | PROT_WRITE,
thp_area = mmap((void *)(1UL << 30), thp_area_size, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (one_page == MAP_FAILED)
ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno));
madvise(one_page, len, MADV_HUGEPAGE);
for (i = 0; i < len; i++)
one_page[i] = (char)i;
if (!check_huge_anon(one_page, 4, pmd_pagesize))
ksft_exit_fail_msg("No THP is allocated\n");
/* remap the first pagesize of first THP */
pte_mapped = mremap(one_page, pagesize, pagesize, MREMAP_MAYMOVE);
/* remap the Nth pagesize of Nth THP */
for (i = 1; i < 4; i++) {
pte_mapped2 = mremap(one_page + pmd_pagesize * i + pagesize * i,
pagesize, pagesize,
MREMAP_MAYMOVE|MREMAP_FIXED,
pte_mapped + pagesize * i);
if (pte_mapped2 == MAP_FAILED)
ksft_exit_fail_msg("mremap failed: %s\n", strerror(errno));
if (thp_area == MAP_FAILED) {
ksft_test_result_fail("Fail to allocate memory: %s\n", strerror(errno));
return;
}
/* smap does not show THPs after mremap, use kpageflags instead */
thp_size = 0;
for (i = 0; i < pagesize * 4; i++)
if (i % pagesize == 0 &&
is_backed_by_folio(&pte_mapped[i], pmd_order, pagemap_fd, kpageflags_fd))
thp_size++;
madvise(thp_area, thp_area_size, MADV_HUGEPAGE);
if (thp_size != 4)
ksft_exit_fail_msg("Some THPs are missing during mremap\n");
for (i = 0; i < thp_area_size; i++)
thp_area[i] = (char)i;
/* split all remapped THPs */
write_debugfs(PID_FMT, getpid(), (uint64_t)pte_mapped,
(uint64_t)pte_mapped + pagesize * 4, 0);
/* smap does not show THPs after mremap, use kpageflags instead */
thp_size = 0;
for (i = 0; i < pagesize * 4; i++) {
if (pte_mapped[i] != (char)i)
ksft_exit_fail_msg("%ld byte corrupted\n", i);
if (i % pagesize == 0 &&
!is_backed_by_folio(&pte_mapped[i], 0, pagemap_fd, kpageflags_fd))
thp_size++;
if (!check_huge_anon(thp_area, nr_thps, pmd_pagesize)) {
ksft_test_result_skip("Not all THPs allocated\n");
goto out;
}
if (thp_size)
ksft_exit_fail_msg("Still %ld THPs not split\n", thp_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
* replace the PMD mappings in the thp_area by PTE mappings first,
* but leaving the THP unsplit, to then create a page-sized hole in
* the thp_area.
* We will then manually trigger splitting of all THPs through the
* single mremap'ed pages of each THP in the page_area.
*/
page_area = mmap(NULL, page_area_size, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (page_area == MAP_FAILED) {
ksft_test_result_fail("Fail to allocate memory: %s\n", strerror(errno));
goto out;
}
for (i = 0; i < nr_thps; i++) {
tmp = mremap(thp_area + pmd_pagesize * i + pagesize * i,
pagesize, pagesize, MREMAP_MAYMOVE|MREMAP_FIXED,
page_area + pagesize * i);
if (tmp != MAP_FAILED)
continue;
ksft_test_result_fail("mremap failed: %s\n", strerror(errno));
goto out;
}
/*
* Verify that our THPs were not split yet. Note that
* check_huge_anon() cannot be used as it checks for PMD mappings.
*/
for (i = 0; i < nr_thps; i++) {
if (is_backed_by_folio(page_area + i * pagesize, pmd_order,
pagemap_fd, kpageflags_fd))
continue;
ksft_test_result_fail("THP %zu missing after mremap\n", i);
goto out;
}
/* Split all THPs through the remapped pages. */
write_debugfs(PID_FMT, getpid(), (uint64_t)page_area,
(uint64_t)page_area + page_area_size, 0);
/* Corruption during mremap or split? */
for (i = 0; i < page_area_size; i++) {
if (page_area[i] == (char)i)
continue;
ksft_test_result_fail("%zu byte corrupted\n", i);
goto out;
}
/* Split failed? */
for (i = 0; i < nr_thps; i++) {
if (is_backed_by_folio(page_area + i * pagesize, 0,
pagemap_fd, kpageflags_fd))
continue;
ksft_test_result_fail("THP %zu not split\n", i);
}
ksft_test_result_pass("Split PTE-mapped huge pages successful\n");
munmap(one_page, len);
out:
munmap(thp_area, thp_area_size);
if (page_area != MAP_FAILED)
munmap(page_area, page_area_size);
}
static void split_file_backed_thp(int order)