Commit b940fd70 authored by David Rientjes's avatar David Rientjes Committed by Linus Torvalds
Browse files

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: default avatarDavid Rientjes <rientjes@google.com>
Reviewed-by: default avatarKAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 8e4228e1

mm/oom_kill.c

+10 −46
Original line number Original line Diff line number Diff line
@@ -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))

#define K(x) ((x) << (PAGE_SHIFT-10))



static int oom_kill_task(struct task_struct *p)

/*

 * 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)

{

{

	if (is_global_init(p)) {

		WARN_ON(1);

		printk(KERN_WARNING "tried to kill init!\n");

		return;

	}



	p = find_lock_task_mm(p);

	p = find_lock_task_mm(p);

	if (!p)

	if (!p || p->signal->oom_adj == OOM_DISABLE) {

		return;

		task_unlock(p);



		return 1;

	if (verbose)

	}

		printk(KERN_ERR "Killed process %d (%s) "

	pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB\n",

		       "vsz:%lukB, anon-rss:%lukB, file-rss:%lukB\n",

		task_pid_nr(p), p->comm, K(p->mm->total_vm),

		       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_ANONPAGES)),

		K(get_mm_counter(p->mm, MM_FILEPAGES)));

		K(get_mm_counter(p->mm, MM_FILEPAGES)));

	task_unlock(p);

	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;

	p->rt.time_slice = HZ;

	set_tsk_thread_flag(p, TIF_MEMDIE);

	set_tsk_thread_flag(p, TIF_MEMDIE);



	force_sig(SIGKILL, p);

	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;

	return 0;

}

}

#undef K





static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,

static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,

			    unsigned long points, struct mem_cgroup *mem,

			    unsigned long points, struct mem_cgroup *mem,

CRA Git | Maintained and supported by SUSTech CRA and CCSE