exit.c 45.7 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>
R
Roland McGrath 已提交
49
#include <linux/tracehook.h>
L
Linus Torvalds 已提交
50 51 52 53 54 55

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

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

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

L
Linus Torvalds 已提交
63 64 65 66 67 68 69
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);
70

71
		list_del_rcu(&p->tasks);
72
		__get_cpu_var(process_counts)--;
L
Linus Torvalds 已提交
73
	}
O
Oleg Nesterov 已提交
74
	list_del_rcu(&p->thread_group);
R
Roland McGrath 已提交
75
	list_del_init(&p->sibling);
L
Linus Torvalds 已提交
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));

	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
		task_io_accounting_add(&sig->ioac, &tsk->ioac);
125
		sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
126 127 128
		sig = NULL; /* Marker for below. */
	}

129 130
	__unhash_process(tsk);

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

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

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

R
Roland McGrath 已提交
155

L
Linus Torvalds 已提交
156 157
void release_task(struct task_struct * p)
{
158
	struct task_struct *leader;
L
Linus Torvalds 已提交
159
	int zap_leader;
160
repeat:
R
Roland McGrath 已提交
161
	tracehook_prepare_release_task(p);
L
Linus Torvalds 已提交
162
	atomic_dec(&p->user->processes);
163
	proc_flush_task(p);
L
Linus Torvalds 已提交
164
	write_lock_irq(&tasklist_lock);
R
Roland McGrath 已提交
165
	tracehook_finish_release_task(p);
L
Linus Torvalds 已提交
166
	__exit_signal(p);
167

L
Linus Torvalds 已提交
168 169 170 171 172 173 174 175
	/*
	 * 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) {
176
		BUG_ON(task_detached(leader));
L
Linus Torvalds 已提交
177 178 179 180 181 182 183 184 185
		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.
		 */
186
		zap_leader = task_detached(leader);
R
Roland McGrath 已提交
187 188 189 190 191 192 193

		/*
		 * This maintains the invariant that release_task()
		 * only runs on a task in EXIT_DEAD, just for sanity.
		 */
		if (zap_leader)
			leader->exit_state = EXIT_DEAD;
L
Linus Torvalds 已提交
194 195 196 197
	}

	write_unlock_irq(&tasklist_lock);
	release_thread(p);
198
	call_rcu(&p->rcu, delayed_put_task_struct);
L
Linus Torvalds 已提交
199 200 201 202 203 204 205 206 207 208

	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...
209 210
 *
 * The caller must hold rcu lock or the tasklist lock.
L
Linus Torvalds 已提交
211
 */
212
struct pid *session_of_pgrp(struct pid *pgrp)
L
Linus Torvalds 已提交
213 214
{
	struct task_struct *p;
215
	struct pid *sid = NULL;
216

217
	p = pid_task(pgrp, PIDTYPE_PGID);
218
	if (p == NULL)
219
		p = pid_task(pgrp, PIDTYPE_PID);
220
	if (p != NULL)
221
		sid = task_session(p);
222

L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230 231 232 233
	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?"
 */
234
static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
L
Linus Torvalds 已提交
235 236 237
{
	struct task_struct *p;

238
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
239 240 241
		if ((p == ignored_task) ||
		    (p->exit_state && thread_group_empty(p)) ||
		    is_global_init(p->real_parent))
L
Linus Torvalds 已提交
242
			continue;
243

244
		if (task_pgrp(p->real_parent) != pgrp &&
245 246
		    task_session(p->real_parent) == task_session(p))
			return 0;
247
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
248 249

	return 1;
L
Linus Torvalds 已提交
250 251
}

252
int is_current_pgrp_orphaned(void)
L
Linus Torvalds 已提交
253 254 255 256
{
	int retval;

	read_lock(&tasklist_lock);
257
	retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
L
Linus Torvalds 已提交
258 259 260 261 262
	read_unlock(&tasklist_lock);

	return retval;
}

263
static int has_stopped_jobs(struct pid *pgrp)
L
Linus Torvalds 已提交
264 265 266 267
{
	int retval = 0;
	struct task_struct *p;

268
	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
M
Matthew Wilcox 已提交
269
		if (!task_is_stopped(p))
L
Linus Torvalds 已提交
270 271 272
			continue;
		retval = 1;
		break;
273
	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
274 275 276
	return retval;
}

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
/*
 * 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 已提交
308
/**
309
 * reparent_to_kthreadd - Reparent the calling kernel thread to kthreadd
L
Linus Torvalds 已提交
310 311
 *
 * If a kernel thread is launched as a result of a system call, or if
312 313
 * 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 已提交
314 315 316 317
 *
 * 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.
 *
318
 * NOTE that reparent_to_kthreadd() gives the caller full capabilities.
L
Linus Torvalds 已提交
319
 */
320
static void reparent_to_kthreadd(void)
L
Linus Torvalds 已提交
321 322 323 324 325
{
	write_lock_irq(&tasklist_lock);

	ptrace_unlink(current);
	/* Reparent to init */
326
	current->real_parent = current->parent = kthreadd_task;
R
Roland McGrath 已提交
327
	list_move_tail(&current->sibling, &current->real_parent->children);
L
Linus Torvalds 已提交
328 329 330 331

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

332
	if (task_nice(current) < 0)
L
Linus Torvalds 已提交
333 334 335 336 337 338 339 340 341 342 343 344
		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);
}

345
void __set_special_pids(struct pid *pid)
L
Linus Torvalds 已提交
346
{
347
	struct task_struct *curr = current->group_leader;
348
	pid_t nr = pid_nr(pid);
L
Linus Torvalds 已提交
349

350
	if (task_session(curr) != pid) {
351
		change_pid(curr, PIDTYPE_SID, pid);
352
		set_task_session(curr, nr);
L
Linus Torvalds 已提交
353
	}
354
	if (task_pgrp(curr) != pid) {
355
		change_pid(curr, PIDTYPE_PGID, pid);
356
		set_task_pgrp(curr, nr);
L
Linus Torvalds 已提交
357 358 359
	}
}

360
static void set_special_pids(struct pid *pid)
L
Linus Torvalds 已提交
361 362
{
	write_lock_irq(&tasklist_lock);
363
	__set_special_pids(pid);
L
Linus Torvalds 已提交
364 365 366 367 368 369 370 371 372 373
	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)
{
374
	if (!valid_signal(sig) || sig < 1)
L
Linus Torvalds 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
		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)
{
395
	if (!valid_signal(sig) || sig < 1)
L
Linus Torvalds 已提交
396 397 398
		return -EINVAL;

	spin_lock_irq(&current->sighand->siglock);
399
	current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN;
L
Linus Torvalds 已提交
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
	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);
428 429 430 431
	/*
	 * We don't want to have TIF_FREEZE set if the system-wide hibernation
	 * or suspend transition begins right now.
	 */
O
Oleg Nesterov 已提交
432
	current->flags |= (PF_NOFREEZE | PF_KTHREAD);
L
Linus Torvalds 已提交
433

434 435 436 437
	if (current->nsproxy != &init_nsproxy) {
		get_nsproxy(&init_nsproxy);
		switch_task_namespaces(current, &init_nsproxy);
	}
438
	set_special_pids(&init_struct_pid);
439
	proc_clear_tty(current);
L
Linus Torvalds 已提交
440 441 442 443 444 445 446 447 448 449 450 451

	/* 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 已提交
452

453
	exit_files(current);
L
Linus Torvalds 已提交
454 455 456
	current->files = init_task.files;
	atomic_inc(&current->files->count);

457
	reparent_to_kthreadd();
L
Linus Torvalds 已提交
458 459 460 461
}

EXPORT_SYMBOL(daemonize);

462
static void close_files(struct files_struct * files)
L
Linus Torvalds 已提交
463 464
{
	int i, j;
465
	struct fdtable *fdt;
L
Linus Torvalds 已提交
466 467

	j = 0;
468 469 470 471 472 473

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

508
void put_files_struct(struct files_struct *files)
L
Linus Torvalds 已提交
509
{
510 511
	struct fdtable *fdt;

L
Linus Torvalds 已提交
512 513 514 515
	if (atomic_dec_and_test(&files->count)) {
		close_files(files);
		/*
		 * Free the fd and fdset arrays if we expanded them.
516 517 518
		 * 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 已提交
519
		 */
520
		fdt = files_fdtable(files);
521
		if (fdt != &files->fdtab)
522
			kmem_cache_free(files_cachep, files);
523
		free_fdtable(fdt);
L
Linus Torvalds 已提交
524 525 526
	}
}

527
void reset_files_struct(struct files_struct *files)
528
{
529
	struct task_struct *tsk = current;
530 531 532 533 534 535 536 537 538
	struct files_struct *old;

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

539
void exit_files(struct task_struct *tsk)
L
Linus Torvalds 已提交
540 541 542 543 544 545 546 547 548 549 550
{
	struct files_struct * files = tsk->files;

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

551
void put_fs_struct(struct fs_struct *fs)
L
Linus Torvalds 已提交
552 553 554
{
	/* No need to hold fs->lock if we are killing it */
	if (atomic_dec_and_test(&fs->count)) {
J
Jan Blunck 已提交
555 556
		path_put(&fs->root);
		path_put(&fs->pwd);
L
Linus Torvalds 已提交
557 558 559 560
		kmem_cache_free(fs_cachep, fs);
	}
}

561
void exit_fs(struct task_struct *tsk)
L
Linus Torvalds 已提交
562 563 564 565 566 567 568
{
	struct fs_struct * fs = tsk->fs;

	if (fs) {
		task_lock(tsk);
		tsk->fs = NULL;
		task_unlock(tsk);
569
		put_fs_struct(fs);
L
Linus Torvalds 已提交
570 571 572 573 574
	}
}

EXPORT_SYMBOL_GPL(exit_fs);

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 652 653 654 655 656
#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 已提交
657 658 659 660
/*
 * Turn us into a lazy TLB process if we
 * aren't already..
 */
A
Adrian Bunk 已提交
661
static void exit_mm(struct task_struct * tsk)
L
Linus Torvalds 已提交
662 663
{
	struct mm_struct *mm = tsk->mm;
664
	struct core_state *core_state;
L
Linus Torvalds 已提交
665 666 667 668 669 670

	mm_release(tsk, mm);
	if (!mm)
		return;
	/*
	 * Serialize with any possible pending coredump.
671
	 * We must hold mmap_sem around checking core_state
L
Linus Torvalds 已提交
672
	 * and clearing tsk->mm.  The core-inducing thread
673
	 * will increment ->nr_threads for each thread in the
L
Linus Torvalds 已提交
674 675 676
	 * group with ->mm != NULL.
	 */
	down_read(&mm->mmap_sem);
677 678 679
	core_state = mm->core_state;
	if (core_state) {
		struct core_thread self;
L
Linus Torvalds 已提交
680
		up_read(&mm->mmap_sem);
681

682 683 684 685 686 687 688 689
		self.task = tsk;
		self.next = xchg(&core_state->dumper.next, &self);
		/*
		 * Implies mb(), the result of xchg() must be visible
		 * to core_state->dumper.
		 */
		if (atomic_dec_and_test(&core_state->nr_threads))
			complete(&core_state->startup);
L
Linus Torvalds 已提交
690

O
Oleg Nesterov 已提交
691 692 693 694 695 696 697
		for (;;) {
			set_task_state(tsk, TASK_UNINTERRUPTIBLE);
			if (!self.task) /* see coredump_finish() */
				break;
			schedule();
		}
		__set_task_state(tsk, TASK_RUNNING);
L
Linus Torvalds 已提交
698 699 700
		down_read(&mm->mmap_sem);
	}
	atomic_inc(&mm->mm_count);
E
Eric Sesterhenn 已提交
701
	BUG_ON(mm != tsk->active_mm);
L
Linus Torvalds 已提交
702 703 704 705 706
	/* more a memory barrier than a real lock */
	task_lock(tsk);
	tsk->mm = NULL;
	up_read(&mm->mmap_sem);
	enter_lazy_tlb(mm, current);
707 708
	/* We don't want this task to be frozen prematurely */
	clear_freeze_flag(tsk);
L
Linus Torvalds 已提交
709
	task_unlock(tsk);
710
	mm_update_next_owner(mm);
L
Linus Torvalds 已提交
711 712 713
	mmput(mm);
}

714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
/*
 * Return nonzero if @parent's children should reap themselves.
 *
 * Called with write_lock_irq(&tasklist_lock) held.
 */
static int ignoring_children(struct task_struct *parent)
{
	int ret;
	struct sighand_struct *psig = parent->sighand;
	unsigned long flags;
	spin_lock_irqsave(&psig->siglock, flags);
	ret = (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
	       (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT));
	spin_unlock_irqrestore(&psig->siglock, flags);
	return ret;
}

R
Roland McGrath 已提交
731 732 733 734 735 736 737
/*
 * Detach all tasks we were using ptrace on.
 * Any that need to be release_task'd are put on the @dead list.
 *
 * Called with write_lock(&tasklist_lock) held.
 */
static void ptrace_exit(struct task_struct *parent, struct list_head *dead)
L
Linus Torvalds 已提交
738
{
R
Roland McGrath 已提交
739
	struct task_struct *p, *n;
740
	int ign = -1;
741

R
Roland McGrath 已提交
742 743 744 745 746 747 748 749 750 751 752 753 754 755
	list_for_each_entry_safe(p, n, &parent->ptraced, ptrace_entry) {
		__ptrace_unlink(p);

		if (p->exit_state != EXIT_ZOMBIE)
			continue;

		/*
		 * If it's a zombie, our attachedness prevented normal
		 * parent notification or self-reaping.  Do notification
		 * now if it would have happened earlier.  If it should
		 * reap itself, add it to the @dead list.  We can't call
		 * release_task() here because we already hold tasklist_lock.
		 *
		 * If it's our own child, there is no notification to do.
756 757
		 * But if our normal children self-reap, then this child
		 * was prevented by ptrace and we must reap it now.
L
Linus Torvalds 已提交
758
		 */
R
Roland McGrath 已提交
759 760 761
		if (!task_detached(p) && thread_group_empty(p)) {
			if (!same_thread_group(p->real_parent, parent))
				do_notify_parent(p, p->exit_signal);
762 763 764 765 766 767
			else {
				if (ign < 0)
					ign = ignoring_children(parent);
				if (ign)
					p->exit_signal = -1;
			}
R
Roland McGrath 已提交
768
		}
L
Linus Torvalds 已提交
769

R
Roland McGrath 已提交
770
		if (task_detached(p)) {
L
Linus Torvalds 已提交
771
			/*
R
Roland McGrath 已提交
772
			 * Mark it as in the process of being reaped.
L
Linus Torvalds 已提交
773
			 */
R
Roland McGrath 已提交
774 775
			p->exit_state = EXIT_DEAD;
			list_add(&p->ptrace_entry, dead);
L
Linus Torvalds 已提交
776 777
		}
	}
R
Roland McGrath 已提交
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
}

/*
 * Finish up exit-time ptrace cleanup.
 *
 * Called without locks.
 */
static void ptrace_exit_finish(struct task_struct *parent,
			       struct list_head *dead)
{
	struct task_struct *p, *n;

	BUG_ON(!list_empty(&parent->ptraced));

	list_for_each_entry_safe(p, n, dead, ptrace_entry) {
		list_del_init(&p->ptrace_entry);
		release_task(p);
	}
}

static void reparent_thread(struct task_struct *p, struct task_struct *father)
{
	if (p->pdeath_signal)
		/* We already hold the tasklist_lock here.  */
		group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);

	list_move_tail(&p->sibling, &p->real_parent->children);
L
Linus Torvalds 已提交
805

806 807 808
	/* If this is a threaded reparent there is no need to
	 * notify anyone anything has happened.
	 */
809
	if (same_thread_group(p->real_parent, father))
810 811 812
		return;

	/* We don't want people slaying init.  */
813
	if (!task_detached(p))
814 815 816 817 818
		p->exit_signal = SIGCHLD;

	/* If we'd notified the old parent about this child's death,
	 * also notify the new parent.
	 */
R
Roland McGrath 已提交
819 820
	if (!ptrace_reparented(p) &&
	    p->exit_state == EXIT_ZOMBIE &&
821
	    !task_detached(p) && thread_group_empty(p))
822 823
		do_notify_parent(p, p->exit_signal);

824
	kill_orphaned_pgrp(p, father);
L
Linus Torvalds 已提交
825 826 827 828 829 830
}

/*
 * 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
831 832
 * the child reaper process (ie "init") in our pid
 * space.
L
Linus Torvalds 已提交
833
 */
834
static void forget_original_parent(struct task_struct *father)
L
Linus Torvalds 已提交
835
{
836
	struct task_struct *p, *n, *reaper = father;
R
Roland McGrath 已提交
837
	LIST_HEAD(ptrace_dead);
838 839

	write_lock_irq(&tasklist_lock);
L
Linus Torvalds 已提交
840

R
Roland McGrath 已提交
841 842 843 844 845
	/*
	 * First clean up ptrace if we were using it.
	 */
	ptrace_exit(father, &ptrace_dead);

L
Linus Torvalds 已提交
846 847 848
	do {
		reaper = next_thread(reaper);
		if (reaper == father) {
849
			reaper = task_child_reaper(father);
L
Linus Torvalds 已提交
850 851
			break;
		}
852
	} while (reaper->flags & PF_EXITING);
L
Linus Torvalds 已提交
853

854
	list_for_each_entry_safe(p, n, &father->children, sibling) {
855
		p->real_parent = reaper;
R
Roland McGrath 已提交
856 857 858 859 860
		if (p->parent == father) {
			BUG_ON(p->ptrace);
			p->parent = p->real_parent;
		}
		reparent_thread(p, father);
L
Linus Torvalds 已提交
861
	}
862 863 864 865

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

R
Roland McGrath 已提交
866
	ptrace_exit_finish(father, &ptrace_dead);
L
Linus Torvalds 已提交
867 868 869 870 871 872
}

/*
 * Send signals to all our closest relatives so that they know
 * to properly mourn us..
 */
873
static void exit_notify(struct task_struct *tsk, int group_dead)
L
Linus Torvalds 已提交
874
{
R
Roland McGrath 已提交
875 876
	int signal;
	void *cookie;
L
Linus Torvalds 已提交
877 878 879 880 881 882 883 884 885

	/*
	 * 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)
	 */
886
	forget_original_parent(tsk);
887
	exit_task_namespaces(tsk);
L
Linus Torvalds 已提交
888

889
	write_lock_irq(&tasklist_lock);
890 891
	if (group_dead)
		kill_orphaned_pgrp(tsk->group_leader, NULL);
L
Linus Torvalds 已提交
892

893
	/* Let father know we died
L
Linus Torvalds 已提交
894 895
	 *
	 * Thread signals are configurable, but you aren't going to use
896
	 * that to send signals to arbitary processes.
L
Linus Torvalds 已提交
897 898 899 900 901 902 903 904 905 906
	 * 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.
	 */
907
	if (tsk->exit_signal != SIGCHLD && !task_detached(tsk) &&
908
	    (tsk->parent_exec_id != tsk->real_parent->self_exec_id ||
909 910
	     tsk->self_exec_id != tsk->parent_exec_id) &&
	    !capable(CAP_KILL))
L
Linus Torvalds 已提交
911 912
		tsk->exit_signal = SIGCHLD;

R
Roland McGrath 已提交
913 914 915
	signal = tracehook_notify_death(tsk, &cookie, group_dead);
	if (signal > 0)
		signal = do_notify_parent(tsk, signal);
L
Linus Torvalds 已提交
916

R
Roland McGrath 已提交
917
	tsk->exit_state = signal < 0 ? EXIT_DEAD : EXIT_ZOMBIE;
L
Linus Torvalds 已提交
918

919
	/* mt-exec, de_thread() is waiting for us */
920 921 922 923 924
	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 已提交
925 926
	write_unlock_irq(&tasklist_lock);

R
Roland McGrath 已提交
927 928
	tracehook_report_death(tsk, signal, cookie, group_dead);

L
Linus Torvalds 已提交
929
	/* If the process is dead, release it - nobody will wait for it */
R
Roland McGrath 已提交
930
	if (signal < 0)
L
Linus Torvalds 已提交
931 932 933
		release_task(tsk);
}

934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
#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

962 963
static inline void exit_child_reaper(struct task_struct *tsk)
{
964
	if (likely(tsk->group_leader != task_child_reaper(tsk)))
965 966
		return;

967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
	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);
993 994
}

995
NORET_TYPE void do_exit(long code)
L
Linus Torvalds 已提交
996 997 998 999 1000 1001
{
	struct task_struct *tsk = current;
	int group_dead;

	profile_task_exit(tsk);

1002 1003
	WARN_ON(atomic_read(&tsk->fs_excl));

L
Linus Torvalds 已提交
1004 1005 1006 1007 1008
	if (unlikely(in_interrupt()))
		panic("Aiee, killing interrupt handler!");
	if (unlikely(!tsk->pid))
		panic("Attempted to kill the idle task!");

R
Roland McGrath 已提交
1009
	tracehook_report_exit(&code);
L
Linus Torvalds 已提交
1010

1011 1012 1013 1014 1015 1016 1017
	/*
	 * 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");
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
		/*
		 * 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;
1028 1029
		if (tsk->io_context)
			exit_io_context();
1030 1031 1032 1033
		set_current_state(TASK_UNINTERRUPTIBLE);
		schedule();
	}

O
Oleg Nesterov 已提交
1034
	exit_signals(tsk);  /* sets PF_EXITING */
1035 1036 1037 1038
	/*
	 * tsk->flags are checked in the futex code to protect against
	 * an exiting task cleaning up the robust pi futexes.
	 */
1039 1040
	smp_mb();
	spin_unlock_wait(&tsk->pi_lock);
L
Linus Torvalds 已提交
1041 1042 1043

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

	acct_update_integrals(tsk);
1048 1049 1050 1051
	if (tsk->mm) {
		update_hiwater_rss(tsk->mm);
		update_hiwater_vm(tsk->mm);
	}
L
Linus Torvalds 已提交
1052
	group_dead = atomic_dec_and_test(&tsk->signal->live);
1053
	if (group_dead) {
1054
		exit_child_reaper(tsk);
1055
		hrtimer_cancel(&tsk->signal->real_timer);
1056
		exit_itimers(tsk->signal);
1057
	}
1058
	acct_collect(code, group_dead);
1059
#ifdef CONFIG_FUTEX
1060 1061
	if (unlikely(tsk->robust_list))
		exit_robust_list(tsk);
1062
#ifdef CONFIG_COMPAT
1063 1064
	if (unlikely(tsk->compat_robust_list))
		compat_exit_robust_list(tsk);
1065
#endif
1066
#endif
M
Miloslav Trmac 已提交
1067 1068
	if (group_dead)
		tty_audit_exit();
1069 1070
	if (unlikely(tsk->audit_context))
		audit_free(tsk);
1071

1072
	tsk->exit_code = code;
1073
	taskstats_exit(tsk, group_dead);
1074

L
Linus Torvalds 已提交
1075 1076
	exit_mm(tsk);

1077
	if (group_dead)
1078
		acct_process();
L
Linus Torvalds 已提交
1079
	exit_sem(tsk);
1080 1081
	exit_files(tsk);
	exit_fs(tsk);
1082
	check_stack_usage();
L
Linus Torvalds 已提交
1083
	exit_thread();
1084
	cgroup_exit(tsk, 1);
L
Linus Torvalds 已提交
1085 1086 1087 1088 1089
	exit_keys(tsk);

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

A
Al Viro 已提交
1090
	module_put(task_thread_info(tsk)->exec_domain->module);
L
Linus Torvalds 已提交
1091 1092 1093
	if (tsk->binfmt)
		module_put(tsk->binfmt->module);

M
Matt Helsley 已提交
1094
	proc_exit_connector(tsk);
1095
	exit_notify(tsk, group_dead);
L
Linus Torvalds 已提交
1096
#ifdef CONFIG_NUMA
1097
	mpol_put(tsk->mempolicy);
L
Linus Torvalds 已提交
1098 1099
	tsk->mempolicy = NULL;
#endif
1100
#ifdef CONFIG_FUTEX
1101 1102 1103 1104 1105 1106 1107 1108
	/*
	 * 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);
1109
#endif
1110
	/*
1111
	 * Make sure we are holding no locks:
1112
	 */
1113
	debug_check_no_locks_held(tsk);
1114 1115 1116 1117 1118 1119
	/*
	 * 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 已提交
1120

1121 1122 1123
	if (tsk->io_context)
		exit_io_context();

1124 1125 1126
	if (tsk->splice_pipe)
		__free_pipe_info(tsk->splice_pipe);

C
Coywolf Qi Hunt 已提交
1127
	preempt_disable();
O
Oleg Nesterov 已提交
1128
	/* causes final put_task_struct in finish_task_switch(). */
1129
	tsk->state = TASK_DEAD;
C
Coywolf Qi Hunt 已提交
1130

L
Linus Torvalds 已提交
1131 1132 1133
	schedule();
	BUG();
	/* Avoid "noreturn function does return".  */
A
Alan Cox 已提交
1134 1135
	for (;;)
		cpu_relax();	/* For when BUG is null */
L
Linus Torvalds 已提交
1136 1137
}

1138 1139
EXPORT_SYMBOL_GPL(do_exit);

L
Linus Torvalds 已提交
1140 1141 1142 1143
NORET_TYPE void complete_and_exit(struct completion *comp, long code)
{
	if (comp)
		complete(comp);
O
Oleg Nesterov 已提交
1144

L
Linus Torvalds 已提交
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
	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)
{
1162 1163
	struct signal_struct *sig = current->signal;

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

1166 1167
	if (signal_group_exit(sig))
		exit_code = sig->group_exit_code;
L
Linus Torvalds 已提交
1168 1169 1170
	else if (!thread_group_empty(current)) {
		struct sighand_struct *const sighand = current->sighand;
		spin_lock_irq(&sighand->siglock);
1171
		if (signal_group_exit(sig))
L
Linus Torvalds 已提交
1172 1173 1174 1175
			/* Another thread got here before we took the lock.  */
			exit_code = sig->group_exit_code;
		else {
			sig->group_exit_code = exit_code;
1176
			sig->flags = SIGNAL_GROUP_EXIT;
L
Linus Torvalds 已提交
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
			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 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
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 已提交
1208
{
1209 1210
	int err;

E
Eric W. Biederman 已提交
1211 1212
	if (type < PIDTYPE_MAX) {
		if (task_pid_type(p, type) != pid)
L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
			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;

1225
	err = security_task_wait(p);
1226 1227
	if (err)
		return err;
L
Linus Torvalds 已提交
1228

1229
	return 1;
L
Linus Torvalds 已提交
1230 1231
}

1232
static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
L
Linus Torvalds 已提交
1233 1234 1235 1236 1237
			       int why, int status,
			       struct siginfo __user *infop,
			       struct rusage __user *rusagep)
{
	int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
1238

L
Linus Torvalds 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
	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.
 */
R
Roland McGrath 已提交
1263
static int wait_task_zombie(struct task_struct *p, int options,
L
Linus Torvalds 已提交
1264 1265 1266 1267
			    struct siginfo __user *infop,
			    int __user *stat_addr, struct rusage __user *ru)
{
	unsigned long state;
1268
	int retval, status, traced;
1269
	pid_t pid = task_pid_vnr(p);
L
Linus Torvalds 已提交
1270

R
Roland McGrath 已提交
1271 1272 1273 1274
	if (!likely(options & WEXITED))
		return 0;

	if (unlikely(options & WNOWAIT)) {
L
Linus Torvalds 已提交
1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
		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;
	}

1302
	traced = ptrace_reparented(p);
1303 1304

	if (likely(!traced)) {
1305 1306 1307
		struct signal_struct *psig;
		struct signal_struct *sig;

L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
		/*
		 * 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);
1324 1325 1326 1327
		psig = p->parent->signal;
		sig = p->signal;
		psig->cutime =
			cputime_add(psig->cutime,
L
Linus Torvalds 已提交
1328
			cputime_add(p->utime,
1329 1330 1331 1332
			cputime_add(sig->utime,
				    sig->cutime)));
		psig->cstime =
			cputime_add(psig->cstime,
L
Linus Torvalds 已提交
1333
			cputime_add(p->stime,
1334 1335
			cputime_add(sig->stime,
				    sig->cstime)));
1336 1337 1338 1339 1340
		psig->cgtime =
			cputime_add(psig->cgtime,
			cputime_add(p->gtime,
			cputime_add(sig->gtime,
				    sig->cgtime)));
1341 1342 1343 1344 1345 1346 1347 1348
		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;
1349 1350 1351 1352 1353 1354
		psig->cinblock +=
			task_io_get_inblock(p) +
			sig->inblock + sig->cinblock;
		psig->coublock +=
			task_io_get_oublock(p) +
			sig->oublock + sig->coublock;
1355 1356
		task_io_accounting_add(&psig->ioac, &p->ioac);
		task_io_accounting_add(&psig->ioac, &sig->ioac);
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
		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)
1390
		retval = put_user(pid, &infop->si_pid);
L
Linus Torvalds 已提交
1391 1392
	if (!retval && infop)
		retval = put_user(p->uid, &infop->si_uid);
1393
	if (!retval)
1394
		retval = pid;
1395 1396

	if (traced) {
L
Linus Torvalds 已提交
1397
		write_lock_irq(&tasklist_lock);
1398 1399 1400 1401 1402 1403 1404
		/* 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.
		 */
1405
		if (!task_detached(p)) {
1406
			do_notify_parent(p, p->exit_signal);
1407
			if (!task_detached(p)) {
1408 1409
				p->exit_state = EXIT_ZOMBIE;
				p = NULL;
L
Linus Torvalds 已提交
1410 1411 1412 1413 1414 1415
			}
		}
		write_unlock_irq(&tasklist_lock);
	}
	if (p != NULL)
		release_task(p);
1416

L
Linus Torvalds 已提交
1417 1418 1419 1420 1421 1422 1423 1424 1425
	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.
 */
R
Roland McGrath 已提交
1426
static int wait_task_stopped(int ptrace, struct task_struct *p,
R
Roland McGrath 已提交
1427
			     int options, struct siginfo __user *infop,
L
Linus Torvalds 已提交
1428 1429
			     int __user *stat_addr, struct rusage __user *ru)
{
1430 1431
	int retval, exit_code, why;
	uid_t uid = 0; /* unneeded, required by compiler */
1432
	pid_t pid;
L
Linus Torvalds 已提交
1433

R
Roland McGrath 已提交
1434
	if (!(options & WUNTRACED))
R
Roland McGrath 已提交
1435 1436
		return 0;

1437 1438 1439 1440 1441 1442
	exit_code = 0;
	spin_lock_irq(&p->sighand->siglock);

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

R
Roland McGrath 已提交
1443
	if (!ptrace && p->signal->group_stop_count > 0)
L
Linus Torvalds 已提交
1444 1445 1446 1447
		/*
		 * A group stop is in progress and this is the group leader.
		 * We won't report until all threads have stopped.
		 */
1448 1449 1450 1451 1452 1453
		goto unlock_sig;

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

R
Roland McGrath 已提交
1454
	if (!unlikely(options & WNOWAIT))
1455 1456 1457 1458 1459 1460
		p->exit_code = 0;

	uid = p->uid;
unlock_sig:
	spin_unlock_irq(&p->sighand->siglock);
	if (!exit_code)
L
Linus Torvalds 已提交
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
		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);
1471
	pid = task_pid_vnr(p);
R
Roland McGrath 已提交
1472
	why = ptrace ? CLD_TRAPPED : CLD_STOPPED;
L
Linus Torvalds 已提交
1473 1474
	read_unlock(&tasklist_lock);

R
Roland McGrath 已提交
1475
	if (unlikely(options & WNOWAIT))
L
Linus Torvalds 已提交
1476
		return wait_noreap_copyout(p, pid, uid,
1477
					   why, exit_code,
L
Linus Torvalds 已提交
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
					   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 已提交
1488
		retval = put_user((short)why, &infop->si_code);
L
Linus Torvalds 已提交
1489 1490 1491
	if (!retval && infop)
		retval = put_user(exit_code, &infop->si_status);
	if (!retval && infop)
1492
		retval = put_user(pid, &infop->si_pid);
L
Linus Torvalds 已提交
1493
	if (!retval && infop)
1494
		retval = put_user(uid, &infop->si_uid);
L
Linus Torvalds 已提交
1495
	if (!retval)
1496
		retval = pid;
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
	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.
 */
R
Roland McGrath 已提交
1509
static int wait_task_continued(struct task_struct *p, int options,
L
Linus Torvalds 已提交
1510 1511 1512 1513 1514 1515 1516
			       struct siginfo __user *infop,
			       int __user *stat_addr, struct rusage __user *ru)
{
	int retval;
	pid_t pid;
	uid_t uid;

R
Roland McGrath 已提交
1517 1518 1519
	if (!unlikely(options & WCONTINUED))
		return 0;

L
Linus Torvalds 已提交
1520 1521 1522 1523 1524 1525 1526 1527 1528
	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;
	}
R
Roland McGrath 已提交
1529
	if (!unlikely(options & WNOWAIT))
L
Linus Torvalds 已提交
1530 1531 1532
		p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
	spin_unlock_irq(&p->sighand->siglock);

1533
	pid = task_pid_vnr(p);
L
Linus Torvalds 已提交
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	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)
1544
			retval = pid;
L
Linus Torvalds 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
	} else {
		retval = wait_noreap_copyout(p, pid, uid,
					     CLD_CONTINUED, SIGCONT,
					     infop, ru);
		BUG_ON(retval == 0);
	}

	return retval;
}

R
Roland McGrath 已提交
1555 1556 1557 1558 1559 1560
/*
 * Consider @p for a wait by @parent.
 *
 * -ECHILD should be in *@notask_error before the first call.
 * Returns nonzero for a final return, when we have unlocked tasklist_lock.
 * Returns zero if the search for a child should continue;
1561 1562
 * then *@notask_error is 0 if @p is an eligible child,
 * or another error from security_task_wait(), or still -ECHILD.
R
Roland McGrath 已提交
1563
 */
R
Roland McGrath 已提交
1564
static int wait_consider_task(struct task_struct *parent, int ptrace,
R
Roland McGrath 已提交
1565 1566 1567 1568 1569 1570
			      struct task_struct *p, int *notask_error,
			      enum pid_type type, struct pid *pid, int options,
			      struct siginfo __user *infop,
			      int __user *stat_addr, struct rusage __user *ru)
{
	int ret = eligible_child(type, pid, options, p);
1571
	if (!ret)
R
Roland McGrath 已提交
1572 1573
		return ret;

1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
	if (unlikely(ret < 0)) {
		/*
		 * If we have not yet seen any eligible child,
		 * then let this error code replace -ECHILD.
		 * A permission error will give the user a clue
		 * to look for security policy problems, rather
		 * than for mysterious wait bugs.
		 */
		if (*notask_error)
			*notask_error = ret;
	}

R
Roland McGrath 已提交
1586 1587 1588 1589 1590 1591 1592 1593 1594
	if (likely(!ptrace) && unlikely(p->ptrace)) {
		/*
		 * This child is hidden by ptrace.
		 * We aren't allowed to see it now, but eventually we will.
		 */
		*notask_error = 0;
		return 0;
	}

R
Roland McGrath 已提交
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
	if (p->exit_state == EXIT_DEAD)
		return 0;

	/*
	 * We don't reap group leaders with subthreads.
	 */
	if (p->exit_state == EXIT_ZOMBIE && !delay_group_leader(p))
		return wait_task_zombie(p, options, infop, stat_addr, ru);

	/*
	 * It's stopped or running now, so it might
	 * later continue, exit, or stop again.
	 */
	*notask_error = 0;

	if (task_is_stopped_or_traced(p))
R
Roland McGrath 已提交
1611 1612
		return wait_task_stopped(ptrace, p, options,
					 infop, stat_addr, ru);
R
Roland McGrath 已提交
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622

	return wait_task_continued(p, options, infop, stat_addr, ru);
}

/*
 * Do the work of do_wait() for one thread in the group, @tsk.
 *
 * -ECHILD should be in *@notask_error before the first call.
 * Returns nonzero for a final return, when we have unlocked tasklist_lock.
 * Returns zero if the search for a child should continue; then
1623 1624
 * *@notask_error is 0 if there were any eligible children,
 * or another error from security_task_wait(), or still -ECHILD.
R
Roland McGrath 已提交
1625 1626 1627 1628 1629 1630 1631 1632 1633
 */
static int do_wait_thread(struct task_struct *tsk, int *notask_error,
			  enum pid_type type, struct pid *pid, int options,
			  struct siginfo __user *infop, int __user *stat_addr,
			  struct rusage __user *ru)
{
	struct task_struct *p;

	list_for_each_entry(p, &tsk->children, sibling) {
R
Roland McGrath 已提交
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
		/*
		 * Do not consider detached threads.
		 */
		if (!task_detached(p)) {
			int ret = wait_consider_task(tsk, 0, p, notask_error,
						     type, pid, options,
						     infop, stat_addr, ru);
			if (ret)
				return ret;
		}
R
Roland McGrath 已提交
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
	}

	return 0;
}

static int ptrace_do_wait(struct task_struct *tsk, int *notask_error,
			  enum pid_type type, struct pid *pid, int options,
			  struct siginfo __user *infop, int __user *stat_addr,
			  struct rusage __user *ru)
{
	struct task_struct *p;

	/*
R
Roland McGrath 已提交
1657
	 * Traditionally we see ptrace'd stopped tasks regardless of options.
R
Roland McGrath 已提交
1658
	 */
R
Roland McGrath 已提交
1659
	options |= WUNTRACED;
R
Roland McGrath 已提交
1660

R
Roland McGrath 已提交
1661 1662 1663 1664 1665
	list_for_each_entry(p, &tsk->ptraced, ptrace_entry) {
		int ret = wait_consider_task(tsk, 1, p, notask_error,
					     type, pid, options,
					     infop, stat_addr, ru);
		if (ret)
R
Roland McGrath 已提交
1666 1667 1668 1669 1670 1671
			return ret;
	}

	return 0;
}

E
Eric W. Biederman 已提交
1672 1673 1674
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 已提交
1675 1676 1677
{
	DECLARE_WAITQUEUE(wait, current);
	struct task_struct *tsk;
R
Roland McGrath 已提交
1678
	int retval;
L
Linus Torvalds 已提交
1679 1680 1681

	add_wait_queue(&current->signal->wait_chldexit,&wait);
repeat:
R
Roland McGrath 已提交
1682 1683 1684 1685 1686
	/*
	 * If there is nothing that can match our critiera just get out.
	 * We will clear @retval to zero if we see any child that might later
	 * match our criteria, even if we are not able to reap it yet.
	 */
E
Eric W. Biederman 已提交
1687 1688 1689 1690
	retval = -ECHILD;
	if ((type < PIDTYPE_MAX) && (!pid || hlist_empty(&pid->tasks[type])))
		goto end;

L
Linus Torvalds 已提交
1691 1692 1693 1694
	current->state = TASK_INTERRUPTIBLE;
	read_lock(&tasklist_lock);
	tsk = current;
	do {
R
Roland McGrath 已提交
1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
		int tsk_result = do_wait_thread(tsk, &retval,
						type, pid, options,
						infop, stat_addr, ru);
		if (!tsk_result)
			tsk_result = ptrace_do_wait(tsk, &retval,
						    type, pid, options,
						    infop, stat_addr, ru);
		if (tsk_result) {
			/*
			 * tasklist_lock is unlocked and we have a final result.
			 */
			retval = tsk_result;
			goto end;
L
Linus Torvalds 已提交
1708
		}
R
Roland McGrath 已提交
1709

L
Linus Torvalds 已提交
1710 1711 1712
		if (options & __WNOTHREAD)
			break;
		tsk = next_thread(tsk);
E
Eric Sesterhenn 已提交
1713
		BUG_ON(tsk->signal != current->signal);
L
Linus Torvalds 已提交
1714 1715
	} while (tsk != current);
	read_unlock(&tasklist_lock);
O
Oleg Nesterov 已提交
1716

R
Roland McGrath 已提交
1717
	if (!retval && !(options & WNOHANG)) {
L
Linus Torvalds 已提交
1718
		retval = -ERESTARTSYS;
R
Roland McGrath 已提交
1719 1720 1721 1722
		if (!signal_pending(current)) {
			schedule();
			goto repeat;
		}
L
Linus Torvalds 已提交
1723
	}
R
Roland McGrath 已提交
1724

L
Linus Torvalds 已提交
1725 1726 1727 1728 1729
end:
	current->state = TASK_RUNNING;
	remove_wait_queue(&current->signal->wait_chldexit,&wait);
	if (infop) {
		if (retval > 0)
1730
			retval = 0;
L
Linus Torvalds 已提交
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753
		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 已提交
1754
asmlinkage long sys_waitid(int which, pid_t upid,
L
Linus Torvalds 已提交
1755 1756 1757
			   struct siginfo __user *infop, int options,
			   struct rusage __user *ru)
{
E
Eric W. Biederman 已提交
1758 1759
	struct pid *pid = NULL;
	enum pid_type type;
L
Linus Torvalds 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768
	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 已提交
1769
		type = PIDTYPE_MAX;
L
Linus Torvalds 已提交
1770 1771
		break;
	case P_PID:
E
Eric W. Biederman 已提交
1772 1773
		type = PIDTYPE_PID;
		if (upid <= 0)
L
Linus Torvalds 已提交
1774 1775 1776
			return -EINVAL;
		break;
	case P_PGID:
E
Eric W. Biederman 已提交
1777 1778
		type = PIDTYPE_PGID;
		if (upid <= 0)
L
Linus Torvalds 已提交
1779 1780 1781 1782 1783 1784
			return -EINVAL;
		break;
	default:
		return -EINVAL;
	}

E
Eric W. Biederman 已提交
1785 1786 1787 1788
	if (type < PIDTYPE_MAX)
		pid = find_get_pid(upid);
	ret = do_wait(type, pid, options, infop, NULL, ru);
	put_pid(pid);
L
Linus Torvalds 已提交
1789 1790

	/* avoid REGPARM breakage on x86: */
1791
	asmlinkage_protect(5, ret, which, upid, infop, options, ru);
L
Linus Torvalds 已提交
1792 1793 1794
	return ret;
}

E
Eric W. Biederman 已提交
1795
asmlinkage long sys_wait4(pid_t upid, int __user *stat_addr,
L
Linus Torvalds 已提交
1796 1797
			  int options, struct rusage __user *ru)
{
E
Eric W. Biederman 已提交
1798 1799
	struct pid *pid = NULL;
	enum pid_type type;
L
Linus Torvalds 已提交
1800 1801 1802 1803 1804
	long ret;

	if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
			__WNOTHREAD|__WCLONE|__WALL))
		return -EINVAL;
E
Eric W. Biederman 已提交
1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820

	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 已提交
1821 1822

	/* avoid REGPARM breakage on x86: */
1823
	asmlinkage_protect(4, ret, upid, stat_addr, options, ru);
L
Linus Torvalds 已提交
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
	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