Home | History | Annotate | Line # | Download | only in kern
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