mm: invoke oom-killer from page fault

[net-next-2.6.git] / mm / oom_kill.c

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 0e0b282a2073e97f7d575246a20d90326bc4e937..c592965dab2fc805411015cb879e3fb5a5eb7d38 100644 (file)
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -38,7 +38,6 @@ static DEFINE_SPINLOCK(zone_scan_mutex);
  * badness - calculate a numeric value for how bad this task has been
  * @p: task struct of which task we should calculate
  * @uptime: current uptime in seconds
- * @mem: target memory controller
  *
  * The formula used is relatively simple and documented inline in the
  * function. The main rationale is that we want to select a good task
@@ -295,6 +294,8 @@ static void dump_tasks(const struct mem_cgroup *mem)
                        continue;
                if (mem && !task_in_mem_cgroup(p, mem))
                        continue;
+               if (!thread_group_leader(p))
+                       continue;
 
                task_lock(p);
                printk(KERN_INFO "[%5d] %5d %5d %8lu %8lu %3d     %3d %s\n",
@@ -508,6 +509,69 @@ void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask)
        spin_unlock(&zone_scan_mutex);
 }
 
+/*
+ * Must be called with tasklist_lock held for read.
+ */
+static void __out_of_memory(gfp_t gfp_mask, int order)
+{
+       if (sysctl_oom_kill_allocating_task) {
+               oom_kill_process(current, gfp_mask, order, 0, NULL,
+                               "Out of memory (oom_kill_allocating_task)");
+
+       } else {
+               unsigned long points;
+               struct task_struct *p;
+
+retry:
+               /*
+                * Rambo mode: Shoot down a process and hope it solves whatever
+                * issues we may have.
+                */
+               p = select_bad_process(&points, NULL);
+
+               if (PTR_ERR(p) == -1UL)
+                       return;
+
+               /* Found nothing?!?! Either we hang forever, or we panic. */
+               if (!p) {
+                       read_unlock(&tasklist_lock);
+                       panic("Out of memory and no killable processes...\n");
+               }
+
+               if (oom_kill_process(p, gfp_mask, order, points, NULL,
+                                    "Out of memory"))
+                       goto retry;
+       }
+}
+
+/*
+ * pagefault handler calls into here because it is out of memory but
+ * doesn't know exactly how or why.
+ */
+void pagefault_out_of_memory(void)
+{
+       unsigned long freed = 0;
+
+       blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
+       if (freed > 0)
+               /* Got some memory back in the last second. */
+               return;
+
+       if (sysctl_panic_on_oom)
+               panic("out of memory from page fault. panic_on_oom is selected.\n");
+
+       read_lock(&tasklist_lock);
+       __out_of_memory(0, 0); /* unknown gfp_mask and order */
+       read_unlock(&tasklist_lock);
+
+       /*
+        * Give "p" a good chance of killing itself before we
+        * retry to allocate memory.
+        */
+       if (!test_thread_flag(TIF_MEMDIE))
+               schedule_timeout_uninterruptible(1);
+}
+
 /**
  * out_of_memory - kill the "best" process when we run out of memory
  * @zonelist: zonelist pointer
@@ -521,8 +585,6 @@ void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_mask)
  */
 void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
 {
-       struct task_struct *p;
-       unsigned long points = 0;
        unsigned long freed = 0;
        enum oom_constraint constraint;
 
@@ -543,7 +605,7 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
 
        switch (constraint) {
        case CONSTRAINT_MEMORY_POLICY:
-               oom_kill_process(current, gfp_mask, order, points, NULL,
+               oom_kill_process(current, gfp_mask, order, 0, NULL,
                                "No available memory (MPOL_BIND)");
                break;
 
@@ -552,35 +614,10 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
                        panic("out of memory. panic_on_oom is selected\n");
                /* Fall-through */
        case CONSTRAINT_CPUSET:
-               if (sysctl_oom_kill_allocating_task) {
-                       oom_kill_process(current, gfp_mask, order, points, NULL,
-                                       "Out of memory (oom_kill_allocating_task)");
-                       break;
-               }
-retry:
-               /*
-                * Rambo mode: Shoot down a process and hope it solves whatever
-                * issues we may have.
-                */
-               p = select_bad_process(&points, NULL);
-
-               if (PTR_ERR(p) == -1UL)
-                       goto out;
-
-               /* Found nothing?!?! Either we hang forever, or we panic. */
-               if (!p) {
-                       read_unlock(&tasklist_lock);
-                       panic("Out of memory and no killable processes...\n");
-               }
-
-               if (oom_kill_process(p, gfp_mask, order, points, NULL,
-                                    "Out of memory"))
-                       goto retry;
-
+               __out_of_memory(gfp_mask, order);
                break;
        }
 
-out:
        read_unlock(&tasklist_lock);
 
        /*