oom_kill.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738
  1. /*
  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...
  7. * Copyright (C) 2010 Google, Inc.
  8. * Rewritten by David Rientjes
  9. *
  10. * The routines in this file are used to kill a process when
  11. * we're seriously out of memory. This gets called from __alloc_pages()
  12. * in mm/page_alloc.c when we really run out of memory.
  13. *
  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. #include <linux/oom.h>
  20. #include <linux/mm.h>
  21. #include <linux/err.h>
  22. #include <linux/gfp.h>
  23. #include <linux/sched.h>
  24. #include <linux/swap.h>
  25. #include <linux/timex.h>
  26. #include <linux/jiffies.h>
  27. #include <linux/cpuset.h>
  28. #include <linux/export.h>
  29. #include <linux/notifier.h>
  30. #include <linux/memcontrol.h>
  31. #include <linux/mempolicy.h>
  32. #include <linux/security.h>
  33. #include <linux/ptrace.h>
  34. #include <linux/freezer.h>
  35. #include <linux/ftrace.h>
  36. #include <linux/ratelimit.h>
  37. #define CREATE_TRACE_POINTS
  38. #include <trace/events/oom.h>
  39. int sysctl_panic_on_oom;
  40. int sysctl_oom_kill_allocating_task;
  41. int sysctl_oom_dump_tasks = 1;
  42. DEFINE_MUTEX(oom_lock);
  43. #ifdef CONFIG_NUMA
  44. /**
  45. * has_intersects_mems_allowed() - check task eligiblity for kill
  46. * @start: task struct of which task to consider
  47. * @mask: nodemask passed to page allocator for mempolicy ooms
  48. *
  49. * Task eligibility is determined by whether or not a candidate task, @tsk,
  50. * shares the same mempolicy nodes as current if it is bound by such a policy
  51. * and whether or not it has the same set of allowed cpuset nodes.
  52. */
  53. static bool has_intersects_mems_allowed(struct task_struct *start,
  54. const nodemask_t *mask)
  55. {
  56. struct task_struct *tsk;
  57. bool ret = false;
  58. rcu_read_lock();
  59. for_each_thread(start, tsk) {
  60. if (mask) {
  61. /*
  62. * If this is a mempolicy constrained oom, tsk's
  63. * cpuset is irrelevant. Only return true if its
  64. * mempolicy intersects current, otherwise it may be
  65. * needlessly killed.
  66. */
  67. ret = mempolicy_nodemask_intersects(tsk, mask);
  68. } else {
  69. /*
  70. * This is not a mempolicy constrained oom, so only
  71. * check the mems of tsk's cpuset.
  72. */
  73. ret = cpuset_mems_allowed_intersects(current, tsk);
  74. }
  75. if (ret)
  76. break;
  77. }
  78. rcu_read_unlock();
  79. return ret;
  80. }
  81. #else
  82. static bool has_intersects_mems_allowed(struct task_struct *tsk,
  83. const nodemask_t *mask)
  84. {
  85. return true;
  86. }
  87. #endif /* CONFIG_NUMA */
  88. /*
  89. * The process p may have detached its own ->mm while exiting or through
  90. * use_mm(), but one or more of its subthreads may still have a valid
  91. * pointer. Return p, or any of its subthreads with a valid ->mm, with
  92. * task_lock() held.
  93. */
  94. struct task_struct *find_lock_task_mm(struct task_struct *p)
  95. {
  96. struct task_struct *t;
  97. rcu_read_lock();
  98. for_each_thread(p, t) {
  99. task_lock(t);
  100. if (likely(t->mm))
  101. goto found;
  102. task_unlock(t);
  103. }
  104. t = NULL;
  105. found:
  106. rcu_read_unlock();
  107. return t;
  108. }
  109. /* return true if the task is not adequate as candidate victim task. */
  110. static bool oom_unkillable_task(struct task_struct *p,
  111. struct mem_cgroup *memcg, const nodemask_t *nodemask)
  112. {
  113. if (is_global_init(p))
  114. return true;
  115. if (p->flags & PF_KTHREAD)
  116. return true;
  117. /* When mem_cgroup_out_of_memory() and p is not member of the group */
  118. if (memcg && !task_in_mem_cgroup(p, memcg))
  119. return true;
  120. /* p may not have freeable memory in nodemask */
  121. if (!has_intersects_mems_allowed(p, nodemask))
  122. return true;
  123. return false;
  124. }
  125. /**
  126. * oom_badness - heuristic function to determine which candidate task to kill
  127. * @p: task struct of which task we should calculate
  128. * @totalpages: total present RAM allowed for page allocation
  129. *
  130. * The heuristic for determining which task to kill is made to be as simple and
  131. * predictable as possible. The goal is to return the highest value for the
  132. * task consuming the most memory to avoid subsequent oom failures.
  133. */
  134. unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,
  135. const nodemask_t *nodemask, unsigned long totalpages)
  136. {
  137. long points;
  138. long adj;
  139. if (oom_unkillable_task(p, memcg, nodemask))
  140. return 0;
  141. p = find_lock_task_mm(p);
  142. if (!p)
  143. return 0;
  144. adj = (long)p->signal->oom_score_adj;
  145. if (adj == OOM_SCORE_ADJ_MIN) {
  146. task_unlock(p);
  147. return 0;
  148. }
  149. /*
  150. * The baseline for the badness score is the proportion of RAM that each
  151. * task's rss, pagetable and swap space use.
  152. */
  153. points = get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) +
  154. atomic_long_read(&p->mm->nr_ptes) + mm_nr_pmds(p->mm);
  155. task_unlock(p);
  156. /*
  157. * Root processes get 3% bonus, just like the __vm_enough_memory()
  158. * implementation used by LSMs.
  159. */
  160. if (has_capability_noaudit(p, CAP_SYS_ADMIN))
  161. points -= (points * 3) / 100;
  162. /* Normalize to oom_score_adj units */
  163. adj *= totalpages / 1000;
  164. points += adj;
  165. /*
  166. * Never return 0 for an eligible task regardless of the root bonus and
  167. * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here).
  168. */
  169. return points > 0 ? points : 1;
  170. }
  171. /*
  172. * Determine the type of allocation constraint.
  173. */
  174. #ifdef CONFIG_NUMA
  175. static enum oom_constraint constrained_alloc(struct oom_control *oc,
  176. unsigned long *totalpages)
  177. {
  178. struct zone *zone;
  179. struct zoneref *z;
  180. enum zone_type high_zoneidx = gfp_zone(oc->gfp_mask);
  181. bool cpuset_limited = false;
  182. int nid;
  183. /* Default to all available memory */
  184. *totalpages = totalram_pages + total_swap_pages;
  185. if (!oc->zonelist)
  186. return CONSTRAINT_NONE;
  187. /*
  188. * Reach here only when __GFP_NOFAIL is used. So, we should avoid
  189. * to kill current.We have to random task kill in this case.
  190. * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now.
  191. */
  192. if (oc->gfp_mask & __GFP_THISNODE)
  193. return CONSTRAINT_NONE;
  194. /*
  195. * This is not a __GFP_THISNODE allocation, so a truncated nodemask in
  196. * the page allocator means a mempolicy is in effect. Cpuset policy
  197. * is enforced in get_page_from_freelist().
  198. */
  199. if (oc->nodemask &&
  200. !nodes_subset(node_states[N_MEMORY], *oc->nodemask)) {
  201. *totalpages = total_swap_pages;
  202. for_each_node_mask(nid, *oc->nodemask)
  203. *totalpages += node_spanned_pages(nid);
  204. return CONSTRAINT_MEMORY_POLICY;
  205. }
  206. /* Check this allocation failure is caused by cpuset's wall function */
  207. for_each_zone_zonelist_nodemask(zone, z, oc->zonelist,
  208. high_zoneidx, oc->nodemask)
  209. if (!cpuset_zone_allowed(zone, oc->gfp_mask))
  210. cpuset_limited = true;
  211. if (cpuset_limited) {
  212. *totalpages = total_swap_pages;
  213. for_each_node_mask(nid, cpuset_current_mems_allowed)
  214. *totalpages += node_spanned_pages(nid);
  215. return CONSTRAINT_CPUSET;
  216. }
  217. return CONSTRAINT_NONE;
  218. }
  219. #else
  220. static enum oom_constraint constrained_alloc(struct oom_control *oc,
  221. unsigned long *totalpages)
  222. {
  223. *totalpages = totalram_pages + total_swap_pages;
  224. return CONSTRAINT_NONE;
  225. }
  226. #endif
  227. enum oom_scan_t oom_scan_process_thread(struct oom_control *oc,
  228. struct task_struct *task, unsigned long totalpages)
  229. {
  230. if (oom_unkillable_task(task, NULL, oc->nodemask))
  231. return OOM_SCAN_CONTINUE;
  232. /*
  233. * This task already has access to memory reserves and is being killed.
  234. * Don't allow any other task to have access to the reserves.
  235. */
  236. if (test_tsk_thread_flag(task, TIF_MEMDIE)) {
  237. if (oc->order != -1)
  238. return OOM_SCAN_ABORT;
  239. }
  240. if (!task->mm)
  241. return OOM_SCAN_CONTINUE;
  242. /*
  243. * If task is allocating a lot of memory and has been marked to be
  244. * killed first if it triggers an oom, then select it.
  245. */
  246. if (oom_task_origin(task))
  247. return OOM_SCAN_SELECT;
  248. if (task_will_free_mem(task) && oc->order != -1)
  249. return OOM_SCAN_ABORT;
  250. return OOM_SCAN_OK;
  251. }
  252. /*
  253. * Simple selection loop. We chose the process with the highest
  254. * number of 'points'. Returns -1 on scan abort.
  255. */
  256. static struct task_struct *select_bad_process(struct oom_control *oc,
  257. unsigned int *ppoints, unsigned long totalpages)
  258. {
  259. struct task_struct *g, *p;
  260. struct task_struct *chosen = NULL;
  261. unsigned long chosen_points = 0;
  262. rcu_read_lock();
  263. for_each_process_thread(g, p) {
  264. unsigned int points;
  265. switch (oom_scan_process_thread(oc, p, totalpages)) {
  266. case OOM_SCAN_SELECT:
  267. chosen = p;
  268. chosen_points = ULONG_MAX;
  269. /* fall through */
  270. case OOM_SCAN_CONTINUE:
  271. continue;
  272. case OOM_SCAN_ABORT:
  273. rcu_read_unlock();
  274. return (struct task_struct *)(-1UL);
  275. case OOM_SCAN_OK:
  276. break;
  277. };
  278. points = oom_badness(p, NULL, oc->nodemask, totalpages);
  279. if (!points || points < chosen_points)
  280. continue;
  281. /* Prefer thread group leaders for display purposes */
  282. if (points == chosen_points && thread_group_leader(chosen))
  283. continue;
  284. chosen = p;
  285. chosen_points = points;
  286. }
  287. if (chosen)
  288. get_task_struct(chosen);
  289. rcu_read_unlock();
  290. *ppoints = chosen_points * 1000 / totalpages;
  291. return chosen;
  292. }
  293. /**
  294. * dump_tasks - dump current memory state of all system tasks
  295. * @memcg: current's memory controller, if constrained
  296. * @nodemask: nodemask passed to page allocator for mempolicy ooms
  297. *
  298. * Dumps the current memory state of all eligible tasks. Tasks not in the same
  299. * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes
  300. * are not shown.
  301. * State information includes task's pid, uid, tgid, vm size, rss, nr_ptes,
  302. * swapents, oom_score_adj value, and name.
  303. */
  304. static void dump_tasks(struct mem_cgroup *memcg, const nodemask_t *nodemask)
  305. {
  306. struct task_struct *p;
  307. struct task_struct *task;
  308. pr_info("[ pid ] uid tgid total_vm rss nr_ptes nr_pmds swapents oom_score_adj name\n");
  309. rcu_read_lock();
  310. for_each_process(p) {
  311. if (oom_unkillable_task(p, memcg, nodemask))
  312. continue;
  313. task = find_lock_task_mm(p);
  314. if (!task) {
  315. /*
  316. * This is a kthread or all of p's threads have already
  317. * detached their mm's. There's no need to report
  318. * them; they can't be oom killed anyway.
  319. */
  320. continue;
  321. }
  322. pr_info("[%5d] %5d %5d %8lu %8lu %7ld %7ld %8lu %5hd %s\n",
  323. task->pid, from_kuid(&init_user_ns, task_uid(task)),
  324. task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
  325. atomic_long_read(&task->mm->nr_ptes),
  326. mm_nr_pmds(task->mm),
  327. get_mm_counter(task->mm, MM_SWAPENTS),
  328. task->signal->oom_score_adj, task->comm);
  329. task_unlock(task);
  330. }
  331. rcu_read_unlock();
  332. }
  333. static void dump_header(struct oom_control *oc, struct task_struct *p,
  334. struct mem_cgroup *memcg)
  335. {
  336. task_lock(current);
  337. pr_warning("%s invoked oom-killer: gfp_mask=0x%x, order=%d, "
  338. "oom_score_adj=%hd\n",
  339. current->comm, oc->gfp_mask, oc->order,
  340. current->signal->oom_score_adj);
  341. cpuset_print_task_mems_allowed(current);
  342. task_unlock(current);
  343. dump_stack();
  344. if (memcg)
  345. mem_cgroup_print_oom_info(memcg, p);
  346. else
  347. show_mem(SHOW_MEM_FILTER_NODES);
  348. if (sysctl_oom_dump_tasks)
  349. dump_tasks(memcg, oc->nodemask);
  350. }
  351. /*
  352. * Number of OOM victims in flight
  353. */
  354. static atomic_t oom_victims = ATOMIC_INIT(0);
  355. static DECLARE_WAIT_QUEUE_HEAD(oom_victims_wait);
  356. bool oom_killer_disabled __read_mostly;
  357. /**
  358. * mark_oom_victim - mark the given task as OOM victim
  359. * @tsk: task to mark
  360. *
  361. * Has to be called with oom_lock held and never after
  362. * oom has been disabled already.
  363. */
  364. void mark_oom_victim(struct task_struct *tsk)
  365. {
  366. WARN_ON(oom_killer_disabled);
  367. /* OOM killer might race with memcg OOM */
  368. if (test_and_set_tsk_thread_flag(tsk, TIF_MEMDIE))
  369. return;
  370. /*
  371. * Make sure that the task is woken up from uninterruptible sleep
  372. * if it is frozen because OOM killer wouldn't be able to free
  373. * any memory and livelock. freezing_slow_path will tell the freezer
  374. * that TIF_MEMDIE tasks should be ignored.
  375. */
  376. __thaw_task(tsk);
  377. atomic_inc(&oom_victims);
  378. }
  379. /**
  380. * exit_oom_victim - note the exit of an OOM victim
  381. */
  382. void exit_oom_victim(void)
  383. {
  384. clear_thread_flag(TIF_MEMDIE);
  385. if (!atomic_dec_return(&oom_victims))
  386. wake_up_all(&oom_victims_wait);
  387. }
  388. /**
  389. * oom_killer_disable - disable OOM killer
  390. *
  391. * Forces all page allocations to fail rather than trigger OOM killer.
  392. * Will block and wait until all OOM victims are killed.
  393. *
  394. * The function cannot be called when there are runnable user tasks because
  395. * the userspace would see unexpected allocation failures as a result. Any
  396. * new usage of this function should be consulted with MM people.
  397. *
  398. * Returns true if successful and false if the OOM killer cannot be
  399. * disabled.
  400. */
  401. bool oom_killer_disable(void)
  402. {
  403. /*
  404. * Make sure to not race with an ongoing OOM killer
  405. * and that the current is not the victim.
  406. */
  407. mutex_lock(&oom_lock);
  408. if (test_thread_flag(TIF_MEMDIE)) {
  409. mutex_unlock(&oom_lock);
  410. return false;
  411. }
  412. oom_killer_disabled = true;
  413. mutex_unlock(&oom_lock);
  414. wait_event(oom_victims_wait, !atomic_read(&oom_victims));
  415. return true;
  416. }
  417. /**
  418. * oom_killer_enable - enable OOM killer
  419. */
  420. void oom_killer_enable(void)
  421. {
  422. oom_killer_disabled = false;
  423. }
  424. #define K(x) ((x) << (PAGE_SHIFT-10))
  425. /*
  426. * Must be called while holding a reference to p, which will be released upon
  427. * returning.
  428. */
  429. void oom_kill_process(struct oom_control *oc, struct task_struct *p,
  430. unsigned int points, unsigned long totalpages,
  431. struct mem_cgroup *memcg, const char *message)
  432. {
  433. struct task_struct *victim = p;
  434. struct task_struct *child;
  435. struct task_struct *t;
  436. struct mm_struct *mm;
  437. unsigned int victim_points = 0;
  438. static DEFINE_RATELIMIT_STATE(oom_rs, DEFAULT_RATELIMIT_INTERVAL,
  439. DEFAULT_RATELIMIT_BURST);
  440. /*
  441. * If the task is already exiting, don't alarm the sysadmin or kill
  442. * its children or threads, just set TIF_MEMDIE so it can die quickly
  443. */
  444. task_lock(p);
  445. if (p->mm && task_will_free_mem(p)) {
  446. mark_oom_victim(p);
  447. task_unlock(p);
  448. put_task_struct(p);
  449. return;
  450. }
  451. task_unlock(p);
  452. if (__ratelimit(&oom_rs))
  453. dump_header(oc, p, memcg);
  454. task_lock(p);
  455. pr_err("%s: Kill process %d (%s) score %u or sacrifice child\n",
  456. message, task_pid_nr(p), p->comm, points);
  457. task_unlock(p);
  458. /*
  459. * If any of p's children has a different mm and is eligible for kill,
  460. * the one with the highest oom_badness() score is sacrificed for its
  461. * parent. This attempts to lose the minimal amount of work done while
  462. * still freeing memory.
  463. */
  464. read_lock(&tasklist_lock);
  465. for_each_thread(p, t) {
  466. list_for_each_entry(child, &t->children, sibling) {
  467. unsigned int child_points;
  468. if (child->mm == p->mm)
  469. continue;
  470. /*
  471. * oom_badness() returns 0 if the thread is unkillable
  472. */
  473. child_points = oom_badness(child, memcg, oc->nodemask,
  474. totalpages);
  475. if (child_points > victim_points) {
  476. put_task_struct(victim);
  477. victim = child;
  478. victim_points = child_points;
  479. get_task_struct(victim);
  480. }
  481. }
  482. }
  483. read_unlock(&tasklist_lock);
  484. p = find_lock_task_mm(victim);
  485. if (!p) {
  486. put_task_struct(victim);
  487. return;
  488. } else if (victim != p) {
  489. get_task_struct(p);
  490. put_task_struct(victim);
  491. victim = p;
  492. }
  493. /* mm cannot safely be dereferenced after task_unlock(victim) */
  494. mm = victim->mm;
  495. mark_oom_victim(victim);
  496. pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB\n",
  497. task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
  498. K(get_mm_counter(victim->mm, MM_ANONPAGES)),
  499. K(get_mm_counter(victim->mm, MM_FILEPAGES)));
  500. task_unlock(victim);
  501. /*
  502. * Kill all user processes sharing victim->mm in other thread groups, if
  503. * any. They don't get access to memory reserves, though, to avoid
  504. * depletion of all memory. This prevents mm->mmap_sem livelock when an
  505. * oom killed thread cannot exit because it requires the semaphore and
  506. * its contended by another thread trying to allocate memory itself.
  507. * That thread will now get access to memory reserves since it has a
  508. * pending fatal signal.
  509. */
  510. rcu_read_lock();
  511. for_each_process(p)
  512. if (p->mm == mm && !same_thread_group(p, victim) &&
  513. !(p->flags & PF_KTHREAD)) {
  514. if (p->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
  515. continue;
  516. task_lock(p); /* Protect ->comm from prctl() */
  517. pr_err("Kill process %d (%s) sharing same memory\n",
  518. task_pid_nr(p), p->comm);
  519. task_unlock(p);
  520. do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true);
  521. }
  522. rcu_read_unlock();
  523. do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
  524. put_task_struct(victim);
  525. }
  526. #undef K
  527. /*
  528. * Determines whether the kernel must panic because of the panic_on_oom sysctl.
  529. */
  530. void check_panic_on_oom(struct oom_control *oc, enum oom_constraint constraint,
  531. struct mem_cgroup *memcg)
  532. {
  533. if (likely(!sysctl_panic_on_oom))
  534. return;
  535. if (sysctl_panic_on_oom != 2) {
  536. /*
  537. * panic_on_oom == 1 only affects CONSTRAINT_NONE, the kernel
  538. * does not panic for cpuset, mempolicy, or memcg allocation
  539. * failures.
  540. */
  541. if (constraint != CONSTRAINT_NONE)
  542. return;
  543. }
  544. /* Do not panic for oom kills triggered by sysrq */
  545. if (oc->order == -1)
  546. return;
  547. dump_header(oc, NULL, memcg);
  548. panic("Out of memory: %s panic_on_oom is enabled\n",
  549. sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide");
  550. }
  551. static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
  552. int register_oom_notifier(struct notifier_block *nb)
  553. {
  554. return blocking_notifier_chain_register(&oom_notify_list, nb);
  555. }
  556. EXPORT_SYMBOL_GPL(register_oom_notifier);
  557. int unregister_oom_notifier(struct notifier_block *nb)
  558. {
  559. return blocking_notifier_chain_unregister(&oom_notify_list, nb);
  560. }
  561. EXPORT_SYMBOL_GPL(unregister_oom_notifier);
  562. /**
  563. * out_of_memory - kill the "best" process when we run out of memory
  564. * @oc: pointer to struct oom_control
  565. *
  566. * If we run out of memory, we have the choice between either
  567. * killing a random task (bad), letting the system crash (worse)
  568. * OR try to be smart about which process to kill. Note that we
  569. * don't have to be perfect here, we just have to be good.
  570. */
  571. bool out_of_memory(struct oom_control *oc)
  572. {
  573. struct task_struct *p;
  574. unsigned long totalpages;
  575. unsigned long freed = 0;
  576. unsigned int uninitialized_var(points);
  577. enum oom_constraint constraint = CONSTRAINT_NONE;
  578. if (oom_killer_disabled)
  579. return false;
  580. blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
  581. if (freed > 0)
  582. /* Got some memory back in the last second. */
  583. return true;
  584. /*
  585. * If current has a pending SIGKILL or is exiting, then automatically
  586. * select it. The goal is to allow it to allocate so that it may
  587. * quickly exit and free its memory.
  588. *
  589. * But don't select if current has already released its mm and cleared
  590. * TIF_MEMDIE flag at exit_mm(), otherwise an OOM livelock may occur.
  591. */
  592. if (current->mm &&
  593. (fatal_signal_pending(current) || task_will_free_mem(current))) {
  594. mark_oom_victim(current);
  595. return true;
  596. }
  597. /*
  598. * Check if there were limitations on the allocation (only relevant for
  599. * NUMA) that may require different handling.
  600. */
  601. constraint = constrained_alloc(oc, &totalpages);
  602. if (constraint != CONSTRAINT_MEMORY_POLICY)
  603. oc->nodemask = NULL;
  604. check_panic_on_oom(oc, constraint, NULL);
  605. if (sysctl_oom_kill_allocating_task && current->mm &&
  606. !oom_unkillable_task(current, NULL, oc->nodemask) &&
  607. current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) {
  608. get_task_struct(current);
  609. oom_kill_process(oc, current, 0, totalpages, NULL,
  610. "Out of memory (oom_kill_allocating_task)");
  611. return true;
  612. }
  613. p = select_bad_process(oc, &points, totalpages);
  614. /* Found nothing?!?! Either we hang forever, or we panic. */
  615. if (!p && oc->order != -1) {
  616. dump_header(oc, NULL, NULL);
  617. panic("Out of memory and no killable processes...\n");
  618. }
  619. if (p && p != (void *)-1UL) {
  620. oom_kill_process(oc, p, points, totalpages, NULL,
  621. "Out of memory");
  622. /*
  623. * Give the killed process a good chance to exit before trying
  624. * to allocate memory again.
  625. */
  626. schedule_timeout_killable(1);
  627. }
  628. return true;
  629. }
  630. /*
  631. * The pagefault handler calls here because it is out of memory, so kill a
  632. * memory-hogging task. If any populated zone has ZONE_OOM_LOCKED set, a
  633. * parallel oom killing is already in progress so do nothing.
  634. */
  635. void pagefault_out_of_memory(void)
  636. {
  637. struct oom_control oc = {
  638. .zonelist = NULL,
  639. .nodemask = NULL,
  640. .gfp_mask = 0,
  641. .order = 0,
  642. };
  643. if (mem_cgroup_oom_synchronize(true))
  644. return;
  645. if (!mutex_trylock(&oom_lock))
  646. return;
  647. if (!out_of_memory(&oc)) {
  648. /*
  649. * There shouldn't be any user tasks runnable while the
  650. * OOM killer is disabled, so the current task has to
  651. * be a racing OOM victim for which oom_killer_disable()
  652. * is waiting for.
  653. */
  654. WARN_ON(test_thread_flag(TIF_MEMDIE));
  655. }
  656. mutex_unlock(&oom_lock);
  657. }