[PATCH] oom: handle current exiting

If current *is* exiting, it should actually be allowed to access reserved
memory rather than OOM kill something else.  Can't do this via a straight
check in page_alloc.c because that would allow multiple tasks to use up
reserves.  Instead cause current to OOM-kill itself which will mark it as
TIF_MEMDIE.

The current procedure of simply aborting the OOM-kill if a task is exiting can
lead to OOM deadlocks.

In the case of killing a PF_EXITING task, don't make a lot of noise about it.
This becomes more important in future patches, where we can "kill" OOM_DISABLE
tasks.

Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 31 insertions, 4 deletions

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 4f815b06ac1b..0131bae2a16d 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -210,11 +210,26 @@ static struct task_struct *select_bad_process(unsigned long *ppoints)
                 /*
                  * This is in the process of releasing memory so wait for it
                  * to finish before killing some other task by mistake.
+                 *
+                 * However, if p is the current task, we allow the 'kill' to
+                 * go ahead if it is exiting: this will simply set TIF_MEMDIE,
+                 * which will allow it to gain access to memory reserves in
+                 * the process of exiting and releasing its resources.
+                 * Otherwise we could get an OOM deadlock.
                  */
                 releasing = test_tsk_thread_flag(p, TIF_MEMDIE) ||
                                                 p->flags & PF_EXITING;
-                if (releasing && !(p->flags & PF_DEAD))
+                if (releasing) {
+                        /* PF_DEAD tasks have already released their mm */
+                        if (p->flags & PF_DEAD)
+                                continue;
+                        if (p->flags & PF_EXITING && p == current) {
+                                chosen = p;
+                                *ppoints = ULONG_MAX;
+                                break;
+                        }
                         return ERR_PTR(-1UL);
+                }
                 if (p->flags & PF_SWAPOFF)
                         return p;
 
@@ -248,8 +263,11 @@ static void __oom_kill_task(struct task_struct *p, const char *message)
                 return;
         }
         task_unlock(p);
-        printk(KERN_ERR "%s: Killed process %d (%s).\n",
+
+        if (message) {
+                printk(KERN_ERR "%s: Killed process %d (%s).\n",
                                 message, p->pid, p->comm);
+        }
 
         /*
          * We give our sacrificial lamb high priority and access to
@@ -300,8 +318,17 @@ static int oom_kill_process(struct task_struct *p, unsigned long points,
         struct task_struct *c;
         struct list_head *tsk;
 
-        printk(KERN_ERR "Out of Memory: Kill process %d (%s) score %li and "
-                "children.\n", p->pid, p->comm, points);
+        /*
+         * If the task is already exiting, don't alarm the sysadmin or kill
+         * its children or threads, just set TIF_MEMDIE so it can die quickly
+         */
+        if (p->flags & PF_EXITING) {
+                __oom_kill_task(p, NULL);
+                return 0;
+        }
+
+        printk(KERN_ERR "Out of Memory: Kill process %d (%s) score %li"
+                        " and children.\n", p->pid, p->comm, points);
         /* Try to kill a child first */
         list_for_each(tsk, &p->children) {
                 c = list_entry(tsk, struct task_struct, sibling);