oom: remove unnecessary code and cleanup

Remove the redundancy in __oom_kill_task() since:

 - init can never be passed to this function: it will never be PF_EXITING
   or selectable from select_bad_process(), and

 - it will never be passed a task from oom_kill_task() without an ->mm
   and we're unconcerned about detachment from exiting tasks, there's no
   reason to protect them against SIGKILL or access to memory reserves.

Also moves the kernel log message to a higher level since the verbosity is
not always emitted here; we need not print an error message if an exiting
task is given a longer timeslice.

__oom_kill_task() only has a single caller, so it can be merged into that
function at the same time.

Signed-off-by: David Rientjes <rientjes@google.com>
Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index dad13fc41f47a58447f2742ef5bb7be70e4f7121..2f37f6113d9ea787dacf72bd0e1d0778907e3d5d 100644 (file)
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -410,61 +410,25 @@ static void dump_header(struct task_struct *p, gfp_t gfp_mask, int order,
 }
 
 #define K(x) ((x) << (PAGE_SHIFT-10))
-
-/*
- * 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, int verbose)
+static int oom_kill_task(struct task_struct *p)
 {
-       if (is_global_init(p)) {
-               WARN_ON(1);
-               printk(KERN_WARNING "tried to kill init!\n");
-               return;
-       }
-
        p = find_lock_task_mm(p);
-       if (!p)
-               return;
-
-       if (verbose)
-               printk(KERN_ERR "Killed process %d (%s) "
-                      "vsz:%lukB, anon-rss:%lukB, file-rss:%lukB\n",
-                      task_pid_nr(p), p->comm,
-                      K(p->mm->total_vm),
-                      K(get_mm_counter(p->mm, MM_ANONPAGES)),
-                      K(get_mm_counter(p->mm, MM_FILEPAGES)));
+       if (!p || p->signal->oom_adj == OOM_DISABLE) {
+               task_unlock(p);
+               return 1;
+       }
+       pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB\n",
+               task_pid_nr(p), p->comm, K(p->mm->total_vm),
+               K(get_mm_counter(p->mm, MM_ANONPAGES)),
+               K(get_mm_counter(p->mm, MM_FILEPAGES)));
        task_unlock(p);
 
-       /*
-        * We give our sacrificial lamb high priority and access to
-        * all the memory it needs. That way it should be able to
-        * exit() and clear out its resources quickly...
-        */
        p->rt.time_slice = HZ;
        set_tsk_thread_flag(p, TIF_MEMDIE);
-
        force_sig(SIGKILL, p);
-}
-
-static int oom_kill_task(struct task_struct *p)
-{
-       /* 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.
-        *
-        * Furthermore, even if mm contains a non-NULL value, p->mm may
-        * change to NULL at any time since we do not hold task_lock(p).
-        * However, this is of no concern to us.
-        */
-       if (!p->mm || p->signal->oom_adj == OOM_DISABLE)
-               return 1;
-
-       __oom_kill_task(p, 1);
-
        return 0;
 }
+#undef K
 
 static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                            unsigned long points, struct mem_cgroup *mem,