xref: /onnv-gate/usr/src/uts/common/os/exit.c (revision 9393)
10Sstevel@tonic-gate /*
20Sstevel@tonic-gate  * CDDL HEADER START
30Sstevel@tonic-gate  *
40Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
52267Sdp  * Common Development and Distribution License (the "License").
62267Sdp  * You may not use this file except in compliance with the License.
70Sstevel@tonic-gate  *
80Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
90Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
100Sstevel@tonic-gate  * See the License for the specific language governing permissions
110Sstevel@tonic-gate  * and limitations under the License.
120Sstevel@tonic-gate  *
130Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
140Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
150Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
160Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
170Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
180Sstevel@tonic-gate  *
190Sstevel@tonic-gate  * CDDL HEADER END
200Sstevel@tonic-gate  */
21390Sraf 
220Sstevel@tonic-gate /*
23*9393SRoger.Faulkner@Sun.COM  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
240Sstevel@tonic-gate  * Use is subject to license terms.
250Sstevel@tonic-gate  */
260Sstevel@tonic-gate 
270Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
280Sstevel@tonic-gate 
290Sstevel@tonic-gate #include <sys/types.h>
300Sstevel@tonic-gate #include <sys/param.h>
310Sstevel@tonic-gate #include <sys/sysmacros.h>
320Sstevel@tonic-gate #include <sys/systm.h>
330Sstevel@tonic-gate #include <sys/cred.h>
340Sstevel@tonic-gate #include <sys/user.h>
350Sstevel@tonic-gate #include <sys/errno.h>
360Sstevel@tonic-gate #include <sys/proc.h>
370Sstevel@tonic-gate #include <sys/ucontext.h>
380Sstevel@tonic-gate #include <sys/procfs.h>
390Sstevel@tonic-gate #include <sys/vnode.h>
400Sstevel@tonic-gate #include <sys/acct.h>
410Sstevel@tonic-gate #include <sys/var.h>
420Sstevel@tonic-gate #include <sys/cmn_err.h>
430Sstevel@tonic-gate #include <sys/debug.h>
440Sstevel@tonic-gate #include <sys/wait.h>
450Sstevel@tonic-gate #include <sys/siginfo.h>
460Sstevel@tonic-gate #include <sys/procset.h>
470Sstevel@tonic-gate #include <sys/class.h>
480Sstevel@tonic-gate #include <sys/file.h>
490Sstevel@tonic-gate #include <sys/session.h>
500Sstevel@tonic-gate #include <sys/kmem.h>
510Sstevel@tonic-gate #include <sys/vtrace.h>
520Sstevel@tonic-gate #include <sys/prsystm.h>
530Sstevel@tonic-gate #include <sys/ipc.h>
540Sstevel@tonic-gate #include <sys/sem_impl.h>
550Sstevel@tonic-gate #include <c2/audit.h>
560Sstevel@tonic-gate #include <sys/aio_impl.h>
570Sstevel@tonic-gate #include <vm/as.h>
580Sstevel@tonic-gate #include <sys/poll.h>
590Sstevel@tonic-gate #include <sys/door.h>
600Sstevel@tonic-gate #include <sys/lwpchan_impl.h>
610Sstevel@tonic-gate #include <sys/utrap.h>
620Sstevel@tonic-gate #include <sys/task.h>
630Sstevel@tonic-gate #include <sys/exacct.h>
640Sstevel@tonic-gate #include <sys/cyclic.h>
650Sstevel@tonic-gate #include <sys/schedctl.h>
660Sstevel@tonic-gate #include <sys/rctl.h>
670Sstevel@tonic-gate #include <sys/contract_impl.h>
680Sstevel@tonic-gate #include <sys/contract/process_impl.h>
690Sstevel@tonic-gate #include <sys/list.h>
700Sstevel@tonic-gate #include <sys/dtrace.h>
710Sstevel@tonic-gate #include <sys/pool.h>
720Sstevel@tonic-gate #include <sys/sdt.h>
730Sstevel@tonic-gate #include <sys/corectl.h>
742712Snn35248 #include <sys/brand.h>
753086Sraf #include <sys/libc_kernel.h>
760Sstevel@tonic-gate 
770Sstevel@tonic-gate /*
780Sstevel@tonic-gate  * convert code/data pair into old style wait status
790Sstevel@tonic-gate  */
800Sstevel@tonic-gate int
810Sstevel@tonic-gate wstat(int code, int data)
820Sstevel@tonic-gate {
830Sstevel@tonic-gate 	int stat = (data & 0377);
840Sstevel@tonic-gate 
850Sstevel@tonic-gate 	switch (code) {
860Sstevel@tonic-gate 	case CLD_EXITED:
870Sstevel@tonic-gate 		stat <<= 8;
880Sstevel@tonic-gate 		break;
890Sstevel@tonic-gate 	case CLD_DUMPED:
900Sstevel@tonic-gate 		stat |= WCOREFLG;
910Sstevel@tonic-gate 		break;
920Sstevel@tonic-gate 	case CLD_KILLED:
930Sstevel@tonic-gate 		break;
940Sstevel@tonic-gate 	case CLD_TRAPPED:
950Sstevel@tonic-gate 	case CLD_STOPPED:
960Sstevel@tonic-gate 		stat <<= 8;
970Sstevel@tonic-gate 		stat |= WSTOPFLG;
980Sstevel@tonic-gate 		break;
990Sstevel@tonic-gate 	case CLD_CONTINUED:
1000Sstevel@tonic-gate 		stat = WCONTFLG;
1010Sstevel@tonic-gate 		break;
1020Sstevel@tonic-gate 	default:
1030Sstevel@tonic-gate 		cmn_err(CE_PANIC, "wstat: bad code");
1040Sstevel@tonic-gate 		/* NOTREACHED */
1050Sstevel@tonic-gate 	}
1060Sstevel@tonic-gate 	return (stat);
1070Sstevel@tonic-gate }
1080Sstevel@tonic-gate 
1090Sstevel@tonic-gate static char *
1100Sstevel@tonic-gate exit_reason(char *buf, size_t bufsz, int what, int why)
1110Sstevel@tonic-gate {
1120Sstevel@tonic-gate 	switch (why) {
1130Sstevel@tonic-gate 	case CLD_EXITED:
1140Sstevel@tonic-gate 		(void) snprintf(buf, bufsz, "exited with status %d", what);
1150Sstevel@tonic-gate 		break;
1160Sstevel@tonic-gate 	case CLD_KILLED:
1170Sstevel@tonic-gate 		(void) snprintf(buf, bufsz, "exited on fatal signal %d", what);
1180Sstevel@tonic-gate 		break;
1190Sstevel@tonic-gate 	case CLD_DUMPED:
1200Sstevel@tonic-gate 		(void) snprintf(buf, bufsz, "core dumped on signal %d", what);
1210Sstevel@tonic-gate 		break;
1220Sstevel@tonic-gate 	default:
1230Sstevel@tonic-gate 		(void) snprintf(buf, bufsz, "encountered unknown error "
1240Sstevel@tonic-gate 		    "(%d, %d)", why, what);
1250Sstevel@tonic-gate 		break;
1260Sstevel@tonic-gate 	}
1270Sstevel@tonic-gate 
1280Sstevel@tonic-gate 	return (buf);
1290Sstevel@tonic-gate }
1300Sstevel@tonic-gate 
1310Sstevel@tonic-gate /*
1320Sstevel@tonic-gate  * exit system call: pass back caller's arg.
1330Sstevel@tonic-gate  */
1340Sstevel@tonic-gate void
1350Sstevel@tonic-gate rexit(int rval)
1360Sstevel@tonic-gate {
1370Sstevel@tonic-gate 	exit(CLD_EXITED, rval);
1380Sstevel@tonic-gate }
1390Sstevel@tonic-gate 
1400Sstevel@tonic-gate /*
1410Sstevel@tonic-gate  * Called by proc_exit() when a zone's init exits, presumably because
1420Sstevel@tonic-gate  * it failed.  As long as the given zone is still in the "running"
1430Sstevel@tonic-gate  * state, we will re-exec() init, but first we need to reset things
1440Sstevel@tonic-gate  * which are usually inherited across exec() but will break init's
1450Sstevel@tonic-gate  * assumption that it is being exec()'d from a virgin process.  Most
1460Sstevel@tonic-gate  * importantly this includes closing all file descriptors (exec only
1470Sstevel@tonic-gate  * closes those marked close-on-exec) and resetting signals (exec only
1480Sstevel@tonic-gate  * resets handled signals, and we need to clear any signals which
1490Sstevel@tonic-gate  * killed init).  Anything else that exec(2) says would be inherited,
1500Sstevel@tonic-gate  * but would affect the execution of init, needs to be reset.
1510Sstevel@tonic-gate  */
1520Sstevel@tonic-gate static int
1530Sstevel@tonic-gate restart_init(int what, int why)
1540Sstevel@tonic-gate {
1550Sstevel@tonic-gate 	kthread_t *t = curthread;
1560Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
1570Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
1580Sstevel@tonic-gate 	user_t *up = PTOU(p);
1590Sstevel@tonic-gate 
1600Sstevel@tonic-gate 	vnode_t *oldcd, *oldrd;
1610Sstevel@tonic-gate 	int i, err;
1620Sstevel@tonic-gate 	char reason_buf[64];
1630Sstevel@tonic-gate 
1640Sstevel@tonic-gate 	/*
1650Sstevel@tonic-gate 	 * Let zone admin (and global zone admin if this is for a non-global
1660Sstevel@tonic-gate 	 * zone) know that init has failed and will be restarted.
1670Sstevel@tonic-gate 	 */
1680Sstevel@tonic-gate 	zcmn_err(p->p_zone->zone_id, CE_WARN,
1690Sstevel@tonic-gate 	    "init(1M) %s: restarting automatically",
1700Sstevel@tonic-gate 	    exit_reason(reason_buf, sizeof (reason_buf), what, why));
1710Sstevel@tonic-gate 
1720Sstevel@tonic-gate 	if (!INGLOBALZONE(p)) {
1730Sstevel@tonic-gate 		cmn_err(CE_WARN, "init(1M) for zone %s (pid %d) %s: "
1740Sstevel@tonic-gate 		    "restarting automatically",
1750Sstevel@tonic-gate 		    p->p_zone->zone_name, p->p_pid, reason_buf);
1760Sstevel@tonic-gate 	}
1770Sstevel@tonic-gate 
1780Sstevel@tonic-gate 	/*
1790Sstevel@tonic-gate 	 * Remove any fpollinfo_t's for this (last) thread from our file
1800Sstevel@tonic-gate 	 * descriptors so closeall() can ASSERT() that they're all gone.
1810Sstevel@tonic-gate 	 * Then close all open file descriptors in the process.
1820Sstevel@tonic-gate 	 */
1830Sstevel@tonic-gate 	pollcleanup();
1840Sstevel@tonic-gate 	closeall(P_FINFO(p));
1850Sstevel@tonic-gate 
1860Sstevel@tonic-gate 	/*
1870Sstevel@tonic-gate 	 * Grab p_lock and begin clearing miscellaneous global process
1880Sstevel@tonic-gate 	 * state that needs to be reset before we exec the new init(1M).
1890Sstevel@tonic-gate 	 */
1900Sstevel@tonic-gate 
1910Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
192390Sraf 	prbarrier(p);
1930Sstevel@tonic-gate 
194390Sraf 	p->p_flag &= ~(SKILLED | SEXTKILLED | SEXITING | SDOCORE);
1950Sstevel@tonic-gate 	up->u_cmask = CMASK;
1960Sstevel@tonic-gate 
1970Sstevel@tonic-gate 	sigemptyset(&t->t_hold);
1980Sstevel@tonic-gate 	sigemptyset(&t->t_sig);
1990Sstevel@tonic-gate 	sigemptyset(&t->t_extsig);
2000Sstevel@tonic-gate 
2010Sstevel@tonic-gate 	sigemptyset(&p->p_sig);
2020Sstevel@tonic-gate 	sigemptyset(&p->p_extsig);
2030Sstevel@tonic-gate 
2040Sstevel@tonic-gate 	sigdelq(p, t, 0);
2050Sstevel@tonic-gate 	sigdelq(p, NULL, 0);
2060Sstevel@tonic-gate 
2070Sstevel@tonic-gate 	if (p->p_killsqp) {
2080Sstevel@tonic-gate 		siginfofree(p->p_killsqp);
2090Sstevel@tonic-gate 		p->p_killsqp = NULL;
2100Sstevel@tonic-gate 	}
2110Sstevel@tonic-gate 
2120Sstevel@tonic-gate 	/*
2130Sstevel@tonic-gate 	 * Reset any signals that are ignored back to the default disposition.
2140Sstevel@tonic-gate 	 * Other u_signal members will be cleared when exec calls sigdefault().
2150Sstevel@tonic-gate 	 */
2160Sstevel@tonic-gate 	for (i = 1; i < NSIG; i++) {
2170Sstevel@tonic-gate 		if (up->u_signal[i - 1] == SIG_IGN) {
2180Sstevel@tonic-gate 			up->u_signal[i - 1] = SIG_DFL;
2190Sstevel@tonic-gate 			sigemptyset(&up->u_sigmask[i - 1]);
2200Sstevel@tonic-gate 		}
2210Sstevel@tonic-gate 	}
2220Sstevel@tonic-gate 
2230Sstevel@tonic-gate 	/*
2240Sstevel@tonic-gate 	 * Clear the current signal, any signal info associated with it, and
2250Sstevel@tonic-gate 	 * any signal information from contracts and/or contract templates.
2260Sstevel@tonic-gate 	 */
2270Sstevel@tonic-gate 	lwp->lwp_cursig = 0;
2280Sstevel@tonic-gate 	lwp->lwp_extsig = 0;
2290Sstevel@tonic-gate 	if (lwp->lwp_curinfo != NULL) {
2300Sstevel@tonic-gate 		siginfofree(lwp->lwp_curinfo);
2310Sstevel@tonic-gate 		lwp->lwp_curinfo = NULL;
2320Sstevel@tonic-gate 	}
2330Sstevel@tonic-gate 	lwp_ctmpl_clear(lwp);
2340Sstevel@tonic-gate 
2350Sstevel@tonic-gate 	/*
2360Sstevel@tonic-gate 	 * Reset both the process root directory and the current working
2370Sstevel@tonic-gate 	 * directory to the root of the zone just as we do during boot.
2380Sstevel@tonic-gate 	 */
2390Sstevel@tonic-gate 	VN_HOLD(p->p_zone->zone_rootvp);
2400Sstevel@tonic-gate 	oldrd = up->u_rdir;
2410Sstevel@tonic-gate 	up->u_rdir = p->p_zone->zone_rootvp;
2420Sstevel@tonic-gate 
2430Sstevel@tonic-gate 	VN_HOLD(p->p_zone->zone_rootvp);
2440Sstevel@tonic-gate 	oldcd = up->u_cdir;
2450Sstevel@tonic-gate 	up->u_cdir = p->p_zone->zone_rootvp;
2460Sstevel@tonic-gate 
2470Sstevel@tonic-gate 	if (up->u_cwd != NULL) {
2480Sstevel@tonic-gate 		refstr_rele(up->u_cwd);
2490Sstevel@tonic-gate 		up->u_cwd = NULL;
2500Sstevel@tonic-gate 	}
2510Sstevel@tonic-gate 
2520Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
2530Sstevel@tonic-gate 
2540Sstevel@tonic-gate 	if (oldrd != NULL)
2550Sstevel@tonic-gate 		VN_RELE(oldrd);
2560Sstevel@tonic-gate 	if (oldcd != NULL)
2570Sstevel@tonic-gate 		VN_RELE(oldcd);
2580Sstevel@tonic-gate 
2592712Snn35248 	/* Free the controlling tty.  (freectty() always assumes curproc.) */
2602712Snn35248 	ASSERT(p == curproc);
2612712Snn35248 	(void) freectty(B_TRUE);
2620Sstevel@tonic-gate 
2630Sstevel@tonic-gate 	/*
2640Sstevel@tonic-gate 	 * Now exec() the new init(1M) on top of the current process.  If we
2650Sstevel@tonic-gate 	 * succeed, the caller will treat this like a successful system call.
2660Sstevel@tonic-gate 	 * If we fail, we issue messages and the caller will proceed with exit.
2670Sstevel@tonic-gate 	 */
2682267Sdp 	err = exec_init(p->p_zone->zone_initname, NULL);
2690Sstevel@tonic-gate 
2700Sstevel@tonic-gate 	if (err == 0)
2710Sstevel@tonic-gate 		return (0);
2720Sstevel@tonic-gate 
2730Sstevel@tonic-gate 	zcmn_err(p->p_zone->zone_id, CE_WARN,
2740Sstevel@tonic-gate 	    "failed to restart init(1M) (err=%d): system reboot required", err);
2750Sstevel@tonic-gate 
2760Sstevel@tonic-gate 	if (!INGLOBALZONE(p)) {
2770Sstevel@tonic-gate 		cmn_err(CE_WARN, "failed to restart init(1M) for zone %s "
2780Sstevel@tonic-gate 		    "(pid %d, err=%d): zoneadm(1M) boot required",
2790Sstevel@tonic-gate 		    p->p_zone->zone_name, p->p_pid, err);
2800Sstevel@tonic-gate 	}
2810Sstevel@tonic-gate 
2820Sstevel@tonic-gate 	return (-1);
2830Sstevel@tonic-gate }
2840Sstevel@tonic-gate 
2850Sstevel@tonic-gate /*
2860Sstevel@tonic-gate  * Release resources.
2870Sstevel@tonic-gate  * Enter zombie state.
2880Sstevel@tonic-gate  * Wake up parent and init processes,
2890Sstevel@tonic-gate  * and dispose of children.
2900Sstevel@tonic-gate  */
2910Sstevel@tonic-gate void
2920Sstevel@tonic-gate exit(int why, int what)
2930Sstevel@tonic-gate {
2940Sstevel@tonic-gate 	/*
2950Sstevel@tonic-gate 	 * If proc_exit() fails, then some other lwp in the process
2960Sstevel@tonic-gate 	 * got there first.  We just have to call lwp_exit() to allow
2970Sstevel@tonic-gate 	 * the other lwp to finish exiting the process.  Otherwise we're
2980Sstevel@tonic-gate 	 * restarting init, and should return.
2990Sstevel@tonic-gate 	 */
3000Sstevel@tonic-gate 	if (proc_exit(why, what) != 0) {
3010Sstevel@tonic-gate 		mutex_enter(&curproc->p_lock);
3020Sstevel@tonic-gate 		ASSERT(curproc->p_flag & SEXITLWPS);
3030Sstevel@tonic-gate 		lwp_exit();
3040Sstevel@tonic-gate 		/* NOTREACHED */
3050Sstevel@tonic-gate 	}
3060Sstevel@tonic-gate }
3070Sstevel@tonic-gate 
3080Sstevel@tonic-gate /*
309390Sraf  * Set the SEXITING flag on the process, after making sure /proc does
310390Sraf  * not have it locked.  This is done in more places than proc_exit(),
311390Sraf  * so it is a separate function.
312390Sraf  */
313390Sraf void
314390Sraf proc_is_exiting(proc_t *p)
315390Sraf {
316390Sraf 	mutex_enter(&p->p_lock);
317390Sraf 	prbarrier(p);
318390Sraf 	p->p_flag |= SEXITING;
319390Sraf 	mutex_exit(&p->p_lock);
320390Sraf }
321390Sraf 
322390Sraf /*
3230Sstevel@tonic-gate  * Return value:
3240Sstevel@tonic-gate  *   1 - exitlwps() failed, call (or continue) lwp_exit()
3250Sstevel@tonic-gate  *   0 - restarting init.  Return through system call path
3260Sstevel@tonic-gate  */
3270Sstevel@tonic-gate int
3280Sstevel@tonic-gate proc_exit(int why, int what)
3290Sstevel@tonic-gate {
3300Sstevel@tonic-gate 	kthread_t *t = curthread;
3310Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
3320Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
3330Sstevel@tonic-gate 	zone_t *z = p->p_zone;
3340Sstevel@tonic-gate 	timeout_id_t tmp_id;
3350Sstevel@tonic-gate 	int rv;
3360Sstevel@tonic-gate 	proc_t *q;
3370Sstevel@tonic-gate 	task_t *tk;
3380Sstevel@tonic-gate 	vnode_t *exec_vp, *execdir_vp, *cdir, *rdir;
3390Sstevel@tonic-gate 	sigqueue_t *sqp;
3400Sstevel@tonic-gate 	lwpdir_t *lwpdir;
3410Sstevel@tonic-gate 	uint_t lwpdir_sz;
342*9393SRoger.Faulkner@Sun.COM 	tidhash_t *tidhash;
3430Sstevel@tonic-gate 	uint_t tidhash_sz;
344*9393SRoger.Faulkner@Sun.COM 	ret_tidhash_t *ret_tidhash;
3450Sstevel@tonic-gate 	refstr_t *cwd;
3460Sstevel@tonic-gate 	hrtime_t hrutime, hrstime;
3473086Sraf 	int evaporate;
3480Sstevel@tonic-gate 
3490Sstevel@tonic-gate 	/*
3500Sstevel@tonic-gate 	 * Stop and discard the process's lwps except for the current one,
3510Sstevel@tonic-gate 	 * unless some other lwp beat us to it.  If exitlwps() fails then
3520Sstevel@tonic-gate 	 * return and the calling lwp will call (or continue in) lwp_exit().
3530Sstevel@tonic-gate 	 */
354390Sraf 	proc_is_exiting(p);
3550Sstevel@tonic-gate 	if (exitlwps(0) != 0)
3560Sstevel@tonic-gate 		return (1);
3570Sstevel@tonic-gate 
3585788Smv143129 	mutex_enter(&p->p_lock);
3595788Smv143129 	if (p->p_ttime > 0) {
3605788Smv143129 		/*
3615788Smv143129 		 * Account any remaining ticks charged to this process
3625788Smv143129 		 * on its way out.
3635788Smv143129 		 */
3645788Smv143129 		(void) task_cpu_time_incr(p->p_task, p->p_ttime);
3655788Smv143129 		p->p_ttime = 0;
3665788Smv143129 	}
3675788Smv143129 	mutex_exit(&p->p_lock);
3685788Smv143129 
3690Sstevel@tonic-gate 	DTRACE_PROC(lwp__exit);
3700Sstevel@tonic-gate 	DTRACE_PROC1(exit, int, why);
3710Sstevel@tonic-gate 
3720Sstevel@tonic-gate 	/*
3732712Snn35248 	 * Will perform any brand specific proc exit processing, since this
3742712Snn35248 	 * is always the last lwp, will also perform lwp_exit and free brand
3752712Snn35248 	 * data
3762712Snn35248 	 */
3776994Sedp 	if (PROC_IS_BRANDED(p)) {
3786994Sedp 		lwp_detach_brand_hdlrs(lwp);
3796994Sedp 		brand_clearbrand(p);
3806994Sedp 	}
3812712Snn35248 
3822712Snn35248 	/*
3832267Sdp 	 * Don't let init exit unless zone_start_init() failed its exec, or
3840Sstevel@tonic-gate 	 * we are shutting down the zone or the machine.
3850Sstevel@tonic-gate 	 *
3860Sstevel@tonic-gate 	 * Since we are single threaded, we don't need to lock the
3870Sstevel@tonic-gate 	 * following accesses to zone_proc_initpid.
3880Sstevel@tonic-gate 	 */
3890Sstevel@tonic-gate 	if (p->p_pid == z->zone_proc_initpid) {
3900Sstevel@tonic-gate 		if (z->zone_boot_err == 0 &&
3910Sstevel@tonic-gate 		    zone_status_get(z) < ZONE_IS_SHUTTING_DOWN &&
3920Sstevel@tonic-gate 		    zone_status_get(global_zone) < ZONE_IS_SHUTTING_DOWN &&
3932712Snn35248 		    z->zone_restart_init == B_TRUE &&
3940Sstevel@tonic-gate 		    restart_init(what, why) == 0)
3950Sstevel@tonic-gate 			return (0);
3960Sstevel@tonic-gate 		/*
3970Sstevel@tonic-gate 		 * Since we didn't or couldn't restart init, we clear
3980Sstevel@tonic-gate 		 * the zone's init state and proceed with exit
3990Sstevel@tonic-gate 		 * processing.
4000Sstevel@tonic-gate 		 */
4010Sstevel@tonic-gate 		z->zone_proc_initpid = -1;
4020Sstevel@tonic-gate 	}
4030Sstevel@tonic-gate 
4040Sstevel@tonic-gate 	/*
4050Sstevel@tonic-gate 	 * Allocate a sigqueue now, before we grab locks.
4060Sstevel@tonic-gate 	 * It will be given to sigcld(), below.
4073086Sraf 	 * Special case:  If we will be making the process disappear
4083086Sraf 	 * without a trace (for the benefit of posix_spawn() in libc)
4093086Sraf 	 * don't bother to allocate a useless sigqueue.
4100Sstevel@tonic-gate 	 */
4113086Sraf 	evaporate = ((p->p_flag & SVFORK) &&
4123086Sraf 	    why == CLD_EXITED && what == _EVAPORATE);
4133086Sraf 	if (!evaporate)
4143086Sraf 		sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
4150Sstevel@tonic-gate 
4160Sstevel@tonic-gate 	/*
4170Sstevel@tonic-gate 	 * revoke any doors created by the process.
4180Sstevel@tonic-gate 	 */
4190Sstevel@tonic-gate 	if (p->p_door_list)
4200Sstevel@tonic-gate 		door_exit();
4210Sstevel@tonic-gate 
4220Sstevel@tonic-gate 	/*
4230Sstevel@tonic-gate 	 * Release schedctl data structures.
4240Sstevel@tonic-gate 	 */
4250Sstevel@tonic-gate 	if (p->p_pagep)
4260Sstevel@tonic-gate 		schedctl_proc_cleanup();
4270Sstevel@tonic-gate 
4280Sstevel@tonic-gate 	/*
4290Sstevel@tonic-gate 	 * make sure all pending kaio has completed.
4300Sstevel@tonic-gate 	 */
4310Sstevel@tonic-gate 	if (p->p_aio)
4320Sstevel@tonic-gate 		aio_cleanup_exit();
4330Sstevel@tonic-gate 
4340Sstevel@tonic-gate 	/*
4350Sstevel@tonic-gate 	 * discard the lwpchan cache.
4360Sstevel@tonic-gate 	 */
4370Sstevel@tonic-gate 	if (p->p_lcp != NULL)
4380Sstevel@tonic-gate 		lwpchan_destroy_cache(0);
4390Sstevel@tonic-gate 
4400Sstevel@tonic-gate 	/*
4410Sstevel@tonic-gate 	 * Clean up any DTrace helper actions or probes for the process.
4420Sstevel@tonic-gate 	 */
4430Sstevel@tonic-gate 	if (p->p_dtrace_helpers != NULL) {
4440Sstevel@tonic-gate 		ASSERT(dtrace_helpers_cleanup != NULL);
4450Sstevel@tonic-gate 		(*dtrace_helpers_cleanup)();
4460Sstevel@tonic-gate 	}
4470Sstevel@tonic-gate 
4480Sstevel@tonic-gate 	/* untimeout the realtime timers */
4490Sstevel@tonic-gate 	if (p->p_itimer != NULL)
4500Sstevel@tonic-gate 		timer_exit();
4510Sstevel@tonic-gate 
4520Sstevel@tonic-gate 	if ((tmp_id = p->p_alarmid) != 0) {
4530Sstevel@tonic-gate 		p->p_alarmid = 0;
4540Sstevel@tonic-gate 		(void) untimeout(tmp_id);
4550Sstevel@tonic-gate 	}
4560Sstevel@tonic-gate 
4570Sstevel@tonic-gate 	/*
4580Sstevel@tonic-gate 	 * Remove any fpollinfo_t's for this (last) thread from our file
4590Sstevel@tonic-gate 	 * descriptors so closeall() can ASSERT() that they're all gone.
4600Sstevel@tonic-gate 	 */
4610Sstevel@tonic-gate 	pollcleanup();
4620Sstevel@tonic-gate 
4630Sstevel@tonic-gate 	if (p->p_rprof_cyclic != CYCLIC_NONE) {
4640Sstevel@tonic-gate 		mutex_enter(&cpu_lock);
4650Sstevel@tonic-gate 		cyclic_remove(p->p_rprof_cyclic);
4660Sstevel@tonic-gate 		mutex_exit(&cpu_lock);
4670Sstevel@tonic-gate 	}
4680Sstevel@tonic-gate 
4690Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
4700Sstevel@tonic-gate 
4710Sstevel@tonic-gate 	/*
4720Sstevel@tonic-gate 	 * Clean up any DTrace probes associated with this process.
4730Sstevel@tonic-gate 	 */
4740Sstevel@tonic-gate 	if (p->p_dtrace_probes) {
4750Sstevel@tonic-gate 		ASSERT(dtrace_fasttrap_exit_ptr != NULL);
4760Sstevel@tonic-gate 		dtrace_fasttrap_exit_ptr(p);
4770Sstevel@tonic-gate 	}
4780Sstevel@tonic-gate 
4790Sstevel@tonic-gate 	while ((tmp_id = p->p_itimerid) != 0) {
4800Sstevel@tonic-gate 		p->p_itimerid = 0;
4810Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
4820Sstevel@tonic-gate 		(void) untimeout(tmp_id);
4830Sstevel@tonic-gate 		mutex_enter(&p->p_lock);
4840Sstevel@tonic-gate 	}
4850Sstevel@tonic-gate 
4860Sstevel@tonic-gate 	lwp_cleanup();
4870Sstevel@tonic-gate 
4880Sstevel@tonic-gate 	/*
4890Sstevel@tonic-gate 	 * We are about to exit; prevent our resource associations from
4900Sstevel@tonic-gate 	 * being changed.
4910Sstevel@tonic-gate 	 */
4920Sstevel@tonic-gate 	pool_barrier_enter();
4930Sstevel@tonic-gate 
4940Sstevel@tonic-gate 	/*
4950Sstevel@tonic-gate 	 * Block the process against /proc now that we have really
4960Sstevel@tonic-gate 	 * acquired p->p_lock (to manipulate p_tlist at least).
4970Sstevel@tonic-gate 	 */
4980Sstevel@tonic-gate 	prbarrier(p);
4990Sstevel@tonic-gate 
5000Sstevel@tonic-gate #ifdef	SUN_SRC_COMPAT
5010Sstevel@tonic-gate 	if (code == CLD_KILLED)
5020Sstevel@tonic-gate 		u.u_acflag |= AXSIG;
5030Sstevel@tonic-gate #endif
5040Sstevel@tonic-gate 	sigfillset(&p->p_ignore);
5050Sstevel@tonic-gate 	sigemptyset(&p->p_siginfo);
5060Sstevel@tonic-gate 	sigemptyset(&p->p_sig);
5070Sstevel@tonic-gate 	sigemptyset(&p->p_extsig);
5080Sstevel@tonic-gate 	sigemptyset(&t->t_sig);
5090Sstevel@tonic-gate 	sigemptyset(&t->t_extsig);
5100Sstevel@tonic-gate 	sigemptyset(&p->p_sigmask);
5110Sstevel@tonic-gate 	sigdelq(p, t, 0);
5120Sstevel@tonic-gate 	lwp->lwp_cursig = 0;
5130Sstevel@tonic-gate 	lwp->lwp_extsig = 0;
5140Sstevel@tonic-gate 	p->p_flag &= ~(SKILLED | SEXTKILLED);
5150Sstevel@tonic-gate 	if (lwp->lwp_curinfo) {
5160Sstevel@tonic-gate 		siginfofree(lwp->lwp_curinfo);
5170Sstevel@tonic-gate 		lwp->lwp_curinfo = NULL;
5180Sstevel@tonic-gate 	}
5190Sstevel@tonic-gate 
5200Sstevel@tonic-gate 	t->t_proc_flag |= TP_LWPEXIT;
5210Sstevel@tonic-gate 	ASSERT(p->p_lwpcnt == 1 && p->p_zombcnt == 0);
5220Sstevel@tonic-gate 	prlwpexit(t);		/* notify /proc */
5230Sstevel@tonic-gate 	lwp_hash_out(p, t->t_tid);
5240Sstevel@tonic-gate 	prexit(p);
5250Sstevel@tonic-gate 
5260Sstevel@tonic-gate 	p->p_lwpcnt = 0;
5270Sstevel@tonic-gate 	p->p_tlist = NULL;
5280Sstevel@tonic-gate 	sigqfree(p);
5290Sstevel@tonic-gate 	term_mstate(t);
5300Sstevel@tonic-gate 	p->p_mterm = gethrtime();
5310Sstevel@tonic-gate 
5320Sstevel@tonic-gate 	exec_vp = p->p_exec;
5330Sstevel@tonic-gate 	execdir_vp = p->p_execdir;
5340Sstevel@tonic-gate 	p->p_exec = NULLVP;
5350Sstevel@tonic-gate 	p->p_execdir = NULLVP;
5360Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
5370Sstevel@tonic-gate 	if (exec_vp)
5380Sstevel@tonic-gate 		VN_RELE(exec_vp);
5390Sstevel@tonic-gate 	if (execdir_vp)
5400Sstevel@tonic-gate 		VN_RELE(execdir_vp);
5410Sstevel@tonic-gate 
5420Sstevel@tonic-gate 	pr_free_watched_pages(p);
5430Sstevel@tonic-gate 
5440Sstevel@tonic-gate 	closeall(P_FINFO(p));
5450Sstevel@tonic-gate 
5462712Snn35248 	/* Free the controlling tty.  (freectty() always assumes curproc.) */
5472712Snn35248 	ASSERT(p == curproc);
5482712Snn35248 	(void) freectty(B_TRUE);
5490Sstevel@tonic-gate 
5500Sstevel@tonic-gate #if defined(__sparc)
5510Sstevel@tonic-gate 	if (p->p_utraps != NULL)
5520Sstevel@tonic-gate 		utrap_free(p);
5530Sstevel@tonic-gate #endif
5540Sstevel@tonic-gate 	if (p->p_semacct)			/* IPC semaphore exit */
5550Sstevel@tonic-gate 		semexit(p);
5560Sstevel@tonic-gate 	rv = wstat(why, what);
5570Sstevel@tonic-gate 
5580Sstevel@tonic-gate 	acct(rv & 0xff);
5590Sstevel@tonic-gate 	exacct_commit_proc(p, rv);
5600Sstevel@tonic-gate 
5610Sstevel@tonic-gate 	/*
5620Sstevel@tonic-gate 	 * Release any resources associated with C2 auditing
5630Sstevel@tonic-gate 	 */
5640Sstevel@tonic-gate 	if (audit_active) {
5650Sstevel@tonic-gate 		/*
5660Sstevel@tonic-gate 		 * audit exit system call
5670Sstevel@tonic-gate 		 */
5680Sstevel@tonic-gate 		audit_exit(why, what);
5690Sstevel@tonic-gate 	}
5700Sstevel@tonic-gate 
5710Sstevel@tonic-gate 	/*
5720Sstevel@tonic-gate 	 * Free address space.
5730Sstevel@tonic-gate 	 */
5740Sstevel@tonic-gate 	relvm();
5750Sstevel@tonic-gate 
5760Sstevel@tonic-gate 	/*
5770Sstevel@tonic-gate 	 * Release held contracts.
5780Sstevel@tonic-gate 	 */
5790Sstevel@tonic-gate 	contract_exit(p);
5800Sstevel@tonic-gate 
5810Sstevel@tonic-gate 	/*
5820Sstevel@tonic-gate 	 * Depart our encapsulating process contract.
5830Sstevel@tonic-gate 	 */
5840Sstevel@tonic-gate 	if ((p->p_flag & SSYS) == 0) {
5850Sstevel@tonic-gate 		ASSERT(p->p_ct_process);
5860Sstevel@tonic-gate 		contract_process_exit(p->p_ct_process, p, rv);
5870Sstevel@tonic-gate 	}
5880Sstevel@tonic-gate 
5890Sstevel@tonic-gate 	/*
5900Sstevel@tonic-gate 	 * Remove pool association, and block if requested by pool_do_bind.
5910Sstevel@tonic-gate 	 */
5920Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
5930Sstevel@tonic-gate 	ASSERT(p->p_pool->pool_ref > 0);
5940Sstevel@tonic-gate 	atomic_add_32(&p->p_pool->pool_ref, -1);
5950Sstevel@tonic-gate 	p->p_pool = pool_default;
5960Sstevel@tonic-gate 	/*
5970Sstevel@tonic-gate 	 * Now that our address space has been freed and all other threads
5980Sstevel@tonic-gate 	 * in this process have exited, set the PEXITED pool flag.  This
5990Sstevel@tonic-gate 	 * tells the pools subsystems to ignore this process if it was
6000Sstevel@tonic-gate 	 * requested to rebind this process to a new pool.
6010Sstevel@tonic-gate 	 */
6020Sstevel@tonic-gate 	p->p_poolflag |= PEXITED;
6030Sstevel@tonic-gate 	pool_barrier_exit();
6040Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
6050Sstevel@tonic-gate 
6060Sstevel@tonic-gate 	mutex_enter(&pidlock);
6070Sstevel@tonic-gate 
6080Sstevel@tonic-gate 	/*
6090Sstevel@tonic-gate 	 * Delete this process from the newstate list of its parent. We
6100Sstevel@tonic-gate 	 * will put it in the right place in the sigcld in the end.
6110Sstevel@tonic-gate 	 */
6120Sstevel@tonic-gate 	delete_ns(p->p_parent, p);
6130Sstevel@tonic-gate 
6140Sstevel@tonic-gate 	/*
6150Sstevel@tonic-gate 	 * Reassign the orphans to the next of kin.
6160Sstevel@tonic-gate 	 * Don't rearrange init's orphanage.
6170Sstevel@tonic-gate 	 */
6180Sstevel@tonic-gate 	if ((q = p->p_orphan) != NULL && p != proc_init) {
6190Sstevel@tonic-gate 
6200Sstevel@tonic-gate 		proc_t *nokp = p->p_nextofkin;
6210Sstevel@tonic-gate 
6220Sstevel@tonic-gate 		for (;;) {
6230Sstevel@tonic-gate 			q->p_nextofkin = nokp;
6240Sstevel@tonic-gate 			if (q->p_nextorph == NULL)
6250Sstevel@tonic-gate 				break;
6260Sstevel@tonic-gate 			q = q->p_nextorph;
6270Sstevel@tonic-gate 		}
6280Sstevel@tonic-gate 		q->p_nextorph = nokp->p_orphan;
6290Sstevel@tonic-gate 		nokp->p_orphan = p->p_orphan;
6300Sstevel@tonic-gate 		p->p_orphan = NULL;
6310Sstevel@tonic-gate 	}
6320Sstevel@tonic-gate 
6330Sstevel@tonic-gate 	/*
6340Sstevel@tonic-gate 	 * Reassign the children to init.
6350Sstevel@tonic-gate 	 * Don't try to assign init's children to init.
6360Sstevel@tonic-gate 	 */
6370Sstevel@tonic-gate 	if ((q = p->p_child) != NULL && p != proc_init) {
6380Sstevel@tonic-gate 		struct proc	*np;
6390Sstevel@tonic-gate 		struct proc	*initp = proc_init;
6400Sstevel@tonic-gate 		boolean_t	setzonetop = B_FALSE;
6410Sstevel@tonic-gate 
6420Sstevel@tonic-gate 		if (!INGLOBALZONE(curproc))
6430Sstevel@tonic-gate 			setzonetop = B_TRUE;
6440Sstevel@tonic-gate 
6450Sstevel@tonic-gate 		pgdetach(p);
6460Sstevel@tonic-gate 
6470Sstevel@tonic-gate 		do {
6480Sstevel@tonic-gate 			np = q->p_sibling;
6490Sstevel@tonic-gate 			/*
6500Sstevel@tonic-gate 			 * Delete it from its current parent new state
6510Sstevel@tonic-gate 			 * list and add it to init new state list
6520Sstevel@tonic-gate 			 */
6530Sstevel@tonic-gate 			delete_ns(q->p_parent, q);
6540Sstevel@tonic-gate 
6550Sstevel@tonic-gate 			q->p_ppid = 1;
6563235Sraf 			q->p_pidflag &= ~(CLDNOSIGCHLD | CLDWAITPID);
6570Sstevel@tonic-gate 			if (setzonetop) {
6580Sstevel@tonic-gate 				mutex_enter(&q->p_lock);
6590Sstevel@tonic-gate 				q->p_flag |= SZONETOP;
6600Sstevel@tonic-gate 				mutex_exit(&q->p_lock);
6610Sstevel@tonic-gate 			}
6620Sstevel@tonic-gate 			q->p_parent = initp;
6630Sstevel@tonic-gate 
6640Sstevel@tonic-gate 			/*
6650Sstevel@tonic-gate 			 * Since q will be the first child,
6660Sstevel@tonic-gate 			 * it will not have a previous sibling.
6670Sstevel@tonic-gate 			 */
6680Sstevel@tonic-gate 			q->p_psibling = NULL;
6690Sstevel@tonic-gate 			if (initp->p_child) {
6700Sstevel@tonic-gate 				initp->p_child->p_psibling = q;
6710Sstevel@tonic-gate 			}
6720Sstevel@tonic-gate 			q->p_sibling = initp->p_child;
6730Sstevel@tonic-gate 			initp->p_child = q;
6740Sstevel@tonic-gate 			if (q->p_proc_flag & P_PR_PTRACE) {
6750Sstevel@tonic-gate 				mutex_enter(&q->p_lock);
6760Sstevel@tonic-gate 				sigtoproc(q, NULL, SIGKILL);
6770Sstevel@tonic-gate 				mutex_exit(&q->p_lock);
6780Sstevel@tonic-gate 			}
6790Sstevel@tonic-gate 			/*
6800Sstevel@tonic-gate 			 * sigcld() will add the child to parents
6810Sstevel@tonic-gate 			 * newstate list.
6820Sstevel@tonic-gate 			 */
6830Sstevel@tonic-gate 			if (q->p_stat == SZOMB)
6840Sstevel@tonic-gate 				sigcld(q, NULL);
6850Sstevel@tonic-gate 		} while ((q = np) != NULL);
6860Sstevel@tonic-gate 
6870Sstevel@tonic-gate 		p->p_child = NULL;
6880Sstevel@tonic-gate 		ASSERT(p->p_child_ns == NULL);
6890Sstevel@tonic-gate 	}
6900Sstevel@tonic-gate 
6910Sstevel@tonic-gate 	TRACE_1(TR_FAC_PROC, TR_PROC_EXIT, "proc_exit: %p", p);
6920Sstevel@tonic-gate 
6930Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
6940Sstevel@tonic-gate 	CL_EXIT(curthread); /* tell the scheduler that curthread is exiting */
6950Sstevel@tonic-gate 
6964584Srh87107 	/*
6974584Srh87107 	 * Have our task accummulate our resource usage data before they
6984584Srh87107 	 * become contaminated by p_cacct etc., and before we renounce
6994584Srh87107 	 * membership of the task.
7004584Srh87107 	 *
7014584Srh87107 	 * We do this regardless of whether or not task accounting is active.
7024584Srh87107 	 * This is to avoid having nonsense data reported for this task if
7034584Srh87107 	 * task accounting is subsequently enabled. The overhead is minimal;
7044584Srh87107 	 * by this point, this process has accounted for the usage of all its
7054584Srh87107 	 * LWPs. We nonetheless do the work here, and under the protection of
7064584Srh87107 	 * pidlock, so that the movement of the process's usage to the task
7074584Srh87107 	 * happens at the same time as the removal of the process from the
7084584Srh87107 	 * task, from the point of view of exacct_snapshot_task_usage().
7094584Srh87107 	 */
7104584Srh87107 	exacct_update_task_mstate(p);
7114584Srh87107 
7120Sstevel@tonic-gate 	hrutime = mstate_aggr_state(p, LMS_USER);
7130Sstevel@tonic-gate 	hrstime = mstate_aggr_state(p, LMS_SYSTEM);
7140Sstevel@tonic-gate 	p->p_utime = (clock_t)NSEC_TO_TICK(hrutime) + p->p_cutime;
7150Sstevel@tonic-gate 	p->p_stime = (clock_t)NSEC_TO_TICK(hrstime) + p->p_cstime;
7160Sstevel@tonic-gate 
7170Sstevel@tonic-gate 	p->p_acct[LMS_USER]	+= p->p_cacct[LMS_USER];
7180Sstevel@tonic-gate 	p->p_acct[LMS_SYSTEM]	+= p->p_cacct[LMS_SYSTEM];
7190Sstevel@tonic-gate 	p->p_acct[LMS_TRAP]	+= p->p_cacct[LMS_TRAP];
7200Sstevel@tonic-gate 	p->p_acct[LMS_TFAULT]	+= p->p_cacct[LMS_TFAULT];
7210Sstevel@tonic-gate 	p->p_acct[LMS_DFAULT]	+= p->p_cacct[LMS_DFAULT];
7220Sstevel@tonic-gate 	p->p_acct[LMS_KFAULT]	+= p->p_cacct[LMS_KFAULT];
7230Sstevel@tonic-gate 	p->p_acct[LMS_USER_LOCK] += p->p_cacct[LMS_USER_LOCK];
7240Sstevel@tonic-gate 	p->p_acct[LMS_SLEEP]	+= p->p_cacct[LMS_SLEEP];
7250Sstevel@tonic-gate 	p->p_acct[LMS_WAIT_CPU]	+= p->p_cacct[LMS_WAIT_CPU];
7260Sstevel@tonic-gate 	p->p_acct[LMS_STOPPED]	+= p->p_cacct[LMS_STOPPED];
7270Sstevel@tonic-gate 
7280Sstevel@tonic-gate 	p->p_ru.minflt	+= p->p_cru.minflt;
7290Sstevel@tonic-gate 	p->p_ru.majflt	+= p->p_cru.majflt;
7300Sstevel@tonic-gate 	p->p_ru.nswap	+= p->p_cru.nswap;
7310Sstevel@tonic-gate 	p->p_ru.inblock	+= p->p_cru.inblock;
7320Sstevel@tonic-gate 	p->p_ru.oublock	+= p->p_cru.oublock;
7330Sstevel@tonic-gate 	p->p_ru.msgsnd	+= p->p_cru.msgsnd;
7340Sstevel@tonic-gate 	p->p_ru.msgrcv	+= p->p_cru.msgrcv;
7350Sstevel@tonic-gate 	p->p_ru.nsignals += p->p_cru.nsignals;
7360Sstevel@tonic-gate 	p->p_ru.nvcsw	+= p->p_cru.nvcsw;
7370Sstevel@tonic-gate 	p->p_ru.nivcsw	+= p->p_cru.nivcsw;
7380Sstevel@tonic-gate 	p->p_ru.sysc	+= p->p_cru.sysc;
7390Sstevel@tonic-gate 	p->p_ru.ioch	+= p->p_cru.ioch;
7400Sstevel@tonic-gate 
7410Sstevel@tonic-gate 	p->p_stat = SZOMB;
7420Sstevel@tonic-gate 	p->p_proc_flag &= ~P_PR_PTRACE;
7430Sstevel@tonic-gate 	p->p_wdata = what;
7440Sstevel@tonic-gate 	p->p_wcode = (char)why;
7450Sstevel@tonic-gate 
7460Sstevel@tonic-gate 	cdir = PTOU(p)->u_cdir;
7470Sstevel@tonic-gate 	rdir = PTOU(p)->u_rdir;
7480Sstevel@tonic-gate 	cwd = PTOU(p)->u_cwd;
7490Sstevel@tonic-gate 
7500Sstevel@tonic-gate 	/*
7510Sstevel@tonic-gate 	 * Release resource controls, as they are no longer enforceable.
7520Sstevel@tonic-gate 	 */
7530Sstevel@tonic-gate 	rctl_set_free(p->p_rctls);
7540Sstevel@tonic-gate 
7550Sstevel@tonic-gate 	/*
7560Sstevel@tonic-gate 	 * Give up task and project memberships.  Decrement tk_nlwps counter
7570Sstevel@tonic-gate 	 * for our task.max-lwps resource control.  An extended accounting
7580Sstevel@tonic-gate 	 * record, if that facility is active, is scheduled to be written.
7590Sstevel@tonic-gate 	 * Zombie processes are false members of task0 for the remainder of
7600Sstevel@tonic-gate 	 * their lifetime; no accounting information is recorded for them.
7610Sstevel@tonic-gate 	 */
7620Sstevel@tonic-gate 	tk = p->p_task;
7630Sstevel@tonic-gate 
7640Sstevel@tonic-gate 	mutex_enter(&p->p_zone->zone_nlwps_lock);
7650Sstevel@tonic-gate 	tk->tk_nlwps--;
7660Sstevel@tonic-gate 	tk->tk_proj->kpj_nlwps--;
7670Sstevel@tonic-gate 	p->p_zone->zone_nlwps--;
7680Sstevel@tonic-gate 	mutex_exit(&p->p_zone->zone_nlwps_lock);
7690Sstevel@tonic-gate 	task_detach(p);
7700Sstevel@tonic-gate 	p->p_task = task0p;
7710Sstevel@tonic-gate 
7720Sstevel@tonic-gate 	/*
7730Sstevel@tonic-gate 	 * Clear the lwp directory and the lwpid hash table
7740Sstevel@tonic-gate 	 * now that /proc can't bother us any more.
7750Sstevel@tonic-gate 	 * We free the memory below, after dropping p->p_lock.
7760Sstevel@tonic-gate 	 */
7770Sstevel@tonic-gate 	lwpdir = p->p_lwpdir;
7780Sstevel@tonic-gate 	lwpdir_sz = p->p_lwpdir_sz;
7790Sstevel@tonic-gate 	tidhash = p->p_tidhash;
7800Sstevel@tonic-gate 	tidhash_sz = p->p_tidhash_sz;
781*9393SRoger.Faulkner@Sun.COM 	ret_tidhash = p->p_ret_tidhash;
7820Sstevel@tonic-gate 	p->p_lwpdir = NULL;
7830Sstevel@tonic-gate 	p->p_lwpfree = NULL;
7840Sstevel@tonic-gate 	p->p_lwpdir_sz = 0;
7850Sstevel@tonic-gate 	p->p_tidhash = NULL;
7860Sstevel@tonic-gate 	p->p_tidhash_sz = 0;
787*9393SRoger.Faulkner@Sun.COM 	p->p_ret_tidhash = NULL;
7880Sstevel@tonic-gate 
7890Sstevel@tonic-gate 	/*
7901217Srab 	 * If the process has context ops installed, call the exit routine
7911217Srab 	 * on behalf of this last remaining thread. Normally exitpctx() is
7921217Srab 	 * called during thread_exit() or lwp_exit(), but because this is the
7931217Srab 	 * last thread in the process, we must call it here. By the time
7941217Srab 	 * thread_exit() is called (below), the association with the relevant
7951217Srab 	 * process has been lost.
7961217Srab 	 *
7971217Srab 	 * We also free the context here.
7981217Srab 	 */
7991217Srab 	if (p->p_pctx) {
8001217Srab 		kpreempt_disable();
8011217Srab 		exitpctx(p);
8021217Srab 		kpreempt_enable();
8031217Srab 
8041217Srab 		freepctx(p, 0);
8051217Srab 	}
8061217Srab 
8071217Srab 	/*
8083813Sdp 	 * curthread's proc pointer is changed to point to the 'sched'
8093813Sdp 	 * process for the corresponding zone, except in the case when
8103813Sdp 	 * the exiting process is in fact a zsched instance, in which
8113813Sdp 	 * case the proc pointer is set to p0.  We do so, so that the
8123813Sdp 	 * process still points at the right zone when we call the VN_RELE()
8133813Sdp 	 * below.
8143813Sdp 	 *
8153813Sdp 	 * This is because curthread's original proc pointer can be freed as
8163813Sdp 	 * soon as the child sends a SIGCLD to its parent.  We use zsched so
8173813Sdp 	 * that for user processes, even in the final moments of death, the
8183813Sdp 	 * process is still associated with its zone.
8190Sstevel@tonic-gate 	 */
8203813Sdp 	if (p != t->t_procp->p_zone->zone_zsched)
8213813Sdp 		t->t_procp = t->t_procp->p_zone->zone_zsched;
8223813Sdp 	else
8233813Sdp 		t->t_procp = &p0;
8240Sstevel@tonic-gate 
8250Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
8263235Sraf 	if (!evaporate) {
8273235Sraf 		p->p_pidflag &= ~CLDPEND;
8283086Sraf 		sigcld(p, sqp);
8293235Sraf 	} else {
8303086Sraf 		/*
8313086Sraf 		 * Do what sigcld() would do if the disposition
8323086Sraf 		 * of the SIGCHLD signal were set to be ignored.
8333086Sraf 		 */
8343086Sraf 		cv_broadcast(&p->p_srwchan_cv);
8353086Sraf 		freeproc(p);
8363086Sraf 	}
8370Sstevel@tonic-gate 	mutex_exit(&pidlock);
8380Sstevel@tonic-gate 
8390Sstevel@tonic-gate 	/*
8400Sstevel@tonic-gate 	 * We don't release u_cdir and u_rdir until SZOMB is set.
8410Sstevel@tonic-gate 	 * This protects us against dofusers().
8420Sstevel@tonic-gate 	 */
8430Sstevel@tonic-gate 	VN_RELE(cdir);
8440Sstevel@tonic-gate 	if (rdir)
8450Sstevel@tonic-gate 		VN_RELE(rdir);
8460Sstevel@tonic-gate 	if (cwd)
8470Sstevel@tonic-gate 		refstr_rele(cwd);
8480Sstevel@tonic-gate 
8493813Sdp 	/*
8503813Sdp 	 * task_rele() may ultimately cause the zone to go away (or
8513813Sdp 	 * may cause the last user process in a zone to go away, which
8523813Sdp 	 * signals zsched to go away).  So prior to this call, we must
8533813Sdp 	 * no longer point at zsched.
8543813Sdp 	 */
8553813Sdp 	t->t_procp = &p0;
8563813Sdp 	task_rele(tk);
8573813Sdp 
8583813Sdp 	kmem_free(lwpdir, lwpdir_sz * sizeof (lwpdir_t));
859*9393SRoger.Faulkner@Sun.COM 	kmem_free(tidhash, tidhash_sz * sizeof (tidhash_t));
860*9393SRoger.Faulkner@Sun.COM 	while (ret_tidhash != NULL) {
861*9393SRoger.Faulkner@Sun.COM 		ret_tidhash_t *next = ret_tidhash->rth_next;
862*9393SRoger.Faulkner@Sun.COM 		kmem_free(ret_tidhash->rth_tidhash,
863*9393SRoger.Faulkner@Sun.COM 		    ret_tidhash->rth_tidhash_sz * sizeof (tidhash_t));
864*9393SRoger.Faulkner@Sun.COM 		kmem_free(ret_tidhash, sizeof (*ret_tidhash));
865*9393SRoger.Faulkner@Sun.COM 		ret_tidhash = next;
866*9393SRoger.Faulkner@Sun.COM 	}
8673813Sdp 
8680Sstevel@tonic-gate 	lwp_pcb_exit();
8690Sstevel@tonic-gate 
8700Sstevel@tonic-gate 	thread_exit();
8710Sstevel@tonic-gate 	/* NOTREACHED */
8720Sstevel@tonic-gate }
8730Sstevel@tonic-gate 
8740Sstevel@tonic-gate /*
8750Sstevel@tonic-gate  * Format siginfo structure for wait system calls.
8760Sstevel@tonic-gate  */
8770Sstevel@tonic-gate void
8780Sstevel@tonic-gate winfo(proc_t *pp, k_siginfo_t *ip, int waitflag)
8790Sstevel@tonic-gate {
8800Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
8810Sstevel@tonic-gate 
8820Sstevel@tonic-gate 	bzero(ip, sizeof (k_siginfo_t));
8830Sstevel@tonic-gate 	ip->si_signo = SIGCLD;
8840Sstevel@tonic-gate 	ip->si_code = pp->p_wcode;
8850Sstevel@tonic-gate 	ip->si_pid = pp->p_pid;
8860Sstevel@tonic-gate 	ip->si_ctid = PRCTID(pp);
8870Sstevel@tonic-gate 	ip->si_zoneid = pp->p_zone->zone_id;
8880Sstevel@tonic-gate 	ip->si_status = pp->p_wdata;
8890Sstevel@tonic-gate 	ip->si_stime = pp->p_stime;
8900Sstevel@tonic-gate 	ip->si_utime = pp->p_utime;
8910Sstevel@tonic-gate 
8920Sstevel@tonic-gate 	if (waitflag) {
8930Sstevel@tonic-gate 		pp->p_wcode = 0;
8940Sstevel@tonic-gate 		pp->p_wdata = 0;
8950Sstevel@tonic-gate 		pp->p_pidflag &= ~CLDPEND;
8960Sstevel@tonic-gate 	}
8970Sstevel@tonic-gate }
8980Sstevel@tonic-gate 
8990Sstevel@tonic-gate /*
9000Sstevel@tonic-gate  * Wait system call.
9010Sstevel@tonic-gate  * Search for a terminated (zombie) child,
9020Sstevel@tonic-gate  * finally lay it to rest, and collect its status.
9030Sstevel@tonic-gate  * Look also for stopped children,
9040Sstevel@tonic-gate  * and pass back status from them.
9050Sstevel@tonic-gate  */
9060Sstevel@tonic-gate int
9070Sstevel@tonic-gate waitid(idtype_t idtype, id_t id, k_siginfo_t *ip, int options)
9080Sstevel@tonic-gate {
9090Sstevel@tonic-gate 	int found;
9100Sstevel@tonic-gate 	proc_t *cp, *pp;
9110Sstevel@tonic-gate 	int proc_gone;
9120Sstevel@tonic-gate 	int waitflag = !(options & WNOWAIT);
9130Sstevel@tonic-gate 
9140Sstevel@tonic-gate 	/*
9150Sstevel@tonic-gate 	 * Obsolete flag, defined here only for binary compatibility
9160Sstevel@tonic-gate 	 * with old statically linked executables.  Delete this when
9170Sstevel@tonic-gate 	 * we no longer care about these old and broken applications.
9180Sstevel@tonic-gate 	 */
9190Sstevel@tonic-gate #define	_WNOCHLD	0400
9200Sstevel@tonic-gate 	options &= ~_WNOCHLD;
9210Sstevel@tonic-gate 
9220Sstevel@tonic-gate 	if (options == 0 || (options & ~WOPTMASK))
9230Sstevel@tonic-gate 		return (EINVAL);
9240Sstevel@tonic-gate 
9250Sstevel@tonic-gate 	switch (idtype) {
9260Sstevel@tonic-gate 	case P_PID:
9270Sstevel@tonic-gate 	case P_PGID:
9280Sstevel@tonic-gate 		if (id < 0 || id >= maxpid)
9290Sstevel@tonic-gate 			return (EINVAL);
9300Sstevel@tonic-gate 		/* FALLTHROUGH */
9310Sstevel@tonic-gate 	case P_ALL:
9320Sstevel@tonic-gate 		break;
9330Sstevel@tonic-gate 	default:
9340Sstevel@tonic-gate 		return (EINVAL);
9350Sstevel@tonic-gate 	}
9360Sstevel@tonic-gate 
9370Sstevel@tonic-gate 	pp = ttoproc(curthread);
938749Ssusans 
9390Sstevel@tonic-gate 	/*
9400Sstevel@tonic-gate 	 * lock parent mutex so that sibling chain can be searched.
9410Sstevel@tonic-gate 	 */
9420Sstevel@tonic-gate 	mutex_enter(&pidlock);
943749Ssusans 
944749Ssusans 	/*
945749Ssusans 	 * if we are only looking for exited processes and child_ns list
946749Ssusans 	 * is empty no reason to look at all children.
947749Ssusans 	 */
948749Ssusans 	if (idtype == P_ALL &&
9493235Sraf 	    (options & ~WNOWAIT) == (WNOHANG | WEXITED) &&
9502267Sdp 	    pp->p_child_ns == NULL) {
951749Ssusans 		if (pp->p_child) {
952749Ssusans 			mutex_exit(&pidlock);
953749Ssusans 			bzero(ip, sizeof (k_siginfo_t));
954749Ssusans 			return (0);
955749Ssusans 		}
956749Ssusans 		mutex_exit(&pidlock);
957749Ssusans 		return (ECHILD);
958749Ssusans 	}
959749Ssusans 
9603235Sraf 	while (pp->p_child != NULL) {
9610Sstevel@tonic-gate 
9620Sstevel@tonic-gate 		proc_gone = 0;
9630Sstevel@tonic-gate 
9643235Sraf 		for (cp = pp->p_child_ns; cp != NULL; cp = cp->p_sibling_ns) {
9653235Sraf 			if (idtype != P_PID && (cp->p_pidflag & CLDWAITPID))
9663235Sraf 				continue;
9673235Sraf 			if (idtype == P_PID && id != cp->p_pid)
9680Sstevel@tonic-gate 				continue;
9693235Sraf 			if (idtype == P_PGID && id != cp->p_pgrp)
9700Sstevel@tonic-gate 				continue;
9710Sstevel@tonic-gate 
9723235Sraf 			switch (cp->p_wcode) {
9730Sstevel@tonic-gate 
9740Sstevel@tonic-gate 			case CLD_TRAPPED:
9750Sstevel@tonic-gate 			case CLD_STOPPED:
9760Sstevel@tonic-gate 			case CLD_CONTINUED:
9770Sstevel@tonic-gate 				cmn_err(CE_PANIC,
9780Sstevel@tonic-gate 				    "waitid: wrong state %d on the p_newstate"
9793235Sraf 				    " list", cp->p_wcode);
9800Sstevel@tonic-gate 				break;
9810Sstevel@tonic-gate 
9820Sstevel@tonic-gate 			case CLD_EXITED:
9830Sstevel@tonic-gate 			case CLD_DUMPED:
9840Sstevel@tonic-gate 			case CLD_KILLED:
9850Sstevel@tonic-gate 				if (!(options & WEXITED)) {
9860Sstevel@tonic-gate 					/*
9870Sstevel@tonic-gate 					 * Count how many are already gone
9880Sstevel@tonic-gate 					 * for good.
9890Sstevel@tonic-gate 					 */
9900Sstevel@tonic-gate 					proc_gone++;
9910Sstevel@tonic-gate 					break;
9920Sstevel@tonic-gate 				}
9930Sstevel@tonic-gate 				if (!waitflag) {
9943235Sraf 					winfo(cp, ip, 0);
9950Sstevel@tonic-gate 				} else {
9963235Sraf 					winfo(cp, ip, 1);
9973235Sraf 					freeproc(cp);
9980Sstevel@tonic-gate 				}
9990Sstevel@tonic-gate 				mutex_exit(&pidlock);
10000Sstevel@tonic-gate 				if (waitflag) {		/* accept SIGCLD */
10010Sstevel@tonic-gate 					sigcld_delete(ip);
10020Sstevel@tonic-gate 					sigcld_repost();
10030Sstevel@tonic-gate 				}
10040Sstevel@tonic-gate 				return (0);
10050Sstevel@tonic-gate 			}
10060Sstevel@tonic-gate 
10070Sstevel@tonic-gate 			if (idtype == P_PID)
10080Sstevel@tonic-gate 				break;
10090Sstevel@tonic-gate 		}
10100Sstevel@tonic-gate 
10110Sstevel@tonic-gate 		/*
10120Sstevel@tonic-gate 		 * Wow! None of the threads on the p_sibling_ns list were
10130Sstevel@tonic-gate 		 * interesting threads. Check all the kids!
10140Sstevel@tonic-gate 		 */
10150Sstevel@tonic-gate 		found = 0;
10163235Sraf 		for (cp = pp->p_child; cp != NULL; cp = cp->p_sibling) {
10173235Sraf 			if (idtype == P_PID && id != cp->p_pid)
10180Sstevel@tonic-gate 				continue;
10193235Sraf 			if (idtype == P_PGID && id != cp->p_pgrp)
10200Sstevel@tonic-gate 				continue;
10210Sstevel@tonic-gate 
10220Sstevel@tonic-gate 			switch (cp->p_wcode) {
10230Sstevel@tonic-gate 			case CLD_TRAPPED:
10240Sstevel@tonic-gate 				if (!(options & WTRAPPED))
10250Sstevel@tonic-gate 					break;
10260Sstevel@tonic-gate 				winfo(cp, ip, waitflag);
10270Sstevel@tonic-gate 				mutex_exit(&pidlock);
10280Sstevel@tonic-gate 				if (waitflag) {		/* accept SIGCLD */
10290Sstevel@tonic-gate 					sigcld_delete(ip);
10300Sstevel@tonic-gate 					sigcld_repost();
10310Sstevel@tonic-gate 				}
10320Sstevel@tonic-gate 				return (0);
10330Sstevel@tonic-gate 
10340Sstevel@tonic-gate 			case CLD_STOPPED:
10350Sstevel@tonic-gate 				if (!(options & WSTOPPED))
10360Sstevel@tonic-gate 					break;
10370Sstevel@tonic-gate 				/* Is it still stopped? */
10380Sstevel@tonic-gate 				mutex_enter(&cp->p_lock);
10390Sstevel@tonic-gate 				if (!jobstopped(cp)) {
10400Sstevel@tonic-gate 					mutex_exit(&cp->p_lock);
10410Sstevel@tonic-gate 					break;
10420Sstevel@tonic-gate 				}
10430Sstevel@tonic-gate 				mutex_exit(&cp->p_lock);
10440Sstevel@tonic-gate 				winfo(cp, ip, waitflag);
10450Sstevel@tonic-gate 				mutex_exit(&pidlock);
10460Sstevel@tonic-gate 				if (waitflag) {		/* accept SIGCLD */
10470Sstevel@tonic-gate 					sigcld_delete(ip);
10480Sstevel@tonic-gate 					sigcld_repost();
10490Sstevel@tonic-gate 				}
10500Sstevel@tonic-gate 				return (0);
10510Sstevel@tonic-gate 
10520Sstevel@tonic-gate 			case CLD_CONTINUED:
10530Sstevel@tonic-gate 				if (!(options & WCONTINUED))
10540Sstevel@tonic-gate 					break;
10550Sstevel@tonic-gate 				winfo(cp, ip, waitflag);
10560Sstevel@tonic-gate 				mutex_exit(&pidlock);
10570Sstevel@tonic-gate 				if (waitflag) {		/* accept SIGCLD */
10580Sstevel@tonic-gate 					sigcld_delete(ip);
10590Sstevel@tonic-gate 					sigcld_repost();
10600Sstevel@tonic-gate 				}
10610Sstevel@tonic-gate 				return (0);
10620Sstevel@tonic-gate 
10630Sstevel@tonic-gate 			case CLD_EXITED:
10640Sstevel@tonic-gate 			case CLD_DUMPED:
10650Sstevel@tonic-gate 			case CLD_KILLED:
10663235Sraf 				if (idtype != P_PID &&
10673235Sraf 				    (cp->p_pidflag & CLDWAITPID))
10683235Sraf 					continue;
10690Sstevel@tonic-gate 				/*
10700Sstevel@tonic-gate 				 * Don't complain if a process was found in
10710Sstevel@tonic-gate 				 * the first loop but we broke out of the loop
10720Sstevel@tonic-gate 				 * because of the arguments passed to us.
10730Sstevel@tonic-gate 				 */
10740Sstevel@tonic-gate 				if (proc_gone == 0) {
10750Sstevel@tonic-gate 					cmn_err(CE_PANIC,
10760Sstevel@tonic-gate 					    "waitid: wrong state on the"
10770Sstevel@tonic-gate 					    " p_child list");
10780Sstevel@tonic-gate 				} else {
10790Sstevel@tonic-gate 					break;
10800Sstevel@tonic-gate 				}
10810Sstevel@tonic-gate 			}
10820Sstevel@tonic-gate 
10833235Sraf 			found++;
10843235Sraf 
10850Sstevel@tonic-gate 			if (idtype == P_PID)
10860Sstevel@tonic-gate 				break;
10873235Sraf 		}
10880Sstevel@tonic-gate 
10890Sstevel@tonic-gate 		/*
10900Sstevel@tonic-gate 		 * If we found no interesting processes at all,
10910Sstevel@tonic-gate 		 * break out and return ECHILD.
10920Sstevel@tonic-gate 		 */
10930Sstevel@tonic-gate 		if (found + proc_gone == 0)
10940Sstevel@tonic-gate 			break;
10950Sstevel@tonic-gate 
10960Sstevel@tonic-gate 		if (options & WNOHANG) {
10973235Sraf 			mutex_exit(&pidlock);
10980Sstevel@tonic-gate 			bzero(ip, sizeof (k_siginfo_t));
10990Sstevel@tonic-gate 			/*
11000Sstevel@tonic-gate 			 * We should set ip->si_signo = SIGCLD,
11010Sstevel@tonic-gate 			 * but there is an SVVS test that expects
11020Sstevel@tonic-gate 			 * ip->si_signo to be zero in this case.
11030Sstevel@tonic-gate 			 */
11040Sstevel@tonic-gate 			return (0);
11050Sstevel@tonic-gate 		}
11060Sstevel@tonic-gate 
11070Sstevel@tonic-gate 		/*
11080Sstevel@tonic-gate 		 * If we found no processes of interest that could
11090Sstevel@tonic-gate 		 * change state while we wait, we don't wait at all.
11100Sstevel@tonic-gate 		 * Get out with ECHILD according to SVID.
11110Sstevel@tonic-gate 		 */
11120Sstevel@tonic-gate 		if (found == proc_gone)
11130Sstevel@tonic-gate 			break;
11140Sstevel@tonic-gate 
11150Sstevel@tonic-gate 		if (!cv_wait_sig_swap(&pp->p_cv, &pidlock)) {
11160Sstevel@tonic-gate 			mutex_exit(&pidlock);
11170Sstevel@tonic-gate 			return (EINTR);
11180Sstevel@tonic-gate 		}
11190Sstevel@tonic-gate 	}
11200Sstevel@tonic-gate 	mutex_exit(&pidlock);
11210Sstevel@tonic-gate 	return (ECHILD);
11220Sstevel@tonic-gate }
11230Sstevel@tonic-gate 
11240Sstevel@tonic-gate /*
11253235Sraf  * The wait() system call trap is no longer invoked by libc.
11263235Sraf  * It is retained only for the benefit of statically linked applications.
11273235Sraf  * Delete this when we no longer care about these old and broken applications.
11280Sstevel@tonic-gate  */
11290Sstevel@tonic-gate int64_t
11300Sstevel@tonic-gate wait(void)
11310Sstevel@tonic-gate {
11320Sstevel@tonic-gate 	int error;
11330Sstevel@tonic-gate 	k_siginfo_t info;
11340Sstevel@tonic-gate 	rval_t	r;
11350Sstevel@tonic-gate 
11360Sstevel@tonic-gate 	if (error =  waitid(P_ALL, (id_t)0, &info, WEXITED|WTRAPPED))
11370Sstevel@tonic-gate 		return (set_errno(error));
11380Sstevel@tonic-gate 	r.r_val1 = info.si_pid;
11390Sstevel@tonic-gate 	r.r_val2 = wstat(info.si_code, info.si_status);
11400Sstevel@tonic-gate 	return (r.r_vals);
11410Sstevel@tonic-gate }
11420Sstevel@tonic-gate 
11430Sstevel@tonic-gate int
11440Sstevel@tonic-gate waitsys(idtype_t idtype, id_t id, siginfo_t *infop, int options)
11450Sstevel@tonic-gate {
11460Sstevel@tonic-gate 	int error;
11470Sstevel@tonic-gate 	k_siginfo_t info;
11480Sstevel@tonic-gate 
11490Sstevel@tonic-gate 	if (error = waitid(idtype, id, &info, options))
11500Sstevel@tonic-gate 		return (set_errno(error));
11510Sstevel@tonic-gate 	if (copyout(&info, infop, sizeof (k_siginfo_t)))
11520Sstevel@tonic-gate 		return (set_errno(EFAULT));
11530Sstevel@tonic-gate 	return (0);
11540Sstevel@tonic-gate }
11550Sstevel@tonic-gate 
11560Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
11570Sstevel@tonic-gate 
11580Sstevel@tonic-gate int
11590Sstevel@tonic-gate waitsys32(idtype_t idtype, id_t id, siginfo_t *infop, int options)
11600Sstevel@tonic-gate {
11610Sstevel@tonic-gate 	int error;
11620Sstevel@tonic-gate 	k_siginfo_t info;
11630Sstevel@tonic-gate 	siginfo32_t info32;
11640Sstevel@tonic-gate 
11650Sstevel@tonic-gate 	if (error = waitid(idtype, id, &info, options))
11660Sstevel@tonic-gate 		return (set_errno(error));
11670Sstevel@tonic-gate 	siginfo_kto32(&info, &info32);
11680Sstevel@tonic-gate 	if (copyout(&info32, infop, sizeof (info32)))
11690Sstevel@tonic-gate 		return (set_errno(EFAULT));
11700Sstevel@tonic-gate 	return (0);
11710Sstevel@tonic-gate }
11720Sstevel@tonic-gate 
11730Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
11740Sstevel@tonic-gate 
11750Sstevel@tonic-gate void
11760Sstevel@tonic-gate proc_detach(proc_t *p)
11770Sstevel@tonic-gate {
11780Sstevel@tonic-gate 	proc_t *q;
11790Sstevel@tonic-gate 
11800Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
11810Sstevel@tonic-gate 
11820Sstevel@tonic-gate 	q = p->p_parent;
11830Sstevel@tonic-gate 	ASSERT(q != NULL);
11840Sstevel@tonic-gate 
11850Sstevel@tonic-gate 	/*
11860Sstevel@tonic-gate 	 * Take it off the newstate list of its parent
11870Sstevel@tonic-gate 	 */
11880Sstevel@tonic-gate 	delete_ns(q, p);
11890Sstevel@tonic-gate 
11900Sstevel@tonic-gate 	if (q->p_child == p) {
11910Sstevel@tonic-gate 		q->p_child = p->p_sibling;
11920Sstevel@tonic-gate 		/*
11930Sstevel@tonic-gate 		 * If the parent has no children, it better not
11940Sstevel@tonic-gate 		 * have any with new states either!
11950Sstevel@tonic-gate 		 */
11960Sstevel@tonic-gate 		ASSERT(q->p_child ? 1 : q->p_child_ns == NULL);
11970Sstevel@tonic-gate 	}
11980Sstevel@tonic-gate 
11990Sstevel@tonic-gate 	if (p->p_sibling) {
12000Sstevel@tonic-gate 		p->p_sibling->p_psibling = p->p_psibling;
12010Sstevel@tonic-gate 	}
12020Sstevel@tonic-gate 
12030Sstevel@tonic-gate 	if (p->p_psibling) {
12040Sstevel@tonic-gate 		p->p_psibling->p_sibling = p->p_sibling;
12050Sstevel@tonic-gate 	}
12060Sstevel@tonic-gate }
12070Sstevel@tonic-gate 
12080Sstevel@tonic-gate /*
12090Sstevel@tonic-gate  * Remove zombie children from the process table.
12100Sstevel@tonic-gate  */
12110Sstevel@tonic-gate void
12120Sstevel@tonic-gate freeproc(proc_t *p)
12130Sstevel@tonic-gate {
12140Sstevel@tonic-gate 	proc_t *q;
12150Sstevel@tonic-gate 
12160Sstevel@tonic-gate 	ASSERT(p->p_stat == SZOMB);
12170Sstevel@tonic-gate 	ASSERT(p->p_tlist == NULL);
12180Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
12190Sstevel@tonic-gate 
12200Sstevel@tonic-gate 	sigdelq(p, NULL, 0);
12210Sstevel@tonic-gate 	if (p->p_killsqp) {
12220Sstevel@tonic-gate 		siginfofree(p->p_killsqp);
12230Sstevel@tonic-gate 		p->p_killsqp = NULL;
12240Sstevel@tonic-gate 	}
12250Sstevel@tonic-gate 
12260Sstevel@tonic-gate 	prfree(p);	/* inform /proc */
12270Sstevel@tonic-gate 
12280Sstevel@tonic-gate 	/*
12290Sstevel@tonic-gate 	 * Don't free the init processes.
12300Sstevel@tonic-gate 	 * Other dying processes will access it.
12310Sstevel@tonic-gate 	 */
12320Sstevel@tonic-gate 	if (p == proc_init)
12330Sstevel@tonic-gate 		return;
12340Sstevel@tonic-gate 
12350Sstevel@tonic-gate 
12360Sstevel@tonic-gate 	/*
12370Sstevel@tonic-gate 	 * We wait until now to free the cred structure because a
12380Sstevel@tonic-gate 	 * zombie process's credentials may be examined by /proc.
12390Sstevel@tonic-gate 	 * No cred locking needed because there are no threads at this point.
12400Sstevel@tonic-gate 	 */
12410Sstevel@tonic-gate 	upcount_dec(crgetruid(p->p_cred), crgetzoneid(p->p_cred));
12420Sstevel@tonic-gate 	crfree(p->p_cred);
12430Sstevel@tonic-gate 	if (p->p_corefile != NULL) {
12440Sstevel@tonic-gate 		corectl_path_rele(p->p_corefile);
12450Sstevel@tonic-gate 		p->p_corefile = NULL;
12460Sstevel@tonic-gate 	}
12470Sstevel@tonic-gate 	if (p->p_content != NULL) {
12480Sstevel@tonic-gate 		corectl_content_rele(p->p_content);
12490Sstevel@tonic-gate 		p->p_content = NULL;
12500Sstevel@tonic-gate 	}
12510Sstevel@tonic-gate 
12520Sstevel@tonic-gate 	if (p->p_nextofkin && !((p->p_nextofkin->p_flag & SNOWAIT) ||
12530Sstevel@tonic-gate 	    (PTOU(p->p_nextofkin)->u_signal[SIGCLD - 1] == SIG_IGN))) {
12540Sstevel@tonic-gate 		/*
12550Sstevel@tonic-gate 		 * This should still do the right thing since p_utime/stime
12560Sstevel@tonic-gate 		 * get set to the correct value on process exit, so it
12570Sstevel@tonic-gate 		 * should get properly updated
12580Sstevel@tonic-gate 		 */
12590Sstevel@tonic-gate 		p->p_nextofkin->p_cutime += p->p_utime;
12600Sstevel@tonic-gate 		p->p_nextofkin->p_cstime += p->p_stime;
12610Sstevel@tonic-gate 
12620Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_USER] += p->p_acct[LMS_USER];
12630Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_SYSTEM] += p->p_acct[LMS_SYSTEM];
12640Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_TRAP] += p->p_acct[LMS_TRAP];
12650Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_TFAULT] += p->p_acct[LMS_TFAULT];
12660Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_DFAULT] += p->p_acct[LMS_DFAULT];
12670Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_KFAULT] += p->p_acct[LMS_KFAULT];
12680Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_USER_LOCK]
12690Sstevel@tonic-gate 		    += p->p_acct[LMS_USER_LOCK];
12700Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_SLEEP] += p->p_acct[LMS_SLEEP];
12710Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_WAIT_CPU]
12720Sstevel@tonic-gate 		    += p->p_acct[LMS_WAIT_CPU];
12730Sstevel@tonic-gate 		p->p_nextofkin->p_cacct[LMS_STOPPED] += p->p_acct[LMS_STOPPED];
12740Sstevel@tonic-gate 
12750Sstevel@tonic-gate 		p->p_nextofkin->p_cru.minflt	+= p->p_ru.minflt;
12760Sstevel@tonic-gate 		p->p_nextofkin->p_cru.majflt	+= p->p_ru.majflt;
12770Sstevel@tonic-gate 		p->p_nextofkin->p_cru.nswap	+= p->p_ru.nswap;
12780Sstevel@tonic-gate 		p->p_nextofkin->p_cru.inblock	+= p->p_ru.inblock;
12790Sstevel@tonic-gate 		p->p_nextofkin->p_cru.oublock	+= p->p_ru.oublock;
12800Sstevel@tonic-gate 		p->p_nextofkin->p_cru.msgsnd	+= p->p_ru.msgsnd;
12810Sstevel@tonic-gate 		p->p_nextofkin->p_cru.msgrcv	+= p->p_ru.msgrcv;
12820Sstevel@tonic-gate 		p->p_nextofkin->p_cru.nsignals	+= p->p_ru.nsignals;
12830Sstevel@tonic-gate 		p->p_nextofkin->p_cru.nvcsw	+= p->p_ru.nvcsw;
12840Sstevel@tonic-gate 		p->p_nextofkin->p_cru.nivcsw	+= p->p_ru.nivcsw;
12850Sstevel@tonic-gate 		p->p_nextofkin->p_cru.sysc	+= p->p_ru.sysc;
12860Sstevel@tonic-gate 		p->p_nextofkin->p_cru.ioch	+= p->p_ru.ioch;
12870Sstevel@tonic-gate 
12880Sstevel@tonic-gate 	}
12890Sstevel@tonic-gate 
12900Sstevel@tonic-gate 	q = p->p_nextofkin;
12910Sstevel@tonic-gate 	if (q && q->p_orphan == p)
12920Sstevel@tonic-gate 		q->p_orphan = p->p_nextorph;
12930Sstevel@tonic-gate 	else if (q) {
12940Sstevel@tonic-gate 		for (q = q->p_orphan; q; q = q->p_nextorph)
12950Sstevel@tonic-gate 			if (q->p_nextorph == p)
12960Sstevel@tonic-gate 				break;
12970Sstevel@tonic-gate 		ASSERT(q && q->p_nextorph == p);
12980Sstevel@tonic-gate 		q->p_nextorph = p->p_nextorph;
12990Sstevel@tonic-gate 	}
13000Sstevel@tonic-gate 
13010Sstevel@tonic-gate 	proc_detach(p);
13020Sstevel@tonic-gate 	pid_exit(p);	/* frees pid and proc structure */
13030Sstevel@tonic-gate }
13040Sstevel@tonic-gate 
13050Sstevel@tonic-gate /*
13060Sstevel@tonic-gate  * Delete process "child" from the newstate list of process "parent"
13070Sstevel@tonic-gate  */
13080Sstevel@tonic-gate void
13090Sstevel@tonic-gate delete_ns(proc_t *parent, proc_t *child)
13100Sstevel@tonic-gate {
13110Sstevel@tonic-gate 	proc_t **ns;
13120Sstevel@tonic-gate 
13130Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
13140Sstevel@tonic-gate 	ASSERT(child->p_parent == parent);
13150Sstevel@tonic-gate 	for (ns = &parent->p_child_ns; *ns != NULL; ns = &(*ns)->p_sibling_ns) {
13160Sstevel@tonic-gate 		if (*ns == child) {
13170Sstevel@tonic-gate 
13180Sstevel@tonic-gate 			ASSERT((*ns)->p_parent == parent);
13190Sstevel@tonic-gate 
13200Sstevel@tonic-gate 			*ns = child->p_sibling_ns;
13210Sstevel@tonic-gate 			child->p_sibling_ns = NULL;
13220Sstevel@tonic-gate 			return;
13230Sstevel@tonic-gate 		}
13240Sstevel@tonic-gate 	}
13250Sstevel@tonic-gate }
13260Sstevel@tonic-gate 
13270Sstevel@tonic-gate /*
13280Sstevel@tonic-gate  * Add process "child" to the new state list of process "parent"
13290Sstevel@tonic-gate  */
13300Sstevel@tonic-gate void
13310Sstevel@tonic-gate add_ns(proc_t *parent, proc_t *child)
13320Sstevel@tonic-gate {
13330Sstevel@tonic-gate 	ASSERT(child->p_sibling_ns == NULL);
13340Sstevel@tonic-gate 	child->p_sibling_ns = parent->p_child_ns;
13350Sstevel@tonic-gate 	parent->p_child_ns = child;
13360Sstevel@tonic-gate }
1337