Blame view
mm/oom_kill.c
21.6 KB
1da177e4c Linux-2.6.12-rc2 |
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 oom: badness heur... |
7 8 |
* Copyright (C) 2010 Google, Inc. * Rewritten by David Rientjes |
1da177e4c Linux-2.6.12-rc2 |
9 10 |
* * The routines in this file are used to kill a process when |
a49335cce [PATCH] cpusets: ... |
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 Linux-2.6.12-rc2 |
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 [PATCH] OOM kille... |
19 |
#include <linux/oom.h> |
1da177e4c Linux-2.6.12-rc2 |
20 |
#include <linux/mm.h> |
4e950f6f0 Remove fs.h from ... |
21 |
#include <linux/err.h> |
5a0e3ad6a include cleanup: ... |
22 |
#include <linux/gfp.h> |
1da177e4c Linux-2.6.12-rc2 |
23 24 25 26 |
#include <linux/sched.h> #include <linux/swap.h> #include <linux/timex.h> #include <linux/jiffies.h> |
ef08e3b49 [PATCH] cpusets: ... |
27 |
#include <linux/cpuset.h> |
8bc719d3c [PATCH] out of me... |
28 29 |
#include <linux/module.h> #include <linux/notifier.h> |
c7ba5c9e8 Memory controller... |
30 |
#include <linux/memcontrol.h> |
6f48d0ebd oom: select task ... |
31 |
#include <linux/mempolicy.h> |
5cd9c58fb security: Fix set... |
32 |
#include <linux/security.h> |
edd45544c oom: avoid deferr... |
33 |
#include <linux/ptrace.h> |
1da177e4c Linux-2.6.12-rc2 |
34 |
|
fadd8fbd1 [PATCH] support f... |
35 |
int sysctl_panic_on_oom; |
fe071d7e8 oom: add oom_kill... |
36 |
int sysctl_oom_kill_allocating_task; |
ad915c432 oom: enable oom t... |
37 |
int sysctl_oom_dump_tasks = 1; |
c7d4caeb1 oom: fix zone_sca... |
38 |
static DEFINE_SPINLOCK(zone_scan_lock); |
1da177e4c Linux-2.6.12-rc2 |
39 |
|
72788c385 oom: replace PF_O... |
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
/** * 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; if (new_val != old_val) { if (new_val == OOM_SCORE_ADJ_MIN) atomic_inc(¤t->mm->oom_disable_count); else if (old_val == OOM_SCORE_ADJ_MIN) atomic_dec(¤t->mm->oom_disable_count); current->signal->oom_score_adj = new_val; } spin_unlock_irq(&sighand->siglock); return old_val; } |
6f48d0ebd oom: select task ... |
66 67 68 69 70 71 72 73 74 |
#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 oom: make oom_sco... |
75 |
*/ |
6f48d0ebd oom: select task ... |
76 77 |
static bool has_intersects_mems_allowed(struct task_struct *tsk, const nodemask_t *mask) |
495789a51 oom: make oom_sco... |
78 |
{ |
6f48d0ebd oom: select task ... |
79 |
struct task_struct *start = tsk; |
495789a51 oom: make oom_sco... |
80 |
|
495789a51 oom: make oom_sco... |
81 |
do { |
6f48d0ebd oom: select task ... |
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
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 oom: cleanup has_... |
99 |
} while_each_thread(start, tsk); |
6f48d0ebd oom: select task ... |
100 101 102 103 104 105 106 |
return false; } #else static bool has_intersects_mems_allowed(struct task_struct *tsk, const nodemask_t *mask) { return true; |
495789a51 oom: make oom_sco... |
107 |
} |
6f48d0ebd oom: select task ... |
108 |
#endif /* CONFIG_NUMA */ |
495789a51 oom: make oom_sco... |
109 |
|
6f48d0ebd oom: select task ... |
110 111 112 113 114 115 |
/* * 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 memcg: use find_l... |
116 |
struct task_struct *find_lock_task_mm(struct task_struct *p) |
dd8e8f405 oom: introduce fi... |
117 118 119 120 121 122 123 124 125 126 127 128 |
{ 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 oom: make oom_unk... |
129 |
/* return true if the task is not adequate as candidate victim task. */ |
e85bfd3aa oom: filter unkil... |
130 131 |
static bool oom_unkillable_task(struct task_struct *p, const struct mem_cgroup *mem, const nodemask_t *nodemask) |
ab290adba oom: make oom_unk... |
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 |
{ 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 */ if (mem && !task_in_mem_cgroup(p, mem)) return true; /* p may not have freeable memory in nodemask */ if (!has_intersects_mems_allowed(p, nodemask)) return true; return false; } |
1da177e4c Linux-2.6.12-rc2 |
148 |
/** |
a63d83f42 oom: badness heur... |
149 |
* oom_badness - heuristic function to determine which candidate task to kill |
1da177e4c Linux-2.6.12-rc2 |
150 |
* @p: task struct of which task we should calculate |
a63d83f42 oom: badness heur... |
151 |
* @totalpages: total present RAM allowed for page allocation |
1da177e4c Linux-2.6.12-rc2 |
152 |
* |
a63d83f42 oom: badness heur... |
153 154 155 |
* 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 Linux-2.6.12-rc2 |
156 |
*/ |
a63d83f42 oom: badness heur... |
157 158 |
unsigned int oom_badness(struct task_struct *p, struct mem_cgroup *mem, const nodemask_t *nodemask, unsigned long totalpages) |
1da177e4c Linux-2.6.12-rc2 |
159 |
{ |
a63d83f42 oom: badness heur... |
160 |
int points; |
28b83c519 oom: move oom_adj... |
161 |
|
26ebc9849 oom: /proc/<pid>/... |
162 163 |
if (oom_unkillable_task(p, mem, nodemask)) return 0; |
1da177e4c Linux-2.6.12-rc2 |
164 |
|
dd8e8f405 oom: introduce fi... |
165 166 |
p = find_lock_task_mm(p); if (!p) |
1da177e4c Linux-2.6.12-rc2 |
167 168 169 |
return 0; /* |
e18641e19 oom: avoid killin... |
170 171 172 |
* Shortcut check for a thread sharing p->mm that is OOM_SCORE_ADJ_MIN * so the entire heuristic doesn't need to be executed for something * that cannot be killed. |
1da177e4c Linux-2.6.12-rc2 |
173 |
*/ |
e18641e19 oom: avoid killin... |
174 |
if (atomic_read(&p->mm->oom_disable_count)) { |
a63d83f42 oom: badness heur... |
175 176 177 |
task_unlock(p); return 0; } |
1da177e4c Linux-2.6.12-rc2 |
178 179 |
/* |
a63d83f42 oom: badness heur... |
180 181 |
* The memory controller may have a limit of 0 bytes, so avoid a divide * by zero, if necessary. |
1da177e4c Linux-2.6.12-rc2 |
182 |
*/ |
a63d83f42 oom: badness heur... |
183 184 |
if (!totalpages) totalpages = 1; |
1da177e4c Linux-2.6.12-rc2 |
185 186 |
/* |
a63d83f42 oom: badness heur... |
187 |
* The baseline for the badness score is the proportion of RAM that each |
f755a042d oom: use pte page... |
188 |
* task's rss, pagetable and swap space use. |
1da177e4c Linux-2.6.12-rc2 |
189 |
*/ |
f755a042d oom: use pte page... |
190 191 192 193 194 |
points = get_mm_rss(p->mm) + p->mm->nr_ptes; points += get_mm_counter(p->mm, MM_SWAPENTS); points *= 1000; points /= totalpages; |
a63d83f42 oom: badness heur... |
195 |
task_unlock(p); |
1da177e4c Linux-2.6.12-rc2 |
196 197 |
/* |
a63d83f42 oom: badness heur... |
198 199 |
* Root processes get 3% bonus, just like the __vm_enough_memory() * implementation used by LSMs. |
1da177e4c Linux-2.6.12-rc2 |
200 |
*/ |
a63d83f42 oom: badness heur... |
201 202 |
if (has_capability_noaudit(p, CAP_SYS_ADMIN)) points -= 30; |
1da177e4c Linux-2.6.12-rc2 |
203 204 |
/* |
a63d83f42 oom: badness heur... |
205 206 207 |
* /proc/pid/oom_score_adj ranges from -1000 to +1000 such that it may * either completely disable oom killing or always prefer a certain * task. |
1da177e4c Linux-2.6.12-rc2 |
208 |
*/ |
a63d83f42 oom: badness heur... |
209 |
points += p->signal->oom_score_adj; |
1da177e4c Linux-2.6.12-rc2 |
210 |
|
f19e8aa11 oom: always retur... |
211 212 213 214 215 216 217 |
/* * Never return 0 for an eligible task that may be killed since it's * possible that no single user task uses more than 0.1% of memory and * no single admin tasks uses more than 3.0%. */ if (points <= 0) return 1; |
a63d83f42 oom: badness heur... |
218 |
return (points < 1000) ? points : 1000; |
1da177e4c Linux-2.6.12-rc2 |
219 220 221 |
} /* |
9b0f8b040 [PATCH] Terminate... |
222 223 |
* Determine the type of allocation constraint. */ |
9b0f8b040 [PATCH] Terminate... |
224 |
#ifdef CONFIG_NUMA |
4365a5676 oom-kill: fix NUM... |
225 |
static enum oom_constraint constrained_alloc(struct zonelist *zonelist, |
a63d83f42 oom: badness heur... |
226 227 |
gfp_t gfp_mask, nodemask_t *nodemask, unsigned long *totalpages) |
4365a5676 oom-kill: fix NUM... |
228 |
{ |
54a6eb5c4 mm: use two zonel... |
229 |
struct zone *zone; |
dd1a239f6 mm: have zonelist... |
230 |
struct zoneref *z; |
54a6eb5c4 mm: use two zonel... |
231 |
enum zone_type high_zoneidx = gfp_zone(gfp_mask); |
a63d83f42 oom: badness heur... |
232 233 |
bool cpuset_limited = false; int nid; |
9b0f8b040 [PATCH] Terminate... |
234 |
|
a63d83f42 oom: badness heur... |
235 236 237 238 239 |
/* Default to all available memory */ *totalpages = totalram_pages + total_swap_pages; if (!zonelist) return CONSTRAINT_NONE; |
4365a5676 oom-kill: fix NUM... |
240 241 242 243 244 245 246 |
/* * 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 [PATCH] Terminate... |
247 |
|
4365a5676 oom-kill: fix NUM... |
248 |
/* |
a63d83f42 oom: badness heur... |
249 250 251 |
* 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 oom-kill: fix NUM... |
252 |
*/ |
a63d83f42 oom: badness heur... |
253 254 255 256 |
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 [PATCH] Terminate... |
257 |
return CONSTRAINT_MEMORY_POLICY; |
a63d83f42 oom: badness heur... |
258 |
} |
4365a5676 oom-kill: fix NUM... |
259 260 261 262 263 |
/* 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 oom: badness heur... |
264 |
cpuset_limited = true; |
9b0f8b040 [PATCH] Terminate... |
265 |
|
a63d83f42 oom: badness heur... |
266 267 268 269 270 271 |
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 [PATCH] Terminate... |
272 273 |
return CONSTRAINT_NONE; } |
4365a5676 oom-kill: fix NUM... |
274 275 |
#else static enum oom_constraint constrained_alloc(struct zonelist *zonelist, |
a63d83f42 oom: badness heur... |
276 277 |
gfp_t gfp_mask, nodemask_t *nodemask, unsigned long *totalpages) |
4365a5676 oom-kill: fix NUM... |
278 |
{ |
a63d83f42 oom: badness heur... |
279 |
*totalpages = totalram_pages + total_swap_pages; |
4365a5676 oom-kill: fix NUM... |
280 281 282 |
return CONSTRAINT_NONE; } #endif |
9b0f8b040 [PATCH] Terminate... |
283 284 |
/* |
1da177e4c Linux-2.6.12-rc2 |
285 286 287 288 289 |
* Simple selection loop. We chose the process with the highest * number of 'points'. We expect the caller will lock the tasklist. * * (not docbooked, we don't want this one cluttering up the manual) */ |
a63d83f42 oom: badness heur... |
290 291 292 |
static struct task_struct *select_bad_process(unsigned int *ppoints, unsigned long totalpages, struct mem_cgroup *mem, const nodemask_t *nodemask) |
1da177e4c Linux-2.6.12-rc2 |
293 |
{ |
3a5dda7a1 oom: prevent unne... |
294 |
struct task_struct *g, *p; |
1da177e4c Linux-2.6.12-rc2 |
295 |
struct task_struct *chosen = NULL; |
9827b781f [PATCH] OOM kill:... |
296 |
*ppoints = 0; |
1da177e4c Linux-2.6.12-rc2 |
297 |
|
3a5dda7a1 oom: prevent unne... |
298 |
do_each_thread(g, p) { |
a63d83f42 oom: badness heur... |
299 |
unsigned int points; |
a49335cce [PATCH] cpusets: ... |
300 |
|
c027a474a oom: task->mm == ... |
301 |
if (p->exit_state) |
30e2b41f2 oom: skip zombies... |
302 |
continue; |
ab290adba oom: make oom_unk... |
303 |
if (oom_unkillable_task(p, mem, nodemask)) |
6cf86ac6f oom: filter tasks... |
304 |
continue; |
ef08e3b49 [PATCH] cpusets: ... |
305 |
|
a49335cce [PATCH] cpusets: ... |
306 |
/* |
b78483a4b [PATCH] oom: don'... |
307 308 309 310 311 312 313 314 315 316 |
* This task already has access to memory reserves and is * being killed. Don't allow any other task access to the * memory reserve. * * Note: this may have a chance of deadlock if it gets * blocked waiting for another task which itself is waiting * for memory. Is there a better alternative? */ if (test_tsk_thread_flag(p, TIF_MEMDIE)) return ERR_PTR(-1UL); |
c027a474a oom: task->mm == ... |
317 318 |
if (!p->mm) continue; |
b78483a4b [PATCH] oom: don'... |
319 |
|
30e2b41f2 oom: skip zombies... |
320 |
if (p->flags & PF_EXITING) { |
edd45544c oom: avoid deferr... |
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 |
/* * If p is the current task and is in the process of * releasing memory, we allow the "kill" to set * TIF_MEMDIE, which will allow it to gain access to * memory reserves. Otherwise, it may stall forever. * * The loop isn't broken here, however, in case other * threads are found to have already been oom killed. */ if (p == current) { chosen = p; *ppoints = 1000; } else { /* * If this task is not being ptraced on exit, * then wait for it to finish before killing * some other task unnecessarily. */ |
d21142ece ptrace: kill task... |
339 |
if (!(p->group_leader->ptrace & PT_TRACE_EXIT)) |
edd45544c oom: avoid deferr... |
340 341 |
return ERR_PTR(-1UL); } |
50ec3bbff [PATCH] oom: hand... |
342 |
} |
972c4ea59 [PATCH] select_ba... |
343 |
|
a63d83f42 oom: badness heur... |
344 345 |
points = oom_badness(p, mem, nodemask, totalpages); if (points > *ppoints) { |
a49335cce [PATCH] cpusets: ... |
346 |
chosen = p; |
9827b781f [PATCH] OOM kill:... |
347 |
*ppoints = points; |
1da177e4c Linux-2.6.12-rc2 |
348 |
} |
3a5dda7a1 oom: prevent unne... |
349 |
} while_each_thread(g, p); |
972c4ea59 [PATCH] select_ba... |
350 |
|
1da177e4c Linux-2.6.12-rc2 |
351 352 353 354 |
return chosen; } /** |
1b578df02 mm/oom_kill: fix ... |
355 |
* dump_tasks - dump current memory state of all system tasks |
74ab7f1d3 oom: improve comm... |
356 |
* @mem: current's memory controller, if constrained |
e85bfd3aa oom: filter unkil... |
357 |
* @nodemask: nodemask passed to page allocator for mempolicy ooms |
1b578df02 mm/oom_kill: fix ... |
358 |
* |
e85bfd3aa oom: filter unkil... |
359 360 361 |
* 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. |
fef1bdd68 oom: add sysctl t... |
362 |
* State information includes task's pid, uid, tgid, vm size, rss, cpu, oom_adj |
a63d83f42 oom: badness heur... |
363 |
* value, oom_score_adj value, and name. |
fef1bdd68 oom: add sysctl t... |
364 |
* |
fef1bdd68 oom: add sysctl t... |
365 366 |
* Call with tasklist_lock read-locked. */ |
e85bfd3aa oom: filter unkil... |
367 |
static void dump_tasks(const struct mem_cgroup *mem, const nodemask_t *nodemask) |
fef1bdd68 oom: add sysctl t... |
368 |
{ |
c55db9578 oom: dump_tasks u... |
369 370 |
struct task_struct *p; struct task_struct *task; |
fef1bdd68 oom: add sysctl t... |
371 |
|
a63d83f42 oom: badness heur... |
372 373 |
pr_info("[ pid ] uid tgid total_vm rss cpu oom_adj oom_score_adj name "); |
c55db9578 oom: dump_tasks u... |
374 |
for_each_process(p) { |
e85bfd3aa oom: filter unkil... |
375 |
if (oom_unkillable_task(p, mem, nodemask)) |
b4416d2be oom: do not dump ... |
376 |
continue; |
fef1bdd68 oom: add sysctl t... |
377 |
|
c55db9578 oom: dump_tasks u... |
378 379 |
task = find_lock_task_mm(p); if (!task) { |
6d2661ede oom: fix possible... |
380 |
/* |
74ab7f1d3 oom: improve comm... |
381 382 |
* This is a kthread or all of p's threads have already * detached their mm's. There's no need to report |
c55db9578 oom: dump_tasks u... |
383 |
* them; they can't be oom killed anyway. |
6d2661ede oom: fix possible... |
384 |
*/ |
6d2661ede oom: fix possible... |
385 386 |
continue; } |
c55db9578 oom: dump_tasks u... |
387 |
|
a63d83f42 oom: badness heur... |
388 389 |
pr_info("[%5d] %5d %5d %8lu %8lu %3u %3d %5d %s ", |
8d6c83f0b oom: __task_cred(... |
390 |
task->pid, task_uid(task), task->tgid, |
a63d83f42 oom: badness heur... |
391 392 393 |
task->mm->total_vm, get_mm_rss(task->mm), task_cpu(task), task->signal->oom_adj, task->signal->oom_score_adj, task->comm); |
c55db9578 oom: dump_tasks u... |
394 395 |
task_unlock(task); } |
fef1bdd68 oom: add sysctl t... |
396 |
} |
d31f56dbf memcg: avoid oom-... |
397 |
static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order, |
e85bfd3aa oom: filter unkil... |
398 |
struct mem_cgroup *mem, const nodemask_t *nodemask) |
1b604d75b oom: dump stack a... |
399 |
{ |
5e9d834a0 oom: sacrifice ch... |
400 |
task_lock(current); |
1b604d75b oom: dump stack a... |
401 |
pr_warning("%s invoked oom-killer: gfp_mask=0x%x, order=%d, " |
a63d83f42 oom: badness heur... |
402 403 404 405 |
"oom_adj=%d, oom_score_adj=%d ", current->comm, gfp_mask, order, current->signal->oom_adj, current->signal->oom_score_adj); |
1b604d75b oom: dump stack a... |
406 407 408 |
cpuset_print_task_mems_allowed(current); task_unlock(current); dump_stack(); |
d31f56dbf memcg: avoid oom-... |
409 |
mem_cgroup_print_oom_info(mem, p); |
b2b755b5f lib, arch: add fi... |
410 |
show_mem(SHOW_MEM_FILTER_NODES); |
1b604d75b oom: dump stack a... |
411 |
if (sysctl_oom_dump_tasks) |
e85bfd3aa oom: filter unkil... |
412 |
dump_tasks(mem, nodemask); |
1b604d75b oom: dump stack a... |
413 |
} |
3b4798cbc oom-kill: show vi... |
414 |
#define K(x) ((x) << (PAGE_SHIFT-10)) |
93b43fa55 oom: give the dyi... |
415 |
static int oom_kill_task(struct task_struct *p, struct mem_cgroup *mem) |
1da177e4c Linux-2.6.12-rc2 |
416 |
{ |
1e99bad0d oom: kill all thr... |
417 418 |
struct task_struct *q; struct mm_struct *mm; |
dd8e8f405 oom: introduce fi... |
419 |
p = find_lock_task_mm(p); |
be71cf220 oom: fix NULL poi... |
420 |
if (!p) |
b940fd703 oom: remove unnec... |
421 |
return 1; |
be71cf220 oom: fix NULL poi... |
422 |
|
1e99bad0d oom: kill all thr... |
423 424 |
/* mm cannot be safely dereferenced after task_unlock(p) */ mm = p->mm; |
b940fd703 oom: remove unnec... |
425 426 427 428 429 |
pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB ", task_pid_nr(p), p->comm, K(p->mm->total_vm), K(get_mm_counter(p->mm, MM_ANONPAGES)), K(get_mm_counter(p->mm, MM_FILEPAGES))); |
3b4798cbc oom-kill: show vi... |
430 |
task_unlock(p); |
1da177e4c Linux-2.6.12-rc2 |
431 |
|
1e99bad0d oom: kill all thr... |
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 |
/* * Kill all processes sharing p->mm in other thread groups, if any. * They don't get access to memory reserves or a higher scheduler * priority, though, to avoid depletion of all memory or task * starvation. This prevents mm->mmap_sem livelock when an oom killed * task 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(q) if (q->mm == mm && !same_thread_group(q, p)) { task_lock(q); /* Protect ->comm from prctl() */ pr_err("Kill process %d (%s) sharing same memory ", task_pid_nr(q), q->comm); task_unlock(q); force_sig(SIGKILL, q); } |
93b43fa55 oom: give the dyi... |
451 |
|
1da177e4c Linux-2.6.12-rc2 |
452 |
set_tsk_thread_flag(p, TIF_MEMDIE); |
1da177e4c Linux-2.6.12-rc2 |
453 |
force_sig(SIGKILL, p); |
93b43fa55 oom: give the dyi... |
454 |
|
013159227 [PATCH] mm: fix m... |
455 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
456 |
} |
b940fd703 oom: remove unnec... |
457 |
#undef K |
1da177e4c Linux-2.6.12-rc2 |
458 |
|
7213f5066 oom: suppress ext... |
459 |
static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order, |
a63d83f42 oom: badness heur... |
460 461 462 |
unsigned int points, unsigned long totalpages, struct mem_cgroup *mem, nodemask_t *nodemask, const char *message) |
1da177e4c Linux-2.6.12-rc2 |
463 |
{ |
52d3c0367 Revert "oom: oom_... |
464 |
struct task_struct *victim = p; |
5e9d834a0 oom: sacrifice ch... |
465 |
struct task_struct *child; |
52d3c0367 Revert "oom: oom_... |
466 467 |
struct task_struct *t = p; unsigned int victim_points = 0; |
1da177e4c Linux-2.6.12-rc2 |
468 |
|
1b604d75b oom: dump stack a... |
469 |
if (printk_ratelimit()) |
e85bfd3aa oom: filter unkil... |
470 |
dump_header(p, gfp_mask, order, mem, nodemask); |
7213f5066 oom: suppress ext... |
471 |
|
50ec3bbff [PATCH] oom: hand... |
472 473 474 475 |
/* * 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 mm: revert "oom: ... |
476 |
if (p->flags & PF_EXITING) { |
4358997ae oom: avoid sendin... |
477 |
set_tsk_thread_flag(p, TIF_MEMDIE); |
50ec3bbff [PATCH] oom: hand... |
478 479 |
return 0; } |
5e9d834a0 oom: sacrifice ch... |
480 |
task_lock(p); |
a63d83f42 oom: badness heur... |
481 482 |
pr_err("%s: Kill process %d (%s) score %d or sacrifice child ", |
5e9d834a0 oom: sacrifice ch... |
483 484 |
message, task_pid_nr(p), p->comm, points); task_unlock(p); |
f3af38d30 [PATCH] oom: clea... |
485 |
|
5e9d834a0 oom: sacrifice ch... |
486 487 |
/* * If any of p's children has a different mm and is eligible for kill, |
11239836c oom: remove refer... |
488 |
* the one with the highest oom_badness() score is sacrificed for its |
5e9d834a0 oom: sacrifice ch... |
489 490 491 |
* parent. This attempts to lose the minimal amount of work done while * still freeing memory. */ |
dd8e8f405 oom: introduce fi... |
492 |
do { |
5e9d834a0 oom: sacrifice ch... |
493 |
list_for_each_entry(child, &t->children, sibling) { |
a63d83f42 oom: badness heur... |
494 |
unsigned int child_points; |
5e9d834a0 oom: sacrifice ch... |
495 |
|
edd45544c oom: avoid deferr... |
496 497 |
if (child->mm == p->mm) continue; |
a63d83f42 oom: badness heur... |
498 499 500 501 502 |
/* * oom_badness() returns 0 if the thread is unkillable */ child_points = oom_badness(child, mem, nodemask, totalpages); |
5e9d834a0 oom: sacrifice ch... |
503 504 505 506 |
if (child_points > victim_points) { victim = child; victim_points = child_points; } |
dd8e8f405 oom: introduce fi... |
507 508 |
} } while_each_thread(p, t); |
93b43fa55 oom: give the dyi... |
509 |
return oom_kill_task(victim, mem); |
1da177e4c Linux-2.6.12-rc2 |
510 |
} |
309ed8825 oom: extract pani... |
511 512 513 514 |
/* * Determines whether the kernel must panic because of the panic_on_oom sysctl. */ static void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask, |
e85bfd3aa oom: filter unkil... |
515 |
int order, const nodemask_t *nodemask) |
309ed8825 oom: extract pani... |
516 517 518 519 520 521 522 523 524 525 526 527 528 |
{ 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; } read_lock(&tasklist_lock); |
e85bfd3aa oom: filter unkil... |
529 |
dump_header(NULL, gfp_mask, order, NULL, nodemask); |
309ed8825 oom: extract pani... |
530 531 532 533 534 |
read_unlock(&tasklist_lock); panic("Out of memory: %s panic_on_oom is enabled ", sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide"); } |
00f0b8259 Memory controller... |
535 |
#ifdef CONFIG_CGROUP_MEM_RES_CTLR |
c7ba5c9e8 Memory controller... |
536 537 |
void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask) { |
a63d83f42 oom: badness heur... |
538 539 |
unsigned long limit; unsigned int points = 0; |
c7ba5c9e8 Memory controller... |
540 |
struct task_struct *p; |
f9434ad15 memcg: give curre... |
541 542 543 544 545 546 547 |
/* * 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); |
f9434ad15 memcg: give curre... |
548 549 |
return; } |
e85bfd3aa oom: filter unkil... |
550 |
check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, 0, NULL); |
a63d83f42 oom: badness heur... |
551 |
limit = mem_cgroup_get_limit(mem) >> PAGE_SHIFT; |
e115f2d89 memcg: fix oops i... |
552 |
read_lock(&tasklist_lock); |
c7ba5c9e8 Memory controller... |
553 |
retry: |
a63d83f42 oom: badness heur... |
554 |
p = select_bad_process(&points, limit, mem, NULL); |
df64f81bb memcg: make oom k... |
555 |
if (!p || PTR_ERR(p) == -1UL) |
c7ba5c9e8 Memory controller... |
556 |
goto out; |
a63d83f42 oom: badness heur... |
557 |
if (oom_kill_process(p, gfp_mask, 0, points, limit, mem, NULL, |
c7ba5c9e8 Memory controller... |
558 559 560 |
"Memory cgroup out of memory")) goto retry; out: |
e115f2d89 memcg: fix oops i... |
561 |
read_unlock(&tasklist_lock); |
c7ba5c9e8 Memory controller... |
562 563 |
} #endif |
8bc719d3c [PATCH] out of me... |
564 565 566 567 568 569 570 571 572 573 574 575 576 |
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 oom: add per-zone... |
577 578 579 580 581 |
/* * 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 mm: rename try_se... |
582 |
int try_set_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask) |
098d7f128 oom: add per-zone... |
583 |
{ |
dd1a239f6 mm: have zonelist... |
584 585 |
struct zoneref *z; struct zone *zone; |
098d7f128 oom: add per-zone... |
586 |
int ret = 1; |
c7d4caeb1 oom: fix zone_sca... |
587 |
spin_lock(&zone_scan_lock); |
dd1a239f6 mm: have zonelist... |
588 589 |
for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { if (zone_is_oom_locked(zone)) { |
098d7f128 oom: add per-zone... |
590 591 592 |
ret = 0; goto out; } |
dd1a239f6 mm: have zonelist... |
593 594 595 596 |
} for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { /* |
c7d4caeb1 oom: fix zone_sca... |
597 |
* Lock each zone in the zonelist under zone_scan_lock so a |
ff321feac mm: rename try_se... |
598 |
* parallel invocation of try_set_zonelist_oom() doesn't succeed |
dd1a239f6 mm: have zonelist... |
599 600 601 602 |
* when it shouldn't. */ zone_set_flag(zone, ZONE_OOM_LOCKED); } |
098d7f128 oom: add per-zone... |
603 |
|
098d7f128 oom: add per-zone... |
604 |
out: |
c7d4caeb1 oom: fix zone_sca... |
605 |
spin_unlock(&zone_scan_lock); |
098d7f128 oom: add per-zone... |
606 607 608 609 610 611 612 613 |
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 mm: have zonelist... |
614 |
void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask) |
098d7f128 oom: add per-zone... |
615 |
{ |
dd1a239f6 mm: have zonelist... |
616 617 |
struct zoneref *z; struct zone *zone; |
098d7f128 oom: add per-zone... |
618 |
|
c7d4caeb1 oom: fix zone_sca... |
619 |
spin_lock(&zone_scan_lock); |
dd1a239f6 mm: have zonelist... |
620 621 622 |
for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { zone_clear_flag(zone, ZONE_OOM_LOCKED); } |
c7d4caeb1 oom: fix zone_sca... |
623 |
spin_unlock(&zone_scan_lock); |
098d7f128 oom: add per-zone... |
624 |
} |
1c0fe6e3b mm: invoke oom-ki... |
625 |
/* |
e36589323 oom: remove speci... |
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 |
* 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 Linux-2.6.12-rc2 |
661 |
/** |
6937a25cf [PATCH] mm: fix t... |
662 |
* out_of_memory - kill the "best" process when we run out of memory |
1b578df02 mm/oom_kill: fix ... |
663 664 665 |
* @zonelist: zonelist pointer * @gfp_mask: memory allocation flags * @order: amount of memory being requested as a power of 2 |
6f48d0ebd oom: select task ... |
666 |
* @nodemask: nodemask passed to page allocator |
1da177e4c Linux-2.6.12-rc2 |
667 668 669 670 671 672 |
* * 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 oom-kill: fix NUM... |
673 674 |
void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order, nodemask_t *nodemask) |
1da177e4c Linux-2.6.12-rc2 |
675 |
{ |
e85bfd3aa oom: filter unkil... |
676 |
const nodemask_t *mpol_mask; |
0aad4b312 oom: fold __out_o... |
677 |
struct task_struct *p; |
a63d83f42 oom: badness heur... |
678 |
unsigned long totalpages; |
8bc719d3c [PATCH] out of me... |
679 |
unsigned long freed = 0; |
a63d83f42 oom: badness heur... |
680 |
unsigned int points; |
e36589323 oom: remove speci... |
681 |
enum oom_constraint constraint = CONSTRAINT_NONE; |
b52723c56 oom: fix tasklist... |
682 |
int killed = 0; |
8bc719d3c [PATCH] out of me... |
683 684 685 686 687 |
blocking_notifier_call_chain(&oom_notify_list, 0, &freed); if (freed > 0) /* Got some memory back in the last second. */ return; |
1da177e4c Linux-2.6.12-rc2 |
688 |
|
7b98c2e40 oom: give current... |
689 690 691 692 693 694 695 696 697 |
/* * 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 [PATCH] Terminate... |
698 699 700 701 |
/* * Check if there were limitations on the allocation (only relevant for * NUMA) that may require different handling. */ |
a63d83f42 oom: badness heur... |
702 703 |
constraint = constrained_alloc(zonelist, gfp_mask, nodemask, &totalpages); |
e85bfd3aa oom: filter unkil... |
704 705 |
mpol_mask = (constraint == CONSTRAINT_MEMORY_POLICY) ? nodemask : NULL; check_panic_on_oom(constraint, gfp_mask, order, mpol_mask); |
0aad4b312 oom: fold __out_o... |
706 |
|
2b45ab339 oom: fix constrai... |
707 |
read_lock(&tasklist_lock); |
f88ccad58 oom: oom_kill_pro... |
708 |
if (sysctl_oom_kill_allocating_task && |
a96cfd6e9 oom: move OOM_DIS... |
709 |
!oom_unkillable_task(current, NULL, nodemask) && |
e18641e19 oom: avoid killin... |
710 |
current->mm && !atomic_read(¤t->mm->oom_disable_count)) { |
0aad4b312 oom: fold __out_o... |
711 712 713 714 715 |
/* * oom_kill_process() needs tasklist_lock held. If it returns * non-zero, current could not be killed so we must fallback to * the tasklist scan. */ |
a63d83f42 oom: badness heur... |
716 717 |
if (!oom_kill_process(current, gfp_mask, order, 0, totalpages, NULL, nodemask, |
0aad4b312 oom: fold __out_o... |
718 |
"Out of memory (oom_kill_allocating_task)")) |
b52723c56 oom: fix tasklist... |
719 |
goto out; |
0aad4b312 oom: fold __out_o... |
720 721 722 |
} retry: |
e85bfd3aa oom: filter unkil... |
723 |
p = select_bad_process(&points, totalpages, NULL, mpol_mask); |
0aad4b312 oom: fold __out_o... |
724 |
if (PTR_ERR(p) == -1UL) |
b52723c56 oom: fix tasklist... |
725 |
goto out; |
0aad4b312 oom: fold __out_o... |
726 727 728 |
/* Found nothing?!?! Either we hang forever, or we panic. */ if (!p) { |
e85bfd3aa oom: filter unkil... |
729 |
dump_header(NULL, gfp_mask, order, NULL, mpol_mask); |
0aad4b312 oom: fold __out_o... |
730 731 732 733 |
read_unlock(&tasklist_lock); panic("Out of memory and no killable processes... "); } |
a63d83f42 oom: badness heur... |
734 735 |
if (oom_kill_process(p, gfp_mask, order, points, totalpages, NULL, nodemask, "Out of memory")) |
0aad4b312 oom: fold __out_o... |
736 |
goto retry; |
b52723c56 oom: fix tasklist... |
737 738 |
killed = 1; out: |
140ffcec4 [PATCH] out_of_me... |
739 |
read_unlock(&tasklist_lock); |
1da177e4c Linux-2.6.12-rc2 |
740 741 742 |
/* * Give "p" a good chance of killing itself before we |
2f659f462 [PATCH] Optimise ... |
743 |
* retry to allocate memory unless "p" is current |
1da177e4c Linux-2.6.12-rc2 |
744 |
*/ |
b52723c56 oom: fix tasklist... |
745 |
if (killed && !test_thread_flag(TIF_MEMDIE)) |
140ffcec4 [PATCH] out_of_me... |
746 |
schedule_timeout_uninterruptible(1); |
1da177e4c Linux-2.6.12-rc2 |
747 |
} |
e36589323 oom: remove speci... |
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 |
/* * 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()) { out_of_memory(NULL, 0, 0, NULL); clear_system_oom(); } if (!test_thread_flag(TIF_MEMDIE)) schedule_timeout_uninterruptible(1); } |