Blame view
mm/oom_kill.c
11.5 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 7 8 |
/* * 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... * * The routines in this file are used to kill a process when |
a49335cce [PATCH] cpusets: ... |
9 10 |
* 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 |
11 12 13 14 15 16 |
* * 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... |
17 |
#include <linux/oom.h> |
1da177e4c Linux-2.6.12-rc2 |
18 19 20 21 22 |
#include <linux/mm.h> #include <linux/sched.h> #include <linux/swap.h> #include <linux/timex.h> #include <linux/jiffies.h> |
ef08e3b49 [PATCH] cpusets: ... |
23 |
#include <linux/cpuset.h> |
8bc719d3c [PATCH] out of me... |
24 25 |
#include <linux/module.h> #include <linux/notifier.h> |
1da177e4c Linux-2.6.12-rc2 |
26 |
|
fadd8fbd1 [PATCH] support f... |
27 |
int sysctl_panic_on_oom; |
1da177e4c Linux-2.6.12-rc2 |
28 29 30 |
/* #define DEBUG */ /** |
6937a25cf [PATCH] mm: fix t... |
31 |
* badness - calculate a numeric value for how bad this task has been |
1da177e4c Linux-2.6.12-rc2 |
32 |
* @p: task struct of which task we should calculate |
a49335cce [PATCH] cpusets: ... |
33 |
* @uptime: current uptime in seconds |
1da177e4c Linux-2.6.12-rc2 |
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
* * The formula used is relatively simple and documented inline in the * function. The main rationale is that we want to select a good task * to kill when we run out of memory. * * Good in this context means that: * 1) we lose the minimum amount of work done * 2) we recover a large amount of memory * 3) we don't kill anything innocent of eating tons of memory * 4) we want to kill the minimum amount of processes (one) * 5) we try to kill the process the user expects us to kill, this * algorithm has been meticulously tuned to meet the principle * of least surprise ... (be careful when you change it) */ unsigned long badness(struct task_struct *p, unsigned long uptime) { unsigned long points, cpu_time, run_time, s; |
97c2c9b84 [PATCH] oom-kill:... |
52 53 |
struct mm_struct *mm; struct task_struct *child; |
1da177e4c Linux-2.6.12-rc2 |
54 |
|
97c2c9b84 [PATCH] oom-kill:... |
55 56 57 58 |
task_lock(p); mm = p->mm; if (!mm) { task_unlock(p); |
1da177e4c Linux-2.6.12-rc2 |
59 |
return 0; |
97c2c9b84 [PATCH] oom-kill:... |
60 |
} |
1da177e4c Linux-2.6.12-rc2 |
61 62 |
/* |
af5b91243 [PATCH] oom: swap... |
63 64 65 66 67 68 |
* swapoff can easily use up all memory, so kill those first. */ if (p->flags & PF_SWAPOFF) return ULONG_MAX; /* |
1da177e4c Linux-2.6.12-rc2 |
69 70 |
* The memory size of the process is the basis for the badness. */ |
97c2c9b84 [PATCH] oom-kill:... |
71 72 73 74 75 76 |
points = mm->total_vm; /* * After this unlock we can no longer dereference local variable `mm' */ task_unlock(p); |
1da177e4c Linux-2.6.12-rc2 |
77 78 79 |
/* * Processes which fork a lot of child processes are likely |
9827b781f [PATCH] OOM kill:... |
80 |
* a good choice. We add half the vmsize of the children if they |
1da177e4c Linux-2.6.12-rc2 |
81 |
* have an own mm. This prevents forking servers to flood the |
9827b781f [PATCH] OOM kill:... |
82 83 84 |
* machine with an endless amount of children. In case a single * child is eating the vast majority of memory, adding only half * to the parents will make the child our kill candidate of choice. |
1da177e4c Linux-2.6.12-rc2 |
85 |
*/ |
97c2c9b84 [PATCH] oom-kill:... |
86 87 88 89 90 |
list_for_each_entry(child, &p->children, sibling) { task_lock(child); if (child->mm != mm && child->mm) points += child->mm->total_vm/2 + 1; task_unlock(child); |
1da177e4c Linux-2.6.12-rc2 |
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
} /* * CPU time is in tens of seconds and run time is in thousands * of seconds. There is no particular reason for this other than * that it turned out to work very well in practice. */ cpu_time = (cputime_to_jiffies(p->utime) + cputime_to_jiffies(p->stime)) >> (SHIFT_HZ + 3); if (uptime >= p->start_time.tv_sec) run_time = (uptime - p->start_time.tv_sec) >> 10; else run_time = 0; s = int_sqrt(cpu_time); if (s) points /= s; s = int_sqrt(int_sqrt(run_time)); if (s) points /= s; /* * Niced processes are most likely less important, so double * their badness points. */ if (task_nice(p) > 0) points *= 2; /* * Superuser processes are usually more important, so we make it * less likely that we kill those. */ if (cap_t(p->cap_effective) & CAP_TO_MASK(CAP_SYS_ADMIN) || p->uid == 0 || p->euid == 0) points /= 4; /* * We don't want to kill a process with direct hardware access. * Not only could that mess up the hardware, but usually users * tend to only have this flag set on applications they think * of as important. */ if (cap_t(p->cap_effective) & CAP_TO_MASK(CAP_SYS_RAWIO)) points /= 4; /* |
7887a3da7 [PATCH] oom: cpus... |
138 139 140 141 142 143 144 145 |
* If p's nodes don't overlap ours, it may still help to kill p * because p may have allocated or otherwise mapped memory on * this node before. However it will be less likely. */ if (!cpuset_excl_nodes_overlap(p)) points /= 8; /* |
1da177e4c Linux-2.6.12-rc2 |
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 |
* Adjust the score by oomkilladj. */ if (p->oomkilladj) { if (p->oomkilladj > 0) points <<= p->oomkilladj; else points >>= -(p->oomkilladj); } #ifdef DEBUG printk(KERN_DEBUG "OOMkill: task %d (%s) got %d points ", p->pid, p->comm, points); #endif return points; } /* |
9b0f8b040 [PATCH] Terminate... |
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 |
* Types of limitations to the nodes from which allocations may occur */ #define CONSTRAINT_NONE 1 #define CONSTRAINT_MEMORY_POLICY 2 #define CONSTRAINT_CPUSET 3 /* * Determine the type of allocation constraint. */ static inline int constrained_alloc(struct zonelist *zonelist, gfp_t gfp_mask) { #ifdef CONFIG_NUMA struct zone **z; nodemask_t nodes = node_online_map; for (z = zonelist->zones; *z; z++) if (cpuset_zone_allowed(*z, gfp_mask)) |
89fa30242 [PATCH] NUMA: Add... |
181 |
node_clear(zone_to_nid(*z), nodes); |
9b0f8b040 [PATCH] Terminate... |
182 183 184 185 186 187 188 189 190 191 192 |
else return CONSTRAINT_CPUSET; if (!nodes_empty(nodes)) return CONSTRAINT_MEMORY_POLICY; #endif return CONSTRAINT_NONE; } /* |
1da177e4c Linux-2.6.12-rc2 |
193 194 195 196 197 |
* 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) */ |
9827b781f [PATCH] OOM kill:... |
198 |
static struct task_struct *select_bad_process(unsigned long *ppoints) |
1da177e4c Linux-2.6.12-rc2 |
199 |
{ |
1da177e4c Linux-2.6.12-rc2 |
200 201 202 |
struct task_struct *g, *p; struct task_struct *chosen = NULL; struct timespec uptime; |
9827b781f [PATCH] OOM kill:... |
203 |
*ppoints = 0; |
1da177e4c Linux-2.6.12-rc2 |
204 205 |
do_posix_clock_monotonic_gettime(&uptime); |
a49335cce [PATCH] cpusets: ... |
206 207 |
do_each_thread(g, p) { unsigned long points; |
a49335cce [PATCH] cpusets: ... |
208 |
|
28324d1df [PATCH] select_ba... |
209 210 211 212 |
/* * skip kernel threads and tasks which have already released * their mm. */ |
5081dde33 [PATCH] oom: kthr... |
213 214 |
if (!p->mm) continue; |
28324d1df [PATCH] select_ba... |
215 216 |
/* skip the init task */ if (is_init(p)) |
a49335cce [PATCH] cpusets: ... |
217 |
continue; |
ef08e3b49 [PATCH] cpusets: ... |
218 |
|
a49335cce [PATCH] cpusets: ... |
219 |
/* |
b78483a4b [PATCH] oom: don'... |
220 221 222 223 224 225 226 227 228 229 230 231 |
* 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); /* |
6937a25cf [PATCH] mm: fix t... |
232 |
* This is in the process of releasing memory so wait for it |
a49335cce [PATCH] cpusets: ... |
233 |
* to finish before killing some other task by mistake. |
50ec3bbff [PATCH] oom: hand... |
234 235 236 237 238 |
* * However, if p is the current task, we allow the 'kill' to * go ahead if it is exiting: this will simply set TIF_MEMDIE, * which will allow it to gain access to memory reserves in * the process of exiting and releasing its resources. |
b78483a4b [PATCH] oom: don'... |
239 |
* Otherwise we could get an easy OOM deadlock. |
a49335cce [PATCH] cpusets: ... |
240 |
*/ |
b78483a4b [PATCH] oom: don'... |
241 242 243 |
if (p->flags & PF_EXITING) { if (p != current) return ERR_PTR(-1UL); |
972c4ea59 [PATCH] select_ba... |
244 245 |
chosen = p; *ppoints = ULONG_MAX; |
50ec3bbff [PATCH] oom: hand... |
246 |
} |
972c4ea59 [PATCH] select_ba... |
247 |
|
4a3ede107 [PATCH] oom: hand... |
248 249 |
if (p->oomkilladj == OOM_DISABLE) continue; |
a49335cce [PATCH] cpusets: ... |
250 251 |
points = badness(p, uptime.tv_sec); |
9827b781f [PATCH] OOM kill:... |
252 |
if (points > *ppoints || !chosen) { |
a49335cce [PATCH] cpusets: ... |
253 |
chosen = p; |
9827b781f [PATCH] OOM kill:... |
254 |
*ppoints = points; |
1da177e4c Linux-2.6.12-rc2 |
255 |
} |
a49335cce [PATCH] cpusets: ... |
256 |
} while_each_thread(g, p); |
972c4ea59 [PATCH] select_ba... |
257 |
|
1da177e4c Linux-2.6.12-rc2 |
258 259 260 261 |
return chosen; } /** |
5a291b98b [PATCH] oom-kill:... |
262 263 264 |
* Send SIGKILL to the selected process irrespective of CAP_SYS_RAW_IO * flag though it's unlikely that we select a process with CAP_SYS_RAW_IO * set. |
1da177e4c Linux-2.6.12-rc2 |
265 |
*/ |
36c8b5868 [PATCH] sched: cl... |
266 |
static void __oom_kill_task(struct task_struct *p, const char *message) |
1da177e4c Linux-2.6.12-rc2 |
267 |
{ |
f400e198b [PATCH] pidspace:... |
268 |
if (is_init(p)) { |
1da177e4c Linux-2.6.12-rc2 |
269 270 271 272 273 |
WARN_ON(1); printk(KERN_WARNING "tried to kill init! "); return; } |
01017a227 [PATCH] oom_kill_... |
274 |
if (!p->mm) { |
1da177e4c Linux-2.6.12-rc2 |
275 276 277 |
WARN_ON(1); printk(KERN_WARNING "tried to kill an mm-less task! "); |
1da177e4c Linux-2.6.12-rc2 |
278 279 |
return; } |
50ec3bbff [PATCH] oom: hand... |
280 281 282 283 |
if (message) { printk(KERN_ERR "%s: Killed process %d (%s). ", |
9b0f8b040 [PATCH] Terminate... |
284 |
message, p->pid, p->comm); |
50ec3bbff [PATCH] oom: hand... |
285 |
} |
1da177e4c Linux-2.6.12-rc2 |
286 287 288 289 290 291 292 293 294 295 296 |
/* * We give our sacrificial lamb high priority and access to * all the memory it needs. That way it should be able to * exit() and clear out its resources quickly... */ p->time_slice = HZ; set_tsk_thread_flag(p, TIF_MEMDIE); force_sig(SIGKILL, p); } |
36c8b5868 [PATCH] sched: cl... |
297 |
static int oom_kill_task(struct task_struct *p, const char *message) |
1da177e4c Linux-2.6.12-rc2 |
298 |
{ |
013159227 [PATCH] mm: fix m... |
299 |
struct mm_struct *mm; |
36c8b5868 [PATCH] sched: cl... |
300 |
struct task_struct *g, *q; |
1da177e4c Linux-2.6.12-rc2 |
301 |
|
013159227 [PATCH] mm: fix m... |
302 303 304 305 306 307 308 309 310 311 |
mm = p->mm; /* WARNING: mm may not be dereferenced since we did not obtain its * value from get_task_mm(p). This is OK since all we need to do is * compare mm to q->mm below. * * Furthermore, even if mm contains a non-NULL value, p->mm may * change to NULL at any time since we do not hold task_lock(p). * However, this is of no concern to us. */ |
01017a227 [PATCH] oom_kill_... |
312 |
if (mm == NULL) |
013159227 [PATCH] mm: fix m... |
313 |
return 1; |
1da177e4c Linux-2.6.12-rc2 |
314 |
|
9b0f8b040 [PATCH] Terminate... |
315 |
__oom_kill_task(p, message); |
1da177e4c Linux-2.6.12-rc2 |
316 317 318 319 320 321 |
/* * kill all processes that share the ->mm (i.e. all threads), * but are in a different thread group */ do_each_thread(g, q) if (q->mm == mm && q->tgid != p->tgid) |
9b0f8b040 [PATCH] Terminate... |
322 |
__oom_kill_task(q, message); |
1da177e4c Linux-2.6.12-rc2 |
323 |
while_each_thread(g, q); |
013159227 [PATCH] mm: fix m... |
324 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
325 |
} |
013159227 [PATCH] mm: fix m... |
326 327 |
static int oom_kill_process(struct task_struct *p, unsigned long points, const char *message) |
1da177e4c Linux-2.6.12-rc2 |
328 |
{ |
1da177e4c Linux-2.6.12-rc2 |
329 330 |
struct task_struct *c; struct list_head *tsk; |
50ec3bbff [PATCH] oom: hand... |
331 332 333 334 335 336 337 338 339 340 341 342 |
/* * 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 */ if (p->flags & PF_EXITING) { __oom_kill_task(p, NULL); return 0; } printk(KERN_ERR "Out of Memory: Kill process %d (%s) score %li" " and children. ", p->pid, p->comm, points); |
1da177e4c Linux-2.6.12-rc2 |
343 344 345 346 347 |
/* Try to kill a child first */ list_for_each(tsk, &p->children) { c = list_entry(tsk, struct task_struct, sibling); if (c->mm == p->mm) continue; |
013159227 [PATCH] mm: fix m... |
348 349 |
if (!oom_kill_task(c, message)) return 0; |
1da177e4c Linux-2.6.12-rc2 |
350 |
} |
9b0f8b040 [PATCH] Terminate... |
351 |
return oom_kill_task(p, message); |
1da177e4c Linux-2.6.12-rc2 |
352 |
} |
8bc719d3c [PATCH] out of me... |
353 354 355 356 357 358 359 360 361 362 363 364 365 |
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); |
1da177e4c Linux-2.6.12-rc2 |
366 |
/** |
6937a25cf [PATCH] mm: fix t... |
367 |
* out_of_memory - kill the "best" process when we run out of memory |
1da177e4c Linux-2.6.12-rc2 |
368 369 370 371 372 373 |
* * 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. */ |
9b0f8b040 [PATCH] Terminate... |
374 |
void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order) |
1da177e4c Linux-2.6.12-rc2 |
375 |
{ |
36c8b5868 [PATCH] sched: cl... |
376 |
struct task_struct *p; |
d6713e046 [PATCH] out_of_me... |
377 |
unsigned long points = 0; |
8bc719d3c [PATCH] out of me... |
378 379 380 381 382 383 |
unsigned long freed = 0; 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 |
384 |
|
42639269f [PATCH] mm: quiet... |
385 |
if (printk_ratelimit()) { |
b72f16044 [PATCH] oom: more... |
386 387 388 389 |
printk(KERN_WARNING "%s invoked oom-killer: " "gfp_mask=0x%x, order=%d, oomkilladj=%d ", current->comm, gfp_mask, order, current->oomkilladj); |
b958f7d9f [PATCH] dump_stac... |
390 |
dump_stack(); |
42639269f [PATCH] mm: quiet... |
391 392 |
show_mem(); } |
578c2fd6a [PATCH] add OOM d... |
393 |
|
505970b96 [PATCH] cpuset oo... |
394 |
cpuset_lock(); |
1da177e4c Linux-2.6.12-rc2 |
395 |
read_lock(&tasklist_lock); |
9b0f8b040 [PATCH] Terminate... |
396 397 398 399 400 401 402 |
/* * Check if there were limitations on the allocation (only relevant for * NUMA) that may require different handling. */ switch (constrained_alloc(zonelist, gfp_mask)) { case CONSTRAINT_MEMORY_POLICY: |
013159227 [PATCH] mm: fix m... |
403 |
oom_kill_process(current, points, |
9b0f8b040 [PATCH] Terminate... |
404 405 406 407 |
"No available memory (MPOL_BIND)"); break; case CONSTRAINT_CPUSET: |
013159227 [PATCH] mm: fix m... |
408 |
oom_kill_process(current, points, |
9b0f8b040 [PATCH] Terminate... |
409 410 411 412 |
"No available memory in cpuset"); break; case CONSTRAINT_NONE: |
fadd8fbd1 [PATCH] support f... |
413 414 415 |
if (sysctl_panic_on_oom) panic("out of memory. panic_on_oom is selected "); |
1da177e4c Linux-2.6.12-rc2 |
416 |
retry: |
9b0f8b040 [PATCH] Terminate... |
417 418 419 420 421 |
/* * Rambo mode: Shoot down a process and hope it solves whatever * issues we may have. */ p = select_bad_process(&points); |
1da177e4c Linux-2.6.12-rc2 |
422 |
|
9b0f8b040 [PATCH] Terminate... |
423 424 |
if (PTR_ERR(p) == -1UL) goto out; |
1da177e4c Linux-2.6.12-rc2 |
425 |
|
9b0f8b040 [PATCH] Terminate... |
426 427 428 429 430 431 432 |
/* Found nothing?!?! Either we hang forever, or we panic. */ if (!p) { read_unlock(&tasklist_lock); cpuset_unlock(); panic("Out of memory and no killable processes... "); } |
1da177e4c Linux-2.6.12-rc2 |
433 |
|
013159227 [PATCH] mm: fix m... |
434 |
if (oom_kill_process(p, points, "Out of memory")) |
9b0f8b040 [PATCH] Terminate... |
435 436 437 438 |
goto retry; break; } |
1da177e4c Linux-2.6.12-rc2 |
439 |
|
9b0f8b040 [PATCH] Terminate... |
440 |
out: |
140ffcec4 [PATCH] out_of_me... |
441 |
read_unlock(&tasklist_lock); |
505970b96 [PATCH] cpuset oo... |
442 |
cpuset_unlock(); |
1da177e4c Linux-2.6.12-rc2 |
443 444 445 |
/* * Give "p" a good chance of killing itself before we |
2f659f462 [PATCH] Optimise ... |
446 |
* retry to allocate memory unless "p" is current |
1da177e4c Linux-2.6.12-rc2 |
447 |
*/ |
2f659f462 [PATCH] Optimise ... |
448 |
if (!test_thread_flag(TIF_MEMDIE)) |
140ffcec4 [PATCH] out_of_me... |
449 |
schedule_timeout_uninterruptible(1); |
1da177e4c Linux-2.6.12-rc2 |
450 |
} |