[0/4] large folios swap-in: handle refault cases first

Message

Barry Song April 2, 2024, 7:32 a.m. UTC

From: Barry Song <[e-mail]>

This patch is extracted from the large folio swapin series[1], focusing
initially on handling the scenario where large folios are found in
the swap cache. This should facilitate code review and enable sooner
inclusion of this portion into the MM tree.

It relies on Ryan's swap-out series[2], leveraging the helper function
swap_pte_batch() introduced by that series.

Presently, do_swap_page only encounters a large folio in the swap
cache before the large folio is released by vmscan. However, the code
should remain equally useful once we support large folio swap-in via
swapin_readahead(). This approach can effectively reduce page faults
and eliminate most redundant checks and early exits for MTE restoration
in recent MTE patchset[3].

The large folio swap-in for SWP_SYNCHRONOUS_IO and swapin_readahead()
will be split into separate patch sets and sent at a later time.

Differences with the original large folios swap-in series
 - collect r-o-b, acked;
 - rename swap_nr_free to swap_free_nr, according to Ryan;
 - limit the maximum kernel stack usage for swap_free_nr, Ryan;
 - add output argument in swap_pte_batch to expose if all entries are
   exclusive
 - many clean refinements, handle the corner case folio's virtual addr
   might not be naturally aligned

[1] https://lore.kernel.org/linux-mm/[e-mail]/
[2] https://lore.kernel.org/linux-mm/[e-mail]/
[3] https://lore.kernel.org/linux-mm/[e-mail]/

Barry Song (1):
  mm: swap_pte_batch: add an output argument to reture if all swap
    entries are exclusive

Chuanhua Han (3):
  mm: swap: introduce swap_free_nr() for batched swap_free()
  mm: swap: make should_try_to_free_swap() support large-folio
  mm: swap: entirely map large folios found in swapcache

 include/linux/swap.h |  5 ++++
 mm/internal.h        |  5 +++-
 mm/madvise.c         |  2 +-
 mm/memory.c          | 65 ++++++++++++++++++++++++++++++++++----------
 mm/swapfile.c        | 51 ++++++++++++++++++++++++++++++++++
 5 files changed, 112 insertions(+), 16 deletions(-)

Appendix:

The following program can generate numerous instances where large folios
are hit in the swap cache if we enable 64KiB mTHP,

#echo always > /sys/kernel/mm/transparent_hugepage/hugepages-64kB/enabled

#define DATA_SIZE (128UL * 1024)
#define PAGE_SIZE (4UL * 1024)
#define LARGE_FOLIO_SIZE (64UL * 1024)

static void *write_data(void *addr)
{
	unsigned long i;

	for (i = 0; i < DATA_SIZE; i += PAGE_SIZE)
		memset(addr + i, (char)i, PAGE_SIZE);
}

static void *read_data(void *addr)
{
	unsigned long i;

	for (i = 0; i < DATA_SIZE; i += PAGE_SIZE) {
		if (*((char *)addr + i) != (char)i) {
			perror("mismatched data");
			_exit(-1);
		}
	}
}

static void *pgout_data(void *addr)
{
	madvise(addr, DATA_SIZE, MADV_PAGEOUT);
}

int main(int argc, char **argv)
{
	for (int i = 0; i < 10000; i++) {
		pthread_t tid1, tid2;
		void *addr = mmap(NULL, DATA_SIZE * 2, PROT_READ | PROT_WRITE,
				MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
		unsigned long aligned_addr = ((unsigned long)addr + LARGE_FOLIO_SIZE) &
				~(LARGE_FOLIO_SIZE - 1);

		if (addr == MAP_FAILED) {
			perror("fail to malloc");
			return -1;
		}

		write_data(aligned_addr);

		if (pthread_create(&tid1, NULL, pgout_data, (void *)aligned_addr)) {
			perror("fail to pthread_create");
			return -1;
		}

		if (pthread_create(&tid2, NULL, read_data, (void *)aligned_addr)) {
			perror("fail to pthread_create");
			return -1;
		}

		pthread_join(tid1, NULL);
		pthread_join(tid2, NULL);
		munmap(addr, DATA_SIZE * 2);
	}

	return 0;
}