memory-failure.c 48.7 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * Copyright (C) 2008, 2009 Intel Corporation
 * Authors: Andi Kleen, Fengguang Wu
 *
 * This software may be redistributed and/or modified under the terms of
 * the GNU General Public License ("GPL") version 2 only as published by the
 * Free Software Foundation.
 *
 * High level machine check handler. Handles pages reported by the
10
 * hardware as being corrupted usually due to a multi-bit ECC memory or cache
11
 * failure.
12 13 14
 * 
 * In addition there is a "soft offline" entry point that allows stop using
 * not-yet-corrupted-by-suspicious pages without killing anything.
15 16
 *
 * Handles page cache pages in various states.	The tricky part
17 18 19 20 21 22
 * here is that we can access any page asynchronously in respect to 
 * other VM users, because memory failures could happen anytime and 
 * anywhere. This could violate some of their assumptions. This is why 
 * this code has to be extremely careful. Generally it tries to use 
 * normal locking rules, as in get the standard locks, even if that means 
 * the error handling takes potentially a long time.
23 24 25 26 27 28 29 30
 *
 * It can be very tempting to add handling for obscure cases here.
 * In general any code for handling new cases should only be added iff:
 * - You know how to test it.
 * - You have a test that can be added to mce-test
 *   https://git.kernel.org/cgit/utils/cpu/mce/mce-test.git/
 * - The case actually shows up as a frequent (top 10) page state in
 *   tools/vm/page-types when running a real workload.
31 32 33 34 35 36 37
 * 
 * There are several operations here with exponential complexity because
 * of unsuitable VM data structures. For example the operation to map back 
 * from RMAP chains to processes has to walk the complete process list and 
 * has non linear complexity with the number. But since memory corruptions
 * are rare we hope to get away with this. This avoids impacting the core 
 * VM.
38 39 40 41
 */
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/page-flags.h>
W
Wu Fengguang 已提交
42
#include <linux/kernel-page-flags.h>
43
#include <linux/sched.h>
H
Hugh Dickins 已提交
44
#include <linux/ksm.h>
45
#include <linux/rmap.h>
46
#include <linux/export.h>
47 48 49
#include <linux/pagemap.h>
#include <linux/swap.h>
#include <linux/backing-dev.h>
50 51 52
#include <linux/migrate.h>
#include <linux/page-isolation.h>
#include <linux/suspend.h>
53
#include <linux/slab.h>
54
#include <linux/swapops.h>
55
#include <linux/hugetlb.h>
56
#include <linux/memory_hotplug.h>
57
#include <linux/mm_inline.h>
58
#include <linux/kfifo.h>
59
#include <linux/ratelimit.h>
60
#include "internal.h"
61
#include "ras/ras_event.h"
62 63 64 65 66

int sysctl_memory_failure_early_kill __read_mostly = 0;

int sysctl_memory_failure_recovery __read_mostly = 1;

67
atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);
68

69 70
#if defined(CONFIG_HWPOISON_INJECT) || defined(CONFIG_HWPOISON_INJECT_MODULE)

71
u32 hwpoison_filter_enable = 0;
W
Wu Fengguang 已提交
72 73
u32 hwpoison_filter_dev_major = ~0U;
u32 hwpoison_filter_dev_minor = ~0U;
W
Wu Fengguang 已提交
74 75
u64 hwpoison_filter_flags_mask;
u64 hwpoison_filter_flags_value;
76
EXPORT_SYMBOL_GPL(hwpoison_filter_enable);
W
Wu Fengguang 已提交
77 78
EXPORT_SYMBOL_GPL(hwpoison_filter_dev_major);
EXPORT_SYMBOL_GPL(hwpoison_filter_dev_minor);
W
Wu Fengguang 已提交
79 80
EXPORT_SYMBOL_GPL(hwpoison_filter_flags_mask);
EXPORT_SYMBOL_GPL(hwpoison_filter_flags_value);
W
Wu Fengguang 已提交
81 82 83 84 85 86 87 88 89 90 91

static int hwpoison_filter_dev(struct page *p)
{
	struct address_space *mapping;
	dev_t dev;

	if (hwpoison_filter_dev_major == ~0U &&
	    hwpoison_filter_dev_minor == ~0U)
		return 0;

	/*
92
	 * page_mapping() does not accept slab pages.
W
Wu Fengguang 已提交
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
	 */
	if (PageSlab(p))
		return -EINVAL;

	mapping = page_mapping(p);
	if (mapping == NULL || mapping->host == NULL)
		return -EINVAL;

	dev = mapping->host->i_sb->s_dev;
	if (hwpoison_filter_dev_major != ~0U &&
	    hwpoison_filter_dev_major != MAJOR(dev))
		return -EINVAL;
	if (hwpoison_filter_dev_minor != ~0U &&
	    hwpoison_filter_dev_minor != MINOR(dev))
		return -EINVAL;

	return 0;
}

W
Wu Fengguang 已提交
112 113 114 115 116 117 118 119 120 121 122 123
static int hwpoison_filter_flags(struct page *p)
{
	if (!hwpoison_filter_flags_mask)
		return 0;

	if ((stable_page_flags(p) & hwpoison_filter_flags_mask) ==
				    hwpoison_filter_flags_value)
		return 0;
	else
		return -EINVAL;
}

A
Andi Kleen 已提交
124 125 126 127 128 129 130 131 132 133
/*
 * This allows stress tests to limit test scope to a collection of tasks
 * by putting them under some memcg. This prevents killing unrelated/important
 * processes such as /sbin/init. Note that the target task may share clean
 * pages with init (eg. libc text), which is harmless. If the target task
 * share _dirty_ pages with another task B, the test scheme must make sure B
 * is also included in the memcg. At last, due to race conditions this filter
 * can only guarantee that the page either belongs to the memcg tasks, or is
 * a freed page.
 */
134
#ifdef CONFIG_MEMCG
A
Andi Kleen 已提交
135 136 137 138 139 140 141
u64 hwpoison_filter_memcg;
EXPORT_SYMBOL_GPL(hwpoison_filter_memcg);
static int hwpoison_filter_task(struct page *p)
{
	if (!hwpoison_filter_memcg)
		return 0;

142
	if (page_cgroup_ino(p) != hwpoison_filter_memcg)
A
Andi Kleen 已提交
143 144 145 146 147 148 149 150
		return -EINVAL;

	return 0;
}
#else
static int hwpoison_filter_task(struct page *p) { return 0; }
#endif

W
Wu Fengguang 已提交
151 152
int hwpoison_filter(struct page *p)
{
153 154 155
	if (!hwpoison_filter_enable)
		return 0;

W
Wu Fengguang 已提交
156 157 158
	if (hwpoison_filter_dev(p))
		return -EINVAL;

W
Wu Fengguang 已提交
159 160 161
	if (hwpoison_filter_flags(p))
		return -EINVAL;

A
Andi Kleen 已提交
162 163 164
	if (hwpoison_filter_task(p))
		return -EINVAL;

W
Wu Fengguang 已提交
165 166
	return 0;
}
167 168 169 170 171 172 173
#else
int hwpoison_filter(struct page *p)
{
	return 0;
}
#endif

W
Wu Fengguang 已提交
174 175
EXPORT_SYMBOL_GPL(hwpoison_filter);

176
/*
177 178 179
 * Send all the processes who have the page mapped a signal.
 * ``action optional'' if they are not immediately affected by the error
 * ``action required'' if error happened in current execution context
180
 */
181 182
static int kill_proc(struct task_struct *t, unsigned long addr, int trapno,
			unsigned long pfn, struct page *page, int flags)
183 184 185 186
{
	struct siginfo si;
	int ret;

187 188
	pr_err("MCE %#lx: Killing %s:%d due to hardware memory corruption\n",
	       pfn, t->comm, t->pid);
189 190 191 192 193 194
	si.si_signo = SIGBUS;
	si.si_errno = 0;
	si.si_addr = (void *)addr;
#ifdef __ARCH_SI_TRAPNO
	si.si_trapno = trapno;
#endif
195
	si.si_addr_lsb = compound_order(compound_head(page)) + PAGE_SHIFT;
196

197
	if ((flags & MF_ACTION_REQUIRED) && t->mm == current->mm) {
198
		si.si_code = BUS_MCEERR_AR;
199
		ret = force_sig_info(SIGBUS, &si, current);
200 201 202 203 204 205 206 207 208 209
	} else {
		/*
		 * Don't use force here, it's convenient if the signal
		 * can be temporarily blocked.
		 * This could cause a loop when the user sets SIGBUS
		 * to SIG_IGN, but hopefully no one will do that?
		 */
		si.si_code = BUS_MCEERR_AO;
		ret = send_sig_info(SIGBUS, &si, t);  /* synchronous? */
	}
210
	if (ret < 0)
211 212
		pr_info("MCE: Error sending signal to %s:%d: %d\n",
			t->comm, t->pid, ret);
213 214 215
	return ret;
}

216 217 218 219
/*
 * When a unknown page type is encountered drain as many buffers as possible
 * in the hope to turn the page into a LRU or free page, which we can handle.
 */
220
void shake_page(struct page *p, int access)
221 222 223 224 225
{
	if (!PageSlab(p)) {
		lru_add_drain_all();
		if (PageLRU(p))
			return;
226
		drain_all_pages(page_zone(p));
227 228 229
		if (PageLRU(p) || is_free_buddy_page(p))
			return;
	}
230

231
	/*
232 233
	 * Only call shrink_node_slabs here (which would also shrink
	 * other caches) if access is not potentially fatal.
234
	 */
235 236
	if (access)
		drop_slab_node(page_to_nid(p));
237 238 239
}
EXPORT_SYMBOL_GPL(shake_page);

240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
/*
 * Kill all processes that have a poisoned page mapped and then isolate
 * the page.
 *
 * General strategy:
 * Find all processes having the page mapped and kill them.
 * But we keep a page reference around so that the page is not
 * actually freed yet.
 * Then stash the page away
 *
 * There's no convenient way to get back to mapped processes
 * from the VMAs. So do a brute-force search over all
 * running processes.
 *
 * Remember that machine checks are not common (or rather
 * if they are common you have other problems), so this shouldn't
 * be a performance issue.
 *
 * Also there are some races possible while we get from the
 * error detection to actually handle it.
 */

struct to_kill {
	struct list_head nd;
	struct task_struct *tsk;
	unsigned long addr;
266
	char addr_valid;
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
};

/*
 * Failure handling: if we can't find or can't kill a process there's
 * not much we can do.	We just print a message and ignore otherwise.
 */

/*
 * Schedule a process for later kill.
 * Uses GFP_ATOMIC allocations to avoid potential recursions in the VM.
 * TBD would GFP_NOIO be enough?
 */
static void add_to_kill(struct task_struct *tsk, struct page *p,
		       struct vm_area_struct *vma,
		       struct list_head *to_kill,
		       struct to_kill **tkc)
{
	struct to_kill *tk;

	if (*tkc) {
		tk = *tkc;
		*tkc = NULL;
	} else {
		tk = kmalloc(sizeof(struct to_kill), GFP_ATOMIC);
		if (!tk) {
292
			pr_err("MCE: Out of memory while machine check handling\n");
293 294 295 296 297 298 299 300 301 302 303 304 305
			return;
		}
	}
	tk->addr = page_address_in_vma(p, vma);
	tk->addr_valid = 1;

	/*
	 * In theory we don't have to kill when the page was
	 * munmaped. But it could be also a mremap. Since that's
	 * likely very rare kill anyways just out of paranoia, but use
	 * a SIGKILL because the error is not contained anymore.
	 */
	if (tk->addr == -EFAULT) {
306
		pr_info("MCE: Unable to find user space address %lx in %s\n",
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
			page_to_pfn(p), tsk->comm);
		tk->addr_valid = 0;
	}
	get_task_struct(tsk);
	tk->tsk = tsk;
	list_add_tail(&tk->nd, to_kill);
}

/*
 * Kill the processes that have been collected earlier.
 *
 * Only do anything when DOIT is set, otherwise just free the list
 * (this is used for clean pages which do not need killing)
 * Also when FAIL is set do a force kill because something went
 * wrong earlier.
 */
323
static void kill_procs(struct list_head *to_kill, int forcekill, int trapno,
324 325
			  int fail, struct page *page, unsigned long pfn,
			  int flags)
326 327 328 329
{
	struct to_kill *tk, *next;

	list_for_each_entry_safe (tk, next, to_kill, nd) {
330
		if (forcekill) {
331
			/*
332
			 * In case something went wrong with munmapping
333 334 335 336
			 * make sure the process doesn't catch the
			 * signal and then access the memory. Just kill it.
			 */
			if (fail || tk->addr_valid == 0) {
337 338
				pr_err("MCE %#lx: forcibly killing %s:%d because of failure to unmap corrupted page\n",
				       pfn, tk->tsk->comm, tk->tsk->pid);
339 340 341 342 343 344 345 346 347
				force_sig(SIGKILL, tk->tsk);
			}

			/*
			 * In theory the process could have mapped
			 * something else on the address in-between. We could
			 * check for that, but we need to tell the
			 * process anyways.
			 */
348 349
			else if (kill_proc(tk->tsk, tk->addr, trapno,
					      pfn, page, flags) < 0)
350 351
				pr_err("MCE %#lx: Cannot send advisory machine check signal to %s:%d\n",
				       pfn, tk->tsk->comm, tk->tsk->pid);
352 353 354 355 356 357
		}
		put_task_struct(tk->tsk);
		kfree(tk);
	}
}

358 359 360 361 362 363 364 365 366
/*
 * Find a dedicated thread which is supposed to handle SIGBUS(BUS_MCEERR_AO)
 * on behalf of the thread group. Return task_struct of the (first found)
 * dedicated thread if found, and return NULL otherwise.
 *
 * We already hold read_lock(&tasklist_lock) in the caller, so we don't
 * have to call rcu_read_lock/unlock() in this function.
 */
static struct task_struct *find_early_kill_thread(struct task_struct *tsk)
367
{
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
	struct task_struct *t;

	for_each_thread(tsk, t)
		if ((t->flags & PF_MCE_PROCESS) && (t->flags & PF_MCE_EARLY))
			return t;
	return NULL;
}

/*
 * Determine whether a given process is "early kill" process which expects
 * to be signaled when some page under the process is hwpoisoned.
 * Return task_struct of the dedicated thread (main thread unless explicitly
 * specified) if the process is "early kill," and otherwise returns NULL.
 */
static struct task_struct *task_early_kill(struct task_struct *tsk,
					   int force_early)
{
	struct task_struct *t;
386
	if (!tsk->mm)
387
		return NULL;
388
	if (force_early)
389 390 391 392 393 394 395
		return tsk;
	t = find_early_kill_thread(tsk);
	if (t)
		return t;
	if (sysctl_memory_failure_early_kill)
		return tsk;
	return NULL;
396 397 398 399 400 401
}

/*
 * Collect processes when the error hit an anonymous page.
 */
static void collect_procs_anon(struct page *page, struct list_head *to_kill,
402
			      struct to_kill **tkc, int force_early)
403 404 405 406
{
	struct vm_area_struct *vma;
	struct task_struct *tsk;
	struct anon_vma *av;
407
	pgoff_t pgoff;
408

409
	av = page_lock_anon_vma_read(page);
410
	if (av == NULL)	/* Not actually mapped anymore */
411 412
		return;

413
	pgoff = page_to_pgoff(page);
414
	read_lock(&tasklist_lock);
415
	for_each_process (tsk) {
416
		struct anon_vma_chain *vmac;
417
		struct task_struct *t = task_early_kill(tsk, force_early);
418

419
		if (!t)
420
			continue;
421 422
		anon_vma_interval_tree_foreach(vmac, &av->rb_root,
					       pgoff, pgoff) {
423
			vma = vmac->vma;
424 425
			if (!page_mapped_in_vma(page, vma))
				continue;
426 427
			if (vma->vm_mm == t->mm)
				add_to_kill(t, page, vma, to_kill, tkc);
428 429 430
		}
	}
	read_unlock(&tasklist_lock);
431
	page_unlock_anon_vma_read(av);
432 433 434 435 436 437
}

/*
 * Collect processes when the error hit a file mapped page.
 */
static void collect_procs_file(struct page *page, struct list_head *to_kill,
438
			      struct to_kill **tkc, int force_early)
439 440 441 442 443
{
	struct vm_area_struct *vma;
	struct task_struct *tsk;
	struct address_space *mapping = page->mapping;

444
	i_mmap_lock_read(mapping);
445
	read_lock(&tasklist_lock);
446
	for_each_process(tsk) {
447
		pgoff_t pgoff = page_to_pgoff(page);
448
		struct task_struct *t = task_early_kill(tsk, force_early);
449

450
		if (!t)
451
			continue;
452
		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
453 454 455 456 457 458 459 460
				      pgoff) {
			/*
			 * Send early kill signal to tasks where a vma covers
			 * the page but the corrupted page is not necessarily
			 * mapped it in its pte.
			 * Assume applications who requested early kill want
			 * to be informed of all such data corruptions.
			 */
461 462
			if (vma->vm_mm == t->mm)
				add_to_kill(t, page, vma, to_kill, tkc);
463 464 465
		}
	}
	read_unlock(&tasklist_lock);
466
	i_mmap_unlock_read(mapping);
467 468 469 470 471 472 473 474
}

/*
 * Collect the processes who have the corrupted page mapped to kill.
 * This is done in two steps for locking reasons.
 * First preallocate one tokill structure outside the spin locks,
 * so that we can kill at least one process reasonably reliable.
 */
475 476
static void collect_procs(struct page *page, struct list_head *tokill,
				int force_early)
477 478 479 480 481 482 483 484 485 486
{
	struct to_kill *tk;

	if (!page->mapping)
		return;

	tk = kmalloc(sizeof(struct to_kill), GFP_NOIO);
	if (!tk)
		return;
	if (PageAnon(page))
487
		collect_procs_anon(page, tokill, &tk, force_early);
488
	else
489
		collect_procs_file(page, tokill, &tk, force_early);
490 491 492 493
	kfree(tk);
}

static const char *action_name[] = {
494 495 496 497
	[MF_IGNORED] = "Ignored",
	[MF_FAILED] = "Failed",
	[MF_DELAYED] = "Delayed",
	[MF_RECOVERED] = "Recovered",
498 499 500
};

static const char * const action_page_types[] = {
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
	[MF_MSG_KERNEL]			= "reserved kernel page",
	[MF_MSG_KERNEL_HIGH_ORDER]	= "high-order kernel page",
	[MF_MSG_SLAB]			= "kernel slab page",
	[MF_MSG_DIFFERENT_COMPOUND]	= "different compound page after locking",
	[MF_MSG_POISONED_HUGE]		= "huge page already hardware poisoned",
	[MF_MSG_HUGE]			= "huge page",
	[MF_MSG_FREE_HUGE]		= "free huge page",
	[MF_MSG_UNMAP_FAILED]		= "unmapping failed page",
	[MF_MSG_DIRTY_SWAPCACHE]	= "dirty swapcache page",
	[MF_MSG_CLEAN_SWAPCACHE]	= "clean swapcache page",
	[MF_MSG_DIRTY_MLOCKED_LRU]	= "dirty mlocked LRU page",
	[MF_MSG_CLEAN_MLOCKED_LRU]	= "clean mlocked LRU page",
	[MF_MSG_DIRTY_UNEVICTABLE_LRU]	= "dirty unevictable LRU page",
	[MF_MSG_CLEAN_UNEVICTABLE_LRU]	= "clean unevictable LRU page",
	[MF_MSG_DIRTY_LRU]		= "dirty LRU page",
	[MF_MSG_CLEAN_LRU]		= "clean LRU page",
	[MF_MSG_TRUNCATED_LRU]		= "already truncated LRU page",
	[MF_MSG_BUDDY]			= "free buddy page",
	[MF_MSG_BUDDY_2ND]		= "free buddy page (2nd try)",
	[MF_MSG_UNKNOWN]		= "unknown page",
521 522
};

523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
/*
 * XXX: It is possible that a page is isolated from LRU cache,
 * and then kept in swap cache or failed to remove from page cache.
 * The page count will stop it from being freed by unpoison.
 * Stress tests should be aware of this memory leak problem.
 */
static int delete_from_lru_cache(struct page *p)
{
	if (!isolate_lru_page(p)) {
		/*
		 * Clear sensible page flags, so that the buddy system won't
		 * complain when the page is unpoison-and-freed.
		 */
		ClearPageActive(p);
		ClearPageUnevictable(p);
		/*
		 * drop the page count elevated by isolate_lru_page()
		 */
541
		put_page(p);
542 543 544 545 546
		return 0;
	}
	return -EIO;
}

547 548 549 550 551 552 553
/*
 * Error hit kernel page.
 * Do nothing, try to be lucky and not touch this instead. For a few cases we
 * could be more sophisticated.
 */
static int me_kernel(struct page *p, unsigned long pfn)
{
554
	return MF_IGNORED;
555 556 557 558 559 560 561
}

/*
 * Page in unknown state. Do nothing.
 */
static int me_unknown(struct page *p, unsigned long pfn)
{
562
	pr_err("MCE %#lx: Unknown page state\n", pfn);
563
	return MF_FAILED;
564 565 566 567 568 569 570 571
}

/*
 * Clean (or cleaned) page cache page.
 */
static int me_pagecache_clean(struct page *p, unsigned long pfn)
{
	int err;
572
	int ret = MF_FAILED;
573 574
	struct address_space *mapping;

575 576
	delete_from_lru_cache(p);

577 578 579 580 581
	/*
	 * For anonymous pages we're done the only reference left
	 * should be the one m_f() holds.
	 */
	if (PageAnon(p))
582
		return MF_RECOVERED;
583 584 585 586 587 588 589 590 591 592 593 594 595

	/*
	 * Now truncate the page in the page cache. This is really
	 * more like a "temporary hole punch"
	 * Don't do this for block devices when someone else
	 * has a reference, because it could be file system metadata
	 * and that's not safe to truncate.
	 */
	mapping = page_mapping(p);
	if (!mapping) {
		/*
		 * Page has been teared down in the meanwhile
		 */
596
		return MF_FAILED;
597 598 599 600 601 602 603 604 605 606
	}

	/*
	 * Truncation is a bit tricky. Enable it per file system for now.
	 *
	 * Open: to take i_mutex or not for this? Right now we don't.
	 */
	if (mapping->a_ops->error_remove_page) {
		err = mapping->a_ops->error_remove_page(mapping, p);
		if (err != 0) {
607 608
			pr_info("MCE %#lx: Failed to punch page: %d\n",
				pfn, err);
609 610
		} else if (page_has_private(p) &&
				!try_to_release_page(p, GFP_NOIO)) {
611
			pr_info("MCE %#lx: failed to release buffers\n", pfn);
612
		} else {
613
			ret = MF_RECOVERED;
614 615 616 617 618 619 620
		}
	} else {
		/*
		 * If the file system doesn't support it just invalidate
		 * This fails on dirty or anything with private pages
		 */
		if (invalidate_inode_page(p))
621
			ret = MF_RECOVERED;
622
		else
623
			pr_info("MCE %#lx: Failed to invalidate\n", pfn);
624 625 626 627 628
	}
	return ret;
}

/*
629
 * Dirty pagecache page
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
 * Issues: when the error hit a hole page the error is not properly
 * propagated.
 */
static int me_pagecache_dirty(struct page *p, unsigned long pfn)
{
	struct address_space *mapping = page_mapping(p);

	SetPageError(p);
	/* TBD: print more information about the file. */
	if (mapping) {
		/*
		 * IO error will be reported by write(), fsync(), etc.
		 * who check the mapping.
		 * This way the application knows that something went
		 * wrong with its dirty file data.
		 *
		 * There's one open issue:
		 *
		 * The EIO will be only reported on the next IO
		 * operation and then cleared through the IO map.
		 * Normally Linux has two mechanisms to pass IO error
		 * first through the AS_EIO flag in the address space
		 * and then through the PageError flag in the page.
		 * Since we drop pages on memory failure handling the
		 * only mechanism open to use is through AS_AIO.
		 *
		 * This has the disadvantage that it gets cleared on
		 * the first operation that returns an error, while
		 * the PageError bit is more sticky and only cleared
		 * when the page is reread or dropped.  If an
		 * application assumes it will always get error on
		 * fsync, but does other operations on the fd before
L
Lucas De Marchi 已提交
662
		 * and the page is dropped between then the error
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
		 * will not be properly reported.
		 *
		 * This can already happen even without hwpoisoned
		 * pages: first on metadata IO errors (which only
		 * report through AS_EIO) or when the page is dropped
		 * at the wrong time.
		 *
		 * So right now we assume that the application DTRT on
		 * the first EIO, but we're not worse than other parts
		 * of the kernel.
		 */
		mapping_set_error(mapping, EIO);
	}

	return me_pagecache_clean(p, pfn);
}

/*
 * Clean and dirty swap cache.
 *
 * Dirty swap cache page is tricky to handle. The page could live both in page
 * cache and swap cache(ie. page is freshly swapped in). So it could be
 * referenced concurrently by 2 types of PTEs:
 * normal PTEs and swap PTEs. We try to handle them consistently by calling
 * try_to_unmap(TTU_IGNORE_HWPOISON) to convert the normal PTEs to swap PTEs,
 * and then
 *      - clear dirty bit to prevent IO
 *      - remove from LRU
 *      - but keep in the swap cache, so that when we return to it on
 *        a later page fault, we know the application is accessing
 *        corrupted data and shall be killed (we installed simple
 *        interception code in do_swap_page to catch it).
 *
 * Clean swap cache pages can be directly isolated. A later page fault will
 * bring in the known good data from disk.
 */
static int me_swapcache_dirty(struct page *p, unsigned long pfn)
{
	ClearPageDirty(p);
	/* Trigger EIO in shmem: */
	ClearPageUptodate(p);

705
	if (!delete_from_lru_cache(p))
706
		return MF_DELAYED;
707
	else
708
		return MF_FAILED;
709 710 711 712 713
}

static int me_swapcache_clean(struct page *p, unsigned long pfn)
{
	delete_from_swap_cache(p);
714

715
	if (!delete_from_lru_cache(p))
716
		return MF_RECOVERED;
717
	else
718
		return MF_FAILED;
719 720 721 722 723
}

/*
 * Huge pages. Needs work.
 * Issues:
724 725
 * - Error on hugepage is contained in hugepage unit (not in raw page unit.)
 *   To narrow down kill region to one page, we need to break up pmd.
726 727 728
 */
static int me_huge_page(struct page *p, unsigned long pfn)
{
729
	int res = 0;
730
	struct page *hpage = compound_head(p);
731 732 733 734

	if (!PageHuge(hpage))
		return MF_DELAYED;

735 736 737 738 739 740 741 742 743 744 745
	/*
	 * We can safely recover from error on free or reserved (i.e.
	 * not in-use) hugepage by dequeuing it from freelist.
	 * To check whether a hugepage is in-use or not, we can't use
	 * page->lru because it can be used in other hugepage operations,
	 * such as __unmap_hugepage_range() and gather_surplus_pages().
	 * So instead we use page_mapping() and PageAnon().
	 * We assume that this function is called with page lock held,
	 * so there is no race between isolation and mapping/unmapping.
	 */
	if (!(page_mapping(hpage) || PageAnon(hpage))) {
746 747
		res = dequeue_hwpoisoned_huge_page(hpage);
		if (!res)
748
			return MF_RECOVERED;
749
	}
750
	return MF_DELAYED;
751 752 753 754 755 756 757 758 759
}

/*
 * Various page states we can handle.
 *
 * A page state is defined by its current page->flags bits.
 * The table matches them in order and calls the right handler.
 *
 * This is quite tricky because we can access page at any time
L
Lucas De Marchi 已提交
760
 * in its live cycle, so all accesses have to be extremely careful.
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
 *
 * This is not complete. More states could be added.
 * For any missing state don't attempt recovery.
 */

#define dirty		(1UL << PG_dirty)
#define sc		(1UL << PG_swapcache)
#define unevict		(1UL << PG_unevictable)
#define mlock		(1UL << PG_mlocked)
#define writeback	(1UL << PG_writeback)
#define lru		(1UL << PG_lru)
#define swapbacked	(1UL << PG_swapbacked)
#define head		(1UL << PG_head)
#define slab		(1UL << PG_slab)
#define reserved	(1UL << PG_reserved)

static struct page_state {
	unsigned long mask;
	unsigned long res;
780
	enum mf_action_page_type type;
781 782
	int (*action)(struct page *p, unsigned long pfn);
} error_states[] = {
783
	{ reserved,	reserved,	MF_MSG_KERNEL,	me_kernel },
784 785 786 787
	/*
	 * free pages are specially detected outside this table:
	 * PG_buddy pages only make a small fraction of all free pages.
	 */
788 789 790 791 792 793

	/*
	 * Could in theory check if slab page is free or if we can drop
	 * currently unused objects without touching them. But just
	 * treat it as standard kernel for now.
	 */
794
	{ slab,		slab,		MF_MSG_SLAB,	me_kernel },
795

796
	{ head,		head,		MF_MSG_HUGE,		me_huge_page },
797

798 799
	{ sc|dirty,	sc|dirty,	MF_MSG_DIRTY_SWAPCACHE,	me_swapcache_dirty },
	{ sc|dirty,	sc,		MF_MSG_CLEAN_SWAPCACHE,	me_swapcache_clean },
800

801 802
	{ mlock|dirty,	mlock|dirty,	MF_MSG_DIRTY_MLOCKED_LRU,	me_pagecache_dirty },
	{ mlock|dirty,	mlock,		MF_MSG_CLEAN_MLOCKED_LRU,	me_pagecache_clean },
803

804 805
	{ unevict|dirty, unevict|dirty,	MF_MSG_DIRTY_UNEVICTABLE_LRU,	me_pagecache_dirty },
	{ unevict|dirty, unevict,	MF_MSG_CLEAN_UNEVICTABLE_LRU,	me_pagecache_clean },
806

807 808
	{ lru|dirty,	lru|dirty,	MF_MSG_DIRTY_LRU,	me_pagecache_dirty },
	{ lru|dirty,	lru,		MF_MSG_CLEAN_LRU,	me_pagecache_clean },
809 810 811 812

	/*
	 * Catchall entry: must be at end.
	 */
813
	{ 0,		0,		MF_MSG_UNKNOWN,	me_unknown },
814 815
};

816 817 818 819 820 821 822 823 824 825 826
#undef dirty
#undef sc
#undef unevict
#undef mlock
#undef writeback
#undef lru
#undef swapbacked
#undef head
#undef slab
#undef reserved

827 828 829 830
/*
 * "Dirty/Clean" indication is not 100% accurate due to the possibility of
 * setting PG_dirty outside page lock. See also comment above set_page_dirty().
 */
831 832
static void action_result(unsigned long pfn, enum mf_action_page_type type,
			  enum mf_result result)
833
{
834 835
	trace_memory_failure_event(pfn, type, result);

836 837
	pr_err("MCE %#lx: recovery action for %s: %s\n",
		pfn, action_page_types[type], action_name[result]);
838 839 840
}

static int page_action(struct page_state *ps, struct page *p,
841
			unsigned long pfn)
842 843
{
	int result;
844
	int count;
845 846

	result = ps->action(p, pfn);
847

848
	count = page_count(p) - 1;
849
	if (ps->action == me_swapcache_dirty && result == MF_DELAYED)
850 851
		count--;
	if (count != 0) {
852
		pr_err("MCE %#lx: %s still referenced by %d users\n",
853
		       pfn, action_page_types[ps->type], count);
854
		result = MF_FAILED;
855
	}
856
	action_result(pfn, ps->type, result);
857 858 859 860 861 862

	/* Could do more checks here if page looks ok */
	/*
	 * Could adjust zone counters here to correct for the missing page.
	 */

863
	return (result == MF_RECOVERED || result == MF_DELAYED) ? 0 : -EBUSY;
864 865
}

866 867 868 869 870 871 872 873 874 875 876
/**
 * get_hwpoison_page() - Get refcount for memory error handling:
 * @page:	raw error page (hit by memory error)
 *
 * Return: return 0 if failed to grab the refcount, otherwise true (some
 * non-zero value.)
 */
int get_hwpoison_page(struct page *page)
{
	struct page *head = compound_head(page);

877
	if (!PageHuge(head) && PageTransHuge(head)) {
878 879 880 881 882 883 884 885 886 887 888
		/*
		 * Non anonymous thp exists only in allocation/free time. We
		 * can't handle such a case correctly, so let's give it up.
		 * This should be better than triggering BUG_ON when kernel
		 * tries to touch the "partially handled" page.
		 */
		if (!PageAnon(head)) {
			pr_err("MCE: %#lx: non anonymous thp\n",
				page_to_pfn(page));
			return 0;
		}
889 890
	}

891
	return get_page_unless_zero(head);
892 893 894
}
EXPORT_SYMBOL_GPL(get_hwpoison_page);

895 896 897 898
/*
 * Do all that is necessary to remove user space mappings. Unmap
 * the pages and send SIGBUS to the processes if the data was dirty.
 */
W
Wu Fengguang 已提交
899
static int hwpoison_user_mappings(struct page *p, unsigned long pfn,
900
				  int trapno, int flags, struct page **hpagep)
901 902 903 904 905
{
	enum ttu_flags ttu = TTU_UNMAP | TTU_IGNORE_MLOCK | TTU_IGNORE_ACCESS;
	struct address_space *mapping;
	LIST_HEAD(tokill);
	int ret;
906
	int kill = 1, forcekill;
907
	struct page *hpage = *hpagep;
908

909 910 911 912 913 914 915
	/*
	 * Here we are interested only in user-mapped pages, so skip any
	 * other types of pages.
	 */
	if (PageReserved(p) || PageSlab(p))
		return SWAP_SUCCESS;
	if (!(PageLRU(hpage) || PageHuge(p)))
W
Wu Fengguang 已提交
916
		return SWAP_SUCCESS;
917 918 919 920 921

	/*
	 * This check implies we don't kill processes if their pages
	 * are in the swap cache early. Those are always late kills.
	 */
922
	if (!page_mapped(hpage))
W
Wu Fengguang 已提交
923 924
		return SWAP_SUCCESS;

925 926
	if (PageKsm(p)) {
		pr_err("MCE %#lx: can't handle KSM pages.\n", pfn);
W
Wu Fengguang 已提交
927
		return SWAP_FAIL;
928
	}
929 930

	if (PageSwapCache(p)) {
931
		pr_err("MCE %#lx: keeping poisoned page in swap cache\n", pfn);
932 933 934 935 936 937
		ttu |= TTU_IGNORE_HWPOISON;
	}

	/*
	 * Propagate the dirty bit from PTEs to struct page first, because we
	 * need this to decide if we should kill or just drop the page.
938 939
	 * XXX: the dirty test could be racy: set_page_dirty() may not always
	 * be called inside page lock (it's recommended but not enforced).
940
	 */
941
	mapping = page_mapping(hpage);
942
	if (!(flags & MF_MUST_KILL) && !PageDirty(hpage) && mapping &&
943 944 945
	    mapping_cap_writeback_dirty(mapping)) {
		if (page_mkclean(hpage)) {
			SetPageDirty(hpage);
946 947 948
		} else {
			kill = 0;
			ttu |= TTU_IGNORE_HWPOISON;
949
			pr_info("MCE %#lx: corrupted page was clean: dropped without side effects\n",
950 951 952 953 954 955 956 957 958 959 960 961 962
				pfn);
		}
	}

	/*
	 * First collect all the processes that have the page
	 * mapped in dirty form.  This has to be done before try_to_unmap,
	 * because ttu takes the rmap data structures down.
	 *
	 * Error handling: We ignore errors here because
	 * there's nothing that can be done.
	 */
	if (kill)
963
		collect_procs(hpage, &tokill, flags & MF_ACTION_REQUIRED);
964

965
	ret = try_to_unmap(hpage, ttu);
966
	if (ret != SWAP_SUCCESS)
967 968
		pr_err("MCE %#lx: failed to unmap page (mapcount=%d)\n",
		       pfn, page_mapcount(hpage));
969

970 971 972 973
	/*
	 * Now that the dirty bit has been propagated to the
	 * struct page and all unmaps done we can decide if
	 * killing is needed or not.  Only kill when the page
974 975
	 * was dirty or the process is not restartable,
	 * otherwise the tokill list is merely
976 977 978 979
	 * freed.  When there was a problem unmapping earlier
	 * use a more force-full uncatchable kill to prevent
	 * any accesses to the poisoned memory.
	 */
980
	forcekill = PageDirty(hpage) || (flags & MF_MUST_KILL);
981
	kill_procs(&tokill, forcekill, trapno,
982
		      ret != SWAP_SUCCESS, p, pfn, flags);
W
Wu Fengguang 已提交
983 984

	return ret;
985 986
}

987 988 989
static void set_page_hwpoison_huge_page(struct page *hpage)
{
	int i;
990
	int nr_pages = 1 << compound_order(hpage);
991 992 993 994 995 996 997
	for (i = 0; i < nr_pages; i++)
		SetPageHWPoison(hpage + i);
}

static void clear_page_hwpoison_huge_page(struct page *hpage)
{
	int i;
998
	int nr_pages = 1 << compound_order(hpage);
999 1000 1001 1002
	for (i = 0; i < nr_pages; i++)
		ClearPageHWPoison(hpage + i);
}

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
/**
 * memory_failure - Handle memory failure of a page.
 * @pfn: Page Number of the corrupted page
 * @trapno: Trap number reported in the signal to user space.
 * @flags: fine tune action taken
 *
 * This function is called by the low level machine check code
 * of an architecture when it detects hardware memory corruption
 * of a page. It tries its best to recover, which includes
 * dropping pages, killing processes etc.
 *
 * The function is primarily of use for corruptions that
 * happen outside the current execution context (e.g. when
 * detected by a background scrubber)
 *
 * Must run in process context (e.g. a work queue) with interrupts
 * enabled and no spinlocks hold.
 */
int memory_failure(unsigned long pfn, int trapno, int flags)
1022 1023 1024
{
	struct page_state *ps;
	struct page *p;
1025
	struct page *hpage;
1026
	struct page *orig_head;
1027
	int res;
1028
	unsigned int nr_pages;
1029
	unsigned long page_flags;
1030 1031 1032 1033 1034

	if (!sysctl_memory_failure_recovery)
		panic("Memory failure from trap %d on page %lx", trapno, pfn);

	if (!pfn_valid(pfn)) {
1035
		pr_err("MCE %#lx: memory outside kernel control\n", pfn);
1036
		return -ENXIO;
1037 1038 1039
	}

	p = pfn_to_page(pfn);
1040
	orig_head = hpage = compound_head(p);
1041
	if (TestSetPageHWPoison(p)) {
1042
		pr_err("MCE %#lx: already hardware poisoned\n", pfn);
1043 1044 1045
		return 0;
	}

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
	/*
	 * Currently errors on hugetlbfs pages are measured in hugepage units,
	 * so nr_pages should be 1 << compound_order.  OTOH when errors are on
	 * transparent hugepages, they are supposed to be split and error
	 * measurement is done in normal page units.  So nr_pages should be one
	 * in this case.
	 */
	if (PageHuge(p))
		nr_pages = 1 << compound_order(hpage);
	else /* normal page or thp */
		nr_pages = 1;
1057
	num_poisoned_pages_add(nr_pages);
1058 1059 1060 1061 1062

	/*
	 * We need/can do nothing about count=0 pages.
	 * 1) it's a free page, and therefore in safe hand:
	 *    prep_new_page() will be the gate keeper.
1063 1064 1065 1066
	 * 2) it's a free hugepage, which is also safe:
	 *    an affected hugepage will be dequeued from hugepage freelist,
	 *    so there's no concern about reusing it ever after.
	 * 3) it's part of a non-compound high order page.
1067 1068 1069 1070 1071 1072
	 *    Implies some kernel user: cannot stop them from
	 *    R/W the page; let's pray that the page has been
	 *    used and will be freed some time later.
	 * In fact it's dangerous to directly bump up page count from 0,
	 * that may make page_freeze_refs()/page_unfreeze_refs() mismatch.
	 */
1073
	if (!(flags & MF_COUNT_INCREASED) && !get_hwpoison_page(p)) {
1074
		if (is_free_buddy_page(p)) {
1075
			action_result(pfn, MF_MSG_BUDDY, MF_DELAYED);
1076
			return 0;
1077 1078
		} else if (PageHuge(hpage)) {
			/*
1079
			 * Check "filter hit" and "race with other subpage."
1080
			 */
J
Jens Axboe 已提交
1081
			lock_page(hpage);
1082 1083 1084
			if (PageHWPoison(hpage)) {
				if ((hwpoison_filter(p) && TestClearPageHWPoison(p))
				    || (p != hpage && TestSetPageHWPoison(hpage))) {
1085
					num_poisoned_pages_sub(nr_pages);
1086 1087 1088
					unlock_page(hpage);
					return 0;
				}
1089 1090 1091
			}
			set_page_hwpoison_huge_page(hpage);
			res = dequeue_hwpoisoned_huge_page(hpage);
1092 1093
			action_result(pfn, MF_MSG_FREE_HUGE,
				      res ? MF_IGNORED : MF_DELAYED);
1094 1095
			unlock_page(hpage);
			return res;
1096
		} else {
1097
			action_result(pfn, MF_MSG_KERNEL_HIGH_ORDER, MF_IGNORED);
1098 1099
			return -EBUSY;
		}
1100 1101
	}

1102
	if (!PageHuge(p) && PageTransHuge(hpage)) {
1103
		lock_page(hpage);
1104
		if (!PageAnon(hpage) || unlikely(split_huge_page(hpage))) {
1105
			unlock_page(hpage);
1106 1107 1108 1109
			if (!PageAnon(hpage))
				pr_err("MCE: %#lx: non anonymous thp\n", pfn);
			else
				pr_err("MCE: %#lx: thp split failed\n", pfn);
1110
			if (TestClearPageHWPoison(p))
1111
				num_poisoned_pages_sub(nr_pages);
1112
			put_hwpoison_page(p);
1113 1114
			return -EBUSY;
		}
1115
		unlock_page(hpage);
1116 1117
		get_hwpoison_page(p);
		put_hwpoison_page(hpage);
1118 1119 1120 1121
		VM_BUG_ON_PAGE(!page_count(p), p);
		hpage = compound_head(p);
	}

1122 1123 1124
	/*
	 * We ignore non-LRU pages for good reasons.
	 * - PG_locked is only well defined for LRU pages and a few others
1125
	 * - to avoid races with __SetPageLocked()
1126 1127 1128 1129
	 * - to avoid races with __SetPageSlab*() (and more non-atomic ops)
	 * The check (unnecessarily) ignores LRU pages being isolated and
	 * walked by the page reclaim code, however that's not a big loss.
	 */
1130
	if (!PageHuge(p)) {
1131 1132 1133
		if (!PageLRU(p))
			shake_page(p, 0);
		if (!PageLRU(p)) {
1134 1135 1136 1137
			/*
			 * shake_page could have turned it free.
			 */
			if (is_free_buddy_page(p)) {
1138
				if (flags & MF_COUNT_INCREASED)
1139
					action_result(pfn, MF_MSG_BUDDY, MF_DELAYED);
1140
				else
1141 1142
					action_result(pfn, MF_MSG_BUDDY_2ND,
						      MF_DELAYED);
1143 1144
				return 0;
			}
1145
		}
1146 1147
	}

J
Jens Axboe 已提交
1148
	lock_page(hpage);
W
Wu Fengguang 已提交
1149

1150 1151 1152 1153
	/*
	 * The page could have changed compound pages during the locking.
	 * If this happens just bail out.
	 */
1154
	if (PageCompound(p) && compound_head(p) != orig_head) {
1155
		action_result(pfn, MF_MSG_DIFFERENT_COMPOUND, MF_IGNORED);
1156 1157 1158 1159
		res = -EBUSY;
		goto out;
	}

1160 1161 1162 1163 1164 1165 1166 1167 1168
	/*
	 * We use page flags to determine what action should be taken, but
	 * the flags can be modified by the error containment action.  One
	 * example is an mlocked page, where PG_mlocked is cleared by
	 * page_remove_rmap() in try_to_unmap_one(). So to determine page status
	 * correctly, we save a copy of the page flags at this time.
	 */
	page_flags = p->flags;

W
Wu Fengguang 已提交
1169 1170 1171 1172
	/*
	 * unpoison always clear PG_hwpoison inside page lock
	 */
	if (!PageHWPoison(p)) {
1173
		pr_err("MCE %#lx: just unpoisoned\n", pfn);
1174
		num_poisoned_pages_sub(nr_pages);
1175
		unlock_page(hpage);
1176
		put_hwpoison_page(hpage);
1177
		return 0;
W
Wu Fengguang 已提交
1178
	}
W
Wu Fengguang 已提交
1179 1180
	if (hwpoison_filter(p)) {
		if (TestClearPageHWPoison(p))
1181
			num_poisoned_pages_sub(nr_pages);
1182
		unlock_page(hpage);
1183
		put_hwpoison_page(hpage);
W
Wu Fengguang 已提交
1184 1185
		return 0;
	}
W
Wu Fengguang 已提交
1186

1187 1188 1189
	if (!PageHuge(p) && !PageTransTail(p) && !PageLRU(p))
		goto identify_page_state;

1190 1191 1192 1193
	/*
	 * For error on the tail page, we should set PG_hwpoison
	 * on the head page to show that the hugepage is hwpoisoned
	 */
1194
	if (PageHuge(p) && PageTail(p) && TestSetPageHWPoison(hpage)) {
1195
		action_result(pfn, MF_MSG_POISONED_HUGE, MF_IGNORED);
1196
		unlock_page(hpage);
1197
		put_hwpoison_page(hpage);
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
		return 0;
	}
	/*
	 * Set PG_hwpoison on all pages in an error hugepage,
	 * because containment is done in hugepage unit for now.
	 * Since we have done TestSetPageHWPoison() for the head page with
	 * page lock held, we can safely set PG_hwpoison bits on tail pages.
	 */
	if (PageHuge(p))
		set_page_hwpoison_huge_page(hpage);

1209 1210 1211 1212
	/*
	 * It's very difficult to mess with pages currently under IO
	 * and in many cases impossible, so we just avoid it here.
	 */
1213 1214 1215 1216
	wait_on_page_writeback(p);

	/*
	 * Now take care of user space mappings.
1217
	 * Abort on fail: __delete_from_page_cache() assumes unmapped page.
1218 1219 1220
	 *
	 * When the raw error page is thp tail page, hpage points to the raw
	 * page after thp split.
1221
	 */
1222 1223
	if (hwpoison_user_mappings(p, pfn, trapno, flags, &hpage)
	    != SWAP_SUCCESS) {
1224
		action_result(pfn, MF_MSG_UNMAP_FAILED, MF_IGNORED);
W
Wu Fengguang 已提交
1225 1226 1227
		res = -EBUSY;
		goto out;
	}
1228 1229 1230 1231

	/*
	 * Torn down by someone else?
	 */
1232
	if (PageLRU(p) && !PageSwapCache(p) && p->mapping == NULL) {
1233
		action_result(pfn, MF_MSG_TRUNCATED_LRU, MF_IGNORED);
1234
		res = -EBUSY;
1235 1236 1237
		goto out;
	}

1238
identify_page_state:
1239
	res = -EBUSY;
1240 1241 1242 1243 1244 1245 1246
	/*
	 * The first check uses the current page flags which may not have any
	 * relevant information. The second check with the saved page flagss is
	 * carried out only if the first check can't determine the page status.
	 */
	for (ps = error_states;; ps++)
		if ((p->flags & ps->mask) == ps->res)
1247
			break;
1248 1249 1250

	page_flags |= (p->flags & (1UL << PG_dirty));

1251 1252 1253 1254 1255
	if (!ps->mask)
		for (ps = error_states;; ps++)
			if ((page_flags & ps->mask) == ps->res)
				break;
	res = page_action(ps, p, pfn);
1256
out:
1257
	unlock_page(hpage);
1258 1259
	return res;
}
1260
EXPORT_SYMBOL_GPL(memory_failure);
W
Wu Fengguang 已提交
1261

1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
#define MEMORY_FAILURE_FIFO_ORDER	4
#define MEMORY_FAILURE_FIFO_SIZE	(1 << MEMORY_FAILURE_FIFO_ORDER)

struct memory_failure_entry {
	unsigned long pfn;
	int trapno;
	int flags;
};

struct memory_failure_cpu {
	DECLARE_KFIFO(fifo, struct memory_failure_entry,
		      MEMORY_FAILURE_FIFO_SIZE);
	spinlock_t lock;
	struct work_struct work;
};

static DEFINE_PER_CPU(struct memory_failure_cpu, memory_failure_cpu);

/**
 * memory_failure_queue - Schedule handling memory failure of a page.
 * @pfn: Page Number of the corrupted page
 * @trapno: Trap number reported in the signal to user space.
 * @flags: Flags for memory failure handling
 *
 * This function is called by the low level hardware error handler
 * when it detects hardware memory corruption of a page. It schedules
 * the recovering of error page, including dropping pages, killing
 * processes etc.
 *
 * The function is primarily of use for corruptions that
 * happen outside the current execution context (e.g. when
 * detected by a background scrubber)
 *
 * Can run in IRQ context.
 */
void memory_failure_queue(unsigned long pfn, int trapno, int flags)
{
	struct memory_failure_cpu *mf_cpu;
	unsigned long proc_flags;
	struct memory_failure_entry entry = {
		.pfn =		pfn,
		.trapno =	trapno,
		.flags =	flags,
	};

	mf_cpu = &get_cpu_var(memory_failure_cpu);
	spin_lock_irqsave(&mf_cpu->lock, proc_flags);
S
Stefani Seibold 已提交
1309
	if (kfifo_put(&mf_cpu->fifo, entry))
1310 1311
		schedule_work_on(smp_processor_id(), &mf_cpu->work);
	else
J
Joe Perches 已提交
1312
		pr_err("Memory failure: buffer overflow when queuing memory failure at %#lx\n",
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
		       pfn);
	spin_unlock_irqrestore(&mf_cpu->lock, proc_flags);
	put_cpu_var(memory_failure_cpu);
}
EXPORT_SYMBOL_GPL(memory_failure_queue);

static void memory_failure_work_func(struct work_struct *work)
{
	struct memory_failure_cpu *mf_cpu;
	struct memory_failure_entry entry = { 0, };
	unsigned long proc_flags;
	int gotten;

1326
	mf_cpu = this_cpu_ptr(&memory_failure_cpu);
1327 1328 1329 1330 1331 1332
	for (;;) {
		spin_lock_irqsave(&mf_cpu->lock, proc_flags);
		gotten = kfifo_get(&mf_cpu->fifo, &entry);
		spin_unlock_irqrestore(&mf_cpu->lock, proc_flags);
		if (!gotten)
			break;
1333 1334 1335 1336
		if (entry.flags & MF_SOFT_OFFLINE)
			soft_offline_page(pfn_to_page(entry.pfn), entry.flags);
		else
			memory_failure(entry.pfn, entry.trapno, entry.flags);
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
	}
}

static int __init memory_failure_init(void)
{
	struct memory_failure_cpu *mf_cpu;
	int cpu;

	for_each_possible_cpu(cpu) {
		mf_cpu = &per_cpu(memory_failure_cpu, cpu);
		spin_lock_init(&mf_cpu->lock);
		INIT_KFIFO(mf_cpu->fifo);
		INIT_WORK(&mf_cpu->work, memory_failure_work_func);
	}

	return 0;
}
core_initcall(memory_failure_init);

1356 1357 1358 1359 1360 1361
#define unpoison_pr_info(fmt, pfn, rs)			\
({							\
	if (__ratelimit(rs))				\
		pr_info(fmt, pfn);			\
})

W
Wu Fengguang 已提交
1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
/**
 * unpoison_memory - Unpoison a previously poisoned page
 * @pfn: Page number of the to be unpoisoned page
 *
 * Software-unpoison a page that has been poisoned by
 * memory_failure() earlier.
 *
 * This is only done on the software-level, so it only works
 * for linux injected failures, not real hardware failures
 *
 * Returns 0 for success, otherwise -errno.
 */
int unpoison_memory(unsigned long pfn)
{
	struct page *page;
	struct page *p;
	int freeit = 0;
1379
	unsigned int nr_pages;
1380 1381
	static DEFINE_RATELIMIT_STATE(unpoison_rs, DEFAULT_RATELIMIT_INTERVAL,
					DEFAULT_RATELIMIT_BURST);
W
Wu Fengguang 已提交
1382 1383 1384 1385 1386 1387 1388 1389

	if (!pfn_valid(pfn))
		return -ENXIO;

	p = pfn_to_page(pfn);
	page = compound_head(p);

	if (!PageHWPoison(p)) {
1390 1391
		unpoison_pr_info("MCE: Page was already unpoisoned %#lx\n",
				 pfn, &unpoison_rs);
W
Wu Fengguang 已提交
1392 1393 1394
		return 0;
	}

1395
	if (page_count(page) > 1) {
1396 1397
		unpoison_pr_info("MCE: Someone grabs the hwpoison page %#lx\n",
				 pfn, &unpoison_rs);
1398 1399 1400 1401
		return 0;
	}

	if (page_mapped(page)) {
1402 1403
		unpoison_pr_info("MCE: Someone maps the hwpoison page %#lx\n",
				 pfn, &unpoison_rs);
1404 1405 1406 1407
		return 0;
	}

	if (page_mapping(page)) {
1408 1409
		unpoison_pr_info("MCE: the hwpoison page has non-NULL mapping %#lx\n",
				 pfn, &unpoison_rs);
1410 1411 1412
		return 0;
	}

1413 1414 1415 1416 1417
	/*
	 * unpoison_memory() can encounter thp only when the thp is being
	 * worked by memory_failure() and the page lock is not held yet.
	 * In such case, we yield to memory_failure() and make unpoison fail.
	 */
1418
	if (!PageHuge(page) && PageTransHuge(page)) {
1419 1420
		unpoison_pr_info("MCE: Memory failure is now running on %#lx\n",
				 pfn, &unpoison_rs);
1421
		return 0;
1422 1423
	}

1424
	nr_pages = 1 << compound_order(page);
1425

1426
	if (!get_hwpoison_page(p)) {
1427 1428 1429 1430 1431 1432 1433
		/*
		 * Since HWPoisoned hugepage should have non-zero refcount,
		 * race between memory failure and unpoison seems to happen.
		 * In such case unpoison fails and memory failure runs
		 * to the end.
		 */
		if (PageHuge(page)) {
1434 1435
			unpoison_pr_info("MCE: Memory failure is now running on free hugepage %#lx\n",
					 pfn, &unpoison_rs);
1436 1437
			return 0;
		}
W
Wu Fengguang 已提交
1438
		if (TestClearPageHWPoison(p))
1439
			num_poisoned_pages_dec();
1440 1441
		unpoison_pr_info("MCE: Software-unpoisoned free page %#lx\n",
				 pfn, &unpoison_rs);
W
Wu Fengguang 已提交
1442 1443 1444
		return 0;
	}

J
Jens Axboe 已提交
1445
	lock_page(page);
W
Wu Fengguang 已提交
1446 1447 1448 1449 1450 1451
	/*
	 * This test is racy because PG_hwpoison is set outside of page lock.
	 * That's acceptable because that won't trigger kernel panic. Instead,
	 * the PG_hwpoison page will be caught and isolated on the entrance to
	 * the free buddy page pool.
	 */
1452
	if (TestClearPageHWPoison(page)) {
1453 1454
		unpoison_pr_info("MCE: Software-unpoisoned page %#lx\n",
				 pfn, &unpoison_rs);
1455
		num_poisoned_pages_sub(nr_pages);
W
Wu Fengguang 已提交
1456
		freeit = 1;
1457 1458
		if (PageHuge(page))
			clear_page_hwpoison_huge_page(page);
W
Wu Fengguang 已提交
1459 1460 1461
	}
	unlock_page(page);

1462
	put_hwpoison_page(page);
1463
	if (freeit && !(pfn == my_zero_pfn(0) && page_count(p) == 1))
1464
		put_hwpoison_page(page);
W
Wu Fengguang 已提交
1465 1466 1467 1468

	return 0;
}
EXPORT_SYMBOL(unpoison_memory);
1469 1470 1471

static struct page *new_page(struct page *p, unsigned long private, int **x)
{
1472
	int nid = page_to_nid(p);
1473 1474 1475 1476
	if (PageHuge(p))
		return alloc_huge_page_node(page_hstate(compound_head(p)),
						   nid);
	else
1477
		return __alloc_pages_node(nid, GFP_HIGHUSER_MOVABLE, 0);
1478 1479 1480 1481 1482 1483 1484 1485
}

/*
 * Safely get reference count of an arbitrary page.
 * Returns 0 for a free page, -EIO for a zero refcount page
 * that is not free, and 1 for any other page type.
 * For 1 the page is returned with increased page count, otherwise not.
 */
1486
static int __get_any_page(struct page *p, unsigned long pfn, int flags)
1487 1488 1489 1490 1491 1492
{
	int ret;

	if (flags & MF_COUNT_INCREASED)
		return 1;

1493 1494 1495 1496
	/*
	 * When the target page is a free hugepage, just remove it
	 * from free hugepage list.
	 */
1497
	if (!get_hwpoison_page(p)) {
1498
		if (PageHuge(p)) {
1499
			pr_info("%s: %#lx free huge page\n", __func__, pfn);
1500
			ret = 0;
1501
		} else if (is_free_buddy_page(p)) {
1502
			pr_info("%s: %#lx free buddy page\n", __func__, pfn);
1503 1504
			ret = 0;
		} else {
1505 1506
			pr_info("%s: %#lx: unknown zero refcount page type %lx\n",
				__func__, pfn, p->flags);
1507 1508 1509 1510 1511 1512 1513 1514 1515
			ret = -EIO;
		}
	} else {
		/* Not a free page */
		ret = 1;
	}
	return ret;
}

1516 1517 1518 1519 1520 1521 1522 1523
static int get_any_page(struct page *page, unsigned long pfn, int flags)
{
	int ret = __get_any_page(page, pfn, flags);

	if (ret == 1 && !PageHuge(page) && !PageLRU(page)) {
		/*
		 * Try to free it.
		 */
1524
		put_hwpoison_page(page);
1525 1526 1527 1528 1529 1530
		shake_page(page, 1);

		/*
		 * Did it turn free?
		 */
		ret = __get_any_page(page, pfn, 0);
1531
		if (ret == 1 && !PageLRU(page)) {
1532
			/* Drop page reference which is from __get_any_page() */
1533
			put_hwpoison_page(page);
1534 1535 1536 1537 1538 1539 1540 1541
			pr_info("soft_offline: %#lx: unknown non LRU page type %lx\n",
				pfn, page->flags);
			return -EIO;
		}
	}
	return ret;
}

1542 1543 1544 1545 1546
static int soft_offline_huge_page(struct page *page, int flags)
{
	int ret;
	unsigned long pfn = page_to_pfn(page);
	struct page *hpage = compound_head(page);
1547
	LIST_HEAD(pagelist);
1548

1549 1550 1551 1552 1553
	/*
	 * This double-check of PageHWPoison is to avoid the race with
	 * memory_failure(). See also comment in __soft_offline_page().
	 */
	lock_page(hpage);
1554
	if (PageHWPoison(hpage)) {
1555
		unlock_page(hpage);
1556
		put_hwpoison_page(hpage);
1557
		pr_info("soft offline: %#lx hugepage already poisoned\n", pfn);
1558
		return -EBUSY;
1559
	}
1560
	unlock_page(hpage);
1561

1562
	ret = isolate_huge_page(hpage, &pagelist);
1563 1564 1565 1566
	/*
	 * get_any_page() and isolate_huge_page() takes a refcount each,
	 * so need to drop one here.
	 */
1567
	put_hwpoison_page(hpage);
1568
	if (!ret) {
1569 1570 1571 1572
		pr_info("soft offline: %#lx hugepage failed to isolate\n", pfn);
		return -EBUSY;
	}

1573
	ret = migrate_pages(&pagelist, new_page, NULL, MPOL_MF_MOVE_ALL,
1574
				MIGRATE_SYNC, MR_MEMORY_FAILURE);
1575
	if (ret) {
1576 1577
		pr_info("soft offline: %#lx: migration failed %d, type %lx\n",
			pfn, ret, page->flags);
1578 1579 1580 1581 1582 1583 1584 1585
		/*
		 * We know that soft_offline_huge_page() tries to migrate
		 * only one hugepage pointed to by hpage, so we need not
		 * run through the pagelist here.
		 */
		putback_active_hugepage(hpage);
		if (ret > 0)
			ret = -EIO;
1586
	} else {
1587 1588 1589 1590
		/* overcommit hugetlb page will be freed to buddy */
		if (PageHuge(page)) {
			set_page_hwpoison_huge_page(hpage);
			dequeue_hwpoisoned_huge_page(hpage);
1591
			num_poisoned_pages_add(1 << compound_order(hpage));
1592 1593
		} else {
			SetPageHWPoison(page);
1594
			num_poisoned_pages_inc();
1595
		}
1596 1597 1598 1599
	}
	return ret;
}

1600 1601 1602 1603
static int __soft_offline_page(struct page *page, int flags)
{
	int ret;
	unsigned long pfn = page_to_pfn(page);
1604 1605

	/*
1606 1607 1608 1609
	 * Check PageHWPoison again inside page lock because PageHWPoison
	 * is set by memory_failure() outside page lock. Note that
	 * memory_failure() also double-checks PageHWPoison inside page lock,
	 * so there's no race between soft_offline_page() and memory_failure().
1610
	 */
1611 1612
	lock_page(page);
	wait_on_page_writeback(page);
1613 1614
	if (PageHWPoison(page)) {
		unlock_page(page);
1615
		put_hwpoison_page(page);
1616 1617 1618
		pr_info("soft offline: %#lx page already poisoned\n", pfn);
		return -EBUSY;
	}
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
	/*
	 * Try to invalidate first. This should work for
	 * non dirty unmapped page cache pages.
	 */
	ret = invalidate_inode_page(page);
	unlock_page(page);
	/*
	 * RED-PEN would be better to keep it isolated here, but we
	 * would need to fix isolation locking first.
	 */
	if (ret == 1) {
1630
		put_hwpoison_page(page);
1631
		pr_info("soft_offline: %#lx: invalidated\n", pfn);
1632
		SetPageHWPoison(page);
1633
		num_poisoned_pages_inc();
1634
		return 0;
1635 1636 1637 1638 1639 1640 1641 1642
	}

	/*
	 * Simple invalidation didn't work.
	 * Try to migrate to a new page instead. migrate.c
	 * handles a large number of cases for us.
	 */
	ret = isolate_lru_page(page);
1643 1644 1645 1646
	/*
	 * Drop page reference which is came from get_any_page()
	 * successful isolate_lru_page() already took another one.
	 */
1647
	put_hwpoison_page(page);
1648 1649
	if (!ret) {
		LIST_HEAD(pagelist);
1650
		inc_zone_page_state(page, NR_ISOLATED_ANON +
1651
					page_is_file_cache(page));
1652
		list_add(&page->lru, &pagelist);
1653
		ret = migrate_pages(&pagelist, new_page, NULL, MPOL_MF_MOVE_ALL,
1654
					MIGRATE_SYNC, MR_MEMORY_FAILURE);
1655
		if (ret) {
1656 1657 1658 1659 1660 1661 1662
			if (!list_empty(&pagelist)) {
				list_del(&page->lru);
				dec_zone_page_state(page, NR_ISOLATED_ANON +
						page_is_file_cache(page));
				putback_lru_page(page);
			}

1663
			pr_info("soft offline: %#lx: migration failed %d, type %lx\n",
1664 1665 1666 1667 1668
				pfn, ret, page->flags);
			if (ret > 0)
				ret = -EIO;
		}
	} else {
1669
		pr_info("soft offline: %#lx: isolation failed: %d, page count %d, type %lx\n",
1670
			pfn, ret, page_count(page), page->flags);
1671 1672 1673
	}
	return ret;
}
1674

1675 1676 1677 1678 1679 1680 1681
static int soft_offline_in_use_page(struct page *page, int flags)
{
	int ret;
	struct page *hpage = compound_head(page);

	if (!PageHuge(page) && PageTransHuge(hpage)) {
		lock_page(hpage);
1682 1683 1684 1685 1686 1687 1688
		if (!PageAnon(hpage) || unlikely(split_huge_page(hpage))) {
			unlock_page(hpage);
			if (!PageAnon(hpage))
				pr_info("soft offline: %#lx: non anonymous thp\n", page_to_pfn(page));
			else
				pr_info("soft offline: %#lx: thp split failed\n", page_to_pfn(page));
			put_hwpoison_page(hpage);
1689 1690
			return -EBUSY;
		}
1691
		unlock_page(hpage);
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
		get_hwpoison_page(page);
		put_hwpoison_page(hpage);
	}

	if (PageHuge(page))
		ret = soft_offline_huge_page(page, flags);
	else
		ret = __soft_offline_page(page, flags);

	return ret;
}

static void soft_offline_free_page(struct page *page)
{
	if (PageHuge(page)) {
		struct page *hpage = compound_head(page);

		set_page_hwpoison_huge_page(hpage);
		if (!dequeue_hwpoisoned_huge_page(hpage))
			num_poisoned_pages_add(1 << compound_order(hpage));
	} else {
		if (!TestSetPageHWPoison(page))
			num_poisoned_pages_inc();
	}
}

1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
/**
 * soft_offline_page - Soft offline a page.
 * @page: page to offline
 * @flags: flags. Same as memory_failure().
 *
 * Returns 0 on success, otherwise negated errno.
 *
 * Soft offline a page, by migration or invalidation,
 * without killing anything. This is for the case when
 * a page is not corrupted yet (so it's still valid to access),
 * but has had a number of corrected errors and is better taken
 * out.
 *
 * The actual policy on when to do that is maintained by
 * user space.
 *
 * This should never impact any application or cause data loss,
 * however it might take some time.
 *
 * This is not a 100% solution for all memory, but tries to be
 * ``good enough'' for the majority of memory.
 */
int soft_offline_page(struct page *page, int flags)
{
	int ret;
	unsigned long pfn = page_to_pfn(page);

	if (PageHWPoison(page)) {
		pr_info("soft offline: %#lx page already poisoned\n", pfn);
1747
		if (flags & MF_COUNT_INCREASED)
1748
			put_hwpoison_page(page);
1749 1750 1751
		return -EBUSY;
	}

1752
	get_online_mems();
1753
	ret = get_any_page(page, pfn, flags);
1754
	put_online_mems();
1755

1756 1757 1758 1759
	if (ret > 0)
		ret = soft_offline_in_use_page(page, flags);
	else if (ret == 0)
		soft_offline_free_page(page);
1760

1761 1762
	return ret;
}