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