oom_kill.c 9.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8
/*
 *  linux/mm/oom_kill.c
 * 
 *  Copyright (C)  1998,2000  Rik van Riel
 *	Thanks go out to Claus Fischer for some serious inspiration and
 *	for goading me into coding this file...
 *
 *  The routines in this file are used to kill a process when
P
Paul Jackson 已提交
9 10
 *  we're seriously out of memory. This gets called from __alloc_pages()
 *  in mm/page_alloc.c when we really run out of memory.
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21 22
 *
 *  Since we won't call these routines often (on a well-configured
 *  machine) this file will double as a 'coding guide' and a signpost
 *  for newbie kernel hackers. It features several pointers to major
 *  kernel subsystems and hints as to where to find out what things do.
 */

#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/swap.h>
#include <linux/timex.h>
#include <linux/jiffies.h>
23
#include <linux/cpuset.h>
L
Linus Torvalds 已提交
24

25
int sysctl_panic_on_oom;
L
Linus Torvalds 已提交
26 27 28
/* #define DEBUG */

/**
29
 * badness - calculate a numeric value for how bad this task has been
L
Linus Torvalds 已提交
30
 * @p: task struct of which task we should calculate
P
Paul Jackson 已提交
31
 * @uptime: current uptime in seconds
L
Linus Torvalds 已提交
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
 *
 * The formula used is relatively simple and documented inline in the
 * function. The main rationale is that we want to select a good task
 * to kill when we run out of memory.
 *
 * Good in this context means that:
 * 1) we lose the minimum amount of work done
 * 2) we recover a large amount of memory
 * 3) we don't kill anything innocent of eating tons of memory
 * 4) we want to kill the minimum amount of processes (one)
 * 5) we try to kill the process the user expects us to kill, this
 *    algorithm has been meticulously tuned to meet the principle
 *    of least surprise ... (be careful when you change it)
 */

unsigned long badness(struct task_struct *p, unsigned long uptime)
{
	unsigned long points, cpu_time, run_time, s;
A
Andrew Morton 已提交
50 51
	struct mm_struct *mm;
	struct task_struct *child;
L
Linus Torvalds 已提交
52

A
Andrew Morton 已提交
53 54 55 56
	task_lock(p);
	mm = p->mm;
	if (!mm) {
		task_unlock(p);
L
Linus Torvalds 已提交
57
		return 0;
A
Andrew Morton 已提交
58
	}
L
Linus Torvalds 已提交
59 60 61 62

	/*
	 * The memory size of the process is the basis for the badness.
	 */
A
Andrew Morton 已提交
63 64 65 66 67 68
	points = mm->total_vm;

	/*
	 * After this unlock we can no longer dereference local variable `mm'
	 */
	task_unlock(p);
L
Linus Torvalds 已提交
69 70 71

	/*
	 * Processes which fork a lot of child processes are likely
72
	 * a good choice. We add half the vmsize of the children if they
L
Linus Torvalds 已提交
73
	 * have an own mm. This prevents forking servers to flood the
74 75 76
	 * machine with an endless amount of children. In case a single
	 * child is eating the vast majority of memory, adding only half
	 * to the parents will make the child our kill candidate of choice.
L
Linus Torvalds 已提交
77
	 */
A
Andrew Morton 已提交
78 79 80 81 82
	list_for_each_entry(child, &p->children, sibling) {
		task_lock(child);
		if (child->mm != mm && child->mm)
			points += child->mm->total_vm/2 + 1;
		task_unlock(child);
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
	}

	/*
	 * CPU time is in tens of seconds and run time is in thousands
         * of seconds. There is no particular reason for this other than
         * that it turned out to work very well in practice.
	 */
	cpu_time = (cputime_to_jiffies(p->utime) + cputime_to_jiffies(p->stime))
		>> (SHIFT_HZ + 3);

	if (uptime >= p->start_time.tv_sec)
		run_time = (uptime - p->start_time.tv_sec) >> 10;
	else
		run_time = 0;

	s = int_sqrt(cpu_time);
	if (s)
		points /= s;
	s = int_sqrt(int_sqrt(run_time));
	if (s)
		points /= s;

	/*
	 * Niced processes are most likely less important, so double
	 * their badness points.
	 */
	if (task_nice(p) > 0)
		points *= 2;

	/*
	 * Superuser processes are usually more important, so we make it
	 * less likely that we kill those.
	 */
	if (cap_t(p->cap_effective) & CAP_TO_MASK(CAP_SYS_ADMIN) ||
				p->uid == 0 || p->euid == 0)
		points /= 4;

	/*
	 * We don't want to kill a process with direct hardware access.
	 * Not only could that mess up the hardware, but usually users
	 * tend to only have this flag set on applications they think
	 * of as important.
	 */
	if (cap_t(p->cap_effective) & CAP_TO_MASK(CAP_SYS_RAWIO))
		points /= 4;

	/*
	 * Adjust the score by oomkilladj.
	 */
	if (p->oomkilladj) {
		if (p->oomkilladj > 0)
			points <<= p->oomkilladj;
		else
			points >>= -(p->oomkilladj);
	}

#ifdef DEBUG
	printk(KERN_DEBUG "OOMkill: task %d (%s) got %d points\n",
	p->pid, p->comm, points);
#endif
	return points;
}

146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/*
 * Types of limitations to the nodes from which allocations may occur
 */
#define CONSTRAINT_NONE 1
#define CONSTRAINT_MEMORY_POLICY 2
#define CONSTRAINT_CPUSET 3

/*
 * Determine the type of allocation constraint.
 */
static inline int constrained_alloc(struct zonelist *zonelist, gfp_t gfp_mask)
{
#ifdef CONFIG_NUMA
	struct zone **z;
	nodemask_t nodes = node_online_map;

	for (z = zonelist->zones; *z; z++)
		if (cpuset_zone_allowed(*z, gfp_mask))
			node_clear((*z)->zone_pgdat->node_id,
					nodes);
		else
			return CONSTRAINT_CPUSET;

	if (!nodes_empty(nodes))
		return CONSTRAINT_MEMORY_POLICY;
#endif

	return CONSTRAINT_NONE;
}

L
Linus Torvalds 已提交
176 177 178 179 180 181
/*
 * Simple selection loop. We chose the process with the highest
 * number of 'points'. We expect the caller will lock the tasklist.
 *
 * (not docbooked, we don't want this one cluttering up the manual)
 */
182
static struct task_struct *select_bad_process(unsigned long *ppoints)
L
Linus Torvalds 已提交
183 184 185 186
{
	struct task_struct *g, *p;
	struct task_struct *chosen = NULL;
	struct timespec uptime;
187
	*ppoints = 0;
L
Linus Torvalds 已提交
188 189

	do_posix_clock_monotonic_gettime(&uptime);
P
Paul Jackson 已提交
190 191 192 193
	do_each_thread(g, p) {
		unsigned long points;
		int releasing;

L
Linus Torvalds 已提交
194
		/* skip the init task with pid == 1 */
P
Paul Jackson 已提交
195 196 197 198
		if (p->pid == 1)
			continue;
		if (p->oomkilladj == OOM_DISABLE)
			continue;
199 200 201 202
		/* If p's nodes don't overlap ours, it won't help to kill p. */
		if (!cpuset_excl_nodes_overlap(p))
			continue;

P
Paul Jackson 已提交
203
		/*
204
		 * This is in the process of releasing memory so wait for it
P
Paul Jackson 已提交
205 206 207 208 209 210 211 212 213 214
		 * to finish before killing some other task by mistake.
		 */
		releasing = test_tsk_thread_flag(p, TIF_MEMDIE) ||
						p->flags & PF_EXITING;
		if (releasing && !(p->flags & PF_DEAD))
			return ERR_PTR(-1UL);
		if (p->flags & PF_SWAPOFF)
			return p;

		points = badness(p, uptime.tv_sec);
215
		if (points > *ppoints || !chosen) {
P
Paul Jackson 已提交
216
			chosen = p;
217
			*ppoints = points;
L
Linus Torvalds 已提交
218
		}
P
Paul Jackson 已提交
219
	} while_each_thread(g, p);
L
Linus Torvalds 已提交
220 221 222 223 224 225 226 227
	return chosen;
}

/**
 * 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).
 */
228
static void __oom_kill_task(task_t *p, const char *message)
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
{
	if (p->pid == 1) {
		WARN_ON(1);
		printk(KERN_WARNING "tried to kill init!\n");
		return;
	}

	task_lock(p);
	if (!p->mm || p->mm == &init_mm) {
		WARN_ON(1);
		printk(KERN_WARNING "tried to kill an mm-less task!\n");
		task_unlock(p);
		return;
	}
	task_unlock(p);
244 245
	printk(KERN_ERR "%s: Killed process %d (%s).\n",
				message, p->pid, p->comm);
L
Linus Torvalds 已提交
246 247 248 249 250 251 252 253 254 255 256 257

	/*
	 * 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->time_slice = HZ;
	set_tsk_thread_flag(p, TIF_MEMDIE);

	force_sig(SIGKILL, p);
}

258
static int oom_kill_task(task_t *p, const char *message)
L
Linus Torvalds 已提交
259
{
260
	struct mm_struct *mm;
L
Linus Torvalds 已提交
261 262
	task_t * g, * q;

263 264 265 266 267 268 269 270 271 272 273 274 275
	mm = p->mm;

	/* 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 (mm == NULL || mm == &init_mm)
		return 1;
L
Linus Torvalds 已提交
276

277
	__oom_kill_task(p, message);
L
Linus Torvalds 已提交
278 279 280 281 282 283
	/*
	 * kill all processes that share the ->mm (i.e. all threads),
	 * but are in a different thread group
	 */
	do_each_thread(g, q)
		if (q->mm == mm && q->tgid != p->tgid)
284
			__oom_kill_task(q, message);
L
Linus Torvalds 已提交
285 286
	while_each_thread(g, q);

287
	return 0;
L
Linus Torvalds 已提交
288 289
}

290 291
static int oom_kill_process(struct task_struct *p, unsigned long points,
		const char *message)
L
Linus Torvalds 已提交
292 293 294 295
{
	struct task_struct *c;
	struct list_head *tsk;

296 297
	printk(KERN_ERR "Out of Memory: Kill process %d (%s) score %li and "
		"children.\n", p->pid, p->comm, points);
L
Linus Torvalds 已提交
298 299 300 301 302
	/* Try to kill a child first */
	list_for_each(tsk, &p->children) {
		c = list_entry(tsk, struct task_struct, sibling);
		if (c->mm == p->mm)
			continue;
303 304
		if (!oom_kill_task(c, message))
			return 0;
L
Linus Torvalds 已提交
305
	}
306
	return oom_kill_task(p, message);
L
Linus Torvalds 已提交
307 308 309
}

/**
310
 * out_of_memory - kill the "best" process when we run out of memory
L
Linus Torvalds 已提交
311 312 313 314 315 316
 *
 * If we run out of memory, we have the choice between either
 * killing a random task (bad), letting the system crash (worse)
 * OR try to be smart about which process to kill. Note that we
 * don't have to be perfect here, we just have to be good.
 */
317
void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
L
Linus Torvalds 已提交
318
{
319
	task_t *p;
320
	unsigned long points = 0;
L
Linus Torvalds 已提交
321

322 323 324
	if (printk_ratelimit()) {
		printk("oom-killer: gfp_mask=0x%x, order=%d\n",
			gfp_mask, order);
325
		dump_stack();
326 327
		show_mem();
	}
J
Janet Morgan 已提交
328

P
Paul Jackson 已提交
329
	cpuset_lock();
L
Linus Torvalds 已提交
330
	read_lock(&tasklist_lock);
331 332 333 334 335 336 337

	/*
	 * Check if there were limitations on the allocation (only relevant for
	 * NUMA) that may require different handling.
	 */
	switch (constrained_alloc(zonelist, gfp_mask)) {
	case CONSTRAINT_MEMORY_POLICY:
338
		oom_kill_process(current, points,
339 340 341 342
				"No available memory (MPOL_BIND)");
		break;

	case CONSTRAINT_CPUSET:
343
		oom_kill_process(current, points,
344 345 346 347
				"No available memory in cpuset");
		break;

	case CONSTRAINT_NONE:
348 349
		if (sysctl_panic_on_oom)
			panic("out of memory. panic_on_oom is selected\n");
L
Linus Torvalds 已提交
350
retry:
351 352 353 354 355
		/*
		 * Rambo mode: Shoot down a process and hope it solves whatever
		 * issues we may have.
		 */
		p = select_bad_process(&points);
L
Linus Torvalds 已提交
356

357 358
		if (PTR_ERR(p) == -1UL)
			goto out;
L
Linus Torvalds 已提交
359

360 361 362 363 364 365
		/* Found nothing?!?! Either we hang forever, or we panic. */
		if (!p) {
			read_unlock(&tasklist_lock);
			cpuset_unlock();
			panic("Out of memory and no killable processes...\n");
		}
L
Linus Torvalds 已提交
366

367
		if (oom_kill_process(p, points, "Out of memory"))
368 369 370 371
			goto retry;

		break;
	}
L
Linus Torvalds 已提交
372

373
out:
374
	read_unlock(&tasklist_lock);
P
Paul Jackson 已提交
375
	cpuset_unlock();
L
Linus Torvalds 已提交
376 377 378

	/*
	 * Give "p" a good chance of killing itself before we
379
	 * retry to allocate memory unless "p" is current
L
Linus Torvalds 已提交
380
	 */
381
	if (!test_thread_flag(TIF_MEMDIE))
382
		schedule_timeout_uninterruptible(1);
L
Linus Torvalds 已提交
383
}