4 * Copyright (C) 1998,2000 Rik van Riel
5 * Thanks go out to Claus Fischer for some serious inspiration and
6 * for goading me into coding this file...
7 * Copyright (C) 2010 Google, Inc.
8 * Rewritten by David Rientjes
10 * The routines in this file are used to kill a process when
11 * we're seriously out of memory. This gets called from __alloc_pages()
12 * in mm/page_alloc.c when we really run out of memory.
14 * Since we won't call these routines often (on a well-configured
15 * machine) this file will double as a 'coding guide' and a signpost
16 * for newbie kernel hackers. It features several pointers to major
17 * kernel subsystems and hints as to where to find out what things do.
20 #include <linux/oom.h>
22 #include <linux/err.h>
23 #include <linux/gfp.h>
24 #include <linux/sched.h>
25 #include <linux/swap.h>
26 #include <linux/timex.h>
27 #include <linux/jiffies.h>
28 #include <linux/cpuset.h>
29 #include <linux/module.h>
30 #include <linux/notifier.h>
31 #include <linux/memcontrol.h>
32 #include <linux/mempolicy.h>
33 #include <linux/security.h>
34 #include <linux/ptrace.h>
35 #include <linux/freezer.h>
37 int sysctl_panic_on_oom
;
38 int sysctl_oom_kill_allocating_task
;
39 int sysctl_oom_dump_tasks
= 1;
40 static DEFINE_SPINLOCK(zone_scan_lock
);
43 * test_set_oom_score_adj() - set current's oom_score_adj and return old value
44 * @new_val: new oom_score_adj value
46 * Sets the oom_score_adj value for current to @new_val with proper
47 * synchronization and returns the old value. Usually used to temporarily
48 * set a value, save the old value in the caller, and then reinstate it later.
50 int test_set_oom_score_adj(int new_val
)
52 struct sighand_struct
*sighand
= current
->sighand
;
55 spin_lock_irq(&sighand
->siglock
);
56 old_val
= current
->signal
->oom_score_adj
;
57 if (new_val
!= old_val
) {
58 if (new_val
== OOM_SCORE_ADJ_MIN
)
59 atomic_inc(¤t
->mm
->oom_disable_count
);
60 else if (old_val
== OOM_SCORE_ADJ_MIN
)
61 atomic_dec(¤t
->mm
->oom_disable_count
);
62 current
->signal
->oom_score_adj
= new_val
;
64 spin_unlock_irq(&sighand
->siglock
);
71 * has_intersects_mems_allowed() - check task eligiblity for kill
72 * @tsk: task struct of which task to consider
73 * @mask: nodemask passed to page allocator for mempolicy ooms
75 * Task eligibility is determined by whether or not a candidate task, @tsk,
76 * shares the same mempolicy nodes as current if it is bound by such a policy
77 * and whether or not it has the same set of allowed cpuset nodes.
79 static bool has_intersects_mems_allowed(struct task_struct
*tsk
,
80 const nodemask_t
*mask
)
82 struct task_struct
*start
= tsk
;
87 * If this is a mempolicy constrained oom, tsk's
88 * cpuset is irrelevant. Only return true if its
89 * mempolicy intersects current, otherwise it may be
92 if (mempolicy_nodemask_intersects(tsk
, mask
))
96 * This is not a mempolicy constrained oom, so only
97 * check the mems of tsk's cpuset.
99 if (cpuset_mems_allowed_intersects(current
, tsk
))
102 } while_each_thread(start
, tsk
);
107 static bool has_intersects_mems_allowed(struct task_struct
*tsk
,
108 const nodemask_t
*mask
)
112 #endif /* CONFIG_NUMA */
115 * The process p may have detached its own ->mm while exiting or through
116 * use_mm(), but one or more of its subthreads may still have a valid
117 * pointer. Return p, or any of its subthreads with a valid ->mm, with
120 struct task_struct
*find_lock_task_mm(struct task_struct
*p
)
122 struct task_struct
*t
= p
;
129 } while_each_thread(p
, t
);
134 /* return true if the task is not adequate as candidate victim task. */
135 static bool oom_unkillable_task(struct task_struct
*p
,
136 const struct mem_cgroup
*mem
, const nodemask_t
*nodemask
)
138 if (is_global_init(p
))
140 if (p
->flags
& PF_KTHREAD
)
143 /* When mem_cgroup_out_of_memory() and p is not member of the group */
144 if (mem
&& !task_in_mem_cgroup(p
, mem
))
147 /* p may not have freeable memory in nodemask */
148 if (!has_intersects_mems_allowed(p
, nodemask
))
155 * oom_badness - heuristic function to determine which candidate task to kill
156 * @p: task struct of which task we should calculate
157 * @totalpages: total present RAM allowed for page allocation
159 * The heuristic for determining which task to kill is made to be as simple and
160 * predictable as possible. The goal is to return the highest value for the
161 * task consuming the most memory to avoid subsequent oom failures.
163 unsigned int oom_badness(struct task_struct
*p
, struct mem_cgroup
*mem
,
164 const nodemask_t
*nodemask
, unsigned long totalpages
)
168 if (oom_unkillable_task(p
, mem
, nodemask
))
171 p
= find_lock_task_mm(p
);
176 * Shortcut check for a thread sharing p->mm that is OOM_SCORE_ADJ_MIN
177 * so the entire heuristic doesn't need to be executed for something
178 * that cannot be killed.
180 if (atomic_read(&p
->mm
->oom_disable_count
)) {
186 * The memory controller may have a limit of 0 bytes, so avoid a divide
187 * by zero, if necessary.
193 * The baseline for the badness score is the proportion of RAM that each
194 * task's rss, pagetable and swap space use.
196 points
= get_mm_rss(p
->mm
) + p
->mm
->nr_ptes
;
197 points
+= get_mm_counter(p
->mm
, MM_SWAPENTS
);
200 points
/= totalpages
;
204 * Root processes get 3% bonus, just like the __vm_enough_memory()
205 * implementation used by LSMs.
207 if (has_capability_noaudit(p
, CAP_SYS_ADMIN
))
211 * /proc/pid/oom_score_adj ranges from -1000 to +1000 such that it may
212 * either completely disable oom killing or always prefer a certain
215 points
+= p
->signal
->oom_score_adj
;
218 * Never return 0 for an eligible task that may be killed since it's
219 * possible that no single user task uses more than 0.1% of memory and
220 * no single admin tasks uses more than 3.0%.
224 return (points
< 1000) ? points
: 1000;
228 * Determine the type of allocation constraint.
231 static enum oom_constraint
constrained_alloc(struct zonelist
*zonelist
,
232 gfp_t gfp_mask
, nodemask_t
*nodemask
,
233 unsigned long *totalpages
)
237 enum zone_type high_zoneidx
= gfp_zone(gfp_mask
);
238 bool cpuset_limited
= false;
241 /* Default to all available memory */
242 *totalpages
= totalram_pages
+ total_swap_pages
;
245 return CONSTRAINT_NONE
;
247 * Reach here only when __GFP_NOFAIL is used. So, we should avoid
248 * to kill current.We have to random task kill in this case.
249 * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now.
251 if (gfp_mask
& __GFP_THISNODE
)
252 return CONSTRAINT_NONE
;
255 * This is not a __GFP_THISNODE allocation, so a truncated nodemask in
256 * the page allocator means a mempolicy is in effect. Cpuset policy
257 * is enforced in get_page_from_freelist().
259 if (nodemask
&& !nodes_subset(node_states
[N_HIGH_MEMORY
], *nodemask
)) {
260 *totalpages
= total_swap_pages
;
261 for_each_node_mask(nid
, *nodemask
)
262 *totalpages
+= node_spanned_pages(nid
);
263 return CONSTRAINT_MEMORY_POLICY
;
266 /* Check this allocation failure is caused by cpuset's wall function */
267 for_each_zone_zonelist_nodemask(zone
, z
, zonelist
,
268 high_zoneidx
, nodemask
)
269 if (!cpuset_zone_allowed_softwall(zone
, gfp_mask
))
270 cpuset_limited
= true;
272 if (cpuset_limited
) {
273 *totalpages
= total_swap_pages
;
274 for_each_node_mask(nid
, cpuset_current_mems_allowed
)
275 *totalpages
+= node_spanned_pages(nid
);
276 return CONSTRAINT_CPUSET
;
278 return CONSTRAINT_NONE
;
281 static enum oom_constraint
constrained_alloc(struct zonelist
*zonelist
,
282 gfp_t gfp_mask
, nodemask_t
*nodemask
,
283 unsigned long *totalpages
)
285 *totalpages
= totalram_pages
+ total_swap_pages
;
286 return CONSTRAINT_NONE
;
291 * Simple selection loop. We chose the process with the highest
292 * number of 'points'. We expect the caller will lock the tasklist.
294 * (not docbooked, we don't want this one cluttering up the manual)
296 static struct task_struct
*select_bad_process(unsigned int *ppoints
,
297 unsigned long totalpages
, struct mem_cgroup
*mem
,
298 const nodemask_t
*nodemask
)
300 struct task_struct
*g
, *p
;
301 struct task_struct
*chosen
= NULL
;
304 do_each_thread(g
, p
) {
309 if (oom_unkillable_task(p
, mem
, nodemask
))
313 * This task already has access to memory reserves and is
314 * being killed. Don't allow any other task access to the
317 * Note: this may have a chance of deadlock if it gets
318 * blocked waiting for another task which itself is waiting
319 * for memory. Is there a better alternative?
321 if (test_tsk_thread_flag(p
, TIF_MEMDIE
)) {
322 if (unlikely(frozen(p
)))
324 return ERR_PTR(-1UL);
329 if (p
->flags
& PF_EXITING
) {
331 * If p is the current task and is in the process of
332 * releasing memory, we allow the "kill" to set
333 * TIF_MEMDIE, which will allow it to gain access to
334 * memory reserves. Otherwise, it may stall forever.
336 * The loop isn't broken here, however, in case other
337 * threads are found to have already been oom killed.
344 * If this task is not being ptraced on exit,
345 * then wait for it to finish before killing
346 * some other task unnecessarily.
348 if (!(p
->group_leader
->ptrace
& PT_TRACE_EXIT
))
349 return ERR_PTR(-1UL);
353 points
= oom_badness(p
, mem
, nodemask
, totalpages
);
354 if (points
> *ppoints
) {
358 } while_each_thread(g
, p
);
364 * dump_tasks - dump current memory state of all system tasks
365 * @mem: current's memory controller, if constrained
366 * @nodemask: nodemask passed to page allocator for mempolicy ooms
368 * Dumps the current memory state of all eligible tasks. Tasks not in the same
369 * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes
371 * State information includes task's pid, uid, tgid, vm size, rss, cpu, oom_adj
372 * value, oom_score_adj value, and name.
374 * Call with tasklist_lock read-locked.
376 static void dump_tasks(const struct mem_cgroup
*mem
, const nodemask_t
*nodemask
)
378 struct task_struct
*p
;
379 struct task_struct
*task
;
381 pr_info("[ pid ] uid tgid total_vm rss cpu oom_adj oom_score_adj name\n");
382 for_each_process(p
) {
383 if (oom_unkillable_task(p
, mem
, nodemask
))
386 task
= find_lock_task_mm(p
);
389 * This is a kthread or all of p's threads have already
390 * detached their mm's. There's no need to report
391 * them; they can't be oom killed anyway.
396 pr_info("[%5d] %5d %5d %8lu %8lu %3u %3d %5d %s\n",
397 task
->pid
, task_uid(task
), task
->tgid
,
398 task
->mm
->total_vm
, get_mm_rss(task
->mm
),
399 task_cpu(task
), task
->signal
->oom_adj
,
400 task
->signal
->oom_score_adj
, task
->comm
);
405 static void dump_header(struct task_struct
*p
, gfp_t gfp_mask
, int order
,
406 struct mem_cgroup
*mem
, const nodemask_t
*nodemask
)
409 pr_warning("%s invoked oom-killer: gfp_mask=0x%x, order=%d, "
410 "oom_adj=%d, oom_score_adj=%d\n",
411 current
->comm
, gfp_mask
, order
, current
->signal
->oom_adj
,
412 current
->signal
->oom_score_adj
);
413 cpuset_print_task_mems_allowed(current
);
414 task_unlock(current
);
416 mem_cgroup_print_oom_info(mem
, p
);
417 show_mem(SHOW_MEM_FILTER_NODES
);
418 if (sysctl_oom_dump_tasks
)
419 dump_tasks(mem
, nodemask
);
422 #define K(x) ((x) << (PAGE_SHIFT-10))
423 static int oom_kill_task(struct task_struct
*p
, struct mem_cgroup
*mem
)
425 struct task_struct
*q
;
426 struct mm_struct
*mm
;
428 p
= find_lock_task_mm(p
);
432 /* mm cannot be safely dereferenced after task_unlock(p) */
435 pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB\n",
436 task_pid_nr(p
), p
->comm
, K(p
->mm
->total_vm
),
437 K(get_mm_counter(p
->mm
, MM_ANONPAGES
)),
438 K(get_mm_counter(p
->mm
, MM_FILEPAGES
)));
442 * Kill all processes sharing p->mm in other thread groups, if any.
443 * They don't get access to memory reserves or a higher scheduler
444 * priority, though, to avoid depletion of all memory or task
445 * starvation. This prevents mm->mmap_sem livelock when an oom killed
446 * task cannot exit because it requires the semaphore and its contended
447 * by another thread trying to allocate memory itself. That thread will
448 * now get access to memory reserves since it has a pending fatal
452 if (q
->mm
== mm
&& !same_thread_group(q
, p
)) {
453 task_lock(q
); /* Protect ->comm from prctl() */
454 pr_err("Kill process %d (%s) sharing same memory\n",
455 task_pid_nr(q
), q
->comm
);
457 force_sig(SIGKILL
, q
);
460 set_tsk_thread_flag(p
, TIF_MEMDIE
);
461 force_sig(SIGKILL
, p
);
467 static int oom_kill_process(struct task_struct
*p
, gfp_t gfp_mask
, int order
,
468 unsigned int points
, unsigned long totalpages
,
469 struct mem_cgroup
*mem
, nodemask_t
*nodemask
,
472 struct task_struct
*victim
= p
;
473 struct task_struct
*child
;
474 struct task_struct
*t
= p
;
475 unsigned int victim_points
= 0;
477 if (printk_ratelimit())
478 dump_header(p
, gfp_mask
, order
, mem
, nodemask
);
481 * If the task is already exiting, don't alarm the sysadmin or kill
482 * its children or threads, just set TIF_MEMDIE so it can die quickly
484 if (p
->flags
& PF_EXITING
) {
485 set_tsk_thread_flag(p
, TIF_MEMDIE
);
490 pr_err("%s: Kill process %d (%s) score %d or sacrifice child\n",
491 message
, task_pid_nr(p
), p
->comm
, points
);
495 * If any of p's children has a different mm and is eligible for kill,
496 * the one with the highest oom_badness() score is sacrificed for its
497 * parent. This attempts to lose the minimal amount of work done while
498 * still freeing memory.
501 list_for_each_entry(child
, &t
->children
, sibling
) {
502 unsigned int child_points
;
504 if (child
->mm
== p
->mm
)
507 * oom_badness() returns 0 if the thread is unkillable
509 child_points
= oom_badness(child
, mem
, nodemask
,
511 if (child_points
> victim_points
) {
513 victim_points
= child_points
;
516 } while_each_thread(p
, t
);
518 return oom_kill_task(victim
, mem
);
522 * Determines whether the kernel must panic because of the panic_on_oom sysctl.
524 static void check_panic_on_oom(enum oom_constraint constraint
, gfp_t gfp_mask
,
525 int order
, const nodemask_t
*nodemask
)
527 if (likely(!sysctl_panic_on_oom
))
529 if (sysctl_panic_on_oom
!= 2) {
531 * panic_on_oom == 1 only affects CONSTRAINT_NONE, the kernel
532 * does not panic for cpuset, mempolicy, or memcg allocation
535 if (constraint
!= CONSTRAINT_NONE
)
538 read_lock(&tasklist_lock
);
539 dump_header(NULL
, gfp_mask
, order
, NULL
, nodemask
);
540 read_unlock(&tasklist_lock
);
541 panic("Out of memory: %s panic_on_oom is enabled\n",
542 sysctl_panic_on_oom
== 2 ? "compulsory" : "system-wide");
545 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
546 void mem_cgroup_out_of_memory(struct mem_cgroup
*mem
, gfp_t gfp_mask
)
549 unsigned int points
= 0;
550 struct task_struct
*p
;
553 * If current has a pending SIGKILL, then automatically select it. The
554 * goal is to allow it to allocate so that it may quickly exit and free
557 if (fatal_signal_pending(current
)) {
558 set_thread_flag(TIF_MEMDIE
);
562 check_panic_on_oom(CONSTRAINT_MEMCG
, gfp_mask
, 0, NULL
);
563 limit
= mem_cgroup_get_limit(mem
) >> PAGE_SHIFT
;
564 read_lock(&tasklist_lock
);
566 p
= select_bad_process(&points
, limit
, mem
, NULL
);
567 if (!p
|| PTR_ERR(p
) == -1UL)
570 if (oom_kill_process(p
, gfp_mask
, 0, points
, limit
, mem
, NULL
,
571 "Memory cgroup out of memory"))
574 read_unlock(&tasklist_lock
);
578 static BLOCKING_NOTIFIER_HEAD(oom_notify_list
);
580 int register_oom_notifier(struct notifier_block
*nb
)
582 return blocking_notifier_chain_register(&oom_notify_list
, nb
);
584 EXPORT_SYMBOL_GPL(register_oom_notifier
);
586 int unregister_oom_notifier(struct notifier_block
*nb
)
588 return blocking_notifier_chain_unregister(&oom_notify_list
, nb
);
590 EXPORT_SYMBOL_GPL(unregister_oom_notifier
);
593 * Try to acquire the OOM killer lock for the zones in zonelist. Returns zero
594 * if a parallel OOM killing is already taking place that includes a zone in
595 * the zonelist. Otherwise, locks all zones in the zonelist and returns 1.
597 int try_set_zonelist_oom(struct zonelist
*zonelist
, gfp_t gfp_mask
)
603 spin_lock(&zone_scan_lock
);
604 for_each_zone_zonelist(zone
, z
, zonelist
, gfp_zone(gfp_mask
)) {
605 if (zone_is_oom_locked(zone
)) {
611 for_each_zone_zonelist(zone
, z
, zonelist
, gfp_zone(gfp_mask
)) {
613 * Lock each zone in the zonelist under zone_scan_lock so a
614 * parallel invocation of try_set_zonelist_oom() doesn't succeed
617 zone_set_flag(zone
, ZONE_OOM_LOCKED
);
621 spin_unlock(&zone_scan_lock
);
626 * Clears the ZONE_OOM_LOCKED flag for all zones in the zonelist so that failed
627 * allocation attempts with zonelists containing them may now recall the OOM
628 * killer, if necessary.
630 void clear_zonelist_oom(struct zonelist
*zonelist
, gfp_t gfp_mask
)
635 spin_lock(&zone_scan_lock
);
636 for_each_zone_zonelist(zone
, z
, zonelist
, gfp_zone(gfp_mask
)) {
637 zone_clear_flag(zone
, ZONE_OOM_LOCKED
);
639 spin_unlock(&zone_scan_lock
);
643 * Try to acquire the oom killer lock for all system zones. Returns zero if a
644 * parallel oom killing is taking place, otherwise locks all zones and returns
647 static int try_set_system_oom(void)
652 spin_lock(&zone_scan_lock
);
653 for_each_populated_zone(zone
)
654 if (zone_is_oom_locked(zone
)) {
658 for_each_populated_zone(zone
)
659 zone_set_flag(zone
, ZONE_OOM_LOCKED
);
661 spin_unlock(&zone_scan_lock
);
666 * Clears ZONE_OOM_LOCKED for all system zones so that failed allocation
667 * attempts or page faults may now recall the oom killer, if necessary.
669 static void clear_system_oom(void)
673 spin_lock(&zone_scan_lock
);
674 for_each_populated_zone(zone
)
675 zone_clear_flag(zone
, ZONE_OOM_LOCKED
);
676 spin_unlock(&zone_scan_lock
);
680 * out_of_memory - kill the "best" process when we run out of memory
681 * @zonelist: zonelist pointer
682 * @gfp_mask: memory allocation flags
683 * @order: amount of memory being requested as a power of 2
684 * @nodemask: nodemask passed to page allocator
686 * If we run out of memory, we have the choice between either
687 * killing a random task (bad), letting the system crash (worse)
688 * OR try to be smart about which process to kill. Note that we
689 * don't have to be perfect here, we just have to be good.
691 void out_of_memory(struct zonelist
*zonelist
, gfp_t gfp_mask
,
692 int order
, nodemask_t
*nodemask
)
694 const nodemask_t
*mpol_mask
;
695 struct task_struct
*p
;
696 unsigned long totalpages
;
697 unsigned long freed
= 0;
699 enum oom_constraint constraint
= CONSTRAINT_NONE
;
702 blocking_notifier_call_chain(&oom_notify_list
, 0, &freed
);
704 /* Got some memory back in the last second. */
708 * If current has a pending SIGKILL, then automatically select it. The
709 * goal is to allow it to allocate so that it may quickly exit and free
712 if (fatal_signal_pending(current
)) {
713 set_thread_flag(TIF_MEMDIE
);
718 * Check if there were limitations on the allocation (only relevant for
719 * NUMA) that may require different handling.
721 constraint
= constrained_alloc(zonelist
, gfp_mask
, nodemask
,
723 mpol_mask
= (constraint
== CONSTRAINT_MEMORY_POLICY
) ? nodemask
: NULL
;
724 check_panic_on_oom(constraint
, gfp_mask
, order
, mpol_mask
);
726 read_lock(&tasklist_lock
);
727 if (sysctl_oom_kill_allocating_task
&&
728 !oom_unkillable_task(current
, NULL
, nodemask
) &&
729 current
->mm
&& !atomic_read(¤t
->mm
->oom_disable_count
)) {
731 * oom_kill_process() needs tasklist_lock held. If it returns
732 * non-zero, current could not be killed so we must fallback to
735 if (!oom_kill_process(current
, gfp_mask
, order
, 0, totalpages
,
737 "Out of memory (oom_kill_allocating_task)"))
742 p
= select_bad_process(&points
, totalpages
, NULL
, mpol_mask
);
743 if (PTR_ERR(p
) == -1UL)
746 /* Found nothing?!?! Either we hang forever, or we panic. */
748 dump_header(NULL
, gfp_mask
, order
, NULL
, mpol_mask
);
749 read_unlock(&tasklist_lock
);
750 panic("Out of memory and no killable processes...\n");
753 if (oom_kill_process(p
, gfp_mask
, order
, points
, totalpages
, NULL
,
754 nodemask
, "Out of memory"))
758 read_unlock(&tasklist_lock
);
761 * Give "p" a good chance of killing itself before we
762 * retry to allocate memory unless "p" is current
764 if (killed
&& !test_thread_flag(TIF_MEMDIE
))
765 schedule_timeout_uninterruptible(1);
769 * The pagefault handler calls here because it is out of memory, so kill a
770 * memory-hogging task. If a populated zone has ZONE_OOM_LOCKED set, a parallel
771 * oom killing is already in progress so do nothing. If a task is found with
772 * TIF_MEMDIE set, it has been killed so do nothing and allow it to exit.
774 void pagefault_out_of_memory(void)
776 if (try_set_system_oom()) {
777 out_of_memory(NULL
, 0, 0, NULL
);
780 if (!test_thread_flag(TIF_MEMDIE
))
781 schedule_timeout_uninterruptible(1);