1 files changed, 112 insertions, 111 deletions

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index ac300c99baf6..198600861638 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -288,76 +288,93 @@ static enum oom_constraint constrained_alloc(struct zonelist *zonelist,
 }
 #endif
 
+enum oom_scan_t oom_scan_process_thread(struct task_struct *task,
+                unsigned long totalpages, const nodemask_t *nodemask,
+                bool force_kill)
+{
+        if (task->exit_state)
+                return OOM_SCAN_CONTINUE;
+        if (oom_unkillable_task(task, NULL, nodemask))
+                return OOM_SCAN_CONTINUE;
+
+        /*
+         * This task already has access to memory reserves and is being killed.
+         * Don't allow any other task to have access to the reserves.
+         */
+        if (test_tsk_thread_flag(task, TIF_MEMDIE)) {
+                if (unlikely(frozen(task)))
+                        __thaw_task(task);
+                if (!force_kill)
+                        return OOM_SCAN_ABORT;
+        }
+        if (!task->mm)
+                return OOM_SCAN_CONTINUE;
+
+        if (task->flags & PF_EXITING) {
+                /*
+                 * If task is current and is in the process of releasing memory,
+                 * allow the "kill" to set TIF_MEMDIE, which will allow it to
+                 * access memory reserves.  Otherwise, it may stall forever.
+                 *
+                 * The iteration isn't broken here, however, in case other
+                 * threads are found to have already been oom killed.
+                 */
+                if (task == current)
+                        return OOM_SCAN_SELECT;
+                else if (!force_kill) {
+                        /*
+                         * If this task is not being ptraced on exit, then wait
+                         * for it to finish before killing some other task
+                         * unnecessarily.
+                         */
+                        if (!(task->group_leader->ptrace & PT_TRACE_EXIT))
+                                return OOM_SCAN_ABORT;
+                }
+        }
+        return OOM_SCAN_OK;
+}
+
 /*
  * Simple selection loop. We chose the process with the highest
- * number of 'points'. We expect the caller will lock the tasklist.
+ * number of 'points'.
  *
  * (not docbooked, we don't want this one cluttering up the manual)
  */
 static struct task_struct *select_bad_process(unsigned int *ppoints,
-                unsigned long totalpages, struct mem_cgroup *memcg,
-                const nodemask_t *nodemask, bool force_kill)
+                unsigned long totalpages, const nodemask_t *nodemask,
+                bool force_kill)
 {
         struct task_struct *g, *p;
         struct task_struct *chosen = NULL;
         unsigned long chosen_points = 0;
 
+        rcu_read_lock();
         do_each_thread(g, p) {
                 unsigned int points;
 
-                if (p->exit_state)
-                        continue;
-                if (oom_unkillable_task(p, memcg, nodemask))
-                        continue;
-
-                /*
-                 * This task already has access to memory reserves and is
-                 * being killed. Don't allow any other task access to the
-                 * memory reserve.
-                 *
-                 * Note: this may have a chance of deadlock if it gets
-                 * blocked waiting for another task which itself is waiting
-                 * for memory. Is there a better alternative?
-                 */
-                if (test_tsk_thread_flag(p, TIF_MEMDIE)) {
-                        if (unlikely(frozen(p)))
-                                __thaw_task(p);
-                        if (!force_kill)
-                                return ERR_PTR(-1UL);
-                }
-                if (!p->mm)
+                switch (oom_scan_process_thread(p, totalpages, nodemask,
+                                                force_kill)) {
+                case OOM_SCAN_SELECT:
+                        chosen = p;
+                        chosen_points = ULONG_MAX;
+                        /* fall through */
+                case OOM_SCAN_CONTINUE:
                         continue;
-
-                if (p->flags & PF_EXITING) {
-                        /*
-                         * If p is the current task and is in the process of
-                         * releasing memory, we allow the "kill" to set
-                         * TIF_MEMDIE, which will allow it to gain access to
-                         * memory reserves.  Otherwise, it may stall forever.
-                         *
-                         * The loop isn't broken here, however, in case other
-                         * threads are found to have already been oom killed.
-                         */
-                        if (p == current) {
-                                chosen = p;
-                                chosen_points = ULONG_MAX;
-                        } else if (!force_kill) {
-                                /*
-                                 * If this task is not being ptraced on exit,
-                                 * then wait for it to finish before killing
-                                 * some other task unnecessarily.
-                                 */
-                                if (!(p->group_leader->ptrace & PT_TRACE_EXIT))
-                                        return ERR_PTR(-1UL);
-                        }
-                }
-
-                points = oom_badness(p, memcg, nodemask, totalpages);
+                case OOM_SCAN_ABORT:
+                        rcu_read_unlock();
+                        return ERR_PTR(-1UL);
+                case OOM_SCAN_OK:
+                        break;
+                };
+                points = oom_badness(p, NULL, nodemask, totalpages);
                 if (points > chosen_points) {
                         chosen = p;
                         chosen_points = points;
                 }
         } while_each_thread(g, p);
+        if (chosen)
+                get_task_struct(chosen);
+        rcu_read_unlock();
 
         *ppoints = chosen_points * 1000 / totalpages;
         return chosen;
@@ -371,17 +388,16 @@ static struct task_struct *select_bad_process(unsigned int *ppoints,
  * Dumps the current memory state of all eligible tasks.  Tasks not in the same
  * memcg, not in the same cpuset, or bound to a disjoint set of mempolicy nodes
  * are not shown.
- * State information includes task's pid, uid, tgid, vm size, rss, cpu, oom_adj
- * value, oom_score_adj value, and name.
- *
- * Call with tasklist_lock read-locked.
+ * State information includes task's pid, uid, tgid, vm size, rss, nr_ptes,
+ * swapents, oom_score_adj value, and name.
  */
 static void dump_tasks(const struct mem_cgroup *memcg, const nodemask_t *nodemask)
 {
         struct task_struct *p;
         struct task_struct *task;
 
-        pr_info("[ pid ]   uid  tgid total_vm      rss cpu oom_adj oom_score_adj name\n");
+        pr_info("[ pid ]   uid  tgid total_vm      rss nr_ptes swapents oom_score_adj name\n");
+        rcu_read_lock();
         for_each_process(p) {
                 if (oom_unkillable_task(p, memcg, nodemask))
                         continue;
@@ -396,13 +412,15 @@ static void dump_tasks(const struct mem_cgroup *memcg, const nodemask_t *nodemas
                         continue;
                 }
 
-                pr_info("[%5d] %5d %5d %8lu %8lu %3u     %3d         %5d %s\n",
+                pr_info("[%5d] %5d %5d %8lu %8lu %7lu %8lu         %5d %s\n",
                         task->pid, from_kuid(&init_user_ns, task_uid(task)),
                         task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
-                        task_cpu(task), task->signal->oom_adj,
+                        task->mm->nr_ptes,
+                        get_mm_counter(task->mm, MM_SWAPENTS),
                         task->signal->oom_score_adj, task->comm);
                 task_unlock(task);
         }
+        rcu_read_unlock();
 }
 
 static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order,
@@ -423,10 +441,14 @@ static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order,
 }
 
 #define K(x) ((x) << (PAGE_SHIFT-10))
-static void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
-                             unsigned int points, unsigned long totalpages,
-                             struct mem_cgroup *memcg, nodemask_t *nodemask,
-                             const char *message)
+/*
+ * Must be called while holding a reference to p, which will be released upon
+ * returning.
+ */
+void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
+                      unsigned int points, unsigned long totalpages,
+                      struct mem_cgroup *memcg, nodemask_t *nodemask,
+                      const char *message)
 {
         struct task_struct *victim = p;
         struct task_struct *child;
@@ -442,6 +464,7 @@ static void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
          */
         if (p->flags & PF_EXITING) {
                 set_tsk_thread_flag(p, TIF_MEMDIE);
+                put_task_struct(p);
                 return;
         }
 
@@ -459,6 +482,7 @@ static void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
          * parent.  This attempts to lose the minimal amount of work done while
          * still freeing memory.
          */
+        read_lock(&tasklist_lock);
         do {
                 list_for_each_entry(child, &t->children, sibling) {
                         unsigned int child_points;
@@ -471,15 +495,26 @@ static void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                         child_points = oom_badness(child, memcg, nodemask,
                                                                 totalpages);
                         if (child_points > victim_points) {
+                                put_task_struct(victim);
                                 victim = child;
                                 victim_points = child_points;
+                                get_task_struct(victim);
                         }
                 }
         } while_each_thread(p, t);
+        read_unlock(&tasklist_lock);
 
-        victim = find_lock_task_mm(victim);
-        if (!victim)
+        rcu_read_lock();
+        p = find_lock_task_mm(victim);
+        if (!p) {
+                rcu_read_unlock();
+                put_task_struct(victim);
                 return;
+        } else if (victim != p) {
+                get_task_struct(p);
+                put_task_struct(victim);
+                victim = p;
+        }
 
         /* mm cannot safely be dereferenced after task_unlock(victim) */
         mm = victim->mm;
@@ -510,17 +545,19 @@ static void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                         task_unlock(p);
                         do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true);
                 }
+        rcu_read_unlock();
 
         set_tsk_thread_flag(victim, TIF_MEMDIE);
         do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
+        put_task_struct(victim);
 }
 #undef K
 
 /*
  * Determines whether the kernel must panic because of the panic_on_oom sysctl.
  */
-static void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
-                                int order, const nodemask_t *nodemask)
+void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
+                        int order, const nodemask_t *nodemask)
 {
         if (likely(!sysctl_panic_on_oom))
                 return;
@@ -533,42 +570,11 @@ static void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
                 if (constraint != CONSTRAINT_NONE)
                         return;
         }
-        read_lock(&tasklist_lock);
         dump_header(NULL, gfp_mask, order, NULL, nodemask);
-        read_unlock(&tasklist_lock);
         panic("Out of memory: %s panic_on_oom is enabled\n",
                 sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide");
 }
 
-#ifdef CONFIG_CGROUP_MEM_RES_CTLR
-void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
-                              int order)
-{
-        unsigned long limit;
-        unsigned int points = 0;
-        struct task_struct *p;
-
-        /*
-         * If current has a pending SIGKILL, then automatically select it.  The
-         * goal is to allow it to allocate so that it may quickly exit and free
-         * its memory.
-         */
-        if (fatal_signal_pending(current)) {
-                set_thread_flag(TIF_MEMDIE);
-                return;
-        }
-
-        check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, order, NULL);
-        limit = mem_cgroup_get_limit(memcg) >> PAGE_SHIFT ? : 1;
-        read_lock(&tasklist_lock);
-        p = select_bad_process(&points, limit, memcg, NULL, false);
-        if (p && PTR_ERR(p) != -1UL)
-                oom_kill_process(p, gfp_mask, order, points, limit, memcg, NULL,
-                                 "Memory cgroup out of memory");
-        read_unlock(&tasklist_lock);
-}
-#endif
-
 static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
 
 int register_oom_notifier(struct notifier_block *nb)
@@ -690,7 +696,7 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
         struct task_struct *p;
         unsigned long totalpages;
         unsigned long freed = 0;
-        unsigned int points;
+        unsigned int uninitialized_var(points);
         enum oom_constraint constraint = CONSTRAINT_NONE;
         int killed = 0;
 
@@ -718,22 +724,20 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
         mpol_mask = (constraint == CONSTRAINT_MEMORY_POLICY) ? nodemask : NULL;
         check_panic_on_oom(constraint, gfp_mask, order, mpol_mask);
 
-        read_lock(&tasklist_lock);
-        if (sysctl_oom_kill_allocating_task &&
+        if (sysctl_oom_kill_allocating_task && current->mm &&
             !oom_unkillable_task(current, NULL, nodemask) &&
-            current->mm) {
+            current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) {
+                get_task_struct(current);
                 oom_kill_process(current, gfp_mask, order, 0, totalpages, NULL,
                                  nodemask,
                                  "Out of memory (oom_kill_allocating_task)");
                 goto out;
         }
 
-        p = select_bad_process(&points, totalpages, NULL, mpol_mask,
-                               force_kill);
+        p = select_bad_process(&points, totalpages, mpol_mask, force_kill);
         /* Found nothing?!?! Either we hang forever, or we panic. */
         if (!p) {
                 dump_header(NULL, gfp_mask, order, NULL, mpol_mask);
-                read_unlock(&tasklist_lock);
                 panic("Out of memory and no killable processes...\n");
         }
         if (PTR_ERR(p) != -1UL) {
@@ -742,14 +746,12 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
                 killed = 1;
         }
 out:
-        read_unlock(&tasklist_lock);
-
         /*
-         * Give "p" a good chance of killing itself before we
-         * retry to allocate memory unless "p" is current
+         * Give the killed threads a good chance of exiting before trying to
+         * allocate memory again.
          */
-        if (killed && !test_thread_flag(TIF_MEMDIE))
-                schedule_timeout_uninterruptible(1);
+        if (killed)
+                schedule_timeout_killable(1);
 }
 
 /*
@@ -764,6 +766,5 @@ void pagefault_out_of_memory(void)
                 out_of_memory(NULL, 0, 0, NULL, false);
                 clear_system_oom();
         }
-        if (!test_thread_flag(TIF_MEMDIE))
-                schedule_timeout_uninterruptible(1);
+        schedule_timeout_killable(1);
 }