HWPOISON: return early on non-LRU pages

[safe/jmp/linux-2.6] / mm / oom_kill.c

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index a7b2460..ea2147d 100644 (file)
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -34,6 +34,23 @@ int sysctl_oom_dump_tasks;
 static DEFINE_SPINLOCK(zone_scan_lock);
 /* #define DEBUG */
 
+/*
+ * Is all threads of the target process nodes overlap ours?
+ */
+static int has_intersects_mems_allowed(struct task_struct *tsk)
+{
+       struct task_struct *t;
+
+       t = tsk;
+       do {
+               if (cpuset_mems_allowed_intersects(current, t))
+                       return 1;
+               t = next_thread(t);
+       } while (t != tsk);
+
+       return 0;
+}
+
 /**
  * badness - calculate a numeric value for how bad this task has been
  * @p: task struct of which task we should calculate
@@ -58,6 +75,13 @@ 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 = p->signal->oom_adj;
+       struct task_cputime task_time;
+       unsigned long utime;
+       unsigned long stime;
+
+       if (oom_adj == OOM_DISABLE)
+               return 0;
 
        task_lock(p);
        mm = p->mm;
@@ -79,7 +103,7 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
        /*
         * swapoff can easily use up all memory, so kill those first.
         */
-       if (p->flags & PF_SWAPOFF)
+       if (p->flags & PF_OOM_ORIGIN)
                return ULONG_MAX;
 
        /*
@@ -102,8 +126,11 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
          * of seconds. There is no particular reason for this other than
          * that it turned out to work very well in practice.
         */
-       cpu_time = (cputime_to_jiffies(p->utime) + cputime_to_jiffies(p->stime))
-               >> (SHIFT_HZ + 3);
+       thread_group_cputime(p, &task_time);
+       utime = cputime_to_jiffies(task_time.utime);
+       stime = cputime_to_jiffies(task_time.stime);
+       cpu_time = (utime + stime) >> (SHIFT_HZ + 3);
+
 
        if (uptime >= p->start_time.tv_sec)
                run_time = (uptime - p->start_time.tv_sec) >> 10;
@@ -144,19 +171,19 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
         * because p may have allocated or otherwise mapped memory on
         * this node before. However it will be less likely.
         */
-       if (!cpuset_mems_allowed_intersects(current, p))
+       if (!has_intersects_mems_allowed(p))
                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
@@ -200,13 +227,13 @@ static inline enum oom_constraint constrained_alloc(struct zonelist *zonelist,
 static struct task_struct *select_bad_process(unsigned long *ppoints,
                                                struct mem_cgroup *mem)
 {
-       struct task_struct *g, *p;
+       struct task_struct *p;
        struct task_struct *chosen = NULL;
        struct timespec uptime;
        *ppoints = 0;
 
        do_posix_clock_monotonic_gettime(&uptime);
-       do_each_thread(g, p) {
+       for_each_process(p) {
                unsigned long points;
 
                /*
@@ -251,7 +278,7 @@ static struct task_struct *select_bad_process(unsigned long *ppoints,
                        *ppoints = ULONG_MAX;
                }
 
-               if (p->oomkilladj == OOM_DISABLE)
+               if (p->signal->oom_adj == OOM_DISABLE)
                        continue;
 
                points = badness(p, uptime.tv_sec);
@@ -259,7 +286,7 @@ static struct task_struct *select_bad_process(unsigned long *ppoints,
                        chosen = p;
                        *ppoints = points;
                }
-       } while_each_thread(g, p);
+       }
 
        return chosen;
 }
@@ -304,7 +331,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,
+                      get_mm_rss(mm), (int)task_cpu(p), p->signal->oom_adj,
                       p->comm);
                task_unlock(p);
        } while_each_thread(g, p);
@@ -346,11 +373,6 @@ static void __oom_kill_task(struct task_struct *p, int verbose)
 
 static int oom_kill_task(struct task_struct *p)
 {
-       struct mm_struct *mm;
-       struct task_struct *g, *q;
-
-       mm = p->mm;
-
        /* WARNING: mm may not be dereferenced since we did not obtain its
         * value from get_task_mm(p).  This is OK since all we need to do is
         * compare mm to q->mm below.
@@ -359,30 +381,11 @@ static int oom_kill_task(struct task_struct *p)
         * change to NULL at any time since we do not hold task_lock(p).
         * However, this is of no concern to us.
         */
-
-       if (mm == NULL)
+       if (!p->mm || p->signal->oom_adj == OOM_DISABLE)
                return 1;
 
-       /*
-        * 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)
-                       return 1;
-       } while_each_thread(g, q);
-
        __oom_kill_task(p, 1);
 
-       /*
-        * kill all processes that share the ->mm (i.e. all threads),
-        * but are in a different thread group. Don't let them have access
-        * to memory reserves though, otherwise we might deplete all memory.
-        */
-       do_each_thread(g, q) {
-               if (q->mm == mm && !same_thread_group(q, p))
-                       force_sig(SIGKILL, q);
-       } while_each_thread(g, q);
-
        return 0;
 }
 
@@ -394,8 +397,9 @@ static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
 
        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);
+                       "gfp_mask=0x%x, order=%d, oom_adj=%d\n",
+                       current->comm, gfp_mask, order,
+                       current->signal->oom_adj);
                task_lock(current);
                cpuset_print_task_mems_allowed(current);
                task_unlock(current);