[Bluetooth]: Don't update disconnect timer for incoming connections

[pandora-kernel.git] / mm / oom_kill.c

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 4f815b0..bada3d0 100644 (file)
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -59,6 +59,12 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
                return 0;
        }
 
+       /*
+        * swapoff can easily use up all memory, so kill those first.
+        */
+       if (p->flags & PF_SWAPOFF)
+               return ULONG_MAX;
+
        /*
         * The memory size of the process is the basis for the badness.
         */
@@ -171,8 +177,7 @@ static inline int constrained_alloc(struct zonelist *zonelist, gfp_t gfp_mask)
 
        for (z = zonelist->zones; *z; z++)
                if (cpuset_zone_allowed(*z, gfp_mask))
-                       node_clear((*z)->zone_pgdat->node_id,
-                                       nodes);
+                       node_clear(zone_to_nid(*z), nodes);
                else
                        return CONSTRAINT_CPUSET;
 
@@ -201,22 +206,38 @@ static struct task_struct *select_bad_process(unsigned long *ppoints)
                unsigned long points;
                int releasing;
 
+               /* skip kernel threads */
+               if (!p->mm)
+                       continue;
                /* skip the init task with pid == 1 */
                if (p->pid == 1)
                        continue;
-               if (p->oomkilladj == OOM_DISABLE)
-                       continue;
 
                /*
                 * 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;
+               }
+               if (p->oomkilladj == OOM_DISABLE)
+                       continue;
 
                points = badness(p, uptime.tv_sec);
                if (points > *ppoints || !chosen) {
@@ -228,9 +249,9 @@ static struct task_struct *select_bad_process(unsigned long *ppoints)
 }
 
 /**
- * We must be careful though to never send SIGKILL a process with
- * CAP_SYS_RAW_IO set, send SIGTERM instead (but it's unlikely that
- * we select a process with CAP_SYS_RAW_IO set).
+ * Send SIGKILL to the selected  process irrespective of  CAP_SYS_RAW_IO
+ * flag though it's unlikely that  we select a process with CAP_SYS_RAW_IO
+ * set.
  */
 static void __oom_kill_task(struct task_struct *p, const char *message)
 {
@@ -248,8 +269,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 +324,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);
@@ -347,8 +380,9 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
                return;
 
        if (printk_ratelimit()) {
-               printk("oom-killer: gfp_mask=0x%x, order=%d\n",
-                       gfp_mask, order);
+               printk(KERN_WARNING "%s invoked oom-killer: "
+                       "gfp_mask=0x%x, order=%d, oomkilladj=%d\n",
+                       current->comm, gfp_mask, order, current->oomkilladj);
                dump_stack();
                show_mem();
        }