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  *  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/sched/mm.h>
  26 #include <linux/sched/coredump.h>
  27 #include <linux/sched/task.h>
  28 #include <linux/swap.h>
  29 #include <linux/timex.h>
  30 #include <linux/jiffies.h>
  31 #include <linux/cpuset.h>
  32 #include <linux/export.h>
  33 #include <linux/notifier.h>
  34 #include <linux/memcontrol.h>
  35 #include <linux/mempolicy.h>
  36 #include <linux/security.h>
  37 #include <linux/ptrace.h>
  38 #include <linux/freezer.h>
  39 #include <linux/ftrace.h>
  40 #include <linux/ratelimit.h>
  41 #include <linux/kthread.h>
  42 #include <linux/init.h>
  43 #include <linux/mmu_notifier.h>
  44
  45 #include <asm/tlb.h>
  46 #include "internal.h"
  47 #include "slab.h"
  48
  49 #define CREATE_TRACE_POINTS
  50 #include <trace/events/oom.h>
  51
  52 int sysctl_panic_on_oom;
  53 int sysctl_oom_kill_allocating_task;
  54 int sysctl_oom_dump_tasks = 1;
  55
  56 DEFINE_MUTEX(oom_lock);
  57
  58 #ifdef CONFIG_NUMA
  59 /**
  60  * has_intersects_mems_allowed() - check task eligiblity for kill
  61  * @start: task struct of which task to consider
  62  * @mask: nodemask passed to page allocator for mempolicy ooms
  63  *
  64  * Task eligibility is determined by whether or not a candidate task, @tsk,
  65  * shares the same mempolicy nodes as current if it is bound by such a policy
  66  * and whether or not it has the same set of allowed cpuset nodes.
  67  */
  68 static bool has_intersects_mems_allowed(struct task_struct *start,
  69                                         const nodemask_t *mask)
  70 {
  71         struct task_struct *tsk;
  72         bool ret = false;
  73
  74         rcu_read_lock();
  75         for_each_thread(start, tsk) {
  76                 if (mask) {
  77                         /*
  78                          * If this is a mempolicy constrained oom, tsk's
  79                          * cpuset is irrelevant.  Only return true if its
  80                          * mempolicy intersects current, otherwise it may be
  81                          * needlessly killed.
  82                          */
  83                         ret = mempolicy_nodemask_intersects(tsk, mask);
  84                 } else {
  85                         /*
  86                          * This is not a mempolicy constrained oom, so only
  87                          * check the mems of tsk's cpuset.
  88                          */
  89                         ret = cpuset_mems_allowed_intersects(current, tsk);
  90                 }
  91                 if (ret)
  92                         break;
  93         }
  94         rcu_read_unlock();
  95
  96         return ret;
  97 }
  98 #else
  99 static bool has_intersects_mems_allowed(struct task_struct *tsk,
 100                                         const nodemask_t *mask)
 101 {
 102         return true;
 103 }
 104 #endif /* CONFIG_NUMA */
 105
 106 /*
 107  * The process p may have detached its own ->mm while exiting or through
 108  * use_mm(), but one or more of its subthreads may still have a valid
 109  * pointer.  Return p, or any of its subthreads with a valid ->mm, with
 110  * task_lock() held.
 111  */
 112 struct task_struct *find_lock_task_mm(struct task_struct *p)
 113 {
 114         struct task_struct *t;
 115
 116         rcu_read_lock();
 117
 118         for_each_thread(p, t) {
 119                 task_lock(t);
 120                 if (likely(t->mm))
 121                         goto found;
 122                 task_unlock(t);
 123         }
 124         t = NULL;
 125 found:
 126         rcu_read_unlock();
 127
 128         return t;
 129 }
 130
 131 /*
 132  * order == -1 means the oom kill is required by sysrq, otherwise only
 133  * for display purposes.
 134  */
 135 static inline bool is_sysrq_oom(struct oom_control *oc)
 136 {
 137         return oc->order == -1;
 138 }
 139
 140 static inline bool is_memcg_oom(struct oom_control *oc)
 141 {
 142         return oc->memcg != NULL;
 143 }
 144
 145 /* return true if the task is not adequate as candidate victim task. */
 146 static bool oom_unkillable_task(struct task_struct *p,
 147                 struct mem_cgroup *memcg, const nodemask_t *nodemask)
 148 {
 149         if (is_global_init(p))
 150                 return true;
 151         if (p->flags & PF_KTHREAD)
 152                 return true;
 153
 154         /* When mem_cgroup_out_of_memory() and p is not member of the group */
 155         if (memcg && !task_in_mem_cgroup(p, memcg))
 156                 return true;
 157
 158         /* p may not have freeable memory in nodemask */
 159         if (!has_intersects_mems_allowed(p, nodemask))
 160                 return true;
 161
 162         return false;
 163 }
 164
 165 /*
 166  * Print out unreclaimble slabs info when unreclaimable slabs amount is greater
 167  * than all user memory (LRU pages)
 168  */
 169 static bool is_dump_unreclaim_slabs(void)
 170 {
 171         unsigned long nr_lru;
 172
 173         nr_lru = global_node_page_state(NR_ACTIVE_ANON) +
 174                  global_node_page_state(NR_INACTIVE_ANON) +
 175                  global_node_page_state(NR_ACTIVE_FILE) +
 176                  global_node_page_state(NR_INACTIVE_FILE) +
 177                  global_node_page_state(NR_ISOLATED_ANON) +
 178                  global_node_page_state(NR_ISOLATED_FILE) +
 179                  global_node_page_state(NR_UNEVICTABLE);
 180
 181         return (global_node_page_state(NR_SLAB_UNRECLAIMABLE) > nr_lru);
 182 }
 183
 184 /**
 185  * oom_badness - heuristic function to determine which candidate task to kill
 186  * @p: task struct of which task we should calculate
 187  * @totalpages: total present RAM allowed for page allocation
 188  * @memcg: task's memory controller, if constrained
 189  * @nodemask: nodemask passed to page allocator for mempolicy ooms
 190  *
 191  * The heuristic for determining which task to kill is made to be as simple and
 192  * predictable as possible.  The goal is to return the highest value for the
 193  * task consuming the most memory to avoid subsequent oom failures.
 194  */
 195 unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,
 196                           const nodemask_t *nodemask, unsigned long totalpages)
 197 {
 198         long points;
 199         long adj;
 200
 201         if (oom_unkillable_task(p, memcg, nodemask))
 202                 return 0;
 203
 204         p = find_lock_task_mm(p);
 205         if (!p)
 206                 return 0;
 207
 208         /*
 209          * Do not even consider tasks which are explicitly marked oom
 210          * unkillable or have been already oom reaped or the are in
 211          * the middle of vfork
 212          */
 213         adj = (long)p->signal->oom_score_adj;
 214         if (adj == OOM_SCORE_ADJ_MIN ||
 215                         test_bit(MMF_OOM_SKIP, &p->mm->flags) ||
 216                         in_vfork(p)) {
 217                 task_unlock(p);
 218                 return 0;
 219         }
 220
 221         /*
 222          * The baseline for the badness score is the proportion of RAM that each
 223          * task's rss, pagetable and swap space use.
 224          */
 225         points = get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) +
 226                 mm_pgtables_bytes(p->mm) / PAGE_SIZE;
 227         task_unlock(p);
 228
 229         /* Normalize to oom_score_adj units */
 230         adj *= totalpages / 1000;
 231         points += adj;
 232
 233         /*
 234          * Never return 0 for an eligible task regardless of the root bonus and
 235          * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here).
 236          */
 237         return points > 0 ? points : 1;
 238 }
 239
 240 enum oom_constraint {
 241         CONSTRAINT_NONE,
 242         CONSTRAINT_CPUSET,
 243         CONSTRAINT_MEMORY_POLICY,
 244         CONSTRAINT_MEMCG,
 245 };
 246
 247 /*
 248  * Determine the type of allocation constraint.
 249  */
 250 static enum oom_constraint constrained_alloc(struct oom_control *oc)
 251 {
 252         struct zone *zone;
 253         struct zoneref *z;
 254         enum zone_type high_zoneidx = gfp_zone(oc->gfp_mask);
 255         bool cpuset_limited = false;
 256         int nid;
 257
 258         if (is_memcg_oom(oc)) {
 259                 oc->totalpages = mem_cgroup_get_max(oc->memcg) ?: 1;
 260                 return CONSTRAINT_MEMCG;
 261         }
 262
 263         /* Default to all available memory */
 264         oc->totalpages = totalram_pages + total_swap_pages;
 265
 266         if (!IS_ENABLED(CONFIG_NUMA))
 267                 return CONSTRAINT_NONE;
 268
 269         if (!oc->zonelist)
 270                 return CONSTRAINT_NONE;
 271         /*
 272          * Reach here only when __GFP_NOFAIL is used. So, we should avoid
 273          * to kill current.We have to random task kill in this case.
 274          * Hopefully, CONSTRAINT_THISNODE...but no way to handle it, now.
 275          */
 276         if (oc->gfp_mask & __GFP_THISNODE)
 277                 return CONSTRAINT_NONE;
 278
 279         /*
 280          * This is not a __GFP_THISNODE allocation, so a truncated nodemask in
 281          * the page allocator means a mempolicy is in effect.  Cpuset policy
 282          * is enforced in get_page_from_freelist().
 283          */
 284         if (oc->nodemask &&
 285             !nodes_subset(node_states[N_MEMORY], *oc->nodemask)) {
 286                 oc->totalpages = total_swap_pages;
 287                 for_each_node_mask(nid, *oc->nodemask)
 288                         oc->totalpages += node_spanned_pages(nid);
 289                 return CONSTRAINT_MEMORY_POLICY;
 290         }
 291
 292         /* Check this allocation failure is caused by cpuset's wall function */
 293         for_each_zone_zonelist_nodemask(zone, z, oc->zonelist,
 294                         high_zoneidx, oc->nodemask)
 295                 if (!cpuset_zone_allowed(zone, oc->gfp_mask))
 296                         cpuset_limited = true;
 297
 298         if (cpuset_limited) {
 299                 oc->totalpages = total_swap_pages;
 300                 for_each_node_mask(nid, cpuset_current_mems_allowed)
 301                         oc->totalpages += node_spanned_pages(nid);
 302                 return CONSTRAINT_CPUSET;
 303         }
 304         return CONSTRAINT_NONE;
 305 }
 306
 307 static int oom_evaluate_task(struct task_struct *task, void *arg)
 308 {
 309         struct oom_control *oc = arg;
 310         unsigned long points;
 311
 312         if (oom_unkillable_task(task, NULL, oc->nodemask))
 313                 goto next;
 314
 315         /*
 316          * This task already has access to memory reserves and is being killed.
 317          * Don't allow any other task to have access to the reserves unless
 318          * the task has MMF_OOM_SKIP because chances that it would release
 319          * any memory is quite low.
 320          */
 321         if (!is_sysrq_oom(oc) && tsk_is_oom_victim(task)) {
 322                 if (test_bit(MMF_OOM_SKIP, &task->signal->oom_mm->flags))
 323                         goto next;
 324                 goto abort;
 325         }
 326
 327         /*
 328          * If task is allocating a lot of memory and has been marked to be
 329          * killed first if it triggers an oom, then select it.
 330          */
 331         if (oom_task_origin(task)) {
 332                 points = ULONG_MAX;
 333                 goto select;
 334         }
 335
 336         points = oom_badness(task, NULL, oc->nodemask, oc->totalpages);
 337         if (!points || points < oc->chosen_points)
 338                 goto next;
 339
 340         /* Prefer thread group leaders for display purposes */
 341         if (points == oc->chosen_points && thread_group_leader(oc->chosen))
 342                 goto next;
 343 select:
 344         if (oc->chosen)
 345                 put_task_struct(oc->chosen);
 346         get_task_struct(task);
 347         oc->chosen = task;
 348         oc->chosen_points = points;
 349 next:
 350         return 0;
 351 abort:
 352         if (oc->chosen)
 353                 put_task_struct(oc->chosen);
 354         oc->chosen = (void *)-1UL;
 355         return 1;
 356 }
 357
 358 /*
 359  * Simple selection loop. We choose the process with the highest number of
 360  * 'points'. In case scan was aborted, oc->chosen is set to -1.
 361  */
 362 static void select_bad_process(struct oom_control *oc)
 363 {
 364         if (is_memcg_oom(oc))
 365                 mem_cgroup_scan_tasks(oc->memcg, oom_evaluate_task, oc);
 366         else {
 367                 struct task_struct *p;
 368
 369                 rcu_read_lock();
 370                 for_each_process(p)
 371                         if (oom_evaluate_task(p, oc))
 372                                 break;
 373                 rcu_read_unlock();
 374         }
 375
 376         oc->chosen_points = oc->chosen_points * 1000 / oc->totalpages;
 377 }
 378
 379 /**
 380  * dump_tasks - dump current memory state of all system tasks
 381  * @memcg: current's memory controller, if constrained
 382  * @nodemask: nodemask passed to page allocator for mempolicy ooms
 383  *
 384  * Dumps the current memory state of all eligible tasks.  Tasks not in the same
 385  * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes
 386  * are not shown.
 387  * State information includes task's pid, uid, tgid, vm size, rss,
 388  * pgtables_bytes, swapents, oom_score_adj value, and name.
 389  */
 390 static void dump_tasks(struct mem_cgroup *memcg, const nodemask_t *nodemask)
 391 {
 392         struct task_struct *p;
 393         struct task_struct *task;
 394
 395         pr_info("[ pid ]   uid  tgid total_vm      rss pgtables_bytes swapents oom_score_adj name\n");
 396         rcu_read_lock();
 397         for_each_process(p) {
 398                 if (oom_unkillable_task(p, memcg, nodemask))
 399                         continue;
 400
 401                 task = find_lock_task_mm(p);
 402                 if (!task) {
 403                         /*
 404                          * This is a kthread or all of p's threads have already
 405                          * detached their mm's.  There's no need to report
 406                          * them; they can't be oom killed anyway.
 407                          */
 408                         continue;
 409                 }
 410
 411                 pr_info("[%5d] %5d %5d %8lu %8lu %8ld %8lu         %5hd %s\n",
 412                         task->pid, from_kuid(&init_user_ns, task_uid(task)),
 413                         task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
 414                         mm_pgtables_bytes(task->mm),
 415                         get_mm_counter(task->mm, MM_SWAPENTS),
 416                         task->signal->oom_score_adj, task->comm);
 417                 task_unlock(task);
 418         }
 419         rcu_read_unlock();
 420 }
 421
 422 static void dump_header(struct oom_control *oc, struct task_struct *p)
 423 {
 424         pr_warn("%s invoked oom-killer: gfp_mask=%#x(%pGg), nodemask=%*pbl, order=%d, oom_score_adj=%hd\n",
 425                 current->comm, oc->gfp_mask, &oc->gfp_mask,
 426                 nodemask_pr_args(oc->nodemask), oc->order,
 427                         current->signal->oom_score_adj);
 428         if (!IS_ENABLED(CONFIG_COMPACTION) && oc->order)
 429                 pr_warn("COMPACTION is disabled!!!\n");
 430
 431         cpuset_print_current_mems_allowed();
 432         dump_stack();
 433         if (is_memcg_oom(oc))
 434                 mem_cgroup_print_oom_info(oc->memcg, p);
 435         else {
 436                 show_mem(SHOW_MEM_FILTER_NODES, oc->nodemask);
 437                 if (is_dump_unreclaim_slabs())
 438                         dump_unreclaimable_slab();
 439         }
 440         if (sysctl_oom_dump_tasks)
 441                 dump_tasks(oc->memcg, oc->nodemask);
 442 }
 443
 444 /*
 445  * Number of OOM victims in flight
 446  */
 447 static atomic_t oom_victims = ATOMIC_INIT(0);
 448 static DECLARE_WAIT_QUEUE_HEAD(oom_victims_wait);
 449
 450 static bool oom_killer_disabled __read_mostly;
 451
 452 #define K(x) ((x) << (PAGE_SHIFT-10))
 453
 454 /*
 455  * task->mm can be NULL if the task is the exited group leader.  So to
 456  * determine whether the task is using a particular mm, we examine all the
 457  * task's threads: if one of those is using this mm then this task was also
 458  * using it.
 459  */
 460 bool process_shares_mm(struct task_struct *p, struct mm_struct *mm)
 461 {
 462         struct task_struct *t;
 463
 464         for_each_thread(p, t) {
 465                 struct mm_struct *t_mm = READ_ONCE(t->mm);
 466                 if (t_mm)
 467                         return t_mm == mm;
 468         }
 469         return false;
 470 }
 471
 472 #ifdef CONFIG_MMU
 473 /*
 474  * OOM Reaper kernel thread which tries to reap the memory used by the OOM
 475  * victim (if that is possible) to help the OOM killer to move on.
 476  */
 477 static struct task_struct *oom_reaper_th;
 478 static DECLARE_WAIT_QUEUE_HEAD(oom_reaper_wait);
 479 static struct task_struct *oom_reaper_list;
 480 static DEFINE_SPINLOCK(oom_reaper_lock);
 481
 482 void __oom_reap_task_mm(struct mm_struct *mm)
 483 {
 484         struct vm_area_struct *vma;
 485
 486         /*
 487          * Tell all users of get_user/copy_from_user etc... that the content
 488          * is no longer stable. No barriers really needed because unmapping
 489          * should imply barriers already and the reader would hit a page fault
 490          * if it stumbled over a reaped memory.
 491          */
 492         set_bit(MMF_UNSTABLE, &mm->flags);
 493
 494         for (vma = mm->mmap ; vma; vma = vma->vm_next) {
 495                 if (!can_madv_dontneed_vma(vma))
 496                         continue;
 497
 498                 /*
 499                  * Only anonymous pages have a good chance to be dropped
 500                  * without additional steps which we cannot afford as we
 501                  * are OOM already.
 502                  *
 503                  * We do not even care about fs backed pages because all
 504                  * which are reclaimable have already been reclaimed and
 505                  * we do not want to block exit_mmap by keeping mm ref
 506                  * count elevated without a good reason.
 507                  */
 508                 if (vma_is_anonymous(vma) || !(vma->vm_flags & VM_SHARED)) {
 509                         const unsigned long start = vma->vm_start;
 510                         const unsigned long end = vma->vm_end;
 511                         struct mmu_gather tlb;
 512
 513                         tlb_gather_mmu(&tlb, mm, start, end);
 514                         mmu_notifier_invalidate_range_start(mm, start, end);
 515                         unmap_page_range(&tlb, vma, start, end, NULL);
 516                         mmu_notifier_invalidate_range_end(mm, start, end);
 517                         tlb_finish_mmu(&tlb, start, end);
 518                 }
 519         }
 520 }
 521
 522 static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)
 523 {
 524         bool ret = true;
 525
 526         /*
 527          * We have to make sure to not race with the victim exit path
 528          * and cause premature new oom victim selection:
 529          * oom_reap_task_mm             exit_mm
 530          *   mmget_not_zero
 531          *                                mmput
 532          *                                  atomic_dec_and_test
 533          *                                exit_oom_victim
 534          *                              [...]
 535          *                              out_of_memory
 536          *                                select_bad_process
 537          *                                  # no TIF_MEMDIE task selects new victim
 538          *  unmap_page_range # frees some memory
 539          */
 540         mutex_lock(&oom_lock);
 541
 542         if (!down_read_trylock(&mm->mmap_sem)) {
 543                 ret = false;
 544                 trace_skip_task_reaping(tsk->pid);
 545                 goto unlock_oom;
 546         }
 547
 548         /*
 549          * If the mm has invalidate_{start,end}() notifiers that could block,
 550          * sleep to give the oom victim some more time.
 551          * TODO: we really want to get rid of this ugly hack and make sure that
 552          * notifiers cannot block for unbounded amount of time
 553          */
 554         if (mm_has_blockable_invalidate_notifiers(mm)) {
 555                 up_read(&mm->mmap_sem);
 556                 schedule_timeout_idle(HZ);
 557                 goto unlock_oom;
 558         }
 559
 560         /*
 561          * MMF_OOM_SKIP is set by exit_mmap when the OOM reaper can't
 562          * work on the mm anymore. The check for MMF_OOM_SKIP must run
 563          * under mmap_sem for reading because it serializes against the
 564          * down_write();up_write() cycle in exit_mmap().
 565          */
 566         if (test_bit(MMF_OOM_SKIP, &mm->flags)) {
 567                 up_read(&mm->mmap_sem);
 568                 trace_skip_task_reaping(tsk->pid);
 569                 goto unlock_oom;
 570         }
 571
 572         trace_start_task_reaping(tsk->pid);
 573
 574         __oom_reap_task_mm(mm);
 575
 576         pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
 577                         task_pid_nr(tsk), tsk->comm,
 578                         K(get_mm_counter(mm, MM_ANONPAGES)),
 579                         K(get_mm_counter(mm, MM_FILEPAGES)),
 580                         K(get_mm_counter(mm, MM_SHMEMPAGES)));
 581         up_read(&mm->mmap_sem);
 582
 583         trace_finish_task_reaping(tsk->pid);
 584 unlock_oom:
 585         mutex_unlock(&oom_lock);
 586         return ret;
 587 }
 588
 589 #define MAX_OOM_REAP_RETRIES 10
 590 static void oom_reap_task(struct task_struct *tsk)
 591 {
 592         int attempts = 0;
 593         struct mm_struct *mm = tsk->signal->oom_mm;
 594
 595         /* Retry the down_read_trylock(mmap_sem) a few times */
 596         while (attempts++ < MAX_OOM_REAP_RETRIES && !oom_reap_task_mm(tsk, mm))
 597                 schedule_timeout_idle(HZ/10);
 598
 599         if (attempts <= MAX_OOM_REAP_RETRIES ||
 600             test_bit(MMF_OOM_SKIP, &mm->flags))
 601                 goto done;
 602
 603         pr_info("oom_reaper: unable to reap pid:%d (%s)\n",
 604                 task_pid_nr(tsk), tsk->comm);
 605         debug_show_all_locks();
 606
 607 done:
 608         tsk->oom_reaper_list = NULL;
 609
 610         /*
 611          * Hide this mm from OOM killer because it has been either reaped or
 612          * somebody can't call up_write(mmap_sem).
 613          */
 614         set_bit(MMF_OOM_SKIP, &mm->flags);
 615
 616         /* Drop a reference taken by wake_oom_reaper */
 617         put_task_struct(tsk);
 618 }
 619
 620 static int oom_reaper(void *unused)
 621 {
 622         while (true) {
 623                 struct task_struct *tsk = NULL;
 624
 625                 wait_event_freezable(oom_reaper_wait, oom_reaper_list != NULL);
 626                 spin_lock(&oom_reaper_lock);
 627                 if (oom_reaper_list != NULL) {
 628                         tsk = oom_reaper_list;
 629                         oom_reaper_list = tsk->oom_reaper_list;
 630                 }
 631                 spin_unlock(&oom_reaper_lock);
 632
 633                 if (tsk)
 634                         oom_reap_task(tsk);
 635         }
 636
 637         return 0;
 638 }
 639
 640 static void wake_oom_reaper(struct task_struct *tsk)
 641 {
 642         /* tsk is already queued? */
 643         if (tsk == oom_reaper_list || tsk->oom_reaper_list)
 644                 return;
 645
 646         get_task_struct(tsk);
 647
 648         spin_lock(&oom_reaper_lock);
 649         tsk->oom_reaper_list = oom_reaper_list;
 650         oom_reaper_list = tsk;
 651         spin_unlock(&oom_reaper_lock);
 652         trace_wake_reaper(tsk->pid);
 653         wake_up(&oom_reaper_wait);
 654 }
 655
 656 static int __init oom_init(void)
 657 {
 658         oom_reaper_th = kthread_run(oom_reaper, NULL, "oom_reaper");
 659         return 0;
 660 }
 661 subsys_initcall(oom_init)
 662 #else
 663 static inline void wake_oom_reaper(struct task_struct *tsk)
 664 {
 665 }
 666 #endif /* CONFIG_MMU */
 667
 668 /**
 669  * mark_oom_victim - mark the given task as OOM victim
 670  * @tsk: task to mark
 671  *
 672  * Has to be called with oom_lock held and never after
 673  * oom has been disabled already.
 674  *
 675  * tsk->mm has to be non NULL and caller has to guarantee it is stable (either
 676  * under task_lock or operate on the current).
 677  */
 678 static void mark_oom_victim(struct task_struct *tsk)
 679 {
 680         struct mm_struct *mm = tsk->mm;
 681
 682         WARN_ON(oom_killer_disabled);
 683         /* OOM killer might race with memcg OOM */
 684         if (test_and_set_tsk_thread_flag(tsk, TIF_MEMDIE))
 685                 return;
 686
 687         /* oom_mm is bound to the signal struct life time. */
 688         if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm)) {
 689                 mmgrab(tsk->signal->oom_mm);
 690                 set_bit(MMF_OOM_VICTIM, &mm->flags);
 691         }
 692
 693         /*
 694          * Make sure that the task is woken up from uninterruptible sleep
 695          * if it is frozen because OOM killer wouldn't be able to free
 696          * any memory and livelock. freezing_slow_path will tell the freezer
 697          * that TIF_MEMDIE tasks should be ignored.
 698          */
 699         __thaw_task(tsk);
 700         atomic_inc(&oom_victims);
 701         trace_mark_victim(tsk->pid);
 702 }
 703
 704 /**
 705  * exit_oom_victim - note the exit of an OOM victim
 706  */
 707 void exit_oom_victim(void)
 708 {
 709         clear_thread_flag(TIF_MEMDIE);
 710
 711         if (!atomic_dec_return(&oom_victims))
 712                 wake_up_all(&oom_victims_wait);
 713 }
 714
 715 /**
 716  * oom_killer_enable - enable OOM killer
 717  */
 718 void oom_killer_enable(void)
 719 {
 720         oom_killer_disabled = false;
 721         pr_info("OOM killer enabled.\n");
 722 }
 723
 724 /**
 725  * oom_killer_disable - disable OOM killer
 726  * @timeout: maximum timeout to wait for oom victims in jiffies
 727  *
 728  * Forces all page allocations to fail rather than trigger OOM killer.
 729  * Will block and wait until all OOM victims are killed or the given
 730  * timeout expires.
 731  *
 732  * The function cannot be called when there are runnable user tasks because
 733  * the userspace would see unexpected allocation failures as a result. Any
 734  * new usage of this function should be consulted with MM people.
 735  *
 736  * Returns true if successful and false if the OOM killer cannot be
 737  * disabled.
 738  */
 739 bool oom_killer_disable(signed long timeout)
 740 {
 741         signed long ret;
 742
 743         /*
 744          * Make sure to not race with an ongoing OOM killer. Check that the
 745          * current is not killed (possibly due to sharing the victim's memory).
 746          */
 747         if (mutex_lock_killable(&oom_lock))
 748                 return false;
 749         oom_killer_disabled = true;
 750         mutex_unlock(&oom_lock);
 751
 752         ret = wait_event_interruptible_timeout(oom_victims_wait,
 753                         !atomic_read(&oom_victims), timeout);
 754         if (ret <= 0) {
 755                 oom_killer_enable();
 756                 return false;
 757         }
 758         pr_info("OOM killer disabled.\n");
 759
 760         return true;
 761 }
 762
 763 static inline bool __task_will_free_mem(struct task_struct *task)
 764 {
 765         struct signal_struct *sig = task->signal;
 766
 767         /*
 768          * A coredumping process may sleep for an extended period in exit_mm(),
 769          * so the oom killer cannot assume that the process will promptly exit
 770          * and release memory.
 771          */
 772         if (sig->flags & SIGNAL_GROUP_COREDUMP)
 773                 return false;
 774
 775         if (sig->flags & SIGNAL_GROUP_EXIT)
 776                 return true;
 777
 778         if (thread_group_empty(task) && (task->flags & PF_EXITING))
 779                 return true;
 780
 781         return false;
 782 }
 783
 784 /*
 785  * Checks whether the given task is dying or exiting and likely to
 786  * release its address space. This means that all threads and processes
 787  * sharing the same mm have to be killed or exiting.
 788  * Caller has to make sure that task->mm is stable (hold task_lock or
 789  * it operates on the current).
 790  */
 791 static bool task_will_free_mem(struct task_struct *task)
 792 {
 793         struct mm_struct *mm = task->mm;
 794         struct task_struct *p;
 795         bool ret = true;
 796
 797         /*
 798          * Skip tasks without mm because it might have passed its exit_mm and
 799          * exit_oom_victim. oom_reaper could have rescued that but do not rely
 800          * on that for now. We can consider find_lock_task_mm in future.
 801          */
 802         if (!mm)
 803                 return false;
 804
 805         if (!__task_will_free_mem(task))
 806                 return false;
 807
 808         /*
 809          * This task has already been drained by the oom reaper so there are
 810          * only small chances it will free some more
 811          */
 812         if (test_bit(MMF_OOM_SKIP, &mm->flags))
 813                 return false;
 814
 815         if (atomic_read(&mm->mm_users) <= 1)
 816                 return true;
 817
 818         /*
 819          * Make sure that all tasks which share the mm with the given tasks
 820          * are dying as well to make sure that a) nobody pins its mm and
 821          * b) the task is also reapable by the oom reaper.
 822          */
 823         rcu_read_lock();
 824         for_each_process(p) {
 825                 if (!process_shares_mm(p, mm))
 826                         continue;
 827                 if (same_thread_group(task, p))
 828                         continue;
 829                 ret = __task_will_free_mem(p);
 830                 if (!ret)
 831                         break;
 832         }
 833         rcu_read_unlock();
 834
 835         return ret;
 836 }
 837
 838 static void oom_kill_process(struct oom_control *oc, const char *message)
 839 {
 840         struct task_struct *p = oc->chosen;
 841         unsigned int points = oc->chosen_points;
 842         struct task_struct *victim = p;
 843         struct task_struct *child;
 844         struct task_struct *t;
 845         struct mm_struct *mm;
 846         unsigned int victim_points = 0;
 847         static DEFINE_RATELIMIT_STATE(oom_rs, DEFAULT_RATELIMIT_INTERVAL,
 848                                               DEFAULT_RATELIMIT_BURST);
 849         bool can_oom_reap = true;
 850
 851         /*
 852          * If the task is already exiting, don't alarm the sysadmin or kill
 853          * its children or threads, just give it access to memory reserves
 854          * so it can die quickly
 855          */
 856         task_lock(p);
 857         if (task_will_free_mem(p)) {
 858                 mark_oom_victim(p);
 859                 wake_oom_reaper(p);
 860                 task_unlock(p);
 861                 put_task_struct(p);
 862                 return;
 863         }
 864         task_unlock(p);
 865
 866         if (__ratelimit(&oom_rs))
 867                 dump_header(oc, p);
 868
 869         pr_err("%s: Kill process %d (%s) score %u or sacrifice child\n",
 870                 message, task_pid_nr(p), p->comm, points);
 871
 872         /*
 873          * If any of p's children has a different mm and is eligible for kill,
 874          * the one with the highest oom_badness() score is sacrificed for its
 875          * parent.  This attempts to lose the minimal amount of work done while
 876          * still freeing memory.
 877          */
 878         read_lock(&tasklist_lock);
 879         for_each_thread(p, t) {
 880                 list_for_each_entry(child, &t->children, sibling) {
 881                         unsigned int child_points;
 882
 883                         if (process_shares_mm(child, p->mm))
 884                                 continue;
 885                         /*
 886                          * oom_badness() returns 0 if the thread is unkillable
 887                          */
 888                         child_points = oom_badness(child,
 889                                 oc->memcg, oc->nodemask, oc->totalpages);
 890                         if (child_points > victim_points) {
 891                                 put_task_struct(victim);
 892                                 victim = child;
 893                                 victim_points = child_points;
 894                                 get_task_struct(victim);
 895                         }
 896                 }
 897         }
 898         read_unlock(&tasklist_lock);
 899
 900         p = find_lock_task_mm(victim);
 901         if (!p) {
 902                 put_task_struct(victim);
 903                 return;
 904         } else if (victim != p) {
 905                 get_task_struct(p);
 906                 put_task_struct(victim);
 907                 victim = p;
 908         }
 909
 910         /* Get a reference to safely compare mm after task_unlock(victim) */
 911         mm = victim->mm;
 912         mmgrab(mm);
 913
 914         /* Raise event before sending signal: task reaper must see this */
 915         count_vm_event(OOM_KILL);
 916         memcg_memory_event_mm(mm, MEMCG_OOM_KILL);
 917
 918         /*
 919          * We should send SIGKILL before granting access to memory reserves
 920          * in order to prevent the OOM victim from depleting the memory
 921          * reserves from the user space under its control.
 922          */
 923         do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
 924         mark_oom_victim(victim);
 925         pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
 926                 task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
 927                 K(get_mm_counter(victim->mm, MM_ANONPAGES)),
 928                 K(get_mm_counter(victim->mm, MM_FILEPAGES)),
 929                 K(get_mm_counter(victim->mm, MM_SHMEMPAGES)));
 930         task_unlock(victim);
 931
 932         /*
 933          * Kill all user processes sharing victim->mm in other thread groups, if
 934          * any.  They don't get access to memory reserves, though, to avoid
 935          * depletion of all memory.  This prevents mm->mmap_sem livelock when an
 936          * oom killed thread cannot exit because it requires the semaphore and
 937          * its contended by another thread trying to allocate memory itself.
 938          * That thread will now get access to memory reserves since it has a
 939          * pending fatal signal.
 940          */
 941         rcu_read_lock();
 942         for_each_process(p) {
 943                 if (!process_shares_mm(p, mm))
 944                         continue;
 945                 if (same_thread_group(p, victim))
 946                         continue;
 947                 if (is_global_init(p)) {
 948                         can_oom_reap = false;
 949                         set_bit(MMF_OOM_SKIP, &mm->flags);
 950                         pr_info("oom killer %d (%s) has mm pinned by %d (%s)\n",
 951                                         task_pid_nr(victim), victim->comm,
 952                                         task_pid_nr(p), p->comm);
 953                         continue;
 954                 }
 955                 /*
 956                  * No use_mm() user needs to read from the userspace so we are
 957                  * ok to reap it.
 958                  */
 959                 if (unlikely(p->flags & PF_KTHREAD))
 960                         continue;
 961                 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true);
 962         }
 963         rcu_read_unlock();
 964
 965         if (can_oom_reap)
 966                 wake_oom_reaper(victim);
 967
 968         mmdrop(mm);
 969         put_task_struct(victim);
 970 }
 971 #undef K
 972
 973 /*
 974  * Determines whether the kernel must panic because of the panic_on_oom sysctl.
 975  */
 976 static void check_panic_on_oom(struct oom_control *oc,
 977                                enum oom_constraint constraint)
 978 {
 979         if (likely(!sysctl_panic_on_oom))
 980                 return;
 981         if (sysctl_panic_on_oom != 2) {
 982                 /*
 983                  * panic_on_oom == 1 only affects CONSTRAINT_NONE, the kernel
 984                  * does not panic for cpuset, mempolicy, or memcg allocation
 985                  * failures.
 986                  */
 987                 if (constraint != CONSTRAINT_NONE)
 988                         return;
 989         }
 990         /* Do not panic for oom kills triggered by sysrq */
 991         if (is_sysrq_oom(oc))
 992                 return;
 993         dump_header(oc, NULL);
 994         panic("Out of memory: %s panic_on_oom is enabled\n",
 995                 sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide");
 996 }
 997
 998 static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
 999
1000 int register_oom_notifier(struct notifier_block *nb)
1001 {
1002         return blocking_notifier_chain_register(&oom_notify_list, nb);
1003 }
1004 EXPORT_SYMBOL_GPL(register_oom_notifier);
1005
1006 int unregister_oom_notifier(struct notifier_block *nb)
1007 {
1008         return blocking_notifier_chain_unregister(&oom_notify_list, nb);
1009 }
1010 EXPORT_SYMBOL_GPL(unregister_oom_notifier);
1011
1012 /**
1013  * out_of_memory - kill the "best" process when we run out of memory
1014  * @oc: pointer to struct oom_control
1015  *
1016  * If we run out of memory, we have the choice between either
1017  * killing a random task (bad), letting the system crash (worse)
1018  * OR try to be smart about which process to kill. Note that we
1019  * don't have to be perfect here, we just have to be good.
1020  */
1021 bool out_of_memory(struct oom_control *oc)
1022 {
1023         unsigned long freed = 0;
1024         enum oom_constraint constraint = CONSTRAINT_NONE;
1025
1026         if (oom_killer_disabled)
1027                 return false;
1028
1029         if (!is_memcg_oom(oc)) {
1030                 blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
1031                 if (freed > 0)
1032                         /* Got some memory back in the last second. */
1033                         return true;
1034         }
1035
1036         /*
1037          * If current has a pending SIGKILL or is exiting, then automatically
1038          * select it.  The goal is to allow it to allocate so that it may
1039          * quickly exit and free its memory.
1040          */
1041         if (task_will_free_mem(current)) {
1042                 mark_oom_victim(current);
1043                 wake_oom_reaper(current);
1044                 return true;
1045         }
1046
1047         /*
1048          * The OOM killer does not compensate for IO-less reclaim.
1049          * pagefault_out_of_memory lost its gfp context so we have to
1050          * make sure exclude 0 mask - all other users should have at least
1051          * ___GFP_DIRECT_RECLAIM to get here.
1052          */
1053         if (oc->gfp_mask && !(oc->gfp_mask & __GFP_FS))
1054                 return true;
1055
1056         /*
1057          * Check if there were limitations on the allocation (only relevant for
1058          * NUMA and memcg) that may require different handling.
1059          */
1060         constraint = constrained_alloc(oc);
1061         if (constraint != CONSTRAINT_MEMORY_POLICY)
1062                 oc->nodemask = NULL;
1063         check_panic_on_oom(oc, constraint);
1064
1065         if (!is_memcg_oom(oc) && sysctl_oom_kill_allocating_task &&
1066             current->mm && !oom_unkillable_task(current, NULL, oc->nodemask) &&
1067             current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) {
1068                 get_task_struct(current);
1069                 oc->chosen = current;
1070                 oom_kill_process(oc, "Out of memory (oom_kill_allocating_task)");
1071                 return true;
1072         }
1073
1074         select_bad_process(oc);
1075         /* Found nothing?!?! Either we hang forever, or we panic. */
1076         if (!oc->chosen && !is_sysrq_oom(oc) && !is_memcg_oom(oc)) {
1077                 dump_header(oc, NULL);
1078                 panic("Out of memory and no killable processes...\n");
1079         }
1080         if (oc->chosen && oc->chosen != (void *)-1UL) {
1081                 oom_kill_process(oc, !is_memcg_oom(oc) ? "Out of memory" :
1082                                  "Memory cgroup out of memory");
1083                 /*
1084                  * Give the killed process a good chance to exit before trying
1085                  * to allocate memory again.
1086                  */
1087                 schedule_timeout_killable(1);
1088         }
1089         return !!oc->chosen;
1090 }
1091
1092 /*
1093  * The pagefault handler calls here because it is out of memory, so kill a
1094  * memory-hogging task. If oom_lock is held by somebody else, a parallel oom
1095  * killing is already in progress so do nothing.
1096  */
1097 void pagefault_out_of_memory(void)
1098 {
1099         struct oom_control oc = {
1100                 .zonelist = NULL,
1101                 .nodemask = NULL,
1102                 .memcg = NULL,
1103                 .gfp_mask = 0,
1104                 .order = 0,
1105         };
1106
1107         if (mem_cgroup_oom_synchronize(true))
1108                 return;
1109
1110         if (!mutex_trylock(&oom_lock))
1111                 return;
1112         out_of_memory(&oc);
1113         mutex_unlock(&oom_lock);
1114 }