memory-failure.c 47.9 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>
42
#include <linux/kernel-page-flags.h>
43
#include <linux/sched/signal.h>
44
#include <linux/sched/task.h>
45
#include <linux/ksm.h>
46
#include <linux/rmap.h>
47
#include <linux/export.h>
48 49 50
#include <linux/pagemap.h>
#include <linux/swap.h>
#include <linux/backing-dev.h>
51 52
#include <linux/migrate.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;
72 73
u32 hwpoison_filter_dev_major = ~0U;
u32 hwpoison_filter_dev_minor = ~0U;
74 75
u64 hwpoison_filter_flags_mask;
u64 hwpoison_filter_flags_value;
76
EXPORT_SYMBOL_GPL(hwpoison_filter_enable);
77 78
EXPORT_SYMBOL_GPL(hwpoison_filter_dev_major);
EXPORT_SYMBOL_GPL(hwpoison_filter_dev_minor);
79 80
EXPORT_SYMBOL_GPL(hwpoison_filter_flags_mask);
EXPORT_SYMBOL_GPL(hwpoison_filter_flags_value);
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.
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;
}

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;
}

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
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)
143 144 145 146 147 148 149 150
		return -EINVAL;

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

151 152
int hwpoison_filter(struct page *p)
{
153 154 155
	if (!hwpoison_filter_enable)
		return 0;

156 157 158
	if (hwpoison_filter_dev(p))
		return -EINVAL;

159 160 161
	if (hwpoison_filter_flags(p))
		return -EINVAL;

162 163 164
	if (hwpoison_filter_task(p))
		return -EINVAL;

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

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
static int kill_proc(struct task_struct *t, unsigned long addr,
182
			unsigned long pfn, struct page *page, int flags)
183
{
184
	short addr_lsb;
185 186
	int ret;

187 188
	pr_err("Memory failure: %#lx: Killing %s:%d due to hardware memory corruption\n",
		pfn, t->comm, t->pid);
189
	addr_lsb = compound_order(compound_head(page)) + PAGE_SHIFT;
190

191
	if ((flags & MF_ACTION_REQUIRED) && t->mm == current->mm) {
192 193
		ret = force_sig_mceerr(BUS_MCEERR_AR, (void __user *)addr,
				       addr_lsb, current);
194 195 196 197 198 199 200
	} 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?
		 */
201 202
		ret = send_sig_mceerr(BUS_MCEERR_AO, (void __user *)addr,
				      addr_lsb, t);  /* synchronous? */
203
	}
204
	if (ret < 0)
205
		pr_info("Memory failure: Error sending signal to %s:%d: %d\n",
206
			t->comm, t->pid, ret);
207 208 209
	return ret;
}

210 211 212 213
/*
 * 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.
 */
214
void shake_page(struct page *p, int access)
215
{
216 217 218
	if (PageHuge(p))
		return;

219 220 221 222
	if (!PageSlab(p)) {
		lru_add_drain_all();
		if (PageLRU(p))
			return;
223
		drain_all_pages(page_zone(p));
224 225 226
		if (PageLRU(p) || is_free_buddy_page(p))
			return;
	}
227

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

237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
/*
 * 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;
263
	char addr_valid;
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
};

/*
 * 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) {
289
			pr_err("Memory failure: Out of memory while machine check handling\n");
290 291 292 293 294 295 296 297 298 299 300 301 302
			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) {
303
		pr_info("Memory failure: Unable to find user space address %lx in %s\n",
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
			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.
 */
320
static void kill_procs(struct list_head *to_kill, int forcekill,
321
			  bool fail, struct page *page, unsigned long pfn,
322
			  int flags)
323 324 325 326
{
	struct to_kill *tk, *next;

	list_for_each_entry_safe (tk, next, to_kill, nd) {
327
		if (forcekill) {
328
			/*
329
			 * In case something went wrong with munmapping
330 331 332 333
			 * make sure the process doesn't catch the
			 * signal and then access the memory. Just kill it.
			 */
			if (fail || tk->addr_valid == 0) {
334
				pr_err("Memory failure: %#lx: forcibly killing %s:%d because of failure to unmap corrupted page\n",
335
				       pfn, tk->tsk->comm, tk->tsk->pid);
336 337 338 339 340 341 342 343 344
				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.
			 */
345
			else if (kill_proc(tk->tsk, tk->addr,
346
					      pfn, page, flags) < 0)
347
				pr_err("Memory failure: %#lx: Cannot send advisory machine check signal to %s:%d\n",
348
				       pfn, tk->tsk->comm, tk->tsk->pid);
349 350 351 352 353 354
		}
		put_task_struct(tk->tsk);
		kfree(tk);
	}
}

355 356 357 358 359 360 361 362 363
/*
 * 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)
364
{
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
	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;
383
	if (!tsk->mm)
384
		return NULL;
385
	if (force_early)
386 387 388 389 390 391 392
		return tsk;
	t = find_early_kill_thread(tsk);
	if (t)
		return t;
	if (sysctl_memory_failure_early_kill)
		return tsk;
	return NULL;
393 394 395 396 397 398
}

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

406
	av = page_lock_anon_vma_read(page);
407
	if (av == NULL)	/* Not actually mapped anymore */
408 409
		return;

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

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

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

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

447
		if (!t)
448
			continue;
449
		vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff,
450 451 452 453 454 455 456 457
				      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.
			 */
458 459
			if (vma->vm_mm == t->mm)
				add_to_kill(t, page, vma, to_kill, tkc);
460 461 462
		}
	}
	read_unlock(&tasklist_lock);
463
	i_mmap_unlock_read(mapping);
464 465 466 467 468 469 470 471
}

/*
 * 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.
 */
472 473
static void collect_procs(struct page *page, struct list_head *tokill,
				int force_early)
474 475 476 477 478 479 480 481 482 483
{
	struct to_kill *tk;

	if (!page->mapping)
		return;

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

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

static const char * const action_page_types[] = {
498 499 500 501 502 503 504
	[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",
505
	[MF_MSG_NON_PMD_HUGE]		= "non-pmd-sized huge page",
506 507 508 509 510 511 512 513 514 515 516 517 518
	[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",
519 520
};

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
/*
 * 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);
536 537 538 539 540 541 542

		/*
		 * Poisoned page might never drop its ref count to 0 so we have
		 * to uncharge it manually from its memcg.
		 */
		mem_cgroup_uncharge(p);

543 544 545
		/*
		 * drop the page count elevated by isolate_lru_page()
		 */
546
		put_page(p);
547 548 549 550 551
		return 0;
	}
	return -EIO;
}

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
static int truncate_error_page(struct page *p, unsigned long pfn,
				struct address_space *mapping)
{
	int ret = MF_FAILED;

	if (mapping->a_ops->error_remove_page) {
		int err = mapping->a_ops->error_remove_page(mapping, p);

		if (err != 0) {
			pr_info("Memory failure: %#lx: Failed to punch page: %d\n",
				pfn, err);
		} else if (page_has_private(p) &&
			   !try_to_release_page(p, GFP_NOIO)) {
			pr_info("Memory failure: %#lx: failed to release buffers\n",
				pfn);
		} else {
			ret = MF_RECOVERED;
		}
	} 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))
			ret = MF_RECOVERED;
		else
			pr_info("Memory failure: %#lx: Failed to invalidate\n",
				pfn);
	}

	return ret;
}

585 586 587 588 589 590 591
/*
 * 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)
{
592
	return MF_IGNORED;
593 594 595 596 597 598 599
}

/*
 * Page in unknown state. Do nothing.
 */
static int me_unknown(struct page *p, unsigned long pfn)
{
600
	pr_err("Memory failure: %#lx: Unknown page state\n", pfn);
601
	return MF_FAILED;
602 603 604 605 606 607 608 609 610
}

/*
 * Clean (or cleaned) page cache page.
 */
static int me_pagecache_clean(struct page *p, unsigned long pfn)
{
	struct address_space *mapping;

611 612
	delete_from_lru_cache(p);

613 614 615 616 617
	/*
	 * For anonymous pages we're done the only reference left
	 * should be the one m_f() holds.
	 */
	if (PageAnon(p))
618
		return MF_RECOVERED;
619 620 621 622 623 624 625 626 627 628 629 630 631

	/*
	 * 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
		 */
632
		return MF_FAILED;
633 634 635 636 637 638 639
	}

	/*
	 * 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.
	 */
640
	return truncate_error_page(p, pfn, mapping);
641 642 643
}

/*
644
 * Dirty pagecache page
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
 * 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
677
		 * and the page is dropped between then the error
678 679 680 681 682 683 684 685 686 687 688
		 * 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.
		 */
689
		mapping_set_error(mapping, -EIO);
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
	}

	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);

720
	if (!delete_from_lru_cache(p))
721
		return MF_DELAYED;
722
	else
723
		return MF_FAILED;
724 725 726 727 728
}

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

730
	if (!delete_from_lru_cache(p))
731
		return MF_RECOVERED;
732
	else
733
		return MF_FAILED;
734 735 736 737 738
}

/*
 * Huge pages. Needs work.
 * Issues:
739 740
 * - 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.
741 742 743
 */
static int me_huge_page(struct page *p, unsigned long pfn)
{
744
	int res = 0;
745
	struct page *hpage = compound_head(p);
746
	struct address_space *mapping;
747 748 749 750

	if (!PageHuge(hpage))
		return MF_DELAYED;

751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
	mapping = page_mapping(hpage);
	if (mapping) {
		res = truncate_error_page(hpage, pfn, mapping);
	} else {
		unlock_page(hpage);
		/*
		 * migration entry prevents later access on error anonymous
		 * hugepage, so we can free and dissolve it into buddy to
		 * save healthy subpages.
		 */
		if (PageAnon(hpage))
			put_page(hpage);
		dissolve_free_huge_page(p);
		res = MF_RECOVERED;
		lock_page(hpage);
766
	}
767 768

	return res;
769 770 771 772 773 774 775 776 777
}

/*
 * 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
778
 * in its live cycle, so all accesses have to be extremely careful.
779 780 781 782 783 784
 *
 * This is not complete. More states could be added.
 * For any missing state don't attempt recovery.
 */

#define dirty		(1UL << PG_dirty)
785
#define sc		((1UL << PG_swapcache) | (1UL << PG_swapbacked))
786 787 788 789 790 791 792 793 794 795 796
#define unevict		(1UL << PG_unevictable)
#define mlock		(1UL << PG_mlocked)
#define writeback	(1UL << PG_writeback)
#define lru		(1UL << PG_lru)
#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;
797
	enum mf_action_page_type type;
798 799
	int (*action)(struct page *p, unsigned long pfn);
} error_states[] = {
800
	{ reserved,	reserved,	MF_MSG_KERNEL,	me_kernel },
801 802 803 804
	/*
	 * free pages are specially detected outside this table:
	 * PG_buddy pages only make a small fraction of all free pages.
	 */
805 806 807 808 809 810

	/*
	 * 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.
	 */
811
	{ slab,		slab,		MF_MSG_SLAB,	me_kernel },
812

813
	{ head,		head,		MF_MSG_HUGE,		me_huge_page },
814

815 816
	{ sc|dirty,	sc|dirty,	MF_MSG_DIRTY_SWAPCACHE,	me_swapcache_dirty },
	{ sc|dirty,	sc,		MF_MSG_CLEAN_SWAPCACHE,	me_swapcache_clean },
817

818 819
	{ mlock|dirty,	mlock|dirty,	MF_MSG_DIRTY_MLOCKED_LRU,	me_pagecache_dirty },
	{ mlock|dirty,	mlock,		MF_MSG_CLEAN_MLOCKED_LRU,	me_pagecache_clean },
820

821 822
	{ unevict|dirty, unevict|dirty,	MF_MSG_DIRTY_UNEVICTABLE_LRU,	me_pagecache_dirty },
	{ unevict|dirty, unevict,	MF_MSG_CLEAN_UNEVICTABLE_LRU,	me_pagecache_clean },
823

824 825
	{ lru|dirty,	lru|dirty,	MF_MSG_DIRTY_LRU,	me_pagecache_dirty },
	{ lru|dirty,	lru,		MF_MSG_CLEAN_LRU,	me_pagecache_clean },
826 827 828 829

	/*
	 * Catchall entry: must be at end.
	 */
830
	{ 0,		0,		MF_MSG_UNKNOWN,	me_unknown },
831 832
};

833 834 835 836 837 838 839 840 841 842
#undef dirty
#undef sc
#undef unevict
#undef mlock
#undef writeback
#undef lru
#undef head
#undef slab
#undef reserved

843 844 845 846
/*
 * "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().
 */
847 848
static void action_result(unsigned long pfn, enum mf_action_page_type type,
			  enum mf_result result)
849
{
850 851
	trace_memory_failure_event(pfn, type, result);

852
	pr_err("Memory failure: %#lx: recovery action for %s: %s\n",
853
		pfn, action_page_types[type], action_name[result]);
854 855 856
}

static int page_action(struct page_state *ps, struct page *p,
857
			unsigned long pfn)
858 859
{
	int result;
860
	int count;
861 862

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

864
	count = page_count(p) - 1;
865
	if (ps->action == me_swapcache_dirty && result == MF_DELAYED)
866
		count--;
867
	if (count > 0) {
868
		pr_err("Memory failure: %#lx: %s still referenced by %d users\n",
869
		       pfn, action_page_types[ps->type], count);
870
		result = MF_FAILED;
871
	}
872
	action_result(pfn, ps->type, result);
873 874 875 876 877 878

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

879
	return (result == MF_RECOVERED || result == MF_DELAYED) ? 0 : -EBUSY;
880 881
}

882 883 884 885 886 887 888 889 890 891 892
/**
 * 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);

893
	if (!PageHuge(head) && PageTransHuge(head)) {
894 895 896 897 898 899 900
		/*
		 * 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)) {
901
			pr_err("Memory failure: %#lx: non anonymous thp\n",
902 903 904
				page_to_pfn(page));
			return 0;
		}
905 906
	}

907 908 909 910
	if (get_page_unless_zero(head)) {
		if (head == compound_head(page))
			return 1;

911 912
		pr_info("Memory failure: %#lx cannot catch tail\n",
			page_to_pfn(page));
913 914 915 916
		put_page(head);
	}

	return 0;
917 918 919
}
EXPORT_SYMBOL_GPL(get_hwpoison_page);

920 921 922 923
/*
 * Do all that is necessary to remove user space mappings. Unmap
 * the pages and send SIGBUS to the processes if the data was dirty.
 */
924
static bool hwpoison_user_mappings(struct page *p, unsigned long pfn,
925
				  int flags, struct page **hpagep)
926
{
927
	enum ttu_flags ttu = TTU_IGNORE_MLOCK | TTU_IGNORE_ACCESS;
928 929
	struct address_space *mapping;
	LIST_HEAD(tokill);
930
	bool unmap_success;
931
	int kill = 1, forcekill;
932
	struct page *hpage = *hpagep;
933
	bool mlocked = PageMlocked(hpage);
934

935 936 937 938 939
	/*
	 * Here we are interested only in user-mapped pages, so skip any
	 * other types of pages.
	 */
	if (PageReserved(p) || PageSlab(p))
940
		return true;
941
	if (!(PageLRU(hpage) || PageHuge(p)))
942
		return true;
943 944 945 946 947

	/*
	 * This check implies we don't kill processes if their pages
	 * are in the swap cache early. Those are always late kills.
	 */
948
	if (!page_mapped(hpage))
949
		return true;
950

951
	if (PageKsm(p)) {
952
		pr_err("Memory failure: %#lx: can't handle KSM pages.\n", pfn);
953
		return false;
954
	}
955 956

	if (PageSwapCache(p)) {
957 958
		pr_err("Memory failure: %#lx: keeping poisoned page in swap cache\n",
			pfn);
959 960 961 962 963 964
		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.
965 966
	 * XXX: the dirty test could be racy: set_page_dirty() may not always
	 * be called inside page lock (it's recommended but not enforced).
967
	 */
968
	mapping = page_mapping(hpage);
969
	if (!(flags & MF_MUST_KILL) && !PageDirty(hpage) && mapping &&
970 971 972
	    mapping_cap_writeback_dirty(mapping)) {
		if (page_mkclean(hpage)) {
			SetPageDirty(hpage);
973 974 975
		} else {
			kill = 0;
			ttu |= TTU_IGNORE_HWPOISON;
976
			pr_info("Memory failure: %#lx: corrupted page was clean: dropped without side effects\n",
977 978 979 980 981 982 983 984 985 986 987 988 989
				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)
990
		collect_procs(hpage, &tokill, flags & MF_ACTION_REQUIRED);
991

992 993
	unmap_success = try_to_unmap(hpage, ttu);
	if (!unmap_success)
994
		pr_err("Memory failure: %#lx: failed to unmap page (mapcount=%d)\n",
995
		       pfn, page_mapcount(hpage));
996

997 998 999 1000 1001 1002 1003
	/*
	 * try_to_unmap() might put mlocked page in lru cache, so call
	 * shake_page() again to ensure that it's flushed.
	 */
	if (mlocked)
		shake_page(hpage, 0);

1004 1005 1006 1007
	/*
	 * 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
1008 1009
	 * was dirty or the process is not restartable,
	 * otherwise the tokill list is merely
1010 1011 1012 1013
	 * freed.  When there was a problem unmapping earlier
	 * use a more force-full uncatchable kill to prevent
	 * any accesses to the poisoned memory.
	 */
1014
	forcekill = PageDirty(hpage) || (flags & MF_MUST_KILL);
1015
	kill_procs(&tokill, forcekill, !unmap_success, p, pfn, flags);
1016

1017
	return unmap_success;
1018 1019
}

1020 1021
static int identify_page_state(unsigned long pfn, struct page *p,
				unsigned long page_flags)
1022 1023
{
	struct page_state *ps;
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042

	/*
	 * The first check uses the current page flags which may not have any
	 * relevant information. The second check with the saved page flags 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)
			break;

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

	if (!ps->mask)
		for (ps = error_states;; ps++)
			if ((page_flags & ps->mask) == ps->res)
				break;
	return page_action(ps, p, pfn);
}

1043
static int memory_failure_hugetlb(unsigned long pfn, int flags)
1044
{
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
	struct page *p = pfn_to_page(pfn);
	struct page *head = compound_head(p);
	int res;
	unsigned long page_flags;

	if (TestSetPageHWPoison(head)) {
		pr_err("Memory failure: %#lx: already hardware poisoned\n",
		       pfn);
		return 0;
	}

	num_poisoned_pages_inc();

	if (!(flags & MF_COUNT_INCREASED) && !get_hwpoison_page(p)) {
		/*
		 * Check "filter hit" and "race with other subpage."
		 */
		lock_page(head);
		if (PageHWPoison(head)) {
			if ((hwpoison_filter(p) && TestClearPageHWPoison(p))
			    || (p != head && TestSetPageHWPoison(head))) {
				num_poisoned_pages_dec();
				unlock_page(head);
				return 0;
			}
		}
		unlock_page(head);
		dissolve_free_huge_page(p);
		action_result(pfn, MF_MSG_FREE_HUGE, MF_DELAYED);
		return 0;
	}

	lock_page(head);
	page_flags = head->flags;

	if (!PageHWPoison(head)) {
		pr_err("Memory failure: %#lx: just unpoisoned\n", pfn);
		num_poisoned_pages_dec();
		unlock_page(head);
		put_hwpoison_page(head);
		return 0;
	}

1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
	/*
	 * TODO: hwpoison for pud-sized hugetlb doesn't work right now, so
	 * simply disable it. In order to make it work properly, we need
	 * make sure that:
	 *  - conversion of a pud that maps an error hugetlb into hwpoison
	 *    entry properly works, and
	 *  - other mm code walking over page table is aware of pud-aligned
	 *    hwpoison entries.
	 */
	if (huge_page_size(page_hstate(head)) > PMD_SIZE) {
		action_result(pfn, MF_MSG_NON_PMD_HUGE, MF_IGNORED);
		res = -EBUSY;
		goto out;
	}

1103
	if (!hwpoison_user_mappings(p, pfn, flags, &head)) {
1104 1105 1106 1107 1108
		action_result(pfn, MF_MSG_UNMAP_FAILED, MF_IGNORED);
		res = -EBUSY;
		goto out;
	}

1109
	res = identify_page_state(pfn, p, page_flags);
1110 1111 1112 1113 1114
out:
	unlock_page(head);
	return res;
}

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
/**
 * memory_failure - Handle memory failure of a page.
 * @pfn: Page Number of the corrupted page
 * @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.
 */
1132
int memory_failure(unsigned long pfn, int flags)
1133 1134
{
	struct page *p;
1135
	struct page *hpage;
1136
	struct page *orig_head;
1137
	int res;
1138
	unsigned long page_flags;
1139 1140

	if (!sysctl_memory_failure_recovery)
1141
		panic("Memory failure on page %lx", pfn);
1142 1143

	if (!pfn_valid(pfn)) {
1144 1145
		pr_err("Memory failure: %#lx: memory outside kernel control\n",
			pfn);
1146
		return -ENXIO;
1147 1148 1149
	}

	p = pfn_to_page(pfn);
1150
	if (PageHuge(p))
1151
		return memory_failure_hugetlb(pfn, flags);
1152
	if (TestSetPageHWPoison(p)) {
1153 1154
		pr_err("Memory failure: %#lx: already hardware poisoned\n",
			pfn);
1155 1156 1157
		return 0;
	}

1158
	orig_head = hpage = compound_head(p);
1159
	num_poisoned_pages_inc();
1160 1161 1162 1163 1164

	/*
	 * 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.
1165
	 * 2) it's part of a non-compound high order page.
1166 1167 1168 1169 1170 1171
	 *    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.
	 */
1172
	if (!(flags & MF_COUNT_INCREASED) && !get_hwpoison_page(p)) {
1173
		if (is_free_buddy_page(p)) {
1174
			action_result(pfn, MF_MSG_BUDDY, MF_DELAYED);
1175 1176
			return 0;
		} else {
1177
			action_result(pfn, MF_MSG_KERNEL_HIGH_ORDER, MF_IGNORED);
1178 1179
			return -EBUSY;
		}
1180 1181
	}

1182
	if (PageTransHuge(hpage)) {
1183 1184 1185 1186
		lock_page(p);
		if (!PageAnon(p) || unlikely(split_huge_page(p))) {
			unlock_page(p);
			if (!PageAnon(p))
1187 1188
				pr_err("Memory failure: %#lx: non anonymous thp\n",
					pfn);
1189
			else
1190 1191
				pr_err("Memory failure: %#lx: thp split failed\n",
					pfn);
1192
			if (TestClearPageHWPoison(p))
1193
				num_poisoned_pages_dec();
1194
			put_hwpoison_page(p);
1195 1196
			return -EBUSY;
		}
1197
		unlock_page(p);
1198 1199 1200 1201
		VM_BUG_ON_PAGE(!page_count(p), p);
		hpage = compound_head(p);
	}

1202 1203 1204
	/*
	 * We ignore non-LRU pages for good reasons.
	 * - PG_locked is only well defined for LRU pages and a few others
1205
	 * - to avoid races with __SetPageLocked()
1206 1207 1208 1209
	 * - 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.
	 */
1210 1211 1212 1213 1214 1215 1216 1217
	shake_page(p, 0);
	/* shake_page could have turned it free. */
	if (!PageLRU(p) && is_free_buddy_page(p)) {
		if (flags & MF_COUNT_INCREASED)
			action_result(pfn, MF_MSG_BUDDY, MF_DELAYED);
		else
			action_result(pfn, MF_MSG_BUDDY_2ND, MF_DELAYED);
		return 0;
1218 1219
	}

1220
	lock_page(p);
1221

1222 1223 1224 1225
	/*
	 * The page could have changed compound pages during the locking.
	 * If this happens just bail out.
	 */
1226
	if (PageCompound(p) && compound_head(p) != orig_head) {
1227
		action_result(pfn, MF_MSG_DIFFERENT_COMPOUND, MF_IGNORED);
1228 1229 1230 1231
		res = -EBUSY;
		goto out;
	}

1232 1233 1234 1235 1236 1237 1238
	/*
	 * 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.
	 */
1239 1240 1241 1242
	if (PageHuge(p))
		page_flags = hpage->flags;
	else
		page_flags = p->flags;
1243

1244 1245 1246 1247
	/*
	 * unpoison always clear PG_hwpoison inside page lock
	 */
	if (!PageHWPoison(p)) {
1248
		pr_err("Memory failure: %#lx: just unpoisoned\n", pfn);
1249
		num_poisoned_pages_dec();
1250 1251
		unlock_page(p);
		put_hwpoison_page(p);
1252
		return 0;
1253
	}
1254 1255
	if (hwpoison_filter(p)) {
		if (TestClearPageHWPoison(p))
1256
			num_poisoned_pages_dec();
1257 1258
		unlock_page(p);
		put_hwpoison_page(p);
1259 1260
		return 0;
	}
1261

1262
	if (!PageTransTail(p) && !PageLRU(p))
1263 1264
		goto identify_page_state;

1265 1266 1267 1268
	/*
	 * It's very difficult to mess with pages currently under IO
	 * and in many cases impossible, so we just avoid it here.
	 */
1269 1270 1271 1272
	wait_on_page_writeback(p);

	/*
	 * Now take care of user space mappings.
1273
	 * Abort on fail: __delete_from_page_cache() assumes unmapped page.
1274 1275 1276
	 *
	 * When the raw error page is thp tail page, hpage points to the raw
	 * page after thp split.
1277
	 */
1278
	if (!hwpoison_user_mappings(p, pfn, flags, &hpage)) {
1279
		action_result(pfn, MF_MSG_UNMAP_FAILED, MF_IGNORED);
1280 1281 1282
		res = -EBUSY;
		goto out;
	}
1283 1284 1285 1286

	/*
	 * Torn down by someone else?
	 */
1287
	if (PageLRU(p) && !PageSwapCache(p) && p->mapping == NULL) {
1288
		action_result(pfn, MF_MSG_TRUNCATED_LRU, MF_IGNORED);
1289
		res = -EBUSY;
1290 1291 1292
		goto out;
	}

1293
identify_page_state:
1294
	res = identify_page_state(pfn, p, page_flags);
1295
out:
1296
	unlock_page(p);
1297 1298
	return res;
}
1299
EXPORT_SYMBOL_GPL(memory_failure);
1300

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
#define MEMORY_FAILURE_FIFO_ORDER	4
#define MEMORY_FAILURE_FIFO_SIZE	(1 << MEMORY_FAILURE_FIFO_ORDER)

struct memory_failure_entry {
	unsigned long pfn;
	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
 * @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.
 */
1334
void memory_failure_queue(unsigned long pfn, int flags)
1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
{
	struct memory_failure_cpu *mf_cpu;
	unsigned long proc_flags;
	struct memory_failure_entry entry = {
		.pfn =		pfn,
		.flags =	flags,
	};

	mf_cpu = &get_cpu_var(memory_failure_cpu);
	spin_lock_irqsave(&mf_cpu->lock, proc_flags);
Stefani Seibold's avatar
Stefani Seibold committed
1345
	if (kfifo_put(&mf_cpu->fifo, entry))
1346 1347
		schedule_work_on(smp_processor_id(), &mf_cpu->work);
	else
1348
		pr_err("Memory failure: buffer overflow when queuing memory failure at %#lx\n",
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
		       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;

1362
	mf_cpu = this_cpu_ptr(&memory_failure_cpu);
1363 1364 1365 1366 1367 1368
	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;
1369 1370 1371
		if (entry.flags & MF_SOFT_OFFLINE)
			soft_offline_page(pfn_to_page(entry.pfn), entry.flags);
		else
1372
			memory_failure(entry.pfn, entry.flags);
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
	}
}

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);

1392 1393 1394 1395 1396 1397
#define unpoison_pr_info(fmt, pfn, rs)			\
({							\
	if (__ratelimit(rs))				\
		pr_info(fmt, pfn);			\
})

1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
/**
 * 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;
1415 1416
	static DEFINE_RATELIMIT_STATE(unpoison_rs, DEFAULT_RATELIMIT_INTERVAL,
					DEFAULT_RATELIMIT_BURST);
1417 1418 1419 1420 1421 1422 1423 1424

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

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

	if (!PageHWPoison(p)) {
1425
		unpoison_pr_info("Unpoison: Page was already unpoisoned %#lx\n",
1426
				 pfn, &unpoison_rs);
1427 1428 1429
		return 0;
	}

1430
	if (page_count(page) > 1) {
1431
		unpoison_pr_info("Unpoison: Someone grabs the hwpoison page %#lx\n",
1432
				 pfn, &unpoison_rs);
1433 1434 1435 1436
		return 0;
	}

	if (page_mapped(page)) {
1437
		unpoison_pr_info("Unpoison: Someone maps the hwpoison page %#lx\n",
1438
				 pfn, &unpoison_rs);
1439 1440 1441 1442
		return 0;
	}

	if (page_mapping(page)) {
1443
		unpoison_pr_info("Unpoison: the hwpoison page has non-NULL mapping %#lx\n",
1444
				 pfn, &unpoison_rs);
1445 1446 1447
		return 0;
	}

1448 1449 1450 1451 1452
	/*
	 * 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.
	 */
1453
	if (!PageHuge(page) && PageTransHuge(page)) {
1454
		unpoison_pr_info("Unpoison: Memory failure is now running on %#lx\n",
1455
				 pfn, &unpoison_rs);
1456
		return 0;
1457 1458
	}

1459
	if (!get_hwpoison_page(p)) {
1460
		if (TestClearPageHWPoison(p))
1461
			num_poisoned_pages_dec();
1462
		unpoison_pr_info("Unpoison: Software-unpoisoned free page %#lx\n",
1463
				 pfn, &unpoison_rs);
1464 1465 1466
		return 0;
	}

1467
	lock_page(page);
1468 1469 1470 1471 1472 1473
	/*
	 * 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.
	 */
1474
	if (TestClearPageHWPoison(page)) {
1475
		unpoison_pr_info("Unpoison: Software-unpoisoned page %#lx\n",
1476
				 pfn, &unpoison_rs);
1477
		num_poisoned_pages_dec();
1478 1479 1480 1481
		freeit = 1;
	}
	unlock_page(page);

1482
	put_hwpoison_page(page);
1483
	if (freeit && !(pfn == my_zero_pfn(0) && page_count(p) == 1))
1484
		put_hwpoison_page(page);
1485 1486 1487 1488

	return 0;
}
EXPORT_SYMBOL(unpoison_memory);
1489

1490
static struct page *new_page(struct page *p, unsigned long private)
1491
{
1492
	int nid = page_to_nid(p);
1493

1494
	return new_page_nodemask(p, nid, &node_states[N_MEMORY]);
1495 1496 1497 1498 1499 1500 1501 1502
}

/*
 * 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.
 */
1503
static int __get_any_page(struct page *p, unsigned long pfn, int flags)
1504 1505 1506 1507 1508 1509
{
	int ret;

	if (flags & MF_COUNT_INCREASED)
		return 1;

1510 1511 1512 1513
	/*
	 * When the target page is a free hugepage, just remove it
	 * from free hugepage list.
	 */
1514
	if (!get_hwpoison_page(p)) {
1515
		if (PageHuge(p)) {