Blame view
mm/oom_kill.c
15.3 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 |
#include <linux/mm.h> |
4e950f6f0 Remove fs.h from ... |
19 |
#include <linux/err.h> |
1da177e4c Linux-2.6.12-rc2 |
20 21 22 23 |
#include <linux/sched.h> #include <linux/swap.h> #include <linux/timex.h> #include <linux/jiffies.h> |
ef08e3b49 [PATCH] cpusets: ... |
24 |
#include <linux/cpuset.h> |
8bc719d3c [PATCH] out of me... |
25 26 |
#include <linux/module.h> #include <linux/notifier.h> |
c7ba5c9e8 Memory controller... |
27 |
#include <linux/memcontrol.h> |
5cd9c58fb security: Fix set... |
28 |
#include <linux/security.h> |
1da177e4c Linux-2.6.12-rc2 |
29 |
|
fadd8fbd1 [PATCH] support f... |
30 |
int sysctl_panic_on_oom; |
fe071d7e8 oom: add oom_kill... |
31 |
int sysctl_oom_kill_allocating_task; |
fef1bdd68 oom: add sysctl t... |
32 |
int sysctl_oom_dump_tasks; |
ae74138da oom: convert zone... |
33 |
static DEFINE_SPINLOCK(zone_scan_mutex); |
1da177e4c Linux-2.6.12-rc2 |
34 35 36 |
/* #define DEBUG */ /** |
6937a25cf [PATCH] mm: fix t... |
37 |
* badness - calculate a numeric value for how bad this task has been |
1da177e4c Linux-2.6.12-rc2 |
38 |
* @p: task struct of which task we should calculate |
a49335cce [PATCH] cpusets: ... |
39 |
* @uptime: current uptime in seconds |
1b578df02 mm/oom_kill: fix ... |
40 |
* @mem: target memory controller |
1da177e4c Linux-2.6.12-rc2 |
41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
* * 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) */ |
97d87c971 oom_kill: remove ... |
55 |
unsigned long badness(struct task_struct *p, unsigned long uptime) |
1da177e4c Linux-2.6.12-rc2 |
56 57 |
{ unsigned long points, cpu_time, run_time, s; |
97c2c9b84 [PATCH] oom-kill:... |
58 59 |
struct mm_struct *mm; struct task_struct *child; |
1da177e4c Linux-2.6.12-rc2 |
60 |
|
97c2c9b84 [PATCH] oom-kill:... |
61 62 63 64 |
task_lock(p); mm = p->mm; if (!mm) { task_unlock(p); |
1da177e4c Linux-2.6.12-rc2 |
65 |
return 0; |
97c2c9b84 [PATCH] oom-kill:... |
66 |
} |
1da177e4c Linux-2.6.12-rc2 |
67 68 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 |
/* |
7ba348594 [PATCH] fix OOM k... |
79 80 81 82 83 84 |
* 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 |
85 |
* Processes which fork a lot of child processes are likely |
9827b781f [PATCH] OOM kill:... |
86 |
* a good choice. We add half the vmsize of the children if they |
1da177e4c Linux-2.6.12-rc2 |
87 |
* have an own mm. This prevents forking servers to flood the |
9827b781f [PATCH] OOM kill:... |
88 89 90 |
* 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 |
91 |
*/ |
97c2c9b84 [PATCH] oom-kill:... |
92 93 94 95 96 |
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 |
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 |
} /* * 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. */ |
5cd9c58fb security: Fix set... |
130 131 |
if (has_capability(p, CAP_SYS_ADMIN) || has_capability(p, CAP_SYS_RESOURCE)) |
1da177e4c Linux-2.6.12-rc2 |
132 133 134 135 136 137 138 139 |
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. */ |
5cd9c58fb security: Fix set... |
140 |
if (has_capability(p, CAP_SYS_RAWIO)) |
1da177e4c Linux-2.6.12-rc2 |
141 142 143 |
points /= 4; /* |
7887a3da7 [PATCH] oom: cpus... |
144 145 146 147 |
* 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. */ |
bbe373f2c oom: compare cpus... |
148 |
if (!cpuset_mems_allowed_intersects(current, p)) |
7887a3da7 [PATCH] oom: cpus... |
149 150 151 |
points /= 8; /* |
1da177e4c Linux-2.6.12-rc2 |
152 153 154 |
* Adjust the score by oomkilladj. */ if (p->oomkilladj) { |
9a82782f8 allow oom_adj of ... |
155 156 157 |
if (p->oomkilladj > 0) { if (!points) points = 1; |
1da177e4c Linux-2.6.12-rc2 |
158 |
points <<= p->oomkilladj; |
9a82782f8 allow oom_adj of ... |
159 |
} else |
1da177e4c Linux-2.6.12-rc2 |
160 161 162 163 |
points >>= -(p->oomkilladj); } #ifdef DEBUG |
a5e58a614 oom: print points... |
164 165 |
printk(KERN_DEBUG "OOMkill: task %d (%s) got %lu points ", |
1da177e4c Linux-2.6.12-rc2 |
166 167 168 169 170 171 |
p->pid, p->comm, points); #endif return points; } /* |
9b0f8b040 [PATCH] Terminate... |
172 173 |
* Determine the type of allocation constraint. */ |
70e24bdf6 oom: move constra... |
174 175 |
static inline enum oom_constraint constrained_alloc(struct zonelist *zonelist, gfp_t gfp_mask) |
9b0f8b040 [PATCH] Terminate... |
176 177 |
{ #ifdef CONFIG_NUMA |
54a6eb5c4 mm: use two zonel... |
178 |
struct zone *zone; |
dd1a239f6 mm: have zonelist... |
179 |
struct zoneref *z; |
54a6eb5c4 mm: use two zonel... |
180 |
enum zone_type high_zoneidx = gfp_zone(gfp_mask); |
ee31af5d6 Memoryless nodes:... |
181 |
nodemask_t nodes = node_states[N_HIGH_MEMORY]; |
9b0f8b040 [PATCH] Terminate... |
182 |
|
54a6eb5c4 mm: use two zonel... |
183 184 185 |
for_each_zone_zonelist(zone, z, zonelist, high_zoneidx) if (cpuset_zone_allowed_softwall(zone, gfp_mask)) node_clear(zone_to_nid(zone), nodes); |
9b0f8b040 [PATCH] Terminate... |
186 187 188 189 190 191 192 193 194 195 196 |
else return CONSTRAINT_CPUSET; if (!nodes_empty(nodes)) return CONSTRAINT_MEMORY_POLICY; #endif return CONSTRAINT_NONE; } /* |
1da177e4c Linux-2.6.12-rc2 |
197 198 199 200 201 |
* 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) */ |
c7ba5c9e8 Memory controller... |
202 203 |
static struct task_struct *select_bad_process(unsigned long *ppoints, struct mem_cgroup *mem) |
1da177e4c Linux-2.6.12-rc2 |
204 |
{ |
1da177e4c Linux-2.6.12-rc2 |
205 206 207 |
struct task_struct *g, *p; struct task_struct *chosen = NULL; struct timespec uptime; |
9827b781f [PATCH] OOM kill:... |
208 |
*ppoints = 0; |
1da177e4c Linux-2.6.12-rc2 |
209 210 |
do_posix_clock_monotonic_gettime(&uptime); |
a49335cce [PATCH] cpusets: ... |
211 212 |
do_each_thread(g, p) { unsigned long points; |
a49335cce [PATCH] cpusets: ... |
213 |
|
28324d1df [PATCH] select_ba... |
214 215 216 217 |
/* * skip kernel threads and tasks which have already released * their mm. */ |
5081dde33 [PATCH] oom: kthr... |
218 219 |
if (!p->mm) continue; |
28324d1df [PATCH] select_ba... |
220 |
/* skip the init task */ |
b460cbc58 pid namespaces: d... |
221 |
if (is_global_init(p)) |
a49335cce [PATCH] cpusets: ... |
222 |
continue; |
4c4a22148 memcontrol: move ... |
223 224 |
if (mem && !task_in_mem_cgroup(p, mem)) continue; |
ef08e3b49 [PATCH] cpusets: ... |
225 |
|
a49335cce [PATCH] cpusets: ... |
226 |
/* |
b78483a4b [PATCH] oom: don'... |
227 228 229 230 231 232 233 234 235 236 237 238 |
* 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... |
239 |
* This is in the process of releasing memory so wait for it |
a49335cce [PATCH] cpusets: ... |
240 |
* to finish before killing some other task by mistake. |
50ec3bbff [PATCH] oom: hand... |
241 242 243 244 245 |
* * 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'... |
246 |
* Otherwise we could get an easy OOM deadlock. |
a49335cce [PATCH] cpusets: ... |
247 |
*/ |
b78483a4b [PATCH] oom: don'... |
248 249 250 |
if (p->flags & PF_EXITING) { if (p != current) return ERR_PTR(-1UL); |
972c4ea59 [PATCH] select_ba... |
251 252 |
chosen = p; *ppoints = ULONG_MAX; |
50ec3bbff [PATCH] oom: hand... |
253 |
} |
972c4ea59 [PATCH] select_ba... |
254 |
|
4a3ede107 [PATCH] oom: hand... |
255 256 |
if (p->oomkilladj == OOM_DISABLE) continue; |
a49335cce [PATCH] cpusets: ... |
257 |
|
97d87c971 oom_kill: remove ... |
258 |
points = badness(p, uptime.tv_sec); |
9827b781f [PATCH] OOM kill:... |
259 |
if (points > *ppoints || !chosen) { |
a49335cce [PATCH] cpusets: ... |
260 |
chosen = p; |
9827b781f [PATCH] OOM kill:... |
261 |
*ppoints = points; |
1da177e4c Linux-2.6.12-rc2 |
262 |
} |
a49335cce [PATCH] cpusets: ... |
263 |
} while_each_thread(g, p); |
972c4ea59 [PATCH] select_ba... |
264 |
|
1da177e4c Linux-2.6.12-rc2 |
265 266 267 268 |
return chosen; } /** |
1b578df02 mm/oom_kill: fix ... |
269 270 271 |
* dump_tasks - dump current memory state of all system tasks * @mem: target memory controller * |
fef1bdd68 oom: add sysctl t... |
272 273 274 275 276 277 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 |
* Dumps the current memory state of all system tasks, excluding kernel threads. * State information includes task's pid, uid, tgid, vm size, rss, cpu, oom_adj * score, and name. * * If the actual is non-NULL, only tasks that are a member of the mem_cgroup are * shown. * * Call with tasklist_lock read-locked. */ static void dump_tasks(const struct mem_cgroup *mem) { struct task_struct *g, *p; printk(KERN_INFO "[ pid ] uid tgid total_vm rss cpu oom_adj " "name "); do_each_thread(g, p) { /* * total_vm and rss sizes do not exist for tasks with a * detached mm so there's no need to report them. */ if (!p->mm) continue; if (mem && !task_in_mem_cgroup(p, mem)) continue; task_lock(p); printk(KERN_INFO "[%5d] %5d %5d %8lu %8lu %3d %3d %s ", p->pid, p->uid, p->tgid, p->mm->total_vm, get_mm_rss(p->mm), (int)task_cpu(p), p->oomkilladj, p->comm); task_unlock(p); } while_each_thread(g, p); } |
1b578df02 mm/oom_kill: fix ... |
307 |
/* |
5a291b98b [PATCH] oom-kill:... |
308 309 310 |
* 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 |
311 |
*/ |
f3af38d30 [PATCH] oom: clea... |
312 |
static void __oom_kill_task(struct task_struct *p, int verbose) |
1da177e4c Linux-2.6.12-rc2 |
313 |
{ |
b460cbc58 pid namespaces: d... |
314 |
if (is_global_init(p)) { |
1da177e4c Linux-2.6.12-rc2 |
315 316 317 318 319 |
WARN_ON(1); printk(KERN_WARNING "tried to kill init! "); return; } |
01017a227 [PATCH] oom_kill_... |
320 |
if (!p->mm) { |
1da177e4c Linux-2.6.12-rc2 |
321 322 323 |
WARN_ON(1); printk(KERN_WARNING "tried to kill an mm-less task! "); |
1da177e4c Linux-2.6.12-rc2 |
324 325 |
return; } |
50ec3bbff [PATCH] oom: hand... |
326 |
|
f3af38d30 [PATCH] oom: clea... |
327 |
if (verbose) |
ba25f9dcc Use helpers to ob... |
328 329 330 |
printk(KERN_ERR "Killed process %d (%s) ", task_pid_nr(p), p->comm); |
1da177e4c Linux-2.6.12-rc2 |
331 332 333 334 335 336 |
/* * 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... */ |
fa717060f sched: sched_rt_e... |
337 |
p->rt.time_slice = HZ; |
1da177e4c Linux-2.6.12-rc2 |
338 339 340 341 |
set_tsk_thread_flag(p, TIF_MEMDIE); force_sig(SIGKILL, p); } |
f3af38d30 [PATCH] oom: clea... |
342 |
static int oom_kill_task(struct task_struct *p) |
1da177e4c Linux-2.6.12-rc2 |
343 |
{ |
013159227 [PATCH] mm: fix m... |
344 |
struct mm_struct *mm; |
36c8b5868 [PATCH] sched: cl... |
345 |
struct task_struct *g, *q; |
1da177e4c Linux-2.6.12-rc2 |
346 |
|
013159227 [PATCH] mm: fix m... |
347 348 349 350 351 352 353 354 355 356 |
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_... |
357 |
if (mm == NULL) |
013159227 [PATCH] mm: fix m... |
358 |
return 1; |
1da177e4c Linux-2.6.12-rc2 |
359 |
|
c33e0fca3 [PATCH] oom: don'... |
360 361 362 363 |
/* * Don't kill the process if any threads are set to OOM_DISABLE */ do_each_thread(g, q) { |
35ae834fa [PATCH] oom fix: ... |
364 |
if (q->mm == mm && q->oomkilladj == OOM_DISABLE) |
c33e0fca3 [PATCH] oom: don'... |
365 366 |
return 1; } while_each_thread(g, q); |
f3af38d30 [PATCH] oom: clea... |
367 |
__oom_kill_task(p, 1); |
c33e0fca3 [PATCH] oom: don'... |
368 |
|
1da177e4c Linux-2.6.12-rc2 |
369 370 |
/* * kill all processes that share the ->mm (i.e. all threads), |
f2a2a7108 [PATCH] oom: less... |
371 372 |
* but are in a different thread group. Don't let them have access * to memory reserves though, otherwise we might deplete all memory. |
1da177e4c Linux-2.6.12-rc2 |
373 |
*/ |
c33e0fca3 [PATCH] oom: don'... |
374 |
do_each_thread(g, q) { |
bac0abd61 Isolate some expl... |
375 |
if (q->mm == mm && !same_thread_group(q, p)) |
650a7c974 oom: kill all thr... |
376 |
force_sig(SIGKILL, q); |
c33e0fca3 [PATCH] oom: don'... |
377 |
} while_each_thread(g, q); |
1da177e4c Linux-2.6.12-rc2 |
378 |
|
013159227 [PATCH] mm: fix m... |
379 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
380 |
} |
7213f5066 oom: suppress ext... |
381 |
static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order, |
fef1bdd68 oom: add sysctl t... |
382 383 |
unsigned long points, struct mem_cgroup *mem, const char *message) |
1da177e4c Linux-2.6.12-rc2 |
384 |
{ |
1da177e4c Linux-2.6.12-rc2 |
385 |
struct task_struct *c; |
1da177e4c Linux-2.6.12-rc2 |
386 |
|
7213f5066 oom: suppress ext... |
387 388 389 390 391 392 393 |
if (printk_ratelimit()) { printk(KERN_WARNING "%s invoked oom-killer: " "gfp_mask=0x%x, order=%d, oomkilladj=%d ", current->comm, gfp_mask, order, current->oomkilladj); dump_stack(); show_mem(); |
fef1bdd68 oom: add sysctl t... |
394 395 |
if (sysctl_oom_dump_tasks) dump_tasks(mem); |
7213f5066 oom: suppress ext... |
396 |
} |
50ec3bbff [PATCH] oom: hand... |
397 398 399 400 401 |
/* * 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) { |
f3af38d30 [PATCH] oom: clea... |
402 |
__oom_kill_task(p, 0); |
50ec3bbff [PATCH] oom: hand... |
403 404 |
return 0; } |
f3af38d30 [PATCH] oom: clea... |
405 406 |
printk(KERN_ERR "%s: kill process %d (%s) score %li or a child ", |
ba25f9dcc Use helpers to ob... |
407 |
message, task_pid_nr(p), p->comm, points); |
f3af38d30 [PATCH] oom: clea... |
408 |
|
1da177e4c Linux-2.6.12-rc2 |
409 |
/* Try to kill a child first */ |
7b1915a98 mm/oom_kill.c: Us... |
410 |
list_for_each_entry(c, &p->children, sibling) { |
1da177e4c Linux-2.6.12-rc2 |
411 412 |
if (c->mm == p->mm) continue; |
f3af38d30 [PATCH] oom: clea... |
413 |
if (!oom_kill_task(c)) |
013159227 [PATCH] mm: fix m... |
414 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
415 |
} |
f3af38d30 [PATCH] oom: clea... |
416 |
return oom_kill_task(p); |
1da177e4c Linux-2.6.12-rc2 |
417 |
} |
00f0b8259 Memory controller... |
418 |
#ifdef CONFIG_CGROUP_MEM_RES_CTLR |
c7ba5c9e8 Memory controller... |
419 420 421 422 423 424 |
void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask) { unsigned long points = 0; struct task_struct *p; cgroup_lock(); |
e115f2d89 memcg: fix oops i... |
425 |
read_lock(&tasklist_lock); |
c7ba5c9e8 Memory controller... |
426 427 428 429 430 431 432 |
retry: p = select_bad_process(&points, mem); if (PTR_ERR(p) == -1UL) goto out; if (!p) p = current; |
fef1bdd68 oom: add sysctl t... |
433 |
if (oom_kill_process(p, gfp_mask, 0, points, mem, |
c7ba5c9e8 Memory controller... |
434 435 436 |
"Memory cgroup out of memory")) goto retry; out: |
e115f2d89 memcg: fix oops i... |
437 |
read_unlock(&tasklist_lock); |
c7ba5c9e8 Memory controller... |
438 439 440 |
cgroup_unlock(); } #endif |
8bc719d3c [PATCH] out of me... |
441 442 443 444 445 446 447 448 449 450 451 452 453 |
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... |
454 455 456 457 458 |
/* * 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. */ |
dd1a239f6 mm: have zonelist... |
459 |
int try_set_zone_oom(struct zonelist *zonelist, gfp_t gfp_mask) |
098d7f128 oom: add per-zone... |
460 |
{ |
dd1a239f6 mm: have zonelist... |
461 462 |
struct zoneref *z; struct zone *zone; |
098d7f128 oom: add per-zone... |
463 |
int ret = 1; |
ae74138da oom: convert zone... |
464 |
spin_lock(&zone_scan_mutex); |
dd1a239f6 mm: have zonelist... |
465 466 |
for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { if (zone_is_oom_locked(zone)) { |
098d7f128 oom: add per-zone... |
467 468 469 |
ret = 0; goto out; } |
dd1a239f6 mm: have zonelist... |
470 471 472 473 474 475 476 477 478 479 |
} for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { /* * Lock each zone in the zonelist under zone_scan_mutex so a * parallel invocation of try_set_zone_oom() doesn't succeed * when it shouldn't. */ zone_set_flag(zone, ZONE_OOM_LOCKED); } |
098d7f128 oom: add per-zone... |
480 |
|
098d7f128 oom: add per-zone... |
481 |
out: |
ae74138da oom: convert zone... |
482 |
spin_unlock(&zone_scan_mutex); |
098d7f128 oom: add per-zone... |
483 484 485 486 487 488 489 490 |
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... |
491 |
void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask) |
098d7f128 oom: add per-zone... |
492 |
{ |
dd1a239f6 mm: have zonelist... |
493 494 |
struct zoneref *z; struct zone *zone; |
098d7f128 oom: add per-zone... |
495 |
|
ae74138da oom: convert zone... |
496 |
spin_lock(&zone_scan_mutex); |
dd1a239f6 mm: have zonelist... |
497 498 499 |
for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) { zone_clear_flag(zone, ZONE_OOM_LOCKED); } |
ae74138da oom: convert zone... |
500 |
spin_unlock(&zone_scan_mutex); |
098d7f128 oom: add per-zone... |
501 |
} |
1da177e4c Linux-2.6.12-rc2 |
502 |
/** |
6937a25cf [PATCH] mm: fix t... |
503 |
* out_of_memory - kill the "best" process when we run out of memory |
1b578df02 mm/oom_kill: fix ... |
504 505 506 |
* @zonelist: zonelist pointer * @gfp_mask: memory allocation flags * @order: amount of memory being requested as a power of 2 |
1da177e4c Linux-2.6.12-rc2 |
507 508 509 510 511 512 |
* * 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... |
513 |
void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order) |
1da177e4c Linux-2.6.12-rc2 |
514 |
{ |
36c8b5868 [PATCH] sched: cl... |
515 |
struct task_struct *p; |
d6713e046 [PATCH] out_of_me... |
516 |
unsigned long points = 0; |
8bc719d3c [PATCH] out of me... |
517 |
unsigned long freed = 0; |
70e24bdf6 oom: move constra... |
518 |
enum oom_constraint constraint; |
8bc719d3c [PATCH] out of me... |
519 520 521 522 523 |
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 |
524 |
|
2b744c01a mm: fix handling ... |
525 526 527 |
if (sysctl_panic_on_oom == 2) panic("out of memory. Compulsory panic_on_oom is selected. "); |
9b0f8b040 [PATCH] Terminate... |
528 529 530 531 |
/* * Check if there were limitations on the allocation (only relevant for * NUMA) that may require different handling. */ |
2b45ab339 oom: fix constrai... |
532 |
constraint = constrained_alloc(zonelist, gfp_mask); |
2b45ab339 oom: fix constrai... |
533 534 535 |
read_lock(&tasklist_lock); switch (constraint) { |
9b0f8b040 [PATCH] Terminate... |
536 |
case CONSTRAINT_MEMORY_POLICY: |
fef1bdd68 oom: add sysctl t... |
537 |
oom_kill_process(current, gfp_mask, order, points, NULL, |
9b0f8b040 [PATCH] Terminate... |
538 539 |
"No available memory (MPOL_BIND)"); break; |
9b0f8b040 [PATCH] Terminate... |
540 |
case CONSTRAINT_NONE: |
fadd8fbd1 [PATCH] support f... |
541 542 543 |
if (sysctl_panic_on_oom) panic("out of memory. panic_on_oom is selected "); |
fe071d7e8 oom: add oom_kill... |
544 545 546 |
/* Fall-through */ case CONSTRAINT_CPUSET: if (sysctl_oom_kill_allocating_task) { |
fef1bdd68 oom: add sysctl t... |
547 |
oom_kill_process(current, gfp_mask, order, points, NULL, |
fe071d7e8 oom: add oom_kill... |
548 549 550 |
"Out of memory (oom_kill_allocating_task)"); break; } |
1da177e4c Linux-2.6.12-rc2 |
551 |
retry: |
9b0f8b040 [PATCH] Terminate... |
552 553 554 555 |
/* * Rambo mode: Shoot down a process and hope it solves whatever * issues we may have. */ |
c7ba5c9e8 Memory controller... |
556 |
p = select_bad_process(&points, NULL); |
1da177e4c Linux-2.6.12-rc2 |
557 |
|
9b0f8b040 [PATCH] Terminate... |
558 559 |
if (PTR_ERR(p) == -1UL) goto out; |
1da177e4c Linux-2.6.12-rc2 |
560 |
|
9b0f8b040 [PATCH] Terminate... |
561 562 563 |
/* Found nothing?!?! Either we hang forever, or we panic. */ if (!p) { read_unlock(&tasklist_lock); |
9b0f8b040 [PATCH] Terminate... |
564 565 566 |
panic("Out of memory and no killable processes... "); } |
1da177e4c Linux-2.6.12-rc2 |
567 |
|
fef1bdd68 oom: add sysctl t... |
568 |
if (oom_kill_process(p, gfp_mask, order, points, NULL, |
7213f5066 oom: suppress ext... |
569 |
"Out of memory")) |
9b0f8b040 [PATCH] Terminate... |
570 571 572 573 |
goto retry; break; } |
1da177e4c Linux-2.6.12-rc2 |
574 |
|
9b0f8b040 [PATCH] Terminate... |
575 |
out: |
140ffcec4 [PATCH] out_of_me... |
576 |
read_unlock(&tasklist_lock); |
1da177e4c Linux-2.6.12-rc2 |
577 578 579 |
/* * Give "p" a good chance of killing itself before we |
2f659f462 [PATCH] Optimise ... |
580 |
* retry to allocate memory unless "p" is current |
1da177e4c Linux-2.6.12-rc2 |
581 |
*/ |
2f659f462 [PATCH] Optimise ... |
582 |
if (!test_thread_flag(TIF_MEMDIE)) |
140ffcec4 [PATCH] out_of_me... |
583 |
schedule_timeout_uninterruptible(1); |
1da177e4c Linux-2.6.12-rc2 |
584 |
} |