From: "Kiryl Shutsemau (Meta)" <[email protected]> collapse_swapin_single_pte() and collapse_max_ptes_swap() page a range out and then require smaps to report exactly the count they asked for. Two things keep it from arriving. MADV_PAGEOUT is best effort, so the count often turns up a moment late. And wait_for_scan() leaves MADV_HUGEPAGE behind, so khugepaged is still working on the range: collapsing one with up to max_ptes_swap pages swapped out means reading them back in, and the daemon empties the swap as fast as the case fills it. On arm64 with 64K pages, where max_ptes_swap is 1024 pages, that is 64M a step and the case loses:
# Swapout 1024 of 8192 pages... Fail not ok 10 collapse_max_ptes_swap Ask again for up to two seconds, with the range held out of the daemon's reach while asking. The collapse each case runs next puts MADV_HUGEPAGE back, so only the setup is affected. If the pages still will not go, skip. is_swap_enabled() covers a machine with no swap; what is left -- swap too small, full, capped by a memcg, busy with writeback -- is not the kernel under test refusing. An error from madvise() itself still ends the run. Assisted-by: Claude-Code:claude-opus-5 Signed-off-by: Kiryl Shutsemau (Meta) <[email protected]> --- tools/testing/selftests/mm/khugepaged.c | 53 +++++++++++++++++++------ 1 file changed, 41 insertions(+), 12 deletions(-) diff --git a/tools/testing/selftests/mm/khugepaged.c b/tools/testing/selftests/mm/khugepaged.c index c049ac997def..8458cd2ff0df 100644 --- a/tools/testing/selftests/mm/khugepaged.c +++ b/tools/testing/selftests/mm/khugepaged.c @@ -241,6 +241,41 @@ static bool check_swap(void *addr, unsigned long size) return swap; } +/* + * Page the range out and wait for the swap count to say so. + * + * Two things get in the way. MADV_PAGEOUT is best effort: + * shrink_folio_list() leaves a folio alone when it cannot reclaim it right + * away, and one still under writeback from an earlier pageout is the common + * case, so the count the caller asks for arrives a moment later. And a range + * an earlier collapse left MADV_HUGEPAGE is one khugepaged is still working + * on: collapsing a range with up to max_ptes_swap pages swapped out means + * reading those pages back in, so the daemon undoes the pageout as fast as it + * is asked for. Keep the range out of its reach; the collapse the caller runs + * next puts MADV_HUGEPAGE back. + * + * Failing to get the pages out is the machine's answer, not the kernel's -- + * swap too small, swap full, a memcg cap, a folio still under writeback -- so + * callers skip rather than fail. An error from madvise() is different, and + * ends the run here. + */ +static bool swapout_range(void *p, unsigned long size) +{ + int i; + + if (madvise(p, size, MADV_NOHUGEPAGE)) + ksft_exit_fail_perror("madvise(MADV_NOHUGEPAGE)"); + + for (i = 0; i < 40; i++) { + if (madvise(p, size, MADV_PAGEOUT)) + ksft_exit_fail_perror("madvise(MADV_PAGEOUT)"); + if (check_swap(p, size)) + return true; + usleep(50 * 1000); + } + return false; +} + static void *alloc_mapping(int nr) { void *p; @@ -855,12 +890,10 @@ static void collapse_swapin_single_pte(struct collapse_context *c, struct mem_op p = ops->setup_area(1); ops->fault(p, 0, hpage_pmd_size); - if (madvise(p, page_size, MADV_PAGEOUT)) - ksft_exit_fail_perror("madvise(MADV_PAGEOUT)"); - if (check_swap(p, page_size)) { + if (swapout_range(p, page_size)) { success("OK"); } else { - fail("Fail"); + skip("Could not swap out"); goto out; } @@ -887,12 +920,10 @@ static void collapse_max_ptes_swap(struct collapse_context *c, struct mem_ops *o p = ops->setup_area(1); ops->fault(p, 0, hpage_pmd_size); - if (madvise(p, (max_ptes_swap + 1) * page_size, MADV_PAGEOUT)) - ksft_exit_fail_perror("madvise(MADV_PAGEOUT)"); - if (check_swap(p, (max_ptes_swap + 1) * page_size)) { + if (swapout_range(p, (max_ptes_swap + 1) * page_size)) { success("OK"); } else { - fail("Fail"); + skip("Could not swap out"); goto out; } @@ -904,12 +935,10 @@ static void collapse_max_ptes_swap(struct collapse_context *c, struct mem_ops *o ops->fault(p, 0, hpage_pmd_size); ksft_print_msg("Swapout %d of %d pages...", max_ptes_swap, hpage_pmd_nr); - if (madvise(p, max_ptes_swap * page_size, MADV_PAGEOUT)) - ksft_exit_fail_perror("madvise(MADV_PAGEOUT)"); - if (check_swap(p, max_ptes_swap * page_size)) { + if (swapout_range(p, max_ptes_swap * page_size)) { success("OK"); } else { - fail("Fail"); + skip("Could not swap out"); goto out; } -- 2.54.0
