Commit 12e8a2fa authored by Miaohe Lin's avatar Miaohe Lin Committed by Andrew Morton
Browse files

selftests/mm: add memory failure clean pagecache test 

This patch adds a new testcase to validate memory failure handling for
clean pagecache.  This test performs similar operations as anonymous pages
except allocating memory using mmap() with a file fd.

This test helps ensure that memory failure handling for clean pagecache
works correctly, including unchanged page content, page isolation, and
recovery paths.

Link: https://lkml.kernel.org/r/20260206031639.2707102-3-linmiaohe@huawei.com


Signed-off-by: default avatarMiaohe Lin <linmiaohe@huawei.com>
Reported-by: default avatarkernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202601221142.mDWA1ucw-lkp@intel.com/


Cc: David Hildenbrand <david@kernel.org>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Cc: Mark Brown <broonie@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Naoya Horiguchi <nao.horiguchi@gmail.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent ff4ef2fb

tools/testing/selftests/mm/memory-failure.c

+66 −0
Original line number Diff line number Diff line
@@ -10,10 +10,14 @@ 
#include <sys/mman.h>

#include <linux/mman.h>

#include <linux/string.h>

#include <unistd.h>

#include <signal.h>

#include <setjmp.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/vfs.h>

#include <linux/magic.h>

#include <errno.h>



#include "vm_util.h"
@@ -24,7 +28,9 @@ enum inject_type { 


enum result_type {

	MADV_HARD_ANON,

	MADV_HARD_CLEAN_PAGECACHE,

	MADV_SOFT_ANON,

	MADV_SOFT_CLEAN_PAGECACHE,

};



static jmp_buf signal_jmp_buf;
@@ -154,6 +160,8 @@ static void check(struct __test_metadata *_metadata, FIXTURE_DATA(memory_failure 


	switch (type) {

	case MADV_SOFT_ANON:

	case MADV_HARD_CLEAN_PAGECACHE:

	case MADV_SOFT_CLEAN_PAGECACHE:

		/* It is not expected to receive a SIGBUS signal. */

		ASSERT_EQ(setjmp, 0);
@@ -236,4 +244,62 @@ TEST_F(memory_failure, anon) 
	ASSERT_EQ(munmap(addr, self->page_size), 0);

}



/* Borrowed from mm/gup_longterm.c. */

static int get_fs_type(int fd)

{

	struct statfs fs;

	int ret;



	do {

		ret = fstatfs(fd, &fs);

	} while (ret && errno == EINTR);



	return ret ? 0 : (int)fs.f_type;

}



TEST_F(memory_failure, clean_pagecache)

{

	const char *fname = "./clean-page-cache-test-file";

	int fd;

	char *addr;

	int ret;

	int fs_type;



	fd = open(fname, O_RDWR | O_CREAT, 0664);

	if (fd < 0)

		SKIP(return, "failed to open test file.\n");

	unlink(fname);

	ftruncate(fd, self->page_size);

	fs_type = get_fs_type(fd);

	if (!fs_type || fs_type == TMPFS_MAGIC)

		SKIP(return, "unsupported filesystem :%x\n", fs_type);



	addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

		    MAP_SHARED, fd, 0);

	if (addr == MAP_FAILED)

		SKIP(return, "mmap failed, not enough memory.\n");

	memset(addr, 0xce, self->page_size);

	fsync(fd);



	prepare(_metadata, self, addr);



	ret = sigsetjmp(signal_jmp_buf, 1);

	if (!self->triggered) {

		self->triggered = true;

		ASSERT_EQ(variant->inject(self, addr), 0);

		FORCE_READ(*addr);

	}



	if (variant->type == MADV_HARD)

		check(_metadata, self, addr, MADV_HARD_CLEAN_PAGECACHE, ret);

	else

		check(_metadata, self, addr, MADV_SOFT_CLEAN_PAGECACHE, ret);



	cleanup(_metadata, self, addr);



	ASSERT_EQ(munmap(addr, self->page_size), 0);



	ASSERT_EQ(close(fd), 0);

}



TEST_HARNESS_MAIN