kern_exit.c revision 1.96 1 /* $NetBSD: kern_exit.c,v 1.96 2002/08/02 22:45:57 manu Exp $ */
2
3 /*-
4 * Copyright (c) 1998, 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 /*
41 * Copyright (c) 1982, 1986, 1989, 1991, 1993
42 * The Regents of the University of California. All rights reserved.
43 * (c) UNIX System Laboratories, Inc.
44 * All or some portions of this file are derived from material licensed
45 * to the University of California by American Telephone and Telegraph
46 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
47 * the permission of UNIX System Laboratories, Inc.
48 *
49 * Redistribution and use in source and binary forms, with or without
50 * modification, are permitted provided that the following conditions
51 * are met:
52 * 1. Redistributions of source code must retain the above copyright
53 * notice, this list of conditions and the following disclaimer.
54 * 2. Redistributions in binary form must reproduce the above copyright
55 * notice, this list of conditions and the following disclaimer in the
56 * documentation and/or other materials provided with the distribution.
57 * 3. All advertising materials mentioning features or use of this software
58 * must display the following acknowledgement:
59 * This product includes software developed by the University of
60 * California, Berkeley and its contributors.
61 * 4. Neither the name of the University nor the names of its contributors
62 * may be used to endorse or promote products derived from this software
63 * without specific prior written permission.
64 *
65 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
66 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
68 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
69 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
70 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
71 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
72 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
73 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
74 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
75 * SUCH DAMAGE.
76 *
77 * @(#)kern_exit.c 8.10 (Berkeley) 2/23/95
78 */
79
80 #include <sys/cdefs.h>
81 __KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.96 2002/08/02 22:45:57 manu Exp $");
82
83 #include "opt_ktrace.h"
84 #include "opt_systrace.h"
85 #include "opt_sysv.h"
86
87 #include <sys/param.h>
88 #include <sys/systm.h>
89 #include <sys/map.h>
90 #include <sys/ioctl.h>
91 #include <sys/proc.h>
92 #include <sys/tty.h>
93 #include <sys/time.h>
94 #include <sys/resource.h>
95 #include <sys/kernel.h>
96 #include <sys/ktrace.h>
97 #include <sys/proc.h>
98 #include <sys/buf.h>
99 #include <sys/wait.h>
100 #include <sys/file.h>
101 #include <sys/vnode.h>
102 #include <sys/syslog.h>
103 #include <sys/malloc.h>
104 #include <sys/pool.h>
105 #include <sys/resourcevar.h>
106 #include <sys/ptrace.h>
107 #include <sys/acct.h>
108 #include <sys/filedesc.h>
109 #include <sys/signalvar.h>
110 #include <sys/sched.h>
111 #include <sys/mount.h>
112 #include <sys/syscallargs.h>
113 #include <sys/systrace.h>
114
115 #include <machine/cpu.h>
116
117 #include <uvm/uvm_extern.h>
118
119
120 /*
121 * exit --
122 * Death of process.
123 */
124 int
125 sys_exit(struct proc *p, void *v, register_t *retval)
126 {
127 struct sys_exit_args /* {
128 syscallarg(int) rval;
129 } */ *uap = v;
130
131 exit1(p, W_EXITCODE(SCARG(uap, rval), 0));
132 /* NOTREACHED */
133 return (0);
134 }
135
136 /*
137 * Exit: deallocate address space and other resources, change proc state
138 * to zombie, and unlink proc from allproc and parent's lists. Save exit
139 * status and rusage for wait(). Check for child processes and orphan them.
140 */
141 void
142 exit1(struct proc *p, int rv)
143 {
144 struct proc *q, *nq;
145 int s;
146
147 if (__predict_false(p == initproc))
148 panic("init died (signal %d, exit %d)",
149 WTERMSIG(rv), WEXITSTATUS(rv));
150
151 #ifdef PGINPROF
152 vmsizmon();
153 #endif
154 if (p->p_flag & P_PROFIL)
155 stopprofclock(p);
156 p->p_ru = pool_get(&rusage_pool, PR_WAITOK);
157 /*
158 * If parent is waiting for us to exit or exec, P_PPWAIT is set; we
159 * wake up the parent early to avoid deadlock.
160 */
161 p->p_flag |= P_WEXIT;
162 if (p->p_flag & P_PPWAIT) {
163 p->p_flag &= ~P_PPWAIT;
164 wakeup((caddr_t)p->p_pptr);
165 }
166 sigfillset(&p->p_sigctx.ps_sigignore);
167 sigemptyset(&p->p_sigctx.ps_siglist);
168 p->p_sigctx.ps_sigcheck = 0;
169 callout_stop(&p->p_realit_ch);
170
171 /*
172 * Close open files and release open-file table.
173 * This may block!
174 */
175 fdfree(p);
176 cwdfree(p);
177
178 doexithooks(p);
179
180 if (SESS_LEADER(p)) {
181 struct session *sp = p->p_session;
182
183 if (sp->s_ttyvp) {
184 /*
185 * Controlling process.
186 * Signal foreground pgrp,
187 * drain controlling terminal
188 * and revoke access to controlling terminal.
189 */
190 if (sp->s_ttyp->t_session == sp) {
191 if (sp->s_ttyp->t_pgrp)
192 pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1);
193 (void) ttywait(sp->s_ttyp);
194 /*
195 * The tty could have been revoked
196 * if we blocked.
197 */
198 if (sp->s_ttyvp)
199 VOP_REVOKE(sp->s_ttyvp, REVOKEALL);
200 }
201 if (sp->s_ttyvp)
202 vrele(sp->s_ttyvp);
203 sp->s_ttyvp = NULL;
204 /*
205 * s_ttyp is not zero'd; we use this to indicate
206 * that the session once had a controlling terminal.
207 * (for logging and informational purposes)
208 */
209 }
210 sp->s_leader = NULL;
211 }
212 fixjobc(p, p->p_pgrp, 0);
213 (void)acct_process(p);
214 #ifdef KTRACE
215 /*
216 * release trace file
217 */
218 ktrderef(p);
219 #endif
220 #ifdef SYSTRACE
221 systrace_sys_exit(p);
222 #endif
223 /*
224 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP!
225 */
226 p->p_stat = SDEAD;
227
228 /*
229 * Remove proc from pidhash chain so looking it up won't
230 * work. Move it from allproc to zombproc, but do not yet
231 * wake up the reaper. We will put the proc on the
232 * deadproc list later (using the p_hash member), and
233 * wake up the reaper when we do.
234 */
235 s = proclist_lock_write();
236 LIST_REMOVE(p, p_hash);
237 LIST_REMOVE(p, p_list);
238 LIST_INSERT_HEAD(&zombproc, p, p_list);
239 proclist_unlock_write(s);
240
241 /*
242 * Give orphaned children to init(8).
243 */
244 q = p->p_children.lh_first;
245 if (q) /* only need this if any child is S_ZOMB */
246 wakeup((caddr_t)initproc);
247 for (; q != 0; q = nq) {
248 nq = q->p_sibling.le_next;
249 proc_reparent(q, initproc);
250 /*
251 * Traced processes are killed
252 * since their existence means someone is screwing up.
253 */
254 if (q->p_flag & P_TRACED) {
255 q->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE);
256 psignal(q, SIGKILL);
257 }
258 }
259
260 /*
261 * Reset p_opptr pointer of all former children which got
262 * traced by another process and were reparented. We reset
263 * it to NULL here; the trace detach code then reparents
264 * the child to initproc. We only check allproc list, since
265 * eventual former children on zombproc list won't reference
266 * p_opptr anymore.
267 */
268 if (p->p_flag & P_CHTRACED) {
269 struct proc *t;
270
271 proclist_lock_read();
272
273 LIST_FOREACH(t, &allproc, p_list) {
274 if (t->p_opptr == p)
275 t->p_opptr = NULL;
276 }
277
278 proclist_unlock_read();
279 }
280
281 /*
282 * Save exit status and final rusage info, adding in child rusage
283 * info and self times.
284 */
285 p->p_xstat = rv;
286 *p->p_ru = p->p_stats->p_ru;
287 calcru(p, &p->p_ru->ru_utime, &p->p_ru->ru_stime, NULL);
288 ruadd(p->p_ru, &p->p_stats->p_cru);
289
290 /*
291 * Notify parent that we're gone. If parent has the P_NOCLDWAIT
292 * flag set, notify init instead (and hope it will handle
293 * this situation).
294 */
295 if (p->p_pptr->p_flag & P_NOCLDWAIT) {
296 struct proc *pp = p->p_pptr;
297 proc_reparent(p, initproc);
298 /*
299 * If this was the last child of our parent, notify
300 * parent, so in case he was wait(2)ing, he will
301 * continue.
302 */
303 if (pp->p_children.lh_first == NULL)
304 wakeup((caddr_t)pp);
305 }
306
307 /*
308 * Release the process's signal state.
309 */
310 sigactsfree(p);
311
312 /*
313 * If emulation has process exit hook, call it now.
314 */
315 if (p->p_emul->e_proc_exit)
316 (*p->p_emul->e_proc_exit)(p);
317
318 /*
319 * Clear curproc after we've done all operations
320 * that could block, and before tearing down the rest
321 * of the process state that might be used from clock, etc.
322 * Also, can't clear curproc while we're still runnable,
323 * as we're not on a run queue (we are current, just not
324 * a proper proc any longer!).
325 *
326 * Other substructures are freed from wait().
327 */
328 curproc = NULL;
329 limfree(p->p_limit);
330 p->p_limit = NULL;
331
332 /* This process no longer needs to hold the kernel lock. */
333 KERNEL_PROC_UNLOCK(p);
334
335 /*
336 * Finally, call machine-dependent code to switch to a new
337 * context (possibly the idle context). Once we are no longer
338 * using the dead process's vmspace and stack, exit2() will be
339 * called to schedule those resources to be released by the
340 * reaper thread.
341 *
342 * Note that cpu_exit() will end with a call equivalent to
343 * cpu_switch(), finishing our execution (pun intended).
344 */
345 cpu_exit(p);
346 }
347
348 /*
349 * We are called from cpu_exit() once it is safe to schedule the
350 * dead process's resources to be freed (i.e., once we've switched to
351 * the idle PCB for the current CPU).
352 *
353 * NOTE: One must be careful with locking in this routine. It's
354 * called from a critical section in machine-dependent code, so
355 * we should refrain from changing any interrupt state.
356 *
357 * We lock the deadproc list (a spin lock), place the proc on that
358 * list (using the p_hash member), and wake up the reaper.
359 */
360 void
361 exit2(struct proc *p)
362 {
363
364 simple_lock(&deadproc_slock);
365 LIST_INSERT_HEAD(&deadproc, p, p_hash);
366 simple_unlock(&deadproc_slock);
367
368 wakeup(&deadproc);
369 }
370
371 /*
372 * Process reaper. This is run by a kernel thread to free the resources
373 * of a dead process. Once the resources are free, the process becomes
374 * a zombie, and the parent is allowed to read the undead's status.
375 */
376 void
377 reaper(void *arg)
378 {
379 struct proc *p;
380
381 KERNEL_PROC_UNLOCK(curproc);
382
383 for (;;) {
384 simple_lock(&deadproc_slock);
385 p = LIST_FIRST(&deadproc);
386 if (p == NULL) {
387 /* No work for us; go to sleep until someone exits. */
388 (void) ltsleep(&deadproc, PVM|PNORELOCK,
389 "reaper", 0, &deadproc_slock);
390 continue;
391 }
392
393 /* Remove us from the deadproc list. */
394 LIST_REMOVE(p, p_hash);
395 simple_unlock(&deadproc_slock);
396 KERNEL_PROC_LOCK(curproc);
397
398 /*
399 * Give machine-dependent code a chance to free any
400 * resources it couldn't free while still running on
401 * that process's context. This must be done before
402 * uvm_exit(), in case these resources are in the PCB.
403 */
404 cpu_wait(p);
405
406 /*
407 * Free the VM resources we're still holding on to.
408 * We must do this from a valid thread because doing
409 * so may block.
410 */
411 uvm_exit(p);
412
413 /* Process is now a true zombie. */
414 p->p_stat = SZOMB;
415
416 /* Wake up the parent so it can get exit status. */
417 if ((p->p_flag & P_FSTRACE) == 0 && p->p_exitsig != 0)
418 psignal(p->p_pptr, P_EXITSIG(p));
419 KERNEL_PROC_UNLOCK(curproc);
420 wakeup((caddr_t)p->p_pptr);
421 }
422 }
423
424 int
425 sys_wait4(struct proc *q, void *v, register_t *retval)
426 {
427 struct sys_wait4_args /* {
428 syscallarg(int) pid;
429 syscallarg(int *) status;
430 syscallarg(int) options;
431 syscallarg(struct rusage *) rusage;
432 } */ *uap = v;
433 struct proc *p, *t;
434 int nfound, status, error, s;
435
436 if (SCARG(uap, pid) == 0)
437 SCARG(uap, pid) = -q->p_pgid;
438 if (SCARG(uap, options) &~ (WUNTRACED|WNOHANG|WALTSIG))
439 return (EINVAL);
440
441 loop:
442 nfound = 0;
443 for (p = q->p_children.lh_first; p != 0; p = p->p_sibling.le_next) {
444 if (SCARG(uap, pid) != WAIT_ANY &&
445 p->p_pid != SCARG(uap, pid) &&
446 p->p_pgid != -SCARG(uap, pid))
447 continue;
448 /*
449 * Wait for processes with p_exitsig != SIGCHLD processes only
450 * if WALTSIG is set; wait for processes with p_exitsig ==
451 * SIGCHLD only if WALTSIG is clear.
452 */
453 if (((SCARG(uap, options) & WALLSIG) == 0) &&
454 ((SCARG(uap, options) & WALTSIG) ?
455 (p->p_exitsig == SIGCHLD) : (P_EXITSIG(p) != SIGCHLD)))
456 continue;
457
458 nfound++;
459 if (p->p_stat == SZOMB) {
460 retval[0] = p->p_pid;
461
462 if (SCARG(uap, status)) {
463 status = p->p_xstat; /* convert to int */
464 error = copyout((caddr_t)&status,
465 (caddr_t)SCARG(uap, status),
466 sizeof(status));
467 if (error)
468 return (error);
469 }
470 if (SCARG(uap, rusage) &&
471 (error = copyout((caddr_t)p->p_ru,
472 (caddr_t)SCARG(uap, rusage),
473 sizeof(struct rusage))))
474 return (error);
475 /*
476 * If we got the child via ptrace(2) or procfs, and
477 * the parent is different (meaning the process was
478 * attached, rather than run as a child), then we need
479 * to give it back to the old parent, and send the
480 * parent the exit signal. The rest of the cleanup
481 * will be done when the old parent waits on the child.
482 */
483 if ((p->p_flag & P_TRACED) && p->p_opptr != p->p_pptr){
484 t = p->p_opptr;
485 proc_reparent(p, t ? t : initproc);
486 p->p_opptr = NULL;
487 p->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE);
488 if (p->p_exitsig != 0)
489 psignal(p->p_pptr, P_EXITSIG(p));
490 wakeup((caddr_t)p->p_pptr);
491 return (0);
492 }
493 scheduler_wait_hook(q, p);
494 p->p_xstat = 0;
495 ruadd(&q->p_stats->p_cru, p->p_ru);
496 pool_put(&rusage_pool, p->p_ru);
497
498 /*
499 * Finally finished with old proc entry.
500 * Unlink it from its process group and free it.
501 */
502 leavepgrp(p);
503
504 s = proclist_lock_write();
505 LIST_REMOVE(p, p_list); /* off zombproc */
506 proclist_unlock_write(s);
507
508 LIST_REMOVE(p, p_sibling);
509
510 /*
511 * Decrement the count of procs running with this uid.
512 */
513 (void)chgproccnt(p->p_cred->p_ruid, -1);
514
515 /*
516 * Free up credentials.
517 */
518 if (--p->p_cred->p_refcnt == 0) {
519 crfree(p->p_cred->pc_ucred);
520 pool_put(&pcred_pool, p->p_cred);
521 }
522
523 /*
524 * Release reference to text vnode
525 */
526 if (p->p_textvp)
527 vrele(p->p_textvp);
528
529 pool_put(&proc_pool, p);
530 nprocs--;
531 return (0);
532 }
533 if (p->p_stat == SSTOP && (p->p_flag & P_WAITED) == 0 &&
534 (p->p_flag & P_TRACED || SCARG(uap, options) & WUNTRACED)) {
535 p->p_flag |= P_WAITED;
536 retval[0] = p->p_pid;
537
538 if (SCARG(uap, status)) {
539 status = W_STOPCODE(p->p_xstat);
540 error = copyout((caddr_t)&status,
541 (caddr_t)SCARG(uap, status),
542 sizeof(status));
543 } else
544 error = 0;
545 return (error);
546 }
547 }
548 if (nfound == 0)
549 return (ECHILD);
550 if (SCARG(uap, options) & WNOHANG) {
551 retval[0] = 0;
552 return (0);
553 }
554 if ((error = tsleep((caddr_t)q, PWAIT | PCATCH, "wait", 0)) != 0)
555 return (error);
556 goto loop;
557 }
558
559 /*
560 * make process 'parent' the new parent of process 'child'.
561 */
562 void
563 proc_reparent(struct proc *child, struct proc *parent)
564 {
565
566 if (child->p_pptr == parent)
567 return;
568
569 if (parent == initproc)
570 child->p_exitsig = SIGCHLD;
571
572 LIST_REMOVE(child, p_sibling);
573 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
574 child->p_pptr = parent;
575 }
576