Blame view
mm/memory-failure.c
51.9 KB
1439f94c5 treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-only |
6a46079cf HWPOISON: The hig... |
2 3 4 5 |
/* * Copyright (C) 2008, 2009 Intel Corporation * Authors: Andi Kleen, Fengguang Wu * |
6a46079cf HWPOISON: The hig... |
6 |
* High level machine check handler. Handles pages reported by the |
1c80b990a HWPOISON: Improve... |
7 |
* hardware as being corrupted usually due to a multi-bit ECC memory or cache |
6a46079cf HWPOISON: The hig... |
8 |
* failure. |
1c80b990a HWPOISON: Improve... |
9 10 11 |
* * 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... |
12 13 |
* * Handles page cache pages in various states. The tricky part |
1c80b990a HWPOISON: Improve... |
14 15 16 17 18 19 |
* 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. |
e0de78dfb mm, hwpoison: add... |
20 21 22 23 24 25 26 27 |
* * 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. |
1c80b990a HWPOISON: Improve... |
28 29 30 31 32 33 34 |
* * 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... |
35 |
*/ |
6a46079cf HWPOISON: The hig... |
36 37 38 |
#include <linux/kernel.h> #include <linux/mm.h> #include <linux/page-flags.h> |
478c5ffc0 HWPOISON: add pag... |
39 |
#include <linux/kernel-page-flags.h> |
3f07c0144 sched/headers: Pr... |
40 |
#include <linux/sched/signal.h> |
299300258 sched/headers: Pr... |
41 |
#include <linux/sched/task.h> |
01e00f880 HWPOISON: fix oop... |
42 |
#include <linux/ksm.h> |
6a46079cf HWPOISON: The hig... |
43 |
#include <linux/rmap.h> |
b9e15bafd mm: Add export.h ... |
44 |
#include <linux/export.h> |
6a46079cf HWPOISON: The hig... |
45 46 47 |
#include <linux/pagemap.h> #include <linux/swap.h> #include <linux/backing-dev.h> |
facb6011f HWPOISON: Add sof... |
48 |
#include <linux/migrate.h> |
facb6011f HWPOISON: Add sof... |
49 |
#include <linux/suspend.h> |
5a0e3ad6a include cleanup: ... |
50 |
#include <linux/slab.h> |
bf998156d KVM: Avoid killin... |
51 |
#include <linux/swapops.h> |
7af446a84 HWPOISON, hugetlb... |
52 |
#include <linux/hugetlb.h> |
20d6c96b5 mem-hotplug: intr... |
53 |
#include <linux/memory_hotplug.h> |
5db8a73a8 mm/memory-failure... |
54 |
#include <linux/mm_inline.h> |
6100e34b2 mm, memory_failur... |
55 |
#include <linux/memremap.h> |
ea8f5fb8a HWPoison: add mem... |
56 |
#include <linux/kfifo.h> |
a5f651090 mm: hwpoison: rat... |
57 |
#include <linux/ratelimit.h> |
d4ae9916e mm: soft-offline:... |
58 |
#include <linux/page-isolation.h> |
6a46079cf HWPOISON: The hig... |
59 |
#include "internal.h" |
97f0b1345 tracing: add trac... |
60 |
#include "ras/ras_event.h" |
6a46079cf HWPOISON: The hig... |
61 62 63 64 |
int sysctl_memory_failure_early_kill __read_mostly = 0; int sysctl_memory_failure_recovery __read_mostly = 1; |
293c07e31 memory-failure: u... |
65 |
atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0); |
6a46079cf HWPOISON: The hig... |
66 |
|
6b9a217ed mm,hwpoison: refa... |
67 |
static bool page_handle_poison(struct page *page, bool hugepage_or_freepage, bool release) |
06be6ff3d mm,hwpoison: rewo... |
68 |
{ |
6b9a217ed mm,hwpoison: refa... |
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
if (hugepage_or_freepage) { /* * Doing this check for free pages is also fine since dissolve_free_huge_page * returns 0 for non-hugetlb pages as well. */ if (dissolve_free_huge_page(page) || !take_page_off_buddy(page)) /* * We could fail to take off the target page from buddy * for example due to racy page allocaiton, but that's * acceptable because soft-offlined page is not broken * and if someone really want to use it, they should * take it. */ return false; } |
06be6ff3d mm,hwpoison: rewo... |
84 |
SetPageHWPoison(page); |
79f5f8fab mm,hwpoison: rewo... |
85 86 |
if (release) put_page(page); |
06be6ff3d mm,hwpoison: rewo... |
87 88 |
page_ref_inc(page); num_poisoned_pages_inc(); |
6b9a217ed mm,hwpoison: refa... |
89 90 |
return true; |
06be6ff3d mm,hwpoison: rewo... |
91 |
} |
27df5068e HWPOISON: Add PRO... |
92 |
#if defined(CONFIG_HWPOISON_INJECT) || defined(CONFIG_HWPOISON_INJECT_MODULE) |
1bfe5febe HWPOISON: add an ... |
93 |
u32 hwpoison_filter_enable = 0; |
7c116f2b0 HWPOISON: add fs/... |
94 95 |
u32 hwpoison_filter_dev_major = ~0U; u32 hwpoison_filter_dev_minor = ~0U; |
478c5ffc0 HWPOISON: add pag... |
96 97 |
u64 hwpoison_filter_flags_mask; u64 hwpoison_filter_flags_value; |
1bfe5febe HWPOISON: add an ... |
98 |
EXPORT_SYMBOL_GPL(hwpoison_filter_enable); |
7c116f2b0 HWPOISON: add fs/... |
99 100 |
EXPORT_SYMBOL_GPL(hwpoison_filter_dev_major); EXPORT_SYMBOL_GPL(hwpoison_filter_dev_minor); |
478c5ffc0 HWPOISON: add pag... |
101 102 |
EXPORT_SYMBOL_GPL(hwpoison_filter_flags_mask); EXPORT_SYMBOL_GPL(hwpoison_filter_flags_value); |
7c116f2b0 HWPOISON: add fs/... |
103 104 105 106 107 108 109 110 111 112 113 |
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... |
114 |
* page_mapping() does not accept slab pages. |
7c116f2b0 HWPOISON: add fs/... |
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
*/ 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... |
133 134 135 136 137 138 139 140 141 142 143 |
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... |
144 145 146 147 148 149 150 151 152 153 |
/* * 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. */ |
94a59fb36 hwpoison: use pag... |
154 |
#ifdef CONFIG_MEMCG |
4fd466eb4 HWPOISON: add mem... |
155 156 157 158 |
u64 hwpoison_filter_memcg; EXPORT_SYMBOL_GPL(hwpoison_filter_memcg); static int hwpoison_filter_task(struct page *p) { |
4fd466eb4 HWPOISON: add mem... |
159 160 |
if (!hwpoison_filter_memcg) return 0; |
94a59fb36 hwpoison: use pag... |
161 |
if (page_cgroup_ino(p) != hwpoison_filter_memcg) |
4fd466eb4 HWPOISON: add mem... |
162 163 164 165 166 167 168 |
return -EINVAL; return 0; } #else static int hwpoison_filter_task(struct page *p) { return 0; } #endif |
7c116f2b0 HWPOISON: add fs/... |
169 170 |
int hwpoison_filter(struct page *p) { |
1bfe5febe HWPOISON: add an ... |
171 172 |
if (!hwpoison_filter_enable) return 0; |
7c116f2b0 HWPOISON: add fs/... |
173 174 |
if (hwpoison_filter_dev(p)) return -EINVAL; |
478c5ffc0 HWPOISON: add pag... |
175 176 |
if (hwpoison_filter_flags(p)) return -EINVAL; |
4fd466eb4 HWPOISON: add mem... |
177 178 |
if (hwpoison_filter_task(p)) return -EINVAL; |
7c116f2b0 HWPOISON: add fs/... |
179 180 |
return 0; } |
27df5068e HWPOISON: Add PRO... |
181 182 183 184 185 186 |
#else int hwpoison_filter(struct page *p) { return 0; } #endif |
7c116f2b0 HWPOISON: add fs/... |
187 |
EXPORT_SYMBOL_GPL(hwpoison_filter); |
6a46079cf HWPOISON: The hig... |
188 |
/* |
ae1139ece mm, memory_failur... |
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 |
* 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; short size_shift; |
ae1139ece mm, memory_failur... |
215 216 217 |
}; /* |
7329bbeb9 HWPOISON: Add cod... |
218 219 220 |
* 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... |
221 |
*/ |
ae1139ece mm, memory_failur... |
222 |
static int kill_proc(struct to_kill *tk, unsigned long pfn, int flags) |
6a46079cf HWPOISON: The hig... |
223 |
{ |
ae1139ece mm, memory_failur... |
224 225 |
struct task_struct *t = tk->tsk; short addr_lsb = tk->size_shift; |
872e9a205 mm, memory_failur... |
226 |
int ret = 0; |
6a46079cf HWPOISON: The hig... |
227 |
|
03151c6e0 mm/memory-failure... |
228 229 |
pr_err("Memory failure: %#lx: Sending SIGBUS to %s:%d due to hardware memory corruption ", |
872e9a205 mm, memory_failur... |
230 |
pfn, t->comm, t->pid); |
7329bbeb9 HWPOISON: Add cod... |
231 |
|
872e9a205 mm, memory_failur... |
232 |
if (flags & MF_ACTION_REQUIRED) { |
03151c6e0 mm/memory-failure... |
233 234 |
WARN_ON_ONCE(t != current); ret = force_sig_mceerr(BUS_MCEERR_AR, |
872e9a205 mm, memory_failur... |
235 |
(void __user *)tk->addr, addr_lsb); |
7329bbeb9 HWPOISON: Add cod... |
236 237 238 239 240 241 242 |
} 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? */ |
ae1139ece mm, memory_failur... |
243 |
ret = send_sig_mceerr(BUS_MCEERR_AO, (void __user *)tk->addr, |
c0f45555b signal/memory-fai... |
244 |
addr_lsb, t); /* synchronous? */ |
7329bbeb9 HWPOISON: Add cod... |
245 |
} |
6a46079cf HWPOISON: The hig... |
246 |
if (ret < 0) |
495367c05 mm/memory-failure... |
247 248 |
pr_info("Memory failure: Error sending signal to %s:%d: %d ", |
1170532bb mm: convert print... |
249 |
t->comm, t->pid, ret); |
6a46079cf HWPOISON: The hig... |
250 251 252 253 |
return ret; } /* |
588f9ce6c HWPOISON: Be more... |
254 255 256 |
* 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... |
257 |
void shake_page(struct page *p, int access) |
588f9ce6c HWPOISON: Be more... |
258 |
{ |
8bcb74de7 mm: hwpoison: cal... |
259 260 |
if (PageHuge(p)) return; |
588f9ce6c HWPOISON: Be more... |
261 262 263 264 |
if (!PageSlab(p)) { lru_add_drain_all(); if (PageLRU(p)) return; |
c05543293 mm, memory_hotplu... |
265 |
drain_all_pages(page_zone(p)); |
588f9ce6c HWPOISON: Be more... |
266 267 268 |
if (PageLRU(p) || is_free_buddy_page(p)) return; } |
facb6011f HWPOISON: Add sof... |
269 |
|
588f9ce6c HWPOISON: Be more... |
270 |
/* |
6b4f7799c mm: vmscan: invok... |
271 272 |
* Only call shrink_node_slabs here (which would also shrink * other caches) if access is not potentially fatal. |
588f9ce6c HWPOISON: Be more... |
273 |
*/ |
cb731d6c6 vmscan: per memor... |
274 275 |
if (access) drop_slab_node(page_to_nid(p)); |
588f9ce6c HWPOISON: Be more... |
276 277 |
} EXPORT_SYMBOL_GPL(shake_page); |
6100e34b2 mm, memory_failur... |
278 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 |
static unsigned long dev_pagemap_mapping_shift(struct page *page, struct vm_area_struct *vma) { unsigned long address = vma_address(page, vma); pgd_t *pgd; p4d_t *p4d; pud_t *pud; pmd_t *pmd; pte_t *pte; pgd = pgd_offset(vma->vm_mm, address); if (!pgd_present(*pgd)) return 0; p4d = p4d_offset(pgd, address); if (!p4d_present(*p4d)) return 0; pud = pud_offset(p4d, address); if (!pud_present(*pud)) return 0; if (pud_devmap(*pud)) return PUD_SHIFT; pmd = pmd_offset(pud, address); if (!pmd_present(*pmd)) return 0; if (pmd_devmap(*pmd)) return PMD_SHIFT; pte = pte_offset_map(pmd, address); if (!pte_present(*pte)) return 0; if (pte_devmap(*pte)) return PAGE_SHIFT; return 0; } |
6a46079cf HWPOISON: The hig... |
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. |
6a46079cf HWPOISON: The hig... |
320 321 322 |
*/ static void add_to_kill(struct task_struct *tsk, struct page *p, struct vm_area_struct *vma, |
996ff7a08 mm/memory-failure... |
323 |
struct list_head *to_kill) |
6a46079cf HWPOISON: The hig... |
324 325 |
{ struct to_kill *tk; |
996ff7a08 mm/memory-failure... |
326 327 328 329 330 |
tk = kmalloc(sizeof(struct to_kill), GFP_ATOMIC); if (!tk) { pr_err("Memory failure: Out of memory while machine check handling "); return; |
6a46079cf HWPOISON: The hig... |
331 |
} |
996ff7a08 mm/memory-failure... |
332 |
|
6a46079cf HWPOISON: The hig... |
333 |
tk->addr = page_address_in_vma(p, vma); |
6100e34b2 mm, memory_failur... |
334 335 336 |
if (is_zone_device_page(p)) tk->size_shift = dev_pagemap_mapping_shift(p, vma); else |
750685183 mm/memory-failure... |
337 |
tk->size_shift = page_shift(compound_head(p)); |
6a46079cf HWPOISON: The hig... |
338 339 |
/* |
3d7fed4ad mm/memory-failure... |
340 341 342 343 344 345 346 347 |
* Send SIGKILL if "tk->addr == -EFAULT". Also, as * "tk->size_shift" is always non-zero for !is_zone_device_page(), * so "tk->size_shift == 0" effectively checks no mapping on * ZONE_DEVICE. Indeed, when a devdax page is mmapped N times * to a process' address space, it's possible not all N VMAs * contain mappings for the page, but at least one VMA does. * Only deliver SIGBUS with payload derived from the VMA that * has a mapping for the page. |
6a46079cf HWPOISON: The hig... |
348 |
*/ |
3d7fed4ad mm/memory-failure... |
349 |
if (tk->addr == -EFAULT) { |
495367c05 mm/memory-failure... |
350 351 |
pr_info("Memory failure: Unable to find user space address %lx in %s ", |
6a46079cf HWPOISON: The hig... |
352 |
page_to_pfn(p), tsk->comm); |
3d7fed4ad mm/memory-failure... |
353 354 355 |
} else if (tk->size_shift == 0) { kfree(tk); return; |
6a46079cf HWPOISON: The hig... |
356 |
} |
996ff7a08 mm/memory-failure... |
357 |
|
6a46079cf HWPOISON: The hig... |
358 359 360 361 362 363 364 365 366 367 368 369 370 |
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. */ |
ae1139ece mm, memory_failur... |
371 372 |
static void kill_procs(struct list_head *to_kill, int forcekill, bool fail, unsigned long pfn, int flags) |
6a46079cf HWPOISON: The hig... |
373 374 375 376 |
{ struct to_kill *tk, *next; list_for_each_entry_safe (tk, next, to_kill, nd) { |
6751ed65d x86/mce: Fix sigi... |
377 |
if (forcekill) { |
6a46079cf HWPOISON: The hig... |
378 |
/* |
af901ca18 tree-wide: fix as... |
379 |
* In case something went wrong with munmapping |
6a46079cf HWPOISON: The hig... |
380 381 |
* make sure the process doesn't catch the * signal and then access the memory. Just kill it. |
6a46079cf HWPOISON: The hig... |
382 |
*/ |
3d7fed4ad mm/memory-failure... |
383 |
if (fail || tk->addr == -EFAULT) { |
495367c05 mm/memory-failure... |
384 385 |
pr_err("Memory failure: %#lx: forcibly killing %s:%d because of failure to unmap corrupted page ", |
1170532bb mm: convert print... |
386 |
pfn, tk->tsk->comm, tk->tsk->pid); |
6376360ec mm: hwpoison: use... |
387 388 |
do_send_sig_info(SIGKILL, SEND_SIG_PRIV, tk->tsk, PIDTYPE_PID); |
6a46079cf HWPOISON: The hig... |
389 390 391 392 393 394 395 396 |
} /* * 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. */ |
ae1139ece mm, memory_failur... |
397 |
else if (kill_proc(tk, pfn, flags) < 0) |
495367c05 mm/memory-failure... |
398 399 |
pr_err("Memory failure: %#lx: Cannot send advisory machine check signal to %s:%d ", |
1170532bb mm: convert print... |
400 |
pfn, tk->tsk->comm, tk->tsk->pid); |
6a46079cf HWPOISON: The hig... |
401 402 403 404 405 |
} put_task_struct(tk->tsk); kfree(tk); } } |
3ba08129e mm/memory-failure... |
406 407 408 409 410 411 412 413 414 |
/* * 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) |
6a46079cf HWPOISON: The hig... |
415 |
{ |
3ba08129e mm/memory-failure... |
416 |
struct task_struct *t; |
4e018b450 mm/memory-failure... |
417 418 419 420 421 422 423 424 425 |
for_each_thread(tsk, t) { if (t->flags & PF_MCE_PROCESS) { if (t->flags & PF_MCE_EARLY) return t; } else { if (sysctl_memory_failure_early_kill) return t; } } |
3ba08129e mm/memory-failure... |
426 427 428 429 430 431 432 433 |
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. |
03151c6e0 mm/memory-failure... |
434 435 436 |
* * Note that the above is true for Action Optional case, but not for Action * Required case where SIGBUS should sent only to the current thread. |
3ba08129e mm/memory-failure... |
437 438 439 440 |
*/ static struct task_struct *task_early_kill(struct task_struct *tsk, int force_early) { |
6a46079cf HWPOISON: The hig... |
441 |
if (!tsk->mm) |
3ba08129e mm/memory-failure... |
442 |
return NULL; |
03151c6e0 mm/memory-failure... |
443 444 445 446 447 448 449 450 451 452 |
if (force_early) { /* * Comparing ->mm here because current task might represent * a subthread, while tsk always points to the main thread. */ if (tsk->mm == current->mm) return current; else return NULL; } |
4e018b450 mm/memory-failure... |
453 |
return find_early_kill_thread(tsk); |
6a46079cf HWPOISON: The hig... |
454 455 456 457 458 459 |
} /* * Collect processes when the error hit an anonymous page. */ static void collect_procs_anon(struct page *page, struct list_head *to_kill, |
996ff7a08 mm/memory-failure... |
460 |
int force_early) |
6a46079cf HWPOISON: The hig... |
461 462 463 464 |
{ struct vm_area_struct *vma; struct task_struct *tsk; struct anon_vma *av; |
bf181b9f9 mm anon rmap: rep... |
465 |
pgoff_t pgoff; |
6a46079cf HWPOISON: The hig... |
466 |
|
4fc3f1d66 mm/rmap, migratio... |
467 |
av = page_lock_anon_vma_read(page); |
6a46079cf HWPOISON: The hig... |
468 |
if (av == NULL) /* Not actually mapped anymore */ |
9b679320a mm/memory-failure... |
469 |
return; |
a0f7a756c mm/rmap.c: fix pg... |
470 |
pgoff = page_to_pgoff(page); |
9b679320a mm/memory-failure... |
471 |
read_lock(&tasklist_lock); |
6a46079cf HWPOISON: The hig... |
472 |
for_each_process (tsk) { |
5beb49305 mm: change anon_v... |
473 |
struct anon_vma_chain *vmac; |
3ba08129e mm/memory-failure... |
474 |
struct task_struct *t = task_early_kill(tsk, force_early); |
5beb49305 mm: change anon_v... |
475 |
|
3ba08129e mm/memory-failure... |
476 |
if (!t) |
6a46079cf HWPOISON: The hig... |
477 |
continue; |
bf181b9f9 mm anon rmap: rep... |
478 479 |
anon_vma_interval_tree_foreach(vmac, &av->rb_root, pgoff, pgoff) { |
5beb49305 mm: change anon_v... |
480 |
vma = vmac->vma; |
6a46079cf HWPOISON: The hig... |
481 482 |
if (!page_mapped_in_vma(page, vma)) continue; |
3ba08129e mm/memory-failure... |
483 |
if (vma->vm_mm == t->mm) |
996ff7a08 mm/memory-failure... |
484 |
add_to_kill(t, page, vma, to_kill); |
6a46079cf HWPOISON: The hig... |
485 486 |
} } |
6a46079cf HWPOISON: The hig... |
487 |
read_unlock(&tasklist_lock); |
4fc3f1d66 mm/rmap, migratio... |
488 |
page_unlock_anon_vma_read(av); |
6a46079cf HWPOISON: The hig... |
489 490 491 492 493 494 |
} /* * Collect processes when the error hit a file mapped page. */ static void collect_procs_file(struct page *page, struct list_head *to_kill, |
996ff7a08 mm/memory-failure... |
495 |
int force_early) |
6a46079cf HWPOISON: The hig... |
496 497 498 |
{ struct vm_area_struct *vma; struct task_struct *tsk; |
6a46079cf HWPOISON: The hig... |
499 |
struct address_space *mapping = page->mapping; |
c43bc03d0 mm/memory-failure... |
500 |
pgoff_t pgoff; |
6a46079cf HWPOISON: The hig... |
501 |
|
d28eb9c86 mm/memory-failure... |
502 |
i_mmap_lock_read(mapping); |
9b679320a mm/memory-failure... |
503 |
read_lock(&tasklist_lock); |
c43bc03d0 mm/memory-failure... |
504 |
pgoff = page_to_pgoff(page); |
6a46079cf HWPOISON: The hig... |
505 |
for_each_process(tsk) { |
3ba08129e mm/memory-failure... |
506 |
struct task_struct *t = task_early_kill(tsk, force_early); |
6a46079cf HWPOISON: The hig... |
507 |
|
3ba08129e mm/memory-failure... |
508 |
if (!t) |
6a46079cf HWPOISON: The hig... |
509 |
continue; |
6b2dbba8b mm: replace vma p... |
510 |
vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, |
6a46079cf HWPOISON: The hig... |
511 512 513 514 515 516 517 518 |
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. */ |
3ba08129e mm/memory-failure... |
519 |
if (vma->vm_mm == t->mm) |
996ff7a08 mm/memory-failure... |
520 |
add_to_kill(t, page, vma, to_kill); |
6a46079cf HWPOISON: The hig... |
521 522 |
} } |
6a46079cf HWPOISON: The hig... |
523 |
read_unlock(&tasklist_lock); |
d28eb9c86 mm/memory-failure... |
524 |
i_mmap_unlock_read(mapping); |
6a46079cf HWPOISON: The hig... |
525 526 527 528 |
} /* * Collect the processes who have the corrupted page mapped to kill. |
6a46079cf HWPOISON: The hig... |
529 |
*/ |
74614de17 mm/memory-failure... |
530 531 |
static void collect_procs(struct page *page, struct list_head *tokill, int force_early) |
6a46079cf HWPOISON: The hig... |
532 |
{ |
6a46079cf HWPOISON: The hig... |
533 534 |
if (!page->mapping) return; |
6a46079cf HWPOISON: The hig... |
535 |
if (PageAnon(page)) |
996ff7a08 mm/memory-failure... |
536 |
collect_procs_anon(page, tokill, force_early); |
6a46079cf HWPOISON: The hig... |
537 |
else |
996ff7a08 mm/memory-failure... |
538 |
collect_procs_file(page, tokill, force_early); |
6a46079cf HWPOISON: The hig... |
539 |
} |
6a46079cf HWPOISON: The hig... |
540 |
static const char *action_name[] = { |
cc637b170 memory-failure: e... |
541 542 543 544 |
[MF_IGNORED] = "Ignored", [MF_FAILED] = "Failed", [MF_DELAYED] = "Delayed", [MF_RECOVERED] = "Recovered", |
64d37a2ba mm/memory-failure... |
545 546 547 |
}; static const char * const action_page_types[] = { |
cc637b170 memory-failure: e... |
548 549 550 551 552 553 554 |
[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", |
31286a848 mm: hwpoison: dis... |
555 |
[MF_MSG_NON_PMD_HUGE] = "non-pmd-sized huge page", |
cc637b170 memory-failure: e... |
556 557 558 559 560 561 562 563 564 565 566 567 |
[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)", |
6100e34b2 mm, memory_failur... |
568 |
[MF_MSG_DAX] = "dax page", |
5d1fd5dc8 mm,hwpoison: intr... |
569 |
[MF_MSG_UNSPLIT_THP] = "unsplit thp", |
cc637b170 memory-failure: e... |
570 |
[MF_MSG_UNKNOWN] = "unknown page", |
64d37a2ba mm/memory-failure... |
571 |
}; |
6a46079cf HWPOISON: The hig... |
572 |
/* |
dc2a1cbf7 HWPOISON: introdu... |
573 574 575 576 577 578 579 580 581 582 583 584 585 586 |
* 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); |
18365225f hwpoison, memcg: ... |
587 588 589 590 591 592 |
/* * Poisoned page might never drop its ref count to 0 so we have * to uncharge it manually from its memcg. */ mem_cgroup_uncharge(p); |
dc2a1cbf7 HWPOISON: introdu... |
593 594 595 |
/* * drop the page count elevated by isolate_lru_page() */ |
09cbfeaf1 mm, fs: get rid o... |
596 |
put_page(p); |
dc2a1cbf7 HWPOISON: introdu... |
597 598 599 600 |
return 0; } return -EIO; } |
78bb92034 mm: hwpoison: dis... |
601 602 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 635 |
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 ", pfn, err); } else if (page_has_private(p) && !try_to_release_page(p, GFP_NOIO)) { pr_info("Memory failure: %#lx: failed to release buffers ", 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 ", pfn); } return ret; } |
dc2a1cbf7 HWPOISON: introdu... |
636 |
/* |
6a46079cf HWPOISON: The hig... |
637 638 639 640 641 642 |
* 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) { |
cc637b170 memory-failure: e... |
643 |
return MF_IGNORED; |
6a46079cf HWPOISON: The hig... |
644 645 646 647 648 649 650 |
} /* * Page in unknown state. Do nothing. */ static int me_unknown(struct page *p, unsigned long pfn) { |
495367c05 mm/memory-failure... |
651 652 |
pr_err("Memory failure: %#lx: Unknown page state ", pfn); |
cc637b170 memory-failure: e... |
653 |
return MF_FAILED; |
6a46079cf HWPOISON: The hig... |
654 655 656 |
} /* |
6a46079cf HWPOISON: The hig... |
657 658 659 660 |
* Clean (or cleaned) page cache page. */ static int me_pagecache_clean(struct page *p, unsigned long pfn) { |
6a46079cf HWPOISON: The hig... |
661 |
struct address_space *mapping; |
dc2a1cbf7 HWPOISON: introdu... |
662 |
delete_from_lru_cache(p); |
6a46079cf HWPOISON: The hig... |
663 664 665 666 667 |
/* * For anonymous pages we're done the only reference left * should be the one m_f() holds. */ if (PageAnon(p)) |
cc637b170 memory-failure: e... |
668 |
return MF_RECOVERED; |
6a46079cf HWPOISON: The hig... |
669 670 671 672 673 674 675 676 677 678 679 680 681 |
/* * 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 */ |
cc637b170 memory-failure: e... |
682 |
return MF_FAILED; |
6a46079cf HWPOISON: The hig... |
683 684 685 686 687 688 689 |
} /* * 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. */ |
78bb92034 mm: hwpoison: dis... |
690 |
return truncate_error_page(p, pfn, mapping); |
6a46079cf HWPOISON: The hig... |
691 692 693 |
} /* |
549543dff mm, memory-failur... |
694 |
* Dirty pagecache page |
6a46079cf HWPOISON: The hig... |
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 720 721 722 723 724 725 726 |
* 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... |
727 |
* and the page is dropped between then the error |
6a46079cf HWPOISON: The hig... |
728 729 730 731 732 733 734 735 736 737 738 |
* 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. */ |
af21bfaf7 mm: fix mapping_s... |
739 |
mapping_set_error(mapping, -EIO); |
6a46079cf HWPOISON: The hig... |
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 |
} 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... |
766 767 768 |
ClearPageDirty(p); /* Trigger EIO in shmem: */ ClearPageUptodate(p); |
dc2a1cbf7 HWPOISON: introdu... |
769 |
if (!delete_from_lru_cache(p)) |
cc637b170 memory-failure: e... |
770 |
return MF_DELAYED; |
dc2a1cbf7 HWPOISON: introdu... |
771 |
else |
cc637b170 memory-failure: e... |
772 |
return MF_FAILED; |
6a46079cf HWPOISON: The hig... |
773 774 775 776 |
} static int me_swapcache_clean(struct page *p, unsigned long pfn) { |
6a46079cf HWPOISON: The hig... |
777 |
delete_from_swap_cache(p); |
e43c3afb3 HWPOISON: return ... |
778 |
|
dc2a1cbf7 HWPOISON: introdu... |
779 |
if (!delete_from_lru_cache(p)) |
cc637b170 memory-failure: e... |
780 |
return MF_RECOVERED; |
dc2a1cbf7 HWPOISON: introdu... |
781 |
else |
cc637b170 memory-failure: e... |
782 |
return MF_FAILED; |
6a46079cf HWPOISON: The hig... |
783 784 785 786 787 |
} /* * Huge pages. Needs work. * Issues: |
93f70f900 HWPOISON, hugetlb... |
788 789 |
* - 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... |
790 791 792 |
*/ static int me_huge_page(struct page *p, unsigned long pfn) { |
6de2b1aab HWPOISON, hugetlb... |
793 |
int res = 0; |
93f70f900 HWPOISON, hugetlb... |
794 |
struct page *hpage = compound_head(p); |
78bb92034 mm: hwpoison: dis... |
795 |
struct address_space *mapping; |
2491ffee9 mm/memory-failure... |
796 797 798 |
if (!PageHuge(hpage)) return MF_DELAYED; |
78bb92034 mm: hwpoison: dis... |
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 |
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); |
93f70f900 HWPOISON, hugetlb... |
814 |
} |
78bb92034 mm: hwpoison: dis... |
815 816 |
return res; |
6a46079cf HWPOISON: The hig... |
817 818 819 820 821 822 823 824 825 |
} /* * 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... |
826 |
* in its live cycle, so all accesses have to be extremely careful. |
6a46079cf HWPOISON: The hig... |
827 828 829 830 831 832 |
* * This is not complete. More states could be added. * For any missing state don't attempt recovery. */ #define dirty (1UL << PG_dirty) |
6326fec11 mm: Use owner_pri... |
833 |
#define sc ((1UL << PG_swapcache) | (1UL << PG_swapbacked)) |
6a46079cf HWPOISON: The hig... |
834 835 |
#define unevict (1UL << PG_unevictable) #define mlock (1UL << PG_mlocked) |
6a46079cf HWPOISON: The hig... |
836 |
#define lru (1UL << PG_lru) |
6a46079cf HWPOISON: The hig... |
837 |
#define head (1UL << PG_head) |
6a46079cf HWPOISON: The hig... |
838 |
#define slab (1UL << PG_slab) |
6a46079cf HWPOISON: The hig... |
839 840 841 842 843 |
#define reserved (1UL << PG_reserved) static struct page_state { unsigned long mask; unsigned long res; |
cc637b170 memory-failure: e... |
844 |
enum mf_action_page_type type; |
6a46079cf HWPOISON: The hig... |
845 846 |
int (*action)(struct page *p, unsigned long pfn); } error_states[] = { |
cc637b170 memory-failure: e... |
847 |
{ reserved, reserved, MF_MSG_KERNEL, me_kernel }, |
95d01fc66 HWPOISON: remove ... |
848 849 850 851 |
/* * free pages are specially detected outside this table: * PG_buddy pages only make a small fraction of all free pages. */ |
6a46079cf HWPOISON: The hig... |
852 853 854 855 856 857 |
/* * 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. */ |
cc637b170 memory-failure: e... |
858 |
{ slab, slab, MF_MSG_SLAB, me_kernel }, |
6a46079cf HWPOISON: The hig... |
859 |
|
cc637b170 memory-failure: e... |
860 |
{ head, head, MF_MSG_HUGE, me_huge_page }, |
6a46079cf HWPOISON: The hig... |
861 |
|
cc637b170 memory-failure: e... |
862 863 |
{ sc|dirty, sc|dirty, MF_MSG_DIRTY_SWAPCACHE, me_swapcache_dirty }, { sc|dirty, sc, MF_MSG_CLEAN_SWAPCACHE, me_swapcache_clean }, |
6a46079cf HWPOISON: The hig... |
864 |
|
cc637b170 memory-failure: e... |
865 866 |
{ mlock|dirty, mlock|dirty, MF_MSG_DIRTY_MLOCKED_LRU, me_pagecache_dirty }, { mlock|dirty, mlock, MF_MSG_CLEAN_MLOCKED_LRU, me_pagecache_clean }, |
6a46079cf HWPOISON: The hig... |
867 |
|
cc637b170 memory-failure: e... |
868 869 |
{ unevict|dirty, unevict|dirty, MF_MSG_DIRTY_UNEVICTABLE_LRU, me_pagecache_dirty }, { unevict|dirty, unevict, MF_MSG_CLEAN_UNEVICTABLE_LRU, me_pagecache_clean }, |
5f4b9fc5c HWPOISON: change ... |
870 |
|
cc637b170 memory-failure: e... |
871 872 |
{ lru|dirty, lru|dirty, MF_MSG_DIRTY_LRU, me_pagecache_dirty }, { lru|dirty, lru, MF_MSG_CLEAN_LRU, me_pagecache_clean }, |
6a46079cf HWPOISON: The hig... |
873 874 875 876 |
/* * Catchall entry: must be at end. */ |
cc637b170 memory-failure: e... |
877 |
{ 0, 0, MF_MSG_UNKNOWN, me_unknown }, |
6a46079cf HWPOISON: The hig... |
878 |
}; |
2326c467d HWPOISON: Undefin... |
879 880 881 882 |
#undef dirty #undef sc #undef unevict #undef mlock |
2326c467d HWPOISON: Undefin... |
883 |
#undef lru |
2326c467d HWPOISON: Undefin... |
884 |
#undef head |
2326c467d HWPOISON: Undefin... |
885 886 |
#undef slab #undef reserved |
ff604cf6d mm: hwpoison: fix... |
887 888 889 890 |
/* * "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(). */ |
cc3e2af42 memory-failure: c... |
891 892 |
static void action_result(unsigned long pfn, enum mf_action_page_type type, enum mf_result result) |
6a46079cf HWPOISON: The hig... |
893 |
{ |
97f0b1345 tracing: add trac... |
894 |
trace_memory_failure_event(pfn, type, result); |
495367c05 mm/memory-failure... |
895 896 |
pr_err("Memory failure: %#lx: recovery action for %s: %s ", |
64d37a2ba mm/memory-failure... |
897 |
pfn, action_page_types[type], action_name[result]); |
6a46079cf HWPOISON: The hig... |
898 899 900 |
} static int page_action(struct page_state *ps, struct page *p, |
bd1ce5f91 HWPOISON: avoid g... |
901 |
unsigned long pfn) |
6a46079cf HWPOISON: The hig... |
902 903 |
{ int result; |
7456b0405 HWPOISON: fix inv... |
904 |
int count; |
6a46079cf HWPOISON: The hig... |
905 906 |
result = ps->action(p, pfn); |
7456b0405 HWPOISON: fix inv... |
907 |
|
bd1ce5f91 HWPOISON: avoid g... |
908 |
count = page_count(p) - 1; |
cc637b170 memory-failure: e... |
909 |
if (ps->action == me_swapcache_dirty && result == MF_DELAYED) |
138ce286e HWPOISON: return ... |
910 |
count--; |
78bb92034 mm: hwpoison: dis... |
911 |
if (count > 0) { |
495367c05 mm/memory-failure... |
912 913 |
pr_err("Memory failure: %#lx: %s still referenced by %d users ", |
64d37a2ba mm/memory-failure... |
914 |
pfn, action_page_types[ps->type], count); |
cc637b170 memory-failure: e... |
915 |
result = MF_FAILED; |
138ce286e HWPOISON: return ... |
916 |
} |
64d37a2ba mm/memory-failure... |
917 |
action_result(pfn, ps->type, result); |
6a46079cf HWPOISON: The hig... |
918 919 920 921 922 |
/* Could do more checks here if page looks ok */ /* * Could adjust zone counters here to correct for the missing page. */ |
cc637b170 memory-failure: e... |
923 |
return (result == MF_RECOVERED || result == MF_DELAYED) ? 0 : -EBUSY; |
6a46079cf HWPOISON: The hig... |
924 |
} |
ead07f6a8 mm/memory-failure... |
925 926 927 928 929 930 931 |
/** * 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.) */ |
7e27f22c9 mm,hwpoison: unex... |
932 |
static int get_hwpoison_page(struct page *page) |
ead07f6a8 mm/memory-failure... |
933 934 |
{ struct page *head = compound_head(page); |
4e41a30c6 mm: hwpoison: adj... |
935 |
if (!PageHuge(head) && PageTransHuge(head)) { |
98ed2b005 mm/memory-failure... |
936 937 938 939 940 941 942 |
/* * 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)) { |
495367c05 mm/memory-failure... |
943 944 |
pr_err("Memory failure: %#lx: non anonymous thp ", |
98ed2b005 mm/memory-failure... |
945 946 947 |
page_to_pfn(page)); return 0; } |
ead07f6a8 mm/memory-failure... |
948 |
} |
c2e7e00b7 mm/memory-failure... |
949 950 951 |
if (get_page_unless_zero(head)) { if (head == compound_head(page)) return 1; |
495367c05 mm/memory-failure... |
952 953 954 |
pr_info("Memory failure: %#lx cannot catch tail ", page_to_pfn(page)); |
c2e7e00b7 mm/memory-failure... |
955 956 957 958 |
put_page(head); } return 0; |
ead07f6a8 mm/memory-failure... |
959 |
} |
ead07f6a8 mm/memory-failure... |
960 |
|
6a46079cf HWPOISON: The hig... |
961 962 963 964 |
/* * Do all that is necessary to remove user space mappings. Unmap * the pages and send SIGBUS to the processes if the data was dirty. */ |
666e5a406 mm: make ttu's re... |
965 |
static bool hwpoison_user_mappings(struct page *p, unsigned long pfn, |
83b57531c mm/memory_failure... |
966 |
int flags, struct page **hpagep) |
6a46079cf HWPOISON: The hig... |
967 |
{ |
dd156e3fc mm/rmap: always d... |
968 |
enum ttu_flags ttu = TTU_IGNORE_MLOCK; |
6a46079cf HWPOISON: The hig... |
969 970 |
struct address_space *mapping; LIST_HEAD(tokill); |
c0d0381ad hugetlbfs: use i_... |
971 |
bool unmap_success = true; |
6751ed65d x86/mce: Fix sigi... |
972 |
int kill = 1, forcekill; |
54b9dd14d mm/memory-failure... |
973 |
struct page *hpage = *hpagep; |
286c469a9 mm: hwpoison: cal... |
974 |
bool mlocked = PageMlocked(hpage); |
6a46079cf HWPOISON: The hig... |
975 |
|
93a9eb39f hwpoison: fix hug... |
976 977 978 979 980 |
/* * Here we are interested only in user-mapped pages, so skip any * other types of pages. */ if (PageReserved(p) || PageSlab(p)) |
666e5a406 mm: make ttu's re... |
981 |
return true; |
93a9eb39f hwpoison: fix hug... |
982 |
if (!(PageLRU(hpage) || PageHuge(p))) |
666e5a406 mm: make ttu's re... |
983 |
return true; |
6a46079cf HWPOISON: The hig... |
984 |
|
6a46079cf HWPOISON: The hig... |
985 986 987 988 |
/* * 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... |
989 |
if (!page_mapped(hpage)) |
666e5a406 mm: make ttu's re... |
990 |
return true; |
1668bfd5b HWPOISON: abort o... |
991 |
|
52089b14c hwpoison: call ac... |
992 |
if (PageKsm(p)) { |
495367c05 mm/memory-failure... |
993 994 |
pr_err("Memory failure: %#lx: can't handle KSM pages. ", pfn); |
666e5a406 mm: make ttu's re... |
995 |
return false; |
52089b14c hwpoison: call ac... |
996 |
} |
6a46079cf HWPOISON: The hig... |
997 998 |
if (PageSwapCache(p)) { |
495367c05 mm/memory-failure... |
999 1000 1001 |
pr_err("Memory failure: %#lx: keeping poisoned page in swap cache ", pfn); |
6a46079cf HWPOISON: The hig... |
1002 1003 1004 1005 1006 1007 |
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... |
1008 1009 |
* 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... |
1010 |
*/ |
7af446a84 HWPOISON, hugetlb... |
1011 |
mapping = page_mapping(hpage); |
6751ed65d x86/mce: Fix sigi... |
1012 |
if (!(flags & MF_MUST_KILL) && !PageDirty(hpage) && mapping && |
f56753ac2 bdi: replace BDI_... |
1013 |
mapping_can_writeback(mapping)) { |
7af446a84 HWPOISON, hugetlb... |
1014 1015 |
if (page_mkclean(hpage)) { SetPageDirty(hpage); |
6a46079cf HWPOISON: The hig... |
1016 1017 1018 |
} else { kill = 0; ttu |= TTU_IGNORE_HWPOISON; |
495367c05 mm/memory-failure... |
1019 1020 |
pr_info("Memory failure: %#lx: corrupted page was clean: dropped without side effects ", |
6a46079cf HWPOISON: The hig... |
1021 1022 1023 |
pfn); } } |
a6d30ddda thp: fix the wron... |
1024 |
/* |
6a46079cf HWPOISON: The hig... |
1025 1026 1027 1028 1029 1030 1031 1032 |
* 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) |
415c64c14 mm/memory-failure... |
1033 |
collect_procs(hpage, &tokill, flags & MF_ACTION_REQUIRED); |
6a46079cf HWPOISON: The hig... |
1034 |
|
c0d0381ad hugetlbfs: use i_... |
1035 1036 1037 |
if (!PageHuge(hpage)) { unmap_success = try_to_unmap(hpage, ttu); } else { |
336bf30eb hugetlbfs: fix an... |
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 |
if (!PageAnon(hpage)) { /* * For hugetlb pages in shared mappings, try_to_unmap * could potentially call huge_pmd_unshare. Because of * this, take semaphore in write mode here and set * TTU_RMAP_LOCKED to indicate we have taken the lock * at this higer level. */ mapping = hugetlb_page_mapping_lock_write(hpage); if (mapping) { unmap_success = try_to_unmap(hpage, |
c0d0381ad hugetlbfs: use i_... |
1049 |
ttu|TTU_RMAP_LOCKED); |
336bf30eb hugetlbfs: fix an... |
1050 1051 1052 1053 1054 1055 |
i_mmap_unlock_write(mapping); } else { pr_info("Memory failure: %#lx: could not lock mapping for mapped huge page ", pfn); unmap_success = false; } |
c0d0381ad hugetlbfs: use i_... |
1056 |
} else { |
336bf30eb hugetlbfs: fix an... |
1057 |
unmap_success = try_to_unmap(hpage, ttu); |
c0d0381ad hugetlbfs: use i_... |
1058 1059 |
} } |
666e5a406 mm: make ttu's re... |
1060 |
if (!unmap_success) |
495367c05 mm/memory-failure... |
1061 1062 |
pr_err("Memory failure: %#lx: failed to unmap page (mapcount=%d) ", |
1170532bb mm: convert print... |
1063 |
pfn, page_mapcount(hpage)); |
a6d30ddda thp: fix the wron... |
1064 |
|
6a46079cf HWPOISON: The hig... |
1065 |
/* |
286c469a9 mm: hwpoison: cal... |
1066 1067 1068 1069 1070 1071 1072 |
* 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); /* |
6a46079cf HWPOISON: The hig... |
1073 1074 1075 |
* 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... |
1076 1077 |
* was dirty or the process is not restartable, * otherwise the tokill list is merely |
6a46079cf HWPOISON: The hig... |
1078 1079 1080 1081 |
* freed. When there was a problem unmapping earlier * use a more force-full uncatchable kill to prevent * any accesses to the poisoned memory. */ |
415c64c14 mm/memory-failure... |
1082 |
forcekill = PageDirty(hpage) || (flags & MF_MUST_KILL); |
ae1139ece mm, memory_failur... |
1083 |
kill_procs(&tokill, forcekill, !unmap_success, pfn, flags); |
1668bfd5b HWPOISON: abort o... |
1084 |
|
666e5a406 mm: make ttu's re... |
1085 |
return unmap_success; |
6a46079cf HWPOISON: The hig... |
1086 |
} |
0348d2ebe mm: hwpoison: int... |
1087 1088 |
static int identify_page_state(unsigned long pfn, struct page *p, unsigned long page_flags) |
761ad8d7c mm: hwpoison: int... |
1089 1090 |
{ struct page_state *ps; |
0348d2ebe mm: hwpoison: int... |
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 |
/* * 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); } |
694bf0b0c mm,hwpoison: unif... |
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 |
static int try_to_split_thp_page(struct page *page, const char *msg) { lock_page(page); if (!PageAnon(page) || unlikely(split_huge_page(page))) { unsigned long pfn = page_to_pfn(page); unlock_page(page); if (!PageAnon(page)) pr_info("%s: %#lx: non anonymous thp ", msg, pfn); else pr_info("%s: %#lx: thp split failed ", msg, pfn); put_page(page); return -EBUSY; } unlock_page(page); return 0; } |
83b57531c mm/memory_failure... |
1129 |
static int memory_failure_hugetlb(unsigned long pfn, int flags) |
0348d2ebe mm: hwpoison: int... |
1130 |
{ |
761ad8d7c mm: hwpoison: int... |
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 |
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 ", 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 ", pfn); num_poisoned_pages_dec(); unlock_page(head); |
dd6e2402f mm,hwpoison: kill... |
1172 |
put_page(head); |
761ad8d7c mm: hwpoison: int... |
1173 1174 |
return 0; } |
31286a848 mm: hwpoison: dis... |
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 |
/* * 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; } |
83b57531c mm/memory_failure... |
1189 |
if (!hwpoison_user_mappings(p, pfn, flags, &head)) { |
761ad8d7c mm: hwpoison: int... |
1190 1191 1192 1193 |
action_result(pfn, MF_MSG_UNMAP_FAILED, MF_IGNORED); res = -EBUSY; goto out; } |
0348d2ebe mm: hwpoison: int... |
1194 |
res = identify_page_state(pfn, p, page_flags); |
761ad8d7c mm: hwpoison: int... |
1195 1196 1197 1198 |
out: unlock_page(head); return res; } |
6100e34b2 mm, memory_failur... |
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 |
static int memory_failure_dev_pagemap(unsigned long pfn, int flags, struct dev_pagemap *pgmap) { struct page *page = pfn_to_page(pfn); const bool unmap_success = true; unsigned long size = 0; struct to_kill *tk; LIST_HEAD(tokill); int rc = -EBUSY; loff_t start; |
27359fd6e dax: Fix unlock m... |
1209 |
dax_entry_t cookie; |
6100e34b2 mm, memory_failur... |
1210 |
|
b7bf8ed8d mm,memory_failure... |
1211 1212 1213 1214 1215 |
if (flags & MF_COUNT_INCREASED) /* * Drop the extra refcount in case we come from madvise(). */ put_page(page); |
6100e34b2 mm, memory_failur... |
1216 1217 1218 1219 1220 1221 1222 |
/* * Prevent the inode from being freed while we are interrogating * the address_space, typically this would be handled by * lock_page(), but dax pages do not use the page lock. This * also prevents changes to the mapping of this pfn until * poison signaling is complete. */ |
27359fd6e dax: Fix unlock m... |
1223 1224 |
cookie = dax_lock_page(page); if (!cookie) |
6100e34b2 mm, memory_failur... |
1225 1226 1227 1228 1229 1230 |
goto out; if (hwpoison_filter(page)) { rc = 0; goto unlock; } |
25b2995a3 mm: remove MEMORY... |
1231 |
if (pgmap->type == MEMORY_DEVICE_PRIVATE) { |
6100e34b2 mm, memory_failur... |
1232 1233 1234 1235 1236 |
/* * TODO: Handle HMM pages which may need coordination * with device-side memory. */ goto unlock; |
6100e34b2 mm, memory_failur... |
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 1267 1268 1269 |
} /* * Use this flag as an indication that the dax page has been * remapped UC to prevent speculative consumption of poison. */ SetPageHWPoison(page); /* * Unlike System-RAM there is no possibility to swap in a * different physical page at a given virtual address, so all * userspace consumption of ZONE_DEVICE memory necessitates * SIGBUS (i.e. MF_MUST_KILL) */ flags |= MF_ACTION_REQUIRED | MF_MUST_KILL; collect_procs(page, &tokill, flags & MF_ACTION_REQUIRED); list_for_each_entry(tk, &tokill, nd) if (tk->size_shift) size = max(size, 1UL << tk->size_shift); if (size) { /* * Unmap the largest mapping to avoid breaking up * device-dax mappings which are constant size. The * actual size of the mapping being torn down is * communicated in siginfo, see kill_proc() */ start = (page->index << PAGE_SHIFT) & ~(size - 1); unmap_mapping_range(page->mapping, start, start + size, 0); } kill_procs(&tokill, flags & MF_MUST_KILL, !unmap_success, pfn, flags); rc = 0; unlock: |
27359fd6e dax: Fix unlock m... |
1270 |
dax_unlock_page(page, cookie); |
6100e34b2 mm, memory_failur... |
1271 1272 1273 1274 1275 1276 |
out: /* drop pgmap ref acquired in caller */ put_dev_pagemap(pgmap); action_result(pfn, MF_MSG_DAX, rc ? MF_FAILED : MF_RECOVERED); return rc; } |
cd42f4a3b HWPOISON: Clean u... |
1277 1278 1279 |
/** * memory_failure - Handle memory failure of a page. * @pfn: Page Number of the corrupted page |
cd42f4a3b HWPOISON: Clean u... |
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 |
* @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. */ |
83b57531c mm/memory_failure... |
1294 |
int memory_failure(unsigned long pfn, int flags) |
6a46079cf HWPOISON: The hig... |
1295 |
{ |
6a46079cf HWPOISON: The hig... |
1296 |
struct page *p; |
7af446a84 HWPOISON, hugetlb... |
1297 |
struct page *hpage; |
415c64c14 mm/memory-failure... |
1298 |
struct page *orig_head; |
6100e34b2 mm, memory_failur... |
1299 |
struct dev_pagemap *pgmap; |
6a46079cf HWPOISON: The hig... |
1300 |
int res; |
524fca1e7 HWPOISON: fix mis... |
1301 |
unsigned long page_flags; |
6a46079cf HWPOISON: The hig... |
1302 1303 |
if (!sysctl_memory_failure_recovery) |
83b57531c mm/memory_failure... |
1304 |
panic("Memory failure on page %lx", pfn); |
6a46079cf HWPOISON: The hig... |
1305 |
|
96c804a6a mm/memory-failure... |
1306 1307 1308 1309 1310 1311 1312 1313 |
p = pfn_to_online_page(pfn); if (!p) { if (pfn_valid(pfn)) { pgmap = get_dev_pagemap(pfn, NULL); if (pgmap) return memory_failure_dev_pagemap(pfn, flags, pgmap); } |
495367c05 mm/memory-failure... |
1314 1315 1316 |
pr_err("Memory failure: %#lx: memory outside kernel control ", pfn); |
a7560fc80 HWPOISON: return ... |
1317 |
return -ENXIO; |
6a46079cf HWPOISON: The hig... |
1318 |
} |
761ad8d7c mm: hwpoison: int... |
1319 |
if (PageHuge(p)) |
83b57531c mm/memory_failure... |
1320 |
return memory_failure_hugetlb(pfn, flags); |
6a46079cf HWPOISON: The hig... |
1321 |
if (TestSetPageHWPoison(p)) { |
495367c05 mm/memory-failure... |
1322 1323 1324 |
pr_err("Memory failure: %#lx: already hardware poisoned ", pfn); |
6a46079cf HWPOISON: The hig... |
1325 1326 |
return 0; } |
761ad8d7c mm: hwpoison: int... |
1327 |
orig_head = hpage = compound_head(p); |
b37ff71cc mm: hwpoison: cha... |
1328 |
num_poisoned_pages_inc(); |
6a46079cf HWPOISON: The hig... |
1329 1330 1331 1332 1333 |
/* * 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. |
761ad8d7c mm: hwpoison: int... |
1334 |
* 2) it's part of a non-compound high order page. |
6a46079cf HWPOISON: The hig... |
1335 1336 1337 1338 |
* 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, |
1c4c3b99c mm: fix page_free... |
1339 |
* that may make page_ref_freeze()/page_ref_unfreeze() mismatch. |
6a46079cf HWPOISON: The hig... |
1340 |
*/ |
ead07f6a8 mm/memory-failure... |
1341 |
if (!(flags & MF_COUNT_INCREASED) && !get_hwpoison_page(p)) { |
8d22ba1b7 HWPOISON: detect ... |
1342 |
if (is_free_buddy_page(p)) { |
cc637b170 memory-failure: e... |
1343 |
action_result(pfn, MF_MSG_BUDDY, MF_DELAYED); |
8d22ba1b7 HWPOISON: detect ... |
1344 1345 |
return 0; } else { |
cc637b170 memory-failure: e... |
1346 |
action_result(pfn, MF_MSG_KERNEL_HIGH_ORDER, MF_IGNORED); |
8d22ba1b7 HWPOISON: detect ... |
1347 1348 |
return -EBUSY; } |
6a46079cf HWPOISON: The hig... |
1349 |
} |
761ad8d7c mm: hwpoison: int... |
1350 |
if (PageTransHuge(hpage)) { |
5d1fd5dc8 mm,hwpoison: intr... |
1351 1352 |
if (try_to_split_thp_page(p, "Memory Failure") < 0) { action_result(pfn, MF_MSG_UNSPLIT_THP, MF_IGNORED); |
415c64c14 mm/memory-failure... |
1353 |
return -EBUSY; |
5d1fd5dc8 mm,hwpoison: intr... |
1354 |
} |
415c64c14 mm/memory-failure... |
1355 |
VM_BUG_ON_PAGE(!page_count(p), p); |
415c64c14 mm/memory-failure... |
1356 |
} |
6a46079cf HWPOISON: The hig... |
1357 |
/* |
e43c3afb3 HWPOISON: return ... |
1358 1359 |
* We ignore non-LRU pages for good reasons. * - PG_locked is only well defined for LRU pages and a few others |
48c935ad8 page-flags: defin... |
1360 |
* - to avoid races with __SetPageLocked() |
e43c3afb3 HWPOISON: return ... |
1361 1362 1363 1364 |
* - 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. */ |
8bcb74de7 mm: hwpoison: cal... |
1365 1366 1367 1368 1369 1370 1371 1372 |
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; |
e43c3afb3 HWPOISON: return ... |
1373 |
} |
e43c3afb3 HWPOISON: return ... |
1374 |
|
761ad8d7c mm: hwpoison: int... |
1375 |
lock_page(p); |
847ce401d HWPOISON: Add unp... |
1376 1377 |
/* |
f37d4298a hwpoison: fix rac... |
1378 1379 1380 |
* The page could have changed compound pages during the locking. * If this happens just bail out. */ |
415c64c14 mm/memory-failure... |
1381 |
if (PageCompound(p) && compound_head(p) != orig_head) { |
cc637b170 memory-failure: e... |
1382 |
action_result(pfn, MF_MSG_DIFFERENT_COMPOUND, MF_IGNORED); |
f37d4298a hwpoison: fix rac... |
1383 1384 1385 1386 1387 |
res = -EBUSY; goto out; } /* |
524fca1e7 HWPOISON: fix mis... |
1388 1389 1390 1391 1392 1393 |
* 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. */ |
7d9d46ac8 mm,hwpoison: clea... |
1394 |
page_flags = p->flags; |
524fca1e7 HWPOISON: fix mis... |
1395 1396 |
/* |
847ce401d HWPOISON: Add unp... |
1397 1398 1399 |
* unpoison always clear PG_hwpoison inside page lock */ if (!PageHWPoison(p)) { |
495367c05 mm/memory-failure... |
1400 1401 |
pr_err("Memory failure: %#lx: just unpoisoned ", pfn); |
b37ff71cc mm: hwpoison: cha... |
1402 |
num_poisoned_pages_dec(); |
761ad8d7c mm: hwpoison: int... |
1403 |
unlock_page(p); |
dd6e2402f mm,hwpoison: kill... |
1404 |
put_page(p); |
a09233f3e mm/memory-failure... |
1405 |
return 0; |
847ce401d HWPOISON: Add unp... |
1406 |
} |
7c116f2b0 HWPOISON: add fs/... |
1407 1408 |
if (hwpoison_filter(p)) { if (TestClearPageHWPoison(p)) |
b37ff71cc mm: hwpoison: cha... |
1409 |
num_poisoned_pages_dec(); |
761ad8d7c mm: hwpoison: int... |
1410 |
unlock_page(p); |
dd6e2402f mm,hwpoison: kill... |
1411 |
put_page(p); |
7c116f2b0 HWPOISON: add fs/... |
1412 1413 |
return 0; } |
847ce401d HWPOISON: Add unp... |
1414 |
|
761ad8d7c mm: hwpoison: int... |
1415 |
if (!PageTransTail(p) && !PageLRU(p)) |
0bc1f8b06 hwpoison: fix the... |
1416 |
goto identify_page_state; |
7013febc8 HWPOISON, hugetlb... |
1417 |
/* |
6edd6cc66 mm/memory-failure... |
1418 1419 1420 |
* It's very difficult to mess with pages currently under IO * and in many cases impossible, so we just avoid it here. */ |
6a46079cf HWPOISON: The hig... |
1421 1422 1423 1424 |
wait_on_page_writeback(p); /* * Now take care of user space mappings. |
e64a782fe mm: change __remo... |
1425 |
* Abort on fail: __delete_from_page_cache() assumes unmapped page. |
6a46079cf HWPOISON: The hig... |
1426 |
*/ |
1b473becd mm, hwpoison: rem... |
1427 |
if (!hwpoison_user_mappings(p, pfn, flags, &p)) { |
cc637b170 memory-failure: e... |
1428 |
action_result(pfn, MF_MSG_UNMAP_FAILED, MF_IGNORED); |
1668bfd5b HWPOISON: abort o... |
1429 1430 1431 |
res = -EBUSY; goto out; } |
6a46079cf HWPOISON: The hig... |
1432 1433 1434 1435 |
/* * Torn down by someone else? */ |
dc2a1cbf7 HWPOISON: introdu... |
1436 |
if (PageLRU(p) && !PageSwapCache(p) && p->mapping == NULL) { |
cc637b170 memory-failure: e... |
1437 |
action_result(pfn, MF_MSG_TRUNCATED_LRU, MF_IGNORED); |
d95ea51e3 HWPOISON: make se... |
1438 |
res = -EBUSY; |
6a46079cf HWPOISON: The hig... |
1439 1440 |
goto out; } |
0bc1f8b06 hwpoison: fix the... |
1441 |
identify_page_state: |
0348d2ebe mm: hwpoison: int... |
1442 |
res = identify_page_state(pfn, p, page_flags); |
6a46079cf HWPOISON: The hig... |
1443 |
out: |
761ad8d7c mm: hwpoison: int... |
1444 |
unlock_page(p); |
6a46079cf HWPOISON: The hig... |
1445 1446 |
return res; } |
cd42f4a3b HWPOISON: Clean u... |
1447 |
EXPORT_SYMBOL_GPL(memory_failure); |
847ce401d HWPOISON: Add unp... |
1448 |
|
ea8f5fb8a HWPoison: add mem... |
1449 1450 1451 1452 1453 |
#define MEMORY_FAILURE_FIFO_ORDER 4 #define MEMORY_FAILURE_FIFO_SIZE (1 << MEMORY_FAILURE_FIFO_ORDER) struct memory_failure_entry { unsigned long pfn; |
ea8f5fb8a HWPoison: add mem... |
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 |
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 |
ea8f5fb8a HWPoison: add mem... |
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 |
* @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. */ |
83b57531c mm/memory_failure... |
1482 |
void memory_failure_queue(unsigned long pfn, int flags) |
ea8f5fb8a HWPoison: add mem... |
1483 1484 1485 1486 1487 |
{ struct memory_failure_cpu *mf_cpu; unsigned long proc_flags; struct memory_failure_entry entry = { .pfn = pfn, |
ea8f5fb8a HWPoison: add mem... |
1488 1489 1490 1491 1492 |
.flags = flags, }; mf_cpu = &get_cpu_var(memory_failure_cpu); spin_lock_irqsave(&mf_cpu->lock, proc_flags); |
498d319bb kfifo API type sa... |
1493 |
if (kfifo_put(&mf_cpu->fifo, entry)) |
ea8f5fb8a HWPoison: add mem... |
1494 1495 |
schedule_work_on(smp_processor_id(), &mf_cpu->work); else |
8e33a52fa treewide: Fix pri... |
1496 1497 |
pr_err("Memory failure: buffer overflow when queuing memory failure at %#lx ", |
ea8f5fb8a HWPoison: add mem... |
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 |
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; |
062022315 mm/memory-failure... |
1510 |
mf_cpu = container_of(work, struct memory_failure_cpu, work); |
ea8f5fb8a HWPoison: add mem... |
1511 1512 1513 1514 1515 1516 |
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... |
1517 |
if (entry.flags & MF_SOFT_OFFLINE) |
feec24a61 mm, soft-offline:... |
1518 |
soft_offline_page(entry.pfn, entry.flags); |
cf870c70a mce: acpi/apei: S... |
1519 |
else |
83b57531c mm/memory_failure... |
1520 |
memory_failure(entry.pfn, entry.flags); |
ea8f5fb8a HWPoison: add mem... |
1521 1522 |
} } |
062022315 mm/memory-failure... |
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 |
/* * Process memory_failure work queued on the specified CPU. * Used to avoid return-to-userspace racing with the memory_failure workqueue. */ void memory_failure_queue_kick(int cpu) { struct memory_failure_cpu *mf_cpu; mf_cpu = &per_cpu(memory_failure_cpu, cpu); cancel_work_sync(&mf_cpu->work); memory_failure_work_func(&mf_cpu->work); } |
ea8f5fb8a HWPoison: add mem... |
1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 |
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); |
a5f651090 mm: hwpoison: rat... |
1550 1551 1552 1553 1554 |
#define unpoison_pr_info(fmt, pfn, rs) \ ({ \ if (__ratelimit(rs)) \ pr_info(fmt, pfn); \ }) |
847ce401d HWPOISON: Add unp... |
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 |
/** * 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; |
a5f651090 mm: hwpoison: rat... |
1572 1573 |
static DEFINE_RATELIMIT_STATE(unpoison_rs, DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST); |
847ce401d HWPOISON: Add unp... |
1574 1575 1576 1577 1578 1579 1580 1581 |
if (!pfn_valid(pfn)) return -ENXIO; p = pfn_to_page(pfn); page = compound_head(p); if (!PageHWPoison(p)) { |
495367c05 mm/memory-failure... |
1582 1583 |
unpoison_pr_info("Unpoison: Page was already unpoisoned %#lx ", |
a5f651090 mm: hwpoison: rat... |
1584 |
pfn, &unpoison_rs); |
847ce401d HWPOISON: Add unp... |
1585 1586 |
return 0; } |
230ac719c mm/hwpoison: don'... |
1587 |
if (page_count(page) > 1) { |
495367c05 mm/memory-failure... |
1588 1589 |
unpoison_pr_info("Unpoison: Someone grabs the hwpoison page %#lx ", |
a5f651090 mm: hwpoison: rat... |
1590 |
pfn, &unpoison_rs); |
230ac719c mm/hwpoison: don'... |
1591 1592 1593 1594 |
return 0; } if (page_mapped(page)) { |
495367c05 mm/memory-failure... |
1595 1596 |
unpoison_pr_info("Unpoison: Someone maps the hwpoison page %#lx ", |
a5f651090 mm: hwpoison: rat... |
1597 |
pfn, &unpoison_rs); |
230ac719c mm/hwpoison: don'... |
1598 1599 1600 1601 |
return 0; } if (page_mapping(page)) { |
495367c05 mm/memory-failure... |
1602 1603 |
unpoison_pr_info("Unpoison: the hwpoison page has non-NULL mapping %#lx ", |
a5f651090 mm: hwpoison: rat... |
1604 |
pfn, &unpoison_rs); |
230ac719c mm/hwpoison: don'... |
1605 1606 |
return 0; } |
0cea3fdc4 mm/hwpoison: fix ... |
1607 1608 1609 1610 1611 |
/* * 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 ... |
1612 |
if (!PageHuge(page) && PageTransHuge(page)) { |
495367c05 mm/memory-failure... |
1613 1614 |
unpoison_pr_info("Unpoison: Memory failure is now running on %#lx ", |
a5f651090 mm: hwpoison: rat... |
1615 |
pfn, &unpoison_rs); |
ead07f6a8 mm/memory-failure... |
1616 |
return 0; |
0cea3fdc4 mm/hwpoison: fix ... |
1617 |
} |
ead07f6a8 mm/memory-failure... |
1618 |
if (!get_hwpoison_page(p)) { |
847ce401d HWPOISON: Add unp... |
1619 |
if (TestClearPageHWPoison(p)) |
8e30456b6 mm/hwpoison: intr... |
1620 |
num_poisoned_pages_dec(); |
495367c05 mm/memory-failure... |
1621 1622 |
unpoison_pr_info("Unpoison: Software-unpoisoned free page %#lx ", |
a5f651090 mm: hwpoison: rat... |
1623 |
pfn, &unpoison_rs); |
847ce401d HWPOISON: Add unp... |
1624 1625 |
return 0; } |
7eaceacca block: remove per... |
1626 |
lock_page(page); |
847ce401d HWPOISON: Add unp... |
1627 1628 1629 1630 1631 1632 |
/* * 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... |
1633 |
if (TestClearPageHWPoison(page)) { |
495367c05 mm/memory-failure... |
1634 1635 |
unpoison_pr_info("Unpoison: Software-unpoisoned page %#lx ", |
a5f651090 mm: hwpoison: rat... |
1636 |
pfn, &unpoison_rs); |
b37ff71cc mm: hwpoison: cha... |
1637 |
num_poisoned_pages_dec(); |
847ce401d HWPOISON: Add unp... |
1638 1639 1640 |
freeit = 1; } unlock_page(page); |
dd6e2402f mm,hwpoison: kill... |
1641 |
put_page(page); |
3ba5eebc4 mm/memory-failure... |
1642 |
if (freeit && !(pfn == my_zero_pfn(0) && page_count(p) == 1)) |
dd6e2402f mm,hwpoison: kill... |
1643 |
put_page(page); |
847ce401d HWPOISON: Add unp... |
1644 1645 1646 1647 |
return 0; } EXPORT_SYMBOL(unpoison_memory); |
facb6011f HWPOISON: Add sof... |
1648 |
|
facb6011f HWPOISON: Add sof... |
1649 1650 1651 1652 1653 1654 |
/* * 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... |
1655 |
static int __get_any_page(struct page *p, unsigned long pfn, int flags) |
facb6011f HWPOISON: Add sof... |
1656 1657 1658 1659 1660 1661 1662 |
{ int ret; if (flags & MF_COUNT_INCREASED) return 1; /* |
d950b9588 HWPOISON, hugetlb... |
1663 1664 1665 |
* When the target page is a free hugepage, just remove it * from free hugepage list. */ |
ead07f6a8 mm/memory-failure... |
1666 |
if (!get_hwpoison_page(p)) { |
d950b9588 HWPOISON, hugetlb... |
1667 |
if (PageHuge(p)) { |
71dd0b8ae mm/memory_failure... |
1668 1669 |
pr_info("%s: %#lx free huge page ", __func__, pfn); |
af8fae7c0 mm/memory-failure... |
1670 |
ret = 0; |
d950b9588 HWPOISON, hugetlb... |
1671 |
} else if (is_free_buddy_page(p)) { |
71dd0b8ae mm/memory_failure... |
1672 1673 |
pr_info("%s: %#lx free buddy page ", __func__, pfn); |
facb6011f HWPOISON: Add sof... |
1674 |
ret = 0; |
1f2481ddb mm,hwpoison: doub... |
1675 1676 1677 |
} else if (page_count(p)) { /* raced with allocation */ ret = -EBUSY; |
facb6011f HWPOISON: Add sof... |
1678 |
} else { |
71dd0b8ae mm/memory_failure... |
1679 1680 1681 |
pr_info("%s: %#lx: unknown zero refcount page type %lx ", __func__, pfn, p->flags); |
facb6011f HWPOISON: Add sof... |
1682 1683 1684 1685 1686 1687 |
ret = -EIO; } } else { /* Not a free page */ ret = 1; } |
facb6011f HWPOISON: Add sof... |
1688 1689 |
return ret; } |
af8fae7c0 mm/memory-failure... |
1690 1691 1692 |
static int get_any_page(struct page *page, unsigned long pfn, int flags) { int ret = __get_any_page(page, pfn, flags); |
1f2481ddb mm,hwpoison: doub... |
1693 1694 |
if (ret == -EBUSY) ret = __get_any_page(page, pfn, flags); |
85fbe5d1b HWPOISON: soft of... |
1695 1696 |
if (ret == 1 && !PageHuge(page) && !PageLRU(page) && !__PageMovable(page)) { |
af8fae7c0 mm/memory-failure... |
1697 1698 1699 |
/* * Try to free it. */ |
dd6e2402f mm,hwpoison: kill... |
1700 |
put_page(page); |
af8fae7c0 mm/memory-failure... |
1701 1702 1703 1704 1705 1706 |
shake_page(page, 1); /* * Did it turn free? */ ret = __get_any_page(page, pfn, 0); |
d96b339f4 mm: soft-offline:... |
1707 |
if (ret == 1 && !PageLRU(page)) { |
4f32be677 mm/hwpoison: fix ... |
1708 |
/* Drop page reference which is from __get_any_page() */ |
dd6e2402f mm,hwpoison: kill... |
1709 |
put_page(page); |
82a2481e8 mm/memory-failure... |
1710 1711 1712 |
pr_info("soft_offline: %#lx: unknown non LRU page type %lx (%pGp) ", pfn, page->flags, &page->flags); |
af8fae7c0 mm/memory-failure... |
1713 1714 1715 1716 1717 |
return -EIO; } } return ret; } |
6b9a217ed mm,hwpoison: refa... |
1718 |
static bool isolate_page(struct page *page, struct list_head *pagelist) |
d950b9588 HWPOISON, hugetlb... |
1719 |
{ |
6b9a217ed mm,hwpoison: refa... |
1720 1721 |
bool isolated = false; bool lru = PageLRU(page); |
d950b9588 HWPOISON, hugetlb... |
1722 |
|
6b9a217ed mm,hwpoison: refa... |
1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 |
if (PageHuge(page)) { isolated = isolate_huge_page(page, pagelist); } else { if (lru) isolated = !isolate_lru_page(page); else isolated = !isolate_movable_page(page, ISOLATE_UNEVICTABLE); if (isolated) list_add(&page->lru, pagelist); |
0ebff32c3 memory-failure: f... |
1733 |
} |
d950b9588 HWPOISON, hugetlb... |
1734 |
|
6b9a217ed mm,hwpoison: refa... |
1735 1736 1737 |
if (isolated && lru) inc_node_page_state(page, NR_ISOLATED_ANON + page_is_file_lru(page)); |
036138080 mm/hwpoison: fix ... |
1738 |
/* |
6b9a217ed mm,hwpoison: refa... |
1739 1740 1741 1742 1743 |
* If we succeed to isolate the page, we grabbed another refcount on * the page, so we can safely drop the one we got from get_any_pages(). * If we failed to isolate the page, it means that we cannot go further * and we will return an error, so drop the reference we got from * get_any_pages() as well. |
036138080 mm/hwpoison: fix ... |
1744 |
*/ |
6b9a217ed mm,hwpoison: refa... |
1745 1746 |
put_page(page); return isolated; |
d950b9588 HWPOISON, hugetlb... |
1747 |
} |
6b9a217ed mm,hwpoison: refa... |
1748 1749 1750 1751 1752 1753 |
/* * __soft_offline_page handles hugetlb-pages and non-hugetlb pages. * If the page is a non-dirty unmapped page-cache page, it simply invalidates. * If the page is mapped, it migrates the contents over. */ static int __soft_offline_page(struct page *page) |
af8fae7c0 mm/memory-failure... |
1754 |
{ |
6b9a217ed mm,hwpoison: refa... |
1755 |
int ret = 0; |
af8fae7c0 mm/memory-failure... |
1756 |
unsigned long pfn = page_to_pfn(page); |
6b9a217ed mm,hwpoison: refa... |
1757 1758 1759 1760 |
struct page *hpage = compound_head(page); char const *msg_page[] = {"page", "hugepage"}; bool huge = PageHuge(page); LIST_HEAD(pagelist); |
546087599 mm/memory-failure... |
1761 1762 1763 1764 |
struct migration_target_control mtc = { .nid = NUMA_NO_NODE, .gfp_mask = GFP_USER | __GFP_MOVABLE | __GFP_RETRY_MAYFAIL, }; |
facb6011f HWPOISON: Add sof... |
1765 |
|
facb6011f HWPOISON: Add sof... |
1766 |
/* |
af8fae7c0 mm/memory-failure... |
1767 1768 1769 1770 |
* 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... |
1771 |
*/ |
0ebff32c3 memory-failure: f... |
1772 |
lock_page(page); |
6b9a217ed mm,hwpoison: refa... |
1773 1774 |
if (!PageHuge(page)) wait_on_page_writeback(page); |
af8fae7c0 mm/memory-failure... |
1775 1776 |
if (PageHWPoison(page)) { unlock_page(page); |
dd6e2402f mm,hwpoison: kill... |
1777 |
put_page(page); |
af8fae7c0 mm/memory-failure... |
1778 1779 |
pr_info("soft offline: %#lx page already poisoned ", pfn); |
5a2ffca3c mm,hwpoison: retu... |
1780 |
return 0; |
af8fae7c0 mm/memory-failure... |
1781 |
} |
6b9a217ed mm,hwpoison: refa... |
1782 1783 1784 1785 1786 1787 1788 |
if (!PageHuge(page)) /* * Try to invalidate first. This should work for * non dirty unmapped page cache pages. */ ret = invalidate_inode_page(page); |
facb6011f HWPOISON: Add sof... |
1789 |
unlock_page(page); |
6b9a217ed mm,hwpoison: refa... |
1790 |
|
facb6011f HWPOISON: Add sof... |
1791 |
/* |
facb6011f HWPOISON: Add sof... |
1792 1793 1794 |
* RED-PEN would be better to keep it isolated here, but we * would need to fix isolation locking first. */ |
6b9a217ed mm,hwpoison: refa... |
1795 |
if (ret) { |
fb46e7352 HWPOISON: Convert... |
1796 1797 |
pr_info("soft_offline: %#lx: invalidated ", pfn); |
6b9a217ed mm,hwpoison: refa... |
1798 |
page_handle_poison(page, false, true); |
af8fae7c0 mm/memory-failure... |
1799 |
return 0; |
facb6011f HWPOISON: Add sof... |
1800 |
} |
6b9a217ed mm,hwpoison: refa... |
1801 |
if (isolate_page(hpage, &pagelist)) { |
546087599 mm/memory-failure... |
1802 1803 |
ret = migrate_pages(&pagelist, alloc_migration_target, NULL, (unsigned long)&mtc, MIGRATE_SYNC, MR_MEMORY_FAILURE); |
79f5f8fab mm,hwpoison: rewo... |
1804 |
if (!ret) { |
6b9a217ed mm,hwpoison: refa... |
1805 1806 1807 1808 |
bool release = !huge; if (!page_handle_poison(page, huge, release)) ret = -EBUSY; |
79f5f8fab mm,hwpoison: rewo... |
1809 |
} else { |
85fbe5d1b HWPOISON: soft of... |
1810 1811 |
if (!list_empty(&pagelist)) putback_movable_pages(&pagelist); |
59c82b70d mm/migrate: remov... |
1812 |
|
6b9a217ed mm,hwpoison: refa... |
1813 1814 1815 |
pr_info("soft offline: %#lx: %s migration failed %d, type %lx (%pGp) ", pfn, msg_page[huge], ret, page->flags, &page->flags); |
facb6011f HWPOISON: Add sof... |
1816 1817 1818 1819 |
if (ret > 0) ret = -EIO; } } else { |
6b9a217ed mm,hwpoison: refa... |
1820 1821 1822 1823 |
pr_info("soft offline: %#lx: %s isolation failed: %d, page count %d, type %lx (%pGp) ", pfn, msg_page[huge], ret, page_count(page), page->flags, &page->flags); ret = -EBUSY; |
facb6011f HWPOISON: Add sof... |
1824 |
} |
facb6011f HWPOISON: Add sof... |
1825 1826 |
return ret; } |
86e057734 mm/hwpoison: drop... |
1827 |
|
6b9a217ed mm,hwpoison: refa... |
1828 |
static int soft_offline_in_use_page(struct page *page) |
acc14dc4b mm: soft-offline:... |
1829 |
{ |
acc14dc4b mm: soft-offline:... |
1830 |
struct page *hpage = compound_head(page); |
694bf0b0c mm,hwpoison: unif... |
1831 1832 |
if (!PageHuge(page) && PageTransHuge(hpage)) if (try_to_split_thp_page(page, "soft offline") < 0) |
acc14dc4b mm: soft-offline:... |
1833 |
return -EBUSY; |
6b9a217ed mm,hwpoison: refa... |
1834 |
return __soft_offline_page(page); |
acc14dc4b mm: soft-offline:... |
1835 |
} |
d4ae9916e mm: soft-offline:... |
1836 |
static int soft_offline_free_page(struct page *page) |
acc14dc4b mm: soft-offline:... |
1837 |
{ |
6b9a217ed mm,hwpoison: refa... |
1838 |
int rc = 0; |
acc14dc4b mm: soft-offline:... |
1839 |
|
6b9a217ed mm,hwpoison: refa... |
1840 1841 |
if (!page_handle_poison(page, true, false)) rc = -EBUSY; |
06be6ff3d mm,hwpoison: rewo... |
1842 |
|
d4ae9916e mm: soft-offline:... |
1843 |
return rc; |
acc14dc4b mm: soft-offline:... |
1844 |
} |
86e057734 mm/hwpoison: drop... |
1845 1846 |
/** * soft_offline_page - Soft offline a page. |
feec24a61 mm, soft-offline:... |
1847 |
* @pfn: pfn to soft-offline |
86e057734 mm/hwpoison: drop... |
1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 |
* @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. */ |
feec24a61 mm, soft-offline:... |
1867 |
int soft_offline_page(unsigned long pfn, int flags) |
86e057734 mm/hwpoison: drop... |
1868 1869 |
{ int ret; |
feec24a61 mm, soft-offline:... |
1870 |
struct page *page; |
b94e02822 mm,hwpoison: try ... |
1871 |
bool try_again = true; |
86e057734 mm/hwpoison: drop... |
1872 |
|
feec24a61 mm, soft-offline:... |
1873 1874 1875 1876 1877 |
if (!pfn_valid(pfn)) return -ENXIO; /* Only online pages can be soft-offlined (esp., not ZONE_DEVICE). */ page = pfn_to_online_page(pfn); if (!page) |
86a66810b mm, madvise_injec... |
1878 |
return -EIO; |
86a66810b mm, madvise_injec... |
1879 |
|
86e057734 mm/hwpoison: drop... |
1880 1881 1882 |
if (PageHWPoison(page)) { pr_info("soft offline: %#lx page already poisoned ", pfn); |
1e0e635be mm/hwpoison: fix ... |
1883 |
if (flags & MF_COUNT_INCREASED) |
dd6e2402f mm,hwpoison: kill... |
1884 |
put_page(page); |
5a2ffca3c mm,hwpoison: retu... |
1885 |
return 0; |
86e057734 mm/hwpoison: drop... |
1886 |
} |
86e057734 mm/hwpoison: drop... |
1887 |
|
b94e02822 mm,hwpoison: try ... |
1888 |
retry: |
bfc8c9013 mem-hotplug: impl... |
1889 |
get_online_mems(); |
86e057734 mm/hwpoison: drop... |
1890 |
ret = get_any_page(page, pfn, flags); |
bfc8c9013 mem-hotplug: impl... |
1891 |
put_online_mems(); |
4e41a30c6 mm: hwpoison: adj... |
1892 |
|
acc14dc4b mm: soft-offline:... |
1893 |
if (ret > 0) |
6b9a217ed mm,hwpoison: refa... |
1894 |
ret = soft_offline_in_use_page(page); |
acc14dc4b mm: soft-offline:... |
1895 |
else if (ret == 0) |
b94e02822 mm,hwpoison: try ... |
1896 1897 1898 1899 |
if (soft_offline_free_page(page) && try_again) { try_again = false; goto retry; } |
4e41a30c6 mm: hwpoison: adj... |
1900 |
|
86e057734 mm/hwpoison: drop... |
1901 1902 |
return ret; } |