exit.c 43.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10
/*
 *  linux/kernel/exit.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/module.h>
11
#include <linux/capability.h>
L
Linus Torvalds 已提交
12 13 14
#include <linux/completion.h>
#include <linux/personality.h>
#include <linux/tty.h>
15
#include <linux/mnt_namespace.h>
16
#include <linux/iocontext.h>
L
Linus Torvalds 已提交
17 18 19 20
#include <linux/key.h>
#include <linux/security.h>
#include <linux/cpu.h>
#include <linux/acct.h>
21
#include <linux/tsacct_kern.h>
L
Linus Torvalds 已提交
22
#include <linux/file.h>
A
Al Viro 已提交
23
#include <linux/fdtable.h>
L
Linus Torvalds 已提交
24
#include <linux/binfmts.h>
S
Serge E. Hallyn 已提交
25
#include <linux/nsproxy.h>
26
#include <linux/pid_namespace.h>
L
Linus Torvalds 已提交
27 28 29 30
#include <linux/ptrace.h>
#include <linux/profile.h>
#include <linux/mount.h>
#include <linux/proc_fs.h>
31
#include <linux/kthread.h>
L
Linus Torvalds 已提交
32
#include <linux/mempolicy.h>
33
#include <linux/taskstats_kern.h>
34
#include <linux/delayacct.h>
35
#include <linux/freezer.h>
36
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
37
#include <linux/syscalls.h>
38
#include <linux/signal.h>
39
#include <linux/posix-timers.h>
M
Matt Helsley 已提交
40
#include <linux/cn_proc.h>
41
#include <linux/mutex.h>
42
#include <linux/futex.h>
43
#include <linux/compat.h>
44
#include <linux/pipe_fs_i.h>
45
#include <linux/audit.h> /* for audit_free() */
A
Adrian Bunk 已提交
46
#include <linux/resource.h>
47
#include <linux/blkdev.h>
48
#include <linux/task_io_accounting_ops.h>
L
Linus Torvalds 已提交
49 50 51 52 53 54

#include <asm/uaccess.h>
#include <asm/unistd.h>
#include <asm/pgtable.h>
#include <asm/mmu_context.h>

A
Adrian Bunk 已提交
55 56
static void exit_mm(struct task_struct * tsk);

57 58 59 60 61
static inline int task_detached(struct task_struct *p)
{
	return p->exit_signal == -1;
}

L
Linus Torvalds 已提交
62 63 64 65 66 67 68
static void __unhash_process(struct task_struct *p)
{
	nr_threads--;
	detach_pid(p, PIDTYPE_PID);
	if (thread_group_leader(p)) {
		detach_pid(p, PIDTYPE_PGID);
		detach_pid(p, PIDTYPE_SID);
69

70
		list_del_rcu(&p->tasks);
71
		__get_cpu_var(process_counts)--;
L
Linus Torvalds 已提交
72
	}
O
Oleg Nesterov 已提交
73
	list_del_rcu(&p->thread_group);
74
	remove_parent(p);
L
Linus Torvalds 已提交
75 76
}

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
/*
 * This function expects the tasklist_lock write-locked.
 */
static void __exit_signal(struct task_struct *tsk)
{
	struct signal_struct *sig = tsk->signal;
	struct sighand_struct *sighand;

	BUG_ON(!sig);
	BUG_ON(!atomic_read(&sig->count));

	rcu_read_lock();
	sighand = rcu_dereference(tsk->sighand);
	spin_lock(&sighand->siglock);

	posix_cpu_timers_exit(tsk);
	if (atomic_dec_and_test(&sig->count))
		posix_cpu_timers_exit_group(tsk);
	else {
		/*
		 * If there is any task waiting for the group exit
		 * then notify it:
		 */
100
		if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count)
101
			wake_up_process(sig->group_exit_task);
102

103 104 105 106 107 108 109 110 111 112 113 114 115 116
		if (tsk == sig->curr_target)
			sig->curr_target = next_thread(tsk);
		/*
		 * Accumulate here the counters for all threads but the
		 * group leader as they die, so they can be added into
		 * the process-wide totals when those are taken.
		 * The group leader stays around as a zombie as long
		 * as there are other threads.  When it gets reaped,
		 * the exit.c code will add its counts into these totals.
		 * We won't ever get here for the group leader, since it
		 * will have been the last reference on the signal_struct.
		 */
		sig->utime = cputime_add(sig->utime, tsk->utime);
		sig->stime = cputime_add(sig->stime, tsk->stime);
117
		sig->gtime = cputime_add(sig->gtime, tsk->gtime);
118 119 120 121
		sig->min_flt += tsk->min_flt;
		sig->maj_flt += tsk->maj_flt;
		sig->nvcsw += tsk->nvcsw;
		sig->nivcsw += tsk->nivcsw;
122 123
		sig->inblock += task_io_get_inblock(tsk);
		sig->oublock += task_io_get_oublock(tsk);
124
		sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
125 126 127
		sig = NULL; /* Marker for below. */
	}

128 129
	__unhash_process(tsk);

130 131 132 133 134 135
	/*
	 * Do this under ->siglock, we can race with another thread
	 * doing sigqueue_free() if we have SIGQUEUE_PREALLOC signals.
	 */
	flush_sigqueue(&tsk->pending);

136
	tsk->signal = NULL;
137
	tsk->sighand = NULL;
138 139 140
	spin_unlock(&sighand->siglock);
	rcu_read_unlock();

141
	__cleanup_sighand(sighand);
142 143 144
	clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
	if (sig) {
		flush_sigqueue(&sig->shared_pending);
145
		taskstats_tgid_free(sig);
146 147 148 149
		__cleanup_signal(sig);
	}
}

150 151 152 153 154
static void delayed_put_task_struct(struct rcu_head *rhp)
{
	put_task_struct(container_of(rhp, struct task_struct, rcu));
}

L
Linus Torvalds 已提交
155 156
void release_task(struct task_struct * p)
{
157
	struct task_struct *leader;
L
Linus Torvalds 已提交
158
	int zap_leader;
159
repeat:
L
Linus Torvalds 已提交
160
	atomic_dec(&p->user->processes);
161
	proc_flush_task(p);
L
Linus Torvalds 已提交
162
	write_lock_irq(&tasklist_lock);
163
	ptrace_unlink(p);
L
Linus Torvalds 已提交
164 165
	BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children));
	__exit_signal(p);
166

L
Linus Torvalds 已提交
167 168 169 170 171 172 173 174
	/*
	 * If we are the last non-leader member of the thread
	 * group, and the leader is zombie, then notify the
	 * group leader's parent process. (if it wants notification.)
	 */
	zap_leader = 0;
	leader = p->group_leader;
	if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
175
		BUG_ON(task_detached(leader));
L
Linus Torvalds 已提交
176 177 178 179 180 181 182 183 184
		do_notify_parent(leader, leader->exit_signal);
		/*
		 * If we were the last child thread and the leader has
		 * exited already, and the leader's parent ignores SIGCHLD,
		 * then we are the one who should release the leader.
		 *
		 * do_notify_parent() will have marked it self-reaping in
		 * that case.
		 */
185
		zap_leader = task_detached(leader);
L
Linus Torvalds 已提交
186 187 188 189
	}

	write_unlock_irq(&tasklist_lock);
	release_thread(p);
190
	call_rcu(&p->rcu, delayed_put_task_struct);
L
Linus Torvalds 已提交
191 192 193 194 195 196 197 198 199 200

	p = leader;
	if (unlikely(zap_leader))
		goto repeat;
}

/*
 * This checks not only the pgrp, but falls back on the pid if no
 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
 * without this...
201 202
 *
 * The caller must hold rcu lock or the tasklist lock.
L
Linus Torvalds 已提交
203
 */
204
struct pid *session_of_pgrp(struct pid *pgrp)
L
Linus Torvalds 已提交
205 206
{
	struct task_struct *p;
207
	struct pid *sid = NULL;
208

209
	p = pid_task(pgrp, PIDTYPE_PGID);
210
	if (p == NULL)
211
		p = pid_task(pgrp, PIDTYPE_PID);
212
	if (p != NULL)
213
		sid = task_session(p);
214

L
Linus Torvalds 已提交
215 216 217 218 219 220 221 222 223 224 225
	return sid;
}

/*
 * Determine if a process group is "orphaned", according to the POSIX
 * definition in 2.2.2.52.  Orphaned process groups are not to be affected
 * by terminal-generated stop signals.  Newly orphaned process groups are
 * to receive a SIGHUP and a SIGCONT.
 *
 * "I ask you, have you ever known what it is to be an orphan?"
 */
226
static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
L
Linus Torvalds 已提交
227 228 229
{
	struct task_struct *p;

230
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
231 232 233
		if ((p == ignored_task) ||
		    (p->exit_state && thread_group_empty(p)) ||
		    is_global_init(p->real_parent))
L
Linus Torvalds 已提交
234
			continue;
235

236
		if (task_pgrp(p->real_parent) != pgrp &&
237 238
		    task_session(p->real_parent) == task_session(p))
			return 0;
239
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
240 241

	return 1;
L
Linus Torvalds 已提交
242 243
}

244
int is_current_pgrp_orphaned(void)
L
Linus Torvalds 已提交
245 246 247 248
{
	int retval;

	read_lock(&tasklist_lock);
249
	retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
L
Linus Torvalds 已提交
250 251 252 253 254
	read_unlock(&tasklist_lock);

	return retval;
}

255
static int has_stopped_jobs(struct pid *pgrp)
L
Linus Torvalds 已提交
256 257 258 259
{
	int retval = 0;
	struct task_struct *p;

260
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
M
Matthew Wilcox 已提交
261
		if (!task_is_stopped(p))
L
Linus Torvalds 已提交
262 263 264
			continue;
		retval = 1;
		break;
265
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
266 267 268
	return retval;
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
/*
 * Check to see if any process groups have become orphaned as
 * a result of our exiting, and if they have any stopped jobs,
 * send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
 */
static void
kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
{
	struct pid *pgrp = task_pgrp(tsk);
	struct task_struct *ignored_task = tsk;

	if (!parent)
		 /* exit: our father is in a different pgrp than
		  * we are and we were the only connection outside.
		  */
		parent = tsk->real_parent;
	else
		/* reparent: our child is in a different pgrp than
		 * we are, and it was the only connection outside.
		 */
		ignored_task = NULL;

	if (task_pgrp(parent) != pgrp &&
	    task_session(parent) == task_session(tsk) &&
	    will_become_orphaned_pgrp(pgrp, ignored_task) &&
	    has_stopped_jobs(pgrp)) {
		__kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
		__kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
	}
}

L
Linus Torvalds 已提交
300
/**
301
 * reparent_to_kthreadd - Reparent the calling kernel thread to kthreadd
L
Linus Torvalds 已提交
302 303
 *
 * If a kernel thread is launched as a result of a system call, or if
304 305
 * it ever exits, it should generally reparent itself to kthreadd so it
 * isn't in the way of other processes and is correctly cleaned up on exit.
L
Linus Torvalds 已提交
306 307 308 309
 *
 * The various task state such as scheduling policy and priority may have
 * been inherited from a user process, so we reset them to sane values here.
 *
310
 * NOTE that reparent_to_kthreadd() gives the caller full capabilities.
L
Linus Torvalds 已提交
311
 */
312
static void reparent_to_kthreadd(void)
L
Linus Torvalds 已提交
313 314 315 316 317
{
	write_lock_irq(&tasklist_lock);

	ptrace_unlink(current);
	/* Reparent to init */
318
	remove_parent(current);
319
	current->real_parent = current->parent = kthreadd_task;
320
	add_parent(current);
L
Linus Torvalds 已提交
321 322 323 324

	/* Set the exit signal to SIGCHLD so we signal init on exit */
	current->exit_signal = SIGCHLD;

325
	if (task_nice(current) < 0)
L
Linus Torvalds 已提交
326 327 328 329 330 331 332 333 334 335 336 337
		set_user_nice(current, 0);
	/* cpus_allowed? */
	/* rt_priority? */
	/* signals? */
	security_task_reparent_to_init(current);
	memcpy(current->signal->rlim, init_task.signal->rlim,
	       sizeof(current->signal->rlim));
	atomic_inc(&(INIT_USER->__count));
	write_unlock_irq(&tasklist_lock);
	switch_uid(INIT_USER);
}

338
void __set_special_pids(struct pid *pid)
L
Linus Torvalds 已提交
339
{
340
	struct task_struct *curr = current->group_leader;
341
	pid_t nr = pid_nr(pid);
L
Linus Torvalds 已提交
342

343
	if (task_session(curr) != pid) {
344
		change_pid(curr, PIDTYPE_SID, pid);
345
		set_task_session(curr, nr);
L
Linus Torvalds 已提交
346
	}
347
	if (task_pgrp(curr) != pid) {
348
		change_pid(curr, PIDTYPE_PGID, pid);
349
		set_task_pgrp(curr, nr);
L
Linus Torvalds 已提交
350 351 352
	}
}

353
static void set_special_pids(struct pid *pid)
L
Linus Torvalds 已提交
354 355
{
	write_lock_irq(&tasklist_lock);
356
	__set_special_pids(pid);
L
Linus Torvalds 已提交
357 358 359 360 361 362 363 364 365 366
	write_unlock_irq(&tasklist_lock);
}

/*
 * Let kernel threads use this to say that they
 * allow a certain signal (since daemonize() will
 * have disabled all of them by default).
 */
int allow_signal(int sig)
{
367
	if (!valid_signal(sig) || sig < 1)
L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
		return -EINVAL;

	spin_lock_irq(&current->sighand->siglock);
	sigdelset(&current->blocked, sig);
	if (!current->mm) {
		/* Kernel threads handle their own signals.
		   Let the signal code know it'll be handled, so
		   that they don't get converted to SIGKILL or
		   just silently dropped */
		current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
	}
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	return 0;
}

EXPORT_SYMBOL(allow_signal);

int disallow_signal(int sig)
{
388
	if (!valid_signal(sig) || sig < 1)
L
Linus Torvalds 已提交
389 390 391
		return -EINVAL;

	spin_lock_irq(&current->sighand->siglock);
392
	current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN;
L
Linus Torvalds 已提交
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
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
	return 0;
}

EXPORT_SYMBOL(disallow_signal);

/*
 *	Put all the gunge required to become a kernel thread without
 *	attached user resources in one place where it belongs.
 */

void daemonize(const char *name, ...)
{
	va_list args;
	struct fs_struct *fs;
	sigset_t blocked;

	va_start(args, name);
	vsnprintf(current->comm, sizeof(current->comm), name, args);
	va_end(args);

	/*
	 * If we were started as result of loading a module, close all of the
	 * user space pages.  We don't need them, and if we didn't close them
	 * they would be locked into memory.
	 */
	exit_mm(current);
421 422 423 424 425
	/*
	 * We don't want to have TIF_FREEZE set if the system-wide hibernation
	 * or suspend transition begins right now.
	 */
	current->flags |= PF_NOFREEZE;
L
Linus Torvalds 已提交
426

427 428 429 430
	if (current->nsproxy != &init_nsproxy) {
		get_nsproxy(&init_nsproxy);
		switch_task_namespaces(current, &init_nsproxy);
	}
431
	set_special_pids(&init_struct_pid);
432
	proc_clear_tty(current);
L
Linus Torvalds 已提交
433 434 435 436 437 438 439 440 441 442 443 444

	/* Block and flush all signals */
	sigfillset(&blocked);
	sigprocmask(SIG_BLOCK, &blocked, NULL);
	flush_signals(current);

	/* Become as one with the init task */

	exit_fs(current);	/* current->fs->count--; */
	fs = init_task.fs;
	current->fs = fs;
	atomic_inc(&fs->count);
S
Serge E. Hallyn 已提交
445

446
	exit_files(current);
L
Linus Torvalds 已提交
447 448 449
	current->files = init_task.files;
	atomic_inc(&current->files->count);

450
	reparent_to_kthreadd();
L
Linus Torvalds 已提交
451 452 453 454
}

EXPORT_SYMBOL(daemonize);

455
static void close_files(struct files_struct * files)
L
Linus Torvalds 已提交
456 457
{
	int i, j;
458
	struct fdtable *fdt;
L
Linus Torvalds 已提交
459 460

	j = 0;
461 462 463 464 465 466

	/*
	 * It is safe to dereference the fd table without RCU or
	 * ->file_lock because this is the last reference to the
	 * files structure.
	 */
467
	fdt = files_fdtable(files);
L
Linus Torvalds 已提交
468 469 470
	for (;;) {
		unsigned long set;
		i = j * __NFDBITS;
471
		if (i >= fdt->max_fds)
L
Linus Torvalds 已提交
472
			break;
473
		set = fdt->open_fds->fds_bits[j++];
L
Linus Torvalds 已提交
474 475
		while (set) {
			if (set & 1) {
476
				struct file * file = xchg(&fdt->fd[i], NULL);
477
				if (file) {
L
Linus Torvalds 已提交
478
					filp_close(file, files);
479 480
					cond_resched();
				}
L
Linus Torvalds 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
			}
			i++;
			set >>= 1;
		}
	}
}

struct files_struct *get_files_struct(struct task_struct *task)
{
	struct files_struct *files;

	task_lock(task);
	files = task->files;
	if (files)
		atomic_inc(&files->count);
	task_unlock(task);

	return files;
}

501
void put_files_struct(struct files_struct *files)
L
Linus Torvalds 已提交
502
{
503 504
	struct fdtable *fdt;

L
Linus Torvalds 已提交
505 506 507 508
	if (atomic_dec_and_test(&files->count)) {
		close_files(files);
		/*
		 * Free the fd and fdset arrays if we expanded them.
509 510 511
		 * If the fdtable was embedded, pass files for freeing
		 * at the end of the RCU grace period. Otherwise,
		 * you can free files immediately.
L
Linus Torvalds 已提交
512
		 */
513
		fdt = files_fdtable(files);
514
		if (fdt != &files->fdtab)
515
			kmem_cache_free(files_cachep, files);
516
		free_fdtable(fdt);
L
Linus Torvalds 已提交
517 518 519
	}
}

520
void reset_files_struct(struct files_struct *files)
521
{
522
	struct task_struct *tsk = current;
523 524 525 526 527 528 529 530 531
	struct files_struct *old;

	old = tsk->files;
	task_lock(tsk);
	tsk->files = files;
	task_unlock(tsk);
	put_files_struct(old);
}

532
void exit_files(struct task_struct *tsk)
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540 541 542 543
{
	struct files_struct * files = tsk->files;

	if (files) {
		task_lock(tsk);
		tsk->files = NULL;
		task_unlock(tsk);
		put_files_struct(files);
	}
}

544
void put_fs_struct(struct fs_struct *fs)
L
Linus Torvalds 已提交
545 546 547
{
	/* No need to hold fs->lock if we are killing it */
	if (atomic_dec_and_test(&fs->count)) {
J
Jan Blunck 已提交
548 549 550 551
		path_put(&fs->root);
		path_put(&fs->pwd);
		if (fs->altroot.dentry)
			path_put(&fs->altroot);
L
Linus Torvalds 已提交
552 553 554 555
		kmem_cache_free(fs_cachep, fs);
	}
}

556
void exit_fs(struct task_struct *tsk)
L
Linus Torvalds 已提交
557 558 559 560 561 562 563
{
	struct fs_struct * fs = tsk->fs;

	if (fs) {
		task_lock(tsk);
		tsk->fs = NULL;
		task_unlock(tsk);
564
		put_fs_struct(fs);
L
Linus Torvalds 已提交
565 566 567 568 569
	}
}

EXPORT_SYMBOL_GPL(exit_fs);

570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
#ifdef CONFIG_MM_OWNER
/*
 * Task p is exiting and it owned mm, lets find a new owner for it
 */
static inline int
mm_need_new_owner(struct mm_struct *mm, struct task_struct *p)
{
	/*
	 * If there are other users of the mm and the owner (us) is exiting
	 * we need to find a new owner to take on the responsibility.
	 */
	if (!mm)
		return 0;
	if (atomic_read(&mm->mm_users) <= 1)
		return 0;
	if (mm->owner != p)
		return 0;
	return 1;
}

void mm_update_next_owner(struct mm_struct *mm)
{
	struct task_struct *c, *g, *p = current;

retry:
	if (!mm_need_new_owner(mm, p))
		return;

	read_lock(&tasklist_lock);
	/*
	 * Search in the children
	 */
	list_for_each_entry(c, &p->children, sibling) {
		if (c->mm == mm)
			goto assign_new_owner;
	}

	/*
	 * Search in the siblings
	 */
	list_for_each_entry(c, &p->parent->children, sibling) {
		if (c->mm == mm)
			goto assign_new_owner;
	}

	/*
	 * Search through everything else. We should not get
	 * here often
	 */
	do_each_thread(g, c) {
		if (c->mm == mm)
			goto assign_new_owner;
	} while_each_thread(g, c);

	read_unlock(&tasklist_lock);
	return;

assign_new_owner:
	BUG_ON(c == p);
	get_task_struct(c);
	/*
	 * The task_lock protects c->mm from changing.
	 * We always want mm->owner->mm == mm
	 */
	task_lock(c);
	/*
	 * Delay read_unlock() till we have the task_lock()
	 * to ensure that c does not slip away underneath us
	 */
	read_unlock(&tasklist_lock);
	if (c->mm != mm) {
		task_unlock(c);
		put_task_struct(c);
		goto retry;
	}
	cgroup_mm_owner_callbacks(mm->owner, c);
	mm->owner = c;
	task_unlock(c);
	put_task_struct(c);
}
#endif /* CONFIG_MM_OWNER */

L
Linus Torvalds 已提交
652 653 654 655
/*
 * Turn us into a lazy TLB process if we
 * aren't already..
 */
A
Adrian Bunk 已提交
656
static void exit_mm(struct task_struct * tsk)
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
{
	struct mm_struct *mm = tsk->mm;

	mm_release(tsk, mm);
	if (!mm)
		return;
	/*
	 * Serialize with any possible pending coredump.
	 * We must hold mmap_sem around checking core_waiters
	 * and clearing tsk->mm.  The core-inducing thread
	 * will increment core_waiters for each thread in the
	 * group with ->mm != NULL.
	 */
	down_read(&mm->mmap_sem);
	if (mm->core_waiters) {
		up_read(&mm->mmap_sem);
		down_write(&mm->mmap_sem);
		if (!--mm->core_waiters)
			complete(mm->core_startup_done);
		up_write(&mm->mmap_sem);

		wait_for_completion(&mm->core_done);
		down_read(&mm->mmap_sem);
	}
	atomic_inc(&mm->mm_count);
E
Eric Sesterhenn 已提交
682
	BUG_ON(mm != tsk->active_mm);
L
Linus Torvalds 已提交
683 684 685 686 687
	/* more a memory barrier than a real lock */
	task_lock(tsk);
	tsk->mm = NULL;
	up_read(&mm->mmap_sem);
	enter_lazy_tlb(mm, current);
688 689
	/* We don't want this task to be frozen prematurely */
	clear_freeze_flag(tsk);
L
Linus Torvalds 已提交
690
	task_unlock(tsk);
691
	mm_update_next_owner(mm);
L
Linus Torvalds 已提交
692 693 694
	mmput(mm);
}

695 696
static void
reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
L
Linus Torvalds 已提交
697
{
698 699 700 701
	if (p->pdeath_signal)
		/* We already hold the tasklist_lock here.  */
		group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);

L
Linus Torvalds 已提交
702 703 704 705
	/* Move the child from its dying parent to the new one.  */
	if (unlikely(traced)) {
		/* Preserve ptrace links if someone else is tracing this child.  */
		list_del_init(&p->ptrace_list);
706
		if (ptrace_reparented(p))
L
Linus Torvalds 已提交
707 708 709 710 711 712
			list_add(&p->ptrace_list, &p->real_parent->ptrace_children);
	} else {
		/* If this child is being traced, then we're the one tracing it
		 * anyway, so let go of it.
		 */
		p->ptrace = 0;
713
		remove_parent(p);
L
Linus Torvalds 已提交
714
		p->parent = p->real_parent;
715
		add_parent(p);
L
Linus Torvalds 已提交
716

M
Matthew Wilcox 已提交
717
		if (task_is_traced(p)) {
L
Linus Torvalds 已提交
718 719 720 721 722 723 724 725 726
			/*
			 * If it was at a trace stop, turn it into
			 * a normal stop since it's no longer being
			 * traced.
			 */
			ptrace_untrace(p);
		}
	}

727 728 729
	/* If this is a threaded reparent there is no need to
	 * notify anyone anything has happened.
	 */
730
	if (same_thread_group(p->real_parent, father))
731 732 733
		return;

	/* We don't want people slaying init.  */
734
	if (!task_detached(p))
735 736 737 738 739 740
		p->exit_signal = SIGCHLD;

	/* If we'd notified the old parent about this child's death,
	 * also notify the new parent.
	 */
	if (!traced && p->exit_state == EXIT_ZOMBIE &&
741
	    !task_detached(p) && thread_group_empty(p))
742 743
		do_notify_parent(p, p->exit_signal);

744
	kill_orphaned_pgrp(p, father);
L
Linus Torvalds 已提交
745 746 747 748 749 750
}

/*
 * When we die, we re-parent all our children.
 * Try to give them to another thread in our thread
 * group, and if no such member exists, give it to
751 752
 * the child reaper process (ie "init") in our pid
 * space.
L
Linus Torvalds 已提交
753
 */
754
static void forget_original_parent(struct task_struct *father)
L
Linus Torvalds 已提交
755
{
756
	struct task_struct *p, *n, *reaper = father;
757 758 759 760 761
	struct list_head ptrace_dead;

	INIT_LIST_HEAD(&ptrace_dead);

	write_lock_irq(&tasklist_lock);
L
Linus Torvalds 已提交
762 763 764 765

	do {
		reaper = next_thread(reaper);
		if (reaper == father) {
766
			reaper = task_child_reaper(father);
L
Linus Torvalds 已提交
767 768
			break;
		}
769
	} while (reaper->flags & PF_EXITING);
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778

	/*
	 * There are only two places where our children can be:
	 *
	 * - in our child list
	 * - in our ptraced child list
	 *
	 * Search them and reparent children.
	 */
779
	list_for_each_entry_safe(p, n, &father->children, sibling) {
L
Linus Torvalds 已提交
780 781 782 783 784 785 786 787 788
		int ptrace;

		ptrace = p->ptrace;

		/* if father isn't the real parent, then ptrace must be enabled */
		BUG_ON(father != p->real_parent && !ptrace);

		if (father == p->real_parent) {
			/* reparent with a reaper, real father it's us */
789
			p->real_parent = reaper;
L
Linus Torvalds 已提交
790 791 792 793
			reparent_thread(p, father, 0);
		} else {
			/* reparent ptraced task to its real parent */
			__ptrace_unlink (p);
794
			if (p->exit_state == EXIT_ZOMBIE && !task_detached(p) &&
L
Linus Torvalds 已提交
795 796 797 798 799
			    thread_group_empty(p))
				do_notify_parent(p, p->exit_signal);
		}

		/*
800 801 802 803
		 * if the ptraced child is a detached zombie we must collect
		 * it before we exit, or it will remain zombie forever since
		 * we prevented it from self-reap itself while it was being
		 * traced by us, to be able to see it in wait4.
L
Linus Torvalds 已提交
804
		 */
805
		if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && task_detached(p)))
806
			list_add(&p->ptrace_list, &ptrace_dead);
L
Linus Torvalds 已提交
807
	}
808

809
	list_for_each_entry_safe(p, n, &father->ptrace_children, ptrace_list) {
810
		p->real_parent = reaper;
L
Linus Torvalds 已提交
811 812
		reparent_thread(p, father, 1);
	}
813 814 815 816 817 818 819 820 821 822

	write_unlock_irq(&tasklist_lock);
	BUG_ON(!list_empty(&father->children));
	BUG_ON(!list_empty(&father->ptrace_children));

	list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_list) {
		list_del_init(&p->ptrace_list);
		release_task(p);
	}

L
Linus Torvalds 已提交
823 824 825 826 827 828
}

/*
 * Send signals to all our closest relatives so that they know
 * to properly mourn us..
 */
829
static void exit_notify(struct task_struct *tsk, int group_dead)
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837 838 839 840
{
	int state;

	/*
	 * This does two things:
	 *
  	 * A.  Make init inherit all the child processes
	 * B.  Check to see if any process groups have become orphaned
	 *	as a result of our exiting, and if they have any stopped
	 *	jobs, send them a SIGHUP and then a SIGCONT.  (POSIX 3.2.2.2)
	 */
841
	forget_original_parent(tsk);
842
	exit_task_namespaces(tsk);
L
Linus Torvalds 已提交
843

844
	write_lock_irq(&tasklist_lock);
845 846
	if (group_dead)
		kill_orphaned_pgrp(tsk->group_leader, NULL);
L
Linus Torvalds 已提交
847

848
	/* Let father know we died
L
Linus Torvalds 已提交
849 850
	 *
	 * Thread signals are configurable, but you aren't going to use
851
	 * that to send signals to arbitary processes.
L
Linus Torvalds 已提交
852 853 854 855 856 857 858 859 860 861
	 * That stops right now.
	 *
	 * If the parent exec id doesn't match the exec id we saved
	 * when we started then we know the parent has changed security
	 * domain.
	 *
	 * If our self_exec id doesn't match our parent_exec_id then
	 * we have changed execution domain as these two values started
	 * the same after a fork.
	 */
862
	if (tsk->exit_signal != SIGCHLD && !task_detached(tsk) &&
863
	    (tsk->parent_exec_id != tsk->real_parent->self_exec_id ||
864 865
	     tsk->self_exec_id != tsk->parent_exec_id) &&
	    !capable(CAP_KILL))
L
Linus Torvalds 已提交
866 867 868 869 870 871
		tsk->exit_signal = SIGCHLD;

	/* If something other than our normal parent is ptracing us, then
	 * send it a SIGCHLD instead of honoring exit_signal.  exit_signal
	 * only has special meaning to our real parent.
	 */
872
	if (!task_detached(tsk) && thread_group_empty(tsk)) {
873 874
		int signal = ptrace_reparented(tsk) ?
				SIGCHLD : tsk->exit_signal;
L
Linus Torvalds 已提交
875 876 877 878 879 880
		do_notify_parent(tsk, signal);
	} else if (tsk->ptrace) {
		do_notify_parent(tsk, SIGCHLD);
	}

	state = EXIT_ZOMBIE;
881
	if (task_detached(tsk) && likely(!tsk->ptrace))
L
Linus Torvalds 已提交
882 883 884
		state = EXIT_DEAD;
	tsk->exit_state = state;

885
	/* mt-exec, de_thread() is waiting for us */
886 887 888 889 890
	if (thread_group_leader(tsk) &&
	    tsk->signal->notify_count < 0 &&
	    tsk->signal->group_exit_task)
		wake_up_process(tsk->signal->group_exit_task);

L
Linus Torvalds 已提交
891 892 893 894 895 896 897
	write_unlock_irq(&tasklist_lock);

	/* If the process is dead, release it - nobody will wait for it */
	if (state == EXIT_DEAD)
		release_task(tsk);
}

898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
#ifdef CONFIG_DEBUG_STACK_USAGE
static void check_stack_usage(void)
{
	static DEFINE_SPINLOCK(low_water_lock);
	static int lowest_to_date = THREAD_SIZE;
	unsigned long *n = end_of_stack(current);
	unsigned long free;

	while (*n == 0)
		n++;
	free = (unsigned long)n - (unsigned long)end_of_stack(current);

	if (free >= lowest_to_date)
		return;

	spin_lock(&low_water_lock);
	if (free < lowest_to_date) {
		printk(KERN_WARNING "%s used greatest stack depth: %lu bytes "
				"left\n",
				current->comm, free);
		lowest_to_date = free;
	}
	spin_unlock(&low_water_lock);
}
#else
static inline void check_stack_usage(void) {}
#endif

926 927
static inline void exit_child_reaper(struct task_struct *tsk)
{
928
	if (likely(tsk->group_leader != task_child_reaper(tsk)))
929 930
		return;

931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
	if (tsk->nsproxy->pid_ns == &init_pid_ns)
		panic("Attempted to kill init!");

	/*
	 * @tsk is the last thread in the 'cgroup-init' and is exiting.
	 * Terminate all remaining processes in the namespace and reap them
	 * before exiting @tsk.
	 *
	 * Note that @tsk (last thread of cgroup-init) may not necessarily
	 * be the child-reaper (i.e main thread of cgroup-init) of the
	 * namespace i.e the child_reaper may have already exited.
	 *
	 * Even after a child_reaper exits, we let it inherit orphaned children,
	 * because, pid_ns->child_reaper remains valid as long as there is
	 * at least one living sub-thread in the cgroup init.

	 * This living sub-thread of the cgroup-init will be notified when
	 * a child inherited by the 'child-reaper' exits (do_notify_parent()
	 * uses __group_send_sig_info()). Further, when reaping child processes,
	 * do_wait() iterates over children of all living sub threads.

	 * i.e even though 'child_reaper' thread is listed as the parent of the
	 * orphaned children, any living sub-thread in the cgroup-init can
	 * perform the role of the child_reaper.
	 */
	zap_pid_ns_processes(tsk->nsproxy->pid_ns);
957 958
}

959
NORET_TYPE void do_exit(long code)
L
Linus Torvalds 已提交
960 961 962 963 964 965
{
	struct task_struct *tsk = current;
	int group_dead;

	profile_task_exit(tsk);

966 967
	WARN_ON(atomic_read(&tsk->fs_excl));

L
Linus Torvalds 已提交
968 969 970 971 972 973 974 975 976 977
	if (unlikely(in_interrupt()))
		panic("Aiee, killing interrupt handler!");
	if (unlikely(!tsk->pid))
		panic("Attempted to kill the idle task!");

	if (unlikely(current->ptrace & PT_TRACE_EXIT)) {
		current->ptrace_message = code;
		ptrace_notify((PTRACE_EVENT_EXIT << 8) | SIGTRAP);
	}

978 979 980 981 982 983 984
	/*
	 * We're taking recursive faults here in do_exit. Safest is to just
	 * leave this task alone and wait for reboot.
	 */
	if (unlikely(tsk->flags & PF_EXITING)) {
		printk(KERN_ALERT
			"Fixing recursive fault but reboot is needed!\n");
985 986 987 988 989 990 991 992 993 994
		/*
		 * We can do this unlocked here. The futex code uses
		 * this flag just to verify whether the pi state
		 * cleanup has been done or not. In the worst case it
		 * loops once more. We pretend that the cleanup was
		 * done as there is no way to return. Either the
		 * OWNER_DIED bit is set by now or we push the blocked
		 * task into the wait for ever nirwana as well.
		 */
		tsk->flags |= PF_EXITPIDONE;
995 996
		if (tsk->io_context)
			exit_io_context();
997 998 999 1000
		set_current_state(TASK_UNINTERRUPTIBLE);
		schedule();
	}

O
Oleg Nesterov 已提交
1001
	exit_signals(tsk);  /* sets PF_EXITING */
1002 1003 1004 1005
	/*
	 * tsk->flags are checked in the futex code to protect against
	 * an exiting task cleaning up the robust pi futexes.
	 */
1006 1007
	smp_mb();
	spin_unlock_wait(&tsk->pi_lock);
L
Linus Torvalds 已提交
1008 1009 1010

	if (unlikely(in_atomic()))
		printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
1011
				current->comm, task_pid_nr(current),
L
Linus Torvalds 已提交
1012 1013 1014
				preempt_count());

	acct_update_integrals(tsk);
1015 1016 1017 1018
	if (tsk->mm) {
		update_hiwater_rss(tsk->mm);
		update_hiwater_vm(tsk->mm);
	}
L
Linus Torvalds 已提交
1019
	group_dead = atomic_dec_and_test(&tsk->signal->live);
1020
	if (group_dead) {
1021
		exit_child_reaper(tsk);
1022
		hrtimer_cancel(&tsk->signal->real_timer);
1023
		exit_itimers(tsk->signal);
1024
	}
1025
	acct_collect(code, group_dead);
1026
#ifdef CONFIG_FUTEX
1027 1028
	if (unlikely(tsk->robust_list))
		exit_robust_list(tsk);
1029
#ifdef CONFIG_COMPAT
1030 1031
	if (unlikely(tsk->compat_robust_list))
		compat_exit_robust_list(tsk);
1032
#endif
1033
#endif
M
Miloslav Trmac 已提交
1034 1035
	if (group_dead)
		tty_audit_exit();
1036 1037
	if (unlikely(tsk->audit_context))
		audit_free(tsk);
1038

1039
	tsk->exit_code = code;
1040
	taskstats_exit(tsk, group_dead);
1041

L
Linus Torvalds 已提交
1042 1043
	exit_mm(tsk);

1044
	if (group_dead)
1045
		acct_process();
L
Linus Torvalds 已提交
1046
	exit_sem(tsk);
1047 1048
	exit_files(tsk);
	exit_fs(tsk);
1049
	check_stack_usage();
L
Linus Torvalds 已提交
1050
	exit_thread();
1051
	cgroup_exit(tsk, 1);
L
Linus Torvalds 已提交
1052 1053 1054 1055 1056
	exit_keys(tsk);

	if (group_dead && tsk->signal->leader)
		disassociate_ctty(1);

A
Al Viro 已提交
1057
	module_put(task_thread_info(tsk)->exec_domain->module);
L
Linus Torvalds 已提交
1058 1059 1060
	if (tsk->binfmt)
		module_put(tsk->binfmt->module);

M
Matt Helsley 已提交
1061
	proc_exit_connector(tsk);
1062
	exit_notify(tsk, group_dead);
L
Linus Torvalds 已提交
1063
#ifdef CONFIG_NUMA
1064
	mpol_put(tsk->mempolicy);
L
Linus Torvalds 已提交
1065 1066
	tsk->mempolicy = NULL;
#endif
1067
#ifdef CONFIG_FUTEX
1068 1069 1070 1071 1072 1073 1074 1075
	/*
	 * This must happen late, after the PID is not
	 * hashed anymore:
	 */
	if (unlikely(!list_empty(&tsk->pi_state_list)))
		exit_pi_state_list(tsk);
	if (unlikely(current->pi_state_cache))
		kfree(current->pi_state_cache);
1076
#endif
1077
	/*
1078
	 * Make sure we are holding no locks:
1079
	 */
1080
	debug_check_no_locks_held(tsk);
1081 1082 1083 1084 1085 1086
	/*
	 * We can do this unlocked here. The futex code uses this flag
	 * just to verify whether the pi state cleanup has been done
	 * or not. In the worst case it loops once more.
	 */
	tsk->flags |= PF_EXITPIDONE;
L
Linus Torvalds 已提交
1087

1088 1089 1090
	if (tsk->io_context)
		exit_io_context();

1091 1092 1093
	if (tsk->splice_pipe)
		__free_pipe_info(tsk->splice_pipe);

C
Coywolf Qi Hunt 已提交
1094
	preempt_disable();
O
Oleg Nesterov 已提交
1095
	/* causes final put_task_struct in finish_task_switch(). */
1096
	tsk->state = TASK_DEAD;
C
Coywolf Qi Hunt 已提交
1097

L
Linus Torvalds 已提交
1098 1099 1100
	schedule();
	BUG();
	/* Avoid "noreturn function does return".  */
A
Alan Cox 已提交
1101 1102
	for (;;)
		cpu_relax();	/* For when BUG is null */
L
Linus Torvalds 已提交
1103 1104
}

1105 1106
EXPORT_SYMBOL_GPL(do_exit);

L
Linus Torvalds 已提交
1107 1108 1109 1110
NORET_TYPE void complete_and_exit(struct completion *comp, long code)
{
	if (comp)
		complete(comp);
O
Oleg Nesterov 已提交
1111

L
Linus Torvalds 已提交
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	do_exit(code);
}

EXPORT_SYMBOL(complete_and_exit);

asmlinkage long sys_exit(int error_code)
{
	do_exit((error_code&0xff)<<8);
}

/*
 * Take down every thread in the group.  This is called by fatal signals
 * as well as by sys_exit_group (below).
 */
NORET_TYPE void
do_group_exit(int exit_code)
{
1129 1130
	struct signal_struct *sig = current->signal;

L
Linus Torvalds 已提交
1131 1132
	BUG_ON(exit_code & 0x80); /* core dumps don't get here */

1133 1134
	if (signal_group_exit(sig))
		exit_code = sig->group_exit_code;
L
Linus Torvalds 已提交
1135 1136 1137
	else if (!thread_group_empty(current)) {
		struct sighand_struct *const sighand = current->sighand;
		spin_lock_irq(&sighand->siglock);
1138
		if (signal_group_exit(sig))
L
Linus Torvalds 已提交
1139 1140 1141 1142
			/* Another thread got here before we took the lock.  */
			exit_code = sig->group_exit_code;
		else {
			sig->group_exit_code = exit_code;
1143
			sig->flags = SIGNAL_GROUP_EXIT;
L
Linus Torvalds 已提交
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
			zap_other_threads(current);
		}
		spin_unlock_irq(&sighand->siglock);
	}

	do_exit(exit_code);
	/* NOTREACHED */
}

/*
 * this kills every thread in the thread group. Note that any externally
 * wait4()-ing process will get the correct exit code - even if this
 * thread is not the thread group leader.
 */
asmlinkage void sys_exit_group(int error_code)
{
	do_group_exit((error_code & 0xff) << 8);
}

E
Eric W. Biederman 已提交
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
static struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
{
	struct pid *pid = NULL;
	if (type == PIDTYPE_PID)
		pid = task->pids[type].pid;
	else if (type < PIDTYPE_MAX)
		pid = task->group_leader->pids[type].pid;
	return pid;
}

static int eligible_child(enum pid_type type, struct pid *pid, int options,
			  struct task_struct *p)
L
Linus Torvalds 已提交
1175
{
1176 1177
	int err;

E
Eric W. Biederman 已提交
1178 1179
	if (type < PIDTYPE_MAX) {
		if (task_pid_type(p, type) != pid)
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186
			return 0;
	}

	/*
	 * Do not consider detached threads that are
	 * not ptraced:
	 */
1187
	if (task_detached(p) && !p->ptrace)
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
		return 0;

	/* Wait for all children (clone and not) if __WALL is set;
	 * otherwise, wait for clone children *only* if __WCLONE is
	 * set; otherwise, wait for non-clone children *only*.  (Note:
	 * A "clone" child here is one that reports to its parent
	 * using a signal other than SIGCHLD.) */
	if (((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
	    && !(options & __WALL))
		return 0;

1199
	err = security_task_wait(p);
O
Oleg Nesterov 已提交
1200 1201
	if (likely(!err))
		return 1;
L
Linus Torvalds 已提交
1202

E
Eric W. Biederman 已提交
1203
	if (type != PIDTYPE_PID)
O
Oleg Nesterov 已提交
1204 1205 1206 1207
		return 0;
	/* This child was explicitly requested, abort */
	read_unlock(&tasklist_lock);
	return err;
L
Linus Torvalds 已提交
1208 1209
}

1210
static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
L
Linus Torvalds 已提交
1211 1212 1213 1214 1215
			       int why, int status,
			       struct siginfo __user *infop,
			       struct rusage __user *rusagep)
{
	int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
1216

L
Linus Torvalds 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
	put_task_struct(p);
	if (!retval)
		retval = put_user(SIGCHLD, &infop->si_signo);
	if (!retval)
		retval = put_user(0, &infop->si_errno);
	if (!retval)
		retval = put_user((short)why, &infop->si_code);
	if (!retval)
		retval = put_user(pid, &infop->si_pid);
	if (!retval)
		retval = put_user(uid, &infop->si_uid);
	if (!retval)
		retval = put_user(status, &infop->si_status);
	if (!retval)
		retval = pid;
	return retval;
}

/*
 * Handle sys_wait4 work for one task in state EXIT_ZOMBIE.  We hold
 * read_lock(&tasklist_lock) on entry.  If we return zero, we still hold
 * the lock and this task is uninteresting.  If we return nonzero, we have
 * released the lock and the system call should return.
 */
1241
static int wait_task_zombie(struct task_struct *p, int noreap,
L
Linus Torvalds 已提交
1242 1243 1244 1245
			    struct siginfo __user *infop,
			    int __user *stat_addr, struct rusage __user *ru)
{
	unsigned long state;
1246
	int retval, status, traced;
1247
	pid_t pid = task_pid_vnr(p);
L
Linus Torvalds 已提交
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276

	if (unlikely(noreap)) {
		uid_t uid = p->uid;
		int exit_code = p->exit_code;
		int why, status;

		get_task_struct(p);
		read_unlock(&tasklist_lock);
		if ((exit_code & 0x7f) == 0) {
			why = CLD_EXITED;
			status = exit_code >> 8;
		} else {
			why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
			status = exit_code & 0x7f;
		}
		return wait_noreap_copyout(p, pid, uid, why,
					   status, infop, ru);
	}

	/*
	 * Try to move the task's state to DEAD
	 * only one thread is allowed to do this:
	 */
	state = xchg(&p->exit_state, EXIT_DEAD);
	if (state != EXIT_ZOMBIE) {
		BUG_ON(state != EXIT_DEAD);
		return 0;
	}

1277
	traced = ptrace_reparented(p);
1278 1279

	if (likely(!traced)) {
1280 1281 1282
		struct signal_struct *psig;
		struct signal_struct *sig;

L
Linus Torvalds 已提交
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
		/*
		 * The resource counters for the group leader are in its
		 * own task_struct.  Those for dead threads in the group
		 * are in its signal_struct, as are those for the child
		 * processes it has previously reaped.  All these
		 * accumulate in the parent's signal_struct c* fields.
		 *
		 * We don't bother to take a lock here to protect these
		 * p->signal fields, because they are only touched by
		 * __exit_signal, which runs with tasklist_lock
		 * write-locked anyway, and so is excluded here.  We do
		 * need to protect the access to p->parent->signal fields,
		 * as other threads in the parent group can be right
		 * here reaping other children at the same time.
		 */
		spin_lock_irq(&p->parent->sighand->siglock);
1299 1300 1301 1302
		psig = p->parent->signal;
		sig = p->signal;
		psig->cutime =
			cputime_add(psig->cutime,
L
Linus Torvalds 已提交
1303
			cputime_add(p->utime,
1304 1305 1306 1307
			cputime_add(sig->utime,
				    sig->cutime)));
		psig->cstime =
			cputime_add(psig->cstime,
L
Linus Torvalds 已提交
1308
			cputime_add(p->stime,
1309 1310
			cputime_add(sig->stime,
				    sig->cstime)));
1311 1312 1313 1314 1315
		psig->cgtime =
			cputime_add(psig->cgtime,
			cputime_add(p->gtime,
			cputime_add(sig->gtime,
				    sig->cgtime)));
1316 1317 1318 1319 1320 1321 1322 1323
		psig->cmin_flt +=
			p->min_flt + sig->min_flt + sig->cmin_flt;
		psig->cmaj_flt +=
			p->maj_flt + sig->maj_flt + sig->cmaj_flt;
		psig->cnvcsw +=
			p->nvcsw + sig->nvcsw + sig->cnvcsw;
		psig->cnivcsw +=
			p->nivcsw + sig->nivcsw + sig->cnivcsw;
1324 1325 1326 1327 1328 1329
		psig->cinblock +=
			task_io_get_inblock(p) +
			sig->inblock + sig->cinblock;
		psig->coublock +=
			task_io_get_oublock(p) +
			sig->oublock + sig->coublock;
L
Linus Torvalds 已提交
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
		spin_unlock_irq(&p->parent->sighand->siglock);
	}

	/*
	 * Now we are sure this task is interesting, and no other
	 * thread can reap it because we set its state to EXIT_DEAD.
	 */
	read_unlock(&tasklist_lock);

	retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
	status = (p->signal->flags & SIGNAL_GROUP_EXIT)
		? p->signal->group_exit_code : p->exit_code;
	if (!retval && stat_addr)
		retval = put_user(status, stat_addr);
	if (!retval && infop)
		retval = put_user(SIGCHLD, &infop->si_signo);
	if (!retval && infop)
		retval = put_user(0, &infop->si_errno);
	if (!retval && infop) {
		int why;

		if ((status & 0x7f) == 0) {
			why = CLD_EXITED;
			status >>= 8;
		} else {
			why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
			status &= 0x7f;
		}
		retval = put_user((short)why, &infop->si_code);
		if (!retval)
			retval = put_user(status, &infop->si_status);
	}
	if (!retval && infop)
1363
		retval = put_user(pid, &infop->si_pid);
L
Linus Torvalds 已提交
1364 1365
	if (!retval && infop)
		retval = put_user(p->uid, &infop->si_uid);
1366
	if (!retval)
1367
		retval = pid;
1368 1369

	if (traced) {
L
Linus Torvalds 已提交
1370
		write_lock_irq(&tasklist_lock);
1371 1372 1373 1374 1375 1376 1377
		/* We dropped tasklist, ptracer could die and untrace */
		ptrace_unlink(p);
		/*
		 * If this is not a detached task, notify the parent.
		 * If it's still not detached after that, don't release
		 * it now.
		 */
1378
		if (!task_detached(p)) {
1379
			do_notify_parent(p, p->exit_signal);
1380
			if (!task_detached(p)) {
1381 1382
				p->exit_state = EXIT_ZOMBIE;
				p = NULL;
L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388
			}
		}
		write_unlock_irq(&tasklist_lock);
	}
	if (p != NULL)
		release_task(p);
1389

L
Linus Torvalds 已提交
1390 1391 1392 1393 1394 1395 1396 1397 1398
	return retval;
}

/*
 * Handle sys_wait4 work for one task in state TASK_STOPPED.  We hold
 * read_lock(&tasklist_lock) on entry.  If we return zero, we still hold
 * the lock and this task is uninteresting.  If we return nonzero, we have
 * released the lock and the system call should return.
 */
1399
static int wait_task_stopped(struct task_struct *p,
1400
			     int noreap, struct siginfo __user *infop,
L
Linus Torvalds 已提交
1401 1402
			     int __user *stat_addr, struct rusage __user *ru)
{
1403 1404
	int retval, exit_code, why;
	uid_t uid = 0; /* unneeded, required by compiler */
1405
	pid_t pid;
L
Linus Torvalds 已提交
1406

1407 1408 1409 1410 1411 1412
	exit_code = 0;
	spin_lock_irq(&p->sighand->siglock);

	if (unlikely(!task_is_stopped_or_traced(p)))
		goto unlock_sig;

1413
	if (!(p->ptrace & PT_PTRACED) && p->signal->group_stop_count > 0)
L
Linus Torvalds 已提交
1414 1415 1416 1417
		/*
		 * A group stop is in progress and this is the group leader.
		 * We won't report until all threads have stopped.
		 */
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
		goto unlock_sig;

	exit_code = p->exit_code;
	if (!exit_code)
		goto unlock_sig;

	if (!noreap)
		p->exit_code = 0;

	uid = p->uid;
unlock_sig:
	spin_unlock_irq(&p->sighand->siglock);
	if (!exit_code)
L
Linus Torvalds 已提交
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
		return 0;

	/*
	 * Now we are pretty sure this task is interesting.
	 * Make sure it doesn't get reaped out from under us while we
	 * give up the lock and then examine it below.  We don't want to
	 * keep holding onto the tasklist_lock while we call getrusage and
	 * possibly take page faults for user memory.
	 */
	get_task_struct(p);
1441
	pid = task_pid_vnr(p);
1442
	why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;
L
Linus Torvalds 已提交
1443 1444
	read_unlock(&tasklist_lock);

1445
	if (unlikely(noreap))
L
Linus Torvalds 已提交
1446
		return wait_noreap_copyout(p, pid, uid,
1447
					   why, exit_code,
L
Linus Torvalds 已提交
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
					   infop, ru);

	retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
	if (!retval && stat_addr)
		retval = put_user((exit_code << 8) | 0x7f, stat_addr);
	if (!retval && infop)
		retval = put_user(SIGCHLD, &infop->si_signo);
	if (!retval && infop)
		retval = put_user(0, &infop->si_errno);
	if (!retval && infop)
R
Roland McGrath 已提交
1458
		retval = put_user((short)why, &infop->si_code);
L
Linus Torvalds 已提交
1459 1460 1461
	if (!retval && infop)
		retval = put_user(exit_code, &infop->si_status);
	if (!retval && infop)
1462
		retval = put_user(pid, &infop->si_pid);
L
Linus Torvalds 已提交
1463
	if (!retval && infop)
1464
		retval = put_user(uid, &infop->si_uid);
L
Linus Torvalds 已提交
1465
	if (!retval)
1466
		retval = pid;
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
	put_task_struct(p);

	BUG_ON(!retval);
	return retval;
}

/*
 * Handle do_wait work for one task in a live, non-stopped state.
 * read_lock(&tasklist_lock) on entry.  If we return zero, we still hold
 * the lock and this task is uninteresting.  If we return nonzero, we have
 * released the lock and the system call should return.
 */
1479
static int wait_task_continued(struct task_struct *p, int noreap,
L
Linus Torvalds 已提交
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
			       struct siginfo __user *infop,
			       int __user *stat_addr, struct rusage __user *ru)
{
	int retval;
	pid_t pid;
	uid_t uid;

	if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
		return 0;

	spin_lock_irq(&p->sighand->siglock);
	/* Re-check with the lock held.  */
	if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
		spin_unlock_irq(&p->sighand->siglock);
		return 0;
	}
	if (!noreap)
		p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
	spin_unlock_irq(&p->sighand->siglock);

1500
	pid = task_pid_vnr(p);
L
Linus Torvalds 已提交
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
	uid = p->uid;
	get_task_struct(p);
	read_unlock(&tasklist_lock);

	if (!infop) {
		retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
		put_task_struct(p);
		if (!retval && stat_addr)
			retval = put_user(0xffff, stat_addr);
		if (!retval)
1511
			retval = pid;
L
Linus Torvalds 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
	} else {
		retval = wait_noreap_copyout(p, pid, uid,
					     CLD_CONTINUED, SIGCONT,
					     infop, ru);
		BUG_ON(retval == 0);
	}

	return retval;
}

E
Eric W. Biederman 已提交
1522 1523 1524
static long do_wait(enum pid_type type, struct pid *pid, int options,
		    struct siginfo __user *infop, int __user *stat_addr,
		    struct rusage __user *ru)
L
Linus Torvalds 已提交
1525 1526 1527 1528 1529 1530 1531
{
	DECLARE_WAITQUEUE(wait, current);
	struct task_struct *tsk;
	int flag, retval;

	add_wait_queue(&current->signal->wait_chldexit,&wait);
repeat:
E
Eric W. Biederman 已提交
1532 1533 1534 1535 1536
	/* If there is nothing that can match our critier just get out */
	retval = -ECHILD;
	if ((type < PIDTYPE_MAX) && (!pid || hlist_empty(&pid->tasks[type])))
		goto end;

L
Linus Torvalds 已提交
1537 1538 1539 1540
	/*
	 * We will set this flag if we see any child that might later
	 * match our criteria, even if we are not able to reap it yet.
	 */
O
Oleg Nesterov 已提交
1541
	flag = retval = 0;
L
Linus Torvalds 已提交
1542 1543 1544 1545 1546 1547
	current->state = TASK_INTERRUPTIBLE;
	read_lock(&tasklist_lock);
	tsk = current;
	do {
		struct task_struct *p;

1548
		list_for_each_entry(p, &tsk->children, sibling) {
E
Eric W. Biederman 已提交
1549
			int ret = eligible_child(type, pid, options, p);
L
Linus Torvalds 已提交
1550 1551 1552
			if (!ret)
				continue;

1553
			if (unlikely(ret < 0)) {
O
Oleg Nesterov 已提交
1554 1555
				retval = ret;
			} else if (task_is_stopped_or_traced(p)) {
L
Linus Torvalds 已提交
1556 1557 1558 1559 1560
				/*
				 * It's stopped now, so it might later
				 * continue, exit, or stop again.
				 */
				flag = 1;
O
Oleg Nesterov 已提交
1561 1562 1563
				if (!(p->ptrace & PT_PTRACED) &&
				    !(options & WUNTRACED))
					continue;
M
Matthew Wilcox 已提交
1564

1565
				retval = wait_task_stopped(p,
M
Matthew Wilcox 已提交
1566 1567
						(options & WNOWAIT), infop,
						stat_addr, ru);
1568 1569
			} else if (p->exit_state == EXIT_ZOMBIE &&
					!delay_group_leader(p)) {
M
Matthew Wilcox 已提交
1570
				/*
1571
				 * We don't reap group leaders with subthreads.
M
Matthew Wilcox 已提交
1572 1573
				 */
				if (!likely(options & WEXITED))
L
Linus Torvalds 已提交
1574
					continue;
M
Matthew Wilcox 已提交
1575 1576 1577
				retval = wait_task_zombie(p,
						(options & WNOWAIT), infop,
						stat_addr, ru);
1578
			} else if (p->exit_state != EXIT_DEAD) {
L
Linus Torvalds 已提交
1579 1580 1581 1582 1583 1584 1585
				/*
				 * It's running now, so it might later
				 * exit, stop, or stop and then continue.
				 */
				flag = 1;
				if (!unlikely(options & WCONTINUED))
					continue;
M
Matthew Wilcox 已提交
1586 1587 1588
				retval = wait_task_continued(p,
						(options & WNOWAIT), infop,
						stat_addr, ru);
L
Linus Torvalds 已提交
1589
			}
1590 1591
			if (retval != 0) /* tasklist_lock released */
				goto end;
L
Linus Torvalds 已提交
1592 1593
		}
		if (!flag) {
1594
			list_for_each_entry(p, &tsk->ptrace_children,
O
Oleg Nesterov 已提交
1595
								ptrace_list) {
E
Eric W. Biederman 已提交
1596
				flag = eligible_child(type, pid, options, p);
O
Oleg Nesterov 已提交
1597
				if (!flag)
L
Linus Torvalds 已提交
1598
					continue;
O
Oleg Nesterov 已提交
1599 1600 1601 1602
				if (likely(flag > 0))
					break;
				retval = flag;
				goto end;
L
Linus Torvalds 已提交
1603 1604 1605 1606 1607
			}
		}
		if (options & __WNOTHREAD)
			break;
		tsk = next_thread(tsk);
E
Eric Sesterhenn 已提交
1608
		BUG_ON(tsk->signal != current->signal);
L
Linus Torvalds 已提交
1609 1610
	} while (tsk != current);
	read_unlock(&tasklist_lock);
O
Oleg Nesterov 已提交
1611

L
Linus Torvalds 已提交
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
	if (flag) {
		if (options & WNOHANG)
			goto end;
		retval = -ERESTARTSYS;
		if (signal_pending(current))
			goto end;
		schedule();
		goto repeat;
	}
	retval = -ECHILD;
end:
	current->state = TASK_RUNNING;
	remove_wait_queue(&current->signal->wait_chldexit,&wait);
	if (infop) {
		if (retval > 0)
1627
			retval = 0;
L
Linus Torvalds 已提交
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
		else {
			/*
			 * For a WNOHANG return, clear out all the fields
			 * we would set so the user can easily tell the
			 * difference.
			 */
			if (!retval)
				retval = put_user(0, &infop->si_signo);
			if (!retval)
				retval = put_user(0, &infop->si_errno);
			if (!retval)
				retval = put_user(0, &infop->si_code);
			if (!retval)
				retval = put_user(0, &infop->si_pid);
			if (!retval)
				retval = put_user(0, &infop->si_uid);
			if (!retval)
				retval = put_user(0, &infop->si_status);
		}
	}
	return retval;
}

E
Eric W. Biederman 已提交
1651
asmlinkage long sys_waitid(int which, pid_t upid,
L
Linus Torvalds 已提交
1652 1653 1654
			   struct siginfo __user *infop, int options,
			   struct rusage __user *ru)
{
E
Eric W. Biederman 已提交
1655 1656
	struct pid *pid = NULL;
	enum pid_type type;
L
Linus Torvalds 已提交
1657 1658 1659 1660 1661 1662 1663 1664 1665
	long ret;

	if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED))
		return -EINVAL;
	if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
		return -EINVAL;

	switch (which) {
	case P_ALL:
E
Eric W. Biederman 已提交
1666
		type = PIDTYPE_MAX;
L
Linus Torvalds 已提交
1667 1668
		break;
	case P_PID:
E
Eric W. Biederman 已提交
1669 1670
		type = PIDTYPE_PID;
		if (upid <= 0)
L
Linus Torvalds 已提交
1671 1672 1673
			return -EINVAL;
		break;
	case P_PGID:
E
Eric W. Biederman 已提交
1674 1675
		type = PIDTYPE_PGID;
		if (upid <= 0)
L
Linus Torvalds 已提交
1676 1677 1678 1679 1680 1681
			return -EINVAL;
		break;
	default:
		return -EINVAL;
	}

E
Eric W. Biederman 已提交
1682 1683 1684 1685
	if (type < PIDTYPE_MAX)
		pid = find_get_pid(upid);
	ret = do_wait(type, pid, options, infop, NULL, ru);
	put_pid(pid);
L
Linus Torvalds 已提交
1686 1687

	/* avoid REGPARM breakage on x86: */
1688
	asmlinkage_protect(5, ret, which, upid, infop, options, ru);
L
Linus Torvalds 已提交
1689 1690 1691
	return ret;
}

E
Eric W. Biederman 已提交
1692
asmlinkage long sys_wait4(pid_t upid, int __user *stat_addr,
L
Linus Torvalds 已提交
1693 1694
			  int options, struct rusage __user *ru)
{
E
Eric W. Biederman 已提交
1695 1696
	struct pid *pid = NULL;
	enum pid_type type;
L
Linus Torvalds 已提交
1697 1698 1699 1700 1701
	long ret;

	if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
			__WNOTHREAD|__WCLONE|__WALL))
		return -EINVAL;
E
Eric W. Biederman 已提交
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717

	if (upid == -1)
		type = PIDTYPE_MAX;
	else if (upid < 0) {
		type = PIDTYPE_PGID;
		pid = find_get_pid(-upid);
	} else if (upid == 0) {
		type = PIDTYPE_PGID;
		pid = get_pid(task_pgrp(current));
	} else /* upid > 0 */ {
		type = PIDTYPE_PID;
		pid = find_get_pid(upid);
	}

	ret = do_wait(type, pid, options | WEXITED, NULL, stat_addr, ru);
	put_pid(pid);
L
Linus Torvalds 已提交
1718 1719

	/* avoid REGPARM breakage on x86: */
1720
	asmlinkage_protect(4, ret, upid, stat_addr, options, ru);
L
Linus Torvalds 已提交
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
	return ret;
}

#ifdef __ARCH_WANT_SYS_WAITPID

/*
 * sys_waitpid() remains for compatibility. waitpid() should be
 * implemented by calling sys_wait4() from libc.a.
 */
asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options)
{
	return sys_wait4(pid, stat_addr, options, NULL);
}

#endif