blob: 3ac6a7a6f8575898868a8c92e0da8533a7089279 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/exit.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/mm.h>
8#include <linux/slab.h>
9#include <linux/interrupt.h>
10#include <linux/smp_lock.h>
11#include <linux/module.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080012#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/completion.h>
14#include <linux/personality.h>
15#include <linux/tty.h>
Kirill Korotaev6b3286e2006-12-08 02:37:56 -080016#include <linux/mnt_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/key.h>
18#include <linux/security.h>
19#include <linux/cpu.h>
20#include <linux/acct.h>
Jay Lan8f0ab512006-09-30 23:28:59 -070021#include <linux/tsacct_kern.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/file.h>
23#include <linux/binfmts.h>
Serge E. Hallynab516012006-10-02 02:18:06 -070024#include <linux/nsproxy.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080025#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/ptrace.h>
27#include <linux/profile.h>
28#include <linux/mount.h>
29#include <linux/proc_fs.h>
30#include <linux/mempolicy.h>
Shailabh Nagarc7572492006-07-14 00:24:40 -070031#include <linux/taskstats_kern.h>
Shailabh Nagarca74e922006-07-14 00:24:36 -070032#include <linux/delayacct.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/cpuset.h>
34#include <linux/syscalls.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070035#include <linux/signal.h>
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080036#include <linux/posix-timers.h>
Matt Helsley9f460802005-11-07 00:59:16 -080037#include <linux/cn_proc.h>
Ingo Molnarde5097c2006-01-09 15:59:21 -080038#include <linux/mutex.h>
Ingo Molnar0771dfe2006-03-27 01:16:22 -080039#include <linux/futex.h>
Ingo Molnar34f192c2006-03-27 01:16:24 -080040#include <linux/compat.h>
Jens Axboeb92ce552006-04-11 13:52:07 +020041#include <linux/pipe_fs_i.h>
Al Virofa84cb92006-03-29 20:30:19 -050042#include <linux/audit.h> /* for audit_free() */
Adrian Bunk83cc5ed2006-06-25 05:47:41 -070043#include <linux/resource.h>
David Howells0d67a462006-08-29 19:05:56 +010044#include <linux/blkdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#include <asm/uaccess.h>
47#include <asm/unistd.h>
48#include <asm/pgtable.h>
49#include <asm/mmu_context.h>
50
51extern void sem_exit (void);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Adrian Bunk408b6642005-05-01 08:59:29 -070053static void exit_mm(struct task_struct * tsk);
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055static void __unhash_process(struct task_struct *p)
56{
57 nr_threads--;
58 detach_pid(p, PIDTYPE_PID);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 if (thread_group_leader(p)) {
60 detach_pid(p, PIDTYPE_PGID);
61 detach_pid(p, PIDTYPE_SID);
Oleg Nesterovc97d9892006-03-28 16:11:06 -080062
Eric W. Biederman5e85d4a2006-04-18 22:20:16 -070063 list_del_rcu(&p->tasks);
Oleg Nesterov73b9ebf2006-03-28 16:11:07 -080064 __get_cpu_var(process_counts)--;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 }
Oleg Nesterov47e65322006-03-28 16:11:25 -080066 list_del_rcu(&p->thread_group);
Oleg Nesterovc97d9892006-03-28 16:11:06 -080067 remove_parent(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068}
69
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080070/*
71 * This function expects the tasklist_lock write-locked.
72 */
73static void __exit_signal(struct task_struct *tsk)
74{
75 struct signal_struct *sig = tsk->signal;
76 struct sighand_struct *sighand;
77
78 BUG_ON(!sig);
79 BUG_ON(!atomic_read(&sig->count));
80
81 rcu_read_lock();
82 sighand = rcu_dereference(tsk->sighand);
83 spin_lock(&sighand->siglock);
84
85 posix_cpu_timers_exit(tsk);
86 if (atomic_dec_and_test(&sig->count))
87 posix_cpu_timers_exit_group(tsk);
88 else {
89 /*
90 * If there is any task waiting for the group exit
91 * then notify it:
92 */
93 if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
94 wake_up_process(sig->group_exit_task);
95 sig->group_exit_task = NULL;
96 }
97 if (tsk == sig->curr_target)
98 sig->curr_target = next_thread(tsk);
99 /*
100 * Accumulate here the counters for all threads but the
101 * group leader as they die, so they can be added into
102 * the process-wide totals when those are taken.
103 * The group leader stays around as a zombie as long
104 * as there are other threads. When it gets reaped,
105 * the exit.c code will add its counts into these totals.
106 * We won't ever get here for the group leader, since it
107 * will have been the last reference on the signal_struct.
108 */
109 sig->utime = cputime_add(sig->utime, tsk->utime);
110 sig->stime = cputime_add(sig->stime, tsk->stime);
111 sig->min_flt += tsk->min_flt;
112 sig->maj_flt += tsk->maj_flt;
113 sig->nvcsw += tsk->nvcsw;
114 sig->nivcsw += tsk->nivcsw;
115 sig->sched_time += tsk->sched_time;
116 sig = NULL; /* Marker for below. */
117 }
118
Oleg Nesterov58767002006-03-28 16:11:20 -0800119 __unhash_process(tsk);
120
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800121 tsk->signal = NULL;
Oleg Nesterova7e53282006-03-28 16:11:27 -0800122 tsk->sighand = NULL;
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800123 spin_unlock(&sighand->siglock);
124 rcu_read_unlock();
125
Oleg Nesterova7e53282006-03-28 16:11:27 -0800126 __cleanup_sighand(sighand);
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800127 clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
128 flush_sigqueue(&tsk->pending);
129 if (sig) {
130 flush_sigqueue(&sig->shared_pending);
Oleg Nesterov093a8e82006-10-28 10:38:51 -0700131 taskstats_tgid_free(sig);
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800132 __cleanup_signal(sig);
133 }
134}
135
Eric W. Biederman8c7904a2006-03-31 02:31:37 -0800136static void delayed_put_task_struct(struct rcu_head *rhp)
137{
138 put_task_struct(container_of(rhp, struct task_struct, rcu));
139}
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141void release_task(struct task_struct * p)
142{
Ingo Molnar36c8b582006-07-03 00:25:41 -0700143 struct task_struct *leader;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 int zap_leader;
Oleg Nesterov1f09f972006-03-28 16:11:11 -0800145repeat:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 atomic_dec(&p->user->processes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 write_lock_irq(&tasklist_lock);
Oleg Nesterov1f09f972006-03-28 16:11:11 -0800148 ptrace_unlink(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children));
150 __exit_signal(p);
Oleg Nesterov35f5cad2006-03-28 16:11:19 -0800151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 /*
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);
Eric W. Biederman48e64842006-06-26 00:25:48 -0700175 proc_flush_task(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 release_thread(p);
Eric W. Biederman8c7904a2006-03-31 02:31:37 -0800177 call_rcu(&p->rcu, delayed_put_task_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 p = leader;
180 if (unlikely(zap_leader))
181 goto repeat;
182}
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/*
185 * This checks not only the pgrp, but falls back on the pid if no
186 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
187 * without this...
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -0800188 *
189 * The caller must hold rcu lock or the tasklist lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 */
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -0800191struct pid *session_of_pgrp(struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
193 struct task_struct *p;
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -0800194 struct pid *sid = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -0800196 p = pid_task(pgrp, PIDTYPE_PGID);
Oleg Nesterov62dfb552006-12-08 02:38:03 -0800197 if (p == NULL)
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -0800198 p = pid_task(pgrp, PIDTYPE_PID);
Oleg Nesterov62dfb552006-12-08 02:38:03 -0800199 if (p != NULL)
Eric W. Biederman04a2e6a2007-02-12 00:52:56 -0800200 sid = task_session(p);
Oleg Nesterov62dfb552006-12-08 02:38:03 -0800201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return sid;
203}
204
205/*
206 * Determine if a process group is "orphaned", according to the POSIX
207 * definition in 2.2.2.52. Orphaned process groups are not to be affected
208 * by terminal-generated stop signals. Newly orphaned process groups are
209 * to receive a SIGHUP and a SIGCONT.
210 *
211 * "I ask you, have you ever known what it is to be an orphan?"
212 */
Ingo Molnar36c8b582006-07-03 00:25:41 -0700213static int will_become_orphaned_pgrp(int pgrp, struct task_struct *ignored_task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
215 struct task_struct *p;
216 int ret = 1;
217
218 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
219 if (p == ignored_task
220 || p->exit_state
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -0700221 || is_init(p->real_parent))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 continue;
Cedric Le Goater937949d2006-12-08 02:37:54 -0800223 if (process_group(p->real_parent) != pgrp &&
224 process_session(p->real_parent) == process_session(p)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 ret = 0;
226 break;
227 }
228 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
229 return ret; /* (sighing) "Often!" */
230}
231
232int is_orphaned_pgrp(int pgrp)
233{
234 int retval;
235
236 read_lock(&tasklist_lock);
237 retval = will_become_orphaned_pgrp(pgrp, NULL);
238 read_unlock(&tasklist_lock);
239
240 return retval;
241}
242
Arjan van de Ven858119e2006-01-14 13:20:43 -0800243static int has_stopped_jobs(int pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
245 int retval = 0;
246 struct task_struct *p;
247
248 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
249 if (p->state != TASK_STOPPED)
250 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 retval = 1;
252 break;
253 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
254 return retval;
255}
256
257/**
Robert P. J. Day72fd4a32007-02-10 01:45:59 -0800258 * reparent_to_init - Reparent the calling kernel thread to the init task of the pid space that the thread belongs to.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 *
260 * If a kernel thread is launched as a result of a system call, or if
261 * it ever exits, it should generally reparent itself to init so that
262 * it is correctly cleaned up on exit.
263 *
264 * The various task state such as scheduling policy and priority may have
265 * been inherited from a user process, so we reset them to sane values here.
266 *
267 * NOTE that reparent_to_init() gives the caller full capabilities.
268 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800269static void reparent_to_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270{
271 write_lock_irq(&tasklist_lock);
272
273 ptrace_unlink(current);
274 /* Reparent to init */
Oleg Nesterov9b678ec2006-03-28 16:11:05 -0800275 remove_parent(current);
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -0800276 current->parent = child_reaper(current);
277 current->real_parent = child_reaper(current);
Oleg Nesterov9b678ec2006-03-28 16:11:05 -0800278 add_parent(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
280 /* Set the exit signal to SIGCHLD so we signal init on exit */
281 current->exit_signal = SIGCHLD;
282
Oleg Nesterov1c573af2006-09-29 02:00:51 -0700283 if (!has_rt_policy(current) && (task_nice(current) < 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 set_user_nice(current, 0);
285 /* cpus_allowed? */
286 /* rt_priority? */
287 /* signals? */
288 security_task_reparent_to_init(current);
289 memcpy(current->signal->rlim, init_task.signal->rlim,
290 sizeof(current->signal->rlim));
291 atomic_inc(&(INIT_USER->__count));
292 write_unlock_irq(&tasklist_lock);
293 switch_uid(INIT_USER);
294}
295
296void __set_special_pids(pid_t session, pid_t pgrp)
297{
Oren Laadane19f2472006-01-08 01:03:58 -0800298 struct task_struct *curr = current->group_leader;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Cedric Le Goater937949d2006-12-08 02:37:54 -0800300 if (process_session(curr) != session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 detach_pid(curr, PIDTYPE_SID);
Cedric Le Goater1ec320a2006-12-08 02:37:55 -0800302 set_signal_session(curr->signal, session);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 attach_pid(curr, PIDTYPE_SID, session);
304 }
305 if (process_group(curr) != pgrp) {
306 detach_pid(curr, PIDTYPE_PGID);
307 curr->signal->pgrp = pgrp;
308 attach_pid(curr, PIDTYPE_PGID, pgrp);
309 }
310}
311
Oleg Nesterovae424ae2006-12-08 02:36:08 -0800312static void set_special_pids(pid_t session, pid_t pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
314 write_lock_irq(&tasklist_lock);
315 __set_special_pids(session, pgrp);
316 write_unlock_irq(&tasklist_lock);
317}
318
319/*
320 * Let kernel threads use this to say that they
321 * allow a certain signal (since daemonize() will
322 * have disabled all of them by default).
323 */
324int allow_signal(int sig)
325{
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700326 if (!valid_signal(sig) || sig < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return -EINVAL;
328
329 spin_lock_irq(&current->sighand->siglock);
330 sigdelset(&current->blocked, sig);
331 if (!current->mm) {
332 /* Kernel threads handle their own signals.
333 Let the signal code know it'll be handled, so
334 that they don't get converted to SIGKILL or
335 just silently dropped */
336 current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
337 }
338 recalc_sigpending();
339 spin_unlock_irq(&current->sighand->siglock);
340 return 0;
341}
342
343EXPORT_SYMBOL(allow_signal);
344
345int disallow_signal(int sig)
346{
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700347 if (!valid_signal(sig) || sig < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return -EINVAL;
349
350 spin_lock_irq(&current->sighand->siglock);
351 sigaddset(&current->blocked, sig);
352 recalc_sigpending();
353 spin_unlock_irq(&current->sighand->siglock);
354 return 0;
355}
356
357EXPORT_SYMBOL(disallow_signal);
358
359/*
360 * Put all the gunge required to become a kernel thread without
361 * attached user resources in one place where it belongs.
362 */
363
364void daemonize(const char *name, ...)
365{
366 va_list args;
367 struct fs_struct *fs;
368 sigset_t blocked;
369
370 va_start(args, name);
371 vsnprintf(current->comm, sizeof(current->comm), name, args);
372 va_end(args);
373
374 /*
375 * If we were started as result of loading a module, close all of the
376 * user space pages. We don't need them, and if we didn't close them
377 * they would be locked into memory.
378 */
379 exit_mm(current);
380
381 set_special_pids(1, 1);
Peter Zijlstra24ec8392006-12-08 02:36:04 -0800382 proc_clear_tty(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384 /* Block and flush all signals */
385 sigfillset(&blocked);
386 sigprocmask(SIG_BLOCK, &blocked, NULL);
387 flush_signals(current);
388
389 /* Become as one with the init task */
390
391 exit_fs(current); /* current->fs->count--; */
392 fs = init_task.fs;
393 current->fs = fs;
394 atomic_inc(&fs->count);
Serge E. Hallynab516012006-10-02 02:18:06 -0700395
Linus Torvalds444f3782007-01-30 13:35:18 -0800396 exit_task_namespaces(current);
Serge E. Hallynab516012006-10-02 02:18:06 -0700397 current->nsproxy = init_task.nsproxy;
Serge E. Hallynab516012006-10-02 02:18:06 -0700398 get_task_namespaces(current);
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 exit_files(current);
401 current->files = init_task.files;
402 atomic_inc(&current->files->count);
403
404 reparent_to_init();
405}
406
407EXPORT_SYMBOL(daemonize);
408
Arjan van de Ven858119e2006-01-14 13:20:43 -0800409static void close_files(struct files_struct * files)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
411 int i, j;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700412 struct fdtable *fdt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 j = 0;
Dipankar Sarma4fb3a532005-09-16 19:28:13 -0700415
416 /*
417 * It is safe to dereference the fd table without RCU or
418 * ->file_lock because this is the last reference to the
419 * files structure.
420 */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700421 fdt = files_fdtable(files);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 for (;;) {
423 unsigned long set;
424 i = j * __NFDBITS;
Vadim Lobanovbbea9f62006-12-10 02:21:12 -0800425 if (i >= fdt->max_fds)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 break;
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700427 set = fdt->open_fds->fds_bits[j++];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 while (set) {
429 if (set & 1) {
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700430 struct file * file = xchg(&fdt->fd[i], NULL);
Ingo Molnar944be0b2007-02-12 00:52:26 -0800431 if (file) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 filp_close(file, files);
Ingo Molnar944be0b2007-02-12 00:52:26 -0800433 cond_resched();
434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 }
436 i++;
437 set >>= 1;
438 }
439 }
440}
441
442struct files_struct *get_files_struct(struct task_struct *task)
443{
444 struct files_struct *files;
445
446 task_lock(task);
447 files = task->files;
448 if (files)
449 atomic_inc(&files->count);
450 task_unlock(task);
451
452 return files;
453}
454
455void fastcall put_files_struct(struct files_struct *files)
456{
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700457 struct fdtable *fdt;
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 if (atomic_dec_and_test(&files->count)) {
460 close_files(files);
461 /*
462 * Free the fd and fdset arrays if we expanded them.
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700463 * If the fdtable was embedded, pass files for freeing
464 * at the end of the RCU grace period. Otherwise,
465 * you can free files immediately.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 */
Dipankar Sarmabadf1662005-09-09 13:04:10 -0700467 fdt = files_fdtable(files);
Vadim Lobanov4fd45812006-12-10 02:21:17 -0800468 if (fdt != &files->fdtab)
Dipankar Sarmaab2af1f2005-09-09 13:04:13 -0700469 kmem_cache_free(files_cachep, files);
Vadim Lobanov01b2d932006-12-22 01:10:43 -0800470 free_fdtable(fdt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
472}
473
474EXPORT_SYMBOL(put_files_struct);
475
Kirill Korotaev3b9b8ab2006-09-29 02:00:05 -0700476void reset_files_struct(struct task_struct *tsk, struct files_struct *files)
477{
478 struct files_struct *old;
479
480 old = tsk->files;
481 task_lock(tsk);
482 tsk->files = files;
483 task_unlock(tsk);
484 put_files_struct(old);
485}
486EXPORT_SYMBOL(reset_files_struct);
487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488static inline void __exit_files(struct task_struct *tsk)
489{
490 struct files_struct * files = tsk->files;
491
492 if (files) {
493 task_lock(tsk);
494 tsk->files = NULL;
495 task_unlock(tsk);
496 put_files_struct(files);
497 }
498}
499
500void exit_files(struct task_struct *tsk)
501{
502 __exit_files(tsk);
503}
504
505static inline void __put_fs_struct(struct fs_struct *fs)
506{
507 /* No need to hold fs->lock if we are killing it */
508 if (atomic_dec_and_test(&fs->count)) {
509 dput(fs->root);
510 mntput(fs->rootmnt);
511 dput(fs->pwd);
512 mntput(fs->pwdmnt);
513 if (fs->altroot) {
514 dput(fs->altroot);
515 mntput(fs->altrootmnt);
516 }
517 kmem_cache_free(fs_cachep, fs);
518 }
519}
520
521void put_fs_struct(struct fs_struct *fs)
522{
523 __put_fs_struct(fs);
524}
525
526static inline void __exit_fs(struct task_struct *tsk)
527{
528 struct fs_struct * fs = tsk->fs;
529
530 if (fs) {
531 task_lock(tsk);
532 tsk->fs = NULL;
533 task_unlock(tsk);
534 __put_fs_struct(fs);
535 }
536}
537
538void exit_fs(struct task_struct *tsk)
539{
540 __exit_fs(tsk);
541}
542
543EXPORT_SYMBOL_GPL(exit_fs);
544
545/*
546 * Turn us into a lazy TLB process if we
547 * aren't already..
548 */
Adrian Bunk408b6642005-05-01 08:59:29 -0700549static void exit_mm(struct task_struct * tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
551 struct mm_struct *mm = tsk->mm;
552
553 mm_release(tsk, mm);
554 if (!mm)
555 return;
556 /*
557 * Serialize with any possible pending coredump.
558 * We must hold mmap_sem around checking core_waiters
559 * and clearing tsk->mm. The core-inducing thread
560 * will increment core_waiters for each thread in the
561 * group with ->mm != NULL.
562 */
563 down_read(&mm->mmap_sem);
564 if (mm->core_waiters) {
565 up_read(&mm->mmap_sem);
566 down_write(&mm->mmap_sem);
567 if (!--mm->core_waiters)
568 complete(mm->core_startup_done);
569 up_write(&mm->mmap_sem);
570
571 wait_for_completion(&mm->core_done);
572 down_read(&mm->mmap_sem);
573 }
574 atomic_inc(&mm->mm_count);
Eric Sesterhenn125e1872006-06-23 02:06:06 -0700575 BUG_ON(mm != tsk->active_mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 /* more a memory barrier than a real lock */
577 task_lock(tsk);
578 tsk->mm = NULL;
579 up_read(&mm->mmap_sem);
580 enter_lazy_tlb(mm, current);
581 task_unlock(tsk);
582 mmput(mm);
583}
584
Ingo Molnar36c8b582006-07-03 00:25:41 -0700585static inline void
586choose_new_parent(struct task_struct *p, struct task_struct *reaper)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 /*
589 * Make sure we're not reparenting to ourselves and that
590 * the parent is not a zombie.
591 */
Oleg Nesterovd799f032006-03-28 16:11:04 -0800592 BUG_ON(p == reaper || reaper->exit_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 p->real_parent = reaper;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594}
595
Ingo Molnar36c8b582006-07-03 00:25:41 -0700596static void
597reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Oleg Nesterov241ceee2006-12-24 23:30:44 +0300599 if (p->pdeath_signal)
600 /* We already hold the tasklist_lock here. */
601 group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);
602
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 /* Move the child from its dying parent to the new one. */
604 if (unlikely(traced)) {
605 /* Preserve ptrace links if someone else is tracing this child. */
606 list_del_init(&p->ptrace_list);
607 if (p->parent != p->real_parent)
608 list_add(&p->ptrace_list, &p->real_parent->ptrace_children);
609 } else {
610 /* If this child is being traced, then we're the one tracing it
611 * anyway, so let go of it.
612 */
613 p->ptrace = 0;
Oleg Nesterov6ac781b2006-03-28 16:11:09 -0800614 remove_parent(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 p->parent = p->real_parent;
Oleg Nesterov6ac781b2006-03-28 16:11:09 -0800616 add_parent(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Eric W. Biedermanb2b2cbc2006-12-21 21:28:40 -0700618 if (p->state == TASK_TRACED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 /*
620 * If it was at a trace stop, turn it into
621 * a normal stop since it's no longer being
622 * traced.
623 */
624 ptrace_untrace(p);
625 }
626 }
627
Eric W. Biedermanb2b2cbc2006-12-21 21:28:40 -0700628 /* If this is a threaded reparent there is no need to
629 * notify anyone anything has happened.
630 */
631 if (p->real_parent->group_leader == father->group_leader)
632 return;
633
634 /* We don't want people slaying init. */
635 if (p->exit_signal != -1)
636 p->exit_signal = SIGCHLD;
Eric W. Biedermanb2b2cbc2006-12-21 21:28:40 -0700637
638 /* If we'd notified the old parent about this child's death,
639 * also notify the new parent.
640 */
641 if (!traced && p->exit_state == EXIT_ZOMBIE &&
642 p->exit_signal != -1 && thread_group_empty(p))
643 do_notify_parent(p, p->exit_signal);
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 /*
646 * process group orphan check
647 * Case ii: Our child is in a different pgrp
648 * than we are, and it was the only connection
649 * outside, so the child pgrp is now orphaned.
650 */
651 if ((process_group(p) != process_group(father)) &&
Cedric Le Goater937949d2006-12-08 02:37:54 -0800652 (process_session(p) == process_session(father))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 int pgrp = process_group(p);
654
Cedric Le Goater937949d2006-12-08 02:37:54 -0800655 if (will_become_orphaned_pgrp(pgrp, NULL) &&
656 has_stopped_jobs(pgrp)) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800657 __kill_pg_info(SIGHUP, SEND_SIG_PRIV, pgrp);
658 __kill_pg_info(SIGCONT, SEND_SIG_PRIV, pgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 }
660 }
661}
662
663/*
664 * When we die, we re-parent all our children.
665 * Try to give them to another thread in our thread
666 * group, and if no such member exists, give it to
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -0800667 * the child reaper process (ie "init") in our pid
668 * space.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 */
Ingo Molnar36c8b582006-07-03 00:25:41 -0700670static void
671forget_original_parent(struct task_struct *father, struct list_head *to_release)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672{
673 struct task_struct *p, *reaper = father;
674 struct list_head *_p, *_n;
675
676 do {
677 reaper = next_thread(reaper);
678 if (reaper == father) {
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -0800679 reaper = child_reaper(father);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 break;
681 }
682 } while (reaper->exit_state);
683
684 /*
685 * There are only two places where our children can be:
686 *
687 * - in our child list
688 * - in our ptraced child list
689 *
690 * Search them and reparent children.
691 */
692 list_for_each_safe(_p, _n, &father->children) {
693 int ptrace;
Ingo Molnar36c8b582006-07-03 00:25:41 -0700694 p = list_entry(_p, struct task_struct, sibling);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 ptrace = p->ptrace;
697
698 /* if father isn't the real parent, then ptrace must be enabled */
699 BUG_ON(father != p->real_parent && !ptrace);
700
701 if (father == p->real_parent) {
702 /* reparent with a reaper, real father it's us */
Oleg Nesterovd799f032006-03-28 16:11:04 -0800703 choose_new_parent(p, reaper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 reparent_thread(p, father, 0);
705 } else {
706 /* reparent ptraced task to its real parent */
707 __ptrace_unlink (p);
708 if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 &&
709 thread_group_empty(p))
710 do_notify_parent(p, p->exit_signal);
711 }
712
713 /*
714 * if the ptraced child is a zombie with exit_signal == -1
715 * we must collect it before we exit, or it will remain
716 * zombie forever since we prevented it from self-reap itself
717 * while it was being traced by us, to be able to see it in wait4.
718 */
719 if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && p->exit_signal == -1))
720 list_add(&p->ptrace_list, to_release);
721 }
722 list_for_each_safe(_p, _n, &father->ptrace_children) {
Ingo Molnar36c8b582006-07-03 00:25:41 -0700723 p = list_entry(_p, struct task_struct, ptrace_list);
Oleg Nesterovd799f032006-03-28 16:11:04 -0800724 choose_new_parent(p, reaper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 reparent_thread(p, father, 1);
726 }
727}
728
729/*
730 * Send signals to all our closest relatives so that they know
731 * to properly mourn us..
732 */
733static void exit_notify(struct task_struct *tsk)
734{
735 int state;
736 struct task_struct *t;
737 struct list_head ptrace_dead, *_p, *_n;
738
739 if (signal_pending(tsk) && !(tsk->signal->flags & SIGNAL_GROUP_EXIT)
740 && !thread_group_empty(tsk)) {
741 /*
742 * This occurs when there was a race between our exit
743 * syscall and a group signal choosing us as the one to
744 * wake up. It could be that we are the only thread
745 * alerted to check for pending signals, but another thread
746 * should be woken now to take the signal since we will not.
747 * Now we'll wake all the threads in the group just to make
748 * sure someone gets all the pending signals.
749 */
750 read_lock(&tasklist_lock);
751 spin_lock_irq(&tsk->sighand->siglock);
752 for (t = next_thread(tsk); t != tsk; t = next_thread(t))
753 if (!signal_pending(t) && !(t->flags & PF_EXITING)) {
754 recalc_sigpending_tsk(t);
755 if (signal_pending(t))
756 signal_wake_up(t, 0);
757 }
758 spin_unlock_irq(&tsk->sighand->siglock);
759 read_unlock(&tasklist_lock);
760 }
761
762 write_lock_irq(&tasklist_lock);
763
764 /*
765 * This does two things:
766 *
767 * A. Make init inherit all the child processes
768 * B. Check to see if any process groups have become orphaned
769 * as a result of our exiting, and if they have any stopped
770 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
771 */
772
773 INIT_LIST_HEAD(&ptrace_dead);
774 forget_original_parent(tsk, &ptrace_dead);
775 BUG_ON(!list_empty(&tsk->children));
776 BUG_ON(!list_empty(&tsk->ptrace_children));
777
778 /*
779 * Check to see if any process groups have become orphaned
780 * as a result of our exiting, and if they have any stopped
781 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
782 *
783 * Case i: Our father is in a different pgrp than we are
784 * and we were the only connection outside, so our pgrp
785 * is about to become orphaned.
786 */
787
788 t = tsk->real_parent;
789
790 if ((process_group(t) != process_group(tsk)) &&
Cedric Le Goater937949d2006-12-08 02:37:54 -0800791 (process_session(t) == process_session(tsk)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 will_become_orphaned_pgrp(process_group(tsk), tsk) &&
793 has_stopped_jobs(process_group(tsk))) {
Oleg Nesterovb67a1b92005-10-30 15:03:44 -0800794 __kill_pg_info(SIGHUP, SEND_SIG_PRIV, process_group(tsk));
795 __kill_pg_info(SIGCONT, SEND_SIG_PRIV, process_group(tsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 }
797
798 /* Let father know we died
799 *
800 * Thread signals are configurable, but you aren't going to use
801 * that to send signals to arbitary processes.
802 * That stops right now.
803 *
804 * If the parent exec id doesn't match the exec id we saved
805 * when we started then we know the parent has changed security
806 * domain.
807 *
808 * If our self_exec id doesn't match our parent_exec_id then
809 * we have changed execution domain as these two values started
810 * the same after a fork.
811 *
812 */
813
814 if (tsk->exit_signal != SIGCHLD && tsk->exit_signal != -1 &&
815 ( tsk->parent_exec_id != t->self_exec_id ||
816 tsk->self_exec_id != tsk->parent_exec_id)
817 && !capable(CAP_KILL))
818 tsk->exit_signal = SIGCHLD;
819
820
821 /* If something other than our normal parent is ptracing us, then
822 * send it a SIGCHLD instead of honoring exit_signal. exit_signal
823 * only has special meaning to our real parent.
824 */
825 if (tsk->exit_signal != -1 && thread_group_empty(tsk)) {
826 int signal = tsk->parent == tsk->real_parent ? tsk->exit_signal : SIGCHLD;
827 do_notify_parent(tsk, signal);
828 } else if (tsk->ptrace) {
829 do_notify_parent(tsk, SIGCHLD);
830 }
831
832 state = EXIT_ZOMBIE;
833 if (tsk->exit_signal == -1 &&
834 (likely(tsk->ptrace == 0) ||
835 unlikely(tsk->parent->signal->flags & SIGNAL_GROUP_EXIT)))
836 state = EXIT_DEAD;
837 tsk->exit_state = state;
838
839 write_unlock_irq(&tasklist_lock);
840
841 list_for_each_safe(_p, _n, &ptrace_dead) {
842 list_del_init(_p);
Ingo Molnar36c8b582006-07-03 00:25:41 -0700843 t = list_entry(_p, struct task_struct, ptrace_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 release_task(t);
845 }
846
847 /* If the process is dead, release it - nobody will wait for it */
848 if (state == EXIT_DEAD)
849 release_task(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
851
852fastcall NORET_TYPE void do_exit(long code)
853{
854 struct task_struct *tsk = current;
855 int group_dead;
856
857 profile_task_exit(tsk);
858
Jens Axboe22e2c502005-06-27 10:55:12 +0200859 WARN_ON(atomic_read(&tsk->fs_excl));
860
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 if (unlikely(in_interrupt()))
862 panic("Aiee, killing interrupt handler!");
863 if (unlikely(!tsk->pid))
864 panic("Attempted to kill the idle task!");
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -0800865 if (unlikely(tsk == child_reaper(tsk))) {
866 if (tsk->nsproxy->pid_ns != &init_pid_ns)
867 tsk->nsproxy->pid_ns->child_reaper = init_pid_ns.child_reaper;
868 else
869 panic("Attempted to kill init!");
870 }
871
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
873 if (unlikely(current->ptrace & PT_TRACE_EXIT)) {
874 current->ptrace_message = code;
875 ptrace_notify((PTRACE_EVENT_EXIT << 8) | SIGTRAP);
876 }
877
Alexander Nybergdf164db2005-06-23 00:09:13 -0700878 /*
879 * We're taking recursive faults here in do_exit. Safest is to just
880 * leave this task alone and wait for reboot.
881 */
882 if (unlikely(tsk->flags & PF_EXITING)) {
883 printk(KERN_ALERT
884 "Fixing recursive fault but reboot is needed!\n");
Al Viroafc847b2006-02-28 12:51:55 -0500885 if (tsk->io_context)
886 exit_io_context();
Alexander Nybergdf164db2005-06-23 00:09:13 -0700887 set_current_state(TASK_UNINTERRUPTIBLE);
888 schedule();
889 }
890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 tsk->flags |= PF_EXITING;
892
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 if (unlikely(in_atomic()))
894 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
895 current->comm, current->pid,
896 preempt_count());
897
898 acct_update_integrals(tsk);
Hugh Dickins365e9c872005-10-29 18:16:18 -0700899 if (tsk->mm) {
900 update_hiwater_rss(tsk->mm);
901 update_hiwater_vm(tsk->mm);
902 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 group_dead = atomic_dec_and_test(&tsk->signal->live);
Andrew Mortonc3068952005-08-04 16:49:32 -0700904 if (group_dead) {
Thomas Gleixner2ff678b2006-01-09 20:52:34 -0800905 hrtimer_cancel(&tsk->signal->real_timer);
Roland McGrath25f407f2005-10-21 15:03:29 -0700906 exit_itimers(tsk->signal);
Andrew Mortonc3068952005-08-04 16:49:32 -0700907 }
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700908 acct_collect(code, group_dead);
Ingo Molnar0771dfe2006-03-27 01:16:22 -0800909 if (unlikely(tsk->robust_list))
910 exit_robust_list(tsk);
Anton Blanchard2aa92582006-06-25 05:48:44 -0700911#if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT)
Ingo Molnar34f192c2006-03-27 01:16:24 -0800912 if (unlikely(tsk->compat_robust_list))
913 compat_exit_robust_list(tsk);
914#endif
Al Virofa84cb92006-03-29 20:30:19 -0500915 if (unlikely(tsk->audit_context))
916 audit_free(tsk);
Oleg Nesterov115085e2006-12-06 20:36:51 -0800917
918 taskstats_exit(tsk, group_dead);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700919
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 exit_mm(tsk);
921
KaiGai Kohei0e464812006-06-25 05:49:24 -0700922 if (group_dead)
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700923 acct_process();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 exit_sem(tsk);
925 __exit_files(tsk);
926 __exit_fs(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 exit_thread();
928 cpuset_exit(tsk);
929 exit_keys(tsk);
930
931 if (group_dead && tsk->signal->leader)
932 disassociate_ctty(1);
933
Al Viroa1261f52005-11-13 16:06:55 -0800934 module_put(task_thread_info(tsk)->exec_domain->module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 if (tsk->binfmt)
936 module_put(tsk->binfmt->module);
937
938 tsk->exit_code = code;
Matt Helsley9f460802005-11-07 00:59:16 -0800939 proc_exit_connector(tsk);
Linus Torvalds444f3782007-01-30 13:35:18 -0800940 exit_task_namespaces(tsk);
Serge E. Hallyn0f245282007-01-30 15:28:23 -0600941 exit_notify(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942#ifdef CONFIG_NUMA
943 mpol_free(tsk->mempolicy);
944 tsk->mempolicy = NULL;
945#endif
Ingo Molnarde5097c2006-01-09 15:59:21 -0800946 /*
Ingo Molnarc87e2832006-06-27 02:54:58 -0700947 * This must happen late, after the PID is not
948 * hashed anymore:
949 */
950 if (unlikely(!list_empty(&tsk->pi_state_list)))
951 exit_pi_state_list(tsk);
952 if (unlikely(current->pi_state_cache))
953 kfree(current->pi_state_cache);
954 /*
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700955 * Make sure we are holding no locks:
Ingo Molnarde5097c2006-01-09 15:59:21 -0800956 */
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700957 debug_check_no_locks_held(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
Al Viroafc847b2006-02-28 12:51:55 -0500959 if (tsk->io_context)
960 exit_io_context();
961
Jens Axboeb92ce552006-04-11 13:52:07 +0200962 if (tsk->splice_pipe)
963 __free_pipe_info(tsk->splice_pipe);
964
Coywolf Qi Hunt74072512005-10-30 15:02:47 -0800965 preempt_disable();
Oleg Nesterov55a101f2006-09-29 02:01:10 -0700966 /* causes final put_task_struct in finish_task_switch(). */
Oleg Nesterovc394cc92006-09-29 02:01:11 -0700967 tsk->state = TASK_DEAD;
Coywolf Qi Hunt74072512005-10-30 15:02:47 -0800968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 schedule();
970 BUG();
971 /* Avoid "noreturn function does return". */
Alan Cox54306cf2006-09-29 02:00:42 -0700972 for (;;)
973 cpu_relax(); /* For when BUG is null */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974}
975
Russ Anderson012914d2005-04-23 00:08:00 -0700976EXPORT_SYMBOL_GPL(do_exit);
977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978NORET_TYPE void complete_and_exit(struct completion *comp, long code)
979{
980 if (comp)
981 complete(comp);
Oleg Nesterov55a101f2006-09-29 02:01:10 -0700982
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 do_exit(code);
984}
985
986EXPORT_SYMBOL(complete_and_exit);
987
988asmlinkage long sys_exit(int error_code)
989{
990 do_exit((error_code&0xff)<<8);
991}
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993/*
994 * Take down every thread in the group. This is called by fatal signals
995 * as well as by sys_exit_group (below).
996 */
997NORET_TYPE void
998do_group_exit(int exit_code)
999{
1000 BUG_ON(exit_code & 0x80); /* core dumps don't get here */
1001
1002 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1003 exit_code = current->signal->group_exit_code;
1004 else if (!thread_group_empty(current)) {
1005 struct signal_struct *const sig = current->signal;
1006 struct sighand_struct *const sighand = current->sighand;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 spin_lock_irq(&sighand->siglock);
1008 if (sig->flags & SIGNAL_GROUP_EXIT)
1009 /* Another thread got here before we took the lock. */
1010 exit_code = sig->group_exit_code;
1011 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 sig->group_exit_code = exit_code;
1013 zap_other_threads(current);
1014 }
1015 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 }
1017
1018 do_exit(exit_code);
1019 /* NOTREACHED */
1020}
1021
1022/*
1023 * this kills every thread in the thread group. Note that any externally
1024 * wait4()-ing process will get the correct exit code - even if this
1025 * thread is not the thread group leader.
1026 */
1027asmlinkage void sys_exit_group(int error_code)
1028{
1029 do_group_exit((error_code & 0xff) << 8);
1030}
1031
Ingo Molnar36c8b582006-07-03 00:25:41 -07001032static int eligible_child(pid_t pid, int options, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033{
1034 if (pid > 0) {
1035 if (p->pid != pid)
1036 return 0;
1037 } else if (!pid) {
1038 if (process_group(p) != process_group(current))
1039 return 0;
1040 } else if (pid != -1) {
1041 if (process_group(p) != -pid)
1042 return 0;
1043 }
1044
1045 /*
1046 * Do not consider detached threads that are
1047 * not ptraced:
1048 */
1049 if (p->exit_signal == -1 && !p->ptrace)
1050 return 0;
1051
1052 /* Wait for all children (clone and not) if __WALL is set;
1053 * otherwise, wait for clone children *only* if __WCLONE is
1054 * set; otherwise, wait for non-clone children *only*. (Note:
1055 * A "clone" child here is one that reports to its parent
1056 * using a signal other than SIGCHLD.) */
1057 if (((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0))
1058 && !(options & __WALL))
1059 return 0;
1060 /*
1061 * Do not consider thread group leaders that are
1062 * in a non-empty thread group:
1063 */
Oleg Nesterov3b6362b2006-09-02 21:22:16 +04001064 if (delay_group_leader(p))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 return 2;
1066
1067 if (security_task_wait(p))
1068 return 0;
1069
1070 return 1;
1071}
1072
Ingo Molnar36c8b582006-07-03 00:25:41 -07001073static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 int why, int status,
1075 struct siginfo __user *infop,
1076 struct rusage __user *rusagep)
1077{
1078 int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
Ingo Molnar36c8b582006-07-03 00:25:41 -07001079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 put_task_struct(p);
1081 if (!retval)
1082 retval = put_user(SIGCHLD, &infop->si_signo);
1083 if (!retval)
1084 retval = put_user(0, &infop->si_errno);
1085 if (!retval)
1086 retval = put_user((short)why, &infop->si_code);
1087 if (!retval)
1088 retval = put_user(pid, &infop->si_pid);
1089 if (!retval)
1090 retval = put_user(uid, &infop->si_uid);
1091 if (!retval)
1092 retval = put_user(status, &infop->si_status);
1093 if (!retval)
1094 retval = pid;
1095 return retval;
1096}
1097
1098/*
1099 * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold
1100 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1101 * the lock and this task is uninteresting. If we return nonzero, we have
1102 * released the lock and the system call should return.
1103 */
Ingo Molnar36c8b582006-07-03 00:25:41 -07001104static int wait_task_zombie(struct task_struct *p, int noreap,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 struct siginfo __user *infop,
1106 int __user *stat_addr, struct rusage __user *ru)
1107{
1108 unsigned long state;
1109 int retval;
1110 int status;
1111
1112 if (unlikely(noreap)) {
1113 pid_t pid = p->pid;
1114 uid_t uid = p->uid;
1115 int exit_code = p->exit_code;
1116 int why, status;
1117
1118 if (unlikely(p->exit_state != EXIT_ZOMBIE))
1119 return 0;
1120 if (unlikely(p->exit_signal == -1 && p->ptrace == 0))
1121 return 0;
1122 get_task_struct(p);
1123 read_unlock(&tasklist_lock);
1124 if ((exit_code & 0x7f) == 0) {
1125 why = CLD_EXITED;
1126 status = exit_code >> 8;
1127 } else {
1128 why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
1129 status = exit_code & 0x7f;
1130 }
1131 return wait_noreap_copyout(p, pid, uid, why,
1132 status, infop, ru);
1133 }
1134
1135 /*
1136 * Try to move the task's state to DEAD
1137 * only one thread is allowed to do this:
1138 */
1139 state = xchg(&p->exit_state, EXIT_DEAD);
1140 if (state != EXIT_ZOMBIE) {
1141 BUG_ON(state != EXIT_DEAD);
1142 return 0;
1143 }
1144 if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) {
1145 /*
1146 * This can only happen in a race with a ptraced thread
1147 * dying on another processor.
1148 */
1149 return 0;
1150 }
1151
1152 if (likely(p->real_parent == p->parent) && likely(p->signal)) {
Jesper Juhl3795e162006-01-09 20:54:39 -08001153 struct signal_struct *psig;
1154 struct signal_struct *sig;
1155
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 /*
1157 * The resource counters for the group leader are in its
1158 * own task_struct. Those for dead threads in the group
1159 * are in its signal_struct, as are those for the child
1160 * processes it has previously reaped. All these
1161 * accumulate in the parent's signal_struct c* fields.
1162 *
1163 * We don't bother to take a lock here to protect these
1164 * p->signal fields, because they are only touched by
1165 * __exit_signal, which runs with tasklist_lock
1166 * write-locked anyway, and so is excluded here. We do
1167 * need to protect the access to p->parent->signal fields,
1168 * as other threads in the parent group can be right
1169 * here reaping other children at the same time.
1170 */
1171 spin_lock_irq(&p->parent->sighand->siglock);
Jesper Juhl3795e162006-01-09 20:54:39 -08001172 psig = p->parent->signal;
1173 sig = p->signal;
1174 psig->cutime =
1175 cputime_add(psig->cutime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 cputime_add(p->utime,
Jesper Juhl3795e162006-01-09 20:54:39 -08001177 cputime_add(sig->utime,
1178 sig->cutime)));
1179 psig->cstime =
1180 cputime_add(psig->cstime,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 cputime_add(p->stime,
Jesper Juhl3795e162006-01-09 20:54:39 -08001182 cputime_add(sig->stime,
1183 sig->cstime)));
1184 psig->cmin_flt +=
1185 p->min_flt + sig->min_flt + sig->cmin_flt;
1186 psig->cmaj_flt +=
1187 p->maj_flt + sig->maj_flt + sig->cmaj_flt;
1188 psig->cnvcsw +=
1189 p->nvcsw + sig->nvcsw + sig->cnvcsw;
1190 psig->cnivcsw +=
1191 p->nivcsw + sig->nivcsw + sig->cnivcsw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 spin_unlock_irq(&p->parent->sighand->siglock);
1193 }
1194
1195 /*
1196 * Now we are sure this task is interesting, and no other
1197 * thread can reap it because we set its state to EXIT_DEAD.
1198 */
1199 read_unlock(&tasklist_lock);
1200
1201 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
1202 status = (p->signal->flags & SIGNAL_GROUP_EXIT)
1203 ? p->signal->group_exit_code : p->exit_code;
1204 if (!retval && stat_addr)
1205 retval = put_user(status, stat_addr);
1206 if (!retval && infop)
1207 retval = put_user(SIGCHLD, &infop->si_signo);
1208 if (!retval && infop)
1209 retval = put_user(0, &infop->si_errno);
1210 if (!retval && infop) {
1211 int why;
1212
1213 if ((status & 0x7f) == 0) {
1214 why = CLD_EXITED;
1215 status >>= 8;
1216 } else {
1217 why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
1218 status &= 0x7f;
1219 }
1220 retval = put_user((short)why, &infop->si_code);
1221 if (!retval)
1222 retval = put_user(status, &infop->si_status);
1223 }
1224 if (!retval && infop)
1225 retval = put_user(p->pid, &infop->si_pid);
1226 if (!retval && infop)
1227 retval = put_user(p->uid, &infop->si_uid);
1228 if (retval) {
1229 // TODO: is this safe?
1230 p->exit_state = EXIT_ZOMBIE;
1231 return retval;
1232 }
1233 retval = p->pid;
1234 if (p->real_parent != p->parent) {
1235 write_lock_irq(&tasklist_lock);
1236 /* Double-check with lock held. */
1237 if (p->real_parent != p->parent) {
1238 __ptrace_unlink(p);
1239 // TODO: is this safe?
1240 p->exit_state = EXIT_ZOMBIE;
1241 /*
1242 * If this is not a detached task, notify the parent.
1243 * If it's still not detached after that, don't release
1244 * it now.
1245 */
1246 if (p->exit_signal != -1) {
1247 do_notify_parent(p, p->exit_signal);
1248 if (p->exit_signal != -1)
1249 p = NULL;
1250 }
1251 }
1252 write_unlock_irq(&tasklist_lock);
1253 }
1254 if (p != NULL)
1255 release_task(p);
1256 BUG_ON(!retval);
1257 return retval;
1258}
1259
1260/*
1261 * Handle sys_wait4 work for one task in state TASK_STOPPED. We hold
1262 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1263 * the lock and this task is uninteresting. If we return nonzero, we have
1264 * released the lock and the system call should return.
1265 */
Ingo Molnar36c8b582006-07-03 00:25:41 -07001266static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
1267 int noreap, struct siginfo __user *infop,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 int __user *stat_addr, struct rusage __user *ru)
1269{
1270 int retval, exit_code;
1271
1272 if (!p->exit_code)
1273 return 0;
1274 if (delayed_group_leader && !(p->ptrace & PT_PTRACED) &&
1275 p->signal && p->signal->group_stop_count > 0)
1276 /*
1277 * A group stop is in progress and this is the group leader.
1278 * We won't report until all threads have stopped.
1279 */
1280 return 0;
1281
1282 /*
1283 * Now we are pretty sure this task is interesting.
1284 * Make sure it doesn't get reaped out from under us while we
1285 * give up the lock and then examine it below. We don't want to
1286 * keep holding onto the tasklist_lock while we call getrusage and
1287 * possibly take page faults for user memory.
1288 */
1289 get_task_struct(p);
1290 read_unlock(&tasklist_lock);
1291
1292 if (unlikely(noreap)) {
1293 pid_t pid = p->pid;
1294 uid_t uid = p->uid;
1295 int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;
1296
1297 exit_code = p->exit_code;
1298 if (unlikely(!exit_code) ||
Linus Torvalds14bf01b2005-10-01 11:04:18 -07001299 unlikely(p->state & TASK_TRACED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 goto bail_ref;
1301 return wait_noreap_copyout(p, pid, uid,
1302 why, (exit_code << 8) | 0x7f,
1303 infop, ru);
1304 }
1305
1306 write_lock_irq(&tasklist_lock);
1307
1308 /*
1309 * This uses xchg to be atomic with the thread resuming and setting
1310 * it. It must also be done with the write lock held to prevent a
1311 * race with the EXIT_ZOMBIE case.
1312 */
1313 exit_code = xchg(&p->exit_code, 0);
1314 if (unlikely(p->exit_state)) {
1315 /*
1316 * The task resumed and then died. Let the next iteration
1317 * catch it in EXIT_ZOMBIE. Note that exit_code might
1318 * already be zero here if it resumed and did _exit(0).
1319 * The task itself is dead and won't touch exit_code again;
1320 * other processors in this function are locked out.
1321 */
1322 p->exit_code = exit_code;
1323 exit_code = 0;
1324 }
1325 if (unlikely(exit_code == 0)) {
1326 /*
1327 * Another thread in this function got to it first, or it
1328 * resumed, or it resumed and then died.
1329 */
1330 write_unlock_irq(&tasklist_lock);
1331bail_ref:
1332 put_task_struct(p);
1333 /*
1334 * We are returning to the wait loop without having successfully
1335 * removed the process and having released the lock. We cannot
1336 * continue, since the "p" task pointer is potentially stale.
1337 *
1338 * Return -EAGAIN, and do_wait() will restart the loop from the
1339 * beginning. Do _not_ re-acquire the lock.
1340 */
1341 return -EAGAIN;
1342 }
1343
1344 /* move to end of parent's list to avoid starvation */
1345 remove_parent(p);
Oleg Nesterov8fafabd2006-03-28 16:11:05 -08001346 add_parent(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
1348 write_unlock_irq(&tasklist_lock);
1349
1350 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
1351 if (!retval && stat_addr)
1352 retval = put_user((exit_code << 8) | 0x7f, stat_addr);
1353 if (!retval && infop)
1354 retval = put_user(SIGCHLD, &infop->si_signo);
1355 if (!retval && infop)
1356 retval = put_user(0, &infop->si_errno);
1357 if (!retval && infop)
1358 retval = put_user((short)((p->ptrace & PT_PTRACED)
1359 ? CLD_TRAPPED : CLD_STOPPED),
1360 &infop->si_code);
1361 if (!retval && infop)
1362 retval = put_user(exit_code, &infop->si_status);
1363 if (!retval && infop)
1364 retval = put_user(p->pid, &infop->si_pid);
1365 if (!retval && infop)
1366 retval = put_user(p->uid, &infop->si_uid);
1367 if (!retval)
1368 retval = p->pid;
1369 put_task_struct(p);
1370
1371 BUG_ON(!retval);
1372 return retval;
1373}
1374
1375/*
1376 * Handle do_wait work for one task in a live, non-stopped state.
1377 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1378 * the lock and this task is uninteresting. If we return nonzero, we have
1379 * released the lock and the system call should return.
1380 */
Ingo Molnar36c8b582006-07-03 00:25:41 -07001381static int wait_task_continued(struct task_struct *p, int noreap,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 struct siginfo __user *infop,
1383 int __user *stat_addr, struct rusage __user *ru)
1384{
1385 int retval;
1386 pid_t pid;
1387 uid_t uid;
1388
1389 if (unlikely(!p->signal))
1390 return 0;
1391
1392 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
1393 return 0;
1394
1395 spin_lock_irq(&p->sighand->siglock);
1396 /* Re-check with the lock held. */
1397 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
1398 spin_unlock_irq(&p->sighand->siglock);
1399 return 0;
1400 }
1401 if (!noreap)
1402 p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
1403 spin_unlock_irq(&p->sighand->siglock);
1404
1405 pid = p->pid;
1406 uid = p->uid;
1407 get_task_struct(p);
1408 read_unlock(&tasklist_lock);
1409
1410 if (!infop) {
1411 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
1412 put_task_struct(p);
1413 if (!retval && stat_addr)
1414 retval = put_user(0xffff, stat_addr);
1415 if (!retval)
1416 retval = p->pid;
1417 } else {
1418 retval = wait_noreap_copyout(p, pid, uid,
1419 CLD_CONTINUED, SIGCONT,
1420 infop, ru);
1421 BUG_ON(retval == 0);
1422 }
1423
1424 return retval;
1425}
1426
1427
1428static inline int my_ptrace_child(struct task_struct *p)
1429{
1430 if (!(p->ptrace & PT_PTRACED))
1431 return 0;
1432 if (!(p->ptrace & PT_ATTACHED))
1433 return 1;
1434 /*
1435 * This child was PTRACE_ATTACH'd. We should be seeing it only if
1436 * we are the attacher. If we are the real parent, this is a race
1437 * inside ptrace_attach. It is waiting for the tasklist_lock,
1438 * which we have to switch the parent links, but has already set
1439 * the flags in p->ptrace.
1440 */
1441 return (p->parent != p->real_parent);
1442}
1443
1444static long do_wait(pid_t pid, int options, struct siginfo __user *infop,
1445 int __user *stat_addr, struct rusage __user *ru)
1446{
1447 DECLARE_WAITQUEUE(wait, current);
1448 struct task_struct *tsk;
1449 int flag, retval;
1450
1451 add_wait_queue(&current->signal->wait_chldexit,&wait);
1452repeat:
1453 /*
1454 * We will set this flag if we see any child that might later
1455 * match our criteria, even if we are not able to reap it yet.
1456 */
1457 flag = 0;
1458 current->state = TASK_INTERRUPTIBLE;
1459 read_lock(&tasklist_lock);
1460 tsk = current;
1461 do {
1462 struct task_struct *p;
1463 struct list_head *_p;
1464 int ret;
1465
1466 list_for_each(_p,&tsk->children) {
Ingo Molnar36c8b582006-07-03 00:25:41 -07001467 p = list_entry(_p, struct task_struct, sibling);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469 ret = eligible_child(pid, options, p);
1470 if (!ret)
1471 continue;
1472
1473 switch (p->state) {
1474 case TASK_TRACED:
Roland McGrath7f2a5252005-10-30 15:02:50 -08001475 /*
1476 * When we hit the race with PTRACE_ATTACH,
1477 * we will not report this child. But the
1478 * race means it has not yet been moved to
1479 * our ptrace_children list, so we need to
1480 * set the flag here to avoid a spurious ECHILD
1481 * when the race happens with the only child.
1482 */
1483 flag = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 if (!my_ptrace_child(p))
1485 continue;
1486 /*FALLTHROUGH*/
1487 case TASK_STOPPED:
1488 /*
1489 * It's stopped now, so it might later
1490 * continue, exit, or stop again.
1491 */
1492 flag = 1;
1493 if (!(options & WUNTRACED) &&
1494 !my_ptrace_child(p))
1495 continue;
1496 retval = wait_task_stopped(p, ret == 2,
1497 (options & WNOWAIT),
1498 infop,
1499 stat_addr, ru);
1500 if (retval == -EAGAIN)
1501 goto repeat;
1502 if (retval != 0) /* He released the lock. */
1503 goto end;
1504 break;
1505 default:
1506 // case EXIT_DEAD:
1507 if (p->exit_state == EXIT_DEAD)
1508 continue;
1509 // case EXIT_ZOMBIE:
1510 if (p->exit_state == EXIT_ZOMBIE) {
1511 /*
1512 * Eligible but we cannot release
1513 * it yet:
1514 */
1515 if (ret == 2)
1516 goto check_continued;
1517 if (!likely(options & WEXITED))
1518 continue;
1519 retval = wait_task_zombie(
1520 p, (options & WNOWAIT),
1521 infop, stat_addr, ru);
1522 /* He released the lock. */
1523 if (retval != 0)
1524 goto end;
1525 break;
1526 }
1527check_continued:
1528 /*
1529 * It's running now, so it might later
1530 * exit, stop, or stop and then continue.
1531 */
1532 flag = 1;
1533 if (!unlikely(options & WCONTINUED))
1534 continue;
1535 retval = wait_task_continued(
1536 p, (options & WNOWAIT),
1537 infop, stat_addr, ru);
1538 if (retval != 0) /* He released the lock. */
1539 goto end;
1540 break;
1541 }
1542 }
1543 if (!flag) {
1544 list_for_each(_p, &tsk->ptrace_children) {
1545 p = list_entry(_p, struct task_struct,
1546 ptrace_list);
1547 if (!eligible_child(pid, options, p))
1548 continue;
1549 flag = 1;
1550 break;
1551 }
1552 }
1553 if (options & __WNOTHREAD)
1554 break;
1555 tsk = next_thread(tsk);
Eric Sesterhenn125e1872006-06-23 02:06:06 -07001556 BUG_ON(tsk->signal != current->signal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 } while (tsk != current);
1558
1559 read_unlock(&tasklist_lock);
1560 if (flag) {
1561 retval = 0;
1562 if (options & WNOHANG)
1563 goto end;
1564 retval = -ERESTARTSYS;
1565 if (signal_pending(current))
1566 goto end;
1567 schedule();
1568 goto repeat;
1569 }
1570 retval = -ECHILD;
1571end:
1572 current->state = TASK_RUNNING;
1573 remove_wait_queue(&current->signal->wait_chldexit,&wait);
1574 if (infop) {
1575 if (retval > 0)
1576 retval = 0;
1577 else {
1578 /*
1579 * For a WNOHANG return, clear out all the fields
1580 * we would set so the user can easily tell the
1581 * difference.
1582 */
1583 if (!retval)
1584 retval = put_user(0, &infop->si_signo);
1585 if (!retval)
1586 retval = put_user(0, &infop->si_errno);
1587 if (!retval)
1588 retval = put_user(0, &infop->si_code);
1589 if (!retval)
1590 retval = put_user(0, &infop->si_pid);
1591 if (!retval)
1592 retval = put_user(0, &infop->si_uid);
1593 if (!retval)
1594 retval = put_user(0, &infop->si_status);
1595 }
1596 }
1597 return retval;
1598}
1599
1600asmlinkage long sys_waitid(int which, pid_t pid,
1601 struct siginfo __user *infop, int options,
1602 struct rusage __user *ru)
1603{
1604 long ret;
1605
1606 if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED))
1607 return -EINVAL;
1608 if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
1609 return -EINVAL;
1610
1611 switch (which) {
1612 case P_ALL:
1613 pid = -1;
1614 break;
1615 case P_PID:
1616 if (pid <= 0)
1617 return -EINVAL;
1618 break;
1619 case P_PGID:
1620 if (pid <= 0)
1621 return -EINVAL;
1622 pid = -pid;
1623 break;
1624 default:
1625 return -EINVAL;
1626 }
1627
1628 ret = do_wait(pid, options, infop, NULL, ru);
1629
1630 /* avoid REGPARM breakage on x86: */
1631 prevent_tail_call(ret);
1632 return ret;
1633}
1634
1635asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr,
1636 int options, struct rusage __user *ru)
1637{
1638 long ret;
1639
1640 if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
1641 __WNOTHREAD|__WCLONE|__WALL))
1642 return -EINVAL;
1643 ret = do_wait(pid, options | WEXITED, NULL, stat_addr, ru);
1644
1645 /* avoid REGPARM breakage on x86: */
1646 prevent_tail_call(ret);
1647 return ret;
1648}
1649
1650#ifdef __ARCH_WANT_SYS_WAITPID
1651
1652/*
1653 * sys_waitpid() remains for compatibility. waitpid() should be
1654 * implemented by calling sys_wait4() from libc.a.
1655 */
1656asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options)
1657{
1658 return sys_wait4(pid, stat_addr, options, NULL);
1659}
1660
1661#endif