blob: c9f3569a76c796bc051349be9e5f5c868accdd8e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/mm/oom_kill.c
3 *
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...
David Rientjesa63d83f2010-08-09 17:19:46 -07007 * Copyright (C) 2010 Google, Inc.
8 * Rewritten by David Rientjes
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * The routines in this file are used to kill a process when
Paul Jacksona49335c2005-09-06 15:18:09 -070011 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
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.
18 */
19
Alexey Dobriyan8ac773b2006-10-19 23:28:32 -070020#include <linux/oom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/mm.h>
Alexey Dobriyan4e950f62007-07-30 02:36:13 +040022#include <linux/err.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/sched.h>
Ingo Molnar6e84f312017-02-08 18:51:29 +010025#include <linux/sched/mm.h>
Ingo Molnarf7ccbae2017-02-08 18:51:30 +010026#include <linux/sched/coredump.h>
Ingo Molnar29930022017-02-08 18:51:36 +010027#include <linux/sched/task.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/swap.h>
29#include <linux/timex.h>
30#include <linux/jiffies.h>
Paul Jacksonef08e3b2005-09-06 15:18:13 -070031#include <linux/cpuset.h>
Paul Gortmakerb95f1b312011-10-16 02:01:52 -040032#include <linux/export.h>
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -070033#include <linux/notifier.h>
Pavel Emelianovc7ba5c92008-02-07 00:13:58 -080034#include <linux/memcontrol.h>
David Rientjes6f48d0eb2010-08-09 17:18:52 -070035#include <linux/mempolicy.h>
David Howells5cd9c582008-08-14 11:37:28 +010036#include <linux/security.h>
David Rientjesedd45542011-03-22 16:30:12 -070037#include <linux/ptrace.h>
David Rientjesf660daa2011-10-31 17:07:07 -070038#include <linux/freezer.h>
KAMEZAWA Hiroyuki43d2b112012-01-10 15:08:09 -080039#include <linux/ftrace.h>
David Rientjesdc3f21e2012-03-21 16:33:47 -070040#include <linux/ratelimit.h>
Michal Hockoaac45362016-03-25 14:20:24 -070041#include <linux/kthread.h>
42#include <linux/init.h>
43
44#include <asm/tlb.h>
45#include "internal.h"
KAMEZAWA Hiroyuki43d2b112012-01-10 15:08:09 -080046
47#define CREATE_TRACE_POINTS
48#include <trace/events/oom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
KAMEZAWA Hiroyukifadd8fb2006-06-23 02:03:13 -070050int sysctl_panic_on_oom;
David Rientjesfe071d72007-10-16 23:25:56 -070051int sysctl_oom_kill_allocating_task;
David Rientjesad915c42010-08-09 17:18:53 -070052int sysctl_oom_dump_tasks = 1;
Johannes Weinerdc564012015-06-24 16:57:19 -070053
54DEFINE_MUTEX(oom_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
David Rientjes6f48d0eb2010-08-09 17:18:52 -070056#ifdef CONFIG_NUMA
57/**
58 * has_intersects_mems_allowed() - check task eligiblity for kill
Oleg Nesterovad962442014-01-21 15:50:00 -080059 * @start: task struct of which task to consider
David Rientjes6f48d0eb2010-08-09 17:18:52 -070060 * @mask: nodemask passed to page allocator for mempolicy ooms
61 *
62 * Task eligibility is determined by whether or not a candidate task, @tsk,
63 * shares the same mempolicy nodes as current if it is bound by such a policy
64 * and whether or not it has the same set of allowed cpuset nodes.
KOSAKI Motohiro495789a2009-09-21 17:03:14 -070065 */
Oleg Nesterovad962442014-01-21 15:50:00 -080066static bool has_intersects_mems_allowed(struct task_struct *start,
David Rientjes6f48d0eb2010-08-09 17:18:52 -070067 const nodemask_t *mask)
KOSAKI Motohiro495789a2009-09-21 17:03:14 -070068{
Oleg Nesterovad962442014-01-21 15:50:00 -080069 struct task_struct *tsk;
70 bool ret = false;
KOSAKI Motohiro495789a2009-09-21 17:03:14 -070071
Oleg Nesterovad962442014-01-21 15:50:00 -080072 rcu_read_lock();
Oleg Nesterov1da4db02014-01-21 15:49:58 -080073 for_each_thread(start, tsk) {
David Rientjes6f48d0eb2010-08-09 17:18:52 -070074 if (mask) {
75 /*
76 * If this is a mempolicy constrained oom, tsk's
77 * cpuset is irrelevant. Only return true if its
78 * mempolicy intersects current, otherwise it may be
79 * needlessly killed.
80 */
Oleg Nesterovad962442014-01-21 15:50:00 -080081 ret = mempolicy_nodemask_intersects(tsk, mask);
David Rientjes6f48d0eb2010-08-09 17:18:52 -070082 } else {
83 /*
84 * This is not a mempolicy constrained oom, so only
85 * check the mems of tsk's cpuset.
86 */
Oleg Nesterovad962442014-01-21 15:50:00 -080087 ret = cpuset_mems_allowed_intersects(current, tsk);
David Rientjes6f48d0eb2010-08-09 17:18:52 -070088 }
Oleg Nesterovad962442014-01-21 15:50:00 -080089 if (ret)
90 break;
Oleg Nesterov1da4db02014-01-21 15:49:58 -080091 }
Oleg Nesterovad962442014-01-21 15:50:00 -080092 rcu_read_unlock();
KOSAKI Motohirodf1090a2010-08-09 17:19:39 -070093
Oleg Nesterovad962442014-01-21 15:50:00 -080094 return ret;
KOSAKI Motohiro495789a2009-09-21 17:03:14 -070095}
David Rientjes6f48d0eb2010-08-09 17:18:52 -070096#else
97static bool has_intersects_mems_allowed(struct task_struct *tsk,
98 const nodemask_t *mask)
99{
100 return true;
101}
102#endif /* CONFIG_NUMA */
KOSAKI Motohiro495789a2009-09-21 17:03:14 -0700103
David Rientjes6f48d0eb2010-08-09 17:18:52 -0700104/*
105 * The process p may have detached its own ->mm while exiting or through
106 * use_mm(), but one or more of its subthreads may still have a valid
107 * pointer. Return p, or any of its subthreads with a valid ->mm, with
108 * task_lock() held.
109 */
KAMEZAWA Hiroyuki158e0a22010-08-10 18:03:00 -0700110struct task_struct *find_lock_task_mm(struct task_struct *p)
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700111{
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800112 struct task_struct *t;
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700113
Oleg Nesterov4d4048b2014-01-21 15:50:01 -0800114 rcu_read_lock();
115
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800116 for_each_thread(p, t) {
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700117 task_lock(t);
118 if (likely(t->mm))
Oleg Nesterov4d4048b2014-01-21 15:50:01 -0800119 goto found;
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700120 task_unlock(t);
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800121 }
Oleg Nesterov4d4048b2014-01-21 15:50:01 -0800122 t = NULL;
123found:
124 rcu_read_unlock();
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700125
Oleg Nesterov4d4048b2014-01-21 15:50:01 -0800126 return t;
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700127}
128
Yaowei Baidb2a0dd2015-11-06 16:28:06 -0800129/*
130 * order == -1 means the oom kill is required by sysrq, otherwise only
131 * for display purposes.
132 */
133static inline bool is_sysrq_oom(struct oom_control *oc)
134{
135 return oc->order == -1;
136}
137
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700138static inline bool is_memcg_oom(struct oom_control *oc)
139{
140 return oc->memcg != NULL;
141}
142
KOSAKI Motohiroab290ad2010-08-09 17:19:35 -0700143/* return true if the task is not adequate as candidate victim task. */
David Rientjese85bfd32010-09-22 13:05:10 -0700144static bool oom_unkillable_task(struct task_struct *p,
Johannes Weiner2314b422014-12-10 15:44:33 -0800145 struct mem_cgroup *memcg, const nodemask_t *nodemask)
KOSAKI Motohiroab290ad2010-08-09 17:19:35 -0700146{
147 if (is_global_init(p))
148 return true;
149 if (p->flags & PF_KTHREAD)
150 return true;
151
152 /* When mem_cgroup_out_of_memory() and p is not member of the group */
Johannes Weiner72835c82012-01-12 17:18:32 -0800153 if (memcg && !task_in_mem_cgroup(p, memcg))
KOSAKI Motohiroab290ad2010-08-09 17:19:35 -0700154 return true;
155
156 /* p may not have freeable memory in nodemask */
157 if (!has_intersects_mems_allowed(p, nodemask))
158 return true;
159
160 return false;
161}
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163/**
David Rientjesa63d83f2010-08-09 17:19:46 -0700164 * oom_badness - heuristic function to determine which candidate task to kill
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 * @p: task struct of which task we should calculate
David Rientjesa63d83f2010-08-09 17:19:46 -0700166 * @totalpages: total present RAM allowed for page allocation
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 *
David Rientjesa63d83f2010-08-09 17:19:46 -0700168 * The heuristic for determining which task to kill is made to be as simple and
169 * predictable as possible. The goal is to return the highest value for the
170 * task consuming the most memory to avoid subsequent oom failures.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 */
David Rientjesa7f638f2012-05-29 15:06:47 -0700172unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,
173 const nodemask_t *nodemask, unsigned long totalpages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
David Rientjes1e11ad82012-06-08 13:21:26 -0700175 long points;
David Rientjes61eafb02012-06-20 12:52:58 -0700176 long adj;
KOSAKI Motohiro28b83c52009-09-21 17:03:13 -0700177
Johannes Weiner72835c82012-01-12 17:18:32 -0800178 if (oom_unkillable_task(p, memcg, nodemask))
KOSAKI Motohiro26ebc982010-08-09 17:19:37 -0700179 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700181 p = find_lock_task_mm(p);
182 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 return 0;
184
Michal Hockobb8a4b72016-05-20 16:57:18 -0700185 /*
186 * Do not even consider tasks which are explicitly marked oom
Michal Hockob18dc5f2016-07-28 15:44:46 -0700187 * unkillable or have been already oom reaped or the are in
188 * the middle of vfork
Michal Hockobb8a4b72016-05-20 16:57:18 -0700189 */
David Rientjesa9c58b902012-12-11 16:02:54 -0800190 adj = (long)p->signal->oom_score_adj;
Michal Hockobb8a4b72016-05-20 16:57:18 -0700191 if (adj == OOM_SCORE_ADJ_MIN ||
Michal Hocko862e3072016-10-07 16:58:57 -0700192 test_bit(MMF_OOM_SKIP, &p->mm->flags) ||
Michal Hockob18dc5f2016-07-28 15:44:46 -0700193 in_vfork(p)) {
Michal Hocko5aecc852011-11-15 14:36:07 -0800194 task_unlock(p);
195 return 0;
196 }
197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 /*
David Rientjesa63d83f2010-08-09 17:19:46 -0700199 * The baseline for the badness score is the proportion of RAM that each
KOSAKI Motohirof755a042011-04-27 15:26:50 -0700200 * task's rss, pagetable and swap space use.
David Rientjesa63d83f2010-08-09 17:19:46 -0700201 */
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800202 points = get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) +
203 atomic_long_read(&p->mm->nr_ptes) + mm_nr_pmds(p->mm);
Andrew Morton97c2c9b82006-04-18 22:20:38 -0700204 task_unlock(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206 /*
David Rientjesa63d83f2010-08-09 17:19:46 -0700207 * Root processes get 3% bonus, just like the __vm_enough_memory()
208 * implementation used by LSMs.
Hugh Dickins7ba34852007-01-05 16:37:03 -0800209 */
David Rientjesa63d83f2010-08-09 17:19:46 -0700210 if (has_capability_noaudit(p, CAP_SYS_ADMIN))
David Rientjes778c14a2014-01-30 15:46:11 -0800211 points -= (points * 3) / 100;
Hugh Dickins7ba34852007-01-05 16:37:03 -0800212
David Rientjes61eafb02012-06-20 12:52:58 -0700213 /* Normalize to oom_score_adj units */
214 adj *= totalpages / 1000;
215 points += adj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
David Rientjesf19e8aa2010-09-22 13:04:52 -0700217 /*
David Rientjesa7f638f2012-05-29 15:06:47 -0700218 * Never return 0 for an eligible task regardless of the root bonus and
219 * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here).
David Rientjesf19e8aa2010-09-22 13:04:52 -0700220 */
David Rientjes1e11ad82012-06-08 13:21:26 -0700221 return points > 0 ? points : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222}
223
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700224enum oom_constraint {
225 CONSTRAINT_NONE,
226 CONSTRAINT_CPUSET,
227 CONSTRAINT_MEMORY_POLICY,
228 CONSTRAINT_MEMCG,
229};
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231/*
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800232 * Determine the type of allocation constraint.
233 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700234static enum oom_constraint constrained_alloc(struct oom_control *oc)
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800235{
Mel Gorman54a6eb52008-04-28 02:12:16 -0700236 struct zone *zone;
Mel Gormandd1a2392008-04-28 02:12:17 -0700237 struct zoneref *z;
David Rientjes6e0fc462015-09-08 15:00:36 -0700238 enum zone_type high_zoneidx = gfp_zone(oc->gfp_mask);
David Rientjesa63d83f2010-08-09 17:19:46 -0700239 bool cpuset_limited = false;
240 int nid;
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800241
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700242 if (is_memcg_oom(oc)) {
243 oc->totalpages = mem_cgroup_get_limit(oc->memcg) ?: 1;
244 return CONSTRAINT_MEMCG;
245 }
246
David Rientjesa63d83f2010-08-09 17:19:46 -0700247 /* Default to all available memory */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700248 oc->totalpages = totalram_pages + total_swap_pages;
249
250 if (!IS_ENABLED(CONFIG_NUMA))
251 return CONSTRAINT_NONE;
David Rientjesa63d83f2010-08-09 17:19:46 -0700252
David Rientjes6e0fc462015-09-08 15:00:36 -0700253 if (!oc->zonelist)
David Rientjesa63d83f2010-08-09 17:19:46 -0700254 return CONSTRAINT_NONE;
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800255 /*
256 * Reach here only when __GFP_NOFAIL is used. So, we should avoid
257 * to kill current.We have to random task kill in this case.
258 * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now.
259 */
David Rientjes6e0fc462015-09-08 15:00:36 -0700260 if (oc->gfp_mask & __GFP_THISNODE)
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800261 return CONSTRAINT_NONE;
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800262
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800263 /*
David Rientjesa63d83f2010-08-09 17:19:46 -0700264 * This is not a __GFP_THISNODE allocation, so a truncated nodemask in
265 * the page allocator means a mempolicy is in effect. Cpuset policy
266 * is enforced in get_page_from_freelist().
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800267 */
David Rientjes6e0fc462015-09-08 15:00:36 -0700268 if (oc->nodemask &&
269 !nodes_subset(node_states[N_MEMORY], *oc->nodemask)) {
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700270 oc->totalpages = total_swap_pages;
David Rientjes6e0fc462015-09-08 15:00:36 -0700271 for_each_node_mask(nid, *oc->nodemask)
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700272 oc->totalpages += node_spanned_pages(nid);
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800273 return CONSTRAINT_MEMORY_POLICY;
David Rientjesa63d83f2010-08-09 17:19:46 -0700274 }
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800275
276 /* Check this allocation failure is caused by cpuset's wall function */
David Rientjes6e0fc462015-09-08 15:00:36 -0700277 for_each_zone_zonelist_nodemask(zone, z, oc->zonelist,
278 high_zoneidx, oc->nodemask)
279 if (!cpuset_zone_allowed(zone, oc->gfp_mask))
David Rientjesa63d83f2010-08-09 17:19:46 -0700280 cpuset_limited = true;
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800281
David Rientjesa63d83f2010-08-09 17:19:46 -0700282 if (cpuset_limited) {
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700283 oc->totalpages = total_swap_pages;
David Rientjesa63d83f2010-08-09 17:19:46 -0700284 for_each_node_mask(nid, cpuset_current_mems_allowed)
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700285 oc->totalpages += node_spanned_pages(nid);
David Rientjesa63d83f2010-08-09 17:19:46 -0700286 return CONSTRAINT_CPUSET;
287 }
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800288 return CONSTRAINT_NONE;
289}
290
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700291static int oom_evaluate_task(struct task_struct *task, void *arg)
David Rientjes462607e2012-07-31 16:43:40 -0700292{
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700293 struct oom_control *oc = arg;
294 unsigned long points;
295
David Rientjes6e0fc462015-09-08 15:00:36 -0700296 if (oom_unkillable_task(task, NULL, oc->nodemask))
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700297 goto next;
David Rientjes462607e2012-07-31 16:43:40 -0700298
299 /*
300 * This task already has access to memory reserves and is being killed.
Michal Hockoa3739662016-07-28 15:45:01 -0700301 * Don't allow any other task to have access to the reserves unless
Michal Hocko862e3072016-10-07 16:58:57 -0700302 * the task has MMF_OOM_SKIP because chances that it would release
Michal Hockoa3739662016-07-28 15:45:01 -0700303 * any memory is quite low.
David Rientjes462607e2012-07-31 16:43:40 -0700304 */
Michal Hocko862e3072016-10-07 16:58:57 -0700305 if (!is_sysrq_oom(oc) && tsk_is_oom_victim(task)) {
306 if (test_bit(MMF_OOM_SKIP, &task->signal->oom_mm->flags))
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700307 goto next;
308 goto abort;
Michal Hockoa3739662016-07-28 15:45:01 -0700309 }
David Rientjes462607e2012-07-31 16:43:40 -0700310
David Rientjese1e12d22012-12-11 16:02:56 -0800311 /*
312 * If task is allocating a lot of memory and has been marked to be
313 * killed first if it triggers an oom, then select it.
314 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700315 if (oom_task_origin(task)) {
316 points = ULONG_MAX;
317 goto select;
318 }
David Rientjese1e12d22012-12-11 16:02:56 -0800319
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700320 points = oom_badness(task, NULL, oc->nodemask, oc->totalpages);
321 if (!points || points < oc->chosen_points)
322 goto next;
323
324 /* Prefer thread group leaders for display purposes */
325 if (points == oc->chosen_points && thread_group_leader(oc->chosen))
326 goto next;
327select:
328 if (oc->chosen)
329 put_task_struct(oc->chosen);
330 get_task_struct(task);
331 oc->chosen = task;
332 oc->chosen_points = points;
333next:
334 return 0;
335abort:
336 if (oc->chosen)
337 put_task_struct(oc->chosen);
338 oc->chosen = (void *)-1UL;
339 return 1;
David Rientjes462607e2012-07-31 16:43:40 -0700340}
341
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800342/*
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700343 * Simple selection loop. We choose the process with the highest number of
344 * 'points'. In case scan was aborted, oc->chosen is set to -1.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700346static void select_bad_process(struct oom_control *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700348 if (is_memcg_oom(oc))
349 mem_cgroup_scan_tasks(oc->memcg, oom_evaluate_task, oc);
350 else {
351 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700353 rcu_read_lock();
354 for_each_process(p)
355 if (oom_evaluate_task(p, oc))
356 break;
357 rcu_read_unlock();
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800358 }
Oleg Nesterov972c4ea2006-09-29 02:01:12 -0700359
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700360 oc->chosen_points = oc->chosen_points * 1000 / oc->totalpages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
363/**
Randy Dunlap1b578df2008-03-19 17:00:42 -0700364 * dump_tasks - dump current memory state of all system tasks
Wanpeng Lidad75572012-06-20 12:53:01 -0700365 * @memcg: current's memory controller, if constrained
David Rientjese85bfd32010-09-22 13:05:10 -0700366 * @nodemask: nodemask passed to page allocator for mempolicy ooms
Randy Dunlap1b578df2008-03-19 17:00:42 -0700367 *
David Rientjese85bfd32010-09-22 13:05:10 -0700368 * 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
370 * are not shown.
David Rientjesde34d962012-07-31 16:42:56 -0700371 * State information includes task's pid, uid, tgid, vm size, rss, nr_ptes,
372 * swapents, oom_score_adj value, and name.
David Rientjesfef1bdd2008-02-07 00:14:07 -0800373 */
Johannes Weiner2314b422014-12-10 15:44:33 -0800374static void dump_tasks(struct mem_cgroup *memcg, const nodemask_t *nodemask)
David Rientjesfef1bdd2008-02-07 00:14:07 -0800375{
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700376 struct task_struct *p;
377 struct task_struct *task;
David Rientjesfef1bdd2008-02-07 00:14:07 -0800378
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800379 pr_info("[ pid ] uid tgid total_vm rss nr_ptes nr_pmds swapents oom_score_adj name\n");
David Rientjes6b0c81b2012-07-31 16:43:45 -0700380 rcu_read_lock();
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700381 for_each_process(p) {
Johannes Weiner72835c82012-01-12 17:18:32 -0800382 if (oom_unkillable_task(p, memcg, nodemask))
David Rientjesfef1bdd2008-02-07 00:14:07 -0800383 continue;
384
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700385 task = find_lock_task_mm(p);
386 if (!task) {
David Rientjes6d2661e2009-05-28 14:34:19 -0700387 /*
David Rientjes74ab7f12010-08-09 17:18:46 -0700388 * This is a kthread or all of p's threads have already
389 * detached their mm's. There's no need to report
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700390 * them; they can't be oom killed anyway.
David Rientjes6d2661e2009-05-28 14:34:19 -0700391 */
David Rientjes6d2661e2009-05-28 14:34:19 -0700392 continue;
393 }
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700394
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800395 pr_info("[%5d] %5d %5d %8lu %8lu %7ld %7ld %8lu %5hd %s\n",
Eric W. Biederman078de5f2012-02-08 07:00:08 -0800396 task->pid, from_kuid(&init_user_ns, task_uid(task)),
397 task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
Kirill A. Shutemove1f56c82013-11-14 14:30:48 -0800398 atomic_long_read(&task->mm->nr_ptes),
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800399 mm_nr_pmds(task->mm),
David Rientjesde34d962012-07-31 16:42:56 -0700400 get_mm_counter(task->mm, MM_SWAPENTS),
David Rientjesa63d83f2010-08-09 17:19:46 -0700401 task->signal->oom_score_adj, task->comm);
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700402 task_unlock(task);
403 }
David Rientjes6b0c81b2012-07-31 16:43:45 -0700404 rcu_read_unlock();
David Rientjesfef1bdd2008-02-07 00:14:07 -0800405}
406
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700407static void dump_header(struct oom_control *oc, struct task_struct *p)
David Rientjes1b604d72009-12-14 17:57:47 -0800408{
David Rientjes299c5172017-02-24 14:55:42 -0800409 pr_warn("%s invoked oom-killer: gfp_mask=%#x(%pGg), nodemask=",
410 current->comm, oc->gfp_mask, &oc->gfp_mask);
411 if (oc->nodemask)
412 pr_cont("%*pbl", nodemask_pr_args(oc->nodemask));
413 else
414 pr_cont("(null)");
415 pr_cont(", order=%d, oom_score_adj=%hd\n",
416 oc->order, current->signal->oom_score_adj);
Michal Hocko92549902016-10-07 16:59:33 -0700417 if (!IS_ENABLED(CONFIG_COMPACTION) && oc->order)
418 pr_warn("COMPACTION is disabled!!!\n");
Vlastimil Babkaa0795cd2016-03-15 14:56:05 -0700419
David Rientjesda39da32015-11-05 18:48:05 -0800420 cpuset_print_current_mems_allowed();
David Rientjes1b604d72009-12-14 17:57:47 -0800421 dump_stack();
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700422 if (oc->memcg)
423 mem_cgroup_print_oom_info(oc->memcg, p);
Sha Zhengju58cf1882013-02-22 16:32:05 -0800424 else
David Rientjes299c5172017-02-24 14:55:42 -0800425 show_mem(SHOW_MEM_FILTER_NODES, oc->nodemask);
David Rientjes1b604d72009-12-14 17:57:47 -0800426 if (sysctl_oom_dump_tasks)
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700427 dump_tasks(oc->memcg, oc->nodemask);
David Rientjes1b604d72009-12-14 17:57:47 -0800428}
429
Michal Hocko5695be12014-10-20 18:12:32 +0200430/*
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800431 * Number of OOM victims in flight
Michal Hocko5695be12014-10-20 18:12:32 +0200432 */
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800433static atomic_t oom_victims = ATOMIC_INIT(0);
434static DECLARE_WAIT_QUEUE_HEAD(oom_victims_wait);
Michal Hocko5695be12014-10-20 18:12:32 +0200435
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700436static bool oom_killer_disabled __read_mostly;
Michal Hocko5695be12014-10-20 18:12:32 +0200437
Michal Hockobc448e82016-03-25 14:20:30 -0700438#define K(x) ((x) << (PAGE_SHIFT-10))
439
Michal Hocko3ef22df2016-05-19 17:13:12 -0700440/*
441 * task->mm can be NULL if the task is the exited group leader. So to
442 * determine whether the task is using a particular mm, we examine all the
443 * task's threads: if one of those is using this mm then this task was also
444 * using it.
445 */
Michal Hocko44a70ade2016-07-28 15:44:43 -0700446bool process_shares_mm(struct task_struct *p, struct mm_struct *mm)
Michal Hocko3ef22df2016-05-19 17:13:12 -0700447{
448 struct task_struct *t;
449
450 for_each_thread(p, t) {
451 struct mm_struct *t_mm = READ_ONCE(t->mm);
452 if (t_mm)
453 return t_mm == mm;
454 }
455 return false;
456}
457
458
Michal Hockoaac45362016-03-25 14:20:24 -0700459#ifdef CONFIG_MMU
460/*
461 * OOM Reaper kernel thread which tries to reap the memory used by the OOM
462 * victim (if that is possible) to help the OOM killer to move on.
463 */
464static struct task_struct *oom_reaper_th;
Michal Hockoaac45362016-03-25 14:20:24 -0700465static DECLARE_WAIT_QUEUE_HEAD(oom_reaper_wait);
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700466static struct task_struct *oom_reaper_list;
Michal Hocko03049262016-03-25 14:20:33 -0700467static DEFINE_SPINLOCK(oom_reaper_lock);
468
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700469static bool __oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)
Michal Hockoaac45362016-03-25 14:20:24 -0700470{
471 struct mmu_gather tlb;
472 struct vm_area_struct *vma;
Michal Hockoaac45362016-03-25 14:20:24 -0700473 bool ret = true;
474
Michal Hocko36324a92016-03-25 14:20:27 -0700475 /*
Michal Hockoe2fe1452016-05-27 14:27:35 -0700476 * We have to make sure to not race with the victim exit path
477 * and cause premature new oom victim selection:
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700478 * __oom_reap_task_mm exit_mm
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700479 * mmget_not_zero
Michal Hockoe2fe1452016-05-27 14:27:35 -0700480 * mmput
481 * atomic_dec_and_test
482 * exit_oom_victim
483 * [...]
484 * out_of_memory
485 * select_bad_process
486 * # no TIF_MEMDIE task selects new victim
487 * unmap_page_range # frees some memory
488 */
489 mutex_lock(&oom_lock);
490
Michal Hockoaac45362016-03-25 14:20:24 -0700491 if (!down_read_trylock(&mm->mmap_sem)) {
492 ret = false;
Roman Gushchin422580c2017-07-10 15:49:05 -0700493 trace_skip_task_reaping(tsk->pid);
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700494 goto unlock_oom;
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700495 }
496
497 /*
498 * increase mm_users only after we know we will reap something so
499 * that the mmput_async is called only when we have reaped something
500 * and delayed __mmput doesn't matter that much
501 */
502 if (!mmget_not_zero(mm)) {
503 up_read(&mm->mmap_sem);
Roman Gushchin422580c2017-07-10 15:49:05 -0700504 trace_skip_task_reaping(tsk->pid);
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700505 goto unlock_oom;
Michal Hockoaac45362016-03-25 14:20:24 -0700506 }
507
Roman Gushchin422580c2017-07-10 15:49:05 -0700508 trace_start_task_reaping(tsk->pid);
509
Michal Hocko3f70dc32016-10-07 16:59:06 -0700510 /*
511 * Tell all users of get_user/copy_from_user etc... that the content
512 * is no longer stable. No barriers really needed because unmapping
513 * should imply barriers already and the reader would hit a page fault
514 * if it stumbled over a reaped memory.
515 */
516 set_bit(MMF_UNSTABLE, &mm->flags);
517
Michal Hockoaac45362016-03-25 14:20:24 -0700518 tlb_gather_mmu(&tlb, mm, 0, -1);
519 for (vma = mm->mmap ; vma; vma = vma->vm_next) {
Kirill A. Shutemov23519072017-02-22 15:46:39 -0800520 if (!can_madv_dontneed_vma(vma))
Michal Hockoaac45362016-03-25 14:20:24 -0700521 continue;
522
523 /*
524 * Only anonymous pages have a good chance to be dropped
525 * without additional steps which we cannot afford as we
526 * are OOM already.
527 *
528 * We do not even care about fs backed pages because all
529 * which are reclaimable have already been reclaimed and
530 * we do not want to block exit_mmap by keeping mm ref
531 * count elevated without a good reason.
532 */
533 if (vma_is_anonymous(vma) || !(vma->vm_flags & VM_SHARED))
534 unmap_page_range(&tlb, vma, vma->vm_start, vma->vm_end,
Kirill A. Shutemov3e8715f2017-02-22 15:46:34 -0800535 NULL);
Michal Hockoaac45362016-03-25 14:20:24 -0700536 }
537 tlb_finish_mmu(&tlb, 0, -1);
Michal Hockobc448e82016-03-25 14:20:30 -0700538 pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
539 task_pid_nr(tsk), tsk->comm,
540 K(get_mm_counter(mm, MM_ANONPAGES)),
541 K(get_mm_counter(mm, MM_FILEPAGES)),
542 K(get_mm_counter(mm, MM_SHMEMPAGES)));
Michal Hockoaac45362016-03-25 14:20:24 -0700543 up_read(&mm->mmap_sem);
Michal Hocko36324a92016-03-25 14:20:27 -0700544
545 /*
Michal Hockoec8d7c12016-05-20 16:57:21 -0700546 * Drop our reference but make sure the mmput slow path is called from a
547 * different context because we shouldn't risk we get stuck there and
548 * put the oom_reaper out of the way.
549 */
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700550 mmput_async(mm);
Roman Gushchin422580c2017-07-10 15:49:05 -0700551 trace_finish_task_reaping(tsk->pid);
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700552unlock_oom:
553 mutex_unlock(&oom_lock);
Michal Hockoaac45362016-03-25 14:20:24 -0700554 return ret;
555}
556
Michal Hockobc448e82016-03-25 14:20:30 -0700557#define MAX_OOM_REAP_RETRIES 10
Michal Hocko36324a92016-03-25 14:20:27 -0700558static void oom_reap_task(struct task_struct *tsk)
Michal Hockoaac45362016-03-25 14:20:24 -0700559{
560 int attempts = 0;
Michal Hocko26db62f2016-10-07 16:58:51 -0700561 struct mm_struct *mm = tsk->signal->oom_mm;
Michal Hockoaac45362016-03-25 14:20:24 -0700562
563 /* Retry the down_read_trylock(mmap_sem) a few times */
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700564 while (attempts++ < MAX_OOM_REAP_RETRIES && !__oom_reap_task_mm(tsk, mm))
Michal Hockoaac45362016-03-25 14:20:24 -0700565 schedule_timeout_idle(HZ/10);
566
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700567 if (attempts <= MAX_OOM_REAP_RETRIES)
568 goto done;
Michal Hocko11a410d2016-07-28 15:44:58 -0700569
Tetsuo Handa8496afa2016-10-07 16:58:48 -0700570
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700571 pr_info("oom_reaper: unable to reap pid:%d (%s)\n",
572 task_pid_nr(tsk), tsk->comm);
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700573 debug_show_all_locks();
Michal Hockobc448e82016-03-25 14:20:30 -0700574
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700575done:
Michal Hocko449d7772016-05-19 17:13:15 -0700576 tsk->oom_reaper_list = NULL;
Michal Hocko449d7772016-05-19 17:13:15 -0700577
Michal Hocko26db62f2016-10-07 16:58:51 -0700578 /*
579 * Hide this mm from OOM killer because it has been either reaped or
580 * somebody can't call up_write(mmap_sem).
581 */
Michal Hocko862e3072016-10-07 16:58:57 -0700582 set_bit(MMF_OOM_SKIP, &mm->flags);
Michal Hocko26db62f2016-10-07 16:58:51 -0700583
Michal Hockoaac45362016-03-25 14:20:24 -0700584 /* Drop a reference taken by wake_oom_reaper */
Michal Hocko36324a92016-03-25 14:20:27 -0700585 put_task_struct(tsk);
Michal Hockoaac45362016-03-25 14:20:24 -0700586}
587
588static int oom_reaper(void *unused)
589{
590 while (true) {
Michal Hocko03049262016-03-25 14:20:33 -0700591 struct task_struct *tsk = NULL;
Michal Hockoaac45362016-03-25 14:20:24 -0700592
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700593 wait_event_freezable(oom_reaper_wait, oom_reaper_list != NULL);
Michal Hocko03049262016-03-25 14:20:33 -0700594 spin_lock(&oom_reaper_lock);
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700595 if (oom_reaper_list != NULL) {
596 tsk = oom_reaper_list;
597 oom_reaper_list = tsk->oom_reaper_list;
Michal Hocko03049262016-03-25 14:20:33 -0700598 }
599 spin_unlock(&oom_reaper_lock);
600
601 if (tsk)
602 oom_reap_task(tsk);
Michal Hockoaac45362016-03-25 14:20:24 -0700603 }
604
605 return 0;
606}
607
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700608static void wake_oom_reaper(struct task_struct *tsk)
Michal Hockoaac45362016-03-25 14:20:24 -0700609{
Michal Hockoaf8e15c2016-04-01 14:31:34 -0700610 if (!oom_reaper_th)
611 return;
612
613 /* tsk is already queued? */
614 if (tsk == oom_reaper_list || tsk->oom_reaper_list)
Michal Hockoaac45362016-03-25 14:20:24 -0700615 return;
616
Michal Hocko36324a92016-03-25 14:20:27 -0700617 get_task_struct(tsk);
Michal Hockoaac45362016-03-25 14:20:24 -0700618
Michal Hocko03049262016-03-25 14:20:33 -0700619 spin_lock(&oom_reaper_lock);
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700620 tsk->oom_reaper_list = oom_reaper_list;
621 oom_reaper_list = tsk;
Michal Hocko03049262016-03-25 14:20:33 -0700622 spin_unlock(&oom_reaper_lock);
Roman Gushchin422580c2017-07-10 15:49:05 -0700623 trace_wake_reaper(tsk->pid);
Michal Hocko03049262016-03-25 14:20:33 -0700624 wake_up(&oom_reaper_wait);
Michal Hockoaac45362016-03-25 14:20:24 -0700625}
626
627static int __init oom_init(void)
628{
629 oom_reaper_th = kthread_run(oom_reaper, NULL, "oom_reaper");
630 if (IS_ERR(oom_reaper_th)) {
631 pr_err("Unable to start OOM reaper %ld. Continuing regardless\n",
632 PTR_ERR(oom_reaper_th));
633 oom_reaper_th = NULL;
634 }
635 return 0;
636}
637subsys_initcall(oom_init)
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700638#else
639static inline void wake_oom_reaper(struct task_struct *tsk)
640{
641}
642#endif /* CONFIG_MMU */
Michal Hockoaac45362016-03-25 14:20:24 -0700643
Michal Hocko49550b62015-02-11 15:26:12 -0800644/**
Johannes Weiner16e95192015-06-24 16:57:07 -0700645 * mark_oom_victim - mark the given task as OOM victim
Michal Hocko49550b62015-02-11 15:26:12 -0800646 * @tsk: task to mark
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800647 *
Johannes Weinerdc564012015-06-24 16:57:19 -0700648 * Has to be called with oom_lock held and never after
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800649 * oom has been disabled already.
Michal Hocko26db62f2016-10-07 16:58:51 -0700650 *
651 * tsk->mm has to be non NULL and caller has to guarantee it is stable (either
652 * under task_lock or operate on the current).
Michal Hocko49550b62015-02-11 15:26:12 -0800653 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700654static void mark_oom_victim(struct task_struct *tsk)
Michal Hocko49550b62015-02-11 15:26:12 -0800655{
Michal Hocko26db62f2016-10-07 16:58:51 -0700656 struct mm_struct *mm = tsk->mm;
657
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800658 WARN_ON(oom_killer_disabled);
659 /* OOM killer might race with memcg OOM */
660 if (test_and_set_tsk_thread_flag(tsk, TIF_MEMDIE))
661 return;
Michal Hocko26db62f2016-10-07 16:58:51 -0700662
Michal Hocko26db62f2016-10-07 16:58:51 -0700663 /* oom_mm is bound to the signal struct life time. */
664 if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm))
Vegard Nossumf1f10072017-02-27 14:30:07 -0800665 mmgrab(tsk->signal->oom_mm);
Michal Hocko26db62f2016-10-07 16:58:51 -0700666
Michal Hocko63a8ca92015-02-11 15:26:15 -0800667 /*
668 * Make sure that the task is woken up from uninterruptible sleep
669 * if it is frozen because OOM killer wouldn't be able to free
670 * any memory and livelock. freezing_slow_path will tell the freezer
671 * that TIF_MEMDIE tasks should be ignored.
672 */
673 __thaw_task(tsk);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800674 atomic_inc(&oom_victims);
Roman Gushchin422580c2017-07-10 15:49:05 -0700675 trace_mark_victim(tsk->pid);
Michal Hocko49550b62015-02-11 15:26:12 -0800676}
677
678/**
Johannes Weiner16e95192015-06-24 16:57:07 -0700679 * exit_oom_victim - note the exit of an OOM victim
Michal Hocko49550b62015-02-11 15:26:12 -0800680 */
Tetsuo Handa38531202016-10-07 16:59:03 -0700681void exit_oom_victim(void)
Michal Hocko49550b62015-02-11 15:26:12 -0800682{
Tetsuo Handa38531202016-10-07 16:59:03 -0700683 clear_thread_flag(TIF_MEMDIE);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800684
Johannes Weinerc38f1022015-06-24 16:57:13 -0700685 if (!atomic_dec_return(&oom_victims))
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800686 wake_up_all(&oom_victims_wait);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800687}
688
689/**
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700690 * oom_killer_enable - enable OOM killer
691 */
692void oom_killer_enable(void)
693{
694 oom_killer_disabled = false;
Michal Hockod75da002017-05-03 14:54:57 -0700695 pr_info("OOM killer enabled.\n");
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700696}
697
698/**
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800699 * oom_killer_disable - disable OOM killer
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700700 * @timeout: maximum timeout to wait for oom victims in jiffies
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800701 *
702 * Forces all page allocations to fail rather than trigger OOM killer.
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700703 * Will block and wait until all OOM victims are killed or the given
704 * timeout expires.
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800705 *
706 * The function cannot be called when there are runnable user tasks because
707 * the userspace would see unexpected allocation failures as a result. Any
708 * new usage of this function should be consulted with MM people.
709 *
710 * Returns true if successful and false if the OOM killer cannot be
711 * disabled.
712 */
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700713bool oom_killer_disable(signed long timeout)
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800714{
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700715 signed long ret;
716
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800717 /*
Tetsuo Handa6afcf282016-03-17 14:20:45 -0700718 * Make sure to not race with an ongoing OOM killer. Check that the
719 * current is not killed (possibly due to sharing the victim's memory).
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800720 */
Tetsuo Handa6afcf282016-03-17 14:20:45 -0700721 if (mutex_lock_killable(&oom_lock))
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800722 return false;
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800723 oom_killer_disabled = true;
Johannes Weinerdc564012015-06-24 16:57:19 -0700724 mutex_unlock(&oom_lock);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800725
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700726 ret = wait_event_interruptible_timeout(oom_victims_wait,
727 !atomic_read(&oom_victims), timeout);
728 if (ret <= 0) {
729 oom_killer_enable();
730 return false;
731 }
Michal Hockod75da002017-05-03 14:54:57 -0700732 pr_info("OOM killer disabled.\n");
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800733
734 return true;
735}
736
Michal Hocko1af8bb42016-07-28 15:44:52 -0700737static inline bool __task_will_free_mem(struct task_struct *task)
738{
739 struct signal_struct *sig = task->signal;
740
741 /*
742 * A coredumping process may sleep for an extended period in exit_mm(),
743 * so the oom killer cannot assume that the process will promptly exit
744 * and release memory.
745 */
746 if (sig->flags & SIGNAL_GROUP_COREDUMP)
747 return false;
748
749 if (sig->flags & SIGNAL_GROUP_EXIT)
750 return true;
751
752 if (thread_group_empty(task) && (task->flags & PF_EXITING))
753 return true;
754
755 return false;
756}
757
758/*
759 * Checks whether the given task is dying or exiting and likely to
760 * release its address space. This means that all threads and processes
761 * sharing the same mm have to be killed or exiting.
Michal Hocko091f3622016-07-28 15:45:04 -0700762 * Caller has to make sure that task->mm is stable (hold task_lock or
763 * it operates on the current).
Michal Hocko1af8bb42016-07-28 15:44:52 -0700764 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700765static bool task_will_free_mem(struct task_struct *task)
Michal Hocko1af8bb42016-07-28 15:44:52 -0700766{
Michal Hocko091f3622016-07-28 15:45:04 -0700767 struct mm_struct *mm = task->mm;
Michal Hocko1af8bb42016-07-28 15:44:52 -0700768 struct task_struct *p;
Geert Uytterhoevenf33e6f02016-08-11 15:33:09 -0700769 bool ret = true;
Michal Hocko1af8bb42016-07-28 15:44:52 -0700770
Michal Hocko091f3622016-07-28 15:45:04 -0700771 /*
772 * Skip tasks without mm because it might have passed its exit_mm and
773 * exit_oom_victim. oom_reaper could have rescued that but do not rely
774 * on that for now. We can consider find_lock_task_mm in future.
775 */
776 if (!mm)
777 return false;
778
Michal Hocko1af8bb42016-07-28 15:44:52 -0700779 if (!__task_will_free_mem(task))
780 return false;
781
782 /*
Michal Hocko696453e2016-07-28 15:44:55 -0700783 * This task has already been drained by the oom reaper so there are
784 * only small chances it will free some more
785 */
Michal Hocko862e3072016-10-07 16:58:57 -0700786 if (test_bit(MMF_OOM_SKIP, &mm->flags))
Michal Hocko696453e2016-07-28 15:44:55 -0700787 return false;
Michal Hocko696453e2016-07-28 15:44:55 -0700788
Michal Hocko091f3622016-07-28 15:45:04 -0700789 if (atomic_read(&mm->mm_users) <= 1)
Michal Hocko1af8bb42016-07-28 15:44:52 -0700790 return true;
Michal Hocko1af8bb42016-07-28 15:44:52 -0700791
792 /*
Michal Hocko5870c2e2016-10-07 16:57:32 -0700793 * Make sure that all tasks which share the mm with the given tasks
794 * are dying as well to make sure that a) nobody pins its mm and
795 * b) the task is also reapable by the oom reaper.
Michal Hocko1af8bb42016-07-28 15:44:52 -0700796 */
797 rcu_read_lock();
798 for_each_process(p) {
799 if (!process_shares_mm(p, mm))
800 continue;
801 if (same_thread_group(task, p))
802 continue;
803 ret = __task_will_free_mem(p);
804 if (!ret)
805 break;
806 }
807 rcu_read_unlock();
Michal Hocko1af8bb42016-07-28 15:44:52 -0700808
809 return ret;
810}
811
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700812static void oom_kill_process(struct oom_control *oc, const char *message)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813{
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700814 struct task_struct *p = oc->chosen;
815 unsigned int points = oc->chosen_points;
Linus Torvalds52d3c032011-03-14 15:17:07 -0700816 struct task_struct *victim = p;
David Rientjes5e9d8342010-08-09 17:18:51 -0700817 struct task_struct *child;
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800818 struct task_struct *t;
David Rientjes647f2bd2012-03-21 16:33:46 -0700819 struct mm_struct *mm;
Linus Torvalds52d3c032011-03-14 15:17:07 -0700820 unsigned int victim_points = 0;
David Rientjesdc3f21e2012-03-21 16:33:47 -0700821 static DEFINE_RATELIMIT_STATE(oom_rs, DEFAULT_RATELIMIT_INTERVAL,
822 DEFAULT_RATELIMIT_BURST);
Tetsuo Handabb299022016-03-25 14:20:44 -0700823 bool can_oom_reap = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700825 /*
826 * If the task is already exiting, don't alarm the sysadmin or kill
Michal Hockocd04ae12017-09-06 16:24:50 -0700827 * its children or threads, just give it access to memory reserves
828 * so it can die quickly
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700829 */
Michal Hocko091f3622016-07-28 15:45:04 -0700830 task_lock(p);
Michal Hocko1af8bb42016-07-28 15:44:52 -0700831 if (task_will_free_mem(p)) {
Johannes Weiner16e95192015-06-24 16:57:07 -0700832 mark_oom_victim(p);
Michal Hocko1af8bb42016-07-28 15:44:52 -0700833 wake_oom_reaper(p);
Michal Hocko091f3622016-07-28 15:45:04 -0700834 task_unlock(p);
David Rientjes6b0c81b2012-07-31 16:43:45 -0700835 put_task_struct(p);
David Rientjes2a1c9b12012-03-21 16:33:46 -0700836 return;
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700837 }
Michal Hocko091f3622016-07-28 15:45:04 -0700838 task_unlock(p);
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700839
David Rientjesdc3f21e2012-03-21 16:33:47 -0700840 if (__ratelimit(&oom_rs))
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700841 dump_header(oc, p);
David Rientjes8447d952012-03-21 16:33:47 -0700842
Wang Longf0d66472015-06-24 16:58:01 -0700843 pr_err("%s: Kill process %d (%s) score %u or sacrifice child\n",
David Rientjes5e9d8342010-08-09 17:18:51 -0700844 message, task_pid_nr(p), p->comm, points);
Nick Pigginf3af38d2006-12-06 20:31:51 -0800845
David Rientjes5e9d8342010-08-09 17:18:51 -0700846 /*
847 * If any of p's children has a different mm and is eligible for kill,
David Rientjes11239832011-07-25 17:12:17 -0700848 * the one with the highest oom_badness() score is sacrificed for its
David Rientjes5e9d8342010-08-09 17:18:51 -0700849 * parent. This attempts to lose the minimal amount of work done while
850 * still freeing memory.
851 */
David Rientjes6b0c81b2012-07-31 16:43:45 -0700852 read_lock(&tasklist_lock);
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800853 for_each_thread(p, t) {
David Rientjes5e9d8342010-08-09 17:18:51 -0700854 list_for_each_entry(child, &t->children, sibling) {
David Rientjesa63d83f2010-08-09 17:19:46 -0700855 unsigned int child_points;
David Rientjes5e9d8342010-08-09 17:18:51 -0700856
Oleg Nesterov4d7b3392015-11-05 18:48:26 -0800857 if (process_shares_mm(child, p->mm))
David Rientjesedd45542011-03-22 16:30:12 -0700858 continue;
David Rientjesa63d83f2010-08-09 17:19:46 -0700859 /*
860 * oom_badness() returns 0 if the thread is unkillable
861 */
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700862 child_points = oom_badness(child,
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700863 oc->memcg, oc->nodemask, oc->totalpages);
David Rientjes5e9d8342010-08-09 17:18:51 -0700864 if (child_points > victim_points) {
David Rientjes6b0c81b2012-07-31 16:43:45 -0700865 put_task_struct(victim);
David Rientjes5e9d8342010-08-09 17:18:51 -0700866 victim = child;
867 victim_points = child_points;
David Rientjes6b0c81b2012-07-31 16:43:45 -0700868 get_task_struct(victim);
David Rientjes5e9d8342010-08-09 17:18:51 -0700869 }
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700870 }
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800871 }
David Rientjes6b0c81b2012-07-31 16:43:45 -0700872 read_unlock(&tasklist_lock);
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700873
David Rientjes6b0c81b2012-07-31 16:43:45 -0700874 p = find_lock_task_mm(victim);
875 if (!p) {
David Rientjes6b0c81b2012-07-31 16:43:45 -0700876 put_task_struct(victim);
David Rientjes647f2bd2012-03-21 16:33:46 -0700877 return;
David Rientjes6b0c81b2012-07-31 16:43:45 -0700878 } else if (victim != p) {
879 get_task_struct(p);
880 put_task_struct(victim);
881 victim = p;
882 }
David Rientjes647f2bd2012-03-21 16:33:46 -0700883
Tetsuo Handa880b7682015-11-05 18:47:51 -0800884 /* Get a reference to safely compare mm after task_unlock(victim) */
David Rientjes647f2bd2012-03-21 16:33:46 -0700885 mm = victim->mm;
Vegard Nossumf1f10072017-02-27 14:30:07 -0800886 mmgrab(mm);
Konstantin Khlebnikov8e675f72017-07-06 15:40:28 -0700887
888 /* Raise event before sending signal: task reaper must see this */
889 count_vm_event(OOM_KILL);
890 count_memcg_event_mm(mm, OOM_KILL);
891
Tetsuo Handa426fb5e2015-11-05 18:47:44 -0800892 /*
Michal Hockocd04ae12017-09-06 16:24:50 -0700893 * We should send SIGKILL before granting access to memory reserves
894 * in order to prevent the OOM victim from depleting the memory
895 * reserves from the user space under its control.
Tetsuo Handa426fb5e2015-11-05 18:47:44 -0800896 */
897 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
Johannes Weiner16e95192015-06-24 16:57:07 -0700898 mark_oom_victim(victim);
Jerome Marchandeca56ff2016-01-14 15:19:26 -0800899 pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
David Rientjes647f2bd2012-03-21 16:33:46 -0700900 task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
901 K(get_mm_counter(victim->mm, MM_ANONPAGES)),
Jerome Marchandeca56ff2016-01-14 15:19:26 -0800902 K(get_mm_counter(victim->mm, MM_FILEPAGES)),
903 K(get_mm_counter(victim->mm, MM_SHMEMPAGES)));
David Rientjes647f2bd2012-03-21 16:33:46 -0700904 task_unlock(victim);
905
906 /*
907 * Kill all user processes sharing victim->mm in other thread groups, if
908 * any. They don't get access to memory reserves, though, to avoid
909 * depletion of all memory. This prevents mm->mmap_sem livelock when an
910 * oom killed thread cannot exit because it requires the semaphore and
911 * its contended by another thread trying to allocate memory itself.
912 * That thread will now get access to memory reserves since it has a
913 * pending fatal signal.
914 */
Oleg Nesterov4d4048b2014-01-21 15:50:01 -0800915 rcu_read_lock();
Oleg Nesterovc3190252015-11-05 18:48:23 -0800916 for_each_process(p) {
Oleg Nesterov4d7b3392015-11-05 18:48:26 -0800917 if (!process_shares_mm(p, mm))
Oleg Nesterovc3190252015-11-05 18:48:23 -0800918 continue;
919 if (same_thread_group(p, victim))
920 continue;
Michal Hocko1b51e652016-10-07 16:59:09 -0700921 if (is_global_init(p)) {
Michal Hockoaac45362016-03-25 14:20:24 -0700922 can_oom_reap = false;
Michal Hocko862e3072016-10-07 16:58:57 -0700923 set_bit(MMF_OOM_SKIP, &mm->flags);
Michal Hockoa3739662016-07-28 15:45:01 -0700924 pr_info("oom killer %d (%s) has mm pinned by %d (%s)\n",
925 task_pid_nr(victim), victim->comm,
926 task_pid_nr(p), p->comm);
Oleg Nesterovc3190252015-11-05 18:48:23 -0800927 continue;
Michal Hockoaac45362016-03-25 14:20:24 -0700928 }
Michal Hocko1b51e652016-10-07 16:59:09 -0700929 /*
930 * No use_mm() user needs to read from the userspace so we are
931 * ok to reap it.
932 */
933 if (unlikely(p->flags & PF_KTHREAD))
934 continue;
Oleg Nesterovc3190252015-11-05 18:48:23 -0800935 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true);
936 }
David Rientjes6b0c81b2012-07-31 16:43:45 -0700937 rcu_read_unlock();
David Rientjes647f2bd2012-03-21 16:33:46 -0700938
Michal Hockoaac45362016-03-25 14:20:24 -0700939 if (can_oom_reap)
Michal Hocko36324a92016-03-25 14:20:27 -0700940 wake_oom_reaper(victim);
Michal Hockoaac45362016-03-25 14:20:24 -0700941
Tetsuo Handa880b7682015-11-05 18:47:51 -0800942 mmdrop(mm);
David Rientjes6b0c81b2012-07-31 16:43:45 -0700943 put_task_struct(victim);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944}
David Rientjes647f2bd2012-03-21 16:33:46 -0700945#undef K
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
David Rientjes309ed882010-08-09 17:18:54 -0700947/*
948 * Determines whether the kernel must panic because of the panic_on_oom sysctl.
949 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700950static void check_panic_on_oom(struct oom_control *oc,
951 enum oom_constraint constraint)
David Rientjes309ed882010-08-09 17:18:54 -0700952{
953 if (likely(!sysctl_panic_on_oom))
954 return;
955 if (sysctl_panic_on_oom != 2) {
956 /*
957 * panic_on_oom == 1 only affects CONSTRAINT_NONE, the kernel
958 * does not panic for cpuset, mempolicy, or memcg allocation
959 * failures.
960 */
961 if (constraint != CONSTRAINT_NONE)
962 return;
963 }
David Rientjes071a4be2015-09-08 15:00:42 -0700964 /* Do not panic for oom kills triggered by sysrq */
Yaowei Baidb2a0dd2015-11-06 16:28:06 -0800965 if (is_sysrq_oom(oc))
David Rientjes071a4be2015-09-08 15:00:42 -0700966 return;
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700967 dump_header(oc, NULL);
David Rientjes309ed882010-08-09 17:18:54 -0700968 panic("Out of memory: %s panic_on_oom is enabled\n",
969 sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide");
970}
971
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -0700972static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
973
974int register_oom_notifier(struct notifier_block *nb)
975{
976 return blocking_notifier_chain_register(&oom_notify_list, nb);
977}
978EXPORT_SYMBOL_GPL(register_oom_notifier);
979
980int unregister_oom_notifier(struct notifier_block *nb)
981{
982 return blocking_notifier_chain_unregister(&oom_notify_list, nb);
983}
984EXPORT_SYMBOL_GPL(unregister_oom_notifier);
985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986/**
David Rientjes6e0fc462015-09-08 15:00:36 -0700987 * out_of_memory - kill the "best" process when we run out of memory
988 * @oc: pointer to struct oom_control
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 *
990 * If we run out of memory, we have the choice between either
991 * killing a random task (bad), letting the system crash (worse)
992 * OR try to be smart about which process to kill. Note that we
993 * don't have to be perfect here, we just have to be good.
994 */
David Rientjes6e0fc462015-09-08 15:00:36 -0700995bool out_of_memory(struct oom_control *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -0700997 unsigned long freed = 0;
David Rientjese3658932010-08-09 17:18:55 -0700998 enum oom_constraint constraint = CONSTRAINT_NONE;
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -0700999
Johannes Weinerdc564012015-06-24 16:57:19 -07001000 if (oom_killer_disabled)
1001 return false;
1002
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001003 if (!is_memcg_oom(oc)) {
1004 blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
1005 if (freed > 0)
1006 /* Got some memory back in the last second. */
1007 return true;
1008 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
David Rientjes7b98c2e2010-08-09 17:18:48 -07001010 /*
David Rientjes9ff48682012-12-11 16:01:30 -08001011 * If current has a pending SIGKILL or is exiting, then automatically
1012 * select it. The goal is to allow it to allocate so that it may
1013 * quickly exit and free its memory.
David Rientjes7b98c2e2010-08-09 17:18:48 -07001014 */
Michal Hocko091f3622016-07-28 15:45:04 -07001015 if (task_will_free_mem(current)) {
Johannes Weiner16e95192015-06-24 16:57:07 -07001016 mark_oom_victim(current);
Michal Hocko1af8bb42016-07-28 15:44:52 -07001017 wake_oom_reaper(current);
David Rientjes75e8f8b2015-09-08 15:00:47 -07001018 return true;
David Rientjes7b98c2e2010-08-09 17:18:48 -07001019 }
1020
Christoph Lameter9b0f8b02006-02-20 18:27:52 -08001021 /*
Michal Hocko3da88fb2016-05-19 17:13:09 -07001022 * The OOM killer does not compensate for IO-less reclaim.
1023 * pagefault_out_of_memory lost its gfp context so we have to
1024 * make sure exclude 0 mask - all other users should have at least
1025 * ___GFP_DIRECT_RECLAIM to get here.
1026 */
Michal Hocko06ad2762017-02-22 15:46:22 -08001027 if (oc->gfp_mask && !(oc->gfp_mask & __GFP_FS))
Michal Hocko3da88fb2016-05-19 17:13:09 -07001028 return true;
1029
1030 /*
Christoph Lameter9b0f8b02006-02-20 18:27:52 -08001031 * Check if there were limitations on the allocation (only relevant for
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001032 * NUMA and memcg) that may require different handling.
Christoph Lameter9b0f8b02006-02-20 18:27:52 -08001033 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001034 constraint = constrained_alloc(oc);
David Rientjes6e0fc462015-09-08 15:00:36 -07001035 if (constraint != CONSTRAINT_MEMORY_POLICY)
1036 oc->nodemask = NULL;
Vladimir Davydov2a966b72016-07-26 15:22:33 -07001037 check_panic_on_oom(oc, constraint);
David Rientjes0aad4b32010-08-09 17:18:59 -07001038
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001039 if (!is_memcg_oom(oc) && sysctl_oom_kill_allocating_task &&
1040 current->mm && !oom_unkillable_task(current, NULL, oc->nodemask) &&
David Rientjes121d1ba2012-07-31 16:42:55 -07001041 current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) {
David Rientjes6b0c81b2012-07-31 16:43:45 -07001042 get_task_struct(current);
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001043 oc->chosen = current;
1044 oom_kill_process(oc, "Out of memory (oom_kill_allocating_task)");
David Rientjes75e8f8b2015-09-08 15:00:47 -07001045 return true;
David Rientjes0aad4b32010-08-09 17:18:59 -07001046 }
1047
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001048 select_bad_process(oc);
David Rientjes0aad4b32010-08-09 17:18:59 -07001049 /* Found nothing?!?! Either we hang forever, or we panic. */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001050 if (!oc->chosen && !is_sysrq_oom(oc) && !is_memcg_oom(oc)) {
Vladimir Davydov2a966b72016-07-26 15:22:33 -07001051 dump_header(oc, NULL);
David Rientjes0aad4b32010-08-09 17:18:59 -07001052 panic("Out of memory and no killable processes...\n");
1053 }
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001054 if (oc->chosen && oc->chosen != (void *)-1UL) {
1055 oom_kill_process(oc, !is_memcg_oom(oc) ? "Out of memory" :
1056 "Memory cgroup out of memory");
David Rientjes75e8f8b2015-09-08 15:00:47 -07001057 /*
1058 * Give the killed process a good chance to exit before trying
1059 * to allocate memory again.
1060 */
David Rientjes4f774b92012-07-31 16:42:37 -07001061 schedule_timeout_killable(1);
David Rientjes75e8f8b2015-09-08 15:00:47 -07001062 }
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001063 return !!oc->chosen;
Michal Hockoc32b3cb2015-02-11 15:26:24 -08001064}
1065
David Rientjese3658932010-08-09 17:18:55 -07001066/*
1067 * The pagefault handler calls here because it is out of memory, so kill a
Vladimir Davydov798fd752016-07-26 15:22:30 -07001068 * memory-hogging task. If oom_lock is held by somebody else, a parallel oom
1069 * killing is already in progress so do nothing.
David Rientjese3658932010-08-09 17:18:55 -07001070 */
1071void pagefault_out_of_memory(void)
1072{
David Rientjes6e0fc462015-09-08 15:00:36 -07001073 struct oom_control oc = {
1074 .zonelist = NULL,
1075 .nodemask = NULL,
Vladimir Davydov2a966b72016-07-26 15:22:33 -07001076 .memcg = NULL,
David Rientjes6e0fc462015-09-08 15:00:36 -07001077 .gfp_mask = 0,
1078 .order = 0,
David Rientjes6e0fc462015-09-08 15:00:36 -07001079 };
1080
Johannes Weiner49426422013-10-16 13:46:59 -07001081 if (mem_cgroup_oom_synchronize(true))
Johannes Weinerdc564012015-06-24 16:57:19 -07001082 return;
Johannes Weiner3812c8c2013-09-12 15:13:44 -07001083
Johannes Weinerdc564012015-06-24 16:57:19 -07001084 if (!mutex_trylock(&oom_lock))
1085 return;
Tetsuo Handaa1048082016-10-07 17:00:49 -07001086 out_of_memory(&oc);
Johannes Weinerdc564012015-06-24 16:57:19 -07001087 mutex_unlock(&oom_lock);
David Rientjese3658932010-08-09 17:18:55 -07001088}