Blame view
mm/oom_kill.c
21.8 KB
1da177e4c
|
1 2 3 4 5 6 |
/* * linux/mm/oom_kill.c * * Copyright (C) 1998,2000 Rik van Riel * Thanks go out to Claus Fischer for some serious inspiration and * for goading me into coding this file... |
a63d83f42
|
7 8 |
* Copyright (C) 2010 Google, Inc. * Rewritten by David Rientjes |
1da177e4c
|
9 10 |
* * The routines in this file are used to kill a process when |
a49335cce
|
11 12 |
* we're seriously out of memory. This gets called from __alloc_pages() * in mm/page_alloc.c when we really run out of memory. |
1da177e4c
|
13 14 15 16 17 18 |
* * Since we won't call these routines often (on a well-configured * machine) this file will double as a 'coding guide' and a signpost * for newbie kernel hackers. It features several pointers to major * kernel subsystems and hints as to where to find out what things do. */ |
8ac773b4f
|
19 |
#include <linux/oom.h> |
1da177e4c
|
20 |
#include <linux/mm.h> |
4e950f6f0
|
21 |
#include <linux/err.h> |
5a0e3ad6a
|
22 |
#include <linux/gfp.h> |
1da177e4c
|
23 24 25 26 |
#include <linux/sched.h> #include <linux/swap.h> #include <linux/timex.h> #include <linux/jiffies.h> |
ef08e3b49
|
27 |
#include <linux/cpuset.h> |
b95f1b31b
|
28 |
#include <linux/export.h> |
8bc719d3c
|
29 |
#include <linux/notifier.h> |
c7ba5c9e8
|
30 |
#include <linux/memcontrol.h> |
6f48d0ebd
|
31 |
#include <linux/mempolicy.h> |
5cd9c58fb
|
32 |
#include <linux/security.h> |
edd45544c
|
33 |
#include <linux/ptrace.h> |
f660daac4
|
34 |
#include <linux/freezer.h> |
43d2b1132
|
35 |
#include <linux/ftrace.h> |
dc3f21ead
|
36 |
#include <linux/ratelimit.h> |
43d2b1132
|
37 38 39 |
#define CREATE_TRACE_POINTS #include <trace/events/oom.h> |
1da177e4c
|
40 |
|
fadd8fbd1
|
41 |
int sysctl_panic_on_oom; |
fe071d7e8
|
42 |
int sysctl_oom_kill_allocating_task; |
ad915c432
|
43 |
int sysctl_oom_dump_tasks = 1; |
c7d4caeb1
|
44 |
static DEFINE_SPINLOCK(zone_scan_lock); |
1da177e4c
|
45 |
|
43362a497
|
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
/* * compare_swap_oom_score_adj() - compare and swap current's oom_score_adj * @old_val: old oom_score_adj for compare * @new_val: new oom_score_adj for swap * * Sets the oom_score_adj value for current to @new_val iff its present value is * @old_val. Usually used to reinstate a previous value to prevent racing with * userspacing tuning the value in the interim. */ void compare_swap_oom_score_adj(int old_val, int new_val) { struct sighand_struct *sighand = current->sighand; spin_lock_irq(&sighand->siglock); if (current->signal->oom_score_adj == old_val) current->signal->oom_score_adj = new_val; |
43d2b1132
|
62 |
trace_oom_score_adj_update(current); |
43362a497
|
63 64 |
spin_unlock_irq(&sighand->siglock); } |
72788c385
|
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
/** * test_set_oom_score_adj() - set current's oom_score_adj and return old value * @new_val: new oom_score_adj value * * Sets the oom_score_adj value for current to @new_val with proper * synchronization and returns the old value. Usually used to temporarily * set a value, save the old value in the caller, and then reinstate it later. */ int test_set_oom_score_adj(int new_val) { struct sighand_struct *sighand = current->sighand; int old_val; spin_lock_irq(&sighand->siglock); old_val = current->signal->oom_score_adj; |
c9f01245b
|
80 |
current->signal->oom_score_adj = new_val; |
43d2b1132
|
81 |
trace_oom_score_adj_update(current); |
72788c385
|
82 83 84 85 |
spin_unlock_irq(&sighand->siglock); return old_val; } |
6f48d0ebd
|
86 87 88 89 90 91 92 93 94 |
#ifdef CONFIG_NUMA /** * has_intersects_mems_allowed() - check task eligiblity for kill * @tsk: task struct of which task to consider * @mask: nodemask passed to page allocator for mempolicy ooms * * Task eligibility is determined by whether or not a candidate task, @tsk, * shares the same mempolicy nodes as current if it is bound by such a policy * and whether or not it has the same set of allowed cpuset nodes. |
495789a51
|
95 |
*/ |
6f48d0ebd
|
96 97 |
static bool has_intersects_mems_allowed(struct task_struct *tsk, const nodemask_t *mask) |
495789a51
|
98 |
{ |
6f48d0ebd
|
99 |
struct task_struct *start = tsk; |
495789a51
|
100 |
|
495789a51
|
101 |
do { |
6f48d0ebd
|
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
if (mask) { /* * If this is a mempolicy constrained oom, tsk's * cpuset is irrelevant. Only return true if its * mempolicy intersects current, otherwise it may be * needlessly killed. */ if (mempolicy_nodemask_intersects(tsk, mask)) return true; } else { /* * This is not a mempolicy constrained oom, so only * check the mems of tsk's cpuset. */ if (cpuset_mems_allowed_intersects(current, tsk)) return true; } |
df1090a8d
|
119 |
} while_each_thread(start, tsk); |
6f48d0ebd
|
120 121 122 123 124 125 126 |
return false; } #else static bool has_intersects_mems_allowed(struct task_struct *tsk, const nodemask_t *mask) { return true; |
495789a51
|
127 |
} |
6f48d0ebd
|
128 |
#endif /* CONFIG_NUMA */ |
495789a51
|
129 |
|
6f48d0ebd
|
130 131 132 133 134 135 |
/* * The process p may have detached its own ->mm while exiting or through * use_mm(), but one or more of its subthreads may still have a valid * pointer. Return p, or any of its subthreads with a valid ->mm, with * task_lock() held. */ |
158e0a2d1
|
136 |
struct task_struct *find_lock_task_mm(struct task_struct *p) |
dd8e8f405
|
137 138 139 140 141 142 143 144 145 146 147 148 |
{ struct task_struct *t = p; do { task_lock(t); if (likely(t->mm)) return t; task_unlock(t); } while_each_thread(p, t); return NULL; } |
ab290adba
|
149 |
/* return true if the task is not adequate as candidate victim task. */ |
e85bfd3aa
|
150 |
static bool oom_unkillable_task(struct task_struct *p, |
72835c86c
|
151 |
const struct mem_cgroup *memcg, const nodemask_t *nodemask) |
ab290adba
|
152 153 154 155 156 157 158 |
{ if (is_global_init(p)) return true; if (p->flags & PF_KTHREAD) return true; /* When mem_cgroup_out_of_memory() and p is not member of the group */ |
72835c86c
|
159 |
if (memcg && !task_in_mem_cgroup(p, memcg)) |
ab290adba
|
160 161 162 163 164 165 166 167 |
return true; /* p may not have freeable memory in nodemask */ if (!has_intersects_mems_allowed(p, nodemask)) return true; return false; } |
1da177e4c
|
168 |
/** |
a63d83f42
|
169 |
* oom_badness - heuristic function to determine which candidate task to kill |
1da177e4c
|
170 |
* @p: task struct of which task we should calculate |
a63d83f42
|
171 |
* @totalpages: total present RAM allowed for page allocation |
1da177e4c
|
172 |
* |
a63d83f42
|
173 174 175 |
* The heuristic for determining which task to kill is made to be as simple and * predictable as possible. The goal is to return the highest value for the * task consuming the most memory to avoid subsequent oom failures. |
1da177e4c
|
176 |
*/ |
a7f638f99
|
177 178 |
unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg, const nodemask_t *nodemask, unsigned long totalpages) |
1da177e4c
|
179 |
{ |
1e11ad8dc
|
180 |
long points; |
61eafb00d
|
181 |
long adj; |
28b83c519
|
182 |
|
72835c86c
|
183 |
if (oom_unkillable_task(p, memcg, nodemask)) |
26ebc9849
|
184 |
return 0; |
1da177e4c
|
185 |
|
dd8e8f405
|
186 187 |
p = find_lock_task_mm(p); if (!p) |
1da177e4c
|
188 |
return 0; |
61eafb00d
|
189 190 |
adj = p->signal->oom_score_adj; if (adj == OOM_SCORE_ADJ_MIN) { |
5aecc85ab
|
191 192 193 |
task_unlock(p); return 0; } |
1da177e4c
|
194 |
/* |
a63d83f42
|
195 |
* The baseline for the badness score is the proportion of RAM that each |
f755a042d
|
196 |
* task's rss, pagetable and swap space use. |
1da177e4c
|
197 |
*/ |
a7f638f99
|
198 199 |
points = get_mm_rss(p->mm) + p->mm->nr_ptes + get_mm_counter(p->mm, MM_SWAPENTS); |
a63d83f42
|
200 |
task_unlock(p); |
1da177e4c
|
201 202 |
/* |
a63d83f42
|
203 204 |
* Root processes get 3% bonus, just like the __vm_enough_memory() * implementation used by LSMs. |
1da177e4c
|
205 |
*/ |
a63d83f42
|
206 |
if (has_capability_noaudit(p, CAP_SYS_ADMIN)) |
61eafb00d
|
207 |
adj -= 30; |
1da177e4c
|
208 |
|
61eafb00d
|
209 210 211 |
/* Normalize to oom_score_adj units */ adj *= totalpages / 1000; points += adj; |
1da177e4c
|
212 |
|
f19e8aa11
|
213 |
/* |
a7f638f99
|
214 215 |
* Never return 0 for an eligible task regardless of the root bonus and * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here). |
f19e8aa11
|
216 |
*/ |
1e11ad8dc
|
217 |
return points > 0 ? points : 1; |
1da177e4c
|
218 219 220 |
} /* |
9b0f8b040
|
221 222 |
* Determine the type of allocation constraint. */ |
9b0f8b040
|
223 |
#ifdef CONFIG_NUMA |
4365a5676
|
224 |
static enum oom_constraint constrained_alloc(struct zonelist *zonelist, |
a63d83f42
|
225 226 |
gfp_t gfp_mask, nodemask_t *nodemask, unsigned long *totalpages) |
4365a5676
|
227 |
{ |
54a6eb5c4
|
228 |
struct zone *zone; |
dd1a239f6
|
229 |
struct zoneref *z; |
54a6eb5c4
|
230 |
enum zone_type high_zoneidx = gfp_zone(gfp_mask); |
a63d83f42
|
231 232 |
bool cpuset_limited = false; int nid; |
9b0f8b040
|
233 |
|
a63d83f42
|
234 235 236 237 238 |
/* Default to all available memory */ *totalpages = totalram_pages + total_swap_pages; if (!zonelist) return CONSTRAINT_NONE; |
4365a5676
|
239 240 241 242 243 244 245 |
/* * Reach here only when __GFP_NOFAIL is used. So, we should avoid * to kill current.We have to random task kill in this case. * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now. */ if (gfp_mask & __GFP_THISNODE) return CONSTRAINT_NONE; |
9b0f8b040
|
246 |
|
4365a5676
|
247 |
/* |
a63d83f42
|
248 249 250 |
* This is not a __GFP_THISNODE allocation, so a truncated nodemask in * the page allocator means a mempolicy is in effect. Cpuset policy * is enforced in get_page_from_freelist(). |
4365a5676
|
251 |
*/ |
a63d83f42
|
252 253 254 255 |
if (nodemask && !nodes_subset(node_states[N_HIGH_MEMORY], *nodemask)) { *totalpages = total_swap_pages; for_each_node_mask(nid, *nodemask) *totalpages += node_spanned_pages(nid); |
9b0f8b040
|
256 |
return CONSTRAINT_MEMORY_POLICY; |
a63d83f42
|
257 |
} |
4365a5676
|
258 259 260 261 262 |
/* Check this allocation failure is caused by cpuset's wall function */ for_each_zone_zonelist_nodemask(zone, z, zonelist, high_zoneidx, nodemask) if (!cpuset_zone_allowed_softwall(zone, gfp_mask)) |
a63d83f42
|
263 |
cpuset_limited = true; |
9b0f8b040
|
264 |
|
a63d83f42
|
265 266 267 268 269 270 |
if (cpuset_limited) { *totalpages = total_swap_pages; for_each_node_mask(nid, cpuset_current_mems_allowed) *totalpages += node_spanned_pages(nid); return CONSTRAINT_CPUSET; } |
9b0f8b040
|
271 272 |
return CONSTRAINT_NONE; } |
4365a5676
|
273 274 |
#else static enum oom_constraint constrained_alloc(struct zonelist *zonelist, |
a63d83f42
|
275 276 |
gfp_t gfp_mask, nodemask_t *nodemask, unsigned long *totalpages) |
4365a5676
|
277 |
{ |
a63d83f42
|
278 |
*totalpages = totalram_pages + total_swap_pages; |
4365a5676
|
279 280 281 |
return CONSTRAINT_NONE; } #endif |
9b0f8b040
|
282 |
|
9cbb78bb3
|
283 284 285 |
enum oom_scan_t oom_scan_process_thread(struct task_struct *task, unsigned long totalpages, const nodemask_t *nodemask, bool force_kill) |
462607ecc
|
286 287 288 |
{ if (task->exit_state) return OOM_SCAN_CONTINUE; |
9cbb78bb3
|
289 |
if (oom_unkillable_task(task, NULL, nodemask)) |
462607ecc
|
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 320 321 322 323 324 325 326 327 |
return OOM_SCAN_CONTINUE; /* * This task already has access to memory reserves and is being killed. * Don't allow any other task to have access to the reserves. */ if (test_tsk_thread_flag(task, TIF_MEMDIE)) { if (unlikely(frozen(task))) __thaw_task(task); if (!force_kill) return OOM_SCAN_ABORT; } if (!task->mm) return OOM_SCAN_CONTINUE; if (task->flags & PF_EXITING) { /* * If task is current and is in the process of releasing memory, * allow the "kill" to set TIF_MEMDIE, which will allow it to * access memory reserves. Otherwise, it may stall forever. * * The iteration isn't broken here, however, in case other * threads are found to have already been oom killed. */ if (task == current) return OOM_SCAN_SELECT; else if (!force_kill) { /* * If this task is not being ptraced on exit, then wait * for it to finish before killing some other task * unnecessarily. */ if (!(task->group_leader->ptrace & PT_TRACE_EXIT)) return OOM_SCAN_ABORT; } } return OOM_SCAN_OK; } |
9b0f8b040
|
328 |
/* |
1da177e4c
|
329 |
* Simple selection loop. We chose the process with the highest |
6b0c81b3b
|
330 |
* number of 'points'. |
1da177e4c
|
331 332 333 |
* * (not docbooked, we don't want this one cluttering up the manual) */ |
a63d83f42
|
334 |
static struct task_struct *select_bad_process(unsigned int *ppoints, |
9cbb78bb3
|
335 336 |
unsigned long totalpages, const nodemask_t *nodemask, bool force_kill) |
1da177e4c
|
337 |
{ |
3a5dda7a1
|
338 |
struct task_struct *g, *p; |
1da177e4c
|
339 |
struct task_struct *chosen = NULL; |
a7f638f99
|
340 |
unsigned long chosen_points = 0; |
1da177e4c
|
341 |
|
6b0c81b3b
|
342 |
rcu_read_lock(); |
3a5dda7a1
|
343 |
do_each_thread(g, p) { |
a63d83f42
|
344 |
unsigned int points; |
a49335cce
|
345 |
|
9cbb78bb3
|
346 |
switch (oom_scan_process_thread(p, totalpages, nodemask, |
462607ecc
|
347 348 349 350 351 352 |
force_kill)) { case OOM_SCAN_SELECT: chosen = p; chosen_points = ULONG_MAX; /* fall through */ case OOM_SCAN_CONTINUE: |
c027a474a
|
353 |
continue; |
462607ecc
|
354 |
case OOM_SCAN_ABORT: |
6b0c81b3b
|
355 |
rcu_read_unlock(); |
462607ecc
|
356 357 358 359 |
return ERR_PTR(-1UL); case OOM_SCAN_OK: break; }; |
9cbb78bb3
|
360 |
points = oom_badness(p, NULL, nodemask, totalpages); |
a7f638f99
|
361 |
if (points > chosen_points) { |
a49335cce
|
362 |
chosen = p; |
a7f638f99
|
363 |
chosen_points = points; |
1da177e4c
|
364 |
} |
3a5dda7a1
|
365 |
} while_each_thread(g, p); |
6b0c81b3b
|
366 367 368 |
if (chosen) get_task_struct(chosen); rcu_read_unlock(); |
972c4ea59
|
369 |
|
a7f638f99
|
370 |
*ppoints = chosen_points * 1000 / totalpages; |
1da177e4c
|
371 372 373 374 |
return chosen; } /** |
1b578df02
|
375 |
* dump_tasks - dump current memory state of all system tasks |
dad7557eb
|
376 |
* @memcg: current's memory controller, if constrained |
e85bfd3aa
|
377 |
* @nodemask: nodemask passed to page allocator for mempolicy ooms |
1b578df02
|
378 |
* |
e85bfd3aa
|
379 380 381 |
* Dumps the current memory state of all eligible tasks. Tasks not in the same * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes * are not shown. |
de34d965a
|
382 383 |
* State information includes task's pid, uid, tgid, vm size, rss, nr_ptes, * swapents, oom_score_adj value, and name. |
fef1bdd68
|
384 |
*/ |
72835c86c
|
385 |
static void dump_tasks(const struct mem_cgroup *memcg, const nodemask_t *nodemask) |
fef1bdd68
|
386 |
{ |
c55db9578
|
387 388 |
struct task_struct *p; struct task_struct *task; |
fef1bdd68
|
389 |
|
de34d965a
|
390 391 |
pr_info("[ pid ] uid tgid total_vm rss nr_ptes swapents oom_score_adj name "); |
6b0c81b3b
|
392 |
rcu_read_lock(); |
c55db9578
|
393 |
for_each_process(p) { |
72835c86c
|
394 |
if (oom_unkillable_task(p, memcg, nodemask)) |
b4416d2be
|
395 |
continue; |
fef1bdd68
|
396 |
|
c55db9578
|
397 398 |
task = find_lock_task_mm(p); if (!task) { |
6d2661ede
|
399 |
/* |
74ab7f1d3
|
400 401 |
* This is a kthread or all of p's threads have already * detached their mm's. There's no need to report |
c55db9578
|
402 |
* them; they can't be oom killed anyway. |
6d2661ede
|
403 |
*/ |
6d2661ede
|
404 405 |
continue; } |
c55db9578
|
406 |
|
de34d965a
|
407 408 |
pr_info("[%5d] %5d %5d %8lu %8lu %7lu %8lu %5d %s ", |
078de5f70
|
409 410 |
task->pid, from_kuid(&init_user_ns, task_uid(task)), task->tgid, task->mm->total_vm, get_mm_rss(task->mm), |
de34d965a
|
411 412 |
task->mm->nr_ptes, get_mm_counter(task->mm, MM_SWAPENTS), |
a63d83f42
|
413 |
task->signal->oom_score_adj, task->comm); |
c55db9578
|
414 415 |
task_unlock(task); } |
6b0c81b3b
|
416 |
rcu_read_unlock(); |
fef1bdd68
|
417 |
} |
d31f56dbf
|
418 |
static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order, |
72835c86c
|
419 |
struct mem_cgroup *memcg, const nodemask_t *nodemask) |
1b604d75b
|
420 |
{ |
5e9d834a0
|
421 |
task_lock(current); |
1b604d75b
|
422 |
pr_warning("%s invoked oom-killer: gfp_mask=0x%x, order=%d, " |
a63d83f42
|
423 424 425 426 |
"oom_adj=%d, oom_score_adj=%d ", current->comm, gfp_mask, order, current->signal->oom_adj, current->signal->oom_score_adj); |
1b604d75b
|
427 428 429 |
cpuset_print_task_mems_allowed(current); task_unlock(current); dump_stack(); |
72835c86c
|
430 |
mem_cgroup_print_oom_info(memcg, p); |
b2b755b5f
|
431 |
show_mem(SHOW_MEM_FILTER_NODES); |
1b604d75b
|
432 |
if (sysctl_oom_dump_tasks) |
72835c86c
|
433 |
dump_tasks(memcg, nodemask); |
1b604d75b
|
434 |
} |
3b4798cbc
|
435 |
#define K(x) ((x) << (PAGE_SHIFT-10)) |
6b0c81b3b
|
436 437 438 439 |
/* * Must be called while holding a reference to p, which will be released upon * returning. */ |
9cbb78bb3
|
440 441 442 443 |
void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order, unsigned int points, unsigned long totalpages, struct mem_cgroup *memcg, nodemask_t *nodemask, const char *message) |
1da177e4c
|
444 |
{ |
52d3c0367
|
445 |
struct task_struct *victim = p; |
5e9d834a0
|
446 |
struct task_struct *child; |
52d3c0367
|
447 |
struct task_struct *t = p; |
647f2bdf4
|
448 |
struct mm_struct *mm; |
52d3c0367
|
449 |
unsigned int victim_points = 0; |
dc3f21ead
|
450 451 |
static DEFINE_RATELIMIT_STATE(oom_rs, DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST); |
1da177e4c
|
452 |
|
50ec3bbff
|
453 454 455 456 |
/* * If the task is already exiting, don't alarm the sysadmin or kill * its children or threads, just set TIF_MEMDIE so it can die quickly */ |
0753ba01e
|
457 |
if (p->flags & PF_EXITING) { |
4358997ae
|
458 |
set_tsk_thread_flag(p, TIF_MEMDIE); |
6b0c81b3b
|
459 |
put_task_struct(p); |
2a1c9b1fc
|
460 |
return; |
50ec3bbff
|
461 |
} |
dc3f21ead
|
462 |
if (__ratelimit(&oom_rs)) |
8447d950e
|
463 |
dump_header(p, gfp_mask, order, memcg, nodemask); |
5e9d834a0
|
464 |
task_lock(p); |
a63d83f42
|
465 466 |
pr_err("%s: Kill process %d (%s) score %d or sacrifice child ", |
5e9d834a0
|
467 468 |
message, task_pid_nr(p), p->comm, points); task_unlock(p); |
f3af38d30
|
469 |
|
5e9d834a0
|
470 471 |
/* * If any of p's children has a different mm and is eligible for kill, |
11239836c
|
472 |
* the one with the highest oom_badness() score is sacrificed for its |
5e9d834a0
|
473 474 475 |
* parent. This attempts to lose the minimal amount of work done while * still freeing memory. */ |
6b0c81b3b
|
476 |
read_lock(&tasklist_lock); |
dd8e8f405
|
477 |
do { |
5e9d834a0
|
478 |
list_for_each_entry(child, &t->children, sibling) { |
a63d83f42
|
479 |
unsigned int child_points; |
5e9d834a0
|
480 |
|
edd45544c
|
481 482 |
if (child->mm == p->mm) continue; |
a63d83f42
|
483 484 485 |
/* * oom_badness() returns 0 if the thread is unkillable */ |
72835c86c
|
486 |
child_points = oom_badness(child, memcg, nodemask, |
a63d83f42
|
487 |
totalpages); |
5e9d834a0
|
488 |
if (child_points > victim_points) { |
6b0c81b3b
|
489 |
put_task_struct(victim); |
5e9d834a0
|
490 491 |
victim = child; victim_points = child_points; |
6b0c81b3b
|
492 |
get_task_struct(victim); |
5e9d834a0
|
493 |
} |
dd8e8f405
|
494 495 |
} } while_each_thread(p, t); |
6b0c81b3b
|
496 |
read_unlock(&tasklist_lock); |
dd8e8f405
|
497 |
|
6b0c81b3b
|
498 499 500 501 502 |
rcu_read_lock(); p = find_lock_task_mm(victim); if (!p) { rcu_read_unlock(); put_task_struct(victim); |
647f2bdf4
|
503 |
return; |
6b0c81b3b
|
504 505 506 507 508 |
} else if (victim != p) { get_task_struct(p); put_task_struct(victim); victim = p; } |
647f2bdf4
|
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 |
/* mm cannot safely be dereferenced after task_unlock(victim) */ mm = victim->mm; pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB ", task_pid_nr(victim), victim->comm, K(victim->mm->total_vm), K(get_mm_counter(victim->mm, MM_ANONPAGES)), K(get_mm_counter(victim->mm, MM_FILEPAGES))); task_unlock(victim); /* * Kill all user processes sharing victim->mm in other thread groups, if * any. They don't get access to memory reserves, though, to avoid * depletion of all memory. This prevents mm->mmap_sem livelock when an * oom killed thread cannot exit because it requires the semaphore and * its contended by another thread trying to allocate memory itself. * That thread will now get access to memory reserves since it has a * pending fatal signal. */ for_each_process(p) if (p->mm == mm && !same_thread_group(p, victim) && !(p->flags & PF_KTHREAD)) { if (p->signal->oom_score_adj == OOM_SCORE_ADJ_MIN) continue; task_lock(p); /* Protect ->comm from prctl() */ pr_err("Kill process %d (%s) sharing same memory ", task_pid_nr(p), p->comm); task_unlock(p); |
d2d393099
|
539 |
do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true); |
647f2bdf4
|
540 |
} |
6b0c81b3b
|
541 |
rcu_read_unlock(); |
647f2bdf4
|
542 543 |
set_tsk_thread_flag(victim, TIF_MEMDIE); |
d2d393099
|
544 |
do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true); |
6b0c81b3b
|
545 |
put_task_struct(victim); |
1da177e4c
|
546 |
} |
647f2bdf4
|
547 |
#undef K |
1da177e4c
|
548 |
|
309ed8825
|
549 550 551 |
/* * Determines whether the kernel must panic because of the panic_on_oom sysctl. */ |
876aafbfd
|
552 553 |
void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask, int order, const nodemask_t *nodemask) |
309ed8825
|
554 555 556 557 558 559 560 561 562 563 564 565 |
{ if (likely(!sysctl_panic_on_oom)) return; if (sysctl_panic_on_oom != 2) { /* * panic_on_oom == 1 only affects CONSTRAINT_NONE, the kernel * does not panic for cpuset, mempolicy, or memcg allocation * failures. */ if (constraint != CONSTRAINT_NONE) return; } |
e85bfd3aa
|
566 |
dump_header(NULL, gfp_mask, order, NULL, nodemask); |
309ed8825
|
567 568 569 570 |
panic("Out of memory: %s panic_on_oom is enabled ", sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide"); } |
8bc719d3c
|
571 572 573 574 575 576 577 578 579 580 581 582 583 |
static BLOCKING_NOTIFIER_HEAD(oom_notify_list); int register_oom_notifier(struct notifier_block *nb) { return blocking_notifier_chain_register(&oom_notify_list, nb); } EXPORT_SYMBOL_GPL(register_oom_notifier); int unregister_oom_notifier(struct notifier_block *nb) { return blocking_notifier_chain_unregister(&oom_notify_list, nb); } EXPORT_SYMBOL_GPL(unregister_oom_notifier); |
098d7f128
|
584 585 586 587 588 |
/* * Try to acquire the OOM killer lock for the zones in zonelist. Returns zero * if a parallel OOM killing is already taking place that includes a zone in * the zonelist. Otherwise, locks all zones in the zonelist and returns 1. */ |
ff321feac
|
589 |
int try_set_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask) |
098d7f128
|
590 |
{ |
dd1a239f6
|
591 592 |
struct zoneref *z; struct zone *zone; |
098d7f128
|
593 |
int ret = 1; |
c7d4caeb1
|
594 |
spin_lock(&zone_scan_lock); |
dd1a239f6
|
595 596 |
for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { if (zone_is_oom_locked(zone)) { |
098d7f128
|
597 598 599 |
ret = 0; goto out; } |
dd1a239f6
|
600 601 602 603 |
} for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { /* |
c7d4caeb1
|
604 |
* Lock each zone in the zonelist under zone_scan_lock so a |
ff321feac
|
605 |
* parallel invocation of try_set_zonelist_oom() doesn't succeed |
dd1a239f6
|
606 607 608 609 |
* when it shouldn't. */ zone_set_flag(zone, ZONE_OOM_LOCKED); } |
098d7f128
|
610 |
|
098d7f128
|
611 |
out: |
c7d4caeb1
|
612 |
spin_unlock(&zone_scan_lock); |
098d7f128
|
613 614 615 616 617 618 619 620 |
return ret; } /* * Clears the ZONE_OOM_LOCKED flag for all zones in the zonelist so that failed * allocation attempts with zonelists containing them may now recall the OOM * killer, if necessary. */ |
dd1a239f6
|
621 |
void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask) |
098d7f128
|
622 |
{ |
dd1a239f6
|
623 624 |
struct zoneref *z; struct zone *zone; |
098d7f128
|
625 |
|
c7d4caeb1
|
626 |
spin_lock(&zone_scan_lock); |
dd1a239f6
|
627 628 629 |
for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { zone_clear_flag(zone, ZONE_OOM_LOCKED); } |
c7d4caeb1
|
630 |
spin_unlock(&zone_scan_lock); |
098d7f128
|
631 |
} |
1c0fe6e3b
|
632 |
/* |
e36589323
|
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 |
* Try to acquire the oom killer lock for all system zones. Returns zero if a * parallel oom killing is taking place, otherwise locks all zones and returns * non-zero. */ static int try_set_system_oom(void) { struct zone *zone; int ret = 1; spin_lock(&zone_scan_lock); for_each_populated_zone(zone) if (zone_is_oom_locked(zone)) { ret = 0; goto out; } for_each_populated_zone(zone) zone_set_flag(zone, ZONE_OOM_LOCKED); out: spin_unlock(&zone_scan_lock); return ret; } /* * Clears ZONE_OOM_LOCKED for all system zones so that failed allocation * attempts or page faults may now recall the oom killer, if necessary. */ static void clear_system_oom(void) { struct zone *zone; spin_lock(&zone_scan_lock); for_each_populated_zone(zone) zone_clear_flag(zone, ZONE_OOM_LOCKED); spin_unlock(&zone_scan_lock); } |
1da177e4c
|
668 |
/** |
6937a25cf
|
669 |
* out_of_memory - kill the "best" process when we run out of memory |
1b578df02
|
670 671 672 |
* @zonelist: zonelist pointer * @gfp_mask: memory allocation flags * @order: amount of memory being requested as a power of 2 |
6f48d0ebd
|
673 |
* @nodemask: nodemask passed to page allocator |
08ab9b10d
|
674 |
* @force_kill: true if a task must be killed, even if others are exiting |
1da177e4c
|
675 676 677 678 679 680 |
* * If we run out of memory, we have the choice between either * killing a random task (bad), letting the system crash (worse) * OR try to be smart about which process to kill. Note that we * don't have to be perfect here, we just have to be good. */ |
4365a5676
|
681 |
void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, |
08ab9b10d
|
682 |
int order, nodemask_t *nodemask, bool force_kill) |
1da177e4c
|
683 |
{ |
e85bfd3aa
|
684 |
const nodemask_t *mpol_mask; |
0aad4b312
|
685 |
struct task_struct *p; |
a63d83f42
|
686 |
unsigned long totalpages; |
8bc719d3c
|
687 |
unsigned long freed = 0; |
9cbb78bb3
|
688 |
unsigned int uninitialized_var(points); |
e36589323
|
689 |
enum oom_constraint constraint = CONSTRAINT_NONE; |
b52723c56
|
690 |
int killed = 0; |
8bc719d3c
|
691 692 693 694 695 |
blocking_notifier_call_chain(&oom_notify_list, 0, &freed); if (freed > 0) /* Got some memory back in the last second. */ return; |
1da177e4c
|
696 |
|
7b98c2e40
|
697 698 699 700 701 702 703 704 705 |
/* * If current has a pending SIGKILL, then automatically select it. The * goal is to allow it to allocate so that it may quickly exit and free * its memory. */ if (fatal_signal_pending(current)) { set_thread_flag(TIF_MEMDIE); return; } |
9b0f8b040
|
706 707 708 709 |
/* * Check if there were limitations on the allocation (only relevant for * NUMA) that may require different handling. */ |
a63d83f42
|
710 711 |
constraint = constrained_alloc(zonelist, gfp_mask, nodemask, &totalpages); |
e85bfd3aa
|
712 713 |
mpol_mask = (constraint == CONSTRAINT_MEMORY_POLICY) ? nodemask : NULL; check_panic_on_oom(constraint, gfp_mask, order, mpol_mask); |
0aad4b312
|
714 |
|
121d1ba0a
|
715 |
if (sysctl_oom_kill_allocating_task && current->mm && |
a96cfd6e9
|
716 |
!oom_unkillable_task(current, NULL, nodemask) && |
121d1ba0a
|
717 |
current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) { |
6b0c81b3b
|
718 |
get_task_struct(current); |
2a1c9b1fc
|
719 720 721 722 |
oom_kill_process(current, gfp_mask, order, 0, totalpages, NULL, nodemask, "Out of memory (oom_kill_allocating_task)"); goto out; |
0aad4b312
|
723 |
} |
9cbb78bb3
|
724 |
p = select_bad_process(&points, totalpages, mpol_mask, force_kill); |
0aad4b312
|
725 726 |
/* Found nothing?!?! Either we hang forever, or we panic. */ if (!p) { |
e85bfd3aa
|
727 |
dump_header(NULL, gfp_mask, order, NULL, mpol_mask); |
0aad4b312
|
728 729 730 |
panic("Out of memory and no killable processes... "); } |
2a1c9b1fc
|
731 732 733 734 735 |
if (PTR_ERR(p) != -1UL) { oom_kill_process(p, gfp_mask, order, points, totalpages, NULL, nodemask, "Out of memory"); killed = 1; } |
b52723c56
|
736 |
out: |
1da177e4c
|
737 |
/* |
4f774b912
|
738 739 |
* Give the killed threads a good chance of exiting before trying to * allocate memory again. |
1da177e4c
|
740 |
*/ |
4f774b912
|
741 742 |
if (killed) schedule_timeout_killable(1); |
1da177e4c
|
743 |
} |
e36589323
|
744 745 746 747 748 749 750 751 752 753 |
/* * The pagefault handler calls here because it is out of memory, so kill a * memory-hogging task. If a populated zone has ZONE_OOM_LOCKED set, a parallel * oom killing is already in progress so do nothing. If a task is found with * TIF_MEMDIE set, it has been killed so do nothing and allow it to exit. */ void pagefault_out_of_memory(void) { if (try_set_system_oom()) { |
08ab9b10d
|
754 |
out_of_memory(NULL, 0, 0, NULL, false); |
e36589323
|
755 756 |
clear_system_oom(); } |
4f774b912
|
757 |
schedule_timeout_killable(1); |
e36589323
|
758 |
} |