blob: de740800a816cff3a2e49c70089efbca680e5fdf [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>
25#include <linux/swap.h>
26#include <linux/timex.h>
27#include <linux/jiffies.h>
Paul Jacksonef08e3b2005-09-06 15:18:13 -070028#include <linux/cpuset.h>
Paul Gortmakerb95f1b312011-10-16 02:01:52 -040029#include <linux/export.h>
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -070030#include <linux/notifier.h>
Pavel Emelianovc7ba5c92008-02-07 00:13:58 -080031#include <linux/memcontrol.h>
David Rientjes6f48d0eb2010-08-09 17:18:52 -070032#include <linux/mempolicy.h>
David Howells5cd9c582008-08-14 11:37:28 +010033#include <linux/security.h>
David Rientjesedd45542011-03-22 16:30:12 -070034#include <linux/ptrace.h>
David Rientjesf660daa2011-10-31 17:07:07 -070035#include <linux/freezer.h>
KAMEZAWA Hiroyuki43d2b112012-01-10 15:08:09 -080036#include <linux/ftrace.h>
David Rientjesdc3f21e2012-03-21 16:33:47 -070037#include <linux/ratelimit.h>
Michal Hockoaac45362016-03-25 14:20:24 -070038#include <linux/kthread.h>
39#include <linux/init.h>
Prakash Gupta2eb87752017-08-02 15:16:35 +053040#include <linux/show_mem_notifier.h>
Michal Hocko2b819702017-10-03 16:14:50 -070041#include <linux/mmu_notifier.h>
Michal Hockoaac45362016-03-25 14:20:24 -070042
43#include <asm/tlb.h>
44#include "internal.h"
KAMEZAWA Hiroyuki43d2b112012-01-10 15:08:09 -080045
46#define CREATE_TRACE_POINTS
47#include <trace/events/oom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
KAMEZAWA Hiroyukifadd8fb2006-06-23 02:03:13 -070049int sysctl_panic_on_oom;
David Rientjesfe071d72007-10-16 23:25:56 -070050int sysctl_oom_kill_allocating_task;
David Rientjesad915c42010-08-09 17:18:53 -070051int sysctl_oom_dump_tasks = 1;
Charan Teja Reddyf9920cf2018-05-01 20:20:20 +053052int sysctl_reap_mem_on_sigkill;
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
David Rientjes61eafb02012-06-20 12:52:58 -0700206 /* Normalize to oom_score_adj units */
207 adj *= totalpages / 1000;
208 points += adj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
David Rientjesf19e8aa2010-09-22 13:04:52 -0700210 /*
David Rientjesa7f638f2012-05-29 15:06:47 -0700211 * Never return 0 for an eligible task regardless of the root bonus and
212 * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here).
David Rientjesf19e8aa2010-09-22 13:04:52 -0700213 */
David Rientjes1e11ad82012-06-08 13:21:26 -0700214 return points > 0 ? points : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
216
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700217enum oom_constraint {
218 CONSTRAINT_NONE,
219 CONSTRAINT_CPUSET,
220 CONSTRAINT_MEMORY_POLICY,
221 CONSTRAINT_MEMCG,
222};
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224/*
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800225 * Determine the type of allocation constraint.
226 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700227static enum oom_constraint constrained_alloc(struct oom_control *oc)
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800228{
Mel Gorman54a6eb52008-04-28 02:12:16 -0700229 struct zone *zone;
Mel Gormandd1a2392008-04-28 02:12:17 -0700230 struct zoneref *z;
David Rientjes6e0fc462015-09-08 15:00:36 -0700231 enum zone_type high_zoneidx = gfp_zone(oc->gfp_mask);
David Rientjesa63d83f2010-08-09 17:19:46 -0700232 bool cpuset_limited = false;
233 int nid;
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800234
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700235 if (is_memcg_oom(oc)) {
236 oc->totalpages = mem_cgroup_get_limit(oc->memcg) ?: 1;
237 return CONSTRAINT_MEMCG;
238 }
239
David Rientjesa63d83f2010-08-09 17:19:46 -0700240 /* Default to all available memory */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700241 oc->totalpages = totalram_pages + total_swap_pages;
242
243 if (!IS_ENABLED(CONFIG_NUMA))
244 return CONSTRAINT_NONE;
David Rientjesa63d83f2010-08-09 17:19:46 -0700245
David Rientjes6e0fc462015-09-08 15:00:36 -0700246 if (!oc->zonelist)
David Rientjesa63d83f2010-08-09 17:19:46 -0700247 return CONSTRAINT_NONE;
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800248 /*
249 * Reach here only when __GFP_NOFAIL is used. So, we should avoid
250 * to kill current.We have to random task kill in this case.
251 * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now.
252 */
David Rientjes6e0fc462015-09-08 15:00:36 -0700253 if (oc->gfp_mask & __GFP_THISNODE)
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800254 return CONSTRAINT_NONE;
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800255
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800256 /*
David Rientjesa63d83f2010-08-09 17:19:46 -0700257 * This is not a __GFP_THISNODE allocation, so a truncated nodemask in
258 * the page allocator means a mempolicy is in effect. Cpuset policy
259 * is enforced in get_page_from_freelist().
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800260 */
David Rientjes6e0fc462015-09-08 15:00:36 -0700261 if (oc->nodemask &&
262 !nodes_subset(node_states[N_MEMORY], *oc->nodemask)) {
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700263 oc->totalpages = total_swap_pages;
David Rientjes6e0fc462015-09-08 15:00:36 -0700264 for_each_node_mask(nid, *oc->nodemask)
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700265 oc->totalpages += node_spanned_pages(nid);
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800266 return CONSTRAINT_MEMORY_POLICY;
David Rientjesa63d83f2010-08-09 17:19:46 -0700267 }
KAMEZAWA Hiroyuki4365a562009-12-15 16:45:33 -0800268
269 /* Check this allocation failure is caused by cpuset's wall function */
David Rientjes6e0fc462015-09-08 15:00:36 -0700270 for_each_zone_zonelist_nodemask(zone, z, oc->zonelist,
271 high_zoneidx, oc->nodemask)
272 if (!cpuset_zone_allowed(zone, oc->gfp_mask))
David Rientjesa63d83f2010-08-09 17:19:46 -0700273 cpuset_limited = true;
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800274
David Rientjesa63d83f2010-08-09 17:19:46 -0700275 if (cpuset_limited) {
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700276 oc->totalpages = total_swap_pages;
David Rientjesa63d83f2010-08-09 17:19:46 -0700277 for_each_node_mask(nid, cpuset_current_mems_allowed)
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700278 oc->totalpages += node_spanned_pages(nid);
David Rientjesa63d83f2010-08-09 17:19:46 -0700279 return CONSTRAINT_CPUSET;
280 }
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800281 return CONSTRAINT_NONE;
282}
283
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700284static int oom_evaluate_task(struct task_struct *task, void *arg)
David Rientjes462607e2012-07-31 16:43:40 -0700285{
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700286 struct oom_control *oc = arg;
287 unsigned long points;
288
David Rientjes6e0fc462015-09-08 15:00:36 -0700289 if (oom_unkillable_task(task, NULL, oc->nodemask))
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700290 goto next;
David Rientjes462607e2012-07-31 16:43:40 -0700291
292 /*
293 * This task already has access to memory reserves and is being killed.
Michal Hockoa3739662016-07-28 15:45:01 -0700294 * Don't allow any other task to have access to the reserves unless
Michal Hocko862e3072016-10-07 16:58:57 -0700295 * the task has MMF_OOM_SKIP because chances that it would release
Michal Hockoa3739662016-07-28 15:45:01 -0700296 * any memory is quite low.
David Rientjes462607e2012-07-31 16:43:40 -0700297 */
Michal Hocko862e3072016-10-07 16:58:57 -0700298 if (!is_sysrq_oom(oc) && tsk_is_oom_victim(task)) {
299 if (test_bit(MMF_OOM_SKIP, &task->signal->oom_mm->flags))
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700300 goto next;
301 goto abort;
Michal Hockoa3739662016-07-28 15:45:01 -0700302 }
David Rientjes462607e2012-07-31 16:43:40 -0700303
David Rientjese1e12d22012-12-11 16:02:56 -0800304 /*
305 * If task is allocating a lot of memory and has been marked to be
306 * killed first if it triggers an oom, then select it.
307 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700308 if (oom_task_origin(task)) {
309 points = ULONG_MAX;
310 goto select;
311 }
David Rientjese1e12d22012-12-11 16:02:56 -0800312
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700313 points = oom_badness(task, NULL, oc->nodemask, oc->totalpages);
314 if (!points || points < oc->chosen_points)
315 goto next;
316
317 /* Prefer thread group leaders for display purposes */
318 if (points == oc->chosen_points && thread_group_leader(oc->chosen))
319 goto next;
320select:
321 if (oc->chosen)
322 put_task_struct(oc->chosen);
323 get_task_struct(task);
324 oc->chosen = task;
325 oc->chosen_points = points;
326next:
327 return 0;
328abort:
329 if (oc->chosen)
330 put_task_struct(oc->chosen);
331 oc->chosen = (void *)-1UL;
332 return 1;
David Rientjes462607e2012-07-31 16:43:40 -0700333}
334
Christoph Lameter9b0f8b02006-02-20 18:27:52 -0800335/*
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700336 * Simple selection loop. We choose the process with the highest number of
337 * 'points'. In case scan was aborted, oc->chosen is set to -1.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700339static void select_bad_process(struct oom_control *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700341 if (is_memcg_oom(oc))
342 mem_cgroup_scan_tasks(oc->memcg, oom_evaluate_task, oc);
343 else {
344 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700346 rcu_read_lock();
347 for_each_process(p)
348 if (oom_evaluate_task(p, oc))
349 break;
350 rcu_read_unlock();
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800351 }
Oleg Nesterov972c4ea2006-09-29 02:01:12 -0700352
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700353 oc->chosen_points = oc->chosen_points * 1000 / oc->totalpages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
356/**
Randy Dunlap1b578df2008-03-19 17:00:42 -0700357 * dump_tasks - dump current memory state of all system tasks
Wanpeng Lidad75572012-06-20 12:53:01 -0700358 * @memcg: current's memory controller, if constrained
David Rientjese85bfd32010-09-22 13:05:10 -0700359 * @nodemask: nodemask passed to page allocator for mempolicy ooms
Randy Dunlap1b578df2008-03-19 17:00:42 -0700360 *
David Rientjese85bfd32010-09-22 13:05:10 -0700361 * Dumps the current memory state of all eligible tasks. Tasks not in the same
362 * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes
363 * are not shown.
David Rientjesde34d962012-07-31 16:42:56 -0700364 * State information includes task's pid, uid, tgid, vm size, rss, nr_ptes,
365 * swapents, oom_score_adj value, and name.
David Rientjesfef1bdd2008-02-07 00:14:07 -0800366 */
Liam Mark2b5cb612014-06-03 13:33:18 -0700367void dump_tasks(struct mem_cgroup *memcg, const nodemask_t *nodemask)
David Rientjesfef1bdd2008-02-07 00:14:07 -0800368{
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700369 struct task_struct *p;
370 struct task_struct *task;
David Rientjesfef1bdd2008-02-07 00:14:07 -0800371
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800372 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 -0700373 rcu_read_lock();
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700374 for_each_process(p) {
Johannes Weiner72835c82012-01-12 17:18:32 -0800375 if (oom_unkillable_task(p, memcg, nodemask))
David Rientjesfef1bdd2008-02-07 00:14:07 -0800376 continue;
377
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700378 task = find_lock_task_mm(p);
379 if (!task) {
David Rientjes6d2661e2009-05-28 14:34:19 -0700380 /*
David Rientjes74ab7f12010-08-09 17:18:46 -0700381 * This is a kthread or all of p's threads have already
382 * detached their mm's. There's no need to report
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700383 * them; they can't be oom killed anyway.
David Rientjes6d2661e2009-05-28 14:34:19 -0700384 */
David Rientjes6d2661e2009-05-28 14:34:19 -0700385 continue;
386 }
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700387
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800388 pr_info("[%5d] %5d %5d %8lu %8lu %7ld %7ld %8lu %5hd %s\n",
Eric W. Biederman078de5f2012-02-08 07:00:08 -0800389 task->pid, from_kuid(&init_user_ns, task_uid(task)),
390 task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
Kirill A. Shutemove1f56c82013-11-14 14:30:48 -0800391 atomic_long_read(&task->mm->nr_ptes),
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -0800392 mm_nr_pmds(task->mm),
David Rientjesde34d962012-07-31 16:42:56 -0700393 get_mm_counter(task->mm, MM_SWAPENTS),
David Rientjesa63d83f2010-08-09 17:19:46 -0700394 task->signal->oom_score_adj, task->comm);
KOSAKI Motohiroc55db952010-08-09 17:18:46 -0700395 task_unlock(task);
396 }
David Rientjes6b0c81b2012-07-31 16:43:45 -0700397 rcu_read_unlock();
David Rientjesfef1bdd2008-02-07 00:14:07 -0800398}
399
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700400static void dump_header(struct oom_control *oc, struct task_struct *p)
David Rientjes1b604d72009-12-14 17:57:47 -0800401{
Michal Hocko82e7d3a2016-10-07 17:01:43 -0700402 nodemask_t *nm = (oc->nodemask) ? oc->nodemask : &cpuset_current_mems_allowed;
403
404 pr_warn("%s invoked oom-killer: gfp_mask=%#x(%pGg), nodemask=%*pbl, order=%d, oom_score_adj=%hd\n",
405 current->comm, oc->gfp_mask, &oc->gfp_mask,
406 nodemask_pr_args(nm), oc->order,
David Rientjesa63d83f2010-08-09 17:19:46 -0700407 current->signal->oom_score_adj);
Michal Hocko92549902016-10-07 16:59:33 -0700408 if (!IS_ENABLED(CONFIG_COMPACTION) && oc->order)
409 pr_warn("COMPACTION is disabled!!!\n");
Vlastimil Babkaa0795cd2016-03-15 14:56:05 -0700410
David Rientjesda39da32015-11-05 18:48:05 -0800411 cpuset_print_current_mems_allowed();
David Rientjes1b604d72009-12-14 17:57:47 -0800412 dump_stack();
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700413 if (oc->memcg)
414 mem_cgroup_print_oom_info(oc->memcg, p);
Prakash Gupta2eb87752017-08-02 15:16:35 +0530415 else {
Sha Zhengju58cf1882013-02-22 16:32:05 -0800416 show_mem(SHOW_MEM_FILTER_NODES);
Prakash Gupta2eb87752017-08-02 15:16:35 +0530417 show_mem_call_notifiers();
418 }
419
David Rientjes1b604d72009-12-14 17:57:47 -0800420 if (sysctl_oom_dump_tasks)
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700421 dump_tasks(oc->memcg, oc->nodemask);
David Rientjes1b604d72009-12-14 17:57:47 -0800422}
423
Michal Hocko5695be12014-10-20 18:12:32 +0200424/*
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800425 * Number of OOM victims in flight
Michal Hocko5695be12014-10-20 18:12:32 +0200426 */
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800427static atomic_t oom_victims = ATOMIC_INIT(0);
428static DECLARE_WAIT_QUEUE_HEAD(oom_victims_wait);
Michal Hocko5695be12014-10-20 18:12:32 +0200429
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700430static bool oom_killer_disabled __read_mostly;
Michal Hocko5695be12014-10-20 18:12:32 +0200431
Michal Hockobc448e82016-03-25 14:20:30 -0700432#define K(x) ((x) << (PAGE_SHIFT-10))
433
Michal Hocko3ef22df2016-05-19 17:13:12 -0700434/*
435 * task->mm can be NULL if the task is the exited group leader. So to
436 * determine whether the task is using a particular mm, we examine all the
437 * task's threads: if one of those is using this mm then this task was also
438 * using it.
439 */
Michal Hocko44a70ade2016-07-28 15:44:43 -0700440bool process_shares_mm(struct task_struct *p, struct mm_struct *mm)
Michal Hocko3ef22df2016-05-19 17:13:12 -0700441{
442 struct task_struct *t;
443
444 for_each_thread(p, t) {
445 struct mm_struct *t_mm = READ_ONCE(t->mm);
446 if (t_mm)
447 return t_mm == mm;
448 }
449 return false;
450}
451
452
Michal Hockoaac45362016-03-25 14:20:24 -0700453#ifdef CONFIG_MMU
454/*
455 * OOM Reaper kernel thread which tries to reap the memory used by the OOM
456 * victim (if that is possible) to help the OOM killer to move on.
457 */
458static struct task_struct *oom_reaper_th;
Michal Hockoaac45362016-03-25 14:20:24 -0700459static DECLARE_WAIT_QUEUE_HEAD(oom_reaper_wait);
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700460static struct task_struct *oom_reaper_list;
Michal Hocko03049262016-03-25 14:20:33 -0700461static DEFINE_SPINLOCK(oom_reaper_lock);
462
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700463static bool __oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)
Michal Hockoaac45362016-03-25 14:20:24 -0700464{
465 struct mmu_gather tlb;
466 struct vm_area_struct *vma;
Michal Hockoaac45362016-03-25 14:20:24 -0700467 bool ret = true;
468
Michal Hocko36324a92016-03-25 14:20:27 -0700469 /*
Michal Hockoe2fe1452016-05-27 14:27:35 -0700470 * We have to make sure to not race with the victim exit path
471 * and cause premature new oom victim selection:
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700472 * __oom_reap_task_mm exit_mm
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700473 * mmget_not_zero
Michal Hockoe2fe1452016-05-27 14:27:35 -0700474 * mmput
475 * atomic_dec_and_test
476 * exit_oom_victim
477 * [...]
478 * out_of_memory
479 * select_bad_process
480 * # no TIF_MEMDIE task selects new victim
481 * unmap_page_range # frees some memory
482 */
483 mutex_lock(&oom_lock);
484
Michal Hockoaac45362016-03-25 14:20:24 -0700485 if (!down_read_trylock(&mm->mmap_sem)) {
486 ret = false;
Roman Gushchin1a83e5c2017-07-10 15:49:05 -0700487 trace_skip_task_reaping(tsk->pid);
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700488 goto unlock_oom;
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700489 }
490
491 /*
Michal Hocko2b819702017-10-03 16:14:50 -0700492 * If the mm has notifiers then we would need to invalidate them around
493 * unmap_page_range and that is risky because notifiers can sleep and
494 * what they do is basically undeterministic. So let's have a short
495 * sleep to give the oom victim some more time.
496 * TODO: we really want to get rid of this ugly hack and make sure that
497 * notifiers cannot block for unbounded amount of time and add
498 * mmu_notifier_invalidate_range_{start,end} around unmap_page_range
499 */
500 if (mm_has_notifiers(mm)) {
501 up_read(&mm->mmap_sem);
502 schedule_timeout_idle(HZ);
503 goto unlock_oom;
504 }
505
506 /*
Andrea Arcangeli07b039e92017-09-06 16:25:00 -0700507 * MMF_OOM_SKIP is set by exit_mmap when the OOM reaper can't
508 * work on the mm anymore. The check for MMF_OOM_SKIP must run
509 * under mmap_sem for reading because it serializes against the
510 * down_write();up_write() cycle in exit_mmap().
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700511 */
Andrea Arcangeli07b039e92017-09-06 16:25:00 -0700512 if (test_bit(MMF_OOM_SKIP, &mm->flags)) {
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700513 up_read(&mm->mmap_sem);
Roman Gushchin1a83e5c2017-07-10 15:49:05 -0700514 trace_skip_task_reaping(tsk->pid);
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700515 goto unlock_oom;
Michal Hockoaac45362016-03-25 14:20:24 -0700516 }
517
Roman Gushchin1a83e5c2017-07-10 15:49:05 -0700518 trace_start_task_reaping(tsk->pid);
519
Michal Hocko3f70dc32016-10-07 16:59:06 -0700520 /*
521 * Tell all users of get_user/copy_from_user etc... that the content
522 * is no longer stable. No barriers really needed because unmapping
523 * should imply barriers already and the reader would hit a page fault
524 * if it stumbled over a reaped memory.
525 */
526 set_bit(MMF_UNSTABLE, &mm->flags);
527
Michal Hockoaac45362016-03-25 14:20:24 -0700528 for (vma = mm->mmap ; vma; vma = vma->vm_next) {
Kirill A. Shutemov7ade3742017-02-22 15:46:39 -0800529 if (!can_madv_dontneed_vma(vma))
Michal Hockoaac45362016-03-25 14:20:24 -0700530 continue;
531
532 /*
533 * Only anonymous pages have a good chance to be dropped
534 * without additional steps which we cannot afford as we
535 * are OOM already.
536 *
537 * We do not even care about fs backed pages because all
538 * which are reclaimable have already been reclaimed and
539 * we do not want to block exit_mmap by keeping mm ref
540 * count elevated without a good reason.
541 */
Wang Nan37f5d922017-11-08 10:53:48 +1100542 if (vma_is_anonymous(vma) || !(vma->vm_flags & VM_SHARED)) {
543 tlb_gather_mmu(&tlb, mm, vma->vm_start, vma->vm_end);
Michal Hockoaac45362016-03-25 14:20:24 -0700544 unmap_page_range(&tlb, vma, vma->vm_start, vma->vm_end,
Kirill A. Shutemovf51ed732017-02-22 15:46:34 -0800545 NULL);
Wang Nan37f5d922017-11-08 10:53:48 +1100546 tlb_finish_mmu(&tlb, vma->vm_start, vma->vm_end);
547 }
Michal Hockoaac45362016-03-25 14:20:24 -0700548 }
Michal Hockobc448e82016-03-25 14:20:30 -0700549 pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
550 task_pid_nr(tsk), tsk->comm,
551 K(get_mm_counter(mm, MM_ANONPAGES)),
552 K(get_mm_counter(mm, MM_FILEPAGES)),
553 K(get_mm_counter(mm, MM_SHMEMPAGES)));
Michal Hockoaac45362016-03-25 14:20:24 -0700554 up_read(&mm->mmap_sem);
Michal Hocko36324a92016-03-25 14:20:27 -0700555
Roman Gushchin1a83e5c2017-07-10 15:49:05 -0700556 trace_finish_task_reaping(tsk->pid);
Michal Hockoe5e3f4c2016-07-26 15:24:50 -0700557unlock_oom:
558 mutex_unlock(&oom_lock);
Michal Hockoaac45362016-03-25 14:20:24 -0700559 return ret;
560}
561
Michal Hockobc448e82016-03-25 14:20:30 -0700562#define MAX_OOM_REAP_RETRIES 10
Michal Hocko36324a92016-03-25 14:20:27 -0700563static void oom_reap_task(struct task_struct *tsk)
Michal Hockoaac45362016-03-25 14:20:24 -0700564{
565 int attempts = 0;
Michal Hocko26db62f2016-10-07 16:58:51 -0700566 struct mm_struct *mm = tsk->signal->oom_mm;
Michal Hockoaac45362016-03-25 14:20:24 -0700567
568 /* Retry the down_read_trylock(mmap_sem) a few times */
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700569 while (attempts++ < MAX_OOM_REAP_RETRIES && !__oom_reap_task_mm(tsk, mm))
Michal Hockoaac45362016-03-25 14:20:24 -0700570 schedule_timeout_idle(HZ/10);
571
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700572 if (attempts <= MAX_OOM_REAP_RETRIES)
573 goto done;
Michal Hocko11a410d2016-07-28 15:44:58 -0700574
Tetsuo Handa8496afa2016-10-07 16:58:48 -0700575
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700576 pr_info("oom_reaper: unable to reap pid:%d (%s)\n",
577 task_pid_nr(tsk), tsk->comm);
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700578 debug_show_all_locks();
Michal Hockobc448e82016-03-25 14:20:30 -0700579
Tetsuo Handa7ebffa42016-10-07 16:58:45 -0700580done:
Michal Hocko449d7772016-05-19 17:13:15 -0700581 tsk->oom_reaper_list = NULL;
Michal Hocko449d7772016-05-19 17:13:15 -0700582
Michal Hocko26db62f2016-10-07 16:58:51 -0700583 /*
584 * Hide this mm from OOM killer because it has been either reaped or
585 * somebody can't call up_write(mmap_sem).
586 */
Michal Hocko862e3072016-10-07 16:58:57 -0700587 set_bit(MMF_OOM_SKIP, &mm->flags);
Michal Hocko26db62f2016-10-07 16:58:51 -0700588
Michal Hockoaac45362016-03-25 14:20:24 -0700589 /* Drop a reference taken by wake_oom_reaper */
Michal Hocko36324a92016-03-25 14:20:27 -0700590 put_task_struct(tsk);
Michal Hockoaac45362016-03-25 14:20:24 -0700591}
592
593static int oom_reaper(void *unused)
594{
595 while (true) {
Michal Hocko03049262016-03-25 14:20:33 -0700596 struct task_struct *tsk = NULL;
Michal Hockoaac45362016-03-25 14:20:24 -0700597
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700598 wait_event_freezable(oom_reaper_wait, oom_reaper_list != NULL);
Michal Hocko03049262016-03-25 14:20:33 -0700599 spin_lock(&oom_reaper_lock);
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700600 if (oom_reaper_list != NULL) {
601 tsk = oom_reaper_list;
602 oom_reaper_list = tsk->oom_reaper_list;
Michal Hocko03049262016-03-25 14:20:33 -0700603 }
604 spin_unlock(&oom_reaper_lock);
605
606 if (tsk)
607 oom_reap_task(tsk);
Michal Hockoaac45362016-03-25 14:20:24 -0700608 }
609
610 return 0;
611}
612
Charan Teja Reddy05d778c22017-07-20 20:08:08 +0530613void wake_oom_reaper(struct task_struct *tsk)
Michal Hockoaac45362016-03-25 14:20:24 -0700614{
Michal Hockoaf8e15c2016-04-01 14:31:34 -0700615 if (!oom_reaper_th)
616 return;
617
Charan Teja Reddyf9920cf2018-05-01 20:20:20 +0530618 /*
619 * Move the lock here to avoid scenario of queuing
620 * the same task by both OOM killer and any other SIGKILL
621 * path.
Charan Teja Reddy05d778c22017-07-20 20:08:08 +0530622 */
623 spin_lock(&oom_reaper_lock);
Charan Teja Reddyf9920cf2018-05-01 20:20:20 +0530624
Tetsuo Handa7f382992019-02-01 14:20:31 -0800625 /* mm is already queued? */
jianzhoub7d97472019-03-19 13:22:26 +0800626 if (test_and_set_bit(MMF_OOM_REAP_QUEUED, &tsk->signal->oom_mm->flags)) {
Charan Teja Reddy05d778c22017-07-20 20:08:08 +0530627 spin_unlock(&oom_reaper_lock);
Michal Hockoaac45362016-03-25 14:20:24 -0700628 return;
Charan Teja Reddy05d778c22017-07-20 20:08:08 +0530629 }
Michal Hockoaac45362016-03-25 14:20:24 -0700630
Michal Hocko36324a92016-03-25 14:20:27 -0700631 get_task_struct(tsk);
Michal Hockoaac45362016-03-25 14:20:24 -0700632
Vladimir Davydov29c696e2016-03-25 14:20:39 -0700633 tsk->oom_reaper_list = oom_reaper_list;
634 oom_reaper_list = tsk;
Michal Hocko03049262016-03-25 14:20:33 -0700635 spin_unlock(&oom_reaper_lock);
Roman Gushchin1a83e5c2017-07-10 15:49:05 -0700636 trace_wake_reaper(tsk->pid);
Michal Hocko03049262016-03-25 14:20:33 -0700637 wake_up(&oom_reaper_wait);
Michal Hockoaac45362016-03-25 14:20:24 -0700638}
639
640static int __init oom_init(void)
641{
642 oom_reaper_th = kthread_run(oom_reaper, NULL, "oom_reaper");
643 if (IS_ERR(oom_reaper_th)) {
644 pr_err("Unable to start OOM reaper %ld. Continuing regardless\n",
645 PTR_ERR(oom_reaper_th));
646 oom_reaper_th = NULL;
647 }
648 return 0;
649}
650subsys_initcall(oom_init)
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700651#else
652static inline void wake_oom_reaper(struct task_struct *tsk)
653{
654}
655#endif /* CONFIG_MMU */
Michal Hockoaac45362016-03-25 14:20:24 -0700656
Charan Teja Reddyf9920cf2018-05-01 20:20:20 +0530657static void __mark_oom_victim(struct task_struct *tsk)
658{
659 struct mm_struct *mm = tsk->mm;
660
661 if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm)) {
662 atomic_inc(&tsk->signal->oom_mm->mm_count);
663 set_bit(MMF_OOM_VICTIM, &mm->flags);
664 }
665}
666
Michal Hocko49550b62015-02-11 15:26:12 -0800667/**
Johannes Weiner16e95192015-06-24 16:57:07 -0700668 * mark_oom_victim - mark the given task as OOM victim
Michal Hocko49550b62015-02-11 15:26:12 -0800669 * @tsk: task to mark
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800670 *
Johannes Weinerdc564012015-06-24 16:57:19 -0700671 * Has to be called with oom_lock held and never after
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800672 * oom has been disabled already.
Michal Hocko26db62f2016-10-07 16:58:51 -0700673 *
674 * tsk->mm has to be non NULL and caller has to guarantee it is stable (either
675 * under task_lock or operate on the current).
Michal Hocko49550b62015-02-11 15:26:12 -0800676 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700677static void mark_oom_victim(struct task_struct *tsk)
Michal Hocko49550b62015-02-11 15:26:12 -0800678{
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800679 WARN_ON(oom_killer_disabled);
680 /* OOM killer might race with memcg OOM */
681 if (test_and_set_tsk_thread_flag(tsk, TIF_MEMDIE))
682 return;
Michal Hocko26db62f2016-10-07 16:58:51 -0700683
Michal Hocko26db62f2016-10-07 16:58:51 -0700684 /* oom_mm is bound to the signal struct life time. */
Charan Teja Reddyf9920cf2018-05-01 20:20:20 +0530685 __mark_oom_victim(tsk);
Michal Hocko26db62f2016-10-07 16:58:51 -0700686
Michal Hocko63a8ca92015-02-11 15:26:15 -0800687 /*
688 * Make sure that the task is woken up from uninterruptible sleep
689 * if it is frozen because OOM killer wouldn't be able to free
690 * any memory and livelock. freezing_slow_path will tell the freezer
691 * that TIF_MEMDIE tasks should be ignored.
692 */
693 __thaw_task(tsk);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800694 atomic_inc(&oom_victims);
Roman Gushchin1a83e5c2017-07-10 15:49:05 -0700695 trace_mark_victim(tsk->pid);
Michal Hocko49550b62015-02-11 15:26:12 -0800696}
697
698/**
Johannes Weiner16e95192015-06-24 16:57:07 -0700699 * exit_oom_victim - note the exit of an OOM victim
Michal Hocko49550b62015-02-11 15:26:12 -0800700 */
Tetsuo Handa38531202016-10-07 16:59:03 -0700701void exit_oom_victim(void)
Michal Hocko49550b62015-02-11 15:26:12 -0800702{
Tetsuo Handa38531202016-10-07 16:59:03 -0700703 clear_thread_flag(TIF_MEMDIE);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800704
Johannes Weinerc38f1022015-06-24 16:57:13 -0700705 if (!atomic_dec_return(&oom_victims))
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800706 wake_up_all(&oom_victims_wait);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800707}
708
709/**
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700710 * oom_killer_enable - enable OOM killer
711 */
712void oom_killer_enable(void)
713{
714 oom_killer_disabled = false;
715}
716
717/**
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800718 * oom_killer_disable - disable OOM killer
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700719 * @timeout: maximum timeout to wait for oom victims in jiffies
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800720 *
721 * Forces all page allocations to fail rather than trigger OOM killer.
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700722 * Will block and wait until all OOM victims are killed or the given
723 * timeout expires.
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800724 *
725 * The function cannot be called when there are runnable user tasks because
726 * the userspace would see unexpected allocation failures as a result. Any
727 * new usage of this function should be consulted with MM people.
728 *
729 * Returns true if successful and false if the OOM killer cannot be
730 * disabled.
731 */
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700732bool oom_killer_disable(signed long timeout)
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800733{
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700734 signed long ret;
735
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800736 /*
Tetsuo Handa6afcf282016-03-17 14:20:45 -0700737 * Make sure to not race with an ongoing OOM killer. Check that the
738 * current is not killed (possibly due to sharing the victim's memory).
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800739 */
Tetsuo Handa6afcf282016-03-17 14:20:45 -0700740 if (mutex_lock_killable(&oom_lock))
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800741 return false;
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800742 oom_killer_disabled = true;
Johannes Weinerdc564012015-06-24 16:57:19 -0700743 mutex_unlock(&oom_lock);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800744
Michal Hocko7d2e7a22016-10-07 16:59:00 -0700745 ret = wait_event_interruptible_timeout(oom_victims_wait,
746 !atomic_read(&oom_victims), timeout);
747 if (ret <= 0) {
748 oom_killer_enable();
749 return false;
750 }
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800751
752 return true;
753}
754
Michal Hocko1af8bb42016-07-28 15:44:52 -0700755static inline bool __task_will_free_mem(struct task_struct *task)
756{
757 struct signal_struct *sig = task->signal;
758
759 /*
760 * A coredumping process may sleep for an extended period in exit_mm(),
761 * so the oom killer cannot assume that the process will promptly exit
762 * and release memory.
763 */
764 if (sig->flags & SIGNAL_GROUP_COREDUMP)
765 return false;
766
767 if (sig->flags & SIGNAL_GROUP_EXIT)
768 return true;
769
770 if (thread_group_empty(task) && (task->flags & PF_EXITING))
771 return true;
772
773 return false;
774}
775
776/*
777 * Checks whether the given task is dying or exiting and likely to
778 * release its address space. This means that all threads and processes
779 * sharing the same mm have to be killed or exiting.
Michal Hocko091f3622016-07-28 15:45:04 -0700780 * Caller has to make sure that task->mm is stable (hold task_lock or
781 * it operates on the current).
Michal Hocko1af8bb42016-07-28 15:44:52 -0700782 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700783static bool task_will_free_mem(struct task_struct *task)
Michal Hocko1af8bb42016-07-28 15:44:52 -0700784{
Michal Hocko091f3622016-07-28 15:45:04 -0700785 struct mm_struct *mm = task->mm;
Michal Hocko1af8bb42016-07-28 15:44:52 -0700786 struct task_struct *p;
Geert Uytterhoevenf33e6f02016-08-11 15:33:09 -0700787 bool ret = true;
Michal Hocko1af8bb42016-07-28 15:44:52 -0700788
Michal Hocko091f3622016-07-28 15:45:04 -0700789 /*
790 * Skip tasks without mm because it might have passed its exit_mm and
791 * exit_oom_victim. oom_reaper could have rescued that but do not rely
792 * on that for now. We can consider find_lock_task_mm in future.
793 */
794 if (!mm)
795 return false;
796
Michal Hocko1af8bb42016-07-28 15:44:52 -0700797 if (!__task_will_free_mem(task))
798 return false;
799
800 /*
Michal Hocko696453e2016-07-28 15:44:55 -0700801 * This task has already been drained by the oom reaper so there are
802 * only small chances it will free some more
803 */
Michal Hocko862e3072016-10-07 16:58:57 -0700804 if (test_bit(MMF_OOM_SKIP, &mm->flags))
Michal Hocko696453e2016-07-28 15:44:55 -0700805 return false;
Michal Hocko696453e2016-07-28 15:44:55 -0700806
Michal Hocko091f3622016-07-28 15:45:04 -0700807 if (atomic_read(&mm->mm_users) <= 1)
Michal Hocko1af8bb42016-07-28 15:44:52 -0700808 return true;
Michal Hocko1af8bb42016-07-28 15:44:52 -0700809
810 /*
Michal Hocko5870c2e2016-10-07 16:57:32 -0700811 * Make sure that all tasks which share the mm with the given tasks
812 * are dying as well to make sure that a) nobody pins its mm and
813 * b) the task is also reapable by the oom reaper.
Michal Hocko1af8bb42016-07-28 15:44:52 -0700814 */
815 rcu_read_lock();
816 for_each_process(p) {
817 if (!process_shares_mm(p, mm))
818 continue;
819 if (same_thread_group(task, p))
820 continue;
821 ret = __task_will_free_mem(p);
822 if (!ret)
823 break;
824 }
825 rcu_read_unlock();
Michal Hocko1af8bb42016-07-28 15:44:52 -0700826
827 return ret;
828}
829
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700830static void oom_kill_process(struct oom_control *oc, const char *message)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831{
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700832 struct task_struct *p = oc->chosen;
833 unsigned int points = oc->chosen_points;
Linus Torvalds52d3c032011-03-14 15:17:07 -0700834 struct task_struct *victim = p;
David Rientjes5e9d8342010-08-09 17:18:51 -0700835 struct task_struct *child;
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800836 struct task_struct *t;
David Rientjes647f2bd2012-03-21 16:33:46 -0700837 struct mm_struct *mm;
Linus Torvalds52d3c032011-03-14 15:17:07 -0700838 unsigned int victim_points = 0;
David Rientjesdc3f21e2012-03-21 16:33:47 -0700839 static DEFINE_RATELIMIT_STATE(oom_rs, DEFAULT_RATELIMIT_INTERVAL,
840 DEFAULT_RATELIMIT_BURST);
Tetsuo Handabb299022016-03-25 14:20:44 -0700841 bool can_oom_reap = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700843 /*
844 * If the task is already exiting, don't alarm the sysadmin or kill
845 * its children or threads, just set TIF_MEMDIE so it can die quickly
846 */
Michal Hocko091f3622016-07-28 15:45:04 -0700847 task_lock(p);
Michal Hocko1af8bb42016-07-28 15:44:52 -0700848 if (task_will_free_mem(p)) {
Johannes Weiner16e95192015-06-24 16:57:07 -0700849 mark_oom_victim(p);
Michal Hocko1af8bb42016-07-28 15:44:52 -0700850 wake_oom_reaper(p);
Michal Hocko091f3622016-07-28 15:45:04 -0700851 task_unlock(p);
David Rientjes6b0c81b2012-07-31 16:43:45 -0700852 put_task_struct(p);
David Rientjes2a1c9b12012-03-21 16:33:46 -0700853 return;
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700854 }
Michal Hocko091f3622016-07-28 15:45:04 -0700855 task_unlock(p);
Nick Piggin50ec3bb2006-09-25 23:31:29 -0700856
David Rientjesdc3f21e2012-03-21 16:33:47 -0700857 if (__ratelimit(&oom_rs))
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700858 dump_header(oc, p);
David Rientjes8447d952012-03-21 16:33:47 -0700859
Wang Longf0d66472015-06-24 16:58:01 -0700860 pr_err("%s: Kill process %d (%s) score %u or sacrifice child\n",
David Rientjes5e9d8342010-08-09 17:18:51 -0700861 message, task_pid_nr(p), p->comm, points);
Nick Pigginf3af38d2006-12-06 20:31:51 -0800862
David Rientjes5e9d8342010-08-09 17:18:51 -0700863 /*
864 * If any of p's children has a different mm and is eligible for kill,
David Rientjes11239832011-07-25 17:12:17 -0700865 * the one with the highest oom_badness() score is sacrificed for its
David Rientjes5e9d8342010-08-09 17:18:51 -0700866 * parent. This attempts to lose the minimal amount of work done while
867 * still freeing memory.
868 */
David Rientjes6b0c81b2012-07-31 16:43:45 -0700869 read_lock(&tasklist_lock);
Shakeel Butt274be582019-02-01 14:20:54 -0800870
871 /*
872 * The task 'p' might have already exited before reaching here. The
873 * put_task_struct() will free task_struct 'p' while the loop still try
874 * to access the field of 'p', so, get an extra reference.
875 */
876 get_task_struct(p);
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800877 for_each_thread(p, t) {
David Rientjes5e9d8342010-08-09 17:18:51 -0700878 list_for_each_entry(child, &t->children, sibling) {
David Rientjesa63d83f2010-08-09 17:19:46 -0700879 unsigned int child_points;
David Rientjes5e9d8342010-08-09 17:18:51 -0700880
Oleg Nesterov4d7b3392015-11-05 18:48:26 -0800881 if (process_shares_mm(child, p->mm))
David Rientjesedd45542011-03-22 16:30:12 -0700882 continue;
David Rientjesa63d83f2010-08-09 17:19:46 -0700883 /*
884 * oom_badness() returns 0 if the thread is unkillable
885 */
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700886 child_points = oom_badness(child,
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700887 oc->memcg, oc->nodemask, oc->totalpages);
David Rientjes5e9d8342010-08-09 17:18:51 -0700888 if (child_points > victim_points) {
David Rientjes6b0c81b2012-07-31 16:43:45 -0700889 put_task_struct(victim);
David Rientjes5e9d8342010-08-09 17:18:51 -0700890 victim = child;
891 victim_points = child_points;
David Rientjes6b0c81b2012-07-31 16:43:45 -0700892 get_task_struct(victim);
David Rientjes5e9d8342010-08-09 17:18:51 -0700893 }
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700894 }
Oleg Nesterov1da4db02014-01-21 15:49:58 -0800895 }
Shakeel Butt274be582019-02-01 14:20:54 -0800896 put_task_struct(p);
David Rientjes6b0c81b2012-07-31 16:43:45 -0700897 read_unlock(&tasklist_lock);
Oleg Nesterovdd8e8f42010-08-09 17:18:45 -0700898
David Rientjes6b0c81b2012-07-31 16:43:45 -0700899 p = find_lock_task_mm(victim);
900 if (!p) {
David Rientjes6b0c81b2012-07-31 16:43:45 -0700901 put_task_struct(victim);
David Rientjes647f2bd2012-03-21 16:33:46 -0700902 return;
David Rientjes6b0c81b2012-07-31 16:43:45 -0700903 } else if (victim != p) {
904 get_task_struct(p);
905 put_task_struct(victim);
906 victim = p;
907 }
David Rientjes647f2bd2012-03-21 16:33:46 -0700908
Tetsuo Handa880b7682015-11-05 18:47:51 -0800909 /* Get a reference to safely compare mm after task_unlock(victim) */
David Rientjes647f2bd2012-03-21 16:33:46 -0700910 mm = victim->mm;
Tetsuo Handa880b7682015-11-05 18:47:51 -0800911 atomic_inc(&mm->mm_count);
Tetsuo Handa426fb5e2015-11-05 18:47:44 -0800912 /*
913 * We should send SIGKILL before setting TIF_MEMDIE in order to prevent
914 * the OOM victim from depleting the memory reserves from the user
915 * space under its control.
916 */
917 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
Johannes Weiner16e95192015-06-24 16:57:07 -0700918 mark_oom_victim(victim);
Jerome Marchandeca56ff2016-01-14 15:19:26 -0800919 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 -0700920 task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
921 K(get_mm_counter(victim->mm, MM_ANONPAGES)),
Jerome Marchandeca56ff2016-01-14 15:19:26 -0800922 K(get_mm_counter(victim->mm, MM_FILEPAGES)),
923 K(get_mm_counter(victim->mm, MM_SHMEMPAGES)));
David Rientjes647f2bd2012-03-21 16:33:46 -0700924 task_unlock(victim);
925
926 /*
927 * Kill all user processes sharing victim->mm in other thread groups, if
928 * any. They don't get access to memory reserves, though, to avoid
929 * depletion of all memory. This prevents mm->mmap_sem livelock when an
930 * oom killed thread cannot exit because it requires the semaphore and
931 * its contended by another thread trying to allocate memory itself.
932 * That thread will now get access to memory reserves since it has a
933 * pending fatal signal.
934 */
Oleg Nesterov4d4048b2014-01-21 15:50:01 -0800935 rcu_read_lock();
Oleg Nesterovc3190252015-11-05 18:48:23 -0800936 for_each_process(p) {
Oleg Nesterov4d7b3392015-11-05 18:48:26 -0800937 if (!process_shares_mm(p, mm))
Oleg Nesterovc3190252015-11-05 18:48:23 -0800938 continue;
939 if (same_thread_group(p, victim))
940 continue;
Michal Hocko1b51e652016-10-07 16:59:09 -0700941 if (is_global_init(p)) {
Michal Hockoaac45362016-03-25 14:20:24 -0700942 can_oom_reap = false;
Michal Hocko862e3072016-10-07 16:58:57 -0700943 set_bit(MMF_OOM_SKIP, &mm->flags);
Michal Hockoa3739662016-07-28 15:45:01 -0700944 pr_info("oom killer %d (%s) has mm pinned by %d (%s)\n",
945 task_pid_nr(victim), victim->comm,
946 task_pid_nr(p), p->comm);
Oleg Nesterovc3190252015-11-05 18:48:23 -0800947 continue;
Michal Hockoaac45362016-03-25 14:20:24 -0700948 }
Michal Hocko1b51e652016-10-07 16:59:09 -0700949 /*
950 * No use_mm() user needs to read from the userspace so we are
951 * ok to reap it.
952 */
953 if (unlikely(p->flags & PF_KTHREAD))
954 continue;
Oleg Nesterovc3190252015-11-05 18:48:23 -0800955 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true);
956 }
David Rientjes6b0c81b2012-07-31 16:43:45 -0700957 rcu_read_unlock();
David Rientjes647f2bd2012-03-21 16:33:46 -0700958
Michal Hockoaac45362016-03-25 14:20:24 -0700959 if (can_oom_reap)
Michal Hocko36324a92016-03-25 14:20:27 -0700960 wake_oom_reaper(victim);
Michal Hockoaac45362016-03-25 14:20:24 -0700961
Tetsuo Handa880b7682015-11-05 18:47:51 -0800962 mmdrop(mm);
David Rientjes6b0c81b2012-07-31 16:43:45 -0700963 put_task_struct(victim);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964}
David Rientjes647f2bd2012-03-21 16:33:46 -0700965#undef K
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
David Rientjes309ed882010-08-09 17:18:54 -0700967/*
968 * Determines whether the kernel must panic because of the panic_on_oom sysctl.
969 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -0700970static void check_panic_on_oom(struct oom_control *oc,
971 enum oom_constraint constraint)
David Rientjes309ed882010-08-09 17:18:54 -0700972{
973 if (likely(!sysctl_panic_on_oom))
974 return;
975 if (sysctl_panic_on_oom != 2) {
976 /*
977 * panic_on_oom == 1 only affects CONSTRAINT_NONE, the kernel
978 * does not panic for cpuset, mempolicy, or memcg allocation
979 * failures.
980 */
981 if (constraint != CONSTRAINT_NONE)
982 return;
983 }
David Rientjes071a4be2015-09-08 15:00:42 -0700984 /* Do not panic for oom kills triggered by sysrq */
Yaowei Baidb2a0dd2015-11-06 16:28:06 -0800985 if (is_sysrq_oom(oc))
David Rientjes071a4be2015-09-08 15:00:42 -0700986 return;
Vladimir Davydov2a966b72016-07-26 15:22:33 -0700987 dump_header(oc, NULL);
David Rientjes309ed882010-08-09 17:18:54 -0700988 panic("Out of memory: %s panic_on_oom is enabled\n",
989 sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide");
990}
991
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -0700992static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
993
994int register_oom_notifier(struct notifier_block *nb)
995{
996 return blocking_notifier_chain_register(&oom_notify_list, nb);
997}
998EXPORT_SYMBOL_GPL(register_oom_notifier);
999
1000int unregister_oom_notifier(struct notifier_block *nb)
1001{
1002 return blocking_notifier_chain_unregister(&oom_notify_list, nb);
1003}
1004EXPORT_SYMBOL_GPL(unregister_oom_notifier);
1005
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006/**
David Rientjes6e0fc462015-09-08 15:00:36 -07001007 * out_of_memory - kill the "best" process when we run out of memory
1008 * @oc: pointer to struct oom_control
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 *
1010 * If we run out of memory, we have the choice between either
1011 * killing a random task (bad), letting the system crash (worse)
1012 * OR try to be smart about which process to kill. Note that we
1013 * don't have to be perfect here, we just have to be good.
1014 */
David Rientjes6e0fc462015-09-08 15:00:36 -07001015bool out_of_memory(struct oom_control *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016{
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -07001017 unsigned long freed = 0;
David Rientjese3658932010-08-09 17:18:55 -07001018 enum oom_constraint constraint = CONSTRAINT_NONE;
Martin Schwidefsky8bc719d2006-09-25 23:31:20 -07001019
Johannes Weinerdc564012015-06-24 16:57:19 -07001020 if (oom_killer_disabled)
1021 return false;
1022
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001023 if (!is_memcg_oom(oc)) {
1024 blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
1025 if (freed > 0)
1026 /* Got some memory back in the last second. */
1027 return true;
1028 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
David Rientjes7b98c2e2010-08-09 17:18:48 -07001030 /*
David Rientjes9ff48682012-12-11 16:01:30 -08001031 * If current has a pending SIGKILL or is exiting, then automatically
1032 * select it. The goal is to allow it to allocate so that it may
1033 * quickly exit and free its memory.
David Rientjes7b98c2e2010-08-09 17:18:48 -07001034 */
Michal Hocko091f3622016-07-28 15:45:04 -07001035 if (task_will_free_mem(current)) {
Johannes Weiner16e95192015-06-24 16:57:07 -07001036 mark_oom_victim(current);
Michal Hocko1af8bb42016-07-28 15:44:52 -07001037 wake_oom_reaper(current);
David Rientjes75e8f8b2015-09-08 15:00:47 -07001038 return true;
David Rientjes7b98c2e2010-08-09 17:18:48 -07001039 }
1040
Christoph Lameter9b0f8b02006-02-20 18:27:52 -08001041 /*
Michal Hocko3da88fb2016-05-19 17:13:09 -07001042 * The OOM killer does not compensate for IO-less reclaim.
1043 * pagefault_out_of_memory lost its gfp context so we have to
1044 * make sure exclude 0 mask - all other users should have at least
1045 * ___GFP_DIRECT_RECLAIM to get here.
1046 */
1047 if (oc->gfp_mask && !(oc->gfp_mask & (__GFP_FS|__GFP_NOFAIL)))
1048 return true;
1049
1050 /*
Christoph Lameter9b0f8b02006-02-20 18:27:52 -08001051 * Check if there were limitations on the allocation (only relevant for
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001052 * NUMA and memcg) that may require different handling.
Christoph Lameter9b0f8b02006-02-20 18:27:52 -08001053 */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001054 constraint = constrained_alloc(oc);
David Rientjes6e0fc462015-09-08 15:00:36 -07001055 if (constraint != CONSTRAINT_MEMORY_POLICY)
1056 oc->nodemask = NULL;
Vladimir Davydov2a966b72016-07-26 15:22:33 -07001057 check_panic_on_oom(oc, constraint);
David Rientjes0aad4b32010-08-09 17:18:59 -07001058
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001059 if (!is_memcg_oom(oc) && sysctl_oom_kill_allocating_task &&
1060 current->mm && !oom_unkillable_task(current, NULL, oc->nodemask) &&
David Rientjes121d1ba2012-07-31 16:42:55 -07001061 current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) {
David Rientjes6b0c81b2012-07-31 16:43:45 -07001062 get_task_struct(current);
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001063 oc->chosen = current;
1064 oom_kill_process(oc, "Out of memory (oom_kill_allocating_task)");
David Rientjes75e8f8b2015-09-08 15:00:47 -07001065 return true;
David Rientjes0aad4b32010-08-09 17:18:59 -07001066 }
1067
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001068 select_bad_process(oc);
David Rientjes0aad4b32010-08-09 17:18:59 -07001069 /* Found nothing?!?! Either we hang forever, or we panic. */
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001070 if (!oc->chosen && !is_sysrq_oom(oc) && !is_memcg_oom(oc)) {
Vladimir Davydov2a966b72016-07-26 15:22:33 -07001071 dump_header(oc, NULL);
David Rientjes0aad4b32010-08-09 17:18:59 -07001072 panic("Out of memory and no killable processes...\n");
1073 }
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001074 if (oc->chosen && oc->chosen != (void *)-1UL) {
1075 oom_kill_process(oc, !is_memcg_oom(oc) ? "Out of memory" :
1076 "Memory cgroup out of memory");
David Rientjes75e8f8b2015-09-08 15:00:47 -07001077 /*
1078 * Give the killed process a good chance to exit before trying
1079 * to allocate memory again.
1080 */
David Rientjes4f774b92012-07-31 16:42:37 -07001081 schedule_timeout_killable(1);
David Rientjes75e8f8b2015-09-08 15:00:47 -07001082 }
Vladimir Davydov7c5f64f2016-10-07 16:57:23 -07001083 return !!oc->chosen;
Michal Hockoc32b3cb2015-02-11 15:26:24 -08001084}
1085
David Rientjese3658932010-08-09 17:18:55 -07001086/*
1087 * The pagefault handler calls here because it is out of memory, so kill a
Vladimir Davydov798fd752016-07-26 15:22:30 -07001088 * memory-hogging task. If oom_lock is held by somebody else, a parallel oom
1089 * killing is already in progress so do nothing.
David Rientjese3658932010-08-09 17:18:55 -07001090 */
1091void pagefault_out_of_memory(void)
1092{
David Rientjes6e0fc462015-09-08 15:00:36 -07001093 struct oom_control oc = {
1094 .zonelist = NULL,
1095 .nodemask = NULL,
Vladimir Davydov2a966b72016-07-26 15:22:33 -07001096 .memcg = NULL,
David Rientjes6e0fc462015-09-08 15:00:36 -07001097 .gfp_mask = 0,
1098 .order = 0,
David Rientjes6e0fc462015-09-08 15:00:36 -07001099 };
1100
Johannes Weiner49426422013-10-16 13:46:59 -07001101 if (mem_cgroup_oom_synchronize(true))
Johannes Weinerdc564012015-06-24 16:57:19 -07001102 return;
Johannes Weiner3812c8c2013-09-12 15:13:44 -07001103
Johannes Weinerdc564012015-06-24 16:57:19 -07001104 if (!mutex_trylock(&oom_lock))
1105 return;
Tetsuo Handaa1048082016-10-07 17:00:49 -07001106 out_of_memory(&oc);
Johannes Weinerdc564012015-06-24 16:57:19 -07001107 mutex_unlock(&oom_lock);
David Rientjese3658932010-08-09 17:18:55 -07001108}
Charan Teja Reddyf9920cf2018-05-01 20:20:20 +05301109
1110void add_to_oom_reaper(struct task_struct *p)
1111 __releases(p->alloc_lock)
1112{
1113 if (!sysctl_reap_mem_on_sigkill)
1114 return;
1115
1116 p = find_lock_task_mm(p);
1117 if (!p)
1118 return;
1119
1120 get_task_struct(p);
1121 if (task_will_free_mem(p)) {
1122 __mark_oom_victim(p);
1123 wake_oom_reaper(p);
1124 }
1125 task_unlock(p);
1126 put_task_struct(p);
1127}