Blame view
mm/memory-failure.c
46.4 KB
6a46079cf HWPOISON: The hig... |
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 |
1c80b990a HWPOISON: Improve... |
10 |
* hardware as being corrupted usually due to a multi-bit ECC memory or cache |
6a46079cf HWPOISON: The hig... |
11 |
* failure. |
1c80b990a HWPOISON: Improve... |
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. |
6a46079cf HWPOISON: The hig... |
15 16 |
* * Handles page cache pages in various states. The tricky part |
1c80b990a HWPOISON: Improve... |
17 18 19 20 21 22 23 24 25 26 27 28 29 |
* 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. * * 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. |
6a46079cf HWPOISON: The hig... |
30 31 32 33 34 35 36 37 |
*/ /* * Notebook: * - hugetlb needs more code * - kcore/oldmem/vmcore/mem/kmem check for hwpoison pages * - pass bad pages to kdump next kernel */ |
6a46079cf HWPOISON: The hig... |
38 39 40 |
#include <linux/kernel.h> #include <linux/mm.h> #include <linux/page-flags.h> |
478c5ffc0 HWPOISON: add pag... |
41 |
#include <linux/kernel-page-flags.h> |
6a46079cf HWPOISON: The hig... |
42 |
#include <linux/sched.h> |
01e00f880 HWPOISON: fix oop... |
43 |
#include <linux/ksm.h> |
6a46079cf HWPOISON: The hig... |
44 |
#include <linux/rmap.h> |
b9e15bafd mm: Add export.h ... |
45 |
#include <linux/export.h> |
6a46079cf HWPOISON: The hig... |
46 47 48 |
#include <linux/pagemap.h> #include <linux/swap.h> #include <linux/backing-dev.h> |
facb6011f HWPOISON: Add sof... |
49 50 51 |
#include <linux/migrate.h> #include <linux/page-isolation.h> #include <linux/suspend.h> |
5a0e3ad6a include cleanup: ... |
52 |
#include <linux/slab.h> |
bf998156d KVM: Avoid killin... |
53 |
#include <linux/swapops.h> |
7af446a84 HWPOISON, hugetlb... |
54 |
#include <linux/hugetlb.h> |
20d6c96b5 mem-hotplug: intr... |
55 |
#include <linux/memory_hotplug.h> |
5db8a73a8 mm/memory-failure... |
56 |
#include <linux/mm_inline.h> |
ea8f5fb8a HWPoison: add mem... |
57 |
#include <linux/kfifo.h> |
6a46079cf HWPOISON: The hig... |
58 59 60 61 62 |
#include "internal.h" int sysctl_memory_failure_early_kill __read_mostly = 0; int sysctl_memory_failure_recovery __read_mostly = 1; |
293c07e31 memory-failure: u... |
63 |
atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0); |
6a46079cf HWPOISON: The hig... |
64 |
|
27df5068e HWPOISON: Add PRO... |
65 |
#if defined(CONFIG_HWPOISON_INJECT) || defined(CONFIG_HWPOISON_INJECT_MODULE) |
1bfe5febe HWPOISON: add an ... |
66 |
u32 hwpoison_filter_enable = 0; |
7c116f2b0 HWPOISON: add fs/... |
67 68 |
u32 hwpoison_filter_dev_major = ~0U; u32 hwpoison_filter_dev_minor = ~0U; |
478c5ffc0 HWPOISON: add pag... |
69 70 |
u64 hwpoison_filter_flags_mask; u64 hwpoison_filter_flags_value; |
1bfe5febe HWPOISON: add an ... |
71 |
EXPORT_SYMBOL_GPL(hwpoison_filter_enable); |
7c116f2b0 HWPOISON: add fs/... |
72 73 |
EXPORT_SYMBOL_GPL(hwpoison_filter_dev_major); EXPORT_SYMBOL_GPL(hwpoison_filter_dev_minor); |
478c5ffc0 HWPOISON: add pag... |
74 75 |
EXPORT_SYMBOL_GPL(hwpoison_filter_flags_mask); EXPORT_SYMBOL_GPL(hwpoison_filter_flags_value); |
7c116f2b0 HWPOISON: add fs/... |
76 77 78 79 80 81 82 83 84 85 86 |
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; /* |
1c80b990a HWPOISON: Improve... |
87 |
* page_mapping() does not accept slab pages. |
7c116f2b0 HWPOISON: add fs/... |
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
*/ 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; } |
478c5ffc0 HWPOISON: add pag... |
106 107 108 109 110 111 112 113 114 115 116 |
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; } |
4fd466eb4 HWPOISON: add mem... |
117 118 119 120 121 122 123 124 125 126 |
/* * 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. */ |
c255a4580 memcg: rename con... |
127 |
#ifdef CONFIG_MEMCG_SWAP |
4fd466eb4 HWPOISON: add mem... |
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 |
u64 hwpoison_filter_memcg; EXPORT_SYMBOL_GPL(hwpoison_filter_memcg); static int hwpoison_filter_task(struct page *p) { struct mem_cgroup *mem; struct cgroup_subsys_state *css; unsigned long ino; if (!hwpoison_filter_memcg) return 0; mem = try_get_mem_cgroup_from_page(p); if (!mem) return -EINVAL; css = mem_cgroup_css(mem); |
b16649240 cgroup: introduce... |
144 |
ino = cgroup_ino(css->cgroup); |
4fd466eb4 HWPOISON: add mem... |
145 |
css_put(css); |
b16649240 cgroup: introduce... |
146 |
if (!ino || ino != hwpoison_filter_memcg) |
4fd466eb4 HWPOISON: add mem... |
147 148 149 150 151 152 153 |
return -EINVAL; return 0; } #else static int hwpoison_filter_task(struct page *p) { return 0; } #endif |
7c116f2b0 HWPOISON: add fs/... |
154 155 |
int hwpoison_filter(struct page *p) { |
1bfe5febe HWPOISON: add an ... |
156 157 |
if (!hwpoison_filter_enable) return 0; |
7c116f2b0 HWPOISON: add fs/... |
158 159 |
if (hwpoison_filter_dev(p)) return -EINVAL; |
478c5ffc0 HWPOISON: add pag... |
160 161 |
if (hwpoison_filter_flags(p)) return -EINVAL; |
4fd466eb4 HWPOISON: add mem... |
162 163 |
if (hwpoison_filter_task(p)) return -EINVAL; |
7c116f2b0 HWPOISON: add fs/... |
164 165 |
return 0; } |
27df5068e HWPOISON: Add PRO... |
166 167 168 169 170 171 |
#else int hwpoison_filter(struct page *p) { return 0; } #endif |
7c116f2b0 HWPOISON: add fs/... |
172 |
EXPORT_SYMBOL_GPL(hwpoison_filter); |
6a46079cf HWPOISON: The hig... |
173 |
/* |
7329bbeb9 HWPOISON: Add cod... |
174 175 176 |
* 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 |
6a46079cf HWPOISON: The hig... |
177 |
*/ |
7329bbeb9 HWPOISON: Add cod... |
178 179 |
static int kill_proc(struct task_struct *t, unsigned long addr, int trapno, unsigned long pfn, struct page *page, int flags) |
6a46079cf HWPOISON: The hig... |
180 181 182 183 184 |
{ struct siginfo si; int ret; printk(KERN_ERR |
7329bbeb9 HWPOISON: Add cod... |
185 186 |
"MCE %#lx: Killing %s:%d due to hardware memory corruption ", |
6a46079cf HWPOISON: The hig... |
187 188 189 |
pfn, t->comm, t->pid); si.si_signo = SIGBUS; si.si_errno = 0; |
6a46079cf HWPOISON: The hig... |
190 191 192 193 |
si.si_addr = (void *)addr; #ifdef __ARCH_SI_TRAPNO si.si_trapno = trapno; #endif |
f9121153f mm/hwpoison: don'... |
194 |
si.si_addr_lsb = compound_order(compound_head(page)) + PAGE_SHIFT; |
7329bbeb9 HWPOISON: Add cod... |
195 196 197 198 199 200 201 202 203 204 205 206 207 208 |
if ((flags & MF_ACTION_REQUIRED) && t == current) { si.si_code = BUS_MCEERR_AR; ret = force_sig_info(SIGBUS, &si, t); } 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? */ } |
6a46079cf HWPOISON: The hig... |
209 210 211 212 213 214 215 216 |
if (ret < 0) printk(KERN_INFO "MCE: Error sending signal to %s:%d: %d ", t->comm, t->pid, ret); return ret; } /* |
588f9ce6c HWPOISON: Be more... |
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. */ |
facb6011f HWPOISON: Add sof... |
220 |
void shake_page(struct page *p, int access) |
588f9ce6c HWPOISON: Be more... |
221 222 223 224 225 226 227 228 229 |
{ if (!PageSlab(p)) { lru_add_drain_all(); if (PageLRU(p)) return; drain_all_pages(); if (PageLRU(p) || is_free_buddy_page(p)) return; } |
facb6011f HWPOISON: Add sof... |
230 |
|
588f9ce6c HWPOISON: Be more... |
231 |
/* |
af241a083 thp: fix unsuitab... |
232 233 |
* Only call shrink_slab here (which would also shrink other caches) if * access is not potentially fatal. |
588f9ce6c HWPOISON: Be more... |
234 |
*/ |
facb6011f HWPOISON: Add sof... |
235 236 |
if (access) { int nr; |
0ce3d7445 shrinker: add nod... |
237 |
int nid = page_to_nid(p); |
facb6011f HWPOISON: Add sof... |
238 |
do { |
a09ed5e00 vmscan: change sh... |
239 240 |
struct shrink_control shrink = { .gfp_mask = GFP_KERNEL, |
a09ed5e00 vmscan: change sh... |
241 |
}; |
0ce3d7445 shrinker: add nod... |
242 |
node_set(nid, shrink.nodes_to_scan); |
a09ed5e00 vmscan: change sh... |
243 |
|
1495f230f vmscan: change sh... |
244 |
nr = shrink_slab(&shrink, 1000, 1000); |
47f43e7ef HWPOISON: Stop sh... |
245 |
if (page_count(p) == 1) |
facb6011f HWPOISON: Add sof... |
246 247 248 |
break; } while (nr > 10); } |
588f9ce6c HWPOISON: Be more... |
249 250 251 252 |
} EXPORT_SYMBOL_GPL(shake_page); /* |
6a46079cf HWPOISON: The hig... |
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 |
* 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; |
9033ae164 HWPOISON: Turn ad... |
278 |
char addr_valid; |
6a46079cf HWPOISON: The hig... |
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 |
}; /* * 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) { printk(KERN_ERR "MCE: Out of memory while machine check handling "); 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) { |
fb46e7352 HWPOISON: Convert... |
320 321 |
pr_info("MCE: Unable to find user space address %lx in %s ", |
6a46079cf HWPOISON: The hig... |
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 |
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. */ |
6751ed65d x86/mce: Fix sigi... |
338 |
static void kill_procs(struct list_head *to_kill, int forcekill, int trapno, |
7329bbeb9 HWPOISON: Add cod... |
339 340 |
int fail, struct page *page, unsigned long pfn, int flags) |
6a46079cf HWPOISON: The hig... |
341 342 343 344 |
{ struct to_kill *tk, *next; list_for_each_entry_safe (tk, next, to_kill, nd) { |
6751ed65d x86/mce: Fix sigi... |
345 |
if (forcekill) { |
6a46079cf HWPOISON: The hig... |
346 |
/* |
af901ca18 tree-wide: fix as... |
347 |
* In case something went wrong with munmapping |
6a46079cf HWPOISON: The hig... |
348 349 |
* make sure the process doesn't catch the * signal and then access the memory. Just kill it. |
6a46079cf HWPOISON: The hig... |
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 |
*/ if (fail || tk->addr_valid == 0) { printk(KERN_ERR "MCE %#lx: forcibly killing %s:%d because of failure to unmap corrupted page ", pfn, tk->tsk->comm, tk->tsk->pid); 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. */ |
7329bbeb9 HWPOISON: Add cod... |
365 366 |
else if (kill_proc(tk->tsk, tk->addr, trapno, pfn, page, flags) < 0) |
6a46079cf HWPOISON: The hig... |
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 |
printk(KERN_ERR "MCE %#lx: Cannot send advisory machine check signal to %s:%d ", pfn, tk->tsk->comm, tk->tsk->pid); } put_task_struct(tk->tsk); kfree(tk); } } static int task_early_kill(struct task_struct *tsk) { if (!tsk->mm) return 0; if (tsk->flags & PF_MCE_PROCESS) return !!(tsk->flags & PF_MCE_EARLY); return sysctl_memory_failure_early_kill; } /* * Collect processes when the error hit an anonymous page. */ static void collect_procs_anon(struct page *page, struct list_head *to_kill, struct to_kill **tkc) { struct vm_area_struct *vma; struct task_struct *tsk; struct anon_vma *av; |
bf181b9f9 mm anon rmap: rep... |
395 |
pgoff_t pgoff; |
6a46079cf HWPOISON: The hig... |
396 |
|
4fc3f1d66 mm/rmap, migratio... |
397 |
av = page_lock_anon_vma_read(page); |
6a46079cf HWPOISON: The hig... |
398 |
if (av == NULL) /* Not actually mapped anymore */ |
9b679320a mm/memory-failure... |
399 |
return; |
bf181b9f9 mm anon rmap: rep... |
400 |
pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT); |
9b679320a mm/memory-failure... |
401 |
read_lock(&tasklist_lock); |
6a46079cf HWPOISON: The hig... |
402 |
for_each_process (tsk) { |
5beb49305 mm: change anon_v... |
403 |
struct anon_vma_chain *vmac; |
6a46079cf HWPOISON: The hig... |
404 405 |
if (!task_early_kill(tsk)) continue; |
bf181b9f9 mm anon rmap: rep... |
406 407 |
anon_vma_interval_tree_foreach(vmac, &av->rb_root, pgoff, pgoff) { |
5beb49305 mm: change anon_v... |
408 |
vma = vmac->vma; |
6a46079cf HWPOISON: The hig... |
409 410 411 412 413 414 |
if (!page_mapped_in_vma(page, vma)) continue; if (vma->vm_mm == tsk->mm) add_to_kill(tsk, page, vma, to_kill, tkc); } } |
6a46079cf HWPOISON: The hig... |
415 |
read_unlock(&tasklist_lock); |
4fc3f1d66 mm/rmap, migratio... |
416 |
page_unlock_anon_vma_read(av); |
6a46079cf HWPOISON: The hig... |
417 418 419 420 421 422 423 424 425 426 |
} /* * Collect processes when the error hit a file mapped page. */ static void collect_procs_file(struct page *page, struct list_head *to_kill, struct to_kill **tkc) { struct vm_area_struct *vma; struct task_struct *tsk; |
6a46079cf HWPOISON: The hig... |
427 |
struct address_space *mapping = page->mapping; |
3d48ae45e mm: Convert i_mma... |
428 |
mutex_lock(&mapping->i_mmap_mutex); |
9b679320a mm/memory-failure... |
429 |
read_lock(&tasklist_lock); |
6a46079cf HWPOISON: The hig... |
430 431 432 433 434 |
for_each_process(tsk) { pgoff_t pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT); if (!task_early_kill(tsk)) continue; |
6b2dbba8b mm: replace vma p... |
435 |
vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, |
6a46079cf HWPOISON: The hig... |
436 437 438 439 440 441 442 443 444 445 446 447 |
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. */ if (vma->vm_mm == tsk->mm) add_to_kill(tsk, page, vma, to_kill, tkc); } } |
6a46079cf HWPOISON: The hig... |
448 |
read_unlock(&tasklist_lock); |
9b679320a mm/memory-failure... |
449 |
mutex_unlock(&mapping->i_mmap_mutex); |
6a46079cf HWPOISON: The hig... |
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 |
} /* * 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. */ static void collect_procs(struct page *page, struct list_head *tokill) { struct to_kill *tk; if (!page->mapping) return; tk = kmalloc(sizeof(struct to_kill), GFP_NOIO); if (!tk) return; if (PageAnon(page)) collect_procs_anon(page, tokill, &tk); else collect_procs_file(page, tokill, &tk); kfree(tk); } /* * Error handlers for various types of pages. */ enum outcome { |
d95ea51e3 HWPOISON: make se... |
480 481 |
IGNORED, /* Error: cannot be handled */ FAILED, /* Error: handling failed */ |
6a46079cf HWPOISON: The hig... |
482 |
DELAYED, /* Will be handled later */ |
6a46079cf HWPOISON: The hig... |
483 484 485 486 |
RECOVERED, /* Successfully recovered */ }; static const char *action_name[] = { |
d95ea51e3 HWPOISON: make se... |
487 |
[IGNORED] = "Ignored", |
6a46079cf HWPOISON: The hig... |
488 489 |
[FAILED] = "Failed", [DELAYED] = "Delayed", |
6a46079cf HWPOISON: The hig... |
490 491 492 493 |
[RECOVERED] = "Recovered", }; /* |
dc2a1cbf7 HWPOISON: introdu... |
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 |
* 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() */ page_cache_release(p); return 0; } return -EIO; } /* |
6a46079cf HWPOISON: The hig... |
518 519 520 521 522 523 |
* 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) { |
6a46079cf HWPOISON: The hig... |
524 525 526 527 528 529 530 531 532 533 534 535 536 537 |
return IGNORED; } /* * Page in unknown state. Do nothing. */ static int me_unknown(struct page *p, unsigned long pfn) { printk(KERN_ERR "MCE %#lx: Unknown page state ", pfn); return FAILED; } /* |
6a46079cf HWPOISON: The hig... |
538 539 540 541 542 543 544 |
* Clean (or cleaned) page cache page. */ static int me_pagecache_clean(struct page *p, unsigned long pfn) { int err; int ret = FAILED; struct address_space *mapping; |
dc2a1cbf7 HWPOISON: introdu... |
545 |
delete_from_lru_cache(p); |
6a46079cf HWPOISON: The hig... |
546 547 548 549 550 551 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 |
/* * For anonymous pages we're done the only reference left * should be the one m_f() holds. */ if (PageAnon(p)) return RECOVERED; /* * 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 */ return FAILED; } /* * 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) { printk(KERN_INFO "MCE %#lx: Failed to punch page: %d ", pfn, err); } else if (page_has_private(p) && !try_to_release_page(p, GFP_NOIO)) { |
fb46e7352 HWPOISON: Convert... |
581 582 |
pr_info("MCE %#lx: failed to release buffers ", pfn); |
6a46079cf HWPOISON: The hig... |
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 |
} else { ret = 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 = RECOVERED; else printk(KERN_INFO "MCE %#lx: Failed to invalidate ", pfn); } return ret; } /* |
549543dff mm, memory-failur... |
602 |
* Dirty pagecache page |
6a46079cf HWPOISON: The hig... |
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 |
* 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 |
25985edce Fix common misspe... |
635 |
* and the page is dropped between then the error |
6a46079cf HWPOISON: The hig... |
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 662 663 664 665 666 667 668 669 670 671 672 673 |
* 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) { |
6a46079cf HWPOISON: The hig... |
674 675 676 |
ClearPageDirty(p); /* Trigger EIO in shmem: */ ClearPageUptodate(p); |
dc2a1cbf7 HWPOISON: introdu... |
677 678 679 680 |
if (!delete_from_lru_cache(p)) return DELAYED; else return FAILED; |
6a46079cf HWPOISON: The hig... |
681 682 683 684 |
} static int me_swapcache_clean(struct page *p, unsigned long pfn) { |
6a46079cf HWPOISON: The hig... |
685 |
delete_from_swap_cache(p); |
e43c3afb3 HWPOISON: return ... |
686 |
|
dc2a1cbf7 HWPOISON: introdu... |
687 688 689 690 |
if (!delete_from_lru_cache(p)) return RECOVERED; else return FAILED; |
6a46079cf HWPOISON: The hig... |
691 692 693 694 695 |
} /* * Huge pages. Needs work. * Issues: |
93f70f900 HWPOISON, hugetlb... |
696 697 |
* - 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. |
6a46079cf HWPOISON: The hig... |
698 699 700 |
*/ static int me_huge_page(struct page *p, unsigned long pfn) { |
6de2b1aab HWPOISON, hugetlb... |
701 |
int res = 0; |
93f70f900 HWPOISON, hugetlb... |
702 703 704 705 706 707 708 709 710 711 712 713 |
struct page *hpage = compound_head(p); /* * 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))) { |
6de2b1aab HWPOISON, hugetlb... |
714 715 716 |
res = dequeue_hwpoisoned_huge_page(hpage); if (!res) return RECOVERED; |
93f70f900 HWPOISON, hugetlb... |
717 718 |
} return DELAYED; |
6a46079cf HWPOISON: The hig... |
719 720 721 722 723 724 725 726 727 |
} /* * 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 |
25985edce Fix common misspe... |
728 |
* in its live cycle, so all accesses have to be extremely careful. |
6a46079cf HWPOISON: The hig... |
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 |
* * 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 tail (1UL << PG_tail) #define compound (1UL << PG_compound) #define slab (1UL << PG_slab) |
6a46079cf HWPOISON: The hig... |
745 746 747 748 749 750 751 752 |
#define reserved (1UL << PG_reserved) static struct page_state { unsigned long mask; unsigned long res; char *msg; int (*action)(struct page *p, unsigned long pfn); } error_states[] = { |
d95ea51e3 HWPOISON: make se... |
753 |
{ reserved, reserved, "reserved kernel", me_kernel }, |
95d01fc66 HWPOISON: remove ... |
754 755 756 757 |
/* * free pages are specially detected outside this table: * PG_buddy pages only make a small fraction of all free pages. */ |
6a46079cf HWPOISON: The hig... |
758 759 760 761 762 763 764 765 766 767 768 769 770 771 |
/* * 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. */ { slab, slab, "kernel slab", me_kernel }, #ifdef CONFIG_PAGEFLAGS_EXTENDED { head, head, "huge", me_huge_page }, { tail, tail, "huge", me_huge_page }, #else { compound, compound, "huge", me_huge_page }, #endif |
ff604cf6d mm: hwpoison: fix... |
772 773 |
{ sc|dirty, sc|dirty, "dirty swapcache", me_swapcache_dirty }, { sc|dirty, sc, "clean swapcache", me_swapcache_clean }, |
6a46079cf HWPOISON: The hig... |
774 |
|
ff604cf6d mm: hwpoison: fix... |
775 |
{ mlock|dirty, mlock|dirty, "dirty mlocked LRU", me_pagecache_dirty }, |
e39862958 HWPOISON: check d... |
776 |
{ mlock|dirty, mlock, "clean mlocked LRU", me_pagecache_clean }, |
6a46079cf HWPOISON: The hig... |
777 |
|
5f4b9fc5c HWPOISON: change ... |
778 |
{ unevict|dirty, unevict|dirty, "dirty unevictable LRU", me_pagecache_dirty }, |
e39862958 HWPOISON: check d... |
779 |
{ unevict|dirty, unevict, "clean unevictable LRU", me_pagecache_clean }, |
5f4b9fc5c HWPOISON: change ... |
780 |
|
ff604cf6d mm: hwpoison: fix... |
781 |
{ lru|dirty, lru|dirty, "dirty LRU", me_pagecache_dirty }, |
6a46079cf HWPOISON: The hig... |
782 |
{ lru|dirty, lru, "clean LRU", me_pagecache_clean }, |
6a46079cf HWPOISON: The hig... |
783 784 785 786 787 788 |
/* * Catchall entry: must be at end. */ { 0, 0, "unknown page state", me_unknown }, }; |
2326c467d HWPOISON: Undefin... |
789 790 791 792 793 794 795 796 797 798 799 800 |
#undef dirty #undef sc #undef unevict #undef mlock #undef writeback #undef lru #undef swapbacked #undef head #undef tail #undef compound #undef slab #undef reserved |
ff604cf6d mm: hwpoison: fix... |
801 802 803 804 |
/* * "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(). */ |
6a46079cf HWPOISON: The hig... |
805 806 |
static void action_result(unsigned long pfn, char *msg, int result) { |
ff604cf6d mm: hwpoison: fix... |
807 808 809 |
pr_err("MCE %#lx: %s page recovery: %s ", pfn, msg, action_name[result]); |
6a46079cf HWPOISON: The hig... |
810 811 812 |
} static int page_action(struct page_state *ps, struct page *p, |
bd1ce5f91 HWPOISON: avoid g... |
813 |
unsigned long pfn) |
6a46079cf HWPOISON: The hig... |
814 815 |
{ int result; |
7456b0405 HWPOISON: fix inv... |
816 |
int count; |
6a46079cf HWPOISON: The hig... |
817 818 819 |
result = ps->action(p, pfn); action_result(pfn, ps->msg, result); |
7456b0405 HWPOISON: fix inv... |
820 |
|
bd1ce5f91 HWPOISON: avoid g... |
821 |
count = page_count(p) - 1; |
138ce286e HWPOISON: return ... |
822 823 824 |
if (ps->action == me_swapcache_dirty && result == DELAYED) count--; if (count != 0) { |
6a46079cf HWPOISON: The hig... |
825 826 827 |
printk(KERN_ERR "MCE %#lx: %s page still referenced by %d users ", |
7456b0405 HWPOISON: fix inv... |
828 |
pfn, ps->msg, count); |
138ce286e HWPOISON: return ... |
829 830 |
result = FAILED; } |
6a46079cf HWPOISON: The hig... |
831 832 833 834 835 |
/* Could do more checks here if page looks ok */ /* * Could adjust zone counters here to correct for the missing page. */ |
138ce286e HWPOISON: return ... |
836 |
return (result == RECOVERED || result == DELAYED) ? 0 : -EBUSY; |
6a46079cf HWPOISON: The hig... |
837 |
} |
6a46079cf HWPOISON: The hig... |
838 839 840 841 |
/* * Do all that is necessary to remove user space mappings. Unmap * the pages and send SIGBUS to the processes if the data was dirty. */ |
1668bfd5b HWPOISON: abort o... |
842 |
static int hwpoison_user_mappings(struct page *p, unsigned long pfn, |
54b9dd14d mm/memory-failure... |
843 |
int trapno, int flags, struct page **hpagep) |
6a46079cf HWPOISON: The hig... |
844 845 846 847 848 |
{ enum ttu_flags ttu = TTU_UNMAP | TTU_IGNORE_MLOCK | TTU_IGNORE_ACCESS; struct address_space *mapping; LIST_HEAD(tokill); int ret; |
6751ed65d x86/mce: Fix sigi... |
849 |
int kill = 1, forcekill; |
54b9dd14d mm/memory-failure... |
850 |
struct page *hpage = *hpagep; |
a6d30ddda thp: fix the wron... |
851 |
struct page *ppage; |
6a46079cf HWPOISON: The hig... |
852 |
|
1668bfd5b HWPOISON: abort o... |
853 854 |
if (PageReserved(p) || PageSlab(p)) return SWAP_SUCCESS; |
6a46079cf HWPOISON: The hig... |
855 |
|
6a46079cf HWPOISON: The hig... |
856 857 858 859 |
/* * This check implies we don't kill processes if their pages * are in the swap cache early. Those are always late kills. */ |
7af446a84 HWPOISON, hugetlb... |
860 |
if (!page_mapped(hpage)) |
1668bfd5b HWPOISON: abort o... |
861 |
return SWAP_SUCCESS; |
7af446a84 HWPOISON, hugetlb... |
862 |
if (PageKsm(p)) |
1668bfd5b HWPOISON: abort o... |
863 |
return SWAP_FAIL; |
6a46079cf HWPOISON: The hig... |
864 865 866 867 868 869 870 871 872 873 874 |
if (PageSwapCache(p)) { printk(KERN_ERR "MCE %#lx: keeping poisoned page in swap cache ", pfn); 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. |
db0480b3a HWPOISON: comment... |
875 876 |
* XXX: the dirty test could be racy: set_page_dirty() may not always * be called inside page lock (it's recommended but not enforced). |
6a46079cf HWPOISON: The hig... |
877 |
*/ |
7af446a84 HWPOISON, hugetlb... |
878 |
mapping = page_mapping(hpage); |
6751ed65d x86/mce: Fix sigi... |
879 |
if (!(flags & MF_MUST_KILL) && !PageDirty(hpage) && mapping && |
7af446a84 HWPOISON, hugetlb... |
880 881 882 |
mapping_cap_writeback_dirty(mapping)) { if (page_mkclean(hpage)) { SetPageDirty(hpage); |
6a46079cf HWPOISON: The hig... |
883 884 885 886 887 888 889 890 891 |
} else { kill = 0; ttu |= TTU_IGNORE_HWPOISON; printk(KERN_INFO "MCE %#lx: corrupted page was clean: dropped without side effects ", pfn); } } |
a6d30ddda thp: fix the wron... |
892 893 894 895 896 897 898 |
/* * ppage: poisoned page * if p is regular page(4k page) * ppage == real poisoned page; * else p is hugetlb or THP, ppage == head page. */ ppage = hpage; |
efeda7a41 thp: fix splittin... |
899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 |
if (PageTransHuge(hpage)) { /* * Verify that this isn't a hugetlbfs head page, the check for * PageAnon is just for avoid tripping a split_huge_page * internal debug check, as split_huge_page refuses to deal with * anything that isn't an anon page. PageAnon can't go away fro * under us because we hold a refcount on the hpage, without a * refcount on the hpage. split_huge_page can't be safely called * in the first place, having a refcount on the tail isn't * enough * to be safe. */ if (!PageHuge(hpage) && PageAnon(hpage)) { if (unlikely(split_huge_page(hpage))) { /* * FIXME: if splitting THP is failed, it is * better to stop the following operation rather * than causing panic by unmapping. System might * survive if the page is freed later. */ printk(KERN_INFO "MCE %#lx: failed to split THP ", pfn); BUG_ON(!PageHWPoison(p)); return SWAP_FAIL; } |
a3e0f9e47 mm/memory-failure... |
925 926 927 928 |
/* * We pinned the head page for hwpoison handling, * now we split the thp and we are interested in * the hwpoisoned raw page, so move the refcount |
54b9dd14d mm/memory-failure... |
929 |
* to it. Similarly, page lock is shifted. |
a3e0f9e47 mm/memory-failure... |
930 931 |
*/ if (hpage != p) { |
8d547ff4a mm/memory-failure... |
932 933 934 935 |
if (!(flags & MF_COUNT_INCREASED)) { put_page(hpage); get_page(p); } |
54b9dd14d mm/memory-failure... |
936 937 938 |
lock_page(p); unlock_page(hpage); *hpagep = p; |
a3e0f9e47 mm/memory-failure... |
939 |
} |
a6d30ddda thp: fix the wron... |
940 941 |
/* THP is split, so ppage should be the real poisoned page. */ ppage = p; |
efeda7a41 thp: fix splittin... |
942 943 |
} } |
6a46079cf HWPOISON: The hig... |
944 945 946 947 948 949 950 951 952 |
/* * 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) |
a6d30ddda thp: fix the wron... |
953 |
collect_procs(ppage, &tokill); |
6a46079cf HWPOISON: The hig... |
954 |
|
a6d30ddda thp: fix the wron... |
955 |
ret = try_to_unmap(ppage, ttu); |
6a46079cf HWPOISON: The hig... |
956 957 958 |
if (ret != SWAP_SUCCESS) printk(KERN_ERR "MCE %#lx: failed to unmap page (mapcount=%d) ", |
a6d30ddda thp: fix the wron... |
959 |
pfn, page_mapcount(ppage)); |
6a46079cf HWPOISON: The hig... |
960 961 962 963 |
/* * 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 |
6751ed65d x86/mce: Fix sigi... |
964 965 |
* was dirty or the process is not restartable, * otherwise the tokill list is merely |
6a46079cf HWPOISON: The hig... |
966 967 968 969 |
* freed. When there was a problem unmapping earlier * use a more force-full uncatchable kill to prevent * any accesses to the poisoned memory. */ |
6751ed65d x86/mce: Fix sigi... |
970 971 |
forcekill = PageDirty(ppage) || (flags & MF_MUST_KILL); kill_procs(&tokill, forcekill, trapno, |
7329bbeb9 HWPOISON: Add cod... |
972 |
ret != SWAP_SUCCESS, p, pfn, flags); |
1668bfd5b HWPOISON: abort o... |
973 974 |
return ret; |
6a46079cf HWPOISON: The hig... |
975 |
} |
7013febc8 HWPOISON, hugetlb... |
976 977 978 |
static void set_page_hwpoison_huge_page(struct page *hpage) { int i; |
f9121153f mm/hwpoison: don'... |
979 |
int nr_pages = 1 << compound_order(hpage); |
7013febc8 HWPOISON, hugetlb... |
980 981 982 983 984 985 986 |
for (i = 0; i < nr_pages; i++) SetPageHWPoison(hpage + i); } static void clear_page_hwpoison_huge_page(struct page *hpage) { int i; |
f9121153f mm/hwpoison: don'... |
987 |
int nr_pages = 1 << compound_order(hpage); |
7013febc8 HWPOISON, hugetlb... |
988 989 990 |
for (i = 0; i < nr_pages; i++) ClearPageHWPoison(hpage + i); } |
cd42f4a3b HWPOISON: Clean u... |
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 |
/** * 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) |
6a46079cf HWPOISON: The hig... |
1010 1011 1012 |
{ struct page_state *ps; struct page *p; |
7af446a84 HWPOISON, hugetlb... |
1013 |
struct page *hpage; |
6a46079cf HWPOISON: The hig... |
1014 |
int res; |
c9fbdd5f1 HWPOISON, hugetlb... |
1015 |
unsigned int nr_pages; |
524fca1e7 HWPOISON: fix mis... |
1016 |
unsigned long page_flags; |
6a46079cf HWPOISON: The hig... |
1017 1018 1019 1020 1021 |
if (!sysctl_memory_failure_recovery) panic("Memory failure from trap %d on page %lx", trapno, pfn); if (!pfn_valid(pfn)) { |
a7560fc80 HWPOISON: return ... |
1022 1023 1024 1025 1026 |
printk(KERN_ERR "MCE %#lx: memory outside kernel control ", pfn); return -ENXIO; |
6a46079cf HWPOISON: The hig... |
1027 1028 1029 |
} p = pfn_to_page(pfn); |
7af446a84 HWPOISON, hugetlb... |
1030 |
hpage = compound_head(p); |
6a46079cf HWPOISON: The hig... |
1031 |
if (TestSetPageHWPoison(p)) { |
d95ea51e3 HWPOISON: make se... |
1032 1033 |
printk(KERN_ERR "MCE %#lx: already hardware poisoned ", pfn); |
6a46079cf HWPOISON: The hig... |
1034 1035 |
return 0; } |
4db0e950c mm/memory-failure... |
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 |
/* * 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; |
293c07e31 memory-failure: u... |
1047 |
atomic_long_add(nr_pages, &num_poisoned_pages); |
6a46079cf HWPOISON: The hig... |
1048 1049 1050 1051 1052 |
/* * 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. |
8c6c2ecb4 HWPOSION, hugetlb... |
1053 1054 1055 1056 |
* 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. |
6a46079cf HWPOISON: The hig... |
1057 1058 1059 1060 1061 1062 |
* 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. */ |
82ba011b9 HWPOISON: Turn re... |
1063 |
if (!(flags & MF_COUNT_INCREASED) && |
7af446a84 HWPOISON, hugetlb... |
1064 |
!get_page_unless_zero(hpage)) { |
8d22ba1b7 HWPOISON: detect ... |
1065 1066 1067 |
if (is_free_buddy_page(p)) { action_result(pfn, "free buddy", DELAYED); return 0; |
8c6c2ecb4 HWPOSION, hugetlb... |
1068 1069 1070 1071 1072 |
} else if (PageHuge(hpage)) { /* * Check "just unpoisoned", "filter hit", and * "race with other subpage." */ |
7eaceacca block: remove per... |
1073 |
lock_page(hpage); |
8c6c2ecb4 HWPOSION, hugetlb... |
1074 1075 1076 |
if (!PageHWPoison(hpage) || (hwpoison_filter(p) && TestClearPageHWPoison(p)) || (p != hpage && TestSetPageHWPoison(hpage))) { |
293c07e31 memory-failure: u... |
1077 |
atomic_long_sub(nr_pages, &num_poisoned_pages); |
8c6c2ecb4 HWPOSION, hugetlb... |
1078 1079 1080 1081 1082 1083 1084 1085 |
return 0; } set_page_hwpoison_huge_page(hpage); res = dequeue_hwpoisoned_huge_page(hpage); action_result(pfn, "free huge", res ? IGNORED : DELAYED); unlock_page(hpage); return res; |
8d22ba1b7 HWPOISON: detect ... |
1086 1087 1088 1089 |
} else { action_result(pfn, "high order kernel", IGNORED); return -EBUSY; } |
6a46079cf HWPOISON: The hig... |
1090 1091 1092 |
} /* |
e43c3afb3 HWPOISON: return ... |
1093 1094 1095 1096 1097 1098 1099 |
* We ignore non-LRU pages for good reasons. * - PG_locked is only well defined for LRU pages and a few others * - to avoid races with __set_page_locked() * - 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. */ |
385de3572 thp: allow a hwpo... |
1100 |
if (!PageHuge(p) && !PageTransTail(p)) { |
af241a083 thp: fix unsuitab... |
1101 1102 1103 1104 1105 1106 1107 |
if (!PageLRU(p)) shake_page(p, 0); if (!PageLRU(p)) { /* * shake_page could have turned it free. */ if (is_free_buddy_page(p)) { |
2d421acd1 mm/hwpoison: fix ... |
1108 1109 1110 1111 |
if (flags & MF_COUNT_INCREASED) action_result(pfn, "free buddy", DELAYED); else action_result(pfn, "free buddy, 2nd try", DELAYED); |
af241a083 thp: fix unsuitab... |
1112 1113 1114 1115 1116 |
return 0; } action_result(pfn, "non LRU", IGNORED); put_page(p); return -EBUSY; |
0474a60ec HWPOISON: Use new... |
1117 |
} |
e43c3afb3 HWPOISON: return ... |
1118 |
} |
e43c3afb3 HWPOISON: return ... |
1119 1120 |
/* |
6a46079cf HWPOISON: The hig... |
1121 1122 1123 1124 |
* Lock the page and wait for writeback to finish. * It's very difficult to mess with pages currently under IO * and in many cases impossible, so we just avoid it here. */ |
7eaceacca block: remove per... |
1125 |
lock_page(hpage); |
847ce401d HWPOISON: Add unp... |
1126 1127 |
/* |
524fca1e7 HWPOISON: fix mis... |
1128 1129 1130 1131 1132 1133 1134 1135 1136 |
* 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; /* |
847ce401d HWPOISON: Add unp... |
1137 1138 1139 |
* unpoison always clear PG_hwpoison inside page lock */ if (!PageHWPoison(p)) { |
d95ea51e3 HWPOISON: make se... |
1140 1141 |
printk(KERN_ERR "MCE %#lx: just unpoisoned ", pfn); |
847ce401d HWPOISON: Add unp... |
1142 1143 1144 |
res = 0; goto out; } |
7c116f2b0 HWPOISON: add fs/... |
1145 1146 |
if (hwpoison_filter(p)) { if (TestClearPageHWPoison(p)) |
293c07e31 memory-failure: u... |
1147 |
atomic_long_sub(nr_pages, &num_poisoned_pages); |
7af446a84 HWPOISON, hugetlb... |
1148 1149 |
unlock_page(hpage); put_page(hpage); |
7c116f2b0 HWPOISON: add fs/... |
1150 1151 |
return 0; } |
847ce401d HWPOISON: Add unp... |
1152 |
|
7013febc8 HWPOISON, hugetlb... |
1153 1154 1155 1156 |
/* * For error on the tail page, we should set PG_hwpoison * on the head page to show that the hugepage is hwpoisoned */ |
a6d30ddda thp: fix the wron... |
1157 |
if (PageHuge(p) && PageTail(p) && TestSetPageHWPoison(hpage)) { |
7013febc8 HWPOISON, hugetlb... |
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 |
action_result(pfn, "hugepage already hardware poisoned", IGNORED); unlock_page(hpage); put_page(hpage); 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); |
6a46079cf HWPOISON: The hig... |
1172 1173 1174 1175 |
wait_on_page_writeback(p); /* * Now take care of user space mappings. |
e64a782fe mm: change __remo... |
1176 |
* Abort on fail: __delete_from_page_cache() assumes unmapped page. |
54b9dd14d mm/memory-failure... |
1177 1178 1179 |
* * When the raw error page is thp tail page, hpage points to the raw * page after thp split. |
6a46079cf HWPOISON: The hig... |
1180 |
*/ |
54b9dd14d mm/memory-failure... |
1181 1182 |
if (hwpoison_user_mappings(p, pfn, trapno, flags, &hpage) != SWAP_SUCCESS) { |
1668bfd5b HWPOISON: abort o... |
1183 1184 1185 1186 1187 |
printk(KERN_ERR "MCE %#lx: cannot unmap page, give up ", pfn); res = -EBUSY; goto out; } |
6a46079cf HWPOISON: The hig... |
1188 1189 1190 1191 |
/* * Torn down by someone else? */ |
dc2a1cbf7 HWPOISON: introdu... |
1192 |
if (PageLRU(p) && !PageSwapCache(p) && p->mapping == NULL) { |
6a46079cf HWPOISON: The hig... |
1193 |
action_result(pfn, "already truncated LRU", IGNORED); |
d95ea51e3 HWPOISON: make se... |
1194 |
res = -EBUSY; |
6a46079cf HWPOISON: The hig... |
1195 1196 1197 1198 |
goto out; } res = -EBUSY; |
524fca1e7 HWPOISON: fix mis... |
1199 1200 1201 1202 1203 1204 1205 |
/* * 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) |
6a46079cf HWPOISON: The hig... |
1206 |
break; |
841fcc583 mm/hwpoison: fix ... |
1207 1208 |
page_flags |= (p->flags & (1UL << PG_dirty)); |
524fca1e7 HWPOISON: fix mis... |
1209 1210 1211 1212 1213 |
if (!ps->mask) for (ps = error_states;; ps++) if ((page_flags & ps->mask) == ps->res) break; res = page_action(ps, p, pfn); |
6a46079cf HWPOISON: The hig... |
1214 |
out: |
7af446a84 HWPOISON, hugetlb... |
1215 |
unlock_page(hpage); |
6a46079cf HWPOISON: The hig... |
1216 1217 |
return res; } |
cd42f4a3b HWPOISON: Clean u... |
1218 |
EXPORT_SYMBOL_GPL(memory_failure); |
847ce401d HWPOISON: Add unp... |
1219 |
|
ea8f5fb8a HWPoison: add mem... |
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 |
#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); |
498d319bb kfifo API type sa... |
1267 |
if (kfifo_put(&mf_cpu->fifo, entry)) |
ea8f5fb8a HWPoison: add mem... |
1268 1269 |
schedule_work_on(smp_processor_id(), &mf_cpu->work); else |
8e33a52fa treewide: Fix pri... |
1270 1271 |
pr_err("Memory failure: buffer overflow when queuing memory failure at %#lx ", |
ea8f5fb8a HWPoison: add mem... |
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 |
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; mf_cpu = &__get_cpu_var(memory_failure_cpu); 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; |
cf870c70a mce: acpi/apei: S... |
1292 1293 1294 1295 |
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); |
ea8f5fb8a HWPoison: add mem... |
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 |
} } 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); |
847ce401d HWPOISON: Add unp... |
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 |
/** * 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; |
c9fbdd5f1 HWPOISON, hugetlb... |
1331 |
unsigned int nr_pages; |
847ce401d HWPOISON: Add unp... |
1332 1333 1334 1335 1336 1337 1338 1339 |
if (!pfn_valid(pfn)) return -ENXIO; p = pfn_to_page(pfn); page = compound_head(p); if (!PageHWPoison(p)) { |
fb46e7352 HWPOISON: Convert... |
1340 1341 |
pr_info("MCE: Page was already unpoisoned %#lx ", pfn); |
847ce401d HWPOISON: Add unp... |
1342 1343 |
return 0; } |
0cea3fdc4 mm/hwpoison: fix ... |
1344 1345 1346 1347 1348 |
/* * 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. */ |
e76d30e20 mm/hwpoison: fix ... |
1349 |
if (!PageHuge(page) && PageTransHuge(page)) { |
0cea3fdc4 mm/hwpoison: fix ... |
1350 1351 1352 1353 |
pr_info("MCE: Memory failure is now running on %#lx ", pfn); return 0; } |
f9121153f mm/hwpoison: don'... |
1354 |
nr_pages = 1 << compound_order(page); |
c9fbdd5f1 HWPOISON, hugetlb... |
1355 |
|
847ce401d HWPOISON: Add unp... |
1356 |
if (!get_page_unless_zero(page)) { |
8c6c2ecb4 HWPOSION, hugetlb... |
1357 1358 1359 1360 1361 1362 1363 |
/* * 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)) { |
dd73e85f6 HWPOISON: convert... |
1364 1365 |
pr_info("MCE: Memory failure is now running on free hugepage %#lx ", pfn); |
8c6c2ecb4 HWPOSION, hugetlb... |
1366 1367 |
return 0; } |
847ce401d HWPOISON: Add unp... |
1368 |
if (TestClearPageHWPoison(p)) |
dd9538a59 mm/hwpoison: repl... |
1369 |
atomic_long_dec(&num_poisoned_pages); |
fb46e7352 HWPOISON: Convert... |
1370 1371 |
pr_info("MCE: Software-unpoisoned free page %#lx ", pfn); |
847ce401d HWPOISON: Add unp... |
1372 1373 |
return 0; } |
7eaceacca block: remove per... |
1374 |
lock_page(page); |
847ce401d HWPOISON: Add unp... |
1375 1376 1377 1378 1379 1380 |
/* * 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. */ |
c9fbdd5f1 HWPOISON, hugetlb... |
1381 |
if (TestClearPageHWPoison(page)) { |
fb46e7352 HWPOISON: Convert... |
1382 1383 |
pr_info("MCE: Software-unpoisoned page %#lx ", pfn); |
293c07e31 memory-failure: u... |
1384 |
atomic_long_sub(nr_pages, &num_poisoned_pages); |
847ce401d HWPOISON: Add unp... |
1385 |
freeit = 1; |
6a90181c7 HWPOISON, hugetlb... |
1386 1387 |
if (PageHuge(page)) clear_page_hwpoison_huge_page(page); |
847ce401d HWPOISON: Add unp... |
1388 1389 1390 1391 |
} unlock_page(page); put_page(page); |
3ba5eebc4 mm/memory-failure... |
1392 |
if (freeit && !(pfn == my_zero_pfn(0) && page_count(p) == 1)) |
847ce401d HWPOISON: Add unp... |
1393 1394 1395 1396 1397 |
put_page(page); return 0; } EXPORT_SYMBOL(unpoison_memory); |
facb6011f HWPOISON: Add sof... |
1398 1399 1400 |
static struct page *new_page(struct page *p, unsigned long private, int **x) { |
12686d153 HWPOISON: Try to ... |
1401 |
int nid = page_to_nid(p); |
d950b9588 HWPOISON, hugetlb... |
1402 1403 1404 1405 1406 |
if (PageHuge(p)) return alloc_huge_page_node(page_hstate(compound_head(p)), nid); else return alloc_pages_exact_node(nid, GFP_HIGHUSER_MOVABLE, 0); |
facb6011f HWPOISON: Add sof... |
1407 1408 1409 1410 1411 1412 1413 1414 |
} /* * 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. */ |
af8fae7c0 mm/memory-failure... |
1415 |
static int __get_any_page(struct page *p, unsigned long pfn, int flags) |
facb6011f HWPOISON: Add sof... |
1416 1417 1418 1419 1420 1421 1422 |
{ int ret; if (flags & MF_COUNT_INCREASED) return 1; /* |
d950b9588 HWPOISON, hugetlb... |
1423 1424 1425 |
* When the target page is a free hugepage, just remove it * from free hugepage list. */ |
facb6011f HWPOISON: Add sof... |
1426 |
if (!get_page_unless_zero(compound_head(p))) { |
d950b9588 HWPOISON, hugetlb... |
1427 |
if (PageHuge(p)) { |
71dd0b8ae mm/memory_failure... |
1428 1429 |
pr_info("%s: %#lx free huge page ", __func__, pfn); |
af8fae7c0 mm/memory-failure... |
1430 |
ret = 0; |
d950b9588 HWPOISON, hugetlb... |
1431 |
} else if (is_free_buddy_page(p)) { |
71dd0b8ae mm/memory_failure... |
1432 1433 |
pr_info("%s: %#lx free buddy page ", __func__, pfn); |
facb6011f HWPOISON: Add sof... |
1434 1435 |
ret = 0; } else { |
71dd0b8ae mm/memory_failure... |
1436 1437 1438 |
pr_info("%s: %#lx: unknown zero refcount page type %lx ", __func__, pfn, p->flags); |
facb6011f HWPOISON: Add sof... |
1439 1440 1441 1442 1443 1444 |
ret = -EIO; } } else { /* Not a free page */ ret = 1; } |
facb6011f HWPOISON: Add sof... |
1445 1446 |
return ret; } |
af8fae7c0 mm/memory-failure... |
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 |
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. */ put_page(page); shake_page(page, 1); /* * Did it turn free? */ ret = __get_any_page(page, pfn, 0); if (!PageLRU(page)) { pr_info("soft_offline: %#lx: unknown non LRU page type %lx ", pfn, page->flags); return -EIO; } } return ret; } |
d950b9588 HWPOISON, hugetlb... |
1471 1472 1473 1474 1475 |
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); |
b8ec1cee5 mm: soft-offline:... |
1476 |
LIST_HEAD(pagelist); |
d950b9588 HWPOISON, hugetlb... |
1477 |
|
af8fae7c0 mm/memory-failure... |
1478 1479 1480 1481 1482 |
/* * This double-check of PageHWPoison is to avoid the race with * memory_failure(). See also comment in __soft_offline_page(). */ lock_page(hpage); |
0ebff32c3 memory-failure: f... |
1483 |
if (PageHWPoison(hpage)) { |
af8fae7c0 mm/memory-failure... |
1484 1485 |
unlock_page(hpage); put_page(hpage); |
0ebff32c3 memory-failure: f... |
1486 1487 |
pr_info("soft offline: %#lx hugepage already poisoned ", pfn); |
af8fae7c0 mm/memory-failure... |
1488 |
return -EBUSY; |
0ebff32c3 memory-failure: f... |
1489 |
} |
af8fae7c0 mm/memory-failure... |
1490 |
unlock_page(hpage); |
d950b9588 HWPOISON, hugetlb... |
1491 |
|
d950b9588 HWPOISON, hugetlb... |
1492 |
/* Keep page count to indicate a given hugepage is isolated. */ |
b8ec1cee5 mm: soft-offline:... |
1493 1494 1495 |
list_move(&hpage->lru, &pagelist); ret = migrate_pages(&pagelist, new_page, MPOL_MF_MOVE_ALL, MIGRATE_SYNC, MR_MEMORY_FAILURE); |
d950b9588 HWPOISON, hugetlb... |
1496 |
if (ret) { |
dd73e85f6 HWPOISON: convert... |
1497 1498 1499 |
pr_info("soft offline: %#lx: migration failed %d, type %lx ", pfn, ret, page->flags); |
b8ec1cee5 mm: soft-offline:... |
1500 1501 1502 1503 1504 1505 1506 1507 |
/* * 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; |
af8fae7c0 mm/memory-failure... |
1508 |
} else { |
a49ecbcd7 mm/memory-failure... |
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 |
/* overcommit hugetlb page will be freed to buddy */ if (PageHuge(page)) { set_page_hwpoison_huge_page(hpage); dequeue_hwpoisoned_huge_page(hpage); atomic_long_add(1 << compound_order(hpage), &num_poisoned_pages); } else { SetPageHWPoison(page); atomic_long_inc(&num_poisoned_pages); } |
d950b9588 HWPOISON, hugetlb... |
1519 |
} |
d950b9588 HWPOISON, hugetlb... |
1520 1521 |
return ret; } |
af8fae7c0 mm/memory-failure... |
1522 1523 1524 1525 |
static int __soft_offline_page(struct page *page, int flags) { int ret; unsigned long pfn = page_to_pfn(page); |
facb6011f HWPOISON: Add sof... |
1526 |
|
facb6011f HWPOISON: Add sof... |
1527 |
/* |
af8fae7c0 mm/memory-failure... |
1528 1529 1530 1531 |
* 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(). |
facb6011f HWPOISON: Add sof... |
1532 |
*/ |
0ebff32c3 memory-failure: f... |
1533 1534 |
lock_page(page); wait_on_page_writeback(page); |
af8fae7c0 mm/memory-failure... |
1535 1536 1537 1538 1539 1540 1541 |
if (PageHWPoison(page)) { unlock_page(page); put_page(page); pr_info("soft offline: %#lx page already poisoned ", pfn); return -EBUSY; } |
facb6011f HWPOISON: Add sof... |
1542 1543 1544 1545 1546 1547 |
/* * Try to invalidate first. This should work for * non dirty unmapped page cache pages. */ ret = invalidate_inode_page(page); unlock_page(page); |
facb6011f HWPOISON: Add sof... |
1548 |
/* |
facb6011f HWPOISON: Add sof... |
1549 1550 1551 |
* RED-PEN would be better to keep it isolated here, but we * would need to fix isolation locking first. */ |
facb6011f HWPOISON: Add sof... |
1552 |
if (ret == 1) { |
bd486285f mem-hwpoison: fix... |
1553 |
put_page(page); |
fb46e7352 HWPOISON: Convert... |
1554 1555 |
pr_info("soft_offline: %#lx: invalidated ", pfn); |
af8fae7c0 mm/memory-failure... |
1556 1557 1558 |
SetPageHWPoison(page); atomic_long_inc(&num_poisoned_pages); return 0; |
facb6011f HWPOISON: Add sof... |
1559 1560 1561 1562 1563 1564 1565 1566 |
} /* * 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); |
bd486285f mem-hwpoison: fix... |
1567 1568 1569 1570 1571 |
/* * Drop page reference which is came from get_any_page() * successful isolate_lru_page() already took another one. */ put_page(page); |
facb6011f HWPOISON: Add sof... |
1572 1573 |
if (!ret) { LIST_HEAD(pagelist); |
5db8a73a8 mm/memory-failure... |
1574 |
inc_zone_page_state(page, NR_ISOLATED_ANON + |
9c620e2bc mm: remove offlin... |
1575 |
page_is_file_cache(page)); |
facb6011f HWPOISON: Add sof... |
1576 |
list_add(&page->lru, &pagelist); |
77f1fe6b0 mm: migration: al... |
1577 |
ret = migrate_pages(&pagelist, new_page, MPOL_MF_MOVE_ALL, |
9c620e2bc mm: remove offlin... |
1578 |
MIGRATE_SYNC, MR_MEMORY_FAILURE); |
facb6011f HWPOISON: Add sof... |
1579 |
if (ret) { |
59c82b70d mm/migrate: remov... |
1580 1581 1582 1583 1584 1585 |
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); } |
fb46e7352 HWPOISON: Convert... |
1586 1587 |
pr_info("soft offline: %#lx: migration failed %d, type %lx ", |
facb6011f HWPOISON: Add sof... |
1588 1589 1590 |
pfn, ret, page->flags); if (ret > 0) ret = -EIO; |
af8fae7c0 mm/memory-failure... |
1591 |
} else { |
f15bdfa80 mm/memory-failure... |
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 |
/* * After page migration succeeds, the source page can * be trapped in pagevec and actual freeing is delayed. * Freeing code works differently based on PG_hwpoison, * so there's a race. We need to make sure that the * source page should be freed back to buddy before * setting PG_hwpoison. */ if (!is_free_buddy_page(page)) lru_add_drain_all(); if (!is_free_buddy_page(page)) drain_all_pages(); |
af8fae7c0 mm/memory-failure... |
1604 |
SetPageHWPoison(page); |
f15bdfa80 mm/memory-failure... |
1605 1606 1607 1608 |
if (!is_free_buddy_page(page)) pr_info("soft offline: %#lx: page leaked ", pfn); |
af8fae7c0 mm/memory-failure... |
1609 |
atomic_long_inc(&num_poisoned_pages); |
facb6011f HWPOISON: Add sof... |
1610 1611 |
} } else { |
fb46e7352 HWPOISON: Convert... |
1612 1613 |
pr_info("soft offline: %#lx: isolation failed: %d, page count %d, type %lx ", |
dd73e85f6 HWPOISON: convert... |
1614 |
pfn, ret, page_count(page), page->flags); |
facb6011f HWPOISON: Add sof... |
1615 |
} |
facb6011f HWPOISON: Add sof... |
1616 1617 |
return ret; } |
86e057734 mm/hwpoison: drop... |
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 |
/** * 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); |
668f9abbd mm: close PageTai... |
1645 |
struct page *hpage = compound_head(page); |
86e057734 mm/hwpoison: drop... |
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 |
if (PageHWPoison(page)) { pr_info("soft offline: %#lx page already poisoned ", pfn); return -EBUSY; } if (!PageHuge(page) && PageTransHuge(hpage)) { if (PageAnon(hpage) && unlikely(split_huge_page(hpage))) { pr_info("soft offline: %#lx: failed to split THP ", pfn); return -EBUSY; } } |
03b61ff3c mm/memory-failure... |
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 |
/* * The lock_memory_hotplug prevents a race with memory hotplug. * This is a big hammer, a better would be nicer. */ lock_memory_hotplug(); /* * Isolate the page, so that it doesn't get reallocated if it * was free. This flag should be kept set until the source page * is freed and PG_hwpoison on it is set. */ if (get_pageblock_migratetype(page) != MIGRATE_ISOLATE) set_migratetype_isolate(page, true); |
86e057734 mm/hwpoison: drop... |
1673 |
ret = get_any_page(page, pfn, flags); |
03b61ff3c mm/memory-failure... |
1674 1675 |
unlock_memory_hotplug(); if (ret > 0) { /* for in-use pages */ |
86e057734 mm/hwpoison: drop... |
1676 1677 1678 1679 |
if (PageHuge(page)) ret = soft_offline_huge_page(page, flags); else ret = __soft_offline_page(page, flags); |
03b61ff3c mm/memory-failure... |
1680 |
} else if (ret == 0) { /* for free pages */ |
86e057734 mm/hwpoison: drop... |
1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 |
if (PageHuge(page)) { set_page_hwpoison_huge_page(hpage); dequeue_hwpoisoned_huge_page(hpage); atomic_long_add(1 << compound_order(hpage), &num_poisoned_pages); } else { SetPageHWPoison(page); atomic_long_inc(&num_poisoned_pages); } } |
86e057734 mm/hwpoison: drop... |
1691 1692 1693 |
unset_migratetype_isolate(page, MIGRATE_MOVABLE); return ret; } |