oom_kill.c 13.2 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
 *
 *  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.
 */

18
#include <linux/oom.h>
L
Linus Torvalds 已提交
19
#include <linux/mm.h>
A
Alexey Dobriyan 已提交
20
#include <linux/err.h>
L
Linus Torvalds 已提交
21 22 23 24
#include <linux/sched.h>
#include <linux/swap.h>
#include <linux/timex.h>
#include <linux/jiffies.h>
25
#include <linux/cpuset.h>
26 27
#include <linux/module.h>
#include <linux/notifier.h>
L
Linus Torvalds 已提交
28

29
int sysctl_panic_on_oom;
30
int sysctl_oom_kill_allocating_task;
D
David Rientjes 已提交
31
static DEFINE_MUTEX(zone_scan_mutex);
L
Linus Torvalds 已提交
32 33 34
/* #define DEBUG */

/**
35
 * badness - calculate a numeric value for how bad this task has been
L
Linus Torvalds 已提交
36
 * @p: task struct of which task we should calculate
P
Paul Jackson 已提交
37
 * @uptime: current uptime in seconds
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
 *
 * 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 已提交
56 57
	struct mm_struct *mm;
	struct task_struct *child;
L
Linus Torvalds 已提交
58

A
Andrew Morton 已提交
59 60 61 62
	task_lock(p);
	mm = p->mm;
	if (!mm) {
		task_unlock(p);
L
Linus Torvalds 已提交
63
		return 0;
A
Andrew Morton 已提交
64
	}
L
Linus Torvalds 已提交
65 66 67 68

	/*
	 * The memory size of the process is the basis for the badness.
	 */
A
Andrew Morton 已提交
69 70 71 72 73 74
	points = mm->total_vm;

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

76 77 78 79 80 81
	/*
	 * swapoff can easily use up all memory, so kill those first.
	 */
	if (p->flags & PF_SWAPOFF)
		return ULONG_MAX;

L
Linus Torvalds 已提交
82 83
	/*
	 * Processes which fork a lot of child processes are likely
84
	 * a good choice. We add half the vmsize of the children if they
L
Linus Torvalds 已提交
85
	 * have an own mm. This prevents forking servers to flood the
86 87 88
	 * 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 已提交
89
	 */
A
Andrew Morton 已提交
90 91 92 93 94
	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 已提交
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
	}

	/*
	 * 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;

N
Nick Piggin 已提交
141 142 143 144 145
	/*
	 * If p's nodes don't overlap ours, it may still help to kill p
	 * because p may have allocated or otherwise mapped memory on
	 * this node before. However it will be less likely.
	 */
146
	if (!cpuset_mems_allowed_intersects(current, p))
N
Nick Piggin 已提交
147 148
		points /= 8;

L
Linus Torvalds 已提交
149 150 151 152
	/*
	 * Adjust the score by oomkilladj.
	 */
	if (p->oomkilladj) {
153 154 155
		if (p->oomkilladj > 0) {
			if (!points)
				points = 1;
L
Linus Torvalds 已提交
156
			points <<= p->oomkilladj;
157
		} else
L
Linus Torvalds 已提交
158 159 160 161
			points >>= -(p->oomkilladj);
	}

#ifdef DEBUG
162
	printk(KERN_DEBUG "OOMkill: task %d (%s) got %lu points\n",
L
Linus Torvalds 已提交
163 164 165 166 167
	p->pid, p->comm, points);
#endif
	return points;
}

168 169 170
/*
 * Determine the type of allocation constraint.
 */
D
David Rientjes 已提交
171 172
static inline enum oom_constraint constrained_alloc(struct zonelist *zonelist,
						    gfp_t gfp_mask)
173 174 175
{
#ifdef CONFIG_NUMA
	struct zone **z;
176
	nodemask_t nodes = node_states[N_HIGH_MEMORY];
177 178

	for (z = zonelist->zones; *z; z++)
179
		if (cpuset_zone_allowed_softwall(*z, gfp_mask))
180
			node_clear(zone_to_nid(*z), nodes);
181 182 183 184 185 186 187 188 189 190
		else
			return CONSTRAINT_CPUSET;

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

	return CONSTRAINT_NONE;
}

L
Linus Torvalds 已提交
191 192 193 194 195 196
/*
 * 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)
 */
197
static struct task_struct *select_bad_process(unsigned long *ppoints)
L
Linus Torvalds 已提交
198 199 200 201
{
	struct task_struct *g, *p;
	struct task_struct *chosen = NULL;
	struct timespec uptime;
202
	*ppoints = 0;
L
Linus Torvalds 已提交
203 204

	do_posix_clock_monotonic_gettime(&uptime);
P
Paul Jackson 已提交
205 206 207
	do_each_thread(g, p) {
		unsigned long points;

208 209 210 211
		/*
		 * skip kernel threads and tasks which have already released
		 * their mm.
		 */
212 213
		if (!p->mm)
			continue;
214 215
		/* skip the init task */
		if (is_init(p))
P
Paul Jackson 已提交
216
			continue;
217

218 219 220 221 222 223 224 225 226 227 228 229
		/*
		 * This task already has access to memory reserves and is
		 * being killed. Don't allow any other task access to the
		 * memory reserve.
		 *
		 * Note: this may have a chance of deadlock if it gets
		 * blocked waiting for another task which itself is waiting
		 * for memory. Is there a better alternative?
		 */
		if (test_tsk_thread_flag(p, TIF_MEMDIE))
			return ERR_PTR(-1UL);

P
Paul Jackson 已提交
230
		/*
231
		 * This is in the process of releasing memory so wait for it
P
Paul Jackson 已提交
232
		 * to finish before killing some other task by mistake.
233 234 235 236 237
		 *
		 * 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.
238
		 * Otherwise we could get an easy OOM deadlock.
P
Paul Jackson 已提交
239
		 */
240 241 242 243
		if (p->flags & PF_EXITING) {
			if (p != current)
				return ERR_PTR(-1UL);

244 245
			chosen = p;
			*ppoints = ULONG_MAX;
246
		}
247

248 249
		if (p->oomkilladj == OOM_DISABLE)
			continue;
P
Paul Jackson 已提交
250 251

		points = badness(p, uptime.tv_sec);
252
		if (points > *ppoints || !chosen) {
P
Paul Jackson 已提交
253
			chosen = p;
254
			*ppoints = points;
L
Linus Torvalds 已提交
255
		}
P
Paul Jackson 已提交
256
	} while_each_thread(g, p);
257

L
Linus Torvalds 已提交
258 259 260 261
	return chosen;
}

/**
262 263 264
 * 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.
L
Linus Torvalds 已提交
265
 */
N
Nick Piggin 已提交
266
static void __oom_kill_task(struct task_struct *p, int verbose)
L
Linus Torvalds 已提交
267
{
268
	if (is_init(p)) {
L
Linus Torvalds 已提交
269 270 271 272 273
		WARN_ON(1);
		printk(KERN_WARNING "tried to kill init!\n");
		return;
	}

274
	if (!p->mm) {
L
Linus Torvalds 已提交
275 276 277 278
		WARN_ON(1);
		printk(KERN_WARNING "tried to kill an mm-less task!\n");
		return;
	}
279

N
Nick Piggin 已提交
280 281
	if (verbose)
		printk(KERN_ERR "Killed process %d (%s)\n", p->pid, p->comm);
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289 290 291 292 293

	/*
	 * 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);
}

N
Nick Piggin 已提交
294
static int oom_kill_task(struct task_struct *p)
L
Linus Torvalds 已提交
295
{
296
	struct mm_struct *mm;
297
	struct task_struct *g, *q;
L
Linus Torvalds 已提交
298

299 300 301 302 303 304 305 306 307 308 309
	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.
	 */

310
	if (mm == NULL)
311
		return 1;
L
Linus Torvalds 已提交
312

313 314 315 316
	/*
	 * Don't kill the process if any threads are set to OOM_DISABLE
	 */
	do_each_thread(g, q) {
317
		if (q->mm == mm && q->oomkilladj == OOM_DISABLE)
318 319 320
			return 1;
	} while_each_thread(g, q);

N
Nick Piggin 已提交
321
	__oom_kill_task(p, 1);
322

L
Linus Torvalds 已提交
323 324
	/*
	 * kill all processes that share the ->mm (i.e. all threads),
N
Nick Piggin 已提交
325 326
	 * but are in a different thread group. Don't let them have access
	 * to memory reserves though, otherwise we might deplete all memory.
L
Linus Torvalds 已提交
327
	 */
328
	do_each_thread(g, q) {
L
Linus Torvalds 已提交
329
		if (q->mm == mm && q->tgid != p->tgid)
330
			force_sig(SIGKILL, q);
331
	} while_each_thread(g, q);
L
Linus Torvalds 已提交
332

333
	return 0;
L
Linus Torvalds 已提交
334 335
}

336 337
static int oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
			    unsigned long points, const char *message)
L
Linus Torvalds 已提交
338 339 340 341
{
	struct task_struct *c;
	struct list_head *tsk;

342 343 344 345 346 347 348 349
	if (printk_ratelimit()) {
		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();
	}

350 351 352 353 354
	/*
	 * 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) {
N
Nick Piggin 已提交
355
		__oom_kill_task(p, 0);
356 357 358
		return 0;
	}

N
Nick Piggin 已提交
359 360 361
	printk(KERN_ERR "%s: kill process %d (%s) score %li or a child\n",
					message, p->pid, p->comm, points);

L
Linus Torvalds 已提交
362 363 364 365 366
	/* 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;
N
Nick Piggin 已提交
367
		if (!oom_kill_task(c))
368
			return 0;
L
Linus Torvalds 已提交
369
	}
N
Nick Piggin 已提交
370
	return oom_kill_task(p);
L
Linus Torvalds 已提交
371 372
}

373 374 375 376 377 378 379 380 381 382 383 384 385 386
static BLOCKING_NOTIFIER_HEAD(oom_notify_list);

int register_oom_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_register(&oom_notify_list, nb);
}
EXPORT_SYMBOL_GPL(register_oom_notifier);

int unregister_oom_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&oom_notify_list, nb);
}
EXPORT_SYMBOL_GPL(unregister_oom_notifier);

D
David Rientjes 已提交
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
/*
 * Try to acquire the OOM killer lock for the zones in zonelist.  Returns zero
 * if a parallel OOM killing is already taking place that includes a zone in
 * the zonelist.  Otherwise, locks all zones in the zonelist and returns 1.
 */
int try_set_zone_oom(struct zonelist *zonelist)
{
	struct zone **z;
	int ret = 1;

	z = zonelist->zones;

	mutex_lock(&zone_scan_mutex);
	do {
		if (zone_is_oom_locked(*z)) {
			ret = 0;
			goto out;
		}
	} while (*(++z) != NULL);

	/*
	 * Lock each zone in the zonelist under zone_scan_mutex so a parallel
	 * invocation of try_set_zone_oom() doesn't succeed when it shouldn't.
	 */
	z = zonelist->zones;
	do {
		zone_set_flag(*z, ZONE_OOM_LOCKED);
	} while (*(++z) != NULL);
out:
	mutex_unlock(&zone_scan_mutex);
	return ret;
}

/*
 * Clears the ZONE_OOM_LOCKED flag for all zones in the zonelist so that failed
 * allocation attempts with zonelists containing them may now recall the OOM
 * killer, if necessary.
 */
void clear_zonelist_oom(struct zonelist *zonelist)
{
	struct zone **z;

	z = zonelist->zones;

	mutex_lock(&zone_scan_mutex);
	do {
		zone_clear_flag(*z, ZONE_OOM_LOCKED);
	} while (*(++z) != NULL);
	mutex_unlock(&zone_scan_mutex);
}

L
Linus Torvalds 已提交
438
/**
439
 * out_of_memory - kill the "best" process when we run out of memory
L
Linus Torvalds 已提交
440 441 442 443 444 445
 *
 * 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.
 */
446
void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
L
Linus Torvalds 已提交
447
{
448
	struct task_struct *p;
449
	unsigned long points = 0;
450
	unsigned long freed = 0;
D
David Rientjes 已提交
451
	enum oom_constraint constraint;
452 453 454 455 456

	blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
	if (freed > 0)
		/* Got some memory back in the last second. */
		return;
L
Linus Torvalds 已提交
457

458 459 460
	if (sysctl_panic_on_oom == 2)
		panic("out of memory. Compulsory panic_on_oom is selected.\n");

461 462 463 464
	/*
	 * Check if there were limitations on the allocation (only relevant for
	 * NUMA) that may require different handling.
	 */
D
David Rientjes 已提交
465 466 467 468
	constraint = constrained_alloc(zonelist, gfp_mask);
	read_lock(&tasklist_lock);

	switch (constraint) {
469
	case CONSTRAINT_MEMORY_POLICY:
470
		oom_kill_process(current, gfp_mask, order, points,
471 472 473 474
				"No available memory (MPOL_BIND)");
		break;

	case CONSTRAINT_NONE:
475 476
		if (sysctl_panic_on_oom)
			panic("out of memory. panic_on_oom is selected\n");
477 478 479
		/* Fall-through */
	case CONSTRAINT_CPUSET:
		if (sysctl_oom_kill_allocating_task) {
480
			oom_kill_process(current, gfp_mask, order, points,
481 482 483
					"Out of memory (oom_kill_allocating_task)");
			break;
		}
L
Linus Torvalds 已提交
484
retry:
485 486 487 488 489
		/*
		 * Rambo mode: Shoot down a process and hope it solves whatever
		 * issues we may have.
		 */
		p = select_bad_process(&points);
L
Linus Torvalds 已提交
490

491 492
		if (PTR_ERR(p) == -1UL)
			goto out;
L
Linus Torvalds 已提交
493

494 495 496 497 498
		/* Found nothing?!?! Either we hang forever, or we panic. */
		if (!p) {
			read_unlock(&tasklist_lock);
			panic("Out of memory and no killable processes...\n");
		}
L
Linus Torvalds 已提交
499

500 501
		if (oom_kill_process(p, points, gfp_mask, order,
				     "Out of memory"))
502 503 504 505
			goto retry;

		break;
	}
L
Linus Torvalds 已提交
506

507
out:
508
	read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
509 510 511

	/*
	 * Give "p" a good chance of killing itself before we
512
	 * retry to allocate memory unless "p" is current
L
Linus Torvalds 已提交
513
	 */
514
	if (!test_thread_flag(TIF_MEMDIE))
515
		schedule_timeout_uninterruptible(1);
L
Linus Torvalds 已提交
516
}