linux - kernel/exit.c

1638 lines · 41.2 KiB

1	/*
2	* linux/kernel/exit.c
3	*
4	* Copyright (C) 1991, 1992 Linus Torvalds
5	*/
6
7	#include <linux/config.h>
8	#include <linux/mm.h>
9	#include <linux/slab.h>
10	#include <linux/interrupt.h>
11	#include <linux/smp_lock.h>
12	#include <linux/module.h>
13	#include <linux/capability.h>
14	#include <linux/completion.h>
15	#include <linux/personality.h>
16	#include <linux/tty.h>
17	#include <linux/namespace.h>
18	#include <linux/key.h>
19	#include <linux/security.h>
20	#include <linux/cpu.h>
21	#include <linux/acct.h>
22	#include <linux/file.h>
23	#include <linux/binfmts.h>
24	#include <linux/ptrace.h>
25	#include <linux/profile.h>
26	#include <linux/mount.h>
27	#include <linux/proc_fs.h>
28	#include <linux/mempolicy.h>
29	#include <linux/cpuset.h>
30	#include <linux/syscalls.h>
31	#include <linux/signal.h>
32	#include <linux/posix-timers.h>
33	#include <linux/cn_proc.h>
34	#include <linux/mutex.h>
35	#include <linux/futex.h>
36	#include <linux/compat.h>
37	#include <linux/pipe_fs_i.h>
38	#include <linux/audit.h> /* for audit_free() */
39
40	#include <asm/uaccess.h>
41	#include <asm/unistd.h>
42	#include <asm/pgtable.h>
43	#include <asm/mmu_context.h>
44
45	extern void sem_exit (void);
46	extern struct task_struct *child_reaper;
47
48	int getrusage(struct task_struct , int, struct rusage __user );
49
50	static void exit_mm(struct task_struct * tsk);
51
52	static void __unhash_process(struct task_struct *p)
53	{
54	nr_threads--;
55	detach_pid(p, PIDTYPE_PID);
56	if (thread_group_leader(p)) {
57	detach_pid(p, PIDTYPE_PGID);
58	detach_pid(p, PIDTYPE_SID);
59
60	list_del_rcu(&p->tasks);
61	__get_cpu_var(process_counts)--;
62	}
63	list_del_rcu(&p->thread_group);
64	remove_parent(p);
65	}
66
67	/*
68	* This function expects the tasklist_lock write-locked.
69	*/
70	static void __exit_signal(struct task_struct *tsk)
71	{
72	struct signal_struct *sig = tsk->signal;
73	struct sighand_struct *sighand;
74
75	BUG_ON(!sig);
76	BUG_ON(!atomic_read(&sig->count));
77
78	rcu_read_lock();
79	sighand = rcu_dereference(tsk->sighand);
80	spin_lock(&sighand->siglock);
81
82	posix_cpu_timers_exit(tsk);
83	if (atomic_dec_and_test(&sig->count))
84	posix_cpu_timers_exit_group(tsk);
85	else {
86	/*
87	* If there is any task waiting for the group exit
88	* then notify it:
89	*/
90	if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
91	wake_up_process(sig->group_exit_task);
92	sig->group_exit_task = NULL;
93	}
94	if (tsk == sig->curr_target)
95	sig->curr_target = next_thread(tsk);
96	/*
97	* Accumulate here the counters for all threads but the
98	* group leader as they die, so they can be added into
99	* the process-wide totals when those are taken.
100	* The group leader stays around as a zombie as long
101	* as there are other threads. When it gets reaped,
102	* the exit.c code will add its counts into these totals.
103	* We won't ever get here for the group leader, since it
104	* will have been the last reference on the signal_struct.
105	*/
106	sig->utime = cputime_add(sig->utime, tsk->utime);
107	sig->stime = cputime_add(sig->stime, tsk->stime);
108	sig->min_flt += tsk->min_flt;
109	sig->maj_flt += tsk->maj_flt;
110	sig->nvcsw += tsk->nvcsw;
111	sig->nivcsw += tsk->nivcsw;
112	sig->sched_time += tsk->sched_time;
113	sig = NULL; /* Marker for below. */
114	}
115
116	__unhash_process(tsk);
117
118	tsk->signal = NULL;
119	tsk->sighand = NULL;
120	spin_unlock(&sighand->siglock);
121	rcu_read_unlock();
122
123	__cleanup_sighand(sighand);
124	clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
125	flush_sigqueue(&tsk->pending);
126	if (sig) {
127	flush_sigqueue(&sig->shared_pending);
128	__cleanup_signal(sig);
129	}
130	}
131
132	static void delayed_put_task_struct(struct rcu_head *rhp)
133	{
134	put_task_struct(container_of(rhp, struct task_struct, rcu));
135	}
136
137	void release_task(struct task_struct * p)
138	{
139	int zap_leader;
140	task_t *leader;
141	struct dentry *proc_dentry;
142
143	repeat:
144	atomic_dec(&p->user->processes);
145	spin_lock(&p->proc_lock);
146	proc_dentry = proc_pid_unhash(p);
147	write_lock_irq(&tasklist_lock);
148	ptrace_unlink(p);
149	BUG_ON(!list_empty(&p->ptrace_list) \|\| !list_empty(&p->ptrace_children));
150	__exit_signal(p);
151
152	/*
153	* If we are the last non-leader member of the thread
154	* group, and the leader is zombie, then notify the
155	* group leader's parent process. (if it wants notification.)
156	*/
157	zap_leader = 0;
158	leader = p->group_leader;
159	if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
160	BUG_ON(leader->exit_signal == -1);
161	do_notify_parent(leader, leader->exit_signal);
162	/*
163	* If we were the last child thread and the leader has
164	* exited already, and the leader's parent ignores SIGCHLD,
165	* then we are the one who should release the leader.
166	*
167	* do_notify_parent() will have marked it self-reaping in
168	* that case.
169	*/
170	zap_leader = (leader->exit_signal == -1);
171	}
172
173	sched_exit(p);
174	write_unlock_irq(&tasklist_lock);
175	spin_unlock(&p->proc_lock);
176	proc_pid_flush(proc_dentry);
177	release_thread(p);
178	call_rcu(&p->rcu, delayed_put_task_struct);
179
180	p = leader;
181	if (unlikely(zap_leader))
182	goto repeat;
183	}
184
185	/*
186	* This checks not only the pgrp, but falls back on the pid if no
187	* satisfactory pgrp is found. I dunno - gdb doesn't work correctly
188	* without this...
189	*/
190	int session_of_pgrp(int pgrp)
191	{
192	struct task_struct *p;
193	int sid = -1;
194
195	read_lock(&tasklist_lock);
196	do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
197	if (p->signal->session > 0) {
198	sid = p->signal->session;
199	goto out;
200	}
201	} while_each_task_pid(pgrp, PIDTYPE_PGID, p);
202	p = find_task_by_pid(pgrp);
203	if (p)
204	sid = p->signal->session;
205	out:
206	read_unlock(&tasklist_lock);
207
208	return sid;
209	}
210
211	/*
212	* Determine if a process group is "orphaned", according to the POSIX
213	* definition in 2.2.2.52. Orphaned process groups are not to be affected
214	* by terminal-generated stop signals. Newly orphaned process groups are
215	* to receive a SIGHUP and a SIGCONT.
216	*
217	* "I ask you, have you ever known what it is to be an orphan?"
218	*/
219	static int will_become_orphaned_pgrp(int pgrp, task_t *ignored_task)
220	{
221	struct task_struct *p;
222	int ret = 1;
223
224	do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
225	if (p == ignored_task
226	\|\| p->exit_state
227	\|\| p->real_parent->pid == 1)
228	continue;
229	if (process_group(p->real_parent) != pgrp
230	&& p->real_parent->signal->session == p->signal->session) {
231	ret = 0;
232	break;
233	}
234	} while_each_task_pid(pgrp, PIDTYPE_PGID, p);
235	return ret; /* (sighing) "Often!" */
236	}
237
238	int is_orphaned_pgrp(int pgrp)
239	{
240	int retval;
241
242	read_lock(&tasklist_lock);
243	retval = will_become_orphaned_pgrp(pgrp, NULL);
244	read_unlock(&tasklist_lock);
245
246	return retval;
247	}
248
249	static int has_stopped_jobs(int pgrp)
250	{
251	int retval = 0;
252	struct task_struct *p;
253
254	do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
255	if (p->state != TASK_STOPPED)
256	continue;
257
258	/* If p is stopped by a debugger on a signal that won't
259	stop it, then don't count p as stopped. This isn't
260	perfect but it's a good approximation. */
261	if (unlikely (p->ptrace)
262	&& p->exit_code != SIGSTOP
263	&& p->exit_code != SIGTSTP
264	&& p->exit_code != SIGTTOU
265	&& p->exit_code != SIGTTIN)
266	continue;
267
268	retval = 1;
269	break;
270	} while_each_task_pid(pgrp, PIDTYPE_PGID, p);
271	return retval;
272	}
273
274	/**
275	* reparent_to_init - Reparent the calling kernel thread to the init task.
276	*
277	* If a kernel thread is launched as a result of a system call, or if
278	* it ever exits, it should generally reparent itself to init so that
279	* it is correctly cleaned up on exit.
280	*
281	* The various task state such as scheduling policy and priority may have
282	* been inherited from a user process, so we reset them to sane values here.
283	*
284	* NOTE that reparent_to_init() gives the caller full capabilities.
285	*/
286	static void reparent_to_init(void)
287	{
288	write_lock_irq(&tasklist_lock);
289
290	ptrace_unlink(current);
291	/* Reparent to init */
292	remove_parent(current);
293	current->parent = child_reaper;
294	current->real_parent = child_reaper;
295	add_parent(current);
296
297	/* Set the exit signal to SIGCHLD so we signal init on exit */
298	current->exit_signal = SIGCHLD;
299
300	if ((current->policy == SCHED_NORMAL \|\|
301	current->policy == SCHED_BATCH)
302	&& (task_nice(current) < 0))
303	set_user_nice(current, 0);
304	/* cpus_allowed? */
305	/* rt_priority? */
306	/* signals? */
307	security_task_reparent_to_init(current);
308	memcpy(current->signal->rlim, init_task.signal->rlim,
309	sizeof(current->signal->rlim));
310	atomic_inc(&(INIT_USER->__count));
311	write_unlock_irq(&tasklist_lock);
312	switch_uid(INIT_USER);
313	}
314
315	void __set_special_pids(pid_t session, pid_t pgrp)
316	{
317	struct task_struct *curr = current->group_leader;
318
319	if (curr->signal->session != session) {
320	detach_pid(curr, PIDTYPE_SID);
321	curr->signal->session = session;
322	attach_pid(curr, PIDTYPE_SID, session);
323	}
324	if (process_group(curr) != pgrp) {
325	detach_pid(curr, PIDTYPE_PGID);
326	curr->signal->pgrp = pgrp;
327	attach_pid(curr, PIDTYPE_PGID, pgrp);
328	}
329	}
330
331	void set_special_pids(pid_t session, pid_t pgrp)
332	{
333	write_lock_irq(&tasklist_lock);
334	__set_special_pids(session, pgrp);
335	write_unlock_irq(&tasklist_lock);
336	}
337
338	/*
339	* Let kernel threads use this to say that they
340	* allow a certain signal (since daemonize() will
341	* have disabled all of them by default).
342	*/
343	int allow_signal(int sig)
344	{
345	if (!valid_signal(sig) \|\| sig < 1)
346	return -EINVAL;
347
348	spin_lock_irq(&current->sighand->siglock);
349	sigdelset(&current->blocked, sig);
350	if (!current->mm) {
351	/* Kernel threads handle their own signals.
352	Let the signal code know it'll be handled, so
353	that they don't get converted to SIGKILL or
354	just silently dropped */
355	current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
356	}
357	recalc_sigpending();
358	spin_unlock_irq(&current->sighand->siglock);
359	return 0;
360	}
361
362	EXPORT_SYMBOL(allow_signal);
363
364	int disallow_signal(int sig)
365	{
366	if (!valid_signal(sig) \|\| sig < 1)
367	return -EINVAL;
368
369	spin_lock_irq(&current->sighand->siglock);
370	sigaddset(&current->blocked, sig);
371	recalc_sigpending();
372	spin_unlock_irq(&current->sighand->siglock);
373	return 0;
374	}
375
376	EXPORT_SYMBOL(disallow_signal);
377
378	/*
379	* Put all the gunge required to become a kernel thread without
380	* attached user resources in one place where it belongs.
381	*/
382
383	void daemonize(const char *name, ...)
384	{
385	va_list args;
386	struct fs_struct *fs;
387	sigset_t blocked;
388
389	va_start(args, name);
390	vsnprintf(current->comm, sizeof(current->comm), name, args);
391	va_end(args);
392
393	/*
394	* If we were started as result of loading a module, close all of the
395	* user space pages. We don't need them, and if we didn't close them
396	* they would be locked into memory.
397	*/
398	exit_mm(current);
399
400	set_special_pids(1, 1);
401	mutex_lock(&tty_mutex);
402	current->signal->tty = NULL;
403	mutex_unlock(&tty_mutex);
404
405	/* Block and flush all signals */
406	sigfillset(&blocked);
407	sigprocmask(SIG_BLOCK, &blocked, NULL);
408	flush_signals(current);
409
410	/* Become as one with the init task */
411
412	exit_fs(current); /* current->fs->count--; */
413	fs = init_task.fs;
414	current->fs = fs;
415	atomic_inc(&fs->count);
416	exit_namespace(current);
417	current->namespace = init_task.namespace;
418	get_namespace(current->namespace);
419	exit_files(current);
420	current->files = init_task.files;
421	atomic_inc(&current->files->count);
422
423	reparent_to_init();
424	}
425
426	EXPORT_SYMBOL(daemonize);
427
428	static void close_files(struct files_struct * files)
429	{
430	int i, j;
431	struct fdtable *fdt;
432
433	j = 0;
434
435	/*
436	* It is safe to dereference the fd table without RCU or
437	* ->file_lock because this is the last reference to the
438	* files structure.
439	*/
440	fdt = files_fdtable(files);
441	for (;;) {
442	unsigned long set;
443	i = j * __NFDBITS;
444	if (i >= fdt->max_fdset \|\| i >= fdt->max_fds)
445	break;
446	set = fdt->open_fds->fds_bits[j++];
447	while (set) {
448	if (set & 1) {
449	struct file * file = xchg(&fdt->fd[i], NULL);
450	if (file)
451	filp_close(file, files);
452	}
453	i++;
454	set >>= 1;
455	}
456	}
457	}
458
459	struct files_struct get_files_struct(struct task_struct task)
460	{
461	struct files_struct *files;
462
463	task_lock(task);
464	files = task->files;
465	if (files)
466	atomic_inc(&files->count);
467	task_unlock(task);
468
469	return files;
470	}
471
472	void fastcall put_files_struct(struct files_struct *files)
473	{
474	struct fdtable *fdt;
475
476	if (atomic_dec_and_test(&files->count)) {
477	close_files(files);
478	/*
479	* Free the fd and fdset arrays if we expanded them.
480	* If the fdtable was embedded, pass files for freeing
481	* at the end of the RCU grace period. Otherwise,
482	* you can free files immediately.
483	*/
484	fdt = files_fdtable(files);
485	if (fdt == &files->fdtab)
486	fdt->free_files = files;
487	else
488	kmem_cache_free(files_cachep, files);
489	free_fdtable(fdt);
490	}
491	}
492
493	EXPORT_SYMBOL(put_files_struct);
494
495	static inline void __exit_files(struct task_struct *tsk)
496	{
497	struct files_struct * files = tsk->files;
498
499	if (files) {
500	task_lock(tsk);
501	tsk->files = NULL;
502	task_unlock(tsk);
503	put_files_struct(files);
504	}
505	}
506
507	void exit_files(struct task_struct *tsk)
508	{
509	__exit_files(tsk);
510	}
511
512	static inline void __put_fs_struct(struct fs_struct *fs)
513	{
514	/* No need to hold fs->lock if we are killing it */
515	if (atomic_dec_and_test(&fs->count)) {
516	dput(fs->root);
517	mntput(fs->rootmnt);
518	dput(fs->pwd);
519	mntput(fs->pwdmnt);
520	if (fs->altroot) {
521	dput(fs->altroot);
522	mntput(fs->altrootmnt);
523	}
524	kmem_cache_free(fs_cachep, fs);
525	}
526	}
527
528	void put_fs_struct(struct fs_struct *fs)
529	{
530	__put_fs_struct(fs);
531	}
532
533	static inline void __exit_fs(struct task_struct *tsk)
534	{
535	struct fs_struct * fs = tsk->fs;
536
537	if (fs) {
538	task_lock(tsk);
539	tsk->fs = NULL;
540	task_unlock(tsk);
541	__put_fs_struct(fs);
542	}
543	}
544
545	void exit_fs(struct task_struct *tsk)
546	{
547	__exit_fs(tsk);
548	}
549
550	EXPORT_SYMBOL_GPL(exit_fs);
551
552	/*
553	* Turn us into a lazy TLB process if we
554	* aren't already..
555	*/
556	static void exit_mm(struct task_struct * tsk)
557	{
558	struct mm_struct *mm = tsk->mm;
559
560	mm_release(tsk, mm);
561	if (!mm)
562	return;
563	/*
564	* Serialize with any possible pending coredump.
565	* We must hold mmap_sem around checking core_waiters
566	* and clearing tsk->mm. The core-inducing thread
567	* will increment core_waiters for each thread in the
568	* group with ->mm != NULL.
569	*/
570	down_read(&mm->mmap_sem);
571	if (mm->core_waiters) {
572	up_read(&mm->mmap_sem);
573	down_write(&mm->mmap_sem);
574	if (!--mm->core_waiters)
575	complete(mm->core_startup_done);
576	up_write(&mm->mmap_sem);
577
578	wait_for_completion(&mm->core_done);
579	down_read(&mm->mmap_sem);
580	}
581	atomic_inc(&mm->mm_count);
582	BUG_ON(mm != tsk->active_mm);
583	/* more a memory barrier than a real lock */
584	task_lock(tsk);
585	tsk->mm = NULL;
586	up_read(&mm->mmap_sem);
587	enter_lazy_tlb(mm, current);
588	task_unlock(tsk);
589	mmput(mm);
590	}
591
592	static inline void choose_new_parent(task_t p, task_t reaper)
593	{
594	/*
595	* Make sure we're not reparenting to ourselves and that
596	* the parent is not a zombie.
597	*/
598	BUG_ON(p == reaper \|\| reaper->exit_state);
599	p->real_parent = reaper;
600	}
601
602	static void reparent_thread(task_t p, task_t father, int traced)
603	{
604	/* We don't want people slaying init. */
605	if (p->exit_signal != -1)
606	p->exit_signal = SIGCHLD;
607
608	if (p->pdeath_signal)
609	/* We already hold the tasklist_lock here. */
610	group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);
611
612	/* Move the child from its dying parent to the new one. */
613	if (unlikely(traced)) {
614	/* Preserve ptrace links if someone else is tracing this child. */
615	list_del_init(&p->ptrace_list);
616	if (p->parent != p->real_parent)
617	list_add(&p->ptrace_list, &p->real_parent->ptrace_children);
618	} else {
619	/* If this child is being traced, then we're the one tracing it
620	* anyway, so let go of it.
621	*/
622	p->ptrace = 0;
623	remove_parent(p);
624	p->parent = p->real_parent;
625	add_parent(p);
626
627	/* If we'd notified the old parent about this child's death,
628	* also notify the new parent.
629	*/
630	if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 &&
631	thread_group_empty(p))
632	do_notify_parent(p, p->exit_signal);
633	else if (p->state == TASK_TRACED) {
634	/*
635	* If it was at a trace stop, turn it into
636	* a normal stop since it's no longer being
637	* traced.
638	*/
639	ptrace_untrace(p);
640	}
641	}
642
643	/*
644	* process group orphan check
645	* Case ii: Our child is in a different pgrp
646	* than we are, and it was the only connection
647	* outside, so the child pgrp is now orphaned.
648	*/
649	if ((process_group(p) != process_group(father)) &&
650	(p->signal->session == father->signal->session)) {
651	int pgrp = process_group(p);
652
653	if (will_become_orphaned_pgrp(pgrp, NULL) && has_stopped_jobs(pgrp)) {
654	__kill_pg_info(SIGHUP, SEND_SIG_PRIV, pgrp);
655	__kill_pg_info(SIGCONT, SEND_SIG_PRIV, pgrp);
656	}
657	}
658	}
659
660	/*
661	* When we die, we re-parent all our children.
662	* Try to give them to another thread in our thread
663	* group, and if no such member exists, give it to
664	* the global child reaper process (ie "init")
665	*/
666	static void forget_original_parent(struct task_struct * father,
667	struct list_head *to_release)
668	{
669	struct task_struct p, reaper = father;
670	struct list_head _p, _n;
671
672	do {
673	reaper = next_thread(reaper);
674	if (reaper == father) {
675	reaper = child_reaper;
676	break;
677	}
678	} while (reaper->exit_state);
679
680	/*
681	* There are only two places where our children can be:
682	*
683	* - in our child list
684	* - in our ptraced child list
685	*
686	* Search them and reparent children.
687	*/
688	list_for_each_safe(_p, _n, &father->children) {
689	int ptrace;
690	p = list_entry(_p,struct task_struct,sibling);
691
692	ptrace = p->ptrace;
693
694	/* if father isn't the real parent, then ptrace must be enabled */
695	BUG_ON(father != p->real_parent && !ptrace);
696
697	if (father == p->real_parent) {
698	/* reparent with a reaper, real father it's us */
699	choose_new_parent(p, reaper);
700	reparent_thread(p, father, 0);
701	} else {
702	/* reparent ptraced task to its real parent */
703	__ptrace_unlink (p);
704	if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 &&
705	thread_group_empty(p))
706	do_notify_parent(p, p->exit_signal);
707	}
708
709	/*
710	* if the ptraced child is a zombie with exit_signal == -1
711	* we must collect it before we exit, or it will remain
712	* zombie forever since we prevented it from self-reap itself
713	* while it was being traced by us, to be able to see it in wait4.
714	*/
715	if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && p->exit_signal == -1))
716	list_add(&p->ptrace_list, to_release);
717	}
718	list_for_each_safe(_p, _n, &father->ptrace_children) {
719	p = list_entry(_p,struct task_struct,ptrace_list);
720	choose_new_parent(p, reaper);
721	reparent_thread(p, father, 1);
722	}
723	}
724
725	/*
726	* Send signals to all our closest relatives so that they know
727	* to properly mourn us..
728	*/
729	static void exit_notify(struct task_struct *tsk)
730	{
731	int state;
732	struct task_struct *t;
733	struct list_head ptrace_dead, _p, _n;
734
735	if (signal_pending(tsk) && !(tsk->signal->flags & SIGNAL_GROUP_EXIT)
736	&& !thread_group_empty(tsk)) {
737	/*
738	* This occurs when there was a race between our exit
739	* syscall and a group signal choosing us as the one to
740	* wake up. It could be that we are the only thread
741	* alerted to check for pending signals, but another thread
742	* should be woken now to take the signal since we will not.
743	* Now we'll wake all the threads in the group just to make
744	* sure someone gets all the pending signals.
745	*/
746	read_lock(&tasklist_lock);
747	spin_lock_irq(&tsk->sighand->siglock);
748	for (t = next_thread(tsk); t != tsk; t = next_thread(t))
749	if (!signal_pending(t) && !(t->flags & PF_EXITING)) {
750	recalc_sigpending_tsk(t);
751	if (signal_pending(t))
752	signal_wake_up(t, 0);
753	}
754	spin_unlock_irq(&tsk->sighand->siglock);
755	read_unlock(&tasklist_lock);
756	}
757
758	write_lock_irq(&tasklist_lock);
759
760	/*
761	* This does two things:
762	*
763	* A. Make init inherit all the child processes
764	* B. Check to see if any process groups have become orphaned
765	* as a result of our exiting, and if they have any stopped
766	* jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
767	*/
768
769	INIT_LIST_HEAD(&ptrace_dead);
770	forget_original_parent(tsk, &ptrace_dead);
771	BUG_ON(!list_empty(&tsk->children));
772	BUG_ON(!list_empty(&tsk->ptrace_children));
773
774	/*
775	* Check to see if any process groups have become orphaned
776	* as a result of our exiting, and if they have any stopped
777	* jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
778	*
779	* Case i: Our father is in a different pgrp than we are
780	* and we were the only connection outside, so our pgrp
781	* is about to become orphaned.
782	*/
783
784	t = tsk->real_parent;
785
786	if ((process_group(t) != process_group(tsk)) &&
787	(t->signal->session == tsk->signal->session) &&
788	will_become_orphaned_pgrp(process_group(tsk), tsk) &&
789	has_stopped_jobs(process_group(tsk))) {
790	__kill_pg_info(SIGHUP, SEND_SIG_PRIV, process_group(tsk));
791	__kill_pg_info(SIGCONT, SEND_SIG_PRIV, process_group(tsk));
792	}
793
794	/* Let father know we died
795	*
796	* Thread signals are configurable, but you aren't going to use
797	* that to send signals to arbitary processes.
798	* That stops right now.
799	*
800	* If the parent exec id doesn't match the exec id we saved
801	* when we started then we know the parent has changed security
802	* domain.
803	*
804	* If our self_exec id doesn't match our parent_exec_id then
805	* we have changed execution domain as these two values started
806	* the same after a fork.
807	*
808	*/
809
810	if (tsk->exit_signal != SIGCHLD && tsk->exit_signal != -1 &&
811	( tsk->parent_exec_id != t->self_exec_id \|\|
812	tsk->self_exec_id != tsk->parent_exec_id)
813	&& !capable(CAP_KILL))
814	tsk->exit_signal = SIGCHLD;
815
816
817	/* If something other than our normal parent is ptracing us, then
818	* send it a SIGCHLD instead of honoring exit_signal. exit_signal
819	* only has special meaning to our real parent.
820	*/
821	if (tsk->exit_signal != -1 && thread_group_empty(tsk)) {
822	int signal = tsk->parent == tsk->real_parent ? tsk->exit_signal : SIGCHLD;
823	do_notify_parent(tsk, signal);
824	} else if (tsk->ptrace) {
825	do_notify_parent(tsk, SIGCHLD);
826	}
827
828	state = EXIT_ZOMBIE;
829	if (tsk->exit_signal == -1 &&
830	(likely(tsk->ptrace == 0) \|\|
831	unlikely(tsk->parent->signal->flags & SIGNAL_GROUP_EXIT)))
832	state = EXIT_DEAD;
833	tsk->exit_state = state;
834
835	write_unlock_irq(&tasklist_lock);
836
837	list_for_each_safe(_p, _n, &ptrace_dead) {
838	list_del_init(_p);
839	t = list_entry(_p,struct task_struct,ptrace_list);
840	release_task(t);
841	}
842
843	/* If the process is dead, release it - nobody will wait for it */
844	if (state == EXIT_DEAD)
845	release_task(tsk);
846	}
847
848	fastcall NORET_TYPE void do_exit(long code)
849	{
850	struct task_struct *tsk = current;
851	int group_dead;
852
853	profile_task_exit(tsk);
854
855	WARN_ON(atomic_read(&tsk->fs_excl));
856
857	if (unlikely(in_interrupt()))
858	panic("Aiee, killing interrupt handler!");
859	if (unlikely(!tsk->pid))
860	panic("Attempted to kill the idle task!");
861	if (unlikely(tsk == child_reaper))
862	panic("Attempted to kill init!");
863
864	if (unlikely(current->ptrace & PT_TRACE_EXIT)) {
865	current->ptrace_message = code;
866	ptrace_notify((PTRACE_EVENT_EXIT << 8) \| SIGTRAP);
867	}
868
869	/*
870	* We're taking recursive faults here in do_exit. Safest is to just
871	* leave this task alone and wait for reboot.
872	*/
873	if (unlikely(tsk->flags & PF_EXITING)) {
874	printk(KERN_ALERT
875	"Fixing recursive fault but reboot is needed!\n");
876	if (tsk->io_context)
877	exit_io_context();
878	set_current_state(TASK_UNINTERRUPTIBLE);
879	schedule();
880	}
881
882	tsk->flags \|= PF_EXITING;
883
884	if (unlikely(in_atomic()))
885	printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
886	current->comm, current->pid,
887	preempt_count());
888
889	acct_update_integrals(tsk);
890	if (tsk->mm) {
891	update_hiwater_rss(tsk->mm);
892	update_hiwater_vm(tsk->mm);
893	}
894	group_dead = atomic_dec_and_test(&tsk->signal->live);
895	if (group_dead) {
896	hrtimer_cancel(&tsk->signal->real_timer);
897	exit_itimers(tsk->signal);
898	acct_process(code);
899	}
900	if (unlikely(tsk->robust_list))
901	exit_robust_list(tsk);
902	#ifdef CONFIG_COMPAT
903	if (unlikely(tsk->compat_robust_list))
904	compat_exit_robust_list(tsk);
905	#endif
906	if (unlikely(tsk->audit_context))
907	audit_free(tsk);
908	exit_mm(tsk);
909
910	exit_sem(tsk);
911	__exit_files(tsk);
912	__exit_fs(tsk);
913	exit_namespace(tsk);
914	exit_thread();
915	cpuset_exit(tsk);
916	exit_keys(tsk);
917
918	if (group_dead && tsk->signal->leader)
919	disassociate_ctty(1);
920
921	module_put(task_thread_info(tsk)->exec_domain->module);
922	if (tsk->binfmt)
923	module_put(tsk->binfmt->module);
924
925	tsk->exit_code = code;
926	proc_exit_connector(tsk);
927	exit_notify(tsk);
928	#ifdef CONFIG_NUMA
929	mpol_free(tsk->mempolicy);
930	tsk->mempolicy = NULL;
931	#endif
932	/*
933	* If DEBUG_MUTEXES is on, make sure we are holding no locks:
934	*/
935	mutex_debug_check_no_locks_held(tsk);
936
937	if (tsk->io_context)
938	exit_io_context();
939
940	if (tsk->splice_pipe)
941	__free_pipe_info(tsk->splice_pipe);
942
943	/* PF_DEAD causes final put_task_struct after we schedule. */
944	preempt_disable();
945	BUG_ON(tsk->flags & PF_DEAD);
946	tsk->flags \|= PF_DEAD;
947
948	schedule();
949	BUG();
950	/* Avoid "noreturn function does return". */
951	for (;;) ;
952	}
953
954	EXPORT_SYMBOL_GPL(do_exit);
955
956	NORET_TYPE void complete_and_exit(struct completion *comp, long code)
957	{
958	if (comp)
959	complete(comp);
960
961	do_exit(code);
962	}
963
964	EXPORT_SYMBOL(complete_and_exit);
965
966	asmlinkage long sys_exit(int error_code)
967	{
968	do_exit((error_code&0xff)<<8);
969	}
970
971	/*
972	* Take down every thread in the group. This is called by fatal signals
973	* as well as by sys_exit_group (below).
974	*/
975	NORET_TYPE void
976	do_group_exit(int exit_code)
977	{
978	BUG_ON(exit_code & 0x80); /* core dumps don't get here */
979
980	if (current->signal->flags & SIGNAL_GROUP_EXIT)
981	exit_code = current->signal->group_exit_code;
982	else if (!thread_group_empty(current)) {
983	struct signal_struct *const sig = current->signal;
984	struct sighand_struct *const sighand = current->sighand;
985	spin_lock_irq(&sighand->siglock);
986	if (sig->flags & SIGNAL_GROUP_EXIT)
987	/* Another thread got here before we took the lock. */
988	exit_code = sig->group_exit_code;
989	else {
990	sig->group_exit_code = exit_code;
991	zap_other_threads(current);
992	}
993	spin_unlock_irq(&sighand->siglock);
994	}
995
996	do_exit(exit_code);
997	/* NOTREACHED */
998	}
999
1000	/*
1001	* this kills every thread in the thread group. Note that any externally
1002	* wait4()-ing process will get the correct exit code - even if this
1003	* thread is not the thread group leader.
1004	*/
1005	asmlinkage void sys_exit_group(int error_code)
1006	{
1007	do_group_exit((error_code & 0xff) << 8);
1008	}
1009
1010	static int eligible_child(pid_t pid, int options, task_t *p)
1011	{
1012	if (pid > 0) {
1013	if (p->pid != pid)
1014	return 0;
1015	} else if (!pid) {
1016	if (process_group(p) != process_group(current))
1017	return 0;
1018	} else if (pid != -1) {
1019	if (process_group(p) != -pid)
1020	return 0;
1021	}
1022
1023	/*
1024	* Do not consider detached threads that are
1025	* not ptraced:
1026	*/
1027	if (p->exit_signal == -1 && !p->ptrace)
1028	return 0;
1029
1030	/* Wait for all children (clone and not) if __WALL is set;
1031	* otherwise, wait for clone children only if __WCLONE is
1032	* set; otherwise, wait for non-clone children only. (Note:
1033	* A "clone" child here is one that reports to its parent
1034	* using a signal other than SIGCHLD.) */
1035	if (((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
1036	&& !(options & __WALL))
1037	return 0;
1038	/*
1039	* Do not consider thread group leaders that are
1040	* in a non-empty thread group:
1041	*/
1042	if (current->tgid != p->tgid && delay_group_leader(p))
1043	return 2;
1044
1045	if (security_task_wait(p))
1046	return 0;
1047
1048	return 1;
1049	}
1050
1051	static int wait_noreap_copyout(task_t *p, pid_t pid, uid_t uid,
1052	int why, int status,
1053	struct siginfo __user *infop,
1054	struct rusage __user *rusagep)
1055	{
1056	int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
1057	put_task_struct(p);
1058	if (!retval)
1059	retval = put_user(SIGCHLD, &infop->si_signo);
1060	if (!retval)
1061	retval = put_user(0, &infop->si_errno);
1062	if (!retval)
1063	retval = put_user((short)why, &infop->si_code);
1064	if (!retval)
1065	retval = put_user(pid, &infop->si_pid);
1066	if (!retval)
1067	retval = put_user(uid, &infop->si_uid);
1068	if (!retval)
1069	retval = put_user(status, &infop->si_status);
1070	if (!retval)
1071	retval = pid;
1072	return retval;
1073	}
1074
1075	/*
1076	* Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold
1077	* read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1078	* the lock and this task is uninteresting. If we return nonzero, we have
1079	* released the lock and the system call should return.
1080	*/
1081	static int wait_task_zombie(task_t *p, int noreap,
1082	struct siginfo __user *infop,
1083	int __user stat_addr, struct rusage __user ru)
1084	{
1085	unsigned long state;
1086	int retval;
1087	int status;
1088
1089	if (unlikely(noreap)) {
1090	pid_t pid = p->pid;
1091	uid_t uid = p->uid;
1092	int exit_code = p->exit_code;
1093	int why, status;
1094
1095	if (unlikely(p->exit_state != EXIT_ZOMBIE))
1096	return 0;
1097	if (unlikely(p->exit_signal == -1 && p->ptrace == 0))
1098	return 0;
1099	get_task_struct(p);
1100	read_unlock(&tasklist_lock);
1101	if ((exit_code & 0x7f) == 0) {
1102	why = CLD_EXITED;
1103	status = exit_code >> 8;
1104	} else {
1105	why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
1106	status = exit_code & 0x7f;
1107	}
1108	return wait_noreap_copyout(p, pid, uid, why,
1109	status, infop, ru);
1110	}
1111
1112	/*
1113	* Try to move the task's state to DEAD
1114	* only one thread is allowed to do this:
1115	*/
1116	state = xchg(&p->exit_state, EXIT_DEAD);
1117	if (state != EXIT_ZOMBIE) {
1118	BUG_ON(state != EXIT_DEAD);
1119	return 0;
1120	}
1121	if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) {
1122	/*
1123	* This can only happen in a race with a ptraced thread
1124	* dying on another processor.
1125	*/
1126	return 0;
1127	}
1128
1129	if (likely(p->real_parent == p->parent) && likely(p->signal)) {
1130	struct signal_struct *psig;
1131	struct signal_struct *sig;
1132
1133	/*
1134	* The resource counters for the group leader are in its
1135	* own task_struct. Those for dead threads in the group
1136	* are in its signal_struct, as are those for the child
1137	* processes it has previously reaped. All these
1138	* accumulate in the parent's signal_struct c* fields.
1139	*
1140	* We don't bother to take a lock here to protect these
1141	* p->signal fields, because they are only touched by
1142	* __exit_signal, which runs with tasklist_lock
1143	* write-locked anyway, and so is excluded here. We do
1144	* need to protect the access to p->parent->signal fields,
1145	* as other threads in the parent group can be right
1146	* here reaping other children at the same time.
1147	*/
1148	spin_lock_irq(&p->parent->sighand->siglock);
1149	psig = p->parent->signal;
1150	sig = p->signal;
1151	psig->cutime =
1152	cputime_add(psig->cutime,
1153	cputime_add(p->utime,
1154	cputime_add(sig->utime,
1155	sig->cutime)));
1156	psig->cstime =
1157	cputime_add(psig->cstime,
1158	cputime_add(p->stime,
1159	cputime_add(sig->stime,
1160	sig->cstime)));
1161	psig->cmin_flt +=
1162	p->min_flt + sig->min_flt + sig->cmin_flt;
1163	psig->cmaj_flt +=
1164	p->maj_flt + sig->maj_flt + sig->cmaj_flt;
1165	psig->cnvcsw +=
1166	p->nvcsw + sig->nvcsw + sig->cnvcsw;
1167	psig->cnivcsw +=
1168	p->nivcsw + sig->nivcsw + sig->cnivcsw;
1169	spin_unlock_irq(&p->parent->sighand->siglock);
1170	}
1171
1172	/*
1173	* Now we are sure this task is interesting, and no other
1174	* thread can reap it because we set its state to EXIT_DEAD.
1175	*/
1176	read_unlock(&tasklist_lock);
1177
1178	retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
1179	status = (p->signal->flags & SIGNAL_GROUP_EXIT)
1180	? p->signal->group_exit_code : p->exit_code;
1181	if (!retval && stat_addr)
1182	retval = put_user(status, stat_addr);
1183	if (!retval && infop)
1184	retval = put_user(SIGCHLD, &infop->si_signo);
1185	if (!retval && infop)
1186	retval = put_user(0, &infop->si_errno);
1187	if (!retval && infop) {
1188	int why;
1189
1190	if ((status & 0x7f) == 0) {
1191	why = CLD_EXITED;
1192	status >>= 8;
1193	} else {
1194	why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
1195	status &= 0x7f;
1196	}
1197	retval = put_user((short)why, &infop->si_code);
1198	if (!retval)
1199	retval = put_user(status, &infop->si_status);
1200	}
1201	if (!retval && infop)
1202	retval = put_user(p->pid, &infop->si_pid);
1203	if (!retval && infop)
1204	retval = put_user(p->uid, &infop->si_uid);
1205	if (retval) {
1206	// TODO: is this safe?
1207	p->exit_state = EXIT_ZOMBIE;
1208	return retval;
1209	}
1210	retval = p->pid;
1211	if (p->real_parent != p->parent) {
1212	write_lock_irq(&tasklist_lock);
1213	/* Double-check with lock held. */
1214	if (p->real_parent != p->parent) {
1215	__ptrace_unlink(p);
1216	// TODO: is this safe?
1217	p->exit_state = EXIT_ZOMBIE;
1218	/*
1219	* If this is not a detached task, notify the parent.
1220	* If it's still not detached after that, don't release
1221	* it now.
1222	*/
1223	if (p->exit_signal != -1) {
1224	do_notify_parent(p, p->exit_signal);
1225	if (p->exit_signal != -1)
1226	p = NULL;
1227	}
1228	}
1229	write_unlock_irq(&tasklist_lock);
1230	}
1231	if (p != NULL)
1232	release_task(p);
1233	BUG_ON(!retval);
1234	return retval;
1235	}
1236
1237	/*
1238	* Handle sys_wait4 work for one task in state TASK_STOPPED. We hold
1239	* read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1240	* the lock and this task is uninteresting. If we return nonzero, we have
1241	* released the lock and the system call should return.
1242	*/
1243	static int wait_task_stopped(task_t *p, int delayed_group_leader, int noreap,
1244	struct siginfo __user *infop,
1245	int __user stat_addr, struct rusage __user ru)
1246	{
1247	int retval, exit_code;
1248
1249	if (!p->exit_code)
1250	return 0;
1251	if (delayed_group_leader && !(p->ptrace & PT_PTRACED) &&
1252	p->signal && p->signal->group_stop_count > 0)
1253	/*
1254	* A group stop is in progress and this is the group leader.
1255	* We won't report until all threads have stopped.
1256	*/
1257	return 0;
1258
1259	/*
1260	* Now we are pretty sure this task is interesting.
1261	* Make sure it doesn't get reaped out from under us while we
1262	* give up the lock and then examine it below. We don't want to
1263	* keep holding onto the tasklist_lock while we call getrusage and
1264	* possibly take page faults for user memory.
1265	*/
1266	get_task_struct(p);
1267	read_unlock(&tasklist_lock);
1268
1269	if (unlikely(noreap)) {
1270	pid_t pid = p->pid;
1271	uid_t uid = p->uid;
1272	int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;
1273
1274	exit_code = p->exit_code;
1275	if (unlikely(!exit_code) \|\|
1276	unlikely(p->state & TASK_TRACED))
1277	goto bail_ref;
1278	return wait_noreap_copyout(p, pid, uid,
1279	why, (exit_code << 8) \| 0x7f,
1280	infop, ru);
1281	}
1282
1283	write_lock_irq(&tasklist_lock);
1284
1285	/*
1286	* This uses xchg to be atomic with the thread resuming and setting
1287	* it. It must also be done with the write lock held to prevent a
1288	* race with the EXIT_ZOMBIE case.
1289	*/
1290	exit_code = xchg(&p->exit_code, 0);
1291	if (unlikely(p->exit_state)) {
1292	/*
1293	* The task resumed and then died. Let the next iteration
1294	* catch it in EXIT_ZOMBIE. Note that exit_code might
1295	* already be zero here if it resumed and did _exit(0).
1296	* The task itself is dead and won't touch exit_code again;
1297	* other processors in this function are locked out.
1298	*/
1299	p->exit_code = exit_code;
1300	exit_code = 0;
1301	}
1302	if (unlikely(exit_code == 0)) {
1303	/*
1304	* Another thread in this function got to it first, or it
1305	* resumed, or it resumed and then died.
1306	*/
1307	write_unlock_irq(&tasklist_lock);
1308	bail_ref:
1309	put_task_struct(p);
1310	/*
1311	* We are returning to the wait loop without having successfully
1312	* removed the process and having released the lock. We cannot
1313	* continue, since the "p" task pointer is potentially stale.
1314	*
1315	* Return -EAGAIN, and do_wait() will restart the loop from the
1316	* beginning. Do _not_ re-acquire the lock.
1317	*/
1318	return -EAGAIN;
1319	}
1320
1321	/* move to end of parent's list to avoid starvation */
1322	remove_parent(p);
1323	add_parent(p);
1324
1325	write_unlock_irq(&tasklist_lock);
1326
1327	retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
1328	if (!retval && stat_addr)
1329	retval = put_user((exit_code << 8) \| 0x7f, stat_addr);
1330	if (!retval && infop)
1331	retval = put_user(SIGCHLD, &infop->si_signo);
1332	if (!retval && infop)
1333	retval = put_user(0, &infop->si_errno);
1334	if (!retval && infop)
1335	retval = put_user((short)((p->ptrace & PT_PTRACED)
1336	? CLD_TRAPPED : CLD_STOPPED),
1337	&infop->si_code);
1338	if (!retval && infop)
1339	retval = put_user(exit_code, &infop->si_status);
1340	if (!retval && infop)
1341	retval = put_user(p->pid, &infop->si_pid);
1342	if (!retval && infop)
1343	retval = put_user(p->uid, &infop->si_uid);
1344	if (!retval)
1345	retval = p->pid;
1346	put_task_struct(p);
1347
1348	BUG_ON(!retval);
1349	return retval;
1350	}
1351
1352	/*
1353	* Handle do_wait work for one task in a live, non-stopped state.
1354	* read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1355	* the lock and this task is uninteresting. If we return nonzero, we have
1356	* released the lock and the system call should return.
1357	*/
1358	static int wait_task_continued(task_t *p, int noreap,
1359	struct siginfo __user *infop,
1360	int __user stat_addr, struct rusage __user ru)
1361	{
1362	int retval;
1363	pid_t pid;
1364	uid_t uid;
1365
1366	if (unlikely(!p->signal))
1367	return 0;
1368
1369	if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
1370	return 0;
1371
1372	spin_lock_irq(&p->sighand->siglock);
1373	/* Re-check with the lock held. */
1374	if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
1375	spin_unlock_irq(&p->sighand->siglock);
1376	return 0;
1377	}
1378	if (!noreap)
1379	p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
1380	spin_unlock_irq(&p->sighand->siglock);
1381
1382	pid = p->pid;
1383	uid = p->uid;
1384	get_task_struct(p);
1385	read_unlock(&tasklist_lock);
1386
1387	if (!infop) {
1388	retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
1389	put_task_struct(p);
1390	if (!retval && stat_addr)
1391	retval = put_user(0xffff, stat_addr);
1392	if (!retval)
1393	retval = p->pid;
1394	} else {
1395	retval = wait_noreap_copyout(p, pid, uid,
1396	CLD_CONTINUED, SIGCONT,
1397	infop, ru);
1398	BUG_ON(retval == 0);
1399	}
1400
1401	return retval;
1402	}
1403
1404
1405	static inline int my_ptrace_child(struct task_struct *p)
1406	{
1407	if (!(p->ptrace & PT_PTRACED))
1408	return 0;
1409	if (!(p->ptrace & PT_ATTACHED))
1410	return 1;
1411	/*
1412	* This child was PTRACE_ATTACH'd. We should be seeing it only if
1413	* we are the attacher. If we are the real parent, this is a race
1414	* inside ptrace_attach. It is waiting for the tasklist_lock,
1415	* which we have to switch the parent links, but has already set
1416	* the flags in p->ptrace.
1417	*/
1418	return (p->parent != p->real_parent);
1419	}
1420
1421	static long do_wait(pid_t pid, int options, struct siginfo __user *infop,
1422	int __user stat_addr, struct rusage __user ru)
1423	{
1424	DECLARE_WAITQUEUE(wait, current);
1425	struct task_struct *tsk;
1426	int flag, retval;
1427
1428	add_wait_queue(&current->signal->wait_chldexit,&wait);
1429	repeat:
1430	/*
1431	* We will set this flag if we see any child that might later
1432	* match our criteria, even if we are not able to reap it yet.
1433	*/
1434	flag = 0;
1435	current->state = TASK_INTERRUPTIBLE;
1436	read_lock(&tasklist_lock);
1437	tsk = current;
1438	do {
1439	struct task_struct *p;
1440	struct list_head *_p;
1441	int ret;
1442
1443	list_for_each(_p,&tsk->children) {
1444	p = list_entry(_p,struct task_struct,sibling);
1445
1446	ret = eligible_child(pid, options, p);
1447	if (!ret)
1448	continue;
1449
1450	switch (p->state) {
1451	case TASK_TRACED:
1452	/*
1453	* When we hit the race with PTRACE_ATTACH,
1454	* we will not report this child. But the
1455	* race means it has not yet been moved to
1456	* our ptrace_children list, so we need to
1457	* set the flag here to avoid a spurious ECHILD
1458	* when the race happens with the only child.
1459	*/
1460	flag = 1;
1461	if (!my_ptrace_child(p))
1462	continue;
1463	/FALLTHROUGH/
1464	case TASK_STOPPED:
1465	/*
1466	* It's stopped now, so it might later
1467	* continue, exit, or stop again.
1468	*/
1469	flag = 1;
1470	if (!(options & WUNTRACED) &&
1471	!my_ptrace_child(p))
1472	continue;
1473	retval = wait_task_stopped(p, ret == 2,
1474	(options & WNOWAIT),
1475	infop,
1476	stat_addr, ru);
1477	if (retval == -EAGAIN)
1478	goto repeat;
1479	if (retval != 0) /* He released the lock. */
1480	goto end;
1481	break;
1482	default:
1483	// case EXIT_DEAD:
1484	if (p->exit_state == EXIT_DEAD)
1485	continue;
1486	// case EXIT_ZOMBIE:
1487	if (p->exit_state == EXIT_ZOMBIE) {
1488	/*
1489	* Eligible but we cannot release
1490	* it yet:
1491	*/
1492	if (ret == 2)
1493	goto check_continued;
1494	if (!likely(options & WEXITED))
1495	continue;
1496	retval = wait_task_zombie(
1497	p, (options & WNOWAIT),
1498	infop, stat_addr, ru);
1499	/* He released the lock. */
1500	if (retval != 0)
1501	goto end;
1502	break;
1503	}
1504	check_continued:
1505	/*
1506	* It's running now, so it might later
1507	* exit, stop, or stop and then continue.
1508	*/
1509	flag = 1;
1510	if (!unlikely(options & WCONTINUED))
1511	continue;
1512	retval = wait_task_continued(
1513	p, (options & WNOWAIT),
1514	infop, stat_addr, ru);
1515	if (retval != 0) /* He released the lock. */
1516	goto end;
1517	break;
1518	}
1519	}
1520	if (!flag) {
1521	list_for_each(_p, &tsk->ptrace_children) {
1522	p = list_entry(_p, struct task_struct,
1523	ptrace_list);
1524	if (!eligible_child(pid, options, p))
1525	continue;
1526	flag = 1;
1527	break;
1528	}
1529	}
1530	if (options & __WNOTHREAD)
1531	break;
1532	tsk = next_thread(tsk);
1533	BUG_ON(tsk->signal != current->signal);
1534	} while (tsk != current);
1535
1536	read_unlock(&tasklist_lock);
1537	if (flag) {
1538	retval = 0;
1539	if (options & WNOHANG)
1540	goto end;
1541	retval = -ERESTARTSYS;
1542	if (signal_pending(current))
1543	goto end;
1544	schedule();
1545	goto repeat;
1546	}
1547	retval = -ECHILD;
1548	end:
1549	current->state = TASK_RUNNING;
1550	remove_wait_queue(&current->signal->wait_chldexit,&wait);
1551	if (infop) {
1552	if (retval > 0)
1553	retval = 0;
1554	else {
1555	/*
1556	* For a WNOHANG return, clear out all the fields
1557	* we would set so the user can easily tell the
1558	* difference.
1559	*/
1560	if (!retval)
1561	retval = put_user(0, &infop->si_signo);
1562	if (!retval)
1563	retval = put_user(0, &infop->si_errno);
1564	if (!retval)
1565	retval = put_user(0, &infop->si_code);
1566	if (!retval)
1567	retval = put_user(0, &infop->si_pid);
1568	if (!retval)
1569	retval = put_user(0, &infop->si_uid);
1570	if (!retval)
1571	retval = put_user(0, &infop->si_status);
1572	}
1573	}
1574	return retval;
1575	}
1576
1577	asmlinkage long sys_waitid(int which, pid_t pid,
1578	struct siginfo __user *infop, int options,
1579	struct rusage __user *ru)
1580	{
1581	long ret;
1582
1583	if (options & ~(WNOHANG\|WNOWAIT\|WEXITED\|WSTOPPED\|WCONTINUED))
1584	return -EINVAL;
1585	if (!(options & (WEXITED\|WSTOPPED\|WCONTINUED)))
1586	return -EINVAL;
1587
1588	switch (which) {
1589	case P_ALL:
1590	pid = -1;
1591	break;
1592	case P_PID:
1593	if (pid <= 0)
1594	return -EINVAL;
1595	break;
1596	case P_PGID:
1597	if (pid <= 0)
1598	return -EINVAL;
1599	pid = -pid;
1600	break;
1601	default:
1602	return -EINVAL;
1603	}
1604
1605	ret = do_wait(pid, options, infop, NULL, ru);
1606
1607	/* avoid REGPARM breakage on x86: */
1608	prevent_tail_call(ret);
1609	return ret;
1610	}
1611
1612	asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr,
1613	int options, struct rusage __user *ru)
1614	{
1615	long ret;
1616
1617	if (options & ~(WNOHANG\|WUNTRACED\|WCONTINUED\|
1618	__WNOTHREAD\|__WCLONE\|__WALL))
1619	return -EINVAL;
1620	ret = do_wait(pid, options \| WEXITED, NULL, stat_addr, ru);
1621
1622	/* avoid REGPARM breakage on x86: */
1623	prevent_tail_call(ret);
1624	return ret;
1625	}
1626
1627	#ifdef __ARCH_WANT_SYS_WAITPID
1628
1629	/*
1630	* sys_waitpid() remains for compatibility. waitpid() should be
1631	* implemented by calling sys_wait4() from libc.a.
1632	*/
1633	asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options)
1634	{
1635	return sys_wait4(pid, stat_addr, options, NULL);
1636	}
1637
1638	#endif