xref: /titanic_51/usr/src/uts/common/os/sig.c (revision 35a5a3587fd94b666239c157d3722745250ccbd7)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5f841f6adSraf  * Common Development and Distribution License (the "License").
6f841f6adSraf  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
2197eda132Sraf 
227c478bd9Sstevel@tonic-gate /*
239524a69fSRoger A. Faulkner  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
287c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #include <sys/param.h>
317c478bd9Sstevel@tonic-gate #include <sys/types.h>
327c478bd9Sstevel@tonic-gate #include <sys/bitmap.h>
337c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
347c478bd9Sstevel@tonic-gate #include <sys/systm.h>
357c478bd9Sstevel@tonic-gate #include <sys/cred.h>
367c478bd9Sstevel@tonic-gate #include <sys/user.h>
377c478bd9Sstevel@tonic-gate #include <sys/errno.h>
387c478bd9Sstevel@tonic-gate #include <sys/proc.h>
397c478bd9Sstevel@tonic-gate #include <sys/poll_impl.h> /* only needed for kludge in sigwaiting_send() */
407c478bd9Sstevel@tonic-gate #include <sys/signal.h>
417c478bd9Sstevel@tonic-gate #include <sys/siginfo.h>
427c478bd9Sstevel@tonic-gate #include <sys/fault.h>
437c478bd9Sstevel@tonic-gate #include <sys/ucontext.h>
447c478bd9Sstevel@tonic-gate #include <sys/procfs.h>
457c478bd9Sstevel@tonic-gate #include <sys/wait.h>
467c478bd9Sstevel@tonic-gate #include <sys/class.h>
477c478bd9Sstevel@tonic-gate #include <sys/mman.h>
487c478bd9Sstevel@tonic-gate #include <sys/procset.h>
497c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
507c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
517c478bd9Sstevel@tonic-gate #include <sys/prsystm.h>
527c478bd9Sstevel@tonic-gate #include <sys/debug.h>
537c478bd9Sstevel@tonic-gate #include <vm/as.h>
547c478bd9Sstevel@tonic-gate #include <sys/bitmap.h>
557c478bd9Sstevel@tonic-gate #include <c2/audit.h>
567c478bd9Sstevel@tonic-gate #include <sys/core.h>
577c478bd9Sstevel@tonic-gate #include <sys/schedctl.h>
587c478bd9Sstevel@tonic-gate #include <sys/contract/process_impl.h>
59e0cf54a5SRoger A. Faulkner #include <sys/cyclic.h>
607c478bd9Sstevel@tonic-gate #include <sys/dtrace.h>
617c478bd9Sstevel@tonic-gate #include <sys/sdt.h>
627c478bd9Sstevel@tonic-gate 
637c478bd9Sstevel@tonic-gate 				/* MUST be contiguous */
647c478bd9Sstevel@tonic-gate k_sigset_t nullsmask = {0, 0};
657c478bd9Sstevel@tonic-gate 
667c478bd9Sstevel@tonic-gate k_sigset_t fillset = {FILLSET0, FILLSET1};
677c478bd9Sstevel@tonic-gate 
687c478bd9Sstevel@tonic-gate k_sigset_t cantmask = {CANTMASK0, CANTMASK1};
697c478bd9Sstevel@tonic-gate 
707c478bd9Sstevel@tonic-gate k_sigset_t cantreset = {(sigmask(SIGILL)|sigmask(SIGTRAP)|sigmask(SIGPWR)), 0};
717c478bd9Sstevel@tonic-gate 
727c478bd9Sstevel@tonic-gate k_sigset_t ignoredefault = {(sigmask(SIGCONT)|sigmask(SIGCLD)|sigmask(SIGPWR)
737c478bd9Sstevel@tonic-gate 			|sigmask(SIGWINCH)|sigmask(SIGURG)|sigmask(SIGWAITING)),
747c478bd9Sstevel@tonic-gate 			(sigmask(SIGLWP)|sigmask(SIGCANCEL)|sigmask(SIGFREEZE)
757c478bd9Sstevel@tonic-gate 			|sigmask(SIGTHAW)|sigmask(SIGXRES)|sigmask(SIGJVM1)
767c478bd9Sstevel@tonic-gate 			|sigmask(SIGJVM2))};
777c478bd9Sstevel@tonic-gate 
787c478bd9Sstevel@tonic-gate k_sigset_t stopdefault = {(sigmask(SIGSTOP)|sigmask(SIGTSTP)
797c478bd9Sstevel@tonic-gate 			|sigmask(SIGTTOU)|sigmask(SIGTTIN)), 0};
807c478bd9Sstevel@tonic-gate 
817c478bd9Sstevel@tonic-gate k_sigset_t coredefault = {(sigmask(SIGQUIT)|sigmask(SIGILL)|sigmask(SIGTRAP)
827c478bd9Sstevel@tonic-gate 			|sigmask(SIGIOT)|sigmask(SIGEMT)|sigmask(SIGFPE)
837c478bd9Sstevel@tonic-gate 			|sigmask(SIGBUS)|sigmask(SIGSEGV)|sigmask(SIGSYS)
847c478bd9Sstevel@tonic-gate 			|sigmask(SIGXCPU)|sigmask(SIGXFSZ)), 0};
857c478bd9Sstevel@tonic-gate 
867c478bd9Sstevel@tonic-gate k_sigset_t holdvfork = {(sigmask(SIGTTOU)|sigmask(SIGTTIN)|sigmask(SIGTSTP)),
877c478bd9Sstevel@tonic-gate 			0};
887c478bd9Sstevel@tonic-gate 
897c478bd9Sstevel@tonic-gate static	int	isjobstop(int);
907c478bd9Sstevel@tonic-gate static	void	post_sigcld(proc_t *, sigqueue_t *);
917c478bd9Sstevel@tonic-gate 
927c478bd9Sstevel@tonic-gate /*
937c478bd9Sstevel@tonic-gate  * Internal variables for counting number of user thread stop requests posted.
947c478bd9Sstevel@tonic-gate  * They may not be accurate at some special situation such as that a virtually
957c478bd9Sstevel@tonic-gate  * stopped thread starts to run.
967c478bd9Sstevel@tonic-gate  */
977c478bd9Sstevel@tonic-gate static int num_utstop;
987c478bd9Sstevel@tonic-gate /*
997c478bd9Sstevel@tonic-gate  * Internal variables for broadcasting an event when all thread stop requests
1007c478bd9Sstevel@tonic-gate  * are processed.
1017c478bd9Sstevel@tonic-gate  */
1027c478bd9Sstevel@tonic-gate static kcondvar_t utstop_cv;
1037c478bd9Sstevel@tonic-gate 
1047c478bd9Sstevel@tonic-gate static kmutex_t thread_stop_lock;
1057c478bd9Sstevel@tonic-gate void del_one_utstop(void);
1067c478bd9Sstevel@tonic-gate 
1077c478bd9Sstevel@tonic-gate /*
1087c478bd9Sstevel@tonic-gate  * Send the specified signal to the specified process.
1097c478bd9Sstevel@tonic-gate  */
1107c478bd9Sstevel@tonic-gate void
1117c478bd9Sstevel@tonic-gate psignal(proc_t *p, int sig)
1127c478bd9Sstevel@tonic-gate {
1137c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
1147c478bd9Sstevel@tonic-gate 	sigtoproc(p, NULL, sig);
1157c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
1167c478bd9Sstevel@tonic-gate }
1177c478bd9Sstevel@tonic-gate 
1187c478bd9Sstevel@tonic-gate /*
1197c478bd9Sstevel@tonic-gate  * Send the specified signal to the specified thread.
1207c478bd9Sstevel@tonic-gate  */
1217c478bd9Sstevel@tonic-gate void
1227c478bd9Sstevel@tonic-gate tsignal(kthread_t *t, int sig)
1237c478bd9Sstevel@tonic-gate {
1247c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
1257c478bd9Sstevel@tonic-gate 
1267c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
1277c478bd9Sstevel@tonic-gate 	sigtoproc(p, t, sig);
1287c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
1297c478bd9Sstevel@tonic-gate }
1307c478bd9Sstevel@tonic-gate 
1317c478bd9Sstevel@tonic-gate int
1327c478bd9Sstevel@tonic-gate signal_is_blocked(kthread_t *t, int sig)
1337c478bd9Sstevel@tonic-gate {
1347c478bd9Sstevel@tonic-gate 	return (sigismember(&t->t_hold, sig) ||
1357c478bd9Sstevel@tonic-gate 	    (schedctl_sigblock(t) && !sigismember(&cantmask, sig)));
1367c478bd9Sstevel@tonic-gate }
1377c478bd9Sstevel@tonic-gate 
1387c478bd9Sstevel@tonic-gate /*
1397c478bd9Sstevel@tonic-gate  * Return true if the signal can safely be discarded on generation.
1407c478bd9Sstevel@tonic-gate  * That is, if there is no need for the signal on the receiving end.
1417c478bd9Sstevel@tonic-gate  * The answer is true if the process is a zombie or
1427c478bd9Sstevel@tonic-gate  * if all of these conditions are true:
1437c478bd9Sstevel@tonic-gate  *	the signal is being ignored
1447c478bd9Sstevel@tonic-gate  *	the process is single-threaded
1457c478bd9Sstevel@tonic-gate  *	the signal is not being traced by /proc
1467c478bd9Sstevel@tonic-gate  * 	the signal is not blocked by the process
1479524a69fSRoger A. Faulkner  *	the signal is not being accepted via sigwait()
1487c478bd9Sstevel@tonic-gate  */
1497c478bd9Sstevel@tonic-gate static int
1507c478bd9Sstevel@tonic-gate sig_discardable(proc_t *p, int sig)
1517c478bd9Sstevel@tonic-gate {
1527c478bd9Sstevel@tonic-gate 	kthread_t *t = p->p_tlist;
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate 	return (t == NULL ||		/* if zombie or ... */
1557c478bd9Sstevel@tonic-gate 	    (sigismember(&p->p_ignore, sig) &&	/* signal is ignored */
1567c478bd9Sstevel@tonic-gate 	    t->t_forw == t &&			/* and single-threaded */
1577c478bd9Sstevel@tonic-gate 	    !tracing(p, sig) &&			/* and no /proc tracing */
1589524a69fSRoger A. Faulkner 	    !signal_is_blocked(t, sig) &&	/* and signal not blocked */
1599524a69fSRoger A. Faulkner 	    !sigismember(&t->t_sigwait, sig)));	/* and not being accepted */
1607c478bd9Sstevel@tonic-gate }
1617c478bd9Sstevel@tonic-gate 
1627c478bd9Sstevel@tonic-gate /*
1637c478bd9Sstevel@tonic-gate  * Return true if this thread is going to eat this signal soon.
16497eda132Sraf  * Note that, if the signal is SIGKILL, we force stopped threads to be
16597eda132Sraf  * set running (to make SIGKILL be a sure kill), but only if the process
16697eda132Sraf  * is not currently locked by /proc (the P_PR_LOCK flag).  Code in /proc
16797eda132Sraf  * relies on the fact that a process will not change shape while P_PR_LOCK
16897eda132Sraf  * is set (it drops and reacquires p->p_lock while leaving P_PR_LOCK set).
16997eda132Sraf  * We wish that we could simply call prbarrier() below, in sigtoproc(), to
17097eda132Sraf  * ensure that the process is not locked by /proc, but prbarrier() drops
17197eda132Sraf  * and reacquires p->p_lock and dropping p->p_lock here would be damaging.
1727c478bd9Sstevel@tonic-gate  */
1737c478bd9Sstevel@tonic-gate int
1747c478bd9Sstevel@tonic-gate eat_signal(kthread_t *t, int sig)
1757c478bd9Sstevel@tonic-gate {
1767c478bd9Sstevel@tonic-gate 	int rval = 0;
1777c478bd9Sstevel@tonic-gate 	ASSERT(THREAD_LOCK_HELD(t));
1787c478bd9Sstevel@tonic-gate 
1797c478bd9Sstevel@tonic-gate 	/*
1807c478bd9Sstevel@tonic-gate 	 * Do not do anything if the target thread has the signal blocked.
1817c478bd9Sstevel@tonic-gate 	 */
1827c478bd9Sstevel@tonic-gate 	if (!signal_is_blocked(t, sig)) {
1837c478bd9Sstevel@tonic-gate 		t->t_sig_check = 1;	/* have thread do an issig */
184c97ad5cdSakolb 		if (ISWAKEABLE(t) || ISWAITING(t)) {
1857c478bd9Sstevel@tonic-gate 			setrun_locked(t);
1867c478bd9Sstevel@tonic-gate 			rval = 1;
18797eda132Sraf 		} else if (t->t_state == TS_STOPPED && sig == SIGKILL &&
18897eda132Sraf 		    !(ttoproc(t)->p_proc_flag & P_PR_LOCK)) {
1897c478bd9Sstevel@tonic-gate 			ttoproc(t)->p_stopsig = 0;
1907c478bd9Sstevel@tonic-gate 			t->t_dtrace_stop = 0;
1917c478bd9Sstevel@tonic-gate 			t->t_schedflag |= TS_XSTART | TS_PSTART;
1927c478bd9Sstevel@tonic-gate 			setrun_locked(t);
1937c478bd9Sstevel@tonic-gate 		} else if (t != curthread && t->t_state == TS_ONPROC) {
194a8e07b22Smishra 			aston(t);	/* make it do issig promptly */
195a8e07b22Smishra 			if (t->t_cpu != CPU)
1967c478bd9Sstevel@tonic-gate 				poke_cpu(t->t_cpu->cpu_id);
1977c478bd9Sstevel@tonic-gate 			rval = 1;
1987c478bd9Sstevel@tonic-gate 		} else if (t->t_state == TS_RUN) {
1997c478bd9Sstevel@tonic-gate 			rval = 1;
2007c478bd9Sstevel@tonic-gate 		}
2017c478bd9Sstevel@tonic-gate 	}
2027c478bd9Sstevel@tonic-gate 
2037c478bd9Sstevel@tonic-gate 	return (rval);
2047c478bd9Sstevel@tonic-gate }
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate /*
2077c478bd9Sstevel@tonic-gate  * Post a signal.
2087c478bd9Sstevel@tonic-gate  * If a non-null thread pointer is passed, then post the signal
2097c478bd9Sstevel@tonic-gate  * to the thread/lwp, otherwise post the signal to the process.
2107c478bd9Sstevel@tonic-gate  */
2117c478bd9Sstevel@tonic-gate void
2127c478bd9Sstevel@tonic-gate sigtoproc(proc_t *p, kthread_t *t, int sig)
2137c478bd9Sstevel@tonic-gate {
2147c478bd9Sstevel@tonic-gate 	kthread_t *tt;
2157c478bd9Sstevel@tonic-gate 	int ext = !(curproc->p_flag & SSYS) &&
2167c478bd9Sstevel@tonic-gate 	    (curproc->p_ct_process != p->p_ct_process);
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
2197c478bd9Sstevel@tonic-gate 
220*35a5a358SJonathan Adams 	/* System processes don't get signals */
221*35a5a358SJonathan Adams 	if (sig <= 0 || sig >= NSIG || (p->p_flag & SSYS))
2227c478bd9Sstevel@tonic-gate 		return;
2237c478bd9Sstevel@tonic-gate 
2247c478bd9Sstevel@tonic-gate 	/*
2257c478bd9Sstevel@tonic-gate 	 * Regardless of origin or directedness,
2267c478bd9Sstevel@tonic-gate 	 * SIGKILL kills all lwps in the process immediately
2277c478bd9Sstevel@tonic-gate 	 * and jobcontrol signals affect all lwps in the process.
2287c478bd9Sstevel@tonic-gate 	 */
2297c478bd9Sstevel@tonic-gate 	if (sig == SIGKILL) {
2307c478bd9Sstevel@tonic-gate 		p->p_flag |= SKILLED | (ext ? SEXTKILLED : 0);
2317c478bd9Sstevel@tonic-gate 		t = NULL;
2327c478bd9Sstevel@tonic-gate 	} else if (sig == SIGCONT) {
2337c478bd9Sstevel@tonic-gate 		/*
2347c478bd9Sstevel@tonic-gate 		 * The SSCONT flag will remain set until a stopping
2357c478bd9Sstevel@tonic-gate 		 * signal comes in (below).  This is harmless.
2367c478bd9Sstevel@tonic-gate 		 */
2377c478bd9Sstevel@tonic-gate 		p->p_flag |= SSCONT;
2387c478bd9Sstevel@tonic-gate 		sigdelq(p, NULL, SIGSTOP);
2397c478bd9Sstevel@tonic-gate 		sigdelq(p, NULL, SIGTSTP);
2407c478bd9Sstevel@tonic-gate 		sigdelq(p, NULL, SIGTTOU);
2417c478bd9Sstevel@tonic-gate 		sigdelq(p, NULL, SIGTTIN);
2427c478bd9Sstevel@tonic-gate 		sigdiffset(&p->p_sig, &stopdefault);
2437c478bd9Sstevel@tonic-gate 		sigdiffset(&p->p_extsig, &stopdefault);
2447c478bd9Sstevel@tonic-gate 		p->p_stopsig = 0;
2457c478bd9Sstevel@tonic-gate 		if ((tt = p->p_tlist) != NULL) {
2467c478bd9Sstevel@tonic-gate 			do {
2477c478bd9Sstevel@tonic-gate 				sigdelq(p, tt, SIGSTOP);
2487c478bd9Sstevel@tonic-gate 				sigdelq(p, tt, SIGTSTP);
2497c478bd9Sstevel@tonic-gate 				sigdelq(p, tt, SIGTTOU);
2507c478bd9Sstevel@tonic-gate 				sigdelq(p, tt, SIGTTIN);
2517c478bd9Sstevel@tonic-gate 				sigdiffset(&tt->t_sig, &stopdefault);
2527c478bd9Sstevel@tonic-gate 				sigdiffset(&tt->t_extsig, &stopdefault);
2537c478bd9Sstevel@tonic-gate 			} while ((tt = tt->t_forw) != p->p_tlist);
2547c478bd9Sstevel@tonic-gate 		}
2557c478bd9Sstevel@tonic-gate 		if ((tt = p->p_tlist) != NULL) {
2567c478bd9Sstevel@tonic-gate 			do {
2577c478bd9Sstevel@tonic-gate 				thread_lock(tt);
2587c478bd9Sstevel@tonic-gate 				if (tt->t_state == TS_STOPPED &&
2597c478bd9Sstevel@tonic-gate 				    tt->t_whystop == PR_JOBCONTROL) {
2607c478bd9Sstevel@tonic-gate 					tt->t_schedflag |= TS_XSTART;
2617c478bd9Sstevel@tonic-gate 					setrun_locked(tt);
2627c478bd9Sstevel@tonic-gate 				}
2637c478bd9Sstevel@tonic-gate 				thread_unlock(tt);
2647c478bd9Sstevel@tonic-gate 			} while ((tt = tt->t_forw) != p->p_tlist);
2657c478bd9Sstevel@tonic-gate 		}
2667c478bd9Sstevel@tonic-gate 	} else if (sigismember(&stopdefault, sig)) {
2677c478bd9Sstevel@tonic-gate 		/*
2687c478bd9Sstevel@tonic-gate 		 * This test has a race condition which we can't fix:
2697c478bd9Sstevel@tonic-gate 		 * By the time the stopping signal is received by
2707c478bd9Sstevel@tonic-gate 		 * the target process/thread, the signal handler
2717c478bd9Sstevel@tonic-gate 		 * and/or the detached state might have changed.
2727c478bd9Sstevel@tonic-gate 		 */
2737c478bd9Sstevel@tonic-gate 		if (PTOU(p)->u_signal[sig-1] == SIG_DFL &&
2747c478bd9Sstevel@tonic-gate 		    (sig == SIGSTOP || !p->p_pgidp->pid_pgorphaned))
2757c478bd9Sstevel@tonic-gate 			p->p_flag &= ~SSCONT;
2767c478bd9Sstevel@tonic-gate 		sigdelq(p, NULL, SIGCONT);
2777c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_sig, SIGCONT);
2787c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_extsig, SIGCONT);
2797c478bd9Sstevel@tonic-gate 		if ((tt = p->p_tlist) != NULL) {
2807c478bd9Sstevel@tonic-gate 			do {
2817c478bd9Sstevel@tonic-gate 				sigdelq(p, tt, SIGCONT);
2827c478bd9Sstevel@tonic-gate 				sigdelset(&tt->t_sig, SIGCONT);
2837c478bd9Sstevel@tonic-gate 				sigdelset(&tt->t_extsig, SIGCONT);
2847c478bd9Sstevel@tonic-gate 			} while ((tt = tt->t_forw) != p->p_tlist);
2857c478bd9Sstevel@tonic-gate 		}
2867c478bd9Sstevel@tonic-gate 	}
2877c478bd9Sstevel@tonic-gate 
2887c478bd9Sstevel@tonic-gate 	if (sig_discardable(p, sig)) {
2897c478bd9Sstevel@tonic-gate 		DTRACE_PROC3(signal__discard, kthread_t *, p->p_tlist,
2907c478bd9Sstevel@tonic-gate 		    proc_t *, p, int, sig);
2917c478bd9Sstevel@tonic-gate 		return;
2927c478bd9Sstevel@tonic-gate 	}
2937c478bd9Sstevel@tonic-gate 
2947c478bd9Sstevel@tonic-gate 	if (t != NULL) {
2957c478bd9Sstevel@tonic-gate 		/*
2967c478bd9Sstevel@tonic-gate 		 * This is a directed signal, wake up the lwp.
2977c478bd9Sstevel@tonic-gate 		 */
2987c478bd9Sstevel@tonic-gate 		sigaddset(&t->t_sig, sig);
2997c478bd9Sstevel@tonic-gate 		if (ext)
3007c478bd9Sstevel@tonic-gate 			sigaddset(&t->t_extsig, sig);
3017c478bd9Sstevel@tonic-gate 		thread_lock(t);
3027c478bd9Sstevel@tonic-gate 		(void) eat_signal(t, sig);
3037c478bd9Sstevel@tonic-gate 		thread_unlock(t);
3047c478bd9Sstevel@tonic-gate 		DTRACE_PROC2(signal__send, kthread_t *, t, int, sig);
3057c478bd9Sstevel@tonic-gate 	} else if ((tt = p->p_tlist) != NULL) {
3067c478bd9Sstevel@tonic-gate 		/*
3077c478bd9Sstevel@tonic-gate 		 * Make sure that some lwp that already exists
3087c478bd9Sstevel@tonic-gate 		 * in the process fields the signal soon.
3097c478bd9Sstevel@tonic-gate 		 * Wake up an interruptibly sleeping lwp if necessary.
310cbdce38dSbpramod 		 * For SIGKILL make all of the lwps see the signal;
311cbdce38dSbpramod 		 * This is needed to guarantee a sure kill for processes
312cbdce38dSbpramod 		 * with a mix of realtime and non-realtime threads.
3137c478bd9Sstevel@tonic-gate 		 */
3147c478bd9Sstevel@tonic-gate 		int su = 0;
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate 		sigaddset(&p->p_sig, sig);
3177c478bd9Sstevel@tonic-gate 		if (ext)
3187c478bd9Sstevel@tonic-gate 			sigaddset(&p->p_extsig, sig);
3197c478bd9Sstevel@tonic-gate 		do {
3207c478bd9Sstevel@tonic-gate 			thread_lock(tt);
321cbdce38dSbpramod 			if (eat_signal(tt, sig) && sig != SIGKILL) {
3227c478bd9Sstevel@tonic-gate 				thread_unlock(tt);
3237c478bd9Sstevel@tonic-gate 				break;
3247c478bd9Sstevel@tonic-gate 			}
325cbdce38dSbpramod 			if (SUSPENDED(tt))
3267c478bd9Sstevel@tonic-gate 				su++;
3277c478bd9Sstevel@tonic-gate 			thread_unlock(tt);
3287c478bd9Sstevel@tonic-gate 		} while ((tt = tt->t_forw) != p->p_tlist);
3297c478bd9Sstevel@tonic-gate 		/*
3307c478bd9Sstevel@tonic-gate 		 * If the process is deadlocked, make somebody run and die.
3317c478bd9Sstevel@tonic-gate 		 */
3327c478bd9Sstevel@tonic-gate 		if (sig == SIGKILL && p->p_stat != SIDL &&
33397eda132Sraf 		    p->p_lwprcnt == 0 && p->p_lwpcnt == su &&
33497eda132Sraf 		    !(p->p_proc_flag & P_PR_LOCK)) {
3357c478bd9Sstevel@tonic-gate 			thread_lock(tt);
3367c478bd9Sstevel@tonic-gate 			p->p_lwprcnt++;
3377c478bd9Sstevel@tonic-gate 			tt->t_schedflag |= TS_CSTART;
3387c478bd9Sstevel@tonic-gate 			setrun_locked(tt);
3397c478bd9Sstevel@tonic-gate 			thread_unlock(tt);
3407c478bd9Sstevel@tonic-gate 		}
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 		DTRACE_PROC2(signal__send, kthread_t *, tt, int, sig);
3437c478bd9Sstevel@tonic-gate 	}
3447c478bd9Sstevel@tonic-gate }
3457c478bd9Sstevel@tonic-gate 
3467c478bd9Sstevel@tonic-gate static int
3477c478bd9Sstevel@tonic-gate isjobstop(int sig)
3487c478bd9Sstevel@tonic-gate {
3497c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(curthread);
3507c478bd9Sstevel@tonic-gate 
3517c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
3527c478bd9Sstevel@tonic-gate 
353ae115bc7Smrj 	if (PTOU(curproc)->u_signal[sig-1] == SIG_DFL &&
354ae115bc7Smrj 	    sigismember(&stopdefault, sig)) {
3557c478bd9Sstevel@tonic-gate 		/*
3567c478bd9Sstevel@tonic-gate 		 * If SIGCONT has been posted since we promoted this signal
3577c478bd9Sstevel@tonic-gate 		 * from pending to current, then don't do a jobcontrol stop.
3587c478bd9Sstevel@tonic-gate 		 */
3597c478bd9Sstevel@tonic-gate 		if (!(p->p_flag & SSCONT) &&
3607c478bd9Sstevel@tonic-gate 		    (sig == SIGSTOP || !p->p_pgidp->pid_pgorphaned) &&
3617c478bd9Sstevel@tonic-gate 		    curthread != p->p_agenttp) {
3627c478bd9Sstevel@tonic-gate 			sigqueue_t *sqp;
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 			stop(PR_JOBCONTROL, sig);
3657c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
3667c478bd9Sstevel@tonic-gate 			sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
3677c478bd9Sstevel@tonic-gate 			mutex_enter(&pidlock);
3687c478bd9Sstevel@tonic-gate 			/*
3697c478bd9Sstevel@tonic-gate 			 * Only the first lwp to continue notifies the parent.
3707c478bd9Sstevel@tonic-gate 			 */
3717c478bd9Sstevel@tonic-gate 			if (p->p_pidflag & CLDCONT)
3727c478bd9Sstevel@tonic-gate 				siginfofree(sqp);
3737c478bd9Sstevel@tonic-gate 			else {
3747c478bd9Sstevel@tonic-gate 				p->p_pidflag |= CLDCONT;
3757c478bd9Sstevel@tonic-gate 				p->p_wcode = CLD_CONTINUED;
3767c478bd9Sstevel@tonic-gate 				p->p_wdata = SIGCONT;
3777c478bd9Sstevel@tonic-gate 				sigcld(p, sqp);
3787c478bd9Sstevel@tonic-gate 			}
3797c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
3807c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
3817c478bd9Sstevel@tonic-gate 		}
3827c478bd9Sstevel@tonic-gate 		return (1);
3837c478bd9Sstevel@tonic-gate 	}
3847c478bd9Sstevel@tonic-gate 	return (0);
3857c478bd9Sstevel@tonic-gate }
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate /*
3887c478bd9Sstevel@tonic-gate  * Returns true if the current process has a signal to process, and
3897c478bd9Sstevel@tonic-gate  * the signal is not held.  The signal to process is put in p_cursig.
3907c478bd9Sstevel@tonic-gate  * This is asked at least once each time a process enters the system
3917c478bd9Sstevel@tonic-gate  * (though this can usually be done without actually calling issig by
3927c478bd9Sstevel@tonic-gate  * checking the pending signal masks).  A signal does not do anything
3937c478bd9Sstevel@tonic-gate  * directly to a process; it sets a flag that asks the process to do
3947c478bd9Sstevel@tonic-gate  * something to itself.
3957c478bd9Sstevel@tonic-gate  *
3967c478bd9Sstevel@tonic-gate  * The "why" argument indicates the allowable side-effects of the call:
3977c478bd9Sstevel@tonic-gate  *
3987c478bd9Sstevel@tonic-gate  * FORREAL:  Extract the next pending signal from p_sig into p_cursig;
3997c478bd9Sstevel@tonic-gate  * stop the process if a stop has been requested or if a traced signal
4007c478bd9Sstevel@tonic-gate  * is pending.
4017c478bd9Sstevel@tonic-gate  *
4027c478bd9Sstevel@tonic-gate  * JUSTLOOKING:  Don't stop the process, just indicate whether or not
4037c478bd9Sstevel@tonic-gate  * a signal might be pending (FORREAL is needed to tell for sure).
4047c478bd9Sstevel@tonic-gate  *
4057c478bd9Sstevel@tonic-gate  * XXX: Changes to the logic in these routines should be propagated
4067c478bd9Sstevel@tonic-gate  * to lm_sigispending().  See bug 1201594.
4077c478bd9Sstevel@tonic-gate  */
4087c478bd9Sstevel@tonic-gate 
4097c478bd9Sstevel@tonic-gate static int issig_forreal(void);
4107c478bd9Sstevel@tonic-gate static int issig_justlooking(void);
4117c478bd9Sstevel@tonic-gate 
4127c478bd9Sstevel@tonic-gate int
4137c478bd9Sstevel@tonic-gate issig(int why)
4147c478bd9Sstevel@tonic-gate {
4157c478bd9Sstevel@tonic-gate 	ASSERT(why == FORREAL || why == JUSTLOOKING);
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate 	return ((why == FORREAL)? issig_forreal() : issig_justlooking());
4187c478bd9Sstevel@tonic-gate }
4197c478bd9Sstevel@tonic-gate 
4207c478bd9Sstevel@tonic-gate 
4217c478bd9Sstevel@tonic-gate static int
4227c478bd9Sstevel@tonic-gate issig_justlooking(void)
4237c478bd9Sstevel@tonic-gate {
4247c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
4257c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
4267c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
4277c478bd9Sstevel@tonic-gate 	k_sigset_t set;
4287c478bd9Sstevel@tonic-gate 
4297c478bd9Sstevel@tonic-gate 	/*
4307c478bd9Sstevel@tonic-gate 	 * This function answers the question:
4317c478bd9Sstevel@tonic-gate 	 * "Is there any reason to call issig_forreal()?"
4327c478bd9Sstevel@tonic-gate 	 *
4337c478bd9Sstevel@tonic-gate 	 * We have to answer the question w/o grabbing any locks
4347c478bd9Sstevel@tonic-gate 	 * because we are (most likely) being called after we
4357c478bd9Sstevel@tonic-gate 	 * put ourselves on the sleep queue.
4367c478bd9Sstevel@tonic-gate 	 */
4377c478bd9Sstevel@tonic-gate 
4387c478bd9Sstevel@tonic-gate 	if (t->t_dtrace_stop | t->t_dtrace_sig)
4397c478bd9Sstevel@tonic-gate 		return (1);
4407c478bd9Sstevel@tonic-gate 
4417c478bd9Sstevel@tonic-gate 	/*
4427c478bd9Sstevel@tonic-gate 	 * Another piece of complexity in this process.  When single-stepping a
4437c478bd9Sstevel@tonic-gate 	 * process, we don't want an intervening signal or TP_PAUSE request to
4447c478bd9Sstevel@tonic-gate 	 * suspend the current thread.  Otherwise, the controlling process will
4457c478bd9Sstevel@tonic-gate 	 * hang beacuse we will be stopped with TS_PSTART set in t_schedflag.
4467c478bd9Sstevel@tonic-gate 	 * We will trigger any remaining signals when we re-enter the kernel on
4477c478bd9Sstevel@tonic-gate 	 * the single step trap.
4487c478bd9Sstevel@tonic-gate 	 */
4497c478bd9Sstevel@tonic-gate 	if (lwp->lwp_pcb.pcb_flags & NORMAL_STEP)
4507c478bd9Sstevel@tonic-gate 		return (0);
4517c478bd9Sstevel@tonic-gate 
4527c478bd9Sstevel@tonic-gate 	if ((lwp->lwp_asleep && MUSTRETURN(p, t)) ||
4537c478bd9Sstevel@tonic-gate 	    (p->p_flag & (SEXITLWPS|SKILLED)) ||
4548548bf79Snr123932 	    (lwp->lwp_nostop == 0 &&
4558548bf79Snr123932 	    (p->p_stopsig | (p->p_flag & (SHOLDFORK1|SHOLDWATCH)) |
4568548bf79Snr123932 	    (t->t_proc_flag &
4578548bf79Snr123932 	    (TP_PRSTOP|TP_HOLDLWP|TP_CHKPT|TP_PAUSE)))) ||
4587c478bd9Sstevel@tonic-gate 	    lwp->lwp_cursig)
4597c478bd9Sstevel@tonic-gate 		return (1);
4607c478bd9Sstevel@tonic-gate 
4617c478bd9Sstevel@tonic-gate 	if (p->p_flag & SVFWAIT)
4627c478bd9Sstevel@tonic-gate 		return (0);
4637c478bd9Sstevel@tonic-gate 	set = p->p_sig;
4647c478bd9Sstevel@tonic-gate 	sigorset(&set, &t->t_sig);
4657c478bd9Sstevel@tonic-gate 	if (schedctl_sigblock(t))	/* all blockable signals blocked */
4667c478bd9Sstevel@tonic-gate 		sigandset(&set, &cantmask);
4677c478bd9Sstevel@tonic-gate 	else
4687c478bd9Sstevel@tonic-gate 		sigdiffset(&set, &t->t_hold);
4697c478bd9Sstevel@tonic-gate 	if (p->p_flag & SVFORK)
4707c478bd9Sstevel@tonic-gate 		sigdiffset(&set, &holdvfork);
4717c478bd9Sstevel@tonic-gate 
4727c478bd9Sstevel@tonic-gate 	if (!sigisempty(&set)) {
4737c478bd9Sstevel@tonic-gate 		int sig;
4747c478bd9Sstevel@tonic-gate 
4757c478bd9Sstevel@tonic-gate 		for (sig = 1; sig < NSIG; sig++) {
4767c478bd9Sstevel@tonic-gate 			if (sigismember(&set, sig) &&
4777c478bd9Sstevel@tonic-gate 			    (tracing(p, sig) ||
4789524a69fSRoger A. Faulkner 			    sigismember(&t->t_sigwait, sig) ||
4797c478bd9Sstevel@tonic-gate 			    !sigismember(&p->p_ignore, sig))) {
4807c478bd9Sstevel@tonic-gate 				/*
4817c478bd9Sstevel@tonic-gate 				 * Don't promote a signal that will stop
4827c478bd9Sstevel@tonic-gate 				 * the process when lwp_nostop is set.
4837c478bd9Sstevel@tonic-gate 				 */
4847c478bd9Sstevel@tonic-gate 				if (!lwp->lwp_nostop ||
4853f12bda8SRoger A. Faulkner 				    PTOU(p)->u_signal[sig-1] != SIG_DFL ||
4867c478bd9Sstevel@tonic-gate 				    !sigismember(&stopdefault, sig))
4877c478bd9Sstevel@tonic-gate 					return (1);
4887c478bd9Sstevel@tonic-gate 			}
4897c478bd9Sstevel@tonic-gate 		}
4907c478bd9Sstevel@tonic-gate 	}
4917c478bd9Sstevel@tonic-gate 
4927c478bd9Sstevel@tonic-gate 	return (0);
4937c478bd9Sstevel@tonic-gate }
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate static int
4967c478bd9Sstevel@tonic-gate issig_forreal(void)
4977c478bd9Sstevel@tonic-gate {
4987c478bd9Sstevel@tonic-gate 	int sig = 0, ext = 0;
4997c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
5007c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
5017c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
5027c478bd9Sstevel@tonic-gate 	int toproc = 0;
5037c478bd9Sstevel@tonic-gate 	int sigcld_found = 0;
5047c478bd9Sstevel@tonic-gate 	int nostop_break = 0;
5057c478bd9Sstevel@tonic-gate 
5067c478bd9Sstevel@tonic-gate 	ASSERT(t->t_state == TS_ONPROC);
5077c478bd9Sstevel@tonic-gate 
5087c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
5097c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(t);
5107c478bd9Sstevel@tonic-gate 
5117c478bd9Sstevel@tonic-gate 	if (t->t_dtrace_stop | t->t_dtrace_sig) {
5127c478bd9Sstevel@tonic-gate 		if (t->t_dtrace_stop) {
5137c478bd9Sstevel@tonic-gate 			/*
5147c478bd9Sstevel@tonic-gate 			 * If DTrace's "stop" action has been invoked on us,
5157c478bd9Sstevel@tonic-gate 			 * set TP_PRSTOP.
5167c478bd9Sstevel@tonic-gate 			 */
5177c478bd9Sstevel@tonic-gate 			t->t_proc_flag |= TP_PRSTOP;
5187c478bd9Sstevel@tonic-gate 		}
5197c478bd9Sstevel@tonic-gate 
5207c478bd9Sstevel@tonic-gate 		if (t->t_dtrace_sig != 0) {
5217c478bd9Sstevel@tonic-gate 			k_siginfo_t info;
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate 			/*
5247c478bd9Sstevel@tonic-gate 			 * Post the signal generated as the result of
5257c478bd9Sstevel@tonic-gate 			 * DTrace's "raise" action as a normal signal before
5267c478bd9Sstevel@tonic-gate 			 * the full-fledged signal checking begins.
5277c478bd9Sstevel@tonic-gate 			 */
5287c478bd9Sstevel@tonic-gate 			bzero(&info, sizeof (info));
5297c478bd9Sstevel@tonic-gate 			info.si_signo = t->t_dtrace_sig;
5307c478bd9Sstevel@tonic-gate 			info.si_code = SI_DTRACE;
5317c478bd9Sstevel@tonic-gate 
5327c478bd9Sstevel@tonic-gate 			sigaddq(p, NULL, &info, KM_NOSLEEP);
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate 			t->t_dtrace_sig = 0;
5357c478bd9Sstevel@tonic-gate 		}
5367c478bd9Sstevel@tonic-gate 	}
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate 	for (;;) {
5397c478bd9Sstevel@tonic-gate 		if (p->p_flag & (SEXITLWPS|SKILLED)) {
5407c478bd9Sstevel@tonic-gate 			lwp->lwp_cursig = sig = SIGKILL;
5417c478bd9Sstevel@tonic-gate 			lwp->lwp_extsig = ext = (p->p_flag & SEXTKILLED) != 0;
542cbdce38dSbpramod 			t->t_sig_check = 1;
5437c478bd9Sstevel@tonic-gate 			break;
5447c478bd9Sstevel@tonic-gate 		}
5457c478bd9Sstevel@tonic-gate 
5467c478bd9Sstevel@tonic-gate 		/*
5477c478bd9Sstevel@tonic-gate 		 * Another piece of complexity in this process.  When
5487c478bd9Sstevel@tonic-gate 		 * single-stepping a process, we don't want an intervening
5497c478bd9Sstevel@tonic-gate 		 * signal or TP_PAUSE request to suspend the current thread.
5507c478bd9Sstevel@tonic-gate 		 * Otherwise, the controlling process will hang beacuse we will
5517c478bd9Sstevel@tonic-gate 		 * be stopped with TS_PSTART set in t_schedflag.  We will
5527c478bd9Sstevel@tonic-gate 		 * trigger any remaining signals when we re-enter the kernel on
5537c478bd9Sstevel@tonic-gate 		 * the single step trap.
5547c478bd9Sstevel@tonic-gate 		 */
5557c478bd9Sstevel@tonic-gate 		if (lwp->lwp_pcb.pcb_flags & NORMAL_STEP) {
5567c478bd9Sstevel@tonic-gate 			sig = 0;
5577c478bd9Sstevel@tonic-gate 			break;
5587c478bd9Sstevel@tonic-gate 		}
5597c478bd9Sstevel@tonic-gate 
5607c478bd9Sstevel@tonic-gate 		/*
5617c478bd9Sstevel@tonic-gate 		 * Hold the lwp here for watchpoint manipulation.
5627c478bd9Sstevel@tonic-gate 		 */
5637c478bd9Sstevel@tonic-gate 		if ((t->t_proc_flag & TP_PAUSE) && !lwp->lwp_nostop) {
5647c478bd9Sstevel@tonic-gate 			stop(PR_SUSPENDED, SUSPEND_PAUSE);
5657c478bd9Sstevel@tonic-gate 			continue;
5667c478bd9Sstevel@tonic-gate 		}
5677c478bd9Sstevel@tonic-gate 
5687c478bd9Sstevel@tonic-gate 		if (lwp->lwp_asleep && MUSTRETURN(p, t)) {
5697c478bd9Sstevel@tonic-gate 			if ((sig = lwp->lwp_cursig) != 0) {
5707c478bd9Sstevel@tonic-gate 				/*
5717c478bd9Sstevel@tonic-gate 				 * Make sure we call ISSIG() in post_syscall()
5727c478bd9Sstevel@tonic-gate 				 * to re-validate this current signal.
5737c478bd9Sstevel@tonic-gate 				 */
5747c478bd9Sstevel@tonic-gate 				t->t_sig_check = 1;
5757c478bd9Sstevel@tonic-gate 			}
5767c478bd9Sstevel@tonic-gate 			break;
5777c478bd9Sstevel@tonic-gate 		}
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate 		/*
5807c478bd9Sstevel@tonic-gate 		 * If the request is PR_CHECKPOINT, ignore the rest of signals
5817c478bd9Sstevel@tonic-gate 		 * or requests.  Honor other stop requests or signals later.
5827c478bd9Sstevel@tonic-gate 		 * Go back to top of loop here to check if an exit or hold
5837c478bd9Sstevel@tonic-gate 		 * event has occurred while stopped.
5847c478bd9Sstevel@tonic-gate 		 */
5857c478bd9Sstevel@tonic-gate 		if ((t->t_proc_flag & TP_CHKPT) && !lwp->lwp_nostop) {
5867c478bd9Sstevel@tonic-gate 			stop(PR_CHECKPOINT, 0);
5877c478bd9Sstevel@tonic-gate 			continue;
5887c478bd9Sstevel@tonic-gate 		}
5897c478bd9Sstevel@tonic-gate 
5907c478bd9Sstevel@tonic-gate 		/*
5917c478bd9Sstevel@tonic-gate 		 * Honor SHOLDFORK1, SHOLDWATCH, and TP_HOLDLWP before dealing
5927c478bd9Sstevel@tonic-gate 		 * with signals or /proc.  Another lwp is executing fork1(),
5937c478bd9Sstevel@tonic-gate 		 * or is undergoing watchpoint activity (remapping a page),
5947c478bd9Sstevel@tonic-gate 		 * or is executing lwp_suspend() on this lwp.
5957c478bd9Sstevel@tonic-gate 		 * Again, go back to top of loop to check if an exit
5967c478bd9Sstevel@tonic-gate 		 * or hold event has occurred while stopped.
5977c478bd9Sstevel@tonic-gate 		 */
5987c478bd9Sstevel@tonic-gate 		if (((p->p_flag & (SHOLDFORK1|SHOLDWATCH)) ||
5998548bf79Snr123932 		    (t->t_proc_flag & TP_HOLDLWP)) && !lwp->lwp_nostop) {
6007c478bd9Sstevel@tonic-gate 			stop(PR_SUSPENDED, SUSPEND_NORMAL);
6017c478bd9Sstevel@tonic-gate 			continue;
6027c478bd9Sstevel@tonic-gate 		}
6037c478bd9Sstevel@tonic-gate 
6047c478bd9Sstevel@tonic-gate 		/*
6057c478bd9Sstevel@tonic-gate 		 * Honor requested stop before dealing with the
6067c478bd9Sstevel@tonic-gate 		 * current signal; a debugger may change it.
6077c478bd9Sstevel@tonic-gate 		 * Do not want to go back to loop here since this is a special
6087c478bd9Sstevel@tonic-gate 		 * stop that means: make incremental progress before the next
6097c478bd9Sstevel@tonic-gate 		 * stop. The danger is that returning to top of loop would most
6107c478bd9Sstevel@tonic-gate 		 * likely drop the thread right back here to stop soon after it
6117c478bd9Sstevel@tonic-gate 		 * was continued, violating the incremental progress request.
6127c478bd9Sstevel@tonic-gate 		 */
6137c478bd9Sstevel@tonic-gate 		if ((t->t_proc_flag & TP_PRSTOP) && !lwp->lwp_nostop)
6147c478bd9Sstevel@tonic-gate 			stop(PR_REQUESTED, 0);
6157c478bd9Sstevel@tonic-gate 
6167c478bd9Sstevel@tonic-gate 		/*
6177c478bd9Sstevel@tonic-gate 		 * If a debugger wants us to take a signal it will have
6187c478bd9Sstevel@tonic-gate 		 * left it in lwp->lwp_cursig.  If lwp_cursig has been cleared
6197c478bd9Sstevel@tonic-gate 		 * or if it's being ignored, we continue on looking for another
6207c478bd9Sstevel@tonic-gate 		 * signal.  Otherwise we return the specified signal, provided
6217c478bd9Sstevel@tonic-gate 		 * it's not a signal that causes a job control stop.
6227c478bd9Sstevel@tonic-gate 		 *
6237c478bd9Sstevel@tonic-gate 		 * When stopped on PR_JOBCONTROL, there is no current
6247c478bd9Sstevel@tonic-gate 		 * signal; we cancel lwp->lwp_cursig temporarily before
6257c478bd9Sstevel@tonic-gate 		 * calling isjobstop().  The current signal may be reset
6267c478bd9Sstevel@tonic-gate 		 * by a debugger while we are stopped in isjobstop().
6279524a69fSRoger A. Faulkner 		 *
6289524a69fSRoger A. Faulkner 		 * If the current thread is accepting the signal
6299524a69fSRoger A. Faulkner 		 * (via sigwait(), sigwaitinfo(), or sigtimedwait()),
6309524a69fSRoger A. Faulkner 		 * we allow the signal to be accepted, even if it is
6319524a69fSRoger A. Faulkner 		 * being ignored, and without causing a job control stop.
6327c478bd9Sstevel@tonic-gate 		 */
6337c478bd9Sstevel@tonic-gate 		if ((sig = lwp->lwp_cursig) != 0) {
6347c478bd9Sstevel@tonic-gate 			ext = lwp->lwp_extsig;
6357c478bd9Sstevel@tonic-gate 			lwp->lwp_cursig = 0;
6367c478bd9Sstevel@tonic-gate 			lwp->lwp_extsig = 0;
6379524a69fSRoger A. Faulkner 			if (sigismember(&t->t_sigwait, sig) ||
6389524a69fSRoger A. Faulkner 			    (!sigismember(&p->p_ignore, sig) &&
6399524a69fSRoger A. Faulkner 			    !isjobstop(sig))) {
6407c478bd9Sstevel@tonic-gate 				if (p->p_flag & (SEXITLWPS|SKILLED)) {
6417c478bd9Sstevel@tonic-gate 					sig = SIGKILL;
6427c478bd9Sstevel@tonic-gate 					ext = (p->p_flag & SEXTKILLED) != 0;
6437c478bd9Sstevel@tonic-gate 				}
6447c478bd9Sstevel@tonic-gate 				lwp->lwp_cursig = (uchar_t)sig;
6457c478bd9Sstevel@tonic-gate 				lwp->lwp_extsig = (uchar_t)ext;
6467c478bd9Sstevel@tonic-gate 				break;
6477c478bd9Sstevel@tonic-gate 			}
6487c478bd9Sstevel@tonic-gate 			/*
6497c478bd9Sstevel@tonic-gate 			 * The signal is being ignored or it caused a
6507c478bd9Sstevel@tonic-gate 			 * job-control stop.  If another current signal
6517c478bd9Sstevel@tonic-gate 			 * has not been established, return the current
6527c478bd9Sstevel@tonic-gate 			 * siginfo, if any, to the memory manager.
6537c478bd9Sstevel@tonic-gate 			 */
6547c478bd9Sstevel@tonic-gate 			if (lwp->lwp_cursig == 0 && lwp->lwp_curinfo != NULL) {
6557c478bd9Sstevel@tonic-gate 				siginfofree(lwp->lwp_curinfo);
6567c478bd9Sstevel@tonic-gate 				lwp->lwp_curinfo = NULL;
6577c478bd9Sstevel@tonic-gate 			}
6587c478bd9Sstevel@tonic-gate 			/*
6597c478bd9Sstevel@tonic-gate 			 * Loop around again in case we were stopped
6607c478bd9Sstevel@tonic-gate 			 * on a job control signal and a /proc stop
6617c478bd9Sstevel@tonic-gate 			 * request was posted or another current signal
6627c478bd9Sstevel@tonic-gate 			 * was established while we were stopped.
6637c478bd9Sstevel@tonic-gate 			 */
6647c478bd9Sstevel@tonic-gate 			continue;
6657c478bd9Sstevel@tonic-gate 		}
6667c478bd9Sstevel@tonic-gate 
6677c478bd9Sstevel@tonic-gate 		if (p->p_stopsig && !lwp->lwp_nostop &&
6687c478bd9Sstevel@tonic-gate 		    curthread != p->p_agenttp) {
6697c478bd9Sstevel@tonic-gate 			/*
6707c478bd9Sstevel@tonic-gate 			 * Some lwp in the process has already stopped
6717c478bd9Sstevel@tonic-gate 			 * showing PR_JOBCONTROL.  This is a stop in
6727c478bd9Sstevel@tonic-gate 			 * sympathy with the other lwp, even if this
6737c478bd9Sstevel@tonic-gate 			 * lwp is blocking the stopping signal.
6747c478bd9Sstevel@tonic-gate 			 */
6757c478bd9Sstevel@tonic-gate 			stop(PR_JOBCONTROL, p->p_stopsig);
6767c478bd9Sstevel@tonic-gate 			continue;
6777c478bd9Sstevel@tonic-gate 		}
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate 		/*
6807c478bd9Sstevel@tonic-gate 		 * Loop on the pending signals until we find a
6817c478bd9Sstevel@tonic-gate 		 * non-held signal that is traced or not ignored.
6827c478bd9Sstevel@tonic-gate 		 * First check the signals pending for the lwp,
6837c478bd9Sstevel@tonic-gate 		 * then the signals pending for the process as a whole.
6847c478bd9Sstevel@tonic-gate 		 */
6857c478bd9Sstevel@tonic-gate 		for (;;) {
6869524a69fSRoger A. Faulkner 			if ((sig = fsig(&t->t_sig, t)) != 0) {
6877c478bd9Sstevel@tonic-gate 				toproc = 0;
6887c478bd9Sstevel@tonic-gate 				if (tracing(p, sig) ||
6899524a69fSRoger A. Faulkner 				    sigismember(&t->t_sigwait, sig) ||
6907c478bd9Sstevel@tonic-gate 				    !sigismember(&p->p_ignore, sig)) {
6917c478bd9Sstevel@tonic-gate 					if (sigismember(&t->t_extsig, sig))
6927c478bd9Sstevel@tonic-gate 						ext = 1;
6937c478bd9Sstevel@tonic-gate 					break;
6947c478bd9Sstevel@tonic-gate 				}
6957c478bd9Sstevel@tonic-gate 				sigdelset(&t->t_sig, sig);
6967c478bd9Sstevel@tonic-gate 				sigdelset(&t->t_extsig, sig);
6977c478bd9Sstevel@tonic-gate 				sigdelq(p, t, sig);
6987c478bd9Sstevel@tonic-gate 			} else if ((sig = fsig(&p->p_sig, t)) != 0) {
6997c478bd9Sstevel@tonic-gate 				if (sig == SIGCLD)
7007c478bd9Sstevel@tonic-gate 					sigcld_found = 1;
7017c478bd9Sstevel@tonic-gate 				toproc = 1;
7027c478bd9Sstevel@tonic-gate 				if (tracing(p, sig) ||
7039524a69fSRoger A. Faulkner 				    sigismember(&t->t_sigwait, sig) ||
7047c478bd9Sstevel@tonic-gate 				    !sigismember(&p->p_ignore, sig)) {
7057c478bd9Sstevel@tonic-gate 					if (sigismember(&p->p_extsig, sig))
7067c478bd9Sstevel@tonic-gate 						ext = 1;
7077c478bd9Sstevel@tonic-gate 					break;
7087c478bd9Sstevel@tonic-gate 				}
7097c478bd9Sstevel@tonic-gate 				sigdelset(&p->p_sig, sig);
7107c478bd9Sstevel@tonic-gate 				sigdelset(&p->p_extsig, sig);
7117c478bd9Sstevel@tonic-gate 				sigdelq(p, NULL, sig);
7127c478bd9Sstevel@tonic-gate 			} else {
7137c478bd9Sstevel@tonic-gate 				/* no signal was found */
7147c478bd9Sstevel@tonic-gate 				break;
7157c478bd9Sstevel@tonic-gate 			}
7167c478bd9Sstevel@tonic-gate 		}
7177c478bd9Sstevel@tonic-gate 
7187c478bd9Sstevel@tonic-gate 		if (sig == 0) {	/* no signal was found */
7197c478bd9Sstevel@tonic-gate 			if (p->p_flag & (SEXITLWPS|SKILLED)) {
7207c478bd9Sstevel@tonic-gate 				lwp->lwp_cursig = SIGKILL;
7217c478bd9Sstevel@tonic-gate 				sig = SIGKILL;
7227c478bd9Sstevel@tonic-gate 				ext = (p->p_flag & SEXTKILLED) != 0;
7237c478bd9Sstevel@tonic-gate 			}
7247c478bd9Sstevel@tonic-gate 			break;
7257c478bd9Sstevel@tonic-gate 		}
7267c478bd9Sstevel@tonic-gate 
7277c478bd9Sstevel@tonic-gate 		/*
7287c478bd9Sstevel@tonic-gate 		 * If we have been informed not to stop (i.e., we are being
7297c478bd9Sstevel@tonic-gate 		 * called from within a network operation), then don't promote
7307c478bd9Sstevel@tonic-gate 		 * the signal at this time, just return the signal number.
7317c478bd9Sstevel@tonic-gate 		 * We will call issig() again later when it is safe.
7327c478bd9Sstevel@tonic-gate 		 *
7337c478bd9Sstevel@tonic-gate 		 * fsig() does not return a jobcontrol stopping signal
7347c478bd9Sstevel@tonic-gate 		 * with a default action of stopping the process if
7357c478bd9Sstevel@tonic-gate 		 * lwp_nostop is set, so we won't be causing a bogus
7367c478bd9Sstevel@tonic-gate 		 * EINTR by this action.  (Such a signal is eaten by
7377c478bd9Sstevel@tonic-gate 		 * isjobstop() when we loop around to do final checks.)
7387c478bd9Sstevel@tonic-gate 		 */
7397c478bd9Sstevel@tonic-gate 		if (lwp->lwp_nostop) {
7407c478bd9Sstevel@tonic-gate 			nostop_break = 1;
7417c478bd9Sstevel@tonic-gate 			break;
7427c478bd9Sstevel@tonic-gate 		}
7437c478bd9Sstevel@tonic-gate 
7447c478bd9Sstevel@tonic-gate 		/*
7457c478bd9Sstevel@tonic-gate 		 * Promote the signal from pending to current.
7467c478bd9Sstevel@tonic-gate 		 *
7477c478bd9Sstevel@tonic-gate 		 * Note that sigdeq() will set lwp->lwp_curinfo to NULL
7487c478bd9Sstevel@tonic-gate 		 * if no siginfo_t exists for this signal.
7497c478bd9Sstevel@tonic-gate 		 */
7507c478bd9Sstevel@tonic-gate 		lwp->lwp_cursig = (uchar_t)sig;
7517c478bd9Sstevel@tonic-gate 		lwp->lwp_extsig = (uchar_t)ext;
7527c478bd9Sstevel@tonic-gate 		t->t_sig_check = 1;	/* so post_syscall will see signal */
7537c478bd9Sstevel@tonic-gate 		ASSERT(lwp->lwp_curinfo == NULL);
7547c478bd9Sstevel@tonic-gate 		sigdeq(p, toproc ? NULL : t, sig, &lwp->lwp_curinfo);
7557c478bd9Sstevel@tonic-gate 
7567c478bd9Sstevel@tonic-gate 		if (tracing(p, sig))
7577c478bd9Sstevel@tonic-gate 			stop(PR_SIGNALLED, sig);
7587c478bd9Sstevel@tonic-gate 
7597c478bd9Sstevel@tonic-gate 		/*
7607c478bd9Sstevel@tonic-gate 		 * Loop around to check for requested stop before
7617c478bd9Sstevel@tonic-gate 		 * performing the usual current-signal actions.
7627c478bd9Sstevel@tonic-gate 		 */
7637c478bd9Sstevel@tonic-gate 	}
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
7667c478bd9Sstevel@tonic-gate 
7677c478bd9Sstevel@tonic-gate 	/*
7683f12bda8SRoger A. Faulkner 	 * If SIGCLD was dequeued from the process's signal queue,
7693f12bda8SRoger A. Faulkner 	 * search for other pending SIGCLD's from the list of children.
7707c478bd9Sstevel@tonic-gate 	 */
7713f12bda8SRoger A. Faulkner 	if (sigcld_found)
7727c478bd9Sstevel@tonic-gate 		sigcld_repost();
7737c478bd9Sstevel@tonic-gate 
7747c478bd9Sstevel@tonic-gate 	if (sig != 0)
7757c478bd9Sstevel@tonic-gate 		(void) undo_watch_step(NULL);
7767c478bd9Sstevel@tonic-gate 
7777c478bd9Sstevel@tonic-gate 	/*
7787c478bd9Sstevel@tonic-gate 	 * If we have been blocked since the p_lock was dropped off
7797c478bd9Sstevel@tonic-gate 	 * above, then this promoted signal might have been handled
7807c478bd9Sstevel@tonic-gate 	 * already when we were on the way back from sleep queue, so
7817c478bd9Sstevel@tonic-gate 	 * just ignore it.
7827c478bd9Sstevel@tonic-gate 	 * If we have been informed not to stop, just return the signal
7837c478bd9Sstevel@tonic-gate 	 * number. Also see comments above.
7847c478bd9Sstevel@tonic-gate 	 */
7857c478bd9Sstevel@tonic-gate 	if (!nostop_break) {
7867c478bd9Sstevel@tonic-gate 		sig = lwp->lwp_cursig;
7877c478bd9Sstevel@tonic-gate 	}
7887c478bd9Sstevel@tonic-gate 
7897c478bd9Sstevel@tonic-gate 	return (sig != 0);
7907c478bd9Sstevel@tonic-gate }
7917c478bd9Sstevel@tonic-gate 
7927c478bd9Sstevel@tonic-gate /*
7937c478bd9Sstevel@tonic-gate  * Return true if the process is currently stopped showing PR_JOBCONTROL.
7947c478bd9Sstevel@tonic-gate  * This is true only if all of the process's lwp's are so stopped.
7957c478bd9Sstevel@tonic-gate  * If this is asked by one of the lwps in the process, exclude that lwp.
7967c478bd9Sstevel@tonic-gate  */
7977c478bd9Sstevel@tonic-gate int
7987c478bd9Sstevel@tonic-gate jobstopped(proc_t *p)
7997c478bd9Sstevel@tonic-gate {
8007c478bd9Sstevel@tonic-gate 	kthread_t *t;
8017c478bd9Sstevel@tonic-gate 
8027c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8037c478bd9Sstevel@tonic-gate 
8047c478bd9Sstevel@tonic-gate 	if ((t = p->p_tlist) == NULL)
8057c478bd9Sstevel@tonic-gate 		return (0);
8067c478bd9Sstevel@tonic-gate 
8077c478bd9Sstevel@tonic-gate 	do {
8087c478bd9Sstevel@tonic-gate 		thread_lock(t);
8097c478bd9Sstevel@tonic-gate 		/* ignore current, zombie and suspended lwps in the test */
8107c478bd9Sstevel@tonic-gate 		if (!(t == curthread || t->t_state == TS_ZOMB ||
8117c478bd9Sstevel@tonic-gate 		    SUSPENDED(t)) &&
8127c478bd9Sstevel@tonic-gate 		    (t->t_state != TS_STOPPED ||
8137c478bd9Sstevel@tonic-gate 		    t->t_whystop != PR_JOBCONTROL)) {
8147c478bd9Sstevel@tonic-gate 			thread_unlock(t);
8157c478bd9Sstevel@tonic-gate 			return (0);
8167c478bd9Sstevel@tonic-gate 		}
8177c478bd9Sstevel@tonic-gate 		thread_unlock(t);
8187c478bd9Sstevel@tonic-gate 	} while ((t = t->t_forw) != p->p_tlist);
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 	return (1);
8217c478bd9Sstevel@tonic-gate }
8227c478bd9Sstevel@tonic-gate 
8237c478bd9Sstevel@tonic-gate /*
8247c478bd9Sstevel@tonic-gate  * Put ourself (curthread) into the stopped state and notify tracers.
8257c478bd9Sstevel@tonic-gate  */
8267c478bd9Sstevel@tonic-gate void
8277c478bd9Sstevel@tonic-gate stop(int why, int what)
8287c478bd9Sstevel@tonic-gate {
8297c478bd9Sstevel@tonic-gate 	kthread_t	*t = curthread;
8307c478bd9Sstevel@tonic-gate 	proc_t		*p = ttoproc(t);
8317c478bd9Sstevel@tonic-gate 	klwp_t		*lwp = ttolwp(t);
8327c478bd9Sstevel@tonic-gate 	kthread_t	*tx;
8337c478bd9Sstevel@tonic-gate 	lwpent_t	*lep;
8347c478bd9Sstevel@tonic-gate 	int		procstop;
8357c478bd9Sstevel@tonic-gate 	int		flags = TS_ALLSTART;
8367c478bd9Sstevel@tonic-gate 	hrtime_t	stoptime;
8377c478bd9Sstevel@tonic-gate 
8387c478bd9Sstevel@tonic-gate 	/*
8397c478bd9Sstevel@tonic-gate 	 * Can't stop a system process.
8407c478bd9Sstevel@tonic-gate 	 */
8417c478bd9Sstevel@tonic-gate 	if (p == NULL || lwp == NULL || (p->p_flag & SSYS) || p->p_as == &kas)
8427c478bd9Sstevel@tonic-gate 		return;
8437c478bd9Sstevel@tonic-gate 
8447c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8457c478bd9Sstevel@tonic-gate 
8467c478bd9Sstevel@tonic-gate 	if (why != PR_SUSPENDED && why != PR_CHECKPOINT) {
8477c478bd9Sstevel@tonic-gate 		/*
8487c478bd9Sstevel@tonic-gate 		 * Don't stop an lwp with SIGKILL pending.
8497c478bd9Sstevel@tonic-gate 		 * Don't stop if the process or lwp is exiting.
8507c478bd9Sstevel@tonic-gate 		 */
8517c478bd9Sstevel@tonic-gate 		if (lwp->lwp_cursig == SIGKILL ||
8527c478bd9Sstevel@tonic-gate 		    sigismember(&t->t_sig, SIGKILL) ||
8537c478bd9Sstevel@tonic-gate 		    sigismember(&p->p_sig, SIGKILL) ||
8547c478bd9Sstevel@tonic-gate 		    (t->t_proc_flag & TP_LWPEXIT) ||
8557c478bd9Sstevel@tonic-gate 		    (p->p_flag & (SEXITLWPS|SKILLED))) {
8567c478bd9Sstevel@tonic-gate 			p->p_stopsig = 0;
8577c478bd9Sstevel@tonic-gate 			t->t_proc_flag &= ~(TP_PRSTOP|TP_PRVSTOP);
8587c478bd9Sstevel@tonic-gate 			return;
8597c478bd9Sstevel@tonic-gate 		}
8607c478bd9Sstevel@tonic-gate 	}
8617c478bd9Sstevel@tonic-gate 
8627c478bd9Sstevel@tonic-gate 	/*
8637c478bd9Sstevel@tonic-gate 	 * Make sure we don't deadlock on a recursive call to prstop().
8648548bf79Snr123932 	 * prstop() sets the lwp_nostop flag.
8657c478bd9Sstevel@tonic-gate 	 */
8668548bf79Snr123932 	if (lwp->lwp_nostop)
8677c478bd9Sstevel@tonic-gate 		return;
8687c478bd9Sstevel@tonic-gate 
8697c478bd9Sstevel@tonic-gate 	/*
8707c478bd9Sstevel@tonic-gate 	 * Make sure the lwp is in an orderly state for inspection
8717c478bd9Sstevel@tonic-gate 	 * by a debugger through /proc or for dumping via core().
8727c478bd9Sstevel@tonic-gate 	 */
8737c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(t);
8747c478bd9Sstevel@tonic-gate 	t->t_proc_flag |= TP_STOPPING;	/* must set before dropping p_lock */
8757c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
8767c478bd9Sstevel@tonic-gate 	stoptime = gethrtime();
8777c478bd9Sstevel@tonic-gate 	prstop(why, what);
8787c478bd9Sstevel@tonic-gate 	(void) undo_watch_step(NULL);
8797c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
8807c478bd9Sstevel@tonic-gate 	ASSERT(t->t_state == TS_ONPROC);
8817c478bd9Sstevel@tonic-gate 
8827c478bd9Sstevel@tonic-gate 	switch (why) {
8837c478bd9Sstevel@tonic-gate 	case PR_CHECKPOINT:
8847c478bd9Sstevel@tonic-gate 		/*
8857c478bd9Sstevel@tonic-gate 		 * The situation may have changed since we dropped
8867c478bd9Sstevel@tonic-gate 		 * and reacquired p->p_lock. Double-check now
8877c478bd9Sstevel@tonic-gate 		 * whether we should stop or not.
8887c478bd9Sstevel@tonic-gate 		 */
8897c478bd9Sstevel@tonic-gate 		if (!(t->t_proc_flag & TP_CHKPT)) {
8907c478bd9Sstevel@tonic-gate 			t->t_proc_flag &= ~TP_STOPPING;
8917c478bd9Sstevel@tonic-gate 			return;
8927c478bd9Sstevel@tonic-gate 		}
8937c478bd9Sstevel@tonic-gate 		t->t_proc_flag &= ~TP_CHKPT;
8947c478bd9Sstevel@tonic-gate 		flags &= ~TS_RESUME;
8957c478bd9Sstevel@tonic-gate 		break;
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate 	case PR_JOBCONTROL:
8987c478bd9Sstevel@tonic-gate 		ASSERT(what == SIGSTOP || what == SIGTSTP ||
8997c478bd9Sstevel@tonic-gate 		    what == SIGTTIN || what == SIGTTOU);
9007c478bd9Sstevel@tonic-gate 		flags &= ~TS_XSTART;
9017c478bd9Sstevel@tonic-gate 		break;
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate 	case PR_SUSPENDED:
9047c478bd9Sstevel@tonic-gate 		ASSERT(what == SUSPEND_NORMAL || what == SUSPEND_PAUSE);
9057c478bd9Sstevel@tonic-gate 		/*
9067c478bd9Sstevel@tonic-gate 		 * The situation may have changed since we dropped
9077c478bd9Sstevel@tonic-gate 		 * and reacquired p->p_lock.  Double-check now
9087c478bd9Sstevel@tonic-gate 		 * whether we should stop or not.
9097c478bd9Sstevel@tonic-gate 		 */
9107c478bd9Sstevel@tonic-gate 		if (what == SUSPEND_PAUSE) {
9117c478bd9Sstevel@tonic-gate 			if (!(t->t_proc_flag & TP_PAUSE)) {
9127c478bd9Sstevel@tonic-gate 				t->t_proc_flag &= ~TP_STOPPING;
9137c478bd9Sstevel@tonic-gate 				return;
9147c478bd9Sstevel@tonic-gate 			}
9157c478bd9Sstevel@tonic-gate 			flags &= ~TS_UNPAUSE;
9167c478bd9Sstevel@tonic-gate 		} else {
9177c478bd9Sstevel@tonic-gate 			if (!((t->t_proc_flag & TP_HOLDLWP) ||
9187c478bd9Sstevel@tonic-gate 			    (p->p_flag & (SHOLDFORK|SHOLDFORK1|SHOLDWATCH)))) {
9197c478bd9Sstevel@tonic-gate 				t->t_proc_flag &= ~TP_STOPPING;
9207c478bd9Sstevel@tonic-gate 				return;
9217c478bd9Sstevel@tonic-gate 			}
9227c478bd9Sstevel@tonic-gate 			/*
9237c478bd9Sstevel@tonic-gate 			 * If SHOLDFORK is in effect and we are stopping
9247c478bd9Sstevel@tonic-gate 			 * while asleep (not at the top of the stack),
9257c478bd9Sstevel@tonic-gate 			 * we return now to allow the hold to take effect
9267c478bd9Sstevel@tonic-gate 			 * when we reach the top of the kernel stack.
9277c478bd9Sstevel@tonic-gate 			 */
9287c478bd9Sstevel@tonic-gate 			if (lwp->lwp_asleep && (p->p_flag & SHOLDFORK)) {
9297c478bd9Sstevel@tonic-gate 				t->t_proc_flag &= ~TP_STOPPING;
9307c478bd9Sstevel@tonic-gate 				return;
9317c478bd9Sstevel@tonic-gate 			}
9327c478bd9Sstevel@tonic-gate 			flags &= ~TS_CSTART;
9337c478bd9Sstevel@tonic-gate 		}
9347c478bd9Sstevel@tonic-gate 		break;
9357c478bd9Sstevel@tonic-gate 
9367c478bd9Sstevel@tonic-gate 	default:	/* /proc stop */
9377c478bd9Sstevel@tonic-gate 		flags &= ~TS_PSTART;
9387c478bd9Sstevel@tonic-gate 		/*
9397c478bd9Sstevel@tonic-gate 		 * Do synchronous stop unless the async-stop flag is set.
9407c478bd9Sstevel@tonic-gate 		 * If why is PR_REQUESTED and t->t_dtrace_stop flag is set,
9417c478bd9Sstevel@tonic-gate 		 * then no debugger is present and we also do synchronous stop.
9427c478bd9Sstevel@tonic-gate 		 */
9437c478bd9Sstevel@tonic-gate 		if ((why != PR_REQUESTED || t->t_dtrace_stop) &&
9447c478bd9Sstevel@tonic-gate 		    !(p->p_proc_flag & P_PR_ASYNC)) {
9457c478bd9Sstevel@tonic-gate 			int notify;
9467c478bd9Sstevel@tonic-gate 
9477c478bd9Sstevel@tonic-gate 			for (tx = t->t_forw; tx != t; tx = tx->t_forw) {
9487c478bd9Sstevel@tonic-gate 				notify = 0;
9497c478bd9Sstevel@tonic-gate 				thread_lock(tx);
9507c478bd9Sstevel@tonic-gate 				if (ISTOPPED(tx) ||
9517c478bd9Sstevel@tonic-gate 				    (tx->t_proc_flag & TP_PRSTOP)) {
9527c478bd9Sstevel@tonic-gate 					thread_unlock(tx);
9537c478bd9Sstevel@tonic-gate 					continue;
9547c478bd9Sstevel@tonic-gate 				}
9557c478bd9Sstevel@tonic-gate 				tx->t_proc_flag |= TP_PRSTOP;
9567c478bd9Sstevel@tonic-gate 				tx->t_sig_check = 1;
9577c478bd9Sstevel@tonic-gate 				if (tx->t_state == TS_SLEEP &&
9587c478bd9Sstevel@tonic-gate 				    (tx->t_flag & T_WAKEABLE)) {
9597c478bd9Sstevel@tonic-gate 					/*
9607c478bd9Sstevel@tonic-gate 					 * Don't actually wake it up if it's
9617c478bd9Sstevel@tonic-gate 					 * in one of the lwp_*() syscalls.
9627c478bd9Sstevel@tonic-gate 					 * Mark it virtually stopped and
9637c478bd9Sstevel@tonic-gate 					 * notify /proc waiters (below).
9647c478bd9Sstevel@tonic-gate 					 */
9657c478bd9Sstevel@tonic-gate 					if (tx->t_wchan0 == NULL)
9667c478bd9Sstevel@tonic-gate 						setrun_locked(tx);
9677c478bd9Sstevel@tonic-gate 					else {
9687c478bd9Sstevel@tonic-gate 						tx->t_proc_flag |= TP_PRVSTOP;
9697c478bd9Sstevel@tonic-gate 						tx->t_stoptime = stoptime;
9707c478bd9Sstevel@tonic-gate 						notify = 1;
9717c478bd9Sstevel@tonic-gate 					}
9727c478bd9Sstevel@tonic-gate 				}
973c97ad5cdSakolb 
974c97ad5cdSakolb 				/* Move waiting thread to run queue */
975c97ad5cdSakolb 				if (ISWAITING(tx))
976c97ad5cdSakolb 					setrun_locked(tx);
977c97ad5cdSakolb 
9787c478bd9Sstevel@tonic-gate 				/*
9797c478bd9Sstevel@tonic-gate 				 * force the thread into the kernel
9807c478bd9Sstevel@tonic-gate 				 * if it is not already there.
9817c478bd9Sstevel@tonic-gate 				 */
9827c478bd9Sstevel@tonic-gate 				if (tx->t_state == TS_ONPROC &&
9837c478bd9Sstevel@tonic-gate 				    tx->t_cpu != CPU)
9847c478bd9Sstevel@tonic-gate 					poke_cpu(tx->t_cpu->cpu_id);
9857c478bd9Sstevel@tonic-gate 				thread_unlock(tx);
9867c478bd9Sstevel@tonic-gate 				lep = p->p_lwpdir[tx->t_dslot].ld_entry;
9877c478bd9Sstevel@tonic-gate 				if (notify && lep->le_trace)
9887c478bd9Sstevel@tonic-gate 					prnotify(lep->le_trace);
9897c478bd9Sstevel@tonic-gate 			}
9907c478bd9Sstevel@tonic-gate 			/*
9917c478bd9Sstevel@tonic-gate 			 * We do this just in case one of the threads we asked
9927c478bd9Sstevel@tonic-gate 			 * to stop is in holdlwps() (called from cfork()) or
9937c478bd9Sstevel@tonic-gate 			 * lwp_suspend().
9947c478bd9Sstevel@tonic-gate 			 */
9957c478bd9Sstevel@tonic-gate 			cv_broadcast(&p->p_holdlwps);
9967c478bd9Sstevel@tonic-gate 		}
9977c478bd9Sstevel@tonic-gate 		break;
9987c478bd9Sstevel@tonic-gate 	}
9997c478bd9Sstevel@tonic-gate 
10007c478bd9Sstevel@tonic-gate 	t->t_stoptime = stoptime;
10017c478bd9Sstevel@tonic-gate 
10027c478bd9Sstevel@tonic-gate 	if (why == PR_JOBCONTROL || (why == PR_SUSPENDED && p->p_stopsig)) {
10037c478bd9Sstevel@tonic-gate 		/*
10047c478bd9Sstevel@tonic-gate 		 * Determine if the whole process is jobstopped.
10057c478bd9Sstevel@tonic-gate 		 */
10067c478bd9Sstevel@tonic-gate 		if (jobstopped(p)) {
10077c478bd9Sstevel@tonic-gate 			sigqueue_t *sqp;
10087c478bd9Sstevel@tonic-gate 			int sig;
10097c478bd9Sstevel@tonic-gate 
10107c478bd9Sstevel@tonic-gate 			if ((sig = p->p_stopsig) == 0)
10117c478bd9Sstevel@tonic-gate 				p->p_stopsig = (uchar_t)(sig = what);
10127c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
10137c478bd9Sstevel@tonic-gate 			sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
10147c478bd9Sstevel@tonic-gate 			mutex_enter(&pidlock);
10157c478bd9Sstevel@tonic-gate 			/*
10167c478bd9Sstevel@tonic-gate 			 * The last lwp to stop notifies the parent.
10177c478bd9Sstevel@tonic-gate 			 * Turn off the CLDCONT flag now so the first
10187c478bd9Sstevel@tonic-gate 			 * lwp to continue knows what to do.
10197c478bd9Sstevel@tonic-gate 			 */
10207c478bd9Sstevel@tonic-gate 			p->p_pidflag &= ~CLDCONT;
10217c478bd9Sstevel@tonic-gate 			p->p_wcode = CLD_STOPPED;
10227c478bd9Sstevel@tonic-gate 			p->p_wdata = sig;
10237c478bd9Sstevel@tonic-gate 			sigcld(p, sqp);
10247c478bd9Sstevel@tonic-gate 			/*
10257c478bd9Sstevel@tonic-gate 			 * Grab p->p_lock before releasing pidlock so the
10267c478bd9Sstevel@tonic-gate 			 * parent and the child don't have a race condition.
10277c478bd9Sstevel@tonic-gate 			 */
10287c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
10297c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
10307c478bd9Sstevel@tonic-gate 			p->p_stopsig = 0;
10317c478bd9Sstevel@tonic-gate 		} else if (why == PR_JOBCONTROL && p->p_stopsig == 0) {
10327c478bd9Sstevel@tonic-gate 			/*
10337c478bd9Sstevel@tonic-gate 			 * Set p->p_stopsig and wake up sleeping lwps
10347c478bd9Sstevel@tonic-gate 			 * so they will stop in sympathy with this lwp.
10357c478bd9Sstevel@tonic-gate 			 */
10367c478bd9Sstevel@tonic-gate 			p->p_stopsig = (uchar_t)what;
10377c478bd9Sstevel@tonic-gate 			pokelwps(p);
10387c478bd9Sstevel@tonic-gate 			/*
10397c478bd9Sstevel@tonic-gate 			 * We do this just in case one of the threads we asked
10407c478bd9Sstevel@tonic-gate 			 * to stop is in holdlwps() (called from cfork()) or
10417c478bd9Sstevel@tonic-gate 			 * lwp_suspend().
10427c478bd9Sstevel@tonic-gate 			 */
10437c478bd9Sstevel@tonic-gate 			cv_broadcast(&p->p_holdlwps);
10447c478bd9Sstevel@tonic-gate 		}
10457c478bd9Sstevel@tonic-gate 	}
10467c478bd9Sstevel@tonic-gate 
10477c478bd9Sstevel@tonic-gate 	if (why != PR_JOBCONTROL && why != PR_CHECKPOINT) {
10487c478bd9Sstevel@tonic-gate 		/*
10497c478bd9Sstevel@tonic-gate 		 * Do process-level notification when all lwps are
10507c478bd9Sstevel@tonic-gate 		 * either stopped on events of interest to /proc
10517c478bd9Sstevel@tonic-gate 		 * or are stopped showing PR_SUSPENDED or are zombies.
10527c478bd9Sstevel@tonic-gate 		 */
10537c478bd9Sstevel@tonic-gate 		procstop = 1;
10547c478bd9Sstevel@tonic-gate 		for (tx = t->t_forw; procstop && tx != t; tx = tx->t_forw) {
10557c478bd9Sstevel@tonic-gate 			if (VSTOPPED(tx))
10567c478bd9Sstevel@tonic-gate 				continue;
10577c478bd9Sstevel@tonic-gate 			thread_lock(tx);
10587c478bd9Sstevel@tonic-gate 			switch (tx->t_state) {
10597c478bd9Sstevel@tonic-gate 			case TS_ZOMB:
10607c478bd9Sstevel@tonic-gate 				break;
10617c478bd9Sstevel@tonic-gate 			case TS_STOPPED:
10627c478bd9Sstevel@tonic-gate 				/* neither ISTOPPED nor SUSPENDED? */
10637c478bd9Sstevel@tonic-gate 				if ((tx->t_schedflag &
10647c478bd9Sstevel@tonic-gate 				    (TS_CSTART | TS_UNPAUSE | TS_PSTART)) ==
10657c478bd9Sstevel@tonic-gate 				    (TS_CSTART | TS_UNPAUSE | TS_PSTART))
10667c478bd9Sstevel@tonic-gate 					procstop = 0;
10677c478bd9Sstevel@tonic-gate 				break;
10687c478bd9Sstevel@tonic-gate 			case TS_SLEEP:
10697c478bd9Sstevel@tonic-gate 				/* not paused for watchpoints? */
10707c478bd9Sstevel@tonic-gate 				if (!(tx->t_flag & T_WAKEABLE) ||
10717c478bd9Sstevel@tonic-gate 				    tx->t_wchan0 == NULL ||
10727c478bd9Sstevel@tonic-gate 				    !(tx->t_proc_flag & TP_PAUSE))
10737c478bd9Sstevel@tonic-gate 					procstop = 0;
10747c478bd9Sstevel@tonic-gate 				break;
10757c478bd9Sstevel@tonic-gate 			default:
10767c478bd9Sstevel@tonic-gate 				procstop = 0;
10777c478bd9Sstevel@tonic-gate 				break;
10787c478bd9Sstevel@tonic-gate 			}
10797c478bd9Sstevel@tonic-gate 			thread_unlock(tx);
10807c478bd9Sstevel@tonic-gate 		}
10817c478bd9Sstevel@tonic-gate 		if (procstop) {
10827c478bd9Sstevel@tonic-gate 			/* there must not be any remapped watched pages now */
10837c478bd9Sstevel@tonic-gate 			ASSERT(p->p_mapcnt == 0);
10847c478bd9Sstevel@tonic-gate 			if (p->p_proc_flag & P_PR_PTRACE) {
10857c478bd9Sstevel@tonic-gate 				/* ptrace() compatibility */
10867c478bd9Sstevel@tonic-gate 				mutex_exit(&p->p_lock);
10877c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
10887c478bd9Sstevel@tonic-gate 				p->p_wcode = CLD_TRAPPED;
10897c478bd9Sstevel@tonic-gate 				p->p_wdata = (why == PR_SIGNALLED)?
10907c478bd9Sstevel@tonic-gate 				    what : SIGTRAP;
10917c478bd9Sstevel@tonic-gate 				cv_broadcast(&p->p_parent->p_cv);
10927c478bd9Sstevel@tonic-gate 				/*
10937c478bd9Sstevel@tonic-gate 				 * Grab p->p_lock before releasing pidlock so
10947c478bd9Sstevel@tonic-gate 				 * parent and child don't have a race condition.
10957c478bd9Sstevel@tonic-gate 				 */
10967c478bd9Sstevel@tonic-gate 				mutex_enter(&p->p_lock);
10977c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
10987c478bd9Sstevel@tonic-gate 			}
10997c478bd9Sstevel@tonic-gate 			if (p->p_trace)			/* /proc */
11007c478bd9Sstevel@tonic-gate 				prnotify(p->p_trace);
11017c478bd9Sstevel@tonic-gate 			cv_broadcast(&pr_pid_cv[p->p_slot]); /* pauselwps() */
11027c478bd9Sstevel@tonic-gate 			cv_broadcast(&p->p_holdlwps);	/* holdwatch() */
11037c478bd9Sstevel@tonic-gate 		}
11047c478bd9Sstevel@tonic-gate 		if (why != PR_SUSPENDED) {
11057c478bd9Sstevel@tonic-gate 			lep = p->p_lwpdir[t->t_dslot].ld_entry;
11067c478bd9Sstevel@tonic-gate 			if (lep->le_trace)		/* /proc */
11077c478bd9Sstevel@tonic-gate 				prnotify(lep->le_trace);
11087c478bd9Sstevel@tonic-gate 			/*
11097c478bd9Sstevel@tonic-gate 			 * Special notification for creation of the agent lwp.
11107c478bd9Sstevel@tonic-gate 			 */
11117c478bd9Sstevel@tonic-gate 			if (t == p->p_agenttp &&
11127c478bd9Sstevel@tonic-gate 			    (t->t_proc_flag & TP_PRSTOP) &&
11137c478bd9Sstevel@tonic-gate 			    p->p_trace)
11147c478bd9Sstevel@tonic-gate 				prnotify(p->p_trace);
11157c478bd9Sstevel@tonic-gate 			/*
11167c478bd9Sstevel@tonic-gate 			 * The situation may have changed since we dropped
11177c478bd9Sstevel@tonic-gate 			 * and reacquired p->p_lock. Double-check now
11187c478bd9Sstevel@tonic-gate 			 * whether we should stop or not.
11197c478bd9Sstevel@tonic-gate 			 */
11207c478bd9Sstevel@tonic-gate 			if (!(t->t_proc_flag & TP_STOPPING)) {
11217c478bd9Sstevel@tonic-gate 				if (t->t_proc_flag & TP_PRSTOP)
11227c478bd9Sstevel@tonic-gate 					t->t_proc_flag |= TP_STOPPING;
11237c478bd9Sstevel@tonic-gate 			}
11247c478bd9Sstevel@tonic-gate 			t->t_proc_flag &= ~(TP_PRSTOP|TP_PRVSTOP);
11257c478bd9Sstevel@tonic-gate 			prnostep(lwp);
11267c478bd9Sstevel@tonic-gate 		}
11277c478bd9Sstevel@tonic-gate 	}
11287c478bd9Sstevel@tonic-gate 
11297c478bd9Sstevel@tonic-gate 	if (why == PR_SUSPENDED) {
11307c478bd9Sstevel@tonic-gate 
11317c478bd9Sstevel@tonic-gate 		/*
11327c478bd9Sstevel@tonic-gate 		 * We always broadcast in the case of SUSPEND_PAUSE.  This is
11337c478bd9Sstevel@tonic-gate 		 * because checks for TP_PAUSE take precedence over checks for
11347c478bd9Sstevel@tonic-gate 		 * SHOLDWATCH.  If a thread is trying to stop because of
11357c478bd9Sstevel@tonic-gate 		 * SUSPEND_PAUSE and tries to do a holdwatch(), it will be
11367c478bd9Sstevel@tonic-gate 		 * waiting for the rest of the threads to enter a stopped state.
11377c478bd9Sstevel@tonic-gate 		 * If we are stopping for a SUSPEND_PAUSE, we may be the last
11387c478bd9Sstevel@tonic-gate 		 * lwp and not know it, so broadcast just in case.
11397c478bd9Sstevel@tonic-gate 		 */
11407c478bd9Sstevel@tonic-gate 		if (what == SUSPEND_PAUSE ||
11417c478bd9Sstevel@tonic-gate 		    --p->p_lwprcnt == 0 || (t->t_proc_flag & TP_HOLDLWP))
11427c478bd9Sstevel@tonic-gate 			cv_broadcast(&p->p_holdlwps);
11437c478bd9Sstevel@tonic-gate 
11447c478bd9Sstevel@tonic-gate 	}
11457c478bd9Sstevel@tonic-gate 
11467c478bd9Sstevel@tonic-gate 	/*
11477c478bd9Sstevel@tonic-gate 	 * Need to do this here (rather than after the thread is officially
11487c478bd9Sstevel@tonic-gate 	 * stopped) because we can't call mutex_enter from a stopped thread.
11497c478bd9Sstevel@tonic-gate 	 */
11507c478bd9Sstevel@tonic-gate 	if (why == PR_CHECKPOINT)
11517c478bd9Sstevel@tonic-gate 		del_one_utstop();
11527c478bd9Sstevel@tonic-gate 
11537c478bd9Sstevel@tonic-gate 	thread_lock(t);
11547c478bd9Sstevel@tonic-gate 	ASSERT((t->t_schedflag & TS_ALLSTART) == 0);
11557c478bd9Sstevel@tonic-gate 	t->t_schedflag |= flags;
11567c478bd9Sstevel@tonic-gate 	t->t_whystop = (short)why;
11577c478bd9Sstevel@tonic-gate 	t->t_whatstop = (short)what;
11587c478bd9Sstevel@tonic-gate 	CL_STOP(t, why, what);
11597c478bd9Sstevel@tonic-gate 	(void) new_mstate(t, LMS_STOPPED);
11607c478bd9Sstevel@tonic-gate 	thread_stop(t);			/* set stop state and drop lock */
11617c478bd9Sstevel@tonic-gate 
11627c478bd9Sstevel@tonic-gate 	if (why != PR_SUSPENDED && why != PR_CHECKPOINT) {
11637c478bd9Sstevel@tonic-gate 		/*
11647c478bd9Sstevel@tonic-gate 		 * We may have gotten a SIGKILL or a SIGCONT when
11657c478bd9Sstevel@tonic-gate 		 * we released p->p_lock; make one last check.
11667c478bd9Sstevel@tonic-gate 		 * Also check for a /proc run-on-last-close.
11677c478bd9Sstevel@tonic-gate 		 */
11687c478bd9Sstevel@tonic-gate 		if (sigismember(&t->t_sig, SIGKILL) ||
11697c478bd9Sstevel@tonic-gate 		    sigismember(&p->p_sig, SIGKILL) ||
11707c478bd9Sstevel@tonic-gate 		    (t->t_proc_flag & TP_LWPEXIT) ||
11717c478bd9Sstevel@tonic-gate 		    (p->p_flag & (SEXITLWPS|SKILLED))) {
11727c478bd9Sstevel@tonic-gate 			p->p_stopsig = 0;
11737c478bd9Sstevel@tonic-gate 			thread_lock(t);
11747c478bd9Sstevel@tonic-gate 			t->t_schedflag |= TS_XSTART | TS_PSTART;
11757c478bd9Sstevel@tonic-gate 			setrun_locked(t);
11767c478bd9Sstevel@tonic-gate 			thread_unlock_nopreempt(t);
11777c478bd9Sstevel@tonic-gate 		} else if (why == PR_JOBCONTROL) {
11787c478bd9Sstevel@tonic-gate 			if (p->p_flag & SSCONT) {
11797c478bd9Sstevel@tonic-gate 				/*
11807c478bd9Sstevel@tonic-gate 				 * This resulted from a SIGCONT posted
11817c478bd9Sstevel@tonic-gate 				 * while we were not holding p->p_lock.
11827c478bd9Sstevel@tonic-gate 				 */
11837c478bd9Sstevel@tonic-gate 				p->p_stopsig = 0;
11847c478bd9Sstevel@tonic-gate 				thread_lock(t);
11857c478bd9Sstevel@tonic-gate 				t->t_schedflag |= TS_XSTART;
11867c478bd9Sstevel@tonic-gate 				setrun_locked(t);
11877c478bd9Sstevel@tonic-gate 				thread_unlock_nopreempt(t);
11887c478bd9Sstevel@tonic-gate 			}
11897c478bd9Sstevel@tonic-gate 		} else if (!(t->t_proc_flag & TP_STOPPING)) {
11907c478bd9Sstevel@tonic-gate 			/*
11917c478bd9Sstevel@tonic-gate 			 * This resulted from a /proc run-on-last-close.
11927c478bd9Sstevel@tonic-gate 			 */
11937c478bd9Sstevel@tonic-gate 			thread_lock(t);
11947c478bd9Sstevel@tonic-gate 			t->t_schedflag |= TS_PSTART;
11957c478bd9Sstevel@tonic-gate 			setrun_locked(t);
11967c478bd9Sstevel@tonic-gate 			thread_unlock_nopreempt(t);
11977c478bd9Sstevel@tonic-gate 		}
11987c478bd9Sstevel@tonic-gate 	}
11997c478bd9Sstevel@tonic-gate 
12007c478bd9Sstevel@tonic-gate 	t->t_proc_flag &= ~TP_STOPPING;
12017c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
12027c478bd9Sstevel@tonic-gate 
12037c478bd9Sstevel@tonic-gate 	swtch();
12047c478bd9Sstevel@tonic-gate 	setallwatch();	/* reestablish any watchpoints set while stopped */
12057c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
12067c478bd9Sstevel@tonic-gate 	prbarrier(p);	/* barrier against /proc locking */
12077c478bd9Sstevel@tonic-gate }
12087c478bd9Sstevel@tonic-gate 
12097c478bd9Sstevel@tonic-gate /* Interface for resetting user thread stop count. */
12107c478bd9Sstevel@tonic-gate void
12117c478bd9Sstevel@tonic-gate utstop_init(void)
12127c478bd9Sstevel@tonic-gate {
12137c478bd9Sstevel@tonic-gate 	mutex_enter(&thread_stop_lock);
12147c478bd9Sstevel@tonic-gate 	num_utstop = 0;
12157c478bd9Sstevel@tonic-gate 	mutex_exit(&thread_stop_lock);
12167c478bd9Sstevel@tonic-gate }
12177c478bd9Sstevel@tonic-gate 
12187c478bd9Sstevel@tonic-gate /* Interface for registering a user thread stop request. */
12197c478bd9Sstevel@tonic-gate void
12207c478bd9Sstevel@tonic-gate add_one_utstop(void)
12217c478bd9Sstevel@tonic-gate {
12227c478bd9Sstevel@tonic-gate 	mutex_enter(&thread_stop_lock);
12237c478bd9Sstevel@tonic-gate 	num_utstop++;
12247c478bd9Sstevel@tonic-gate 	mutex_exit(&thread_stop_lock);
12257c478bd9Sstevel@tonic-gate }
12267c478bd9Sstevel@tonic-gate 
12277c478bd9Sstevel@tonic-gate /* Interface for cancelling a user thread stop request */
12287c478bd9Sstevel@tonic-gate void
12297c478bd9Sstevel@tonic-gate del_one_utstop(void)
12307c478bd9Sstevel@tonic-gate {
12317c478bd9Sstevel@tonic-gate 	mutex_enter(&thread_stop_lock);
12327c478bd9Sstevel@tonic-gate 	num_utstop--;
12337c478bd9Sstevel@tonic-gate 	if (num_utstop == 0)
12347c478bd9Sstevel@tonic-gate 		cv_broadcast(&utstop_cv);
12357c478bd9Sstevel@tonic-gate 	mutex_exit(&thread_stop_lock);
12367c478bd9Sstevel@tonic-gate }
12377c478bd9Sstevel@tonic-gate 
12387c478bd9Sstevel@tonic-gate /* Interface to wait for all user threads to be stopped */
12397c478bd9Sstevel@tonic-gate void
12407c478bd9Sstevel@tonic-gate utstop_timedwait(clock_t ticks)
12417c478bd9Sstevel@tonic-gate {
12427c478bd9Sstevel@tonic-gate 	mutex_enter(&thread_stop_lock);
12437c478bd9Sstevel@tonic-gate 	if (num_utstop > 0)
1244d3d50737SRafael Vanoni 		(void) cv_reltimedwait(&utstop_cv, &thread_stop_lock, ticks,
1245d3d50737SRafael Vanoni 		    TR_CLOCK_TICK);
12467c478bd9Sstevel@tonic-gate 	mutex_exit(&thread_stop_lock);
12477c478bd9Sstevel@tonic-gate }
12487c478bd9Sstevel@tonic-gate 
12497c478bd9Sstevel@tonic-gate /*
12507c478bd9Sstevel@tonic-gate  * Perform the action specified by the current signal.
12517c478bd9Sstevel@tonic-gate  * The usual sequence is:
12527c478bd9Sstevel@tonic-gate  * 	if (issig())
12537c478bd9Sstevel@tonic-gate  * 		psig();
12547c478bd9Sstevel@tonic-gate  * The signal bit has already been cleared by issig(),
12557c478bd9Sstevel@tonic-gate  * the current signal number has been stored in lwp_cursig,
12567c478bd9Sstevel@tonic-gate  * and the current siginfo is now referenced by lwp_curinfo.
12577c478bd9Sstevel@tonic-gate  */
12587c478bd9Sstevel@tonic-gate void
12597c478bd9Sstevel@tonic-gate psig(void)
12607c478bd9Sstevel@tonic-gate {
12617c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
12627c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
12637c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
12647c478bd9Sstevel@tonic-gate 	void (*func)();
12657c478bd9Sstevel@tonic-gate 	int sig, rc, code, ext;
12667c478bd9Sstevel@tonic-gate 	pid_t pid = -1;
12677c478bd9Sstevel@tonic-gate 	id_t ctid = 0;
12687c478bd9Sstevel@tonic-gate 	zoneid_t zoneid = -1;
12697c478bd9Sstevel@tonic-gate 	sigqueue_t *sqp = NULL;
12707c478bd9Sstevel@tonic-gate 
12717c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
12727c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(t);
12737c478bd9Sstevel@tonic-gate 	code = CLD_KILLED;
12747c478bd9Sstevel@tonic-gate 
12757c478bd9Sstevel@tonic-gate 	if (p->p_flag & SEXITLWPS) {
12767c478bd9Sstevel@tonic-gate 		lwp_exit();
12777c478bd9Sstevel@tonic-gate 		return;			/* not reached */
12787c478bd9Sstevel@tonic-gate 	}
12797c478bd9Sstevel@tonic-gate 	sig = lwp->lwp_cursig;
12807c478bd9Sstevel@tonic-gate 	ext = lwp->lwp_extsig;
12817c478bd9Sstevel@tonic-gate 
12827c478bd9Sstevel@tonic-gate 	ASSERT(sig < NSIG);
12837c478bd9Sstevel@tonic-gate 
12847c478bd9Sstevel@tonic-gate 	/*
12857c478bd9Sstevel@tonic-gate 	 * Re-check lwp_cursig after we acquire p_lock.  Since p_lock was
12867c478bd9Sstevel@tonic-gate 	 * dropped between issig() and psig(), a debugger may have cleared
12877c478bd9Sstevel@tonic-gate 	 * lwp_cursig via /proc in the intervening window.
12887c478bd9Sstevel@tonic-gate 	 */
12897c478bd9Sstevel@tonic-gate 	if (sig == 0) {
12907c478bd9Sstevel@tonic-gate 		if (lwp->lwp_curinfo) {
12917c478bd9Sstevel@tonic-gate 			siginfofree(lwp->lwp_curinfo);
12927c478bd9Sstevel@tonic-gate 			lwp->lwp_curinfo = NULL;
12937c478bd9Sstevel@tonic-gate 		}
12947c478bd9Sstevel@tonic-gate 		if (t->t_flag & T_TOMASK) {	/* sigsuspend or pollsys */
12957c478bd9Sstevel@tonic-gate 			t->t_flag &= ~T_TOMASK;
12967c478bd9Sstevel@tonic-gate 			t->t_hold = lwp->lwp_sigoldmask;
12977c478bd9Sstevel@tonic-gate 		}
12987c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
12997c478bd9Sstevel@tonic-gate 		return;
13007c478bd9Sstevel@tonic-gate 	}
1301ae115bc7Smrj 	func = PTOU(curproc)->u_signal[sig-1];
13027c478bd9Sstevel@tonic-gate 
13037c478bd9Sstevel@tonic-gate 	/*
13047c478bd9Sstevel@tonic-gate 	 * The signal disposition could have changed since we promoted
13057c478bd9Sstevel@tonic-gate 	 * this signal from pending to current (we dropped p->p_lock).
13067c478bd9Sstevel@tonic-gate 	 * This can happen only in a multi-threaded process.
13077c478bd9Sstevel@tonic-gate 	 */
13087c478bd9Sstevel@tonic-gate 	if (sigismember(&p->p_ignore, sig) ||
13097c478bd9Sstevel@tonic-gate 	    (func == SIG_DFL && sigismember(&stopdefault, sig))) {
13107c478bd9Sstevel@tonic-gate 		lwp->lwp_cursig = 0;
13117c478bd9Sstevel@tonic-gate 		lwp->lwp_extsig = 0;
13127c478bd9Sstevel@tonic-gate 		if (lwp->lwp_curinfo) {
13137c478bd9Sstevel@tonic-gate 			siginfofree(lwp->lwp_curinfo);
13147c478bd9Sstevel@tonic-gate 			lwp->lwp_curinfo = NULL;
13157c478bd9Sstevel@tonic-gate 		}
13167c478bd9Sstevel@tonic-gate 		if (t->t_flag & T_TOMASK) {	/* sigsuspend or pollsys */
13177c478bd9Sstevel@tonic-gate 			t->t_flag &= ~T_TOMASK;
13187c478bd9Sstevel@tonic-gate 			t->t_hold = lwp->lwp_sigoldmask;
13197c478bd9Sstevel@tonic-gate 		}
13207c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
13217c478bd9Sstevel@tonic-gate 		return;
13227c478bd9Sstevel@tonic-gate 	}
13237c478bd9Sstevel@tonic-gate 
13247c478bd9Sstevel@tonic-gate 	/*
13257c478bd9Sstevel@tonic-gate 	 * We check lwp_curinfo first since pr_setsig can actually
13267c478bd9Sstevel@tonic-gate 	 * stuff a sigqueue_t there for SIGKILL.
13277c478bd9Sstevel@tonic-gate 	 */
13287c478bd9Sstevel@tonic-gate 	if (lwp->lwp_curinfo) {
13297c478bd9Sstevel@tonic-gate 		sqp = lwp->lwp_curinfo;
13307c478bd9Sstevel@tonic-gate 	} else if (sig == SIGKILL && p->p_killsqp) {
13317c478bd9Sstevel@tonic-gate 		sqp = p->p_killsqp;
13327c478bd9Sstevel@tonic-gate 	}
13337c478bd9Sstevel@tonic-gate 
13347c478bd9Sstevel@tonic-gate 	if (sqp != NULL) {
13357c478bd9Sstevel@tonic-gate 		if (SI_FROMUSER(&sqp->sq_info)) {
13367c478bd9Sstevel@tonic-gate 			pid = sqp->sq_info.si_pid;
13377c478bd9Sstevel@tonic-gate 			ctid = sqp->sq_info.si_ctid;
13387c478bd9Sstevel@tonic-gate 			zoneid = sqp->sq_info.si_zoneid;
13397c478bd9Sstevel@tonic-gate 		}
13407c478bd9Sstevel@tonic-gate 		/*
13417c478bd9Sstevel@tonic-gate 		 * If we have a sigqueue_t, its sq_external value
13427c478bd9Sstevel@tonic-gate 		 * trumps the lwp_extsig value.  It is theoretically
13437c478bd9Sstevel@tonic-gate 		 * possible to make lwp_extsig reflect reality, but it
13447c478bd9Sstevel@tonic-gate 		 * would unnecessarily complicate things elsewhere.
13457c478bd9Sstevel@tonic-gate 		 */
13467c478bd9Sstevel@tonic-gate 		ext = sqp->sq_external;
13477c478bd9Sstevel@tonic-gate 	}
13487c478bd9Sstevel@tonic-gate 
13497c478bd9Sstevel@tonic-gate 	if (func == SIG_DFL) {
13507c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
13517c478bd9Sstevel@tonic-gate 		DTRACE_PROC3(signal__handle, int, sig, k_siginfo_t *,
13527c478bd9Sstevel@tonic-gate 		    NULL, void (*)(void), func);
13537c478bd9Sstevel@tonic-gate 	} else {
13547c478bd9Sstevel@tonic-gate 		k_siginfo_t *sip = NULL;
13557c478bd9Sstevel@tonic-gate 
13567c478bd9Sstevel@tonic-gate 		/*
13577c478bd9Sstevel@tonic-gate 		 * If DTrace user-land tracing is active, give DTrace a
13587c478bd9Sstevel@tonic-gate 		 * chance to defer the signal until after tracing is
13597c478bd9Sstevel@tonic-gate 		 * complete.
13607c478bd9Sstevel@tonic-gate 		 */
13617c478bd9Sstevel@tonic-gate 		if (t->t_dtrace_on && dtrace_safe_defer_signal()) {
13627c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
13637c478bd9Sstevel@tonic-gate 			return;
13647c478bd9Sstevel@tonic-gate 		}
13657c478bd9Sstevel@tonic-gate 
13667c478bd9Sstevel@tonic-gate 		/*
13677c478bd9Sstevel@tonic-gate 		 * save siginfo pointer here, in case the
13687c478bd9Sstevel@tonic-gate 		 * the signal's reset bit is on
13697c478bd9Sstevel@tonic-gate 		 *
13707c478bd9Sstevel@tonic-gate 		 * The presence of a current signal prevents paging
13717c478bd9Sstevel@tonic-gate 		 * from succeeding over a network.  We copy the current
13727c478bd9Sstevel@tonic-gate 		 * signal information to the side and cancel the current
13737c478bd9Sstevel@tonic-gate 		 * signal so that sendsig() will succeed.
13747c478bd9Sstevel@tonic-gate 		 */
13757c478bd9Sstevel@tonic-gate 		if (sigismember(&p->p_siginfo, sig)) {
1376ee01d137Sraf 			sip = &lwp->lwp_siginfo;
13777c478bd9Sstevel@tonic-gate 			if (sqp) {
1378ee01d137Sraf 				bcopy(&sqp->sq_info, sip, sizeof (*sip));
1379a574db85Sraf 				/*
1380a574db85Sraf 				 * If we were interrupted out of a system call
1381a574db85Sraf 				 * due to pthread_cancel(), inform libc.
1382a574db85Sraf 				 */
1383a574db85Sraf 				if (sig == SIGCANCEL &&
1384a574db85Sraf 				    sip->si_code == SI_LWP &&
1385a574db85Sraf 				    t->t_sysnum != 0)
1386a574db85Sraf 					schedctl_cancel_eintr();
1387ee01d137Sraf 			} else if (sig == SIGPROF && sip->si_signo == SIGPROF &&
1388ee01d137Sraf 			    t->t_rprof != NULL && t->t_rprof->rp_anystate) {
1389ee01d137Sraf 				/* EMPTY */;
1390ee01d137Sraf 			} else {
1391ee01d137Sraf 				bzero(sip, sizeof (*sip));
1392ee01d137Sraf 				sip->si_signo = sig;
1393ee01d137Sraf 				sip->si_code = SI_NOINFO;
13947c478bd9Sstevel@tonic-gate 			}
13957c478bd9Sstevel@tonic-gate 		}
13967c478bd9Sstevel@tonic-gate 
13977c478bd9Sstevel@tonic-gate 		if (t->t_flag & T_TOMASK)
13987c478bd9Sstevel@tonic-gate 			t->t_flag &= ~T_TOMASK;
13997c478bd9Sstevel@tonic-gate 		else
14007c478bd9Sstevel@tonic-gate 			lwp->lwp_sigoldmask = t->t_hold;
1401ae115bc7Smrj 		sigorset(&t->t_hold, &PTOU(curproc)->u_sigmask[sig-1]);
1402ae115bc7Smrj 		if (!sigismember(&PTOU(curproc)->u_signodefer, sig))
14037c478bd9Sstevel@tonic-gate 			sigaddset(&t->t_hold, sig);
1404ae115bc7Smrj 		if (sigismember(&PTOU(curproc)->u_sigresethand, sig))
14057c478bd9Sstevel@tonic-gate 			setsigact(sig, SIG_DFL, nullsmask, 0);
14067c478bd9Sstevel@tonic-gate 
14077c478bd9Sstevel@tonic-gate 		DTRACE_PROC3(signal__handle, int, sig, k_siginfo_t *,
14087c478bd9Sstevel@tonic-gate 		    sip, void (*)(void), func);
14097c478bd9Sstevel@tonic-gate 
14107c478bd9Sstevel@tonic-gate 		lwp->lwp_cursig = 0;
14117c478bd9Sstevel@tonic-gate 		lwp->lwp_extsig = 0;
14127c478bd9Sstevel@tonic-gate 		if (lwp->lwp_curinfo) {
14137c478bd9Sstevel@tonic-gate 			/* p->p_killsqp is freed by freeproc */
14147c478bd9Sstevel@tonic-gate 			siginfofree(lwp->lwp_curinfo);
14157c478bd9Sstevel@tonic-gate 			lwp->lwp_curinfo = NULL;
14167c478bd9Sstevel@tonic-gate 		}
14177c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
14187c478bd9Sstevel@tonic-gate 		lwp->lwp_ru.nsignals++;
14197c478bd9Sstevel@tonic-gate 
14207c478bd9Sstevel@tonic-gate 		if (p->p_model == DATAMODEL_NATIVE)
14217c478bd9Sstevel@tonic-gate 			rc = sendsig(sig, sip, func);
14227c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
14237c478bd9Sstevel@tonic-gate 		else
14247c478bd9Sstevel@tonic-gate 			rc = sendsig32(sig, sip, func);
14257c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
14267c478bd9Sstevel@tonic-gate 		if (rc)
14277c478bd9Sstevel@tonic-gate 			return;
14287c478bd9Sstevel@tonic-gate 		sig = lwp->lwp_cursig = SIGSEGV;
14297c478bd9Sstevel@tonic-gate 		ext = 0;	/* lwp_extsig was set above */
14307c478bd9Sstevel@tonic-gate 		pid = -1;
14317c478bd9Sstevel@tonic-gate 		ctid = 0;
14327c478bd9Sstevel@tonic-gate 	}
14337c478bd9Sstevel@tonic-gate 
14347c478bd9Sstevel@tonic-gate 	if (sigismember(&coredefault, sig)) {
14357c478bd9Sstevel@tonic-gate 		/*
14367c478bd9Sstevel@tonic-gate 		 * Terminate all LWPs but don't discard them.
14377c478bd9Sstevel@tonic-gate 		 * If another lwp beat us to the punch by calling exit(),
14387c478bd9Sstevel@tonic-gate 		 * evaporate now.
14397c478bd9Sstevel@tonic-gate 		 */
144097eda132Sraf 		proc_is_exiting(p);
14417c478bd9Sstevel@tonic-gate 		if (exitlwps(1) != 0) {
14427c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
14437c478bd9Sstevel@tonic-gate 			lwp_exit();
14447c478bd9Sstevel@tonic-gate 		}
14457c478bd9Sstevel@tonic-gate 		/* if we got a SIGKILL from anywhere, no core dump */
14467c478bd9Sstevel@tonic-gate 		if (p->p_flag & SKILLED) {
14477c478bd9Sstevel@tonic-gate 			sig = SIGKILL;
14487c478bd9Sstevel@tonic-gate 			ext = (p->p_flag & SEXTKILLED) != 0;
14497c478bd9Sstevel@tonic-gate 		} else {
14507c478bd9Sstevel@tonic-gate 			if (audit_active)		/* audit core dump */
14517c478bd9Sstevel@tonic-gate 				audit_core_start(sig);
14527c478bd9Sstevel@tonic-gate 			if (core(sig, ext) == 0)
14537c478bd9Sstevel@tonic-gate 				code = CLD_DUMPED;
14547c478bd9Sstevel@tonic-gate 			if (audit_active)		/* audit core dump */
14557c478bd9Sstevel@tonic-gate 				audit_core_finish(code);
14567c478bd9Sstevel@tonic-gate 		}
14577c478bd9Sstevel@tonic-gate 	}
1458cbdce38dSbpramod 
1459cbdce38dSbpramod 	/*
1460cbdce38dSbpramod 	 * Generate a contract event once if the process is killed
1461cbdce38dSbpramod 	 * by a signal.
1462cbdce38dSbpramod 	 */
1463cbdce38dSbpramod 	if (ext) {
1464cbdce38dSbpramod 		proc_is_exiting(p);
1465cbdce38dSbpramod 		if (exitlwps(0) != 0) {
1466cbdce38dSbpramod 			mutex_enter(&p->p_lock);
1467cbdce38dSbpramod 			lwp_exit();
1468cbdce38dSbpramod 		}
14697c478bd9Sstevel@tonic-gate 		contract_process_sig(p->p_ct_process, p, sig, pid, ctid,
14707c478bd9Sstevel@tonic-gate 		    zoneid);
1471cbdce38dSbpramod 	}
14727c478bd9Sstevel@tonic-gate 
14737c478bd9Sstevel@tonic-gate 	exit(code, sig);
14747c478bd9Sstevel@tonic-gate }
14757c478bd9Sstevel@tonic-gate 
14767c478bd9Sstevel@tonic-gate /*
14777c478bd9Sstevel@tonic-gate  * Find next unheld signal in ssp for thread t.
14787c478bd9Sstevel@tonic-gate  */
14797c478bd9Sstevel@tonic-gate int
14807c478bd9Sstevel@tonic-gate fsig(k_sigset_t *ssp, kthread_t *t)
14817c478bd9Sstevel@tonic-gate {
14827c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
14837c478bd9Sstevel@tonic-gate 	user_t *up = PTOU(p);
14847c478bd9Sstevel@tonic-gate 	int i;
14857c478bd9Sstevel@tonic-gate 	k_sigset_t temp;
14867c478bd9Sstevel@tonic-gate 
14877c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
14887c478bd9Sstevel@tonic-gate 
14897c478bd9Sstevel@tonic-gate 	/*
14907c478bd9Sstevel@tonic-gate 	 * Don't promote any signals for the parent of a vfork()d
14917c478bd9Sstevel@tonic-gate 	 * child that hasn't yet released the parent's memory.
14927c478bd9Sstevel@tonic-gate 	 */
14937c478bd9Sstevel@tonic-gate 	if (p->p_flag & SVFWAIT)
14947c478bd9Sstevel@tonic-gate 		return (0);
14957c478bd9Sstevel@tonic-gate 
14967c478bd9Sstevel@tonic-gate 	temp = *ssp;
14977c478bd9Sstevel@tonic-gate 	sigdiffset(&temp, &t->t_hold);
14987c478bd9Sstevel@tonic-gate 
14997c478bd9Sstevel@tonic-gate 	/*
15007c478bd9Sstevel@tonic-gate 	 * Don't promote stopping signals (except SIGSTOP) for a child
15017c478bd9Sstevel@tonic-gate 	 * of vfork() that hasn't yet released the parent's memory.
15027c478bd9Sstevel@tonic-gate 	 */
15037c478bd9Sstevel@tonic-gate 	if (p->p_flag & SVFORK)
15047c478bd9Sstevel@tonic-gate 		sigdiffset(&temp, &holdvfork);
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	/*
15077c478bd9Sstevel@tonic-gate 	 * Don't promote a signal that will stop
15087c478bd9Sstevel@tonic-gate 	 * the process when lwp_nostop is set.
15097c478bd9Sstevel@tonic-gate 	 */
15107c478bd9Sstevel@tonic-gate 	if (ttolwp(t)->lwp_nostop) {
15117c478bd9Sstevel@tonic-gate 		sigdelset(&temp, SIGSTOP);
15127c478bd9Sstevel@tonic-gate 		if (!p->p_pgidp->pid_pgorphaned) {
15137c478bd9Sstevel@tonic-gate 			if (up->u_signal[SIGTSTP-1] == SIG_DFL)
15147c478bd9Sstevel@tonic-gate 				sigdelset(&temp, SIGTSTP);
15157c478bd9Sstevel@tonic-gate 			if (up->u_signal[SIGTTIN-1] == SIG_DFL)
15167c478bd9Sstevel@tonic-gate 				sigdelset(&temp, SIGTTIN);
15177c478bd9Sstevel@tonic-gate 			if (up->u_signal[SIGTTOU-1] == SIG_DFL)
15187c478bd9Sstevel@tonic-gate 				sigdelset(&temp, SIGTTOU);
15197c478bd9Sstevel@tonic-gate 		}
15207c478bd9Sstevel@tonic-gate 	}
15217c478bd9Sstevel@tonic-gate 
15227c478bd9Sstevel@tonic-gate 	/*
15237c478bd9Sstevel@tonic-gate 	 * Choose SIGKILL and SIGPROF before all other pending signals.
15247c478bd9Sstevel@tonic-gate 	 * The rest are promoted in signal number order.
15257c478bd9Sstevel@tonic-gate 	 */
15267c478bd9Sstevel@tonic-gate 	if (sigismember(&temp, SIGKILL))
15277c478bd9Sstevel@tonic-gate 		return (SIGKILL);
15287c478bd9Sstevel@tonic-gate 	if (sigismember(&temp, SIGPROF))
15297c478bd9Sstevel@tonic-gate 		return (SIGPROF);
15307c478bd9Sstevel@tonic-gate 
15317c478bd9Sstevel@tonic-gate 	for (i = 0; i < sizeof (temp) / sizeof (temp.__sigbits[0]); i++) {
15327c478bd9Sstevel@tonic-gate 		if (temp.__sigbits[i])
15337c478bd9Sstevel@tonic-gate 			return ((i * NBBY * sizeof (temp.__sigbits[0])) +
15347c478bd9Sstevel@tonic-gate 			    lowbit(temp.__sigbits[i]));
15357c478bd9Sstevel@tonic-gate 	}
15367c478bd9Sstevel@tonic-gate 
15377c478bd9Sstevel@tonic-gate 	return (0);
15387c478bd9Sstevel@tonic-gate }
15397c478bd9Sstevel@tonic-gate 
15407c478bd9Sstevel@tonic-gate void
15417c478bd9Sstevel@tonic-gate setsigact(int sig, void (*disp)(), k_sigset_t mask, int flags)
15427c478bd9Sstevel@tonic-gate {
15437c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(curthread);
15447c478bd9Sstevel@tonic-gate 	kthread_t *t;
15457c478bd9Sstevel@tonic-gate 
15467c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
15477c478bd9Sstevel@tonic-gate 
1548ae115bc7Smrj 	PTOU(curproc)->u_signal[sig - 1] = disp;
15497c478bd9Sstevel@tonic-gate 
15507c478bd9Sstevel@tonic-gate 	/*
15517c478bd9Sstevel@tonic-gate 	 * Honor the SA_SIGINFO flag if the signal is being caught.
15527c478bd9Sstevel@tonic-gate 	 * Force the SA_SIGINFO flag if the signal is not being caught.
15537c478bd9Sstevel@tonic-gate 	 * This is necessary to make sigqueue() and sigwaitinfo() work
15547c478bd9Sstevel@tonic-gate 	 * properly together when the signal is set to default or is
15557c478bd9Sstevel@tonic-gate 	 * being temporarily ignored.
15567c478bd9Sstevel@tonic-gate 	 */
15577c478bd9Sstevel@tonic-gate 	if ((flags & SA_SIGINFO) || disp == SIG_DFL || disp == SIG_IGN)
15587c478bd9Sstevel@tonic-gate 		sigaddset(&p->p_siginfo, sig);
15597c478bd9Sstevel@tonic-gate 	else
15607c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_siginfo, sig);
15617c478bd9Sstevel@tonic-gate 
15627c478bd9Sstevel@tonic-gate 	if (disp != SIG_DFL && disp != SIG_IGN) {
15637c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_ignore, sig);
1564ae115bc7Smrj 		PTOU(curproc)->u_sigmask[sig - 1] = mask;
15657c478bd9Sstevel@tonic-gate 		if (!sigismember(&cantreset, sig)) {
15667c478bd9Sstevel@tonic-gate 			if (flags & SA_RESETHAND)
1567ae115bc7Smrj 				sigaddset(&PTOU(curproc)->u_sigresethand, sig);
15687c478bd9Sstevel@tonic-gate 			else
1569ae115bc7Smrj 				sigdelset(&PTOU(curproc)->u_sigresethand, sig);
15707c478bd9Sstevel@tonic-gate 		}
15717c478bd9Sstevel@tonic-gate 		if (flags & SA_NODEFER)
1572ae115bc7Smrj 			sigaddset(&PTOU(curproc)->u_signodefer, sig);
15737c478bd9Sstevel@tonic-gate 		else
1574ae115bc7Smrj 			sigdelset(&PTOU(curproc)->u_signodefer, sig);
15757c478bd9Sstevel@tonic-gate 		if (flags & SA_RESTART)
1576ae115bc7Smrj 			sigaddset(&PTOU(curproc)->u_sigrestart, sig);
15777c478bd9Sstevel@tonic-gate 		else
1578ae115bc7Smrj 			sigdelset(&PTOU(curproc)->u_sigrestart, sig);
15797c478bd9Sstevel@tonic-gate 		if (flags & SA_ONSTACK)
1580ae115bc7Smrj 			sigaddset(&PTOU(curproc)->u_sigonstack, sig);
15817c478bd9Sstevel@tonic-gate 		else
1582ae115bc7Smrj 			sigdelset(&PTOU(curproc)->u_sigonstack, sig);
15837c478bd9Sstevel@tonic-gate 	} else if (disp == SIG_IGN ||
15847c478bd9Sstevel@tonic-gate 	    (disp == SIG_DFL && sigismember(&ignoredefault, sig))) {
15857c478bd9Sstevel@tonic-gate 		/*
15867c478bd9Sstevel@tonic-gate 		 * Setting the signal action to SIG_IGN results in the
15877c478bd9Sstevel@tonic-gate 		 * discarding of all pending signals of that signal number.
15887c478bd9Sstevel@tonic-gate 		 * Setting the signal action to SIG_DFL does the same *only*
15897c478bd9Sstevel@tonic-gate 		 * if the signal's default behavior is to be ignored.
15907c478bd9Sstevel@tonic-gate 		 */
15917c478bd9Sstevel@tonic-gate 		sigaddset(&p->p_ignore, sig);
15927c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_sig, sig);
15937c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_extsig, sig);
15947c478bd9Sstevel@tonic-gate 		sigdelq(p, NULL, sig);
15957c478bd9Sstevel@tonic-gate 		t = p->p_tlist;
15967c478bd9Sstevel@tonic-gate 		do {
15977c478bd9Sstevel@tonic-gate 			sigdelset(&t->t_sig, sig);
15987c478bd9Sstevel@tonic-gate 			sigdelset(&t->t_extsig, sig);
15997c478bd9Sstevel@tonic-gate 			sigdelq(p, t, sig);
16007c478bd9Sstevel@tonic-gate 		} while ((t = t->t_forw) != p->p_tlist);
16017c478bd9Sstevel@tonic-gate 	} else {
16027c478bd9Sstevel@tonic-gate 		/*
16037c478bd9Sstevel@tonic-gate 		 * The signal action is being set to SIG_DFL and the default
16047c478bd9Sstevel@tonic-gate 		 * behavior is to do something: make sure it is not ignored.
16057c478bd9Sstevel@tonic-gate 		 */
16067c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_ignore, sig);
16077c478bd9Sstevel@tonic-gate 	}
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate 	if (sig == SIGCLD) {
16107c478bd9Sstevel@tonic-gate 		if (flags & SA_NOCLDWAIT)
16117c478bd9Sstevel@tonic-gate 			p->p_flag |= SNOWAIT;
16127c478bd9Sstevel@tonic-gate 		else
16137c478bd9Sstevel@tonic-gate 			p->p_flag &= ~SNOWAIT;
16147c478bd9Sstevel@tonic-gate 
16157c478bd9Sstevel@tonic-gate 		if (flags & SA_NOCLDSTOP)
16167c478bd9Sstevel@tonic-gate 			p->p_flag &= ~SJCTL;
16177c478bd9Sstevel@tonic-gate 		else
16187c478bd9Sstevel@tonic-gate 			p->p_flag |= SJCTL;
16197c478bd9Sstevel@tonic-gate 
1620657b1f3dSraf 		if ((p->p_flag & SNOWAIT) || disp == SIG_IGN) {
16217c478bd9Sstevel@tonic-gate 			proc_t *cp, *tp;
16227c478bd9Sstevel@tonic-gate 
16237c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
16247c478bd9Sstevel@tonic-gate 			mutex_enter(&pidlock);
16257c478bd9Sstevel@tonic-gate 			for (cp = p->p_child; cp != NULL; cp = tp) {
16267c478bd9Sstevel@tonic-gate 				tp = cp->p_sibling;
1627657b1f3dSraf 				if (cp->p_stat == SZOMB &&
1628657b1f3dSraf 				    !(cp->p_pidflag & CLDWAITPID))
16297c478bd9Sstevel@tonic-gate 					freeproc(cp);
16307c478bd9Sstevel@tonic-gate 			}
16317c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
16327c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
16337c478bd9Sstevel@tonic-gate 		}
16347c478bd9Sstevel@tonic-gate 	}
16357c478bd9Sstevel@tonic-gate }
16367c478bd9Sstevel@tonic-gate 
16377c478bd9Sstevel@tonic-gate /*
16387c478bd9Sstevel@tonic-gate  * Set all signal actions not already set to SIG_DFL or SIG_IGN to SIG_DFL.
16397c478bd9Sstevel@tonic-gate  * Called from exec_common() for a process undergoing execve()
16407c478bd9Sstevel@tonic-gate  * and from cfork() for a newly-created child of vfork().
16417c478bd9Sstevel@tonic-gate  * In the vfork() case, 'p' is not the current process.
16427c478bd9Sstevel@tonic-gate  * In both cases, there is only one thread in the process.
16437c478bd9Sstevel@tonic-gate  */
16447c478bd9Sstevel@tonic-gate void
16457c478bd9Sstevel@tonic-gate sigdefault(proc_t *p)
16467c478bd9Sstevel@tonic-gate {
16477c478bd9Sstevel@tonic-gate 	kthread_t *t = p->p_tlist;
16487c478bd9Sstevel@tonic-gate 	struct user *up = PTOU(p);
16497c478bd9Sstevel@tonic-gate 	int sig;
16507c478bd9Sstevel@tonic-gate 
16517c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
16527c478bd9Sstevel@tonic-gate 
16537c478bd9Sstevel@tonic-gate 	for (sig = 1; sig < NSIG; sig++) {
16547c478bd9Sstevel@tonic-gate 		if (up->u_signal[sig - 1] != SIG_DFL &&
16557c478bd9Sstevel@tonic-gate 		    up->u_signal[sig - 1] != SIG_IGN) {
16567c478bd9Sstevel@tonic-gate 			up->u_signal[sig - 1] = SIG_DFL;
16577c478bd9Sstevel@tonic-gate 			sigemptyset(&up->u_sigmask[sig - 1]);
16587c478bd9Sstevel@tonic-gate 			if (sigismember(&ignoredefault, sig)) {
16597c478bd9Sstevel@tonic-gate 				sigdelq(p, NULL, sig);
16607c478bd9Sstevel@tonic-gate 				sigdelq(p, t, sig);
16617c478bd9Sstevel@tonic-gate 			}
16627c478bd9Sstevel@tonic-gate 			if (sig == SIGCLD)
16637c478bd9Sstevel@tonic-gate 				p->p_flag &= ~(SNOWAIT|SJCTL);
16647c478bd9Sstevel@tonic-gate 		}
16657c478bd9Sstevel@tonic-gate 	}
16667c478bd9Sstevel@tonic-gate 	sigorset(&p->p_ignore, &ignoredefault);
16677c478bd9Sstevel@tonic-gate 	sigfillset(&p->p_siginfo);
16687c478bd9Sstevel@tonic-gate 	sigdiffset(&p->p_siginfo, &cantmask);
16697c478bd9Sstevel@tonic-gate 	sigdiffset(&p->p_sig, &ignoredefault);
16707c478bd9Sstevel@tonic-gate 	sigdiffset(&p->p_extsig, &ignoredefault);
16717c478bd9Sstevel@tonic-gate 	sigdiffset(&t->t_sig, &ignoredefault);
16727c478bd9Sstevel@tonic-gate 	sigdiffset(&t->t_extsig, &ignoredefault);
16737c478bd9Sstevel@tonic-gate }
16747c478bd9Sstevel@tonic-gate 
16757c478bd9Sstevel@tonic-gate void
16767c478bd9Sstevel@tonic-gate sigcld(proc_t *cp, sigqueue_t *sqp)
16777c478bd9Sstevel@tonic-gate {
16787c478bd9Sstevel@tonic-gate 	proc_t *pp = cp->p_parent;
16797c478bd9Sstevel@tonic-gate 
16807c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
16817c478bd9Sstevel@tonic-gate 
16827c478bd9Sstevel@tonic-gate 	switch (cp->p_wcode) {
16837c478bd9Sstevel@tonic-gate 	case CLD_EXITED:
16847c478bd9Sstevel@tonic-gate 	case CLD_DUMPED:
16857c478bd9Sstevel@tonic-gate 	case CLD_KILLED:
16867c478bd9Sstevel@tonic-gate 		ASSERT(cp->p_stat == SZOMB);
16877c478bd9Sstevel@tonic-gate 		/*
16887c478bd9Sstevel@tonic-gate 		 * The broadcast on p_srwchan_cv is a kludge to
16897c478bd9Sstevel@tonic-gate 		 * wakeup a possible thread in uadmin(A_SHUTDOWN).
16907c478bd9Sstevel@tonic-gate 		 */
16917c478bd9Sstevel@tonic-gate 		cv_broadcast(&cp->p_srwchan_cv);
16927c478bd9Sstevel@tonic-gate 
16937c478bd9Sstevel@tonic-gate 		/*
16947c478bd9Sstevel@tonic-gate 		 * Add to newstate list of the parent
16957c478bd9Sstevel@tonic-gate 		 */
16967c478bd9Sstevel@tonic-gate 		add_ns(pp, cp);
16977c478bd9Sstevel@tonic-gate 
16987c478bd9Sstevel@tonic-gate 		cv_broadcast(&pp->p_cv);
16997c478bd9Sstevel@tonic-gate 		if ((pp->p_flag & SNOWAIT) ||
1700657b1f3dSraf 		    PTOU(pp)->u_signal[SIGCLD - 1] == SIG_IGN) {
1701657b1f3dSraf 			if (!(cp->p_pidflag & CLDWAITPID))
17027c478bd9Sstevel@tonic-gate 				freeproc(cp);
1703657b1f3dSraf 		} else if (!(cp->p_pidflag & CLDNOSIGCHLD)) {
17047c478bd9Sstevel@tonic-gate 			post_sigcld(cp, sqp);
17057c478bd9Sstevel@tonic-gate 			sqp = NULL;
17067c478bd9Sstevel@tonic-gate 		}
17077c478bd9Sstevel@tonic-gate 		break;
17087c478bd9Sstevel@tonic-gate 
17097c478bd9Sstevel@tonic-gate 	case CLD_STOPPED:
17107c478bd9Sstevel@tonic-gate 	case CLD_CONTINUED:
17117c478bd9Sstevel@tonic-gate 		cv_broadcast(&pp->p_cv);
17127c478bd9Sstevel@tonic-gate 		if (pp->p_flag & SJCTL) {
17137c478bd9Sstevel@tonic-gate 			post_sigcld(cp, sqp);
17147c478bd9Sstevel@tonic-gate 			sqp = NULL;
17157c478bd9Sstevel@tonic-gate 		}
17167c478bd9Sstevel@tonic-gate 		break;
17177c478bd9Sstevel@tonic-gate 	}
17187c478bd9Sstevel@tonic-gate 
17197c478bd9Sstevel@tonic-gate 	if (sqp)
17207c478bd9Sstevel@tonic-gate 		siginfofree(sqp);
17217c478bd9Sstevel@tonic-gate }
17227c478bd9Sstevel@tonic-gate 
17237c478bd9Sstevel@tonic-gate /*
17243f12bda8SRoger A. Faulkner  * Common code called from sigcld() and from
17253f12bda8SRoger A. Faulkner  * waitid() and issig_forreal() via sigcld_repost().
17267c478bd9Sstevel@tonic-gate  * Give the parent process a SIGCLD if it does not have one pending,
17277c478bd9Sstevel@tonic-gate  * else mark the child process so a SIGCLD can be posted later.
17287c478bd9Sstevel@tonic-gate  */
17297c478bd9Sstevel@tonic-gate static void
17307c478bd9Sstevel@tonic-gate post_sigcld(proc_t *cp, sigqueue_t *sqp)
17317c478bd9Sstevel@tonic-gate {
17327c478bd9Sstevel@tonic-gate 	proc_t *pp = cp->p_parent;
17337c478bd9Sstevel@tonic-gate 	k_siginfo_t info;
17347c478bd9Sstevel@tonic-gate 
17357c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
17367c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
17377c478bd9Sstevel@tonic-gate 
17387c478bd9Sstevel@tonic-gate 	/*
17393f12bda8SRoger A. Faulkner 	 * If a SIGCLD is pending, then just mark the child process
17403f12bda8SRoger A. Faulkner 	 * so that its SIGCLD will be posted later, when the first
17413f12bda8SRoger A. Faulkner 	 * SIGCLD is taken off the queue or when the parent is ready
17423f12bda8SRoger A. Faulkner 	 * to receive it or accept it, if ever.
17437c478bd9Sstevel@tonic-gate 	 */
17443f12bda8SRoger A. Faulkner 	if (sigismember(&pp->p_sig, SIGCLD)) {
17457c478bd9Sstevel@tonic-gate 		cp->p_pidflag |= CLDPEND;
17463f12bda8SRoger A. Faulkner 	} else {
17477c478bd9Sstevel@tonic-gate 		cp->p_pidflag &= ~CLDPEND;
17487c478bd9Sstevel@tonic-gate 		if (sqp == NULL) {
17497c478bd9Sstevel@tonic-gate 			/*
17507c478bd9Sstevel@tonic-gate 			 * This can only happen when the parent is init.
17517c478bd9Sstevel@tonic-gate 			 * (See call to sigcld(q, NULL) in exit().)
17527c478bd9Sstevel@tonic-gate 			 * Use KM_NOSLEEP to avoid deadlock.
17537c478bd9Sstevel@tonic-gate 			 */
17547c478bd9Sstevel@tonic-gate 			ASSERT(pp == proc_init);
17557c478bd9Sstevel@tonic-gate 			winfo(cp, &info, 0);
17567c478bd9Sstevel@tonic-gate 			sigaddq(pp, NULL, &info, KM_NOSLEEP);
17577c478bd9Sstevel@tonic-gate 		} else {
17587c478bd9Sstevel@tonic-gate 			winfo(cp, &sqp->sq_info, 0);
17597c478bd9Sstevel@tonic-gate 			sigaddqa(pp, NULL, sqp);
17607c478bd9Sstevel@tonic-gate 			sqp = NULL;
17617c478bd9Sstevel@tonic-gate 		}
17627c478bd9Sstevel@tonic-gate 	}
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
17657c478bd9Sstevel@tonic-gate 
17667c478bd9Sstevel@tonic-gate 	if (sqp)
17677c478bd9Sstevel@tonic-gate 		siginfofree(sqp);
17687c478bd9Sstevel@tonic-gate }
17697c478bd9Sstevel@tonic-gate 
17707c478bd9Sstevel@tonic-gate /*
17717c478bd9Sstevel@tonic-gate  * Search for a child that has a pending SIGCLD for us, the parent.
17727c478bd9Sstevel@tonic-gate  * The queue of SIGCLD signals is implied by the list of children.
17737c478bd9Sstevel@tonic-gate  * We post the SIGCLD signals one at a time so they don't get lost.
17747c478bd9Sstevel@tonic-gate  * When one is dequeued, another is enqueued, until there are no more.
17757c478bd9Sstevel@tonic-gate  */
17767c478bd9Sstevel@tonic-gate void
17777c478bd9Sstevel@tonic-gate sigcld_repost()
17787c478bd9Sstevel@tonic-gate {
17797c478bd9Sstevel@tonic-gate 	proc_t *pp = curproc;
17807c478bd9Sstevel@tonic-gate 	proc_t *cp;
17817c478bd9Sstevel@tonic-gate 	sigqueue_t *sqp;
17827c478bd9Sstevel@tonic-gate 
17837c478bd9Sstevel@tonic-gate 	sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
17847c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
17857c478bd9Sstevel@tonic-gate 	for (cp = pp->p_child; cp; cp = cp->p_sibling) {
17867c478bd9Sstevel@tonic-gate 		if (cp->p_pidflag & CLDPEND) {
17877c478bd9Sstevel@tonic-gate 			post_sigcld(cp, sqp);
17887c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
17897c478bd9Sstevel@tonic-gate 			return;
17907c478bd9Sstevel@tonic-gate 		}
17917c478bd9Sstevel@tonic-gate 	}
17927c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
17937c478bd9Sstevel@tonic-gate 	kmem_free(sqp, sizeof (sigqueue_t));
17947c478bd9Sstevel@tonic-gate }
17957c478bd9Sstevel@tonic-gate 
17967c478bd9Sstevel@tonic-gate /*
17977c478bd9Sstevel@tonic-gate  * count number of sigqueue send by sigaddqa()
17987c478bd9Sstevel@tonic-gate  */
17997c478bd9Sstevel@tonic-gate void
18007c478bd9Sstevel@tonic-gate sigqsend(int cmd, proc_t *p, kthread_t *t, sigqueue_t *sigqp)
18017c478bd9Sstevel@tonic-gate {
18027c478bd9Sstevel@tonic-gate 	sigqhdr_t *sqh;
18037c478bd9Sstevel@tonic-gate 
18047c478bd9Sstevel@tonic-gate 	sqh = (sigqhdr_t *)sigqp->sq_backptr;
18057c478bd9Sstevel@tonic-gate 	ASSERT(sqh);
18067c478bd9Sstevel@tonic-gate 
18077c478bd9Sstevel@tonic-gate 	mutex_enter(&sqh->sqb_lock);
18087c478bd9Sstevel@tonic-gate 	sqh->sqb_sent++;
18097c478bd9Sstevel@tonic-gate 	mutex_exit(&sqh->sqb_lock);
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 	if (cmd == SN_SEND)
18127c478bd9Sstevel@tonic-gate 		sigaddqa(p, t, sigqp);
18137c478bd9Sstevel@tonic-gate 	else
18147c478bd9Sstevel@tonic-gate 		siginfofree(sigqp);
18157c478bd9Sstevel@tonic-gate }
18167c478bd9Sstevel@tonic-gate 
18177c478bd9Sstevel@tonic-gate int
18187c478bd9Sstevel@tonic-gate sigsendproc(proc_t *p, sigsend_t *pv)
18197c478bd9Sstevel@tonic-gate {
18207c478bd9Sstevel@tonic-gate 	struct cred *cr;
18217c478bd9Sstevel@tonic-gate 	proc_t *myprocp = curproc;
18227c478bd9Sstevel@tonic-gate 
18237c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
18247c478bd9Sstevel@tonic-gate 
18257c478bd9Sstevel@tonic-gate 	if (p->p_pid == 1 && pv->sig && sigismember(&cantmask, pv->sig))
18267c478bd9Sstevel@tonic-gate 		return (EPERM);
18277c478bd9Sstevel@tonic-gate 
18287c478bd9Sstevel@tonic-gate 	cr = CRED();
18297c478bd9Sstevel@tonic-gate 
18307c478bd9Sstevel@tonic-gate 	if (pv->checkperm == 0 ||
18317c478bd9Sstevel@tonic-gate 	    (pv->sig == SIGCONT && p->p_sessp == myprocp->p_sessp) ||
18327c478bd9Sstevel@tonic-gate 	    prochasprocperm(p, myprocp, cr)) {
18337c478bd9Sstevel@tonic-gate 		pv->perm++;
18347c478bd9Sstevel@tonic-gate 		if (pv->sig) {
18357c478bd9Sstevel@tonic-gate 			/* Make sure we should be setting si_pid and friends */
18367c478bd9Sstevel@tonic-gate 			ASSERT(pv->sicode <= 0);
18377c478bd9Sstevel@tonic-gate 			if (SI_CANQUEUE(pv->sicode)) {
18387c478bd9Sstevel@tonic-gate 				sigqueue_t *sqp;
18397c478bd9Sstevel@tonic-gate 
18407c478bd9Sstevel@tonic-gate 				mutex_enter(&myprocp->p_lock);
18417c478bd9Sstevel@tonic-gate 				sqp = sigqalloc(myprocp->p_sigqhdr);
18427c478bd9Sstevel@tonic-gate 				mutex_exit(&myprocp->p_lock);
18437c478bd9Sstevel@tonic-gate 				if (sqp == NULL)
18447c478bd9Sstevel@tonic-gate 					return (EAGAIN);
18457c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_signo = pv->sig;
18467c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_code = pv->sicode;
18477c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_pid = myprocp->p_pid;
18487c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_ctid = PRCTID(myprocp);
18497c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_zoneid = getzoneid();
18507c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_uid = crgetruid(cr);
18517c478bd9Sstevel@tonic-gate 				sqp->sq_info.si_value = pv->value;
18527c478bd9Sstevel@tonic-gate 				mutex_enter(&p->p_lock);
18537c478bd9Sstevel@tonic-gate 				sigqsend(SN_SEND, p, NULL, sqp);
18547c478bd9Sstevel@tonic-gate 				mutex_exit(&p->p_lock);
18557c478bd9Sstevel@tonic-gate 			} else {
18567c478bd9Sstevel@tonic-gate 				k_siginfo_t info;
18577c478bd9Sstevel@tonic-gate 				bzero(&info, sizeof (info));
18587c478bd9Sstevel@tonic-gate 				info.si_signo = pv->sig;
18597c478bd9Sstevel@tonic-gate 				info.si_code = pv->sicode;
18607c478bd9Sstevel@tonic-gate 				info.si_pid = myprocp->p_pid;
18617c478bd9Sstevel@tonic-gate 				info.si_ctid = PRCTID(myprocp);
18627c478bd9Sstevel@tonic-gate 				info.si_zoneid = getzoneid();
18637c478bd9Sstevel@tonic-gate 				info.si_uid = crgetruid(cr);
18647c478bd9Sstevel@tonic-gate 				mutex_enter(&p->p_lock);
18657c478bd9Sstevel@tonic-gate 				/*
18667c478bd9Sstevel@tonic-gate 				 * XXX: Should be KM_SLEEP but
18677c478bd9Sstevel@tonic-gate 				 * we have to avoid deadlock.
18687c478bd9Sstevel@tonic-gate 				 */
18697c478bd9Sstevel@tonic-gate 				sigaddq(p, NULL, &info, KM_NOSLEEP);
18707c478bd9Sstevel@tonic-gate 				mutex_exit(&p->p_lock);
18717c478bd9Sstevel@tonic-gate 			}
18727c478bd9Sstevel@tonic-gate 		}
18737c478bd9Sstevel@tonic-gate 	}
18747c478bd9Sstevel@tonic-gate 
18757c478bd9Sstevel@tonic-gate 	return (0);
18767c478bd9Sstevel@tonic-gate }
18777c478bd9Sstevel@tonic-gate 
18787c478bd9Sstevel@tonic-gate int
18797c478bd9Sstevel@tonic-gate sigsendset(procset_t *psp, sigsend_t *pv)
18807c478bd9Sstevel@tonic-gate {
18817c478bd9Sstevel@tonic-gate 	int error;
18827c478bd9Sstevel@tonic-gate 
18837c478bd9Sstevel@tonic-gate 	error = dotoprocs(psp, sigsendproc, (char *)pv);
18847c478bd9Sstevel@tonic-gate 	if (error == 0 && pv->perm == 0)
18857c478bd9Sstevel@tonic-gate 		return (EPERM);
18867c478bd9Sstevel@tonic-gate 
18877c478bd9Sstevel@tonic-gate 	return (error);
18887c478bd9Sstevel@tonic-gate }
18897c478bd9Sstevel@tonic-gate 
18907c478bd9Sstevel@tonic-gate /*
18917c478bd9Sstevel@tonic-gate  * Dequeue a queued siginfo structure.
18927c478bd9Sstevel@tonic-gate  * If a non-null thread pointer is passed then dequeue from
18937c478bd9Sstevel@tonic-gate  * the thread queue, otherwise dequeue from the process queue.
18947c478bd9Sstevel@tonic-gate  */
18957c478bd9Sstevel@tonic-gate void
18967c478bd9Sstevel@tonic-gate sigdeq(proc_t *p, kthread_t *t, int sig, sigqueue_t **qpp)
18977c478bd9Sstevel@tonic-gate {
18987c478bd9Sstevel@tonic-gate 	sigqueue_t **psqp, *sqp;
18997c478bd9Sstevel@tonic-gate 
19007c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
19017c478bd9Sstevel@tonic-gate 
19027c478bd9Sstevel@tonic-gate 	*qpp = NULL;
19037c478bd9Sstevel@tonic-gate 
19047c478bd9Sstevel@tonic-gate 	if (t != NULL) {
19057c478bd9Sstevel@tonic-gate 		sigdelset(&t->t_sig, sig);
19067c478bd9Sstevel@tonic-gate 		sigdelset(&t->t_extsig, sig);
19077c478bd9Sstevel@tonic-gate 		psqp = &t->t_sigqueue;
19087c478bd9Sstevel@tonic-gate 	} else {
19097c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_sig, sig);
19107c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_extsig, sig);
19117c478bd9Sstevel@tonic-gate 		psqp = &p->p_sigqueue;
19127c478bd9Sstevel@tonic-gate 	}
19137c478bd9Sstevel@tonic-gate 
19147c478bd9Sstevel@tonic-gate 	for (;;) {
19157c478bd9Sstevel@tonic-gate 		if ((sqp = *psqp) == NULL)
19167c478bd9Sstevel@tonic-gate 			return;
19177c478bd9Sstevel@tonic-gate 		if (sqp->sq_info.si_signo == sig)
19187c478bd9Sstevel@tonic-gate 			break;
19197c478bd9Sstevel@tonic-gate 		else
19207c478bd9Sstevel@tonic-gate 			psqp = &sqp->sq_next;
19217c478bd9Sstevel@tonic-gate 	}
19227c478bd9Sstevel@tonic-gate 	*qpp = sqp;
19237c478bd9Sstevel@tonic-gate 	*psqp = sqp->sq_next;
19247c478bd9Sstevel@tonic-gate 	for (sqp = *psqp; sqp; sqp = sqp->sq_next) {
19257c478bd9Sstevel@tonic-gate 		if (sqp->sq_info.si_signo == sig) {
19267c478bd9Sstevel@tonic-gate 			if (t != (kthread_t *)NULL) {
19277c478bd9Sstevel@tonic-gate 				sigaddset(&t->t_sig, sig);
19287c478bd9Sstevel@tonic-gate 				t->t_sig_check = 1;
19297c478bd9Sstevel@tonic-gate 			} else {
19307c478bd9Sstevel@tonic-gate 				sigaddset(&p->p_sig, sig);
19317c478bd9Sstevel@tonic-gate 				set_proc_ast(p);
19327c478bd9Sstevel@tonic-gate 			}
19337c478bd9Sstevel@tonic-gate 			break;
19347c478bd9Sstevel@tonic-gate 		}
19357c478bd9Sstevel@tonic-gate 	}
19367c478bd9Sstevel@tonic-gate }
19377c478bd9Sstevel@tonic-gate 
19387c478bd9Sstevel@tonic-gate /*
19397c478bd9Sstevel@tonic-gate  * Delete a queued SIGCLD siginfo structure matching the k_siginfo_t argument.
19407c478bd9Sstevel@tonic-gate  */
19417c478bd9Sstevel@tonic-gate void
19427c478bd9Sstevel@tonic-gate sigcld_delete(k_siginfo_t *ip)
19437c478bd9Sstevel@tonic-gate {
19447c478bd9Sstevel@tonic-gate 	proc_t *p = curproc;
19457c478bd9Sstevel@tonic-gate 	int another_sigcld = 0;
19467c478bd9Sstevel@tonic-gate 	sigqueue_t **psqp, *sqp;
19477c478bd9Sstevel@tonic-gate 
19487c478bd9Sstevel@tonic-gate 	ASSERT(ip->si_signo == SIGCLD);
19497c478bd9Sstevel@tonic-gate 
19507c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
19517c478bd9Sstevel@tonic-gate 
19527c478bd9Sstevel@tonic-gate 	if (!sigismember(&p->p_sig, SIGCLD)) {
19537c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
19547c478bd9Sstevel@tonic-gate 		return;
19557c478bd9Sstevel@tonic-gate 	}
19567c478bd9Sstevel@tonic-gate 
19577c478bd9Sstevel@tonic-gate 	psqp = &p->p_sigqueue;
19587c478bd9Sstevel@tonic-gate 	for (;;) {
19597c478bd9Sstevel@tonic-gate 		if ((sqp = *psqp) == NULL) {
19607c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
19617c478bd9Sstevel@tonic-gate 			return;
19627c478bd9Sstevel@tonic-gate 		}
19637c478bd9Sstevel@tonic-gate 		if (sqp->sq_info.si_signo == SIGCLD) {
19647c478bd9Sstevel@tonic-gate 			if (sqp->sq_info.si_pid == ip->si_pid &&
19657c478bd9Sstevel@tonic-gate 			    sqp->sq_info.si_code == ip->si_code &&
19667c478bd9Sstevel@tonic-gate 			    sqp->sq_info.si_status == ip->si_status)
19677c478bd9Sstevel@tonic-gate 				break;
19687c478bd9Sstevel@tonic-gate 			another_sigcld = 1;
19697c478bd9Sstevel@tonic-gate 		}
19707c478bd9Sstevel@tonic-gate 		psqp = &sqp->sq_next;
19717c478bd9Sstevel@tonic-gate 	}
19727c478bd9Sstevel@tonic-gate 	*psqp = sqp->sq_next;
19737c478bd9Sstevel@tonic-gate 
19747c478bd9Sstevel@tonic-gate 	siginfofree(sqp);
19757c478bd9Sstevel@tonic-gate 
19767c478bd9Sstevel@tonic-gate 	for (sqp = *psqp; !another_sigcld && sqp; sqp = sqp->sq_next) {
19777c478bd9Sstevel@tonic-gate 		if (sqp->sq_info.si_signo == SIGCLD)
19787c478bd9Sstevel@tonic-gate 			another_sigcld = 1;
19797c478bd9Sstevel@tonic-gate 	}
19807c478bd9Sstevel@tonic-gate 
19817c478bd9Sstevel@tonic-gate 	if (!another_sigcld) {
19827c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_sig, SIGCLD);
19837c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_extsig, SIGCLD);
19847c478bd9Sstevel@tonic-gate 	}
19857c478bd9Sstevel@tonic-gate 
19867c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
19877c478bd9Sstevel@tonic-gate }
19887c478bd9Sstevel@tonic-gate 
19897c478bd9Sstevel@tonic-gate /*
19907c478bd9Sstevel@tonic-gate  * Delete queued siginfo structures.
19917c478bd9Sstevel@tonic-gate  * If a non-null thread pointer is passed then delete from
19927c478bd9Sstevel@tonic-gate  * the thread queue, otherwise delete from the process queue.
19937c478bd9Sstevel@tonic-gate  */
19947c478bd9Sstevel@tonic-gate void
19957c478bd9Sstevel@tonic-gate sigdelq(proc_t *p, kthread_t *t, int sig)
19967c478bd9Sstevel@tonic-gate {
19977c478bd9Sstevel@tonic-gate 	sigqueue_t **psqp, *sqp;
19987c478bd9Sstevel@tonic-gate 
19997c478bd9Sstevel@tonic-gate 	/*
20007c478bd9Sstevel@tonic-gate 	 * We must be holding p->p_lock unless the process is
20017c478bd9Sstevel@tonic-gate 	 * being reaped or has failed to get started on fork.
20027c478bd9Sstevel@tonic-gate 	 */
20037c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock) ||
20047c478bd9Sstevel@tonic-gate 	    p->p_stat == SIDL || p->p_stat == SZOMB);
20057c478bd9Sstevel@tonic-gate 
20067c478bd9Sstevel@tonic-gate 	if (t != (kthread_t *)NULL)
20077c478bd9Sstevel@tonic-gate 		psqp = &t->t_sigqueue;
20087c478bd9Sstevel@tonic-gate 	else
20097c478bd9Sstevel@tonic-gate 		psqp = &p->p_sigqueue;
20107c478bd9Sstevel@tonic-gate 
20117c478bd9Sstevel@tonic-gate 	while (*psqp) {
20127c478bd9Sstevel@tonic-gate 		sqp = *psqp;
20137c478bd9Sstevel@tonic-gate 		if (sig == 0 || sqp->sq_info.si_signo == sig) {
20147c478bd9Sstevel@tonic-gate 			*psqp = sqp->sq_next;
20157c478bd9Sstevel@tonic-gate 			siginfofree(sqp);
20167c478bd9Sstevel@tonic-gate 		} else
20177c478bd9Sstevel@tonic-gate 			psqp = &sqp->sq_next;
20187c478bd9Sstevel@tonic-gate 	}
20197c478bd9Sstevel@tonic-gate }
20207c478bd9Sstevel@tonic-gate 
20217c478bd9Sstevel@tonic-gate /*
20227c478bd9Sstevel@tonic-gate  * Insert a siginfo structure into a queue.
20237c478bd9Sstevel@tonic-gate  * If a non-null thread pointer is passed then add to the thread queue,
20247c478bd9Sstevel@tonic-gate  * otherwise add to the process queue.
20257c478bd9Sstevel@tonic-gate  *
20267c478bd9Sstevel@tonic-gate  * The function sigaddqins() is called with sigqueue already allocated.
20277c478bd9Sstevel@tonic-gate  * It is called from sigaddqa() and sigaddq() below.
20287c478bd9Sstevel@tonic-gate  *
20297c478bd9Sstevel@tonic-gate  * The value of si_code implicitly indicates whether sigp is to be
20307c478bd9Sstevel@tonic-gate  * explicitly queued, or to be queued to depth one.
20317c478bd9Sstevel@tonic-gate  */
20327c478bd9Sstevel@tonic-gate static void
20337c478bd9Sstevel@tonic-gate sigaddqins(proc_t *p, kthread_t *t, sigqueue_t *sigqp)
20347c478bd9Sstevel@tonic-gate {
20357c478bd9Sstevel@tonic-gate 	sigqueue_t **psqp;
20367c478bd9Sstevel@tonic-gate 	int sig = sigqp->sq_info.si_signo;
20377c478bd9Sstevel@tonic-gate 
20387c478bd9Sstevel@tonic-gate 	sigqp->sq_external = (curproc != &p0) &&
20397c478bd9Sstevel@tonic-gate 	    (curproc->p_ct_process != p->p_ct_process);
20407c478bd9Sstevel@tonic-gate 
20417c478bd9Sstevel@tonic-gate 	/*
20427c478bd9Sstevel@tonic-gate 	 * issig_forreal() doesn't bother dequeueing signals if SKILLED
20437c478bd9Sstevel@tonic-gate 	 * is set, and even if it did, we would want to avoid situation
20447c478bd9Sstevel@tonic-gate 	 * (which would be unique to SIGKILL) where one thread dequeued
20457c478bd9Sstevel@tonic-gate 	 * the sigqueue_t and another executed psig().  So we create a
20467c478bd9Sstevel@tonic-gate 	 * separate stash for SIGKILL's sigqueue_t.  Because a second
20477c478bd9Sstevel@tonic-gate 	 * SIGKILL can set SEXTKILLED, we overwrite the existing entry
20487c478bd9Sstevel@tonic-gate 	 * if (and only if) it was non-extracontractual.
20497c478bd9Sstevel@tonic-gate 	 */
20507c478bd9Sstevel@tonic-gate 	if (sig == SIGKILL) {
20517c478bd9Sstevel@tonic-gate 		if (p->p_killsqp == NULL || !p->p_killsqp->sq_external) {
20527c478bd9Sstevel@tonic-gate 			if (p->p_killsqp != NULL)
20537c478bd9Sstevel@tonic-gate 				siginfofree(p->p_killsqp);
20547c478bd9Sstevel@tonic-gate 			p->p_killsqp = sigqp;
20557c478bd9Sstevel@tonic-gate 			sigqp->sq_next = NULL;
20567c478bd9Sstevel@tonic-gate 		} else {
20577c478bd9Sstevel@tonic-gate 			siginfofree(sigqp);
20587c478bd9Sstevel@tonic-gate 		}
20597c478bd9Sstevel@tonic-gate 		return;
20607c478bd9Sstevel@tonic-gate 	}
20617c478bd9Sstevel@tonic-gate 
20627c478bd9Sstevel@tonic-gate 	ASSERT(sig >= 1 && sig < NSIG);
20637c478bd9Sstevel@tonic-gate 	if (t != NULL)	/* directed to a thread */
20647c478bd9Sstevel@tonic-gate 		psqp = &t->t_sigqueue;
20657c478bd9Sstevel@tonic-gate 	else 		/* directed to a process */
20667c478bd9Sstevel@tonic-gate 		psqp = &p->p_sigqueue;
20677c478bd9Sstevel@tonic-gate 	if (SI_CANQUEUE(sigqp->sq_info.si_code) &&
20687c478bd9Sstevel@tonic-gate 	    sigismember(&p->p_siginfo, sig)) {
20697c478bd9Sstevel@tonic-gate 		for (; *psqp != NULL; psqp = &(*psqp)->sq_next)
20707c478bd9Sstevel@tonic-gate 				;
20717c478bd9Sstevel@tonic-gate 	} else {
20727c478bd9Sstevel@tonic-gate 		for (; *psqp != NULL; psqp = &(*psqp)->sq_next) {
20737c478bd9Sstevel@tonic-gate 			if ((*psqp)->sq_info.si_signo == sig) {
20747c478bd9Sstevel@tonic-gate 				siginfofree(sigqp);
20757c478bd9Sstevel@tonic-gate 				return;
20767c478bd9Sstevel@tonic-gate 			}
20777c478bd9Sstevel@tonic-gate 		}
20787c478bd9Sstevel@tonic-gate 	}
20797c478bd9Sstevel@tonic-gate 	*psqp = sigqp;
20807c478bd9Sstevel@tonic-gate 	sigqp->sq_next = NULL;
20817c478bd9Sstevel@tonic-gate }
20827c478bd9Sstevel@tonic-gate 
20837c478bd9Sstevel@tonic-gate /*
20847c478bd9Sstevel@tonic-gate  * The function sigaddqa() is called with sigqueue already allocated.
20857c478bd9Sstevel@tonic-gate  * If signal is ignored, discard but guarantee KILL and generation semantics.
20867c478bd9Sstevel@tonic-gate  * It is called from sigqueue() and other places.
20877c478bd9Sstevel@tonic-gate  */
20887c478bd9Sstevel@tonic-gate void
20897c478bd9Sstevel@tonic-gate sigaddqa(proc_t *p, kthread_t *t, sigqueue_t *sigqp)
20907c478bd9Sstevel@tonic-gate {
20917c478bd9Sstevel@tonic-gate 	int sig = sigqp->sq_info.si_signo;
20927c478bd9Sstevel@tonic-gate 
20937c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
20947c478bd9Sstevel@tonic-gate 	ASSERT(sig >= 1 && sig < NSIG);
20957c478bd9Sstevel@tonic-gate 
20967c478bd9Sstevel@tonic-gate 	if (sig_discardable(p, sig))
20977c478bd9Sstevel@tonic-gate 		siginfofree(sigqp);
20987c478bd9Sstevel@tonic-gate 	else
20997c478bd9Sstevel@tonic-gate 		sigaddqins(p, t, sigqp);
21007c478bd9Sstevel@tonic-gate 
21017c478bd9Sstevel@tonic-gate 	sigtoproc(p, t, sig);
21027c478bd9Sstevel@tonic-gate }
21037c478bd9Sstevel@tonic-gate 
21047c478bd9Sstevel@tonic-gate /*
21057c478bd9Sstevel@tonic-gate  * Allocate the sigqueue_t structure and call sigaddqins().
21067c478bd9Sstevel@tonic-gate  */
21077c478bd9Sstevel@tonic-gate void
21087c478bd9Sstevel@tonic-gate sigaddq(proc_t *p, kthread_t *t, k_siginfo_t *infop, int km_flags)
21097c478bd9Sstevel@tonic-gate {
21107c478bd9Sstevel@tonic-gate 	sigqueue_t *sqp;
21117c478bd9Sstevel@tonic-gate 	int sig = infop->si_signo;
21127c478bd9Sstevel@tonic-gate 
21137c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
21147c478bd9Sstevel@tonic-gate 	ASSERT(sig >= 1 && sig < NSIG);
21157c478bd9Sstevel@tonic-gate 
21167c478bd9Sstevel@tonic-gate 	/*
21177c478bd9Sstevel@tonic-gate 	 * If the signal will be discarded by sigtoproc() or
21187c478bd9Sstevel@tonic-gate 	 * if the process isn't requesting siginfo and it isn't
21197c478bd9Sstevel@tonic-gate 	 * blocking the signal (it *could* change it's mind while
21207c478bd9Sstevel@tonic-gate 	 * the signal is pending) then don't bother creating one.
21217c478bd9Sstevel@tonic-gate 	 */
21227c478bd9Sstevel@tonic-gate 	if (!sig_discardable(p, sig) &&
21237c478bd9Sstevel@tonic-gate 	    (sigismember(&p->p_siginfo, sig) ||
21247c478bd9Sstevel@tonic-gate 	    (curproc->p_ct_process != p->p_ct_process) ||
21257c478bd9Sstevel@tonic-gate 	    (sig == SIGCLD && SI_FROMKERNEL(infop))) &&
21267c478bd9Sstevel@tonic-gate 	    ((sqp = kmem_alloc(sizeof (sigqueue_t), km_flags)) != NULL)) {
21277c478bd9Sstevel@tonic-gate 		bcopy(infop, &sqp->sq_info, sizeof (k_siginfo_t));
21287c478bd9Sstevel@tonic-gate 		sqp->sq_func = NULL;
21297c478bd9Sstevel@tonic-gate 		sqp->sq_next = NULL;
21307c478bd9Sstevel@tonic-gate 		sigaddqins(p, t, sqp);
21317c478bd9Sstevel@tonic-gate 	}
21327c478bd9Sstevel@tonic-gate 	sigtoproc(p, t, sig);
21337c478bd9Sstevel@tonic-gate }
21347c478bd9Sstevel@tonic-gate 
21357c478bd9Sstevel@tonic-gate /*
21367c478bd9Sstevel@tonic-gate  * Handle stop-on-fault processing for the debugger.  Returns 0
21377c478bd9Sstevel@tonic-gate  * if the fault is cleared during the stop, nonzero if it isn't.
21387c478bd9Sstevel@tonic-gate  */
21397c478bd9Sstevel@tonic-gate int
21407c478bd9Sstevel@tonic-gate stop_on_fault(uint_t fault, k_siginfo_t *sip)
21417c478bd9Sstevel@tonic-gate {
21427c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(curthread);
21437c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(curthread);
21447c478bd9Sstevel@tonic-gate 
21457c478bd9Sstevel@tonic-gate 	ASSERT(prismember(&p->p_fltmask, fault));
21467c478bd9Sstevel@tonic-gate 
21477c478bd9Sstevel@tonic-gate 	/*
21487c478bd9Sstevel@tonic-gate 	 * Record current fault and siginfo structure so debugger can
21497c478bd9Sstevel@tonic-gate 	 * find it.
21507c478bd9Sstevel@tonic-gate 	 */
21517c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
21527c478bd9Sstevel@tonic-gate 	lwp->lwp_curflt = (uchar_t)fault;
21537c478bd9Sstevel@tonic-gate 	lwp->lwp_siginfo = *sip;
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	stop(PR_FAULTED, fault);
21567c478bd9Sstevel@tonic-gate 
21577c478bd9Sstevel@tonic-gate 	fault = lwp->lwp_curflt;
21587c478bd9Sstevel@tonic-gate 	lwp->lwp_curflt = 0;
21597c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
21607c478bd9Sstevel@tonic-gate 	return (fault);
21617c478bd9Sstevel@tonic-gate }
21627c478bd9Sstevel@tonic-gate 
21637c478bd9Sstevel@tonic-gate void
21647c478bd9Sstevel@tonic-gate sigorset(k_sigset_t *s1, k_sigset_t *s2)
21657c478bd9Sstevel@tonic-gate {
21667c478bd9Sstevel@tonic-gate 	s1->__sigbits[0] |= s2->__sigbits[0];
21677c478bd9Sstevel@tonic-gate 	s1->__sigbits[1] |= s2->__sigbits[1];
21687c478bd9Sstevel@tonic-gate }
21697c478bd9Sstevel@tonic-gate 
21707c478bd9Sstevel@tonic-gate void
21717c478bd9Sstevel@tonic-gate sigandset(k_sigset_t *s1, k_sigset_t *s2)
21727c478bd9Sstevel@tonic-gate {
21737c478bd9Sstevel@tonic-gate 	s1->__sigbits[0] &= s2->__sigbits[0];
21747c478bd9Sstevel@tonic-gate 	s1->__sigbits[1] &= s2->__sigbits[1];
21757c478bd9Sstevel@tonic-gate }
21767c478bd9Sstevel@tonic-gate 
21777c478bd9Sstevel@tonic-gate void
21787c478bd9Sstevel@tonic-gate sigdiffset(k_sigset_t *s1, k_sigset_t *s2)
21797c478bd9Sstevel@tonic-gate {
21807c478bd9Sstevel@tonic-gate 	s1->__sigbits[0] &= ~(s2->__sigbits[0]);
21817c478bd9Sstevel@tonic-gate 	s1->__sigbits[1] &= ~(s2->__sigbits[1]);
21827c478bd9Sstevel@tonic-gate }
21837c478bd9Sstevel@tonic-gate 
21847c478bd9Sstevel@tonic-gate /*
21857c478bd9Sstevel@tonic-gate  * Return non-zero if curthread->t_sig_check should be set to 1, that is,
21867c478bd9Sstevel@tonic-gate  * if there are any signals the thread might take on return from the kernel.
21877c478bd9Sstevel@tonic-gate  * If ksigset_t's were a single word, we would do:
21887c478bd9Sstevel@tonic-gate  *	return (((p->p_sig | t->t_sig) & ~t->t_hold) & fillset);
21897c478bd9Sstevel@tonic-gate  */
21907c478bd9Sstevel@tonic-gate int
21917c478bd9Sstevel@tonic-gate sigcheck(proc_t *p, kthread_t *t)
21927c478bd9Sstevel@tonic-gate {
21937c478bd9Sstevel@tonic-gate 	sc_shared_t *tdp = t->t_schedctl;
21947c478bd9Sstevel@tonic-gate 
21957c478bd9Sstevel@tonic-gate 	/*
21967c478bd9Sstevel@tonic-gate 	 * If signals are blocked via the schedctl interface
21977c478bd9Sstevel@tonic-gate 	 * then we only check for the unmaskable signals.
21987c478bd9Sstevel@tonic-gate 	 */
21997c478bd9Sstevel@tonic-gate 	if (tdp != NULL && tdp->sc_sigblock)
22007c478bd9Sstevel@tonic-gate 		return ((p->p_sig.__sigbits[0] | t->t_sig.__sigbits[0]) &
22017c478bd9Sstevel@tonic-gate 		    CANTMASK0);
22027c478bd9Sstevel@tonic-gate 
22037c478bd9Sstevel@tonic-gate 	return (((p->p_sig.__sigbits[0] | t->t_sig.__sigbits[0]) &
22047c478bd9Sstevel@tonic-gate 	    ~t->t_hold.__sigbits[0]) |
22057c478bd9Sstevel@tonic-gate 	    (((p->p_sig.__sigbits[1] | t->t_sig.__sigbits[1]) &
22067c478bd9Sstevel@tonic-gate 	    ~t->t_hold.__sigbits[1]) & FILLSET1));
22077c478bd9Sstevel@tonic-gate }
22087c478bd9Sstevel@tonic-gate 
22097c478bd9Sstevel@tonic-gate /* ONC_PLUS EXTRACT START */
22107c478bd9Sstevel@tonic-gate void
22117c478bd9Sstevel@tonic-gate sigintr(k_sigset_t *smask, int intable)
22127c478bd9Sstevel@tonic-gate {
22137c478bd9Sstevel@tonic-gate 	proc_t *p;
22147c478bd9Sstevel@tonic-gate 	int owned;
22157c478bd9Sstevel@tonic-gate 	k_sigset_t lmask;		/* local copy of cantmask */
22167c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(curthread);
22177c478bd9Sstevel@tonic-gate 
22187c478bd9Sstevel@tonic-gate 	/*
22197c478bd9Sstevel@tonic-gate 	 * Mask out all signals except SIGHUP, SIGINT, SIGQUIT
22207c478bd9Sstevel@tonic-gate 	 *    and SIGTERM. (Preserving the existing masks).
22217c478bd9Sstevel@tonic-gate 	 *    This function supports the -intr nfs and ufs mount option.
22227c478bd9Sstevel@tonic-gate 	 */
22237c478bd9Sstevel@tonic-gate 
22247c478bd9Sstevel@tonic-gate 	/*
22257c478bd9Sstevel@tonic-gate 	 * don't do kernel threads
22267c478bd9Sstevel@tonic-gate 	 */
22277c478bd9Sstevel@tonic-gate 	if (lwp == NULL)
22287c478bd9Sstevel@tonic-gate 		return;
22297c478bd9Sstevel@tonic-gate 
22307c478bd9Sstevel@tonic-gate 	/*
22317c478bd9Sstevel@tonic-gate 	 * get access to signal mask
22327c478bd9Sstevel@tonic-gate 	 */
22337c478bd9Sstevel@tonic-gate 	p = ttoproc(curthread);
22347c478bd9Sstevel@tonic-gate 	owned = mutex_owned(&p->p_lock);	/* this is filthy */
22357c478bd9Sstevel@tonic-gate 	if (!owned)
22367c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_lock);
22377c478bd9Sstevel@tonic-gate 
22387c478bd9Sstevel@tonic-gate 	/*
22397c478bd9Sstevel@tonic-gate 	 * remember the current mask
22407c478bd9Sstevel@tonic-gate 	 */
22417c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(curthread);
22427c478bd9Sstevel@tonic-gate 	*smask = curthread->t_hold;
22437c478bd9Sstevel@tonic-gate 
22447c478bd9Sstevel@tonic-gate 	/*
22457c478bd9Sstevel@tonic-gate 	 * mask out all signals
22467c478bd9Sstevel@tonic-gate 	 */
22477c478bd9Sstevel@tonic-gate 	sigfillset(&curthread->t_hold);
22487c478bd9Sstevel@tonic-gate 
22497c478bd9Sstevel@tonic-gate 	/*
22507c478bd9Sstevel@tonic-gate 	 * Unmask the non-maskable signals (e.g., KILL), as long as
22517c478bd9Sstevel@tonic-gate 	 * they aren't already masked (which could happen at exit).
22527c478bd9Sstevel@tonic-gate 	 * The first sigdiffset sets lmask to (cantmask & ~curhold).  The
22537c478bd9Sstevel@tonic-gate 	 * second sets the current hold mask to (~0 & ~lmask), which reduces
22547c478bd9Sstevel@tonic-gate 	 * to (~cantmask | curhold).
22557c478bd9Sstevel@tonic-gate 	 */
22567c478bd9Sstevel@tonic-gate 	lmask = cantmask;
22577c478bd9Sstevel@tonic-gate 	sigdiffset(&lmask, smask);
22587c478bd9Sstevel@tonic-gate 	sigdiffset(&curthread->t_hold, &lmask);
22597c478bd9Sstevel@tonic-gate 
22607c478bd9Sstevel@tonic-gate 	/*
22617c478bd9Sstevel@tonic-gate 	 * Re-enable HUP, QUIT, and TERM iff they were originally enabled
22627c478bd9Sstevel@tonic-gate 	 * Re-enable INT if it's originally enabled and the NFS mount option
22637c478bd9Sstevel@tonic-gate 	 * nointr is not set.
22647c478bd9Sstevel@tonic-gate 	 */
22657c478bd9Sstevel@tonic-gate 	if (!sigismember(smask, SIGHUP))
22667c478bd9Sstevel@tonic-gate 		sigdelset(&curthread->t_hold, SIGHUP);
22677c478bd9Sstevel@tonic-gate 	if (!sigismember(smask, SIGINT) && intable)
22687c478bd9Sstevel@tonic-gate 		sigdelset(&curthread->t_hold, SIGINT);
22697c478bd9Sstevel@tonic-gate 	if (!sigismember(smask, SIGQUIT))
22707c478bd9Sstevel@tonic-gate 		sigdelset(&curthread->t_hold, SIGQUIT);
22717c478bd9Sstevel@tonic-gate 	if (!sigismember(smask, SIGTERM))
22727c478bd9Sstevel@tonic-gate 		sigdelset(&curthread->t_hold, SIGTERM);
22737c478bd9Sstevel@tonic-gate 
22747c478bd9Sstevel@tonic-gate 	/*
22757c478bd9Sstevel@tonic-gate 	 * release access to signal mask
22767c478bd9Sstevel@tonic-gate 	 */
22777c478bd9Sstevel@tonic-gate 	if (!owned)
22787c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
22797c478bd9Sstevel@tonic-gate 
22807c478bd9Sstevel@tonic-gate 	/*
22817c478bd9Sstevel@tonic-gate 	 * Indicate that this lwp is not to be stopped.
22827c478bd9Sstevel@tonic-gate 	 */
22837c478bd9Sstevel@tonic-gate 	lwp->lwp_nostop++;
22847c478bd9Sstevel@tonic-gate 
22857c478bd9Sstevel@tonic-gate }
22867c478bd9Sstevel@tonic-gate /* ONC_PLUS EXTRACT END */
22877c478bd9Sstevel@tonic-gate 
22887c478bd9Sstevel@tonic-gate void
22897c478bd9Sstevel@tonic-gate sigunintr(k_sigset_t *smask)
22907c478bd9Sstevel@tonic-gate {
22917c478bd9Sstevel@tonic-gate 	proc_t *p;
22927c478bd9Sstevel@tonic-gate 	int owned;
22937c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(curthread);
22947c478bd9Sstevel@tonic-gate 
22957c478bd9Sstevel@tonic-gate 	/*
22967c478bd9Sstevel@tonic-gate 	 * Reset previous mask (See sigintr() above)
22977c478bd9Sstevel@tonic-gate 	 */
22987c478bd9Sstevel@tonic-gate 	if (lwp != NULL) {
22997c478bd9Sstevel@tonic-gate 		lwp->lwp_nostop--;	/* restore lwp stoppability */
23007c478bd9Sstevel@tonic-gate 		p = ttoproc(curthread);
23017c478bd9Sstevel@tonic-gate 		owned = mutex_owned(&p->p_lock);	/* this is filthy */
23027c478bd9Sstevel@tonic-gate 		if (!owned)
23037c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
23047c478bd9Sstevel@tonic-gate 		curthread->t_hold = *smask;
23057c478bd9Sstevel@tonic-gate 		/* so unmasked signals will be seen */
23067c478bd9Sstevel@tonic-gate 		curthread->t_sig_check = 1;
23077c478bd9Sstevel@tonic-gate 		if (!owned)
23087c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
23097c478bd9Sstevel@tonic-gate 	}
23107c478bd9Sstevel@tonic-gate }
23117c478bd9Sstevel@tonic-gate 
23127c478bd9Sstevel@tonic-gate void
23137c478bd9Sstevel@tonic-gate sigreplace(k_sigset_t *newmask, k_sigset_t *oldmask)
23147c478bd9Sstevel@tonic-gate {
23157c478bd9Sstevel@tonic-gate 	proc_t	*p;
23167c478bd9Sstevel@tonic-gate 	int owned;
23177c478bd9Sstevel@tonic-gate 	/*
23187c478bd9Sstevel@tonic-gate 	 * Save current signal mask in oldmask, then
23197c478bd9Sstevel@tonic-gate 	 * set it to newmask.
23207c478bd9Sstevel@tonic-gate 	 */
23217c478bd9Sstevel@tonic-gate 	if (ttolwp(curthread) != NULL) {
23227c478bd9Sstevel@tonic-gate 		p = ttoproc(curthread);
23237c478bd9Sstevel@tonic-gate 		owned = mutex_owned(&p->p_lock);	/* this is filthy */
23247c478bd9Sstevel@tonic-gate 		if (!owned)
23257c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
23267c478bd9Sstevel@tonic-gate 		schedctl_finish_sigblock(curthread);
23277c478bd9Sstevel@tonic-gate 		if (oldmask != NULL)
23287c478bd9Sstevel@tonic-gate 			*oldmask = curthread->t_hold;
23297c478bd9Sstevel@tonic-gate 		curthread->t_hold = *newmask;
23307c478bd9Sstevel@tonic-gate 		curthread->t_sig_check = 1;
23317c478bd9Sstevel@tonic-gate 		if (!owned)
23327c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
23337c478bd9Sstevel@tonic-gate 	}
23347c478bd9Sstevel@tonic-gate }
23357c478bd9Sstevel@tonic-gate 
23367c478bd9Sstevel@tonic-gate /*
23377c478bd9Sstevel@tonic-gate  * Return true if the signal number is in range
23387c478bd9Sstevel@tonic-gate  * and the signal code specifies signal queueing.
23397c478bd9Sstevel@tonic-gate  */
23407c478bd9Sstevel@tonic-gate int
23417c478bd9Sstevel@tonic-gate sigwillqueue(int sig, int code)
23427c478bd9Sstevel@tonic-gate {
23437c478bd9Sstevel@tonic-gate 	if (sig >= 0 && sig < NSIG) {
23447c478bd9Sstevel@tonic-gate 		switch (code) {
23457c478bd9Sstevel@tonic-gate 		case SI_QUEUE:
23467c478bd9Sstevel@tonic-gate 		case SI_TIMER:
23477c478bd9Sstevel@tonic-gate 		case SI_ASYNCIO:
23487c478bd9Sstevel@tonic-gate 		case SI_MESGQ:
23497c478bd9Sstevel@tonic-gate 			return (1);
23507c478bd9Sstevel@tonic-gate 		}
23517c478bd9Sstevel@tonic-gate 	}
23527c478bd9Sstevel@tonic-gate 	return (0);
23537c478bd9Sstevel@tonic-gate }
23547c478bd9Sstevel@tonic-gate 
23557c478bd9Sstevel@tonic-gate #ifndef	UCHAR_MAX
23567c478bd9Sstevel@tonic-gate #define	UCHAR_MAX	255
23577c478bd9Sstevel@tonic-gate #endif
23587c478bd9Sstevel@tonic-gate 
23597c478bd9Sstevel@tonic-gate /*
23607c478bd9Sstevel@tonic-gate  * The entire pool (with maxcount entries) is pre-allocated at
23617c478bd9Sstevel@tonic-gate  * the first sigqueue/signotify call.
23627c478bd9Sstevel@tonic-gate  */
23637c478bd9Sstevel@tonic-gate sigqhdr_t *
23647c478bd9Sstevel@tonic-gate sigqhdralloc(size_t size, uint_t maxcount)
23657c478bd9Sstevel@tonic-gate {
23667c478bd9Sstevel@tonic-gate 	size_t i;
23677c478bd9Sstevel@tonic-gate 	sigqueue_t *sq, *next;
23687c478bd9Sstevel@tonic-gate 	sigqhdr_t *sqh;
23697c478bd9Sstevel@tonic-gate 
23707c478bd9Sstevel@tonic-gate 	i = (maxcount * size) + sizeof (sigqhdr_t);
23717c478bd9Sstevel@tonic-gate 	ASSERT(maxcount <= UCHAR_MAX && i <= USHRT_MAX);
23727c478bd9Sstevel@tonic-gate 	sqh = kmem_alloc(i, KM_SLEEP);
23737c478bd9Sstevel@tonic-gate 	sqh->sqb_count = (uchar_t)maxcount;
23747c478bd9Sstevel@tonic-gate 	sqh->sqb_maxcount = (uchar_t)maxcount;
23757c478bd9Sstevel@tonic-gate 	sqh->sqb_size = (ushort_t)i;
23767c478bd9Sstevel@tonic-gate 	sqh->sqb_pexited = 0;
23777c478bd9Sstevel@tonic-gate 	sqh->sqb_sent = 0;
23787c478bd9Sstevel@tonic-gate 	sqh->sqb_free = sq = (sigqueue_t *)(sqh + 1);
23797c478bd9Sstevel@tonic-gate 	for (i = maxcount - 1; i != 0; i--) {
23807c478bd9Sstevel@tonic-gate 		next = (sigqueue_t *)((uintptr_t)sq + size);
23817c478bd9Sstevel@tonic-gate 		sq->sq_next = next;
23827c478bd9Sstevel@tonic-gate 		sq = next;
23837c478bd9Sstevel@tonic-gate 	}
23847c478bd9Sstevel@tonic-gate 	sq->sq_next = NULL;
2385f841f6adSraf 	cv_init(&sqh->sqb_cv, NULL, CV_DEFAULT, NULL);
23867c478bd9Sstevel@tonic-gate 	mutex_init(&sqh->sqb_lock, NULL, MUTEX_DEFAULT, NULL);
23877c478bd9Sstevel@tonic-gate 	return (sqh);
23887c478bd9Sstevel@tonic-gate }
23897c478bd9Sstevel@tonic-gate 
23907c478bd9Sstevel@tonic-gate static void sigqrel(sigqueue_t *);
23917c478bd9Sstevel@tonic-gate 
23927c478bd9Sstevel@tonic-gate /*
23937c478bd9Sstevel@tonic-gate  * allocate a sigqueue/signotify structure from the per process
23947c478bd9Sstevel@tonic-gate  * pre-allocated pool.
23957c478bd9Sstevel@tonic-gate  */
23967c478bd9Sstevel@tonic-gate sigqueue_t *
23977c478bd9Sstevel@tonic-gate sigqalloc(sigqhdr_t *sqh)
23987c478bd9Sstevel@tonic-gate {
23997c478bd9Sstevel@tonic-gate 	sigqueue_t *sq = NULL;
24007c478bd9Sstevel@tonic-gate 
24017c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&curproc->p_lock));
24027c478bd9Sstevel@tonic-gate 
24037c478bd9Sstevel@tonic-gate 	if (sqh != NULL) {
24047c478bd9Sstevel@tonic-gate 		mutex_enter(&sqh->sqb_lock);
24057c478bd9Sstevel@tonic-gate 		if (sqh->sqb_count > 0) {
24067c478bd9Sstevel@tonic-gate 			sqh->sqb_count--;
24077c478bd9Sstevel@tonic-gate 			sq = sqh->sqb_free;
24087c478bd9Sstevel@tonic-gate 			sqh->sqb_free = sq->sq_next;
24097c478bd9Sstevel@tonic-gate 			mutex_exit(&sqh->sqb_lock);
24107c478bd9Sstevel@tonic-gate 			bzero(&sq->sq_info, sizeof (k_siginfo_t));
24117c478bd9Sstevel@tonic-gate 			sq->sq_backptr = sqh;
24127c478bd9Sstevel@tonic-gate 			sq->sq_func = sigqrel;
24137c478bd9Sstevel@tonic-gate 			sq->sq_next = NULL;
24147c478bd9Sstevel@tonic-gate 			sq->sq_external = 0;
24157c478bd9Sstevel@tonic-gate 		} else {
24167c478bd9Sstevel@tonic-gate 			mutex_exit(&sqh->sqb_lock);
24177c478bd9Sstevel@tonic-gate 		}
24187c478bd9Sstevel@tonic-gate 	}
24197c478bd9Sstevel@tonic-gate 	return (sq);
24207c478bd9Sstevel@tonic-gate }
24217c478bd9Sstevel@tonic-gate 
24227c478bd9Sstevel@tonic-gate /*
24237c478bd9Sstevel@tonic-gate  * Return a sigqueue structure back to the pre-allocated pool.
24247c478bd9Sstevel@tonic-gate  */
24257c478bd9Sstevel@tonic-gate static void
24267c478bd9Sstevel@tonic-gate sigqrel(sigqueue_t *sq)
24277c478bd9Sstevel@tonic-gate {
24287c478bd9Sstevel@tonic-gate 	sigqhdr_t *sqh;
24297c478bd9Sstevel@tonic-gate 
24307c478bd9Sstevel@tonic-gate 	/* make sure that p_lock of the affected process is held */
24317c478bd9Sstevel@tonic-gate 
24327c478bd9Sstevel@tonic-gate 	sqh = (sigqhdr_t *)sq->sq_backptr;
24337c478bd9Sstevel@tonic-gate 	mutex_enter(&sqh->sqb_lock);
24347c478bd9Sstevel@tonic-gate 	if (sqh->sqb_pexited && sqh->sqb_sent == 1) {
24357c478bd9Sstevel@tonic-gate 		mutex_exit(&sqh->sqb_lock);
2436f841f6adSraf 		cv_destroy(&sqh->sqb_cv);
24377c478bd9Sstevel@tonic-gate 		mutex_destroy(&sqh->sqb_lock);
24387c478bd9Sstevel@tonic-gate 		kmem_free(sqh, sqh->sqb_size);
24397c478bd9Sstevel@tonic-gate 	} else {
24407c478bd9Sstevel@tonic-gate 		sqh->sqb_count++;
24417c478bd9Sstevel@tonic-gate 		sqh->sqb_sent--;
24427c478bd9Sstevel@tonic-gate 		sq->sq_next = sqh->sqb_free;
24437c478bd9Sstevel@tonic-gate 		sq->sq_backptr = NULL;
24447c478bd9Sstevel@tonic-gate 		sqh->sqb_free = sq;
2445f841f6adSraf 		cv_signal(&sqh->sqb_cv);
24467c478bd9Sstevel@tonic-gate 		mutex_exit(&sqh->sqb_lock);
24477c478bd9Sstevel@tonic-gate 	}
24487c478bd9Sstevel@tonic-gate }
24497c478bd9Sstevel@tonic-gate 
24507c478bd9Sstevel@tonic-gate /*
24517c478bd9Sstevel@tonic-gate  * Free up the pre-allocated sigqueue headers of sigqueue pool
24527c478bd9Sstevel@tonic-gate  * and signotify pool, if possible.
24537c478bd9Sstevel@tonic-gate  * Called only by the owning process during exec() and exit().
24547c478bd9Sstevel@tonic-gate  */
24557c478bd9Sstevel@tonic-gate void
24567c478bd9Sstevel@tonic-gate sigqfree(proc_t *p)
24577c478bd9Sstevel@tonic-gate {
24587c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
24597c478bd9Sstevel@tonic-gate 
24607c478bd9Sstevel@tonic-gate 	if (p->p_sigqhdr != NULL) {	/* sigqueue pool */
24617c478bd9Sstevel@tonic-gate 		sigqhdrfree(p->p_sigqhdr);
24627c478bd9Sstevel@tonic-gate 		p->p_sigqhdr = NULL;
24637c478bd9Sstevel@tonic-gate 	}
24647c478bd9Sstevel@tonic-gate 	if (p->p_signhdr != NULL) {	/* signotify pool */
24657c478bd9Sstevel@tonic-gate 		sigqhdrfree(p->p_signhdr);
24667c478bd9Sstevel@tonic-gate 		p->p_signhdr = NULL;
24677c478bd9Sstevel@tonic-gate 	}
24687c478bd9Sstevel@tonic-gate }
24697c478bd9Sstevel@tonic-gate 
24707c478bd9Sstevel@tonic-gate /*
24717c478bd9Sstevel@tonic-gate  * Free up the pre-allocated header and sigq pool if possible.
24727c478bd9Sstevel@tonic-gate  */
24737c478bd9Sstevel@tonic-gate void
24747c478bd9Sstevel@tonic-gate sigqhdrfree(sigqhdr_t *sqh)
24757c478bd9Sstevel@tonic-gate {
24767c478bd9Sstevel@tonic-gate 	mutex_enter(&sqh->sqb_lock);
24777c478bd9Sstevel@tonic-gate 	if (sqh->sqb_sent == 0) {
24787c478bd9Sstevel@tonic-gate 		mutex_exit(&sqh->sqb_lock);
2479f841f6adSraf 		cv_destroy(&sqh->sqb_cv);
24807c478bd9Sstevel@tonic-gate 		mutex_destroy(&sqh->sqb_lock);
24817c478bd9Sstevel@tonic-gate 		kmem_free(sqh, sqh->sqb_size);
24827c478bd9Sstevel@tonic-gate 	} else {
24837c478bd9Sstevel@tonic-gate 		sqh->sqb_pexited = 1;
24847c478bd9Sstevel@tonic-gate 		mutex_exit(&sqh->sqb_lock);
24857c478bd9Sstevel@tonic-gate 	}
24867c478bd9Sstevel@tonic-gate }
24877c478bd9Sstevel@tonic-gate 
24887c478bd9Sstevel@tonic-gate /*
24897c478bd9Sstevel@tonic-gate  * Free up a single sigqueue structure.
24907c478bd9Sstevel@tonic-gate  * No other code should free a sigqueue directly.
24917c478bd9Sstevel@tonic-gate  */
24927c478bd9Sstevel@tonic-gate void
24937c478bd9Sstevel@tonic-gate siginfofree(sigqueue_t *sqp)
24947c478bd9Sstevel@tonic-gate {
24957c478bd9Sstevel@tonic-gate 	if (sqp != NULL) {
24967c478bd9Sstevel@tonic-gate 		if (sqp->sq_func != NULL)
24977c478bd9Sstevel@tonic-gate 			(sqp->sq_func)(sqp);
24987c478bd9Sstevel@tonic-gate 		else
24997c478bd9Sstevel@tonic-gate 			kmem_free(sqp, sizeof (sigqueue_t));
25007c478bd9Sstevel@tonic-gate 	}
25017c478bd9Sstevel@tonic-gate }
25027c478bd9Sstevel@tonic-gate 
25037c478bd9Sstevel@tonic-gate /*
25047c478bd9Sstevel@tonic-gate  * Generate a synchronous signal caused by a hardware
25057c478bd9Sstevel@tonic-gate  * condition encountered by an lwp.  Called from trap().
25067c478bd9Sstevel@tonic-gate  */
25077c478bd9Sstevel@tonic-gate void
25087c478bd9Sstevel@tonic-gate trapsig(k_siginfo_t *ip, int restartable)
25097c478bd9Sstevel@tonic-gate {
25107c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(curthread);
25117c478bd9Sstevel@tonic-gate 	int sig = ip->si_signo;
25127c478bd9Sstevel@tonic-gate 	sigqueue_t *sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
25137c478bd9Sstevel@tonic-gate 
25147c478bd9Sstevel@tonic-gate 	ASSERT(sig > 0 && sig < NSIG);
25157c478bd9Sstevel@tonic-gate 
25167c478bd9Sstevel@tonic-gate 	if (curthread->t_dtrace_on)
25177c478bd9Sstevel@tonic-gate 		dtrace_safe_synchronous_signal();
25187c478bd9Sstevel@tonic-gate 
25197c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
25207c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(curthread);
25217c478bd9Sstevel@tonic-gate 	/*
25227c478bd9Sstevel@tonic-gate 	 * Avoid a possible infinite loop if the lwp is holding the
25237c478bd9Sstevel@tonic-gate 	 * signal generated by a trap of a restartable instruction or
25247c478bd9Sstevel@tonic-gate 	 * if the signal so generated is being ignored by the process.
25257c478bd9Sstevel@tonic-gate 	 */
25267c478bd9Sstevel@tonic-gate 	if (restartable &&
25277c478bd9Sstevel@tonic-gate 	    (sigismember(&curthread->t_hold, sig) ||
25287c478bd9Sstevel@tonic-gate 	    p->p_user.u_signal[sig-1] == SIG_IGN)) {
25297c478bd9Sstevel@tonic-gate 		sigdelset(&curthread->t_hold, sig);
25307c478bd9Sstevel@tonic-gate 		p->p_user.u_signal[sig-1] = SIG_DFL;
25317c478bd9Sstevel@tonic-gate 		sigdelset(&p->p_ignore, sig);
25327c478bd9Sstevel@tonic-gate 	}
25337c478bd9Sstevel@tonic-gate 	bcopy(ip, &sqp->sq_info, sizeof (k_siginfo_t));
25347c478bd9Sstevel@tonic-gate 	sigaddqa(p, curthread, sqp);
25357c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
25367c478bd9Sstevel@tonic-gate }
25377c478bd9Sstevel@tonic-gate 
2538e0cf54a5SRoger A. Faulkner /*
25397be238fcSRoger A. Faulkner  * Dispatch the real time profiling signal in the traditional way,
25407be238fcSRoger A. Faulkner  * honoring all of the /proc tracing mechanism built into issig().
25417be238fcSRoger A. Faulkner  */
25427be238fcSRoger A. Faulkner static void
25437be238fcSRoger A. Faulkner realsigprof_slow(int sysnum, int nsysarg, int error)
25447be238fcSRoger A. Faulkner {
25457be238fcSRoger A. Faulkner 	kthread_t *t = curthread;
25467be238fcSRoger A. Faulkner 	proc_t *p = ttoproc(t);
25477be238fcSRoger A. Faulkner 	klwp_t *lwp = ttolwp(t);
25487be238fcSRoger A. Faulkner 	k_siginfo_t *sip = &lwp->lwp_siginfo;
25497be238fcSRoger A. Faulkner 	void (*func)();
25507be238fcSRoger A. Faulkner 
25517be238fcSRoger A. Faulkner 	mutex_enter(&p->p_lock);
25527be238fcSRoger A. Faulkner 	func = PTOU(p)->u_signal[SIGPROF - 1];
25537be238fcSRoger A. Faulkner 	if (p->p_rprof_cyclic == CYCLIC_NONE ||
25547be238fcSRoger A. Faulkner 	    func == SIG_DFL || func == SIG_IGN) {
25557be238fcSRoger A. Faulkner 		bzero(t->t_rprof, sizeof (*t->t_rprof));
25567be238fcSRoger A. Faulkner 		mutex_exit(&p->p_lock);
25577be238fcSRoger A. Faulkner 		return;
25587be238fcSRoger A. Faulkner 	}
25597be238fcSRoger A. Faulkner 	if (sigismember(&t->t_hold, SIGPROF)) {
25607be238fcSRoger A. Faulkner 		mutex_exit(&p->p_lock);
25617be238fcSRoger A. Faulkner 		return;
25627be238fcSRoger A. Faulkner 	}
25637be238fcSRoger A. Faulkner 	sip->si_signo = SIGPROF;
25647be238fcSRoger A. Faulkner 	sip->si_code = PROF_SIG;
25657be238fcSRoger A. Faulkner 	sip->si_errno = error;
25667be238fcSRoger A. Faulkner 	hrt2ts(gethrtime(), &sip->si_tstamp);
25677be238fcSRoger A. Faulkner 	sip->si_syscall = sysnum;
25687be238fcSRoger A. Faulkner 	sip->si_nsysarg = nsysarg;
25697be238fcSRoger A. Faulkner 	sip->si_fault = lwp->lwp_lastfault;
25707be238fcSRoger A. Faulkner 	sip->si_faddr = lwp->lwp_lastfaddr;
25717be238fcSRoger A. Faulkner 	lwp->lwp_lastfault = 0;
25727be238fcSRoger A. Faulkner 	lwp->lwp_lastfaddr = NULL;
25737be238fcSRoger A. Faulkner 	sigtoproc(p, t, SIGPROF);
25747be238fcSRoger A. Faulkner 	mutex_exit(&p->p_lock);
25757be238fcSRoger A. Faulkner 	ASSERT(lwp->lwp_cursig == 0);
25767be238fcSRoger A. Faulkner 	if (issig(FORREAL))
25777be238fcSRoger A. Faulkner 		psig();
25787be238fcSRoger A. Faulkner 	sip->si_signo = 0;
25797be238fcSRoger A. Faulkner 	bzero(t->t_rprof, sizeof (*t->t_rprof));
25807be238fcSRoger A. Faulkner }
25817be238fcSRoger A. Faulkner 
25827be238fcSRoger A. Faulkner /*
25837be238fcSRoger A. Faulkner  * We are not tracing the SIGPROF signal, or doing any other unnatural
25847be238fcSRoger A. Faulkner  * acts, like watchpoints, so dispatch the real time profiling signal
25857be238fcSRoger A. Faulkner  * directly, bypassing all of the overhead built into issig().
25867be238fcSRoger A. Faulkner  */
25877be238fcSRoger A. Faulkner static void
25887be238fcSRoger A. Faulkner realsigprof_fast(int sysnum, int nsysarg, int error)
25897be238fcSRoger A. Faulkner {
25907be238fcSRoger A. Faulkner 	kthread_t *t = curthread;
25917be238fcSRoger A. Faulkner 	proc_t *p = ttoproc(t);
25927be238fcSRoger A. Faulkner 	klwp_t *lwp = ttolwp(t);
25937be238fcSRoger A. Faulkner 	k_siginfo_t *sip = &lwp->lwp_siginfo;
25947be238fcSRoger A. Faulkner 	void (*func)();
25957be238fcSRoger A. Faulkner 	int rc;
25967be238fcSRoger A. Faulkner 	int code;
25977be238fcSRoger A. Faulkner 
25987be238fcSRoger A. Faulkner 	/*
25997be238fcSRoger A. Faulkner 	 * We don't need to acquire p->p_lock here;
26007be238fcSRoger A. Faulkner 	 * we are manipulating thread-private data.
26017be238fcSRoger A. Faulkner 	 */
26027be238fcSRoger A. Faulkner 	func = PTOU(p)->u_signal[SIGPROF - 1];
26037be238fcSRoger A. Faulkner 	if (p->p_rprof_cyclic == CYCLIC_NONE ||
26047be238fcSRoger A. Faulkner 	    func == SIG_DFL || func == SIG_IGN) {
26057be238fcSRoger A. Faulkner 		bzero(t->t_rprof, sizeof (*t->t_rprof));
26067be238fcSRoger A. Faulkner 		return;
26077be238fcSRoger A. Faulkner 	}
26087be238fcSRoger A. Faulkner 	if (lwp->lwp_cursig != 0 ||
26097be238fcSRoger A. Faulkner 	    lwp->lwp_curinfo != NULL ||
26107be238fcSRoger A. Faulkner 	    sigismember(&t->t_hold, SIGPROF)) {
26117be238fcSRoger A. Faulkner 		return;
26127be238fcSRoger A. Faulkner 	}
26137be238fcSRoger A. Faulkner 	sip->si_signo = SIGPROF;
26147be238fcSRoger A. Faulkner 	sip->si_code = PROF_SIG;
26157be238fcSRoger A. Faulkner 	sip->si_errno = error;
26167be238fcSRoger A. Faulkner 	hrt2ts(gethrtime(), &sip->si_tstamp);
26177be238fcSRoger A. Faulkner 	sip->si_syscall = sysnum;
26187be238fcSRoger A. Faulkner 	sip->si_nsysarg = nsysarg;
26197be238fcSRoger A. Faulkner 	sip->si_fault = lwp->lwp_lastfault;
26207be238fcSRoger A. Faulkner 	sip->si_faddr = lwp->lwp_lastfaddr;
26217be238fcSRoger A. Faulkner 	lwp->lwp_lastfault = 0;
26227be238fcSRoger A. Faulkner 	lwp->lwp_lastfaddr = NULL;
26237be238fcSRoger A. Faulkner 	if (t->t_flag & T_TOMASK)
26247be238fcSRoger A. Faulkner 		t->t_flag &= ~T_TOMASK;
26257be238fcSRoger A. Faulkner 	else
26267be238fcSRoger A. Faulkner 		lwp->lwp_sigoldmask = t->t_hold;
26277be238fcSRoger A. Faulkner 	sigorset(&t->t_hold, &PTOU(p)->u_sigmask[SIGPROF - 1]);
26287be238fcSRoger A. Faulkner 	if (!sigismember(&PTOU(p)->u_signodefer, SIGPROF))
26297be238fcSRoger A. Faulkner 		sigaddset(&t->t_hold, SIGPROF);
26307be238fcSRoger A. Faulkner 	lwp->lwp_extsig = 0;
26317be238fcSRoger A. Faulkner 	lwp->lwp_ru.nsignals++;
26327be238fcSRoger A. Faulkner 	if (p->p_model == DATAMODEL_NATIVE)
26337be238fcSRoger A. Faulkner 		rc = sendsig(SIGPROF, sip, func);
26347be238fcSRoger A. Faulkner #ifdef _SYSCALL32_IMPL
26357be238fcSRoger A. Faulkner 	else
26367be238fcSRoger A. Faulkner 		rc = sendsig32(SIGPROF, sip, func);
26377be238fcSRoger A. Faulkner #endif	/* _SYSCALL32_IMPL */
26387be238fcSRoger A. Faulkner 	sip->si_signo = 0;
26397be238fcSRoger A. Faulkner 	bzero(t->t_rprof, sizeof (*t->t_rprof));
26407be238fcSRoger A. Faulkner 	if (rc == 0) {
26417be238fcSRoger A. Faulkner 		/*
26427be238fcSRoger A. Faulkner 		 * sendsig() failed; we must dump core with a SIGSEGV.
26437be238fcSRoger A. Faulkner 		 * See psig().  This code is copied from there.
26447be238fcSRoger A. Faulkner 		 */
26457be238fcSRoger A. Faulkner 		lwp->lwp_cursig = SIGSEGV;
26467be238fcSRoger A. Faulkner 		code = CLD_KILLED;
26477be238fcSRoger A. Faulkner 		proc_is_exiting(p);
26487be238fcSRoger A. Faulkner 		if (exitlwps(1) != 0) {
26497be238fcSRoger A. Faulkner 			mutex_enter(&p->p_lock);
26507be238fcSRoger A. Faulkner 			lwp_exit();
26517be238fcSRoger A. Faulkner 		}
26527be238fcSRoger A. Faulkner 		if (audit_active)
26537be238fcSRoger A. Faulkner 			audit_core_start(SIGSEGV);
26547be238fcSRoger A. Faulkner 		if (core(SIGSEGV, 0) == 0)
26557be238fcSRoger A. Faulkner 			code = CLD_DUMPED;
26567be238fcSRoger A. Faulkner 		if (audit_active)
26577be238fcSRoger A. Faulkner 			audit_core_finish(code);
26587be238fcSRoger A. Faulkner 		exit(code, SIGSEGV);
26597be238fcSRoger A. Faulkner 	}
26607be238fcSRoger A. Faulkner }
26617be238fcSRoger A. Faulkner 
26627be238fcSRoger A. Faulkner /*
2663e0cf54a5SRoger A. Faulkner  * Arrange for the real time profiling signal to be dispatched.
2664e0cf54a5SRoger A. Faulkner  */
2665e0cf54a5SRoger A. Faulkner void
2666e0cf54a5SRoger A. Faulkner realsigprof(int sysnum, int nsysarg, int error)
2667e0cf54a5SRoger A. Faulkner {
26687be238fcSRoger A. Faulkner 	kthread_t *t = curthread;
26697be238fcSRoger A. Faulkner 	proc_t *p = ttoproc(t);
2670e0cf54a5SRoger A. Faulkner 
26717be238fcSRoger A. Faulkner 	if (t->t_rprof->rp_anystate == 0)
2672e0cf54a5SRoger A. Faulkner 		return;
26737be238fcSRoger A. Faulkner 
26747be238fcSRoger A. Faulkner 	schedctl_finish_sigblock(t);
26757be238fcSRoger A. Faulkner 
26767be238fcSRoger A. Faulkner 	/* test for any activity that requires p->p_lock */
26777be238fcSRoger A. Faulkner 	if (tracing(p, SIGPROF) || pr_watch_active(p) ||
26787be238fcSRoger A. Faulkner 	    sigismember(&PTOU(p)->u_sigresethand, SIGPROF)) {
26797be238fcSRoger A. Faulkner 		/* do it the classic slow way */
26807be238fcSRoger A. Faulkner 		realsigprof_slow(sysnum, nsysarg, error);
26817be238fcSRoger A. Faulkner 	} else {
26827be238fcSRoger A. Faulkner 		/* do it the cheating-a-little fast way */
26837be238fcSRoger A. Faulkner 		realsigprof_fast(sysnum, nsysarg, error);
2684e0cf54a5SRoger A. Faulkner 	}
2685e0cf54a5SRoger A. Faulkner }
2686e0cf54a5SRoger A. Faulkner 
26877c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
26887c478bd9Sstevel@tonic-gate 
26897c478bd9Sstevel@tonic-gate /*
26907c478bd9Sstevel@tonic-gate  * It's tricky to transmit a sigval between 32-bit and 64-bit
26917c478bd9Sstevel@tonic-gate  * process, since in the 64-bit world, a pointer and an integer
26927c478bd9Sstevel@tonic-gate  * are different sizes.  Since we're constrained by the standards
26937c478bd9Sstevel@tonic-gate  * world not to change the types, and it's unclear how useful it is
26947c478bd9Sstevel@tonic-gate  * to send pointers between address spaces this way, we preserve
26957c478bd9Sstevel@tonic-gate  * the 'int' interpretation for 32-bit processes interoperating
26967c478bd9Sstevel@tonic-gate  * with 64-bit processes.  The full semantics (pointers or integers)
26977c478bd9Sstevel@tonic-gate  * are available for N-bit processes interoperating with N-bit
26987c478bd9Sstevel@tonic-gate  * processes.
26997c478bd9Sstevel@tonic-gate  */
27007c478bd9Sstevel@tonic-gate void
27017c478bd9Sstevel@tonic-gate siginfo_kto32(const k_siginfo_t *src, siginfo32_t *dest)
27027c478bd9Sstevel@tonic-gate {
27037c478bd9Sstevel@tonic-gate 	bzero(dest, sizeof (*dest));
27047c478bd9Sstevel@tonic-gate 
27057c478bd9Sstevel@tonic-gate 	/*
27067c478bd9Sstevel@tonic-gate 	 * The absolute minimum content is si_signo and si_code.
27077c478bd9Sstevel@tonic-gate 	 */
27087c478bd9Sstevel@tonic-gate 	dest->si_signo = src->si_signo;
27097c478bd9Sstevel@tonic-gate 	if ((dest->si_code = src->si_code) == SI_NOINFO)
27107c478bd9Sstevel@tonic-gate 		return;
27117c478bd9Sstevel@tonic-gate 
27127c478bd9Sstevel@tonic-gate 	/*
27137c478bd9Sstevel@tonic-gate 	 * A siginfo generated by user level is structured
27147c478bd9Sstevel@tonic-gate 	 * differently from one generated by the kernel.
27157c478bd9Sstevel@tonic-gate 	 */
27167c478bd9Sstevel@tonic-gate 	if (SI_FROMUSER(src)) {
27177c478bd9Sstevel@tonic-gate 		dest->si_pid = src->si_pid;
27187c478bd9Sstevel@tonic-gate 		dest->si_ctid = src->si_ctid;
27197c478bd9Sstevel@tonic-gate 		dest->si_zoneid = src->si_zoneid;
27207c478bd9Sstevel@tonic-gate 		dest->si_uid = src->si_uid;
27217c478bd9Sstevel@tonic-gate 		if (SI_CANQUEUE(src->si_code))
27227c478bd9Sstevel@tonic-gate 			dest->si_value.sival_int =
27237c478bd9Sstevel@tonic-gate 			    (int32_t)src->si_value.sival_int;
27247c478bd9Sstevel@tonic-gate 		return;
27257c478bd9Sstevel@tonic-gate 	}
27267c478bd9Sstevel@tonic-gate 
27277c478bd9Sstevel@tonic-gate 	dest->si_errno = src->si_errno;
27287c478bd9Sstevel@tonic-gate 
27297c478bd9Sstevel@tonic-gate 	switch (src->si_signo) {
27307c478bd9Sstevel@tonic-gate 	default:
27317c478bd9Sstevel@tonic-gate 		dest->si_pid = src->si_pid;
27327c478bd9Sstevel@tonic-gate 		dest->si_ctid = src->si_ctid;
27337c478bd9Sstevel@tonic-gate 		dest->si_zoneid = src->si_zoneid;
27347c478bd9Sstevel@tonic-gate 		dest->si_uid = src->si_uid;
27357c478bd9Sstevel@tonic-gate 		dest->si_value.sival_int = (int32_t)src->si_value.sival_int;
27367c478bd9Sstevel@tonic-gate 		break;
27377c478bd9Sstevel@tonic-gate 	case SIGCLD:
27387c478bd9Sstevel@tonic-gate 		dest->si_pid = src->si_pid;
27397c478bd9Sstevel@tonic-gate 		dest->si_ctid = src->si_ctid;
27407c478bd9Sstevel@tonic-gate 		dest->si_zoneid = src->si_zoneid;
27417c478bd9Sstevel@tonic-gate 		dest->si_status = src->si_status;
27427c478bd9Sstevel@tonic-gate 		dest->si_stime = src->si_stime;
27437c478bd9Sstevel@tonic-gate 		dest->si_utime = src->si_utime;
27447c478bd9Sstevel@tonic-gate 		break;
27457c478bd9Sstevel@tonic-gate 	case SIGSEGV:
27467c478bd9Sstevel@tonic-gate 	case SIGBUS:
27477c478bd9Sstevel@tonic-gate 	case SIGILL:
27487c478bd9Sstevel@tonic-gate 	case SIGTRAP:
27497c478bd9Sstevel@tonic-gate 	case SIGFPE:
27507c478bd9Sstevel@tonic-gate 	case SIGEMT:
27517c478bd9Sstevel@tonic-gate 		dest->si_addr = (caddr32_t)(uintptr_t)src->si_addr;
27527c478bd9Sstevel@tonic-gate 		dest->si_trapno = src->si_trapno;
27537c478bd9Sstevel@tonic-gate 		dest->si_pc = (caddr32_t)(uintptr_t)src->si_pc;
27547c478bd9Sstevel@tonic-gate 		break;
27557c478bd9Sstevel@tonic-gate 	case SIGPOLL:
27567c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
27577c478bd9Sstevel@tonic-gate 		dest->si_fd = src->si_fd;
27587c478bd9Sstevel@tonic-gate 		dest->si_band = src->si_band;
27597c478bd9Sstevel@tonic-gate 		break;
27607c478bd9Sstevel@tonic-gate 	case SIGPROF:
27617c478bd9Sstevel@tonic-gate 		dest->si_faddr = (caddr32_t)(uintptr_t)src->si_faddr;
27627c478bd9Sstevel@tonic-gate 		dest->si_tstamp.tv_sec = src->si_tstamp.tv_sec;
27637c478bd9Sstevel@tonic-gate 		dest->si_tstamp.tv_nsec = src->si_tstamp.tv_nsec;
27647c478bd9Sstevel@tonic-gate 		dest->si_syscall = src->si_syscall;
27657c478bd9Sstevel@tonic-gate 		dest->si_nsysarg = src->si_nsysarg;
27667c478bd9Sstevel@tonic-gate 		dest->si_fault = src->si_fault;
27677c478bd9Sstevel@tonic-gate 		break;
27687c478bd9Sstevel@tonic-gate 	}
27697c478bd9Sstevel@tonic-gate }
27707c478bd9Sstevel@tonic-gate 
27717c478bd9Sstevel@tonic-gate void
27727c478bd9Sstevel@tonic-gate siginfo_32tok(const siginfo32_t *src, k_siginfo_t *dest)
27737c478bd9Sstevel@tonic-gate {
27747c478bd9Sstevel@tonic-gate 	bzero(dest, sizeof (*dest));
27757c478bd9Sstevel@tonic-gate 
27767c478bd9Sstevel@tonic-gate 	/*
27777c478bd9Sstevel@tonic-gate 	 * The absolute minimum content is si_signo and si_code.
27787c478bd9Sstevel@tonic-gate 	 */
27797c478bd9Sstevel@tonic-gate 	dest->si_signo = src->si_signo;
27807c478bd9Sstevel@tonic-gate 	if ((dest->si_code = src->si_code) == SI_NOINFO)
27817c478bd9Sstevel@tonic-gate 		return;
27827c478bd9Sstevel@tonic-gate 
27837c478bd9Sstevel@tonic-gate 	/*
27847c478bd9Sstevel@tonic-gate 	 * A siginfo generated by user level is structured
27857c478bd9Sstevel@tonic-gate 	 * differently from one generated by the kernel.
27867c478bd9Sstevel@tonic-gate 	 */
27877c478bd9Sstevel@tonic-gate 	if (SI_FROMUSER(src)) {
27887c478bd9Sstevel@tonic-gate 		dest->si_pid = src->si_pid;
27897c478bd9Sstevel@tonic-gate 		dest->si_ctid = src->si_ctid;
27907c478bd9Sstevel@tonic-gate 		dest->si_zoneid = src->si_zoneid;
27917c478bd9Sstevel@tonic-gate 		dest->si_uid = src->si_uid;
27927c478bd9Sstevel@tonic-gate 		if (SI_CANQUEUE(src->si_code))
27937c478bd9Sstevel@tonic-gate 			dest->si_value.sival_int =
27947c478bd9Sstevel@tonic-gate 			    (int)src->si_value.sival_int;
27957c478bd9Sstevel@tonic-gate 		return;
27967c478bd9Sstevel@tonic-gate 	}
27977c478bd9Sstevel@tonic-gate 
27987c478bd9Sstevel@tonic-gate 	dest->si_errno = src->si_errno;
27997c478bd9Sstevel@tonic-gate 
28007c478bd9Sstevel@tonic-gate 	switch (src->si_signo) {
28017c478bd9Sstevel@tonic-gate 	default:
28027c478bd9Sstevel@tonic-gate 		dest->si_pid = src->si_pid;
28037c478bd9Sstevel@tonic-gate 		dest->si_ctid = src->si_ctid;
28047c478bd9Sstevel@tonic-gate 		dest->si_zoneid = src->si_zoneid;
28057c478bd9Sstevel@tonic-gate 		dest->si_uid = src->si_uid;
28067c478bd9Sstevel@tonic-gate 		dest->si_value.sival_int = (int)src->si_value.sival_int;
28077c478bd9Sstevel@tonic-gate 		break;
28087c478bd9Sstevel@tonic-gate 	case SIGCLD:
28097c478bd9Sstevel@tonic-gate 		dest->si_pid = src->si_pid;
28107c478bd9Sstevel@tonic-gate 		dest->si_ctid = src->si_ctid;
28117c478bd9Sstevel@tonic-gate 		dest->si_zoneid = src->si_zoneid;
28127c478bd9Sstevel@tonic-gate 		dest->si_status = src->si_status;
28137c478bd9Sstevel@tonic-gate 		dest->si_stime = src->si_stime;
28147c478bd9Sstevel@tonic-gate 		dest->si_utime = src->si_utime;
28157c478bd9Sstevel@tonic-gate 		break;
28167c478bd9Sstevel@tonic-gate 	case SIGSEGV:
28177c478bd9Sstevel@tonic-gate 	case SIGBUS:
28187c478bd9Sstevel@tonic-gate 	case SIGILL:
28197c478bd9Sstevel@tonic-gate 	case SIGTRAP:
28207c478bd9Sstevel@tonic-gate 	case SIGFPE:
28217c478bd9Sstevel@tonic-gate 	case SIGEMT:
28227c478bd9Sstevel@tonic-gate 		dest->si_addr = (void *)(uintptr_t)src->si_addr;
28237c478bd9Sstevel@tonic-gate 		dest->si_trapno = src->si_trapno;
28247c478bd9Sstevel@tonic-gate 		dest->si_pc = (void *)(uintptr_t)src->si_pc;
28257c478bd9Sstevel@tonic-gate 		break;
28267c478bd9Sstevel@tonic-gate 	case SIGPOLL:
28277c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
28287c478bd9Sstevel@tonic-gate 		dest->si_fd = src->si_fd;
28297c478bd9Sstevel@tonic-gate 		dest->si_band = src->si_band;
28307c478bd9Sstevel@tonic-gate 		break;
28317c478bd9Sstevel@tonic-gate 	case SIGPROF:
28327c478bd9Sstevel@tonic-gate 		dest->si_faddr = (void *)(uintptr_t)src->si_faddr;
28337c478bd9Sstevel@tonic-gate 		dest->si_tstamp.tv_sec = src->si_tstamp.tv_sec;
28347c478bd9Sstevel@tonic-gate 		dest->si_tstamp.tv_nsec = src->si_tstamp.tv_nsec;
28357c478bd9Sstevel@tonic-gate 		dest->si_syscall = src->si_syscall;
28367c478bd9Sstevel@tonic-gate 		dest->si_nsysarg = src->si_nsysarg;
28377c478bd9Sstevel@tonic-gate 		dest->si_fault = src->si_fault;
28387c478bd9Sstevel@tonic-gate 		break;
28397c478bd9Sstevel@tonic-gate 	}
28407c478bd9Sstevel@tonic-gate }
28417c478bd9Sstevel@tonic-gate 
28427c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */
2843