Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477// SPDX-License-Identifier: GPL-2.0/* * Memory-failure functional tests. * * Author(s): Miaohe Lin <linmiaohe@huawei.com> */
#include "../kselftest_harness.h"
#include <sys/mman.h>#include <linux/mman.h>#include <linux/string.h>#include <unistd.h>#include <signal.h>#include <setjmp.h>#include <fcntl.h>#include <sys/vfs.h>#include <linux/magic.h>#include <errno.h>
#include "vm_util.h"
enum inject_type { MADV_HARD, MADV_SOFT,};
enum result_type { MADV_HARD_ANON, MADV_HARD_CLEAN_PAGECACHE, MADV_HARD_DIRTY_PAGECACHE, MADV_HARD_CLEAN_SHMEM, MADV_HARD_DIRTY_SHMEM, MADV_SOFT_ANON, MADV_SOFT_CLEAN_PAGECACHE, MADV_SOFT_DIRTY_PAGECACHE, MADV_SOFT_CLEAN_SHMEM, MADV_SOFT_DIRTY_SHMEM, READ_ERROR,};
static jmp_buf signal_jmp_buf;static siginfo_t siginfo;const char *pagemap_proc = "/proc/self/pagemap";const char *kpageflags_proc = "/proc/kpageflags";
FIXTURE(memory_failure){ unsigned long page_size; unsigned long corrupted_size; unsigned long pfn; int pagemap_fd; int kpageflags_fd; bool injection_attempted;};
FIXTURE_VARIANT(memory_failure){ enum inject_type type; int (*inject)(FIXTURE_DATA(memory_failure) * self, void *vaddr);};
static int madv_hard_inject(FIXTURE_DATA(memory_failure) * self, void *vaddr){ return madvise(vaddr, self->page_size, MADV_HWPOISON);}
FIXTURE_VARIANT_ADD(memory_failure, madv_hard){ .type = MADV_HARD, .inject = madv_hard_inject,};
static int madv_soft_inject(FIXTURE_DATA(memory_failure) * self, void *vaddr){ return madvise(vaddr, self->page_size, MADV_SOFT_OFFLINE);}
FIXTURE_VARIANT_ADD(memory_failure, madv_soft){ .type = MADV_SOFT, .inject = madv_soft_inject,};
static void sigbus_action(int signo, siginfo_t *si, void *args){ memcpy(&siginfo, si, sizeof(siginfo_t)); siglongjmp(signal_jmp_buf, 1);}
static int setup_sighandler(void){ struct sigaction sa = { .sa_sigaction = sigbus_action, .sa_flags = SA_SIGINFO, };
return sigaction(SIGBUS, &sa, NULL);}
FIXTURE_SETUP(memory_failure){ memset(self, 0, sizeof(*self));
self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);
memset(&siginfo, 0, sizeof(siginfo)); if (setup_sighandler()) SKIP(return, "setup sighandler failed.\n");
self->pagemap_fd = open(pagemap_proc, O_RDONLY); if (self->pagemap_fd == -1) SKIP(return, "open %s failed.\n", pagemap_proc);
self->kpageflags_fd = open(kpageflags_proc, O_RDONLY); if (self->kpageflags_fd == -1) SKIP(return, "open %s failed.\n", kpageflags_proc);}
static void teardown_sighandler(void){ struct sigaction sa = { .sa_handler = SIG_DFL, .sa_flags = SA_SIGINFO, };
sigaction(SIGBUS, &sa, NULL);}
static void prepare(struct __test_metadata *_metadata, FIXTURE_DATA(memory_failure) * self, void *vaddr){ self->pfn = pagemap_get_pfn(self->pagemap_fd, vaddr); ASSERT_NE(self->pfn, -1UL);
ASSERT_EQ(get_hardware_corrupted_size(&self->corrupted_size), 0);}
static bool check_memory(void *vaddr, unsigned long size){ char buf[64];
memset(buf, 0xce, sizeof(buf)); while (size >= sizeof(buf)) { if (memcmp(vaddr, buf, sizeof(buf))) return false; size -= sizeof(buf); vaddr += sizeof(buf); }
return true;}
static void check(struct __test_metadata *_metadata, FIXTURE_DATA(memory_failure) * self, void *vaddr, enum result_type type, int setjmp){ unsigned long size; uint64_t pfn_flags;
switch (type) { case MADV_SOFT_ANON: case MADV_HARD_CLEAN_PAGECACHE: case MADV_SOFT_CLEAN_PAGECACHE: case MADV_SOFT_DIRTY_PAGECACHE: case MADV_SOFT_DIRTY_SHMEM: /* The page content should remain unchanged. */ ASSERT_TRUE(check_memory(vaddr, self->page_size)); /* FALLTHROUGH */ case MADV_HARD_CLEAN_SHMEM: case MADV_SOFT_CLEAN_SHMEM: /* It is not expected to receive a SIGBUS signal. */ ASSERT_EQ(setjmp, 0);
/* The backing pfn of addr should have changed. */ ASSERT_NE(pagemap_get_pfn(self->pagemap_fd, vaddr), self->pfn); break; case MADV_HARD_ANON: case MADV_HARD_DIRTY_PAGECACHE: case MADV_HARD_DIRTY_SHMEM: case READ_ERROR: /* The SIGBUS signal should have been received. */ ASSERT_EQ(setjmp, 1);
/* Check if siginfo contains correct SIGBUS context. */ ASSERT_EQ(siginfo.si_signo, SIGBUS); ASSERT_EQ(siginfo.si_code, BUS_MCEERR_AR); ASSERT_EQ(1UL << siginfo.si_addr_lsb, self->page_size); ASSERT_EQ(siginfo.si_addr, vaddr);
/* XXX Check backing pte is hwpoison entry when supported. */ ASSERT_TRUE(pagemap_is_swapped(self->pagemap_fd, vaddr)); break; default: SKIP(return, "unexpected inject type %d.\n", type); }
/* Check if the value of HardwareCorrupted has increased. */ ASSERT_EQ(get_hardware_corrupted_size(&size), 0); ASSERT_EQ(size, self->corrupted_size + self->page_size / 1024);
/* Check if HWPoison flag is set. */ ASSERT_EQ(pageflags_get(self->pfn, self->kpageflags_fd, &pfn_flags), 0); ASSERT_EQ(pfn_flags & KPF_HWPOISON, KPF_HWPOISON);}
static void cleanup(struct __test_metadata *_metadata, FIXTURE_DATA(memory_failure) * self){ unsigned long size; uint64_t pfn_flags;
ASSERT_EQ(unpoison_memory(self->pfn), 0);
/* Check if HWPoison flag is cleared. */ ASSERT_EQ(pageflags_get(self->pfn, self->kpageflags_fd, &pfn_flags), 0); ASSERT_NE(pfn_flags & KPF_HWPOISON, KPF_HWPOISON);
/* Check if the value of HardwareCorrupted has decreased. */ ASSERT_EQ(get_hardware_corrupted_size(&size), 0); ASSERT_EQ(size, self->corrupted_size);}
FIXTURE_TEARDOWN(memory_failure){ /* * Injection may poison the page before failing or delivering SIGBUS, so * clean up after every injection attempt. */ if (self->injection_attempted) cleanup(_metadata, self);
close(self->kpageflags_fd); close(self->pagemap_fd); teardown_sighandler();}
TEST_F(memory_failure, anon){ char *addr; int ret;
addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); if (addr == MAP_FAILED) SKIP(return, "mmap failed, not enough memory.\n"); memset(addr, 0xce, self->page_size);
prepare(_metadata, self, addr);
ret = sigsetjmp(signal_jmp_buf, 1); if (!self->injection_attempted) { self->injection_attempted = true; ASSERT_EQ(variant->inject(self, addr), 0); FORCE_READ(*addr); }
if (variant->type == MADV_HARD) check(_metadata, self, addr, MADV_HARD_ANON, ret); else check(_metadata, self, addr, MADV_SOFT_ANON, ret);
ASSERT_EQ(munmap(addr, self->page_size), 0);}
static int prepare_file(const char *fname, unsigned long size){ int fd;
fd = open(fname, O_RDWR | O_CREAT, 0664); if (fd >= 0) { unlink(fname); ftruncate(fd, size); } return fd;}
static int prepare_shmem(const char *fname, unsigned long size){ int fd;
fd = memfd_create(fname, 0); if (fd < 0) return -1; if (ftruncate(fd, size) < 0) { close(fd); return -1; } return fd;}
/* 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){ int fd; char *addr; int ret; int fs_type;
fd = prepare_file("./clean-page-cache-test-file", self->page_size); if (fd < 0) SKIP(return, "failed to open test file.\n"); fs_type = get_fs_type(fd); if (!fs_type || fs_type == TMPFS_MAGIC) { close(fd); 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->injection_attempted) { self->injection_attempted = 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);
ASSERT_EQ(munmap(addr, self->page_size), 0);
ASSERT_EQ(close(fd), 0);}
TEST_F(memory_failure, dirty_pagecache){ int fd; char *addr; int ret; int fs_type;
fd = prepare_file("./dirty-page-cache-test-file", self->page_size); if (fd < 0) SKIP(return, "failed to open test file.\n"); fs_type = get_fs_type(fd); /* * MADV_HARD poisoning of dirty page-cache data records an expected * -EIO in the file mapping. NFS reports this error on close(), so * skip this variant. */ if (!fs_type || fs_type == TMPFS_MAGIC || (fs_type == NFS_SUPER_MAGIC && variant->type == MADV_HARD)) { close(fd); 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);
prepare(_metadata, self, addr);
ret = sigsetjmp(signal_jmp_buf, 1); if (!self->injection_attempted) { self->injection_attempted = true; ASSERT_EQ(variant->inject(self, addr), 0); FORCE_READ(*addr); }
if (variant->type == MADV_HARD) check(_metadata, self, addr, MADV_HARD_DIRTY_PAGECACHE, ret); else check(_metadata, self, addr, MADV_SOFT_DIRTY_PAGECACHE, ret);
ASSERT_EQ(munmap(addr, self->page_size), 0);
ASSERT_EQ(close(fd), 0);}
TEST_F(memory_failure, dirty_shmem){ int fd; char *addr; int ret;
fd = prepare_shmem("shmem-file", self->page_size); if (fd < 0) SKIP(return, "failed to open test shmem-file.\n");
addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (addr == MAP_FAILED) { close(fd); SKIP(return, "mmap failed, not enough memory.\n"); } memset(addr, 0xce, self->page_size);
prepare(_metadata, self, addr);
ret = sigsetjmp(signal_jmp_buf, 1); if (!ret && !self->injection_attempted) { self->injection_attempted = true; ASSERT_EQ(variant->inject(self, addr), 0); }
if (variant->type == MADV_HARD) { check(_metadata, self, addr, MADV_HARD_DIRTY_SHMEM, ret); ret = sigsetjmp(signal_jmp_buf, 1); if (ret == 0) FORCE_READ(*addr); check(_metadata, self, addr, READ_ERROR, ret); } else { check(_metadata, self, addr, MADV_SOFT_DIRTY_SHMEM, ret); }
ASSERT_EQ(munmap(addr, self->page_size), 0);
ASSERT_EQ(close(fd), 0);}
TEST_F(memory_failure, clean_shmem){ int fd; char *addr; int ret;
fd = prepare_shmem("shmem-file", self->page_size); if (fd < 0) SKIP(return, "failed to open test shmem-file.\n");
addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (addr == MAP_FAILED) { close(fd); SKIP(return, "mmap failed, not enough memory.\n"); } FORCE_READ(*addr);
prepare(_metadata, self, addr);
ret = sigsetjmp(signal_jmp_buf, 1); if (!ret && !self->injection_attempted) { self->injection_attempted = true; ASSERT_EQ(variant->inject(self, addr), 0); }
if (variant->type == MADV_HARD) { check(_metadata, self, addr, MADV_HARD_CLEAN_SHMEM, ret); ret = sigsetjmp(signal_jmp_buf, 1); if (ret == 0) FORCE_READ(*addr); check(_metadata, self, addr, READ_ERROR, ret); } else { /* Test the address accessability without check_memory(). */ FORCE_READ(*addr); check(_metadata, self, addr, MADV_SOFT_CLEAN_SHMEM, ret); }
ASSERT_EQ(munmap(addr, self->page_size), 0);
ASSERT_EQ(close(fd), 0);}
TEST_HARNESS_MAIN