mm/oom_kill.c

   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  *
   8  *  The routines in this file are used to kill a process when
   9  *  we're seriously out of memory. This gets called from __alloc_pages()
  10  *  in mm/page_alloc.c when we really run out of memory.
  11  *
  12  *  Since we won't call these routines often (on a well-configured
  13  *  machine) this file will double as a 'coding guide' and a signpost
  14  *  for newbie kernel hackers. It features several pointers to major
  15  *  kernel subsystems and hints as to where to find out what things do.
  16  */
  17
  18 #include <linux/oom.h>
  19 #include <linux/mm.h>
  20 #include <linux/err.h>
  21 #include <linux/gfp.h>
  22 #include <linux/sched.h>
  23 #include <linux/swap.h>
  24 #include <linux/timex.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/cpuset.h>
  27 #include <linux/module.h>
  28 #include <linux/notifier.h>
  29 #include <linux/memcontrol.h>
  30 #include <linux/security.h>
  31
  32 int sysctl_panic_on_oom;
  33 int sysctl_oom_kill_allocating_task;
  34 int sysctl_oom_dump_tasks;
  35 static DEFINE_SPINLOCK(zone_scan_lock);
  36 /* #define DEBUG */
  37
  38 /*
  39  * Is all threads of the target process nodes overlap ours?
  40  */
  41 static int has_intersects_mems_allowed(struct task_struct *tsk)
  42 {
  43         struct task_struct *t;
  44
  45         t = tsk;
  46         do {
  47                 if (cpuset_mems_allowed_intersects(current, t))
  48                         return 1;
  49                 t = next_thread(t);
  50         } while (t != tsk);
  51
  52         return 0;
  53 }
  54
  55 static struct task_struct *find_lock_task_mm(struct task_struct *p)
  56 {
  57         struct task_struct *t = p;
  58
  59         do {
  60                 task_lock(t);
  61                 if (likely(t->mm))
  62                         return t;
  63                 task_unlock(t);
  64         } while_each_thread(p, t);
  65
  66         return NULL;
  67 }
  68
  69 /**
  70  * badness - calculate a numeric value for how bad this task has been
  71  * @p: task struct of which task we should calculate
  72  * @uptime: current uptime in seconds
  73  *
  74  * The formula used is relatively simple and documented inline in the
  75  * function. The main rationale is that we want to select a good task
  76  * to kill when we run out of memory.
  77  *
  78  * Good in this context means that:
  79  * 1) we lose the minimum amount of work done
  80  * 2) we recover a large amount of memory
  81  * 3) we don't kill anything innocent of eating tons of memory
  82  * 4) we want to kill the minimum amount of processes (one)
  83  * 5) we try to kill the process the user expects us to kill, this
  84  *    algorithm has been meticulously tuned to meet the principle
  85  *    of least surprise ... (be careful when you change it)
  86  */
  87
  88 unsigned long badness(struct task_struct *p, unsigned long uptime)
  89 {
  90         unsigned long points, cpu_time, run_time;
  91         struct task_struct *child;
  92         struct task_struct *c, *t;
  93         int oom_adj = p->signal->oom_adj;
  94         struct task_cputime task_time;
  95         unsigned long utime;
  96         unsigned long stime;
  97
  98         if (oom_adj == OOM_DISABLE)
  99                 return 0;
 100
 101         p = find_lock_task_mm(p);
 102         if (!p)
 103                 return 0;
 104
 105         /*
 106          * The memory size of the process is the basis for the badness.
 107          */
 108         points = p->mm->total_vm;
 109
 110         /*
 111          * After this unlock we can no longer dereference local variable `mm'
 112          */
 113         task_unlock(p);
 114
 115         /*
 116          * swapoff can easily use up all memory, so kill those first.
 117          */
 118         if (p->flags & PF_OOM_ORIGIN)
 119                 return ULONG_MAX;
 120
 121         /*
 122          * Processes which fork a lot of child processes are likely
 123          * a good choice. We add half the vmsize of the children if they
 124          * have an own mm. This prevents forking servers to flood the
 125          * machine with an endless amount of children. In case a single
 126          * child is eating the vast majority of memory, adding only half
 127          * to the parents will make the child our kill candidate of choice.
 128          */
 129         t = p;
 130         do {
 131                 list_for_each_entry(c, &t->children, sibling) {
 132                         child = find_lock_task_mm(c);
 133                         if (child) {
 134                                 if (child->mm != p->mm)
 135                                         points += child->mm->total_vm/2 + 1;
 136                                 task_unlock(child);
 137                         }
 138                 }
 139         } while_each_thread(p, t);
 140
 141         /*
 142          * CPU time is in tens of seconds and run time is in thousands
 143          * of seconds. There is no particular reason for this other than
 144          * that it turned out to work very well in practice.
 145          */
 146         thread_group_cputime(p, &task_time);
 147         utime = cputime_to_jiffies(task_time.utime);
 148         stime = cputime_to_jiffies(task_time.stime);
 149         cpu_time = (utime + stime) >> (SHIFT_HZ + 3);
 150
 151
 152         if (uptime >= p->start_time.tv_sec)
 153                 run_time = (uptime - p->start_time.tv_sec) >> 10;
 154         else
 155                 run_time = 0;
 156
 157         if (cpu_time)
 158                 points /= int_sqrt(cpu_time);
 159         if (run_time)
 160                 points /= int_sqrt(int_sqrt(run_time));
 161
 162         /*
 163          * Niced processes are most likely less important, so double
 164          * their badness points.
 165          */
 166         if (task_nice(p) > 0)
 167                 points *= 2;
 168
 169         /*
 170          * Superuser processes are usually more important, so we make it
 171          * less likely that we kill those.
 172          */
 173         if (has_capability_noaudit(p, CAP_SYS_ADMIN) ||
 174             has_capability_noaudit(p, CAP_SYS_RESOURCE))
 175                 points /= 4;
 176
 177         /*
 178          * We don't want to kill a process with direct hardware access.
 179          * Not only could that mess up the hardware, but usually users
 180          * tend to only have this flag set on applications they think
 181          * of as important.
 182          */
 183         if (has_capability_noaudit(p, CAP_SYS_RAWIO))
 184                 points /= 4;
 185
 186         /*
 187          * Adjust the score by oom_adj.
 188          */
 189         if (oom_adj) {
 190                 if (oom_adj > 0) {
 191                         if (!points)
 192                                 points = 1;
 193                         points <<= oom_adj;
 194                 } else
 195                         points >>= -(oom_adj);
 196         }
 197
 198 #ifdef DEBUG
 199         printk(KERN_DEBUG "OOMkill: task %d (%s) got %lu points\n",
 200         p->pid, p->comm, points);
 201 #endif
 202         return points;
 203 }
 204
 205 /*
 206  * Determine the type of allocation constraint.
 207  */
 208 #ifdef CONFIG_NUMA
 209 static enum oom_constraint constrained_alloc(struct zonelist *zonelist,
 210                                     gfp_t gfp_mask, nodemask_t *nodemask)
 211 {
 212         struct zone *zone;
 213         struct zoneref *z;
 214         enum zone_type high_zoneidx = gfp_zone(gfp_mask);
 215
 216         /*
 217          * Reach here only when __GFP_NOFAIL is used. So, we should avoid
 218          * to kill current.We have to random task kill in this case.
 219          * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now.
 220          */
 221         if (gfp_mask & __GFP_THISNODE)
 222                 return CONSTRAINT_NONE;
 223
 224         /*
 225          * The nodemask here is a nodemask passed to alloc_pages(). Now,
 226          * cpuset doesn't use this nodemask for its hardwall/softwall/hierarchy
 227          * feature. mempolicy is an only user of nodemask here.
 228          * check mempolicy's nodemask contains all N_HIGH_MEMORY
 229          */
 230         if (nodemask && !nodes_subset(node_states[N_HIGH_MEMORY], *nodemask))
 231                 return CONSTRAINT_MEMORY_POLICY;
 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_softwall(zone, gfp_mask))
 237                         return CONSTRAINT_CPUSET;
 238
 239         return CONSTRAINT_NONE;
 240 }
 241 #else
 242 static enum oom_constraint constrained_alloc(struct zonelist *zonelist,
 243                                 gfp_t gfp_mask, nodemask_t *nodemask)
 244 {
 245         return CONSTRAINT_NONE;
 246 }
 247 #endif
 248
 249 /*
 250  * Simple selection loop. We chose the process with the highest
 251  * number of 'points'. We expect the caller will lock the tasklist.
 252  *
 253  * (not docbooked, we don't want this one cluttering up the manual)
 254  */
 255 static struct task_struct *select_bad_process(unsigned long *ppoints,
 256                                                 struct mem_cgroup *mem)
 257 {
 258         struct task_struct *p;
 259         struct task_struct *chosen = NULL;
 260         struct timespec uptime;
 261         *ppoints = 0;
 262
 263         do_posix_clock_monotonic_gettime(&uptime);
 264         for_each_process(p) {
 265                 unsigned long points;
 266
 267                 /* skip the init task and kthreads */
 268                 if (is_global_init(p) || (p->flags & PF_KTHREAD))
 269                         continue;
 270                 if (mem && !task_in_mem_cgroup(p, mem))
 271                         continue;
 272                 if (!has_intersects_mems_allowed(p))
 273                         continue;
 274
 275                 /*
 276                  * This task already has access to memory reserves and is
 277                  * being killed. Don't allow any other task access to the
 278                  * memory reserve.
 279                  *
 280                  * Note: this may have a chance of deadlock if it gets
 281                  * blocked waiting for another task which itself is waiting
 282                  * for memory. Is there a better alternative?
 283                  */
 284                 if (test_tsk_thread_flag(p, TIF_MEMDIE))
 285                         return ERR_PTR(-1UL);
 286
 287                 /*
 288                  * This is in the process of releasing memory so wait for it
 289                  * to finish before killing some other task by mistake.
 290                  *
 291                  * However, if p is the current task, we allow the 'kill' to
 292                  * go ahead if it is exiting: this will simply set TIF_MEMDIE,
 293                  * which will allow it to gain access to memory reserves in
 294                  * the process of exiting and releasing its resources.
 295                  * Otherwise we could get an easy OOM deadlock.
 296                  */
 297                 if ((p->flags & PF_EXITING) && p->mm) {
 298                         if (p != current)
 299                                 return ERR_PTR(-1UL);
 300
 301                         chosen = p;
 302                         *ppoints = ULONG_MAX;
 303                 }
 304
 305                 if (p->signal->oom_adj == OOM_DISABLE)
 306                         continue;
 307
 308                 points = badness(p, uptime.tv_sec);
 309                 if (points > *ppoints || !chosen) {
 310                         chosen = p;
 311                         *ppoints = points;
 312                 }
 313         }
 314
 315         return chosen;
 316 }
 317
 318 /**
 319  * dump_tasks - dump current memory state of all system tasks
 320  * @mem: current's memory controller, if constrained
 321  *
 322  * Dumps the current memory state of all system tasks, excluding kernel threads.
 323  * State information includes task's pid, uid, tgid, vm size, rss, cpu, oom_adj
 324  * score, and name.
 325  *
 326  * If the actual is non-NULL, only tasks that are a member of the mem_cgroup are
 327  * shown.
 328  *
 329  * Call with tasklist_lock read-locked.
 330  */
 331 static void dump_tasks(const struct mem_cgroup *mem)
 332 {
 333         struct task_struct *p;
 334         struct task_struct *task;
 335
 336         printk(KERN_INFO "[ pid ]   uid  tgid total_vm      rss cpu oom_adj "
 337                "name\n");
 338         for_each_process(p) {
 339                 if (p->flags & PF_KTHREAD)
 340                         continue;
 341                 if (mem && !task_in_mem_cgroup(p, mem))
 342                         continue;
 343
 344                 task = find_lock_task_mm(p);
 345                 if (!task) {
 346                         /*
 347                          * This is a kthread or all of p's threads have already
 348                          * detached their mm's.  There's no need to report
 349                          * them; they can't be oom killed anyway.
 350                          */
 351                         continue;
 352                 }
 353
 354                 printk(KERN_INFO "[%5d] %5d %5d %8lu %8lu %3u     %3d %s\n",
 355                        task->pid, __task_cred(task)->uid, task->tgid,
 356                        task->mm->total_vm, get_mm_rss(task->mm),
 357                        task_cpu(task), task->signal->oom_adj, task->comm);
 358                 task_unlock(task);
 359         }
 360 }
 361
 362 static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order,
 363                                                         struct mem_cgroup *mem)
 364 {
 365         task_lock(current);
 366         pr_warning("%s invoked oom-killer: gfp_mask=0x%x, order=%d, "
 367                 "oom_adj=%d\n",
 368                 current->comm, gfp_mask, order, current->signal->oom_adj);
 369         cpuset_print_task_mems_allowed(current);
 370         task_unlock(current);
 371         dump_stack();
 372         mem_cgroup_print_oom_info(mem, p);
 373         show_mem();
 374         if (sysctl_oom_dump_tasks)
 375                 dump_tasks(mem);
 376 }
 377
 378 #define K(x) ((x) << (PAGE_SHIFT-10))
 379
 380 /*
 381  * Send SIGKILL to the selected  process irrespective of  CAP_SYS_RAW_IO
 382  * flag though it's unlikely that  we select a process with CAP_SYS_RAW_IO
 383  * set.
 384  */
 385 static void __oom_kill_task(struct task_struct *p, int verbose)
 386 {
 387         if (is_global_init(p)) {
 388                 WARN_ON(1);
 389                 printk(KERN_WARNING "tried to kill init!\n");
 390                 return;
 391         }
 392
 393         p = find_lock_task_mm(p);
 394         if (!p)
 395                 return;
 396
 397         if (verbose)
 398                 printk(KERN_ERR "Killed process %d (%s) "
 399                        "vsz:%lukB, anon-rss:%lukB, file-rss:%lukB\n",
 400                        task_pid_nr(p), p->comm,
 401                        K(p->mm->total_vm),
 402                        K(get_mm_counter(p->mm, MM_ANONPAGES)),
 403                        K(get_mm_counter(p->mm, MM_FILEPAGES)));
 404         task_unlock(p);
 405
 406         /*
 407          * We give our sacrificial lamb high priority and access to
 408          * all the memory it needs. That way it should be able to
 409          * exit() and clear out its resources quickly...
 410          */
 411         p->rt.time_slice = HZ;
 412         set_tsk_thread_flag(p, TIF_MEMDIE);
 413
 414         force_sig(SIGKILL, p);
 415 }
 416
 417 static int oom_kill_task(struct task_struct *p)
 418 {
 419         /* WARNING: mm may not be dereferenced since we did not obtain its
 420          * value from get_task_mm(p).  This is OK since all we need to do is
 421          * compare mm to q->mm below.
 422          *
 423          * Furthermore, even if mm contains a non-NULL value, p->mm may
 424          * change to NULL at any time since we do not hold task_lock(p).
 425          * However, this is of no concern to us.
 426          */
 427         if (!p->mm || p->signal->oom_adj == OOM_DISABLE)
 428                 return 1;
 429
 430         __oom_kill_task(p, 1);
 431
 432         return 0;
 433 }
 434
 435 static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
 436                             unsigned long points, struct mem_cgroup *mem,
 437                             const char *message)
 438 {
 439         struct task_struct *victim = p;
 440         struct task_struct *child;
 441         struct task_struct *t = p;
 442         unsigned long victim_points = 0;
 443         struct timespec uptime;
 444
 445         if (printk_ratelimit())
 446                 dump_header(p, gfp_mask, order, mem);
 447
 448         /*
 449          * If the task is already exiting, don't alarm the sysadmin or kill
 450          * its children or threads, just set TIF_MEMDIE so it can die quickly
 451          */
 452         if (p->flags & PF_EXITING) {
 453                 set_tsk_thread_flag(p, TIF_MEMDIE);
 454                 return 0;
 455         }
 456
 457         task_lock(p);
 458         pr_err("%s: Kill process %d (%s) score %lu or sacrifice child\n",
 459                 message, task_pid_nr(p), p->comm, points);
 460         task_unlock(p);
 461
 462         /*
 463          * If any of p's children has a different mm and is eligible for kill,
 464          * the one with the highest badness() score is sacrificed for its
 465          * parent.  This attempts to lose the minimal amount of work done while
 466          * still freeing memory.
 467          */
 468         do_posix_clock_monotonic_gettime(&uptime);
 469         do {
 470                 list_for_each_entry(child, &t->children, sibling) {
 471                         unsigned long child_points;
 472
 473                         if (child->mm == p->mm)
 474                                 continue;
 475                         if (mem && !task_in_mem_cgroup(child, mem))
 476                                 continue;
 477
 478                         /* badness() returns 0 if the thread is unkillable */
 479                         child_points = badness(child, uptime.tv_sec);
 480                         if (child_points > victim_points) {
 481                                 victim = child;
 482                                 victim_points = child_points;
 483                         }
 484                 }
 485         } while_each_thread(p, t);
 486
 487         return oom_kill_task(victim);
 488 }
 489
 490 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
 491 void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask)
 492 {
 493         unsigned long points = 0;
 494         struct task_struct *p;
 495
 496         if (sysctl_panic_on_oom == 2)
 497                 panic("out of memory(memcg). panic_on_oom is selected.\n");
 498         read_lock(&tasklist_lock);
 499 retry:
 500         p = select_bad_process(&points, mem);
 501         if (!p || PTR_ERR(p) == -1UL)
 502                 goto out;
 503
 504         if (oom_kill_process(p, gfp_mask, 0, points, mem,
 505                                 "Memory cgroup out of memory"))
 506                 goto retry;
 507 out:
 508         read_unlock(&tasklist_lock);
 509 }
 510 #endif
 511
 512 static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
 513
 514 int register_oom_notifier(struct notifier_block *nb)
 515 {
 516         return blocking_notifier_chain_register(&oom_notify_list, nb);
 517 }
 518 EXPORT_SYMBOL_GPL(register_oom_notifier);
 519
 520 int unregister_oom_notifier(struct notifier_block *nb)
 521 {
 522         return blocking_notifier_chain_unregister(&oom_notify_list, nb);
 523 }
 524 EXPORT_SYMBOL_GPL(unregister_oom_notifier);
 525
 526 /*
 527  * Try to acquire the OOM killer lock for the zones in zonelist.  Returns zero
 528  * if a parallel OOM killing is already taking place that includes a zone in
 529  * the zonelist.  Otherwise, locks all zones in the zonelist and returns 1.
 530  */
 531 int try_set_zone_oom(struct zonelist *zonelist, gfp_t gfp_mask)
 532 {
 533         struct zoneref *z;
 534         struct zone *zone;
 535         int ret = 1;
 536
 537         spin_lock(&zone_scan_lock);
 538         for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) {
 539                 if (zone_is_oom_locked(zone)) {
 540                         ret = 0;
 541                         goto out;
 542                 }
 543         }
 544
 545         for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) {
 546                 /*
 547                  * Lock each zone in the zonelist under zone_scan_lock so a
 548                  * parallel invocation of try_set_zone_oom() doesn't succeed
 549                  * when it shouldn't.
 550                  */
 551                 zone_set_flag(zone, ZONE_OOM_LOCKED);
 552         }
 553
 554 out:
 555         spin_unlock(&zone_scan_lock);
 556         return ret;
 557 }
 558
 559 /*
 560  * Clears the ZONE_OOM_LOCKED flag for all zones in the zonelist so that failed
 561  * allocation attempts with zonelists containing them may now recall the OOM
 562  * killer, if necessary.
 563  */
 564 void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask)
 565 {
 566         struct zoneref *z;
 567         struct zone *zone;
 568
 569         spin_lock(&zone_scan_lock);
 570         for_each_zone_zonelist(zone, z, zonelist, gfp_zone(gfp_mask)) {
 571                 zone_clear_flag(zone, ZONE_OOM_LOCKED);
 572         }
 573         spin_unlock(&zone_scan_lock);
 574 }
 575
 576 /*
 577  * Must be called with tasklist_lock held for read.
 578  */
 579 static void __out_of_memory(gfp_t gfp_mask, int order)
 580 {
 581         struct task_struct *p;
 582         unsigned long points;
 583
 584         if (sysctl_oom_kill_allocating_task)
 585                 if (!oom_kill_process(current, gfp_mask, order, 0, NULL,
 586                                 "Out of memory (oom_kill_allocating_task)"))
 587                         return;
 588 retry:
 589         /*
 590          * Rambo mode: Shoot down a process and hope it solves whatever
 591          * issues we may have.
 592          */
 593         p = select_bad_process(&points, NULL);
 594
 595         if (PTR_ERR(p) == -1UL)
 596                 return;
 597
 598         /* Found nothing?!?! Either we hang forever, or we panic. */
 599         if (!p) {
 600                 read_unlock(&tasklist_lock);
 601                 dump_header(NULL, gfp_mask, order, NULL);
 602                 panic("Out of memory and no killable processes...\n");
 603         }
 604
 605         if (oom_kill_process(p, gfp_mask, order, points, NULL,
 606                              "Out of memory"))
 607                 goto retry;
 608 }
 609
 610 /*
 611  * pagefault handler calls into here because it is out of memory but
 612  * doesn't know exactly how or why.
 613  */
 614 void pagefault_out_of_memory(void)
 615 {
 616         unsigned long freed = 0;
 617
 618         blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
 619         if (freed > 0)
 620                 /* Got some memory back in the last second. */
 621                 return;
 622
 623         if (sysctl_panic_on_oom)
 624                 panic("out of memory from page fault. panic_on_oom is selected.\n");
 625
 626         read_lock(&tasklist_lock);
 627         __out_of_memory(0, 0); /* unknown gfp_mask and order */
 628         read_unlock(&tasklist_lock);
 629
 630         /*
 631          * Give "p" a good chance of killing itself before we
 632          * retry to allocate memory.
 633          */
 634         if (!test_thread_flag(TIF_MEMDIE))
 635                 schedule_timeout_uninterruptible(1);
 636 }
 637
 638 /**
 639  * out_of_memory - kill the "best" process when we run out of memory
 640  * @zonelist: zonelist pointer
 641  * @gfp_mask: memory allocation flags
 642  * @order: amount of memory being requested as a power of 2
 643  *
 644  * If we run out of memory, we have the choice between either
 645  * killing a random task (bad), letting the system crash (worse)
 646  * OR try to be smart about which process to kill. Note that we
 647  * don't have to be perfect here, we just have to be good.
 648  */
 649 void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
 650                 int order, nodemask_t *nodemask)
 651 {
 652         unsigned long freed = 0;
 653         enum oom_constraint constraint;
 654
 655         blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
 656         if (freed > 0)
 657                 /* Got some memory back in the last second. */
 658                 return;
 659
 660         /*
 661          * If current has a pending SIGKILL, then automatically select it.  The
 662          * goal is to allow it to allocate so that it may quickly exit and free
 663          * its memory.
 664          */
 665         if (fatal_signal_pending(current)) {
 666                 set_thread_flag(TIF_MEMDIE);
 667                 return;
 668         }
 669
 670         if (sysctl_panic_on_oom == 2) {
 671                 dump_header(NULL, gfp_mask, order, NULL);
 672                 panic("out of memory. Compulsory panic_on_oom is selected.\n");
 673         }
 674
 675         /*
 676          * Check if there were limitations on the allocation (only relevant for
 677          * NUMA) that may require different handling.
 678          */
 679         constraint = constrained_alloc(zonelist, gfp_mask, nodemask);
 680         read_lock(&tasklist_lock);
 681
 682         switch (constraint) {
 683         case CONSTRAINT_MEMORY_POLICY:
 684                 oom_kill_process(current, gfp_mask, order, 0, NULL,
 685                                 "No available memory (MPOL_BIND)");
 686                 break;
 687
 688         case CONSTRAINT_NONE:
 689                 if (sysctl_panic_on_oom) {
 690                         dump_header(NULL, gfp_mask, order, NULL);
 691                         panic("out of memory. panic_on_oom is selected\n");
 692                 }
 693                 /* Fall-through */
 694         case CONSTRAINT_CPUSET:
 695                 __out_of_memory(gfp_mask, order);
 696                 break;
 697         }
 698
 699         read_unlock(&tasklist_lock);
 700
 701         /*
 702          * Give "p" a good chance of killing itself before we
 703          * retry to allocate memory unless "p" is current
 704          */
 705         if (!test_thread_flag(TIF_MEMDIE))
 706                 schedule_timeout_uninterruptible(1);
 707 }