oom: move oom_adj value from task_struct to mm_struct

The per-task oom_adj value is a characteristic of its mm more than the
task itself since it's not possible to oom kill any thread that shares the
mm.  If a task were to be killed while attached to an mm that could not be
freed because another thread were set to OOM_DISABLE, it would have
needlessly been terminated since there is no potential for future memory
freeing.

This patch moves oomkilladj (now more appropriately named oom_adj) from
struct task_struct to struct mm_struct.  This requires task_lock() on a
task to check its oom_adj value to protect against exec, but it's already
necessary to take the lock when dereferencing the mm to find the total VM
size for the badness heuristic.

This fixes a livelock if the oom killer chooses a task and another thread
sharing the same memory has an oom_adj value of OOM_DISABLE.  This occurs
because oom_kill_task() repeatedly returns 1 and refuses to kill the
chosen task while select_bad_process() will repeatedly choose the same
task during the next retry.

Taking task_lock() in select_bad_process() to check for OOM_DISABLE and in
oom_kill_task() to check for threads sharing the same memory will be
removed in the next patch in this series where it will no longer be
necessary.

Writing to /proc/pid/oom_adj for a kthread will now return -EINVAL since
these threads are immune from oom killing already.  They simply report an
oom_adj value of OOM_DISABLE.

Cc: Nick Piggin <npiggin@suse.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 22 insertions, 12 deletions

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index a7b2460e922b..b60913520ef3 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -58,6 +58,7 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
         unsigned long points, cpu_time, run_time;
         struct mm_struct *mm;
         struct task_struct *child;
+        int oom_adj;
 
         task_lock(p);
         mm = p->mm;
@@ -65,6 +66,7 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
                 task_unlock(p);
                 return 0;
         }
+        oom_adj = mm->oom_adj;
 
         /*
          * The memory size of the process is the basis for the badness.
@@ -148,15 +150,15 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
                 points /= 8;
 
         /*
-         * Adjust the score by oomkilladj.
+         * Adjust the score by oom_adj.
          */
-        if (p->oomkilladj) {
-                if (p->oomkilladj > 0) {
+        if (oom_adj) {
+                if (oom_adj > 0) {
                         if (!points)
                                 points = 1;
-                        points <<= p->oomkilladj;
+                        points <<= oom_adj;
                 } else
-                        points >>= -(p->oomkilladj);
+                        points >>= -(oom_adj);
         }
 
 #ifdef DEBUG
@@ -251,8 +253,12 @@ static struct task_struct *select_bad_process(unsigned long *ppoints,
                         *ppoints = ULONG_MAX;
                 }
 
-                if (p->oomkilladj == OOM_DISABLE)
+                task_lock(p);
+                if (p->mm && p->mm->oom_adj == OOM_DISABLE) {
+                        task_unlock(p);
                         continue;
+                }
+                task_unlock(p);
 
                 points = badness(p, uptime.tv_sec);
                 if (points > *ppoints || !chosen) {
@@ -304,8 +310,7 @@ static void dump_tasks(const struct mem_cgroup *mem)
                 }
                 printk(KERN_INFO "[%5d] %5d %5d %8lu %8lu %3d     %3d %s\n",
                        p->pid, __task_cred(p)->uid, p->tgid, mm->total_vm,
-                       get_mm_rss(mm), (int)task_cpu(p), p->oomkilladj,
-                       p->comm);
+                       get_mm_rss(mm), (int)task_cpu(p), mm->oom_adj, p->comm);
                 task_unlock(p);
         } while_each_thread(g, p);
 }
@@ -367,8 +372,12 @@ static int oom_kill_task(struct task_struct *p)
          * Don't kill the process if any threads are set to OOM_DISABLE
          */
         do_each_thread(g, q) {
-                if (q->mm == mm && q->oomkilladj == OOM_DISABLE)
+                task_lock(q);
+                if (q->mm == mm && q->mm && q->mm->oom_adj == OOM_DISABLE) {
+                        task_unlock(q);
                         return 1;
+                }
+                task_unlock(q);
         } while_each_thread(g, q);
 
         __oom_kill_task(p, 1);
@@ -393,10 +402,11 @@ static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
         struct task_struct *c;
 
         if (printk_ratelimit()) {
-                printk(KERN_WARNING "%s invoked oom-killer: "
-                        "gfp_mask=0x%x, order=%d, oomkilladj=%d\n",
-                        current->comm, gfp_mask, order, current->oomkilladj);
                 task_lock(current);
+                printk(KERN_WARNING "%s invoked oom-killer: "
+                        "gfp_mask=0x%x, order=%d, oom_adj=%d\n",
+                        current->comm, gfp_mask, order,
+                        current->mm ? current->mm->oom_adj : OOM_DISABLE);
                 cpuset_print_task_mems_allowed(current);
                 task_unlock(current);
                 dump_stack();