team: don't call netdev_change_features under team->lock

[cascardo/linux.git] / mm / oom_kill.c

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 415f7eb..5bb2f76 100644 (file)
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -174,8 +174,13 @@ unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,
        if (!p)
                return 0;
 
+       /*
+        * Do not even consider tasks which are explicitly marked oom
+        * unkillable or have been already oom reaped.
+        */
        adj = (long)p->signal->oom_score_adj;
-       if (adj == OOM_SCORE_ADJ_MIN) {
+       if (adj == OOM_SCORE_ADJ_MIN ||
+                       test_bit(MMF_OOM_REAPED, &p->mm->flags)) {
                task_unlock(p);
                return 0;
        }
@@ -278,12 +283,8 @@ enum oom_scan_t oom_scan_process_thread(struct oom_control *oc,
         * 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 (!is_sysrq_oom(oc))
-                       return OOM_SCAN_ABORT;
-       }
-       if (!task->mm)
-               return OOM_SCAN_CONTINUE;
+       if (!is_sysrq_oom(oc) && atomic_read(&task->signal->oom_victims))
+               return OOM_SCAN_ABORT;
 
        /*
         * If task is allocating a lot of memory and has been marked to be
@@ -302,12 +303,12 @@ enum oom_scan_t oom_scan_process_thread(struct oom_control *oc,
 static struct task_struct *select_bad_process(struct oom_control *oc,
                unsigned int *ppoints, unsigned long totalpages)
 {
-       struct task_struct *g, *p;
+       struct task_struct *p;
        struct task_struct *chosen = NULL;
        unsigned long chosen_points = 0;
 
        rcu_read_lock();
-       for_each_process_thread(g, p) {
+       for_each_process(p) {
                unsigned int points;
 
                switch (oom_scan_process_thread(oc, p, totalpages)) {
@@ -326,9 +327,6 @@ static struct task_struct *select_bad_process(struct oom_control *oc,
                points = oom_badness(p, NULL, oc->nodemask, totalpages);
                if (!points || points < chosen_points)
                        continue;
-               /* Prefer thread group leaders for display purposes */
-               if (points == chosen_points && thread_group_leader(chosen))
-                       continue;
 
                chosen = p;
                chosen_points = points;
@@ -441,7 +439,6 @@ static DECLARE_WAIT_QUEUE_HEAD(oom_reaper_wait);
 static struct task_struct *oom_reaper_list;
 static DEFINE_SPINLOCK(oom_reaper_lock);
 
-
 static bool __oom_reap_task(struct task_struct *tsk)
 {
        struct mmu_gather tlb;
@@ -513,9 +510,14 @@ static bool __oom_reap_task(struct task_struct *tsk)
         * This task can be safely ignored because we cannot do much more
         * to release its memory.
         */
-       tsk->signal->oom_score_adj = OOM_SCORE_ADJ_MIN;
+       set_bit(MMF_OOM_REAPED, &mm->flags);
 out:
-       mmput(mm);
+       /*
+        * Drop our reference but make sure the mmput slow path is called from a
+        * different context because we shouldn't risk we get stuck there and
+        * put the oom_reaper out of the way.
+        */
+       mmput_async(mm);
        return ret;
 }
 
@@ -664,6 +666,7 @@ void mark_oom_victim(struct task_struct *tsk)
        /* OOM killer might race with memcg OOM */
        if (test_and_set_tsk_thread_flag(tsk, TIF_MEMDIE))
                return;
+       atomic_inc(&tsk->signal->oom_victims);
        /*
         * Make sure that the task is woken up from uninterruptible sleep
         * if it is frozen because OOM killer wouldn't be able to free
@@ -681,6 +684,7 @@ void exit_oom_victim(struct task_struct *tsk)
 {
        if (!test_and_clear_tsk_thread_flag(tsk, TIF_MEMDIE))
                return;
+       atomic_dec(&tsk->signal->oom_victims);
 
        if (!atomic_dec_return(&oom_victims))
                wake_up_all(&oom_victims_wait);