kern_exit.c revision 1.74 1 /* $NetBSD: kern_exit.c,v 1.74 1999/09/28 14:47:03 bouyer 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 "opt_ktrace.h"
81 #include "opt_sysv.h"
82
83 #include <sys/param.h>
84 #include <sys/systm.h>
85 #include <sys/map.h>
86 #include <sys/ioctl.h>
87 #include <sys/proc.h>
88 #include <sys/tty.h>
89 #include <sys/time.h>
90 #include <sys/resource.h>
91 #include <sys/kernel.h>
92 #include <sys/ktrace.h>
93 #include <sys/proc.h>
94 #include <sys/buf.h>
95 #include <sys/wait.h>
96 #include <sys/file.h>
97 #include <sys/vnode.h>
98 #include <sys/syslog.h>
99 #include <sys/malloc.h>
100 #include <sys/pool.h>
101 #include <sys/resourcevar.h>
102 #include <sys/ptrace.h>
103 #include <sys/acct.h>
104 #include <sys/filedesc.h>
105 #include <sys/signalvar.h>
106 #include <sys/sched.h>
107 #ifdef SYSVSHM
108 #include <sys/shm.h>
109 #endif
110 #ifdef SYSVSEM
111 #include <sys/sem.h>
112 #endif
113
114 #include <sys/mount.h>
115 #include <sys/syscallargs.h>
116
117 #include <machine/cpu.h>
118
119 #include <vm/vm.h>
120 #include <vm/vm_kern.h>
121
122 #include <uvm/uvm_extern.h>
123
124 /*
125 * exit --
126 * Death of process.
127 */
128 int
129 sys_exit(p, v, retval)
130 struct proc *p;
131 void *v;
132 register_t *retval;
133 {
134 struct sys_exit_args /* {
135 syscallarg(int) rval;
136 } */ *uap = v;
137
138 exit1(p, W_EXITCODE(SCARG(uap, rval), 0));
139 /* NOTREACHED */
140 return (0);
141 }
142
143 /*
144 * Exit: deallocate address space and other resources, change proc state
145 * to zombie, and unlink proc from allproc and parent's lists. Save exit
146 * status and rusage for wait(). Check for child processes and orphan them.
147 */
148 void
149 exit1(p, rv)
150 register struct proc *p;
151 int rv;
152 {
153 register struct proc *q, *nq;
154 register struct vmspace *vm;
155 int s;
156
157 if (p == initproc)
158 panic("init died (signal %d, exit %d)",
159 WTERMSIG(rv), WEXITSTATUS(rv));
160
161 #ifdef PGINPROF
162 vmsizmon();
163 #endif
164 if (p->p_flag & P_PROFIL)
165 stopprofclock(p);
166 p->p_ru = pool_get(&rusage_pool, PR_WAITOK);
167 /*
168 * If parent is waiting for us to exit or exec, P_PPWAIT is set; we
169 * wake up the parent early to avoid deadlock.
170 */
171 p->p_flag |= P_WEXIT;
172 if (p->p_flag & P_PPWAIT) {
173 p->p_flag &= ~P_PPWAIT;
174 wakeup((caddr_t)p->p_pptr);
175 }
176 sigfillset(&p->p_sigignore);
177 sigemptyset(&p->p_siglist);
178 p->p_sigcheck = 0;
179 untimeout(realitexpire, (caddr_t)p);
180
181 /*
182 * Close open files and release open-file table.
183 * This may block!
184 */
185 fdfree(p);
186 cwdfree(p);
187
188 /* The next three chunks should probably be moved to vmspace_exit. */
189 vm = p->p_vmspace;
190 #ifdef SYSVSHM
191 if (vm->vm_shm && vm->vm_refcnt == 1)
192 shmexit(vm);
193 #endif
194 #ifdef SYSVSEM
195 semexit(p);
196 #endif
197 /*
198 * Release user portion of address space.
199 * This releases references to vnodes,
200 * which could cause I/O if the file has been unlinked.
201 * Need to do this early enough that we can still sleep.
202 * Can't free the entire vmspace as the kernel stack
203 * may be mapped within that space also.
204 */
205 if (vm->vm_refcnt == 1)
206 (void) uvm_deallocate(&vm->vm_map, VM_MIN_ADDRESS,
207 VM_MAXUSER_ADDRESS - VM_MIN_ADDRESS);
208
209 if (SESS_LEADER(p)) {
210 register struct session *sp = p->p_session;
211
212 if (sp->s_ttyvp) {
213 /*
214 * Controlling process.
215 * Signal foreground pgrp,
216 * drain controlling terminal
217 * and revoke access to controlling terminal.
218 */
219 if (sp->s_ttyp->t_session == sp) {
220 if (sp->s_ttyp->t_pgrp)
221 pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1);
222 (void) ttywait(sp->s_ttyp);
223 /*
224 * The tty could have been revoked
225 * if we blocked.
226 */
227 if (sp->s_ttyvp)
228 VOP_REVOKE(sp->s_ttyvp, REVOKEALL);
229 }
230 if (sp->s_ttyvp)
231 vrele(sp->s_ttyvp);
232 sp->s_ttyvp = NULL;
233 /*
234 * s_ttyp is not zero'd; we use this to indicate
235 * that the session once had a controlling terminal.
236 * (for logging and informational purposes)
237 */
238 }
239 sp->s_leader = NULL;
240 }
241 fixjobc(p, p->p_pgrp, 0);
242 p->p_rlimit[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
243 (void)acct_process(p);
244 #ifdef KTRACE
245 /*
246 * release trace file
247 */
248 ktrderef(p);
249 #endif
250 /*
251 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP!
252 */
253 p->p_stat = SDEAD;
254
255 /*
256 * Remove proc from pidhash chain so looking it up won't
257 * work. Move it from allproc to zombproc, but do not yet
258 * wake up the reaper. We will put the proc on the
259 * deadproc list later (using the p_hash member), and
260 * wake up the reaper when we do.
261 */
262 s = proclist_lock_write();
263 LIST_REMOVE(p, p_hash);
264 LIST_REMOVE(p, p_list);
265 LIST_INSERT_HEAD(&zombproc, p, p_list);
266 proclist_unlock_write(s);
267
268 /*
269 * Give orphaned children to init(8).
270 */
271 q = p->p_children.lh_first;
272 if (q) /* only need this if any child is S_ZOMB */
273 wakeup((caddr_t)initproc);
274 for (; q != 0; q = nq) {
275 nq = q->p_sibling.le_next;
276 proc_reparent(q, initproc);
277 /*
278 * Traced processes are killed
279 * since their existence means someone is screwing up.
280 */
281 if (q->p_flag & P_TRACED) {
282 q->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE);
283 psignal(q, SIGKILL);
284 }
285 }
286
287 /*
288 * Save exit status and final rusage info, adding in child rusage
289 * info and self times.
290 */
291 p->p_xstat = rv;
292 *p->p_ru = p->p_stats->p_ru;
293 calcru(p, &p->p_ru->ru_utime, &p->p_ru->ru_stime, NULL);
294 ruadd(p->p_ru, &p->p_stats->p_cru);
295
296 /*
297 * Notify parent that we're gone. If parent has the P_NOCLDWAIT
298 * flag set, notify init instead (and hope it will handle
299 * this situation).
300 */
301 if (p->p_pptr->p_flag & P_NOCLDWAIT) {
302 struct proc *pp = p->p_pptr;
303 proc_reparent(p, initproc);
304 /*
305 * If this was the last child of our parent, notify
306 * parent, so in case he was wait(2)ing, he will
307 * continue.
308 */
309 if (pp->p_children.lh_first == NULL)
310 wakeup((caddr_t)pp);
311 }
312
313 /*
314 * Release the process's signal state.
315 */
316 sigactsfree(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
331 /*
332 * Finally, call machine-dependent code to switch to a new
333 * context (possibly the idle context). Once we are no longer
334 * using the dead process's vmspace and stack, exit2() will be
335 * called to schedule those resources to be released by the
336 * reaper thread.
337 *
338 * Note that cpu_exit() will end with a call equivalent to
339 * cpu_switch(), finishing our execution (pun intended).
340 */
341 cpu_exit(p);
342 }
343
344 /*
345 * We are called from cpu_exit() once it is safe to schedule the
346 * dead process's resources to be freed.
347 *
348 * NOTE: One must be careful with locking in this routine. It's
349 * called from a critical section in machine-dependent code, so
350 * we should refrain from changing any interrupt state.
351 *
352 * We lock the deadproc list (a spin lock), place the proc on that
353 * list (using the p_hash member), and wake up the reaper.
354 */
355 void
356 exit2(p)
357 struct proc *p;
358 {
359
360 simple_lock(&deadproc_slock);
361 LIST_INSERT_HEAD(&deadproc, p, p_hash);
362 simple_unlock(&deadproc_slock);
363
364 wakeup(&deadproc);
365 }
366
367 /*
368 * Process reaper. This is run by a kernel thread to free the resources
369 * of a dead process. Once the resources are free, the process becomes
370 * a zombie, and the parent is allowed to read the undead's status.
371 */
372 void
373 reaper()
374 {
375 struct proc *p;
376
377 for (;;) {
378 simple_lock(&deadproc_slock);
379 p = LIST_FIRST(&deadproc);
380 if (p == NULL) {
381 /* No work for us; go to sleep until someone exits. */
382 simple_unlock(&deadproc_slock);
383 (void) tsleep(&deadproc, PVM, "reaper", 0);
384 continue;
385 }
386
387 /* Remove us from the deadproc list. */
388 LIST_REMOVE(p, p_hash);
389 simple_unlock(&deadproc_slock);
390
391 /*
392 * Give machine-dependent code a chance to free any
393 * resources it couldn't free while still running on
394 * that process's context. This must be done before
395 * uvm_exit(), in case these resources are in the PCB.
396 */
397 cpu_wait(p);
398
399 /*
400 * Free the VM resources we're still holding on to.
401 * We must do this from a valid thread because doing
402 * so may block.
403 */
404 uvm_exit(p);
405
406 /* Process is now a true zombie. */
407 p->p_stat = SZOMB;
408
409 /* Wake up the parent so it can get exit status. */
410 if ((p->p_flag & P_FSTRACE) == 0 && p->p_exitsig != 0)
411 psignal(p->p_pptr, P_EXITSIG(p));
412 wakeup((caddr_t)p->p_pptr);
413 }
414 }
415
416 int
417 sys_wait4(q, v, retval)
418 register struct proc *q;
419 void *v;
420 register_t *retval;
421 {
422 register struct sys_wait4_args /* {
423 syscallarg(int) pid;
424 syscallarg(int *) status;
425 syscallarg(int) options;
426 syscallarg(struct rusage *) rusage;
427 } */ *uap = v;
428 register int nfound;
429 register struct proc *p, *t;
430 int status, error, s;
431
432 if (SCARG(uap, pid) == 0)
433 SCARG(uap, pid) = -q->p_pgid;
434 if (SCARG(uap, options) &~ (WUNTRACED|WNOHANG|WALTSIG))
435 return (EINVAL);
436
437 loop:
438 nfound = 0;
439 for (p = q->p_children.lh_first; p != 0; p = p->p_sibling.le_next) {
440 if (SCARG(uap, pid) != WAIT_ANY &&
441 p->p_pid != SCARG(uap, pid) &&
442 p->p_pgid != -SCARG(uap, pid))
443 continue;
444 /*
445 * Wait for processes with p_exitsig != SIGCHLD processes only
446 * if WALTSIG is set; wait for processes with p_exitsig ==
447 * SIGCHLD only if WALTSIG is clear.
448 */
449 if ((SCARG(uap, options) & WALTSIG) ?
450 (p->p_exitsig == SIGCHLD) : (P_EXITSIG(p) != SIGCHLD))
451 continue;
452
453 nfound++;
454 if (p->p_stat == SZOMB) {
455 retval[0] = p->p_pid;
456
457 if (SCARG(uap, status)) {
458 status = p->p_xstat; /* convert to int */
459 error = copyout((caddr_t)&status,
460 (caddr_t)SCARG(uap, status),
461 sizeof(status));
462 if (error)
463 return (error);
464 }
465 if (SCARG(uap, rusage) &&
466 (error = copyout((caddr_t)p->p_ru,
467 (caddr_t)SCARG(uap, rusage),
468 sizeof(struct rusage))))
469 return (error);
470 /*
471 * If we got the child via ptrace(2) or procfs, and
472 * the parent is different (meaning the process was
473 * attached, rather than run as a child), then we need
474 * to give it back to the old parent, and send the
475 * parent the exit signal. The rest of the cleanup
476 * will be done when the old parent waits on the child.
477 */
478 if ((p->p_flag & P_TRACED) &&
479 p->p_oppid != p->p_pptr->p_pid) {
480 t = pfind(p->p_oppid);
481 proc_reparent(p, t ? t : initproc);
482 p->p_oppid = 0;
483 p->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE);
484 if (p->p_exitsig != 0)
485 psignal(p->p_pptr, P_EXITSIG(p));
486 wakeup((caddr_t)p->p_pptr);
487 return (0);
488 }
489 scheduler_wait_hook(curproc, p);
490 p->p_xstat = 0;
491 ruadd(&q->p_stats->p_cru, p->p_ru);
492 pool_put(&rusage_pool, p->p_ru);
493
494 /*
495 * Finally finished with old proc entry.
496 * Unlink it from its process group and free it.
497 */
498 leavepgrp(p);
499
500 s = proclist_lock_write();
501 LIST_REMOVE(p, p_list); /* off zombproc */
502 proclist_unlock_write(s);
503
504 LIST_REMOVE(p, p_sibling);
505
506 /*
507 * Decrement the count of procs running with this uid.
508 */
509 (void)chgproccnt(p->p_cred->p_ruid, -1);
510
511 /*
512 * Free up credentials.
513 */
514 if (--p->p_cred->p_refcnt == 0) {
515 crfree(p->p_cred->pc_ucred);
516 pool_put(&pcred_pool, p->p_cred);
517 }
518
519 /*
520 * Release reference to text vnode
521 */
522 if (p->p_textvp)
523 vrele(p->p_textvp);
524
525 pool_put(&proc_pool, p);
526 nprocs--;
527 return (0);
528 }
529 if (p->p_stat == SSTOP && (p->p_flag & P_WAITED) == 0 &&
530 (p->p_flag & P_TRACED || SCARG(uap, options) & WUNTRACED)) {
531 p->p_flag |= P_WAITED;
532 retval[0] = p->p_pid;
533
534 if (SCARG(uap, status)) {
535 status = W_STOPCODE(p->p_xstat);
536 error = copyout((caddr_t)&status,
537 (caddr_t)SCARG(uap, status),
538 sizeof(status));
539 } else
540 error = 0;
541 return (error);
542 }
543 }
544 if (nfound == 0)
545 return (ECHILD);
546 if (SCARG(uap, options) & WNOHANG) {
547 retval[0] = 0;
548 return (0);
549 }
550 if ((error = tsleep((caddr_t)q, PWAIT | PCATCH, "wait", 0)) != 0)
551 return (error);
552 goto loop;
553 }
554
555 /*
556 * make process 'parent' the new parent of process 'child'.
557 */
558 void
559 proc_reparent(child, parent)
560 register struct proc *child;
561 register struct proc *parent;
562 {
563
564 if (child->p_pptr == parent)
565 return;
566
567 if (parent == initproc)
568 child->p_exitsig = SIGCHLD;
569
570 LIST_REMOVE(child, p_sibling);
571 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
572 child->p_pptr = parent;
573 }
574