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
534709573Sraf  * Common Development and Distribution License (the "License").
634709573Sraf  * 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  */
210293487cSraf 
227c478bd9Sstevel@tonic-gate /*
23*3de0cfbbSRoger A. Faulkner  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate #include "lint.h"
287257d1b4Sraf #include <sys/feature_tests.h>
297257d1b4Sraf /*
307257d1b4Sraf  * setcontext() really can return, if UC_CPU is not specified.
317257d1b4Sraf  * Make the compiler shut up about it.
327257d1b4Sraf  */
337257d1b4Sraf #if defined(__NORETURN)
347257d1b4Sraf #undef	__NORETURN
357257d1b4Sraf #endif
367257d1b4Sraf #define	__NORETURN
377c478bd9Sstevel@tonic-gate #include "thr_uberdata.h"
38f841f6adSraf #include "asyncio.h"
397c478bd9Sstevel@tonic-gate #include <signal.h>
407c478bd9Sstevel@tonic-gate #include <siginfo.h>
417c478bd9Sstevel@tonic-gate #include <sys/systm.h>
427c478bd9Sstevel@tonic-gate 
437c478bd9Sstevel@tonic-gate const sigset_t maskset = {MASKSET0, MASKSET1, 0, 0};	/* maskable signals */
447c478bd9Sstevel@tonic-gate 
457c478bd9Sstevel@tonic-gate /*
467c478bd9Sstevel@tonic-gate  * Return true if the valid signal bits in both sets are the same.
477c478bd9Sstevel@tonic-gate  */
487c478bd9Sstevel@tonic-gate int
497c478bd9Sstevel@tonic-gate sigequalset(const sigset_t *s1, const sigset_t *s2)
507c478bd9Sstevel@tonic-gate {
517c478bd9Sstevel@tonic-gate 	/*
527c478bd9Sstevel@tonic-gate 	 * We only test valid signal bits, not rubbish following MAXSIG
537c478bd9Sstevel@tonic-gate 	 * (for speed).  Algorithm:
547c478bd9Sstevel@tonic-gate 	 * if (s1 & fillset) == (s2 & fillset) then (s1 ^ s2) & fillset == 0
557c478bd9Sstevel@tonic-gate 	 */
567c478bd9Sstevel@tonic-gate 	return (!((s1->__sigbits[0] ^ s2->__sigbits[0]) |
577c478bd9Sstevel@tonic-gate 	    ((s1->__sigbits[1] ^ s2->__sigbits[1]) & FILLSET1)));
587c478bd9Sstevel@tonic-gate }
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate /*
617c478bd9Sstevel@tonic-gate  * Common code for calling the user-specified signal handler.
627c478bd9Sstevel@tonic-gate  */
637c478bd9Sstevel@tonic-gate void
647c478bd9Sstevel@tonic-gate call_user_handler(int sig, siginfo_t *sip, ucontext_t *ucp)
657c478bd9Sstevel@tonic-gate {
667c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
677c478bd9Sstevel@tonic-gate 	uberdata_t *udp = self->ul_uberdata;
687c478bd9Sstevel@tonic-gate 	struct sigaction uact;
697c478bd9Sstevel@tonic-gate 	volatile struct sigaction *sap;
707c478bd9Sstevel@tonic-gate 
717c478bd9Sstevel@tonic-gate 	/*
727c478bd9Sstevel@tonic-gate 	 * If we are taking a signal while parked or about to be parked
737c478bd9Sstevel@tonic-gate 	 * on __lwp_park() then remove ourself from the sleep queue so
747c478bd9Sstevel@tonic-gate 	 * that we can grab locks.  The code in mutex_lock_queue() and
757c478bd9Sstevel@tonic-gate 	 * cond_wait_common() will detect this and deal with it when
767c478bd9Sstevel@tonic-gate 	 * __lwp_park() returns.
777c478bd9Sstevel@tonic-gate 	 */
787c478bd9Sstevel@tonic-gate 	unsleep_self();
797c478bd9Sstevel@tonic-gate 	set_parking_flag(self, 0);
807c478bd9Sstevel@tonic-gate 
817c478bd9Sstevel@tonic-gate 	if (__td_event_report(self, TD_CATCHSIG, udp)) {
827c478bd9Sstevel@tonic-gate 		self->ul_td_evbuf.eventnum = TD_CATCHSIG;
837c478bd9Sstevel@tonic-gate 		self->ul_td_evbuf.eventdata = (void *)(intptr_t)sig;
847c478bd9Sstevel@tonic-gate 		tdb_event(TD_CATCHSIG, udp);
857c478bd9Sstevel@tonic-gate 	}
867c478bd9Sstevel@tonic-gate 
877c478bd9Sstevel@tonic-gate 	/*
887c478bd9Sstevel@tonic-gate 	 * Get a self-consistent set of flags, handler, and mask
897c478bd9Sstevel@tonic-gate 	 * while holding the sig's sig_lock for the least possible time.
907c478bd9Sstevel@tonic-gate 	 * We must acquire the sig's sig_lock because some thread running
917c478bd9Sstevel@tonic-gate 	 * in sigaction() might be establishing a new signal handler.
9241efec22Sraf 	 * The code in sigaction() acquires the writer lock; here
9341efec22Sraf 	 * we acquire the readers lock to ehance concurrency in the
9441efec22Sraf 	 * face of heavy signal traffic, such as generated by java.
957c478bd9Sstevel@tonic-gate 	 *
967c478bd9Sstevel@tonic-gate 	 * Locking exceptions:
977c478bd9Sstevel@tonic-gate 	 * No locking for a child of vfork().
987c478bd9Sstevel@tonic-gate 	 * If the signal is SIGPROF with an si_code of PROF_SIG,
997c478bd9Sstevel@tonic-gate 	 * then we assume that this signal was generated by
1007c478bd9Sstevel@tonic-gate 	 * setitimer(ITIMER_REALPROF) set up by the dbx collector.
1017c478bd9Sstevel@tonic-gate 	 * If the signal is SIGEMT with an si_code of EMT_CPCOVF,
1027c478bd9Sstevel@tonic-gate 	 * then we assume that the signal was generated by
1037c478bd9Sstevel@tonic-gate 	 * a hardware performance counter overflow.
1047c478bd9Sstevel@tonic-gate 	 * In these cases, assume that we need no locking.  It is the
1057c478bd9Sstevel@tonic-gate 	 * monitoring program's responsibility to ensure correctness.
1067c478bd9Sstevel@tonic-gate 	 */
1077c478bd9Sstevel@tonic-gate 	sap = &udp->siguaction[sig].sig_uaction;
1087c478bd9Sstevel@tonic-gate 	if (self->ul_vfork ||
1097c478bd9Sstevel@tonic-gate 	    (sip != NULL &&
1107c478bd9Sstevel@tonic-gate 	    ((sig == SIGPROF && sip->si_code == PROF_SIG) ||
1117c478bd9Sstevel@tonic-gate 	    (sig == SIGEMT && sip->si_code == EMT_CPCOVF)))) {
1127c478bd9Sstevel@tonic-gate 		/* we wish this assignment could be atomic */
1138cd45542Sraf 		(void) memcpy(&uact, (void *)sap, sizeof (uact));
1147c478bd9Sstevel@tonic-gate 	} else {
11541efec22Sraf 		rwlock_t *rwlp = &udp->siguaction[sig].sig_lock;
11641efec22Sraf 		lrw_rdlock(rwlp);
1178cd45542Sraf 		(void) memcpy(&uact, (void *)sap, sizeof (uact));
118a574db85Sraf 		if ((sig == SIGCANCEL || sig == SIGAIOCANCEL) &&
119a574db85Sraf 		    (sap->sa_flags & SA_RESETHAND))
1207c478bd9Sstevel@tonic-gate 			sap->sa_sigaction = SIG_DFL;
12141efec22Sraf 		lrw_unlock(rwlp);
1227c478bd9Sstevel@tonic-gate 	}
1237c478bd9Sstevel@tonic-gate 
1247c478bd9Sstevel@tonic-gate 	/*
1257c478bd9Sstevel@tonic-gate 	 * Set the proper signal mask and call the user's signal handler.
1267c478bd9Sstevel@tonic-gate 	 * (We overrode the user-requested signal mask with maskset
1277c478bd9Sstevel@tonic-gate 	 * so we currently have all blockable signals blocked.)
1287c478bd9Sstevel@tonic-gate 	 *
1297c478bd9Sstevel@tonic-gate 	 * We would like to ASSERT() that the signal is not a member of the
1307c478bd9Sstevel@tonic-gate 	 * signal mask at the previous level (ucp->uc_sigmask) or the specified
1317c478bd9Sstevel@tonic-gate 	 * signal mask for sigsuspend() or pollsys() (self->ul_tmpmask) but
1327c478bd9Sstevel@tonic-gate 	 * /proc can override this via PCSSIG, so we don't bother.
1337c478bd9Sstevel@tonic-gate 	 *
1347c478bd9Sstevel@tonic-gate 	 * We would also like to ASSERT() that the signal mask at the previous
1357c478bd9Sstevel@tonic-gate 	 * level equals self->ul_sigmask (maskset for sigsuspend() / pollsys()),
1367c478bd9Sstevel@tonic-gate 	 * but /proc can change the thread's signal mask via PCSHOLD, so we
1377c478bd9Sstevel@tonic-gate 	 * don't bother with that either.
1387c478bd9Sstevel@tonic-gate 	 */
1397c478bd9Sstevel@tonic-gate 	ASSERT(ucp->uc_flags & UC_SIGMASK);
1407c478bd9Sstevel@tonic-gate 	if (self->ul_sigsuspend) {
1417c478bd9Sstevel@tonic-gate 		ucp->uc_sigmask = self->ul_sigmask;
1427c478bd9Sstevel@tonic-gate 		self->ul_sigsuspend = 0;
1437c478bd9Sstevel@tonic-gate 		/* the sigsuspend() or pollsys() signal mask */
1447c478bd9Sstevel@tonic-gate 		sigorset(&uact.sa_mask, &self->ul_tmpmask);
1457c478bd9Sstevel@tonic-gate 	} else {
1467c478bd9Sstevel@tonic-gate 		/* the signal mask at the previous level */
1477c478bd9Sstevel@tonic-gate 		sigorset(&uact.sa_mask, &ucp->uc_sigmask);
1487c478bd9Sstevel@tonic-gate 	}
1497c478bd9Sstevel@tonic-gate 	if (!(uact.sa_flags & SA_NODEFER))	/* add current signal */
1508cd45542Sraf 		(void) sigaddset(&uact.sa_mask, sig);
1517c478bd9Sstevel@tonic-gate 	self->ul_sigmask = uact.sa_mask;
1527c478bd9Sstevel@tonic-gate 	self->ul_siglink = ucp;
1537c478bd9Sstevel@tonic-gate 	(void) __lwp_sigmask(SIG_SETMASK, &uact.sa_mask, NULL);
1547c478bd9Sstevel@tonic-gate 
1557c478bd9Sstevel@tonic-gate 	/*
1567c478bd9Sstevel@tonic-gate 	 * If this thread has been sent SIGCANCEL from the kernel
1577c478bd9Sstevel@tonic-gate 	 * or from pthread_cancel(), it is being asked to exit.
1587c478bd9Sstevel@tonic-gate 	 * The kernel may send SIGCANCEL without a siginfo struct.
1597c478bd9Sstevel@tonic-gate 	 * If the SIGCANCEL is process-directed (from kill() or
1607c478bd9Sstevel@tonic-gate 	 * sigqueue()), treat it as an ordinary signal.
1617c478bd9Sstevel@tonic-gate 	 */
1627c478bd9Sstevel@tonic-gate 	if (sig == SIGCANCEL) {
1637c478bd9Sstevel@tonic-gate 		if (sip == NULL || SI_FROMKERNEL(sip) ||
1647c478bd9Sstevel@tonic-gate 		    sip->si_code == SI_LWP) {
1657c478bd9Sstevel@tonic-gate 			do_sigcancel();
1667c478bd9Sstevel@tonic-gate 			goto out;
1677c478bd9Sstevel@tonic-gate 		}
168f841f6adSraf 		/* SIGCANCEL is ignored by default */
169f841f6adSraf 		if (uact.sa_sigaction == SIG_DFL ||
170f841f6adSraf 		    uact.sa_sigaction == SIG_IGN)
171f841f6adSraf 			goto out;
172f841f6adSraf 	}
173f841f6adSraf 
174f841f6adSraf 	/*
175f841f6adSraf 	 * If this thread has been sent SIGAIOCANCEL (SIGLWP) and
176f841f6adSraf 	 * we are an aio worker thread, cancel the aio request.
177f841f6adSraf 	 */
178f841f6adSraf 	if (sig == SIGAIOCANCEL) {
1797257d1b4Sraf 		aio_worker_t *aiowp = pthread_getspecific(_aio_key);
180f841f6adSraf 
181f841f6adSraf 		if (sip != NULL && sip->si_code == SI_LWP && aiowp != NULL)
1827257d1b4Sraf 			siglongjmp(aiowp->work_jmp_buf, 1);
183f841f6adSraf 		/* SIGLWP is ignored by default */
1847c478bd9Sstevel@tonic-gate 		if (uact.sa_sigaction == SIG_DFL ||
1857c478bd9Sstevel@tonic-gate 		    uact.sa_sigaction == SIG_IGN)
1867c478bd9Sstevel@tonic-gate 			goto out;
1877c478bd9Sstevel@tonic-gate 	}
1887c478bd9Sstevel@tonic-gate 
1897c478bd9Sstevel@tonic-gate 	if (!(uact.sa_flags & SA_SIGINFO))
1907c478bd9Sstevel@tonic-gate 		sip = NULL;
1917c478bd9Sstevel@tonic-gate 	__sighndlr(sig, sip, ucp, uact.sa_sigaction);
1927c478bd9Sstevel@tonic-gate 
1937c478bd9Sstevel@tonic-gate #if defined(sparc) || defined(__sparc)
1947c478bd9Sstevel@tonic-gate 	/*
1957c478bd9Sstevel@tonic-gate 	 * If this is a floating point exception and the queue
1967c478bd9Sstevel@tonic-gate 	 * is non-empty, pop the top entry from the queue.  This
1977c478bd9Sstevel@tonic-gate 	 * is to maintain expected behavior.
1987c478bd9Sstevel@tonic-gate 	 */
1997c478bd9Sstevel@tonic-gate 	if (sig == SIGFPE && ucp->uc_mcontext.fpregs.fpu_qcnt) {
2007c478bd9Sstevel@tonic-gate 		fpregset_t *fp = &ucp->uc_mcontext.fpregs;
2017c478bd9Sstevel@tonic-gate 
2027c478bd9Sstevel@tonic-gate 		if (--fp->fpu_qcnt > 0) {
2037c478bd9Sstevel@tonic-gate 			unsigned char i;
2047c478bd9Sstevel@tonic-gate 			struct fq *fqp;
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate 			fqp = fp->fpu_q;
2077c478bd9Sstevel@tonic-gate 			for (i = 0; i < fp->fpu_qcnt; i++)
2087c478bd9Sstevel@tonic-gate 				fqp[i] = fqp[i+1];
2097c478bd9Sstevel@tonic-gate 		}
2107c478bd9Sstevel@tonic-gate 	}
2117c478bd9Sstevel@tonic-gate #endif	/* sparc */
2127c478bd9Sstevel@tonic-gate 
2137c478bd9Sstevel@tonic-gate out:
2147257d1b4Sraf 	(void) setcontext(ucp);
2157257d1b4Sraf 	thr_panic("call_user_handler(): setcontext() returned");
2167c478bd9Sstevel@tonic-gate }
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate /*
2197c478bd9Sstevel@tonic-gate  * take_deferred_signal() is called when ul_critical and ul_sigdefer become
2207c478bd9Sstevel@tonic-gate  * zero and a deferred signal has been recorded on the current thread.
2217c478bd9Sstevel@tonic-gate  * We are out of the critical region and are ready to take a signal.
2227c478bd9Sstevel@tonic-gate  * The kernel has all signals blocked on this lwp, but our value of
2237c478bd9Sstevel@tonic-gate  * ul_sigmask is the correct signal mask for the previous context.
224f48068adSraf  *
225f48068adSraf  * We call __sigresend() to atomically restore the signal mask and
226f48068adSraf  * cause the signal to be sent again with the remembered siginfo.
227f48068adSraf  * We will not return successfully from __sigresend() until the
228f48068adSraf  * application's signal handler has been run via sigacthandler().
2297c478bd9Sstevel@tonic-gate  */
2307c478bd9Sstevel@tonic-gate void
2317c478bd9Sstevel@tonic-gate take_deferred_signal(int sig)
2327c478bd9Sstevel@tonic-gate {
233f48068adSraf 	extern int __sigresend(int, siginfo_t *, sigset_t *);
2347c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
235ba03ff9eSraf 	siguaction_t *suap = &self->ul_uberdata->siguaction[sig];
2367c478bd9Sstevel@tonic-gate 	siginfo_t *sip;
237f48068adSraf 	int error;
2387c478bd9Sstevel@tonic-gate 
239f48068adSraf 	ASSERT((self->ul_critical | self->ul_sigdefer | self->ul_cursig) == 0);
2407c478bd9Sstevel@tonic-gate 
241ba03ff9eSraf 	/*
242ba03ff9eSraf 	 * If the signal handler was established with SA_RESETHAND,
243ba03ff9eSraf 	 * the kernel has reset the handler to SIG_DFL, so we have
244ba03ff9eSraf 	 * to reestablish the handler now so that it will be entered
245ba03ff9eSraf 	 * again when we call __sigresend(), below.
2469ac35488Sraf 	 *
2479ac35488Sraf 	 * Logically, we should acquire and release the signal's
2489ac35488Sraf 	 * sig_lock around this operation to protect the integrity
2499ac35488Sraf 	 * of the signal action while we copy it, as is done below
2509ac35488Sraf 	 * in _libc_sigaction().  However, we may be on a user-level
2519ac35488Sraf 	 * sleep queue at this point and lrw_wrlock(&suap->sig_lock)
2529ac35488Sraf 	 * might attempt to sleep on a different sleep queue and
2539ac35488Sraf 	 * that would corrupt the entire sleep queue mechanism.
2549ac35488Sraf 	 *
2559ac35488Sraf 	 * If we are on a sleep queue we will remove ourself from
2569ac35488Sraf 	 * it in call_user_handler(), called from sigacthandler(),
2579ac35488Sraf 	 * before entering the application's signal handler.
2589ac35488Sraf 	 * In the meantime, we must not acquire any locks.
259ba03ff9eSraf 	 */
260ba03ff9eSraf 	if (suap->sig_uaction.sa_flags & SA_RESETHAND) {
261ba03ff9eSraf 		struct sigaction tact = suap->sig_uaction;
262ba03ff9eSraf 		tact.sa_flags &= ~SA_NODEFER;
263ba03ff9eSraf 		tact.sa_sigaction = self->ul_uberdata->sigacthandler;
264ba03ff9eSraf 		tact.sa_mask = maskset;
265ba03ff9eSraf 		(void) __sigaction(sig, &tact, NULL);
266ba03ff9eSraf 	}
267ba03ff9eSraf 
2687c478bd9Sstevel@tonic-gate 	if (self->ul_siginfo.si_signo == 0)
2697c478bd9Sstevel@tonic-gate 		sip = NULL;
270f48068adSraf 	else
271f48068adSraf 		sip = &self->ul_siginfo;
272f48068adSraf 
273f48068adSraf 	/* EAGAIN can happen only for a pending SIGSTOP signal */
274f48068adSraf 	while ((error = __sigresend(sig, sip, &self->ul_sigmask)) == EAGAIN)
275f48068adSraf 		continue;
276f48068adSraf 	if (error)
277f48068adSraf 		thr_panic("take_deferred_signal(): __sigresend() failed");
2787c478bd9Sstevel@tonic-gate }
2797c478bd9Sstevel@tonic-gate 
2807c478bd9Sstevel@tonic-gate void
2817c478bd9Sstevel@tonic-gate sigacthandler(int sig, siginfo_t *sip, void *uvp)
2827c478bd9Sstevel@tonic-gate {
2837c478bd9Sstevel@tonic-gate 	ucontext_t *ucp = uvp;
2847c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
2857c478bd9Sstevel@tonic-gate 
2867c478bd9Sstevel@tonic-gate 	/*
2877c478bd9Sstevel@tonic-gate 	 * Do this in case we took a signal while in a cancelable system call.
2887c478bd9Sstevel@tonic-gate 	 * It does no harm if we were not in such a system call.
2897c478bd9Sstevel@tonic-gate 	 */
2907c478bd9Sstevel@tonic-gate 	self->ul_sp = 0;
2917c478bd9Sstevel@tonic-gate 	if (sig != SIGCANCEL)
2927c478bd9Sstevel@tonic-gate 		self->ul_cancel_async = self->ul_save_async;
2937c478bd9Sstevel@tonic-gate 
294*3de0cfbbSRoger A. Faulkner 	/*
295*3de0cfbbSRoger A. Faulkner 	 * If this thread has performed a longjmp() from a signal handler
296*3de0cfbbSRoger A. Faulkner 	 * back to main level some time in the past, it has left the kernel
297*3de0cfbbSRoger A. Faulkner 	 * thinking that it is still in the signal context.  We repair this
298*3de0cfbbSRoger A. Faulkner 	 * possible damage by setting ucp->uc_link to NULL if we know that
299*3de0cfbbSRoger A. Faulkner 	 * we are actually executing at main level (self->ul_siglink == NULL).
300*3de0cfbbSRoger A. Faulkner 	 * See the code for setjmp()/longjmp() for more details.
301*3de0cfbbSRoger A. Faulkner 	 */
302*3de0cfbbSRoger A. Faulkner 	if (self->ul_siglink == NULL)
303*3de0cfbbSRoger A. Faulkner 		ucp->uc_link = NULL;
304*3de0cfbbSRoger A. Faulkner 
3057c478bd9Sstevel@tonic-gate 	/*
3067c478bd9Sstevel@tonic-gate 	 * If we are not in a critical region and are
3077c478bd9Sstevel@tonic-gate 	 * not deferring signals, take the signal now.
3087c478bd9Sstevel@tonic-gate 	 */
3097c478bd9Sstevel@tonic-gate 	if ((self->ul_critical + self->ul_sigdefer) == 0) {
3107c478bd9Sstevel@tonic-gate 		call_user_handler(sig, sip, ucp);
311d544002dSrh 		/*
312d544002dSrh 		 * On the surface, the following call seems redundant
313d544002dSrh 		 * because call_user_handler() cannot return. However,
314d544002dSrh 		 * we don't want to return from here because the compiler
315d544002dSrh 		 * might recycle our frame. We want to keep it on the
316d544002dSrh 		 * stack to assist debuggers such as pstack in identifying
317d544002dSrh 		 * signal frames. The call to thr_panic() serves to prevent
318d544002dSrh 		 * tail-call optimisation here.
319d544002dSrh 		 */
320d544002dSrh 		thr_panic("sigacthandler(): call_user_handler() returned");
3217c478bd9Sstevel@tonic-gate 	}
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate 	/*
3247c478bd9Sstevel@tonic-gate 	 * We are in a critical region or we are deferring signals.  When
3257c478bd9Sstevel@tonic-gate 	 * we emerge from the region we will call take_deferred_signal().
3267c478bd9Sstevel@tonic-gate 	 */
3277c478bd9Sstevel@tonic-gate 	ASSERT(self->ul_cursig == 0);
3287c478bd9Sstevel@tonic-gate 	self->ul_cursig = (char)sig;
3297c478bd9Sstevel@tonic-gate 	if (sip != NULL)
3308cd45542Sraf 		(void) memcpy(&self->ul_siginfo,
3310293487cSraf 		    sip, sizeof (siginfo_t));
3327c478bd9Sstevel@tonic-gate 	else
3337c478bd9Sstevel@tonic-gate 		self->ul_siginfo.si_signo = 0;
3347c478bd9Sstevel@tonic-gate 
3357c478bd9Sstevel@tonic-gate 	/*
3367c478bd9Sstevel@tonic-gate 	 * Make sure that if we return to a call to __lwp_park()
3377c478bd9Sstevel@tonic-gate 	 * or ___lwp_cond_wait() that it returns right away
3387c478bd9Sstevel@tonic-gate 	 * (giving us a spurious wakeup but not a deadlock).
3397c478bd9Sstevel@tonic-gate 	 */
3407c478bd9Sstevel@tonic-gate 	set_parking_flag(self, 0);
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 	/*
3437c478bd9Sstevel@tonic-gate 	 * Return to the previous context with all signals blocked.
3447c478bd9Sstevel@tonic-gate 	 * We will restore the signal mask in take_deferred_signal().
3457c478bd9Sstevel@tonic-gate 	 * Note that we are calling the system call trap here, not
3467257d1b4Sraf 	 * the setcontext() wrapper.  We don't want to change the
3477c478bd9Sstevel@tonic-gate 	 * thread's ul_sigmask by this operation.
3487c478bd9Sstevel@tonic-gate 	 */
3497c478bd9Sstevel@tonic-gate 	ucp->uc_sigmask = maskset;
3508cd45542Sraf 	(void) __setcontext(ucp);
3517c478bd9Sstevel@tonic-gate 	thr_panic("sigacthandler(): __setcontext() returned");
3527c478bd9Sstevel@tonic-gate }
3537c478bd9Sstevel@tonic-gate 
3547257d1b4Sraf #pragma weak _sigaction = sigaction
3557c478bd9Sstevel@tonic-gate int
3567257d1b4Sraf sigaction(int sig, const struct sigaction *nact, struct sigaction *oact)
3577c478bd9Sstevel@tonic-gate {
3587c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
3597c478bd9Sstevel@tonic-gate 	uberdata_t *udp = self->ul_uberdata;
3607c478bd9Sstevel@tonic-gate 	struct sigaction oaction;
3617c478bd9Sstevel@tonic-gate 	struct sigaction tact;
3627c478bd9Sstevel@tonic-gate 	struct sigaction *tactp = NULL;
3637c478bd9Sstevel@tonic-gate 	int rv;
3647c478bd9Sstevel@tonic-gate 
3657c478bd9Sstevel@tonic-gate 	if (sig <= 0 || sig >= NSIG) {
3667c478bd9Sstevel@tonic-gate 		errno = EINVAL;
3677c478bd9Sstevel@tonic-gate 		return (-1);
3687c478bd9Sstevel@tonic-gate 	}
3697c478bd9Sstevel@tonic-gate 
3707c478bd9Sstevel@tonic-gate 	if (!self->ul_vfork)
37141efec22Sraf 		lrw_wrlock(&udp->siguaction[sig].sig_lock);
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate 	oaction = udp->siguaction[sig].sig_uaction;
3747c478bd9Sstevel@tonic-gate 
3757c478bd9Sstevel@tonic-gate 	if (nact != NULL) {
3767c478bd9Sstevel@tonic-gate 		tact = *nact;	/* make a copy so we can modify it */
3777c478bd9Sstevel@tonic-gate 		tactp = &tact;
3787c478bd9Sstevel@tonic-gate 		delete_reserved_signals(&tact.sa_mask);
3797c478bd9Sstevel@tonic-gate 
3807c478bd9Sstevel@tonic-gate #if !defined(_LP64)
3817c478bd9Sstevel@tonic-gate 		tact.sa_resv[0] = tact.sa_resv[1] = 0;	/* cleanliness */
3827c478bd9Sstevel@tonic-gate #endif
3837c478bd9Sstevel@tonic-gate 		/*
3847c478bd9Sstevel@tonic-gate 		 * To be compatible with the behavior of SunOS 4.x:
3857c478bd9Sstevel@tonic-gate 		 * If the new signal handler is SIG_IGN or SIG_DFL, do
3867c478bd9Sstevel@tonic-gate 		 * not change the signal's entry in the siguaction array.
3877c478bd9Sstevel@tonic-gate 		 * This allows a child of vfork(2) to set signal handlers
3887c478bd9Sstevel@tonic-gate 		 * to SIG_IGN or SIG_DFL without affecting the parent.
3897c478bd9Sstevel@tonic-gate 		 *
3907c478bd9Sstevel@tonic-gate 		 * This also covers a race condition with some thread
3917c478bd9Sstevel@tonic-gate 		 * setting the signal action to SIG_DFL or SIG_IGN
3927c478bd9Sstevel@tonic-gate 		 * when the thread has also received and deferred
3937c478bd9Sstevel@tonic-gate 		 * that signal.  When the thread takes the deferred
3947c478bd9Sstevel@tonic-gate 		 * signal, even though it has set the action to SIG_DFL
3957c478bd9Sstevel@tonic-gate 		 * or SIG_IGN, it will execute the old signal handler
3967c478bd9Sstevel@tonic-gate 		 * anyway.  This is an inherent signaling race condition
3977c478bd9Sstevel@tonic-gate 		 * and is not a bug.
3987c478bd9Sstevel@tonic-gate 		 *
3997c478bd9Sstevel@tonic-gate 		 * A child of vfork() is not allowed to change signal
4007c478bd9Sstevel@tonic-gate 		 * handlers to anything other than SIG_DFL or SIG_IGN.
4017c478bd9Sstevel@tonic-gate 		 */
4027c478bd9Sstevel@tonic-gate 		if (self->ul_vfork) {
4037c478bd9Sstevel@tonic-gate 			if (tact.sa_sigaction != SIG_IGN)
4047c478bd9Sstevel@tonic-gate 				tact.sa_sigaction = SIG_DFL;
405f841f6adSraf 		} else if (sig == SIGCANCEL || sig == SIGAIOCANCEL) {
4067c478bd9Sstevel@tonic-gate 			/*
407f841f6adSraf 			 * Always catch these signals.
408f841f6adSraf 			 * We need SIGCANCEL for pthread_cancel() to work.
409f841f6adSraf 			 * We need SIGAIOCANCEL for aio_cancel() to work.
4107c478bd9Sstevel@tonic-gate 			 */
4117c478bd9Sstevel@tonic-gate 			udp->siguaction[sig].sig_uaction = tact;
4127c478bd9Sstevel@tonic-gate 			if (tact.sa_sigaction == SIG_DFL ||
4137c478bd9Sstevel@tonic-gate 			    tact.sa_sigaction == SIG_IGN)
4147c478bd9Sstevel@tonic-gate 				tact.sa_flags = SA_SIGINFO;
4157c478bd9Sstevel@tonic-gate 			else {
4167c478bd9Sstevel@tonic-gate 				tact.sa_flags |= SA_SIGINFO;
417a574db85Sraf 				tact.sa_flags &=
418a574db85Sraf 				    ~(SA_NODEFER | SA_RESETHAND | SA_RESTART);
4197c478bd9Sstevel@tonic-gate 			}
4207c478bd9Sstevel@tonic-gate 			tact.sa_sigaction = udp->sigacthandler;
4217c478bd9Sstevel@tonic-gate 			tact.sa_mask = maskset;
4227c478bd9Sstevel@tonic-gate 		} else if (tact.sa_sigaction != SIG_DFL &&
4237c478bd9Sstevel@tonic-gate 		    tact.sa_sigaction != SIG_IGN) {
4247c478bd9Sstevel@tonic-gate 			udp->siguaction[sig].sig_uaction = tact;
4257c478bd9Sstevel@tonic-gate 			tact.sa_flags &= ~SA_NODEFER;
4267c478bd9Sstevel@tonic-gate 			tact.sa_sigaction = udp->sigacthandler;
4277c478bd9Sstevel@tonic-gate 			tact.sa_mask = maskset;
4287c478bd9Sstevel@tonic-gate 		}
4297c478bd9Sstevel@tonic-gate 	}
4307c478bd9Sstevel@tonic-gate 
4317c478bd9Sstevel@tonic-gate 	if ((rv = __sigaction(sig, tactp, oact)) != 0)
4327c478bd9Sstevel@tonic-gate 		udp->siguaction[sig].sig_uaction = oaction;
4337c478bd9Sstevel@tonic-gate 	else if (oact != NULL &&
4347c478bd9Sstevel@tonic-gate 	    oact->sa_sigaction != SIG_DFL &&
4357c478bd9Sstevel@tonic-gate 	    oact->sa_sigaction != SIG_IGN)
4367c478bd9Sstevel@tonic-gate 		*oact = oaction;
4377c478bd9Sstevel@tonic-gate 
438f841f6adSraf 	/*
439f841f6adSraf 	 * We detect setting the disposition of SIGIO just to set the
440f841f6adSraf 	 * _sigio_enabled flag for the asynchronous i/o (aio) code.
441f841f6adSraf 	 */
442f841f6adSraf 	if (sig == SIGIO && rv == 0 && tactp != NULL) {
443f841f6adSraf 		_sigio_enabled =
444f841f6adSraf 		    (tactp->sa_handler != SIG_DFL &&
445f841f6adSraf 		    tactp->sa_handler != SIG_IGN);
446f841f6adSraf 	}
447f841f6adSraf 
4487c478bd9Sstevel@tonic-gate 	if (!self->ul_vfork)
44941efec22Sraf 		lrw_unlock(&udp->siguaction[sig].sig_lock);
4507c478bd9Sstevel@tonic-gate 	return (rv);
4517c478bd9Sstevel@tonic-gate }
4527c478bd9Sstevel@tonic-gate 
4538cd45542Sraf /*
4548cd45542Sraf  * This is a private interface for the linux brand interface.
4558cd45542Sraf  */
4569acbbeafSnn void
4579acbbeafSnn setsigacthandler(void (*nsigacthandler)(int, siginfo_t *, void *),
4589acbbeafSnn     void (**osigacthandler)(int, siginfo_t *, void *))
4599acbbeafSnn {
4609acbbeafSnn 	ulwp_t *self = curthread;
4619acbbeafSnn 	uberdata_t *udp = self->ul_uberdata;
4629acbbeafSnn 
4639acbbeafSnn 	if (osigacthandler != NULL)
4649acbbeafSnn 		*osigacthandler = udp->sigacthandler;
4659acbbeafSnn 
4669acbbeafSnn 	udp->sigacthandler = nsigacthandler;
4679acbbeafSnn }
4689acbbeafSnn 
4697c478bd9Sstevel@tonic-gate /*
4707c478bd9Sstevel@tonic-gate  * Tell the kernel to block all signals.
4717c478bd9Sstevel@tonic-gate  * Use the schedctl interface, or failing that, use __lwp_sigmask().
4727c478bd9Sstevel@tonic-gate  * This action can be rescinded only by making a system call that
4737c478bd9Sstevel@tonic-gate  * sets the signal mask:
4747c478bd9Sstevel@tonic-gate  *	__lwp_sigmask(), __sigprocmask(), __setcontext(),
4757c478bd9Sstevel@tonic-gate  *	__sigsuspend() or __pollsys().
4767c478bd9Sstevel@tonic-gate  * In particular, this action cannot be reversed by assigning
4777c478bd9Sstevel@tonic-gate  * scp->sc_sigblock = 0.  That would be a way to lose signals.
4787c478bd9Sstevel@tonic-gate  * See the definition of restore_signals(self).
4797c478bd9Sstevel@tonic-gate  */
4807c478bd9Sstevel@tonic-gate void
4817c478bd9Sstevel@tonic-gate block_all_signals(ulwp_t *self)
4827c478bd9Sstevel@tonic-gate {
4837c478bd9Sstevel@tonic-gate 	volatile sc_shared_t *scp;
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate 	enter_critical(self);
4867c478bd9Sstevel@tonic-gate 	if ((scp = self->ul_schedctl) != NULL ||
4877c478bd9Sstevel@tonic-gate 	    (scp = setup_schedctl()) != NULL)
4887c478bd9Sstevel@tonic-gate 		scp->sc_sigblock = 1;
4897c478bd9Sstevel@tonic-gate 	else
4907c478bd9Sstevel@tonic-gate 		(void) __lwp_sigmask(SIG_SETMASK, &maskset, NULL);
4917c478bd9Sstevel@tonic-gate 	exit_critical(self);
4927c478bd9Sstevel@tonic-gate }
4937c478bd9Sstevel@tonic-gate 
4949acbbeafSnn /*
4958cd45542Sraf  * setcontext() has code that forcibly restores the curthread
4969acbbeafSnn  * pointer in a context passed to the setcontext(2) syscall.
4979acbbeafSnn  *
4989acbbeafSnn  * Certain processes may need to disable this feature, so these routines
4999acbbeafSnn  * provide the mechanism to do so.
5009acbbeafSnn  *
5019acbbeafSnn  * (As an example, branded 32-bit x86 processes may use %gs for their own
5029acbbeafSnn  * purposes, so they need to be able to specify a %gs value to be restored
5039acbbeafSnn  * on return from a signal handler via the passed ucontext_t.)
5049acbbeafSnn  */
5059acbbeafSnn static int setcontext_enforcement = 1;
5069acbbeafSnn 
5079acbbeafSnn void
5089acbbeafSnn set_setcontext_enforcement(int on)
5099acbbeafSnn {
5109acbbeafSnn 	setcontext_enforcement = on;
5119acbbeafSnn }
5129acbbeafSnn 
5137257d1b4Sraf #pragma weak _setcontext = setcontext
5147c478bd9Sstevel@tonic-gate int
5157257d1b4Sraf setcontext(const ucontext_t *ucp)
5167c478bd9Sstevel@tonic-gate {
5177c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
5187c478bd9Sstevel@tonic-gate 	int ret;
5197c478bd9Sstevel@tonic-gate 	ucontext_t uc;
5207c478bd9Sstevel@tonic-gate 
5217c478bd9Sstevel@tonic-gate 	/*
5227c478bd9Sstevel@tonic-gate 	 * Returning from the main context (uc_link == NULL) causes
5237c478bd9Sstevel@tonic-gate 	 * the thread to exit.  See setcontext(2) and makecontext(3C).
5247c478bd9Sstevel@tonic-gate 	 */
5257c478bd9Sstevel@tonic-gate 	if (ucp == NULL)
5267257d1b4Sraf 		thr_exit(NULL);
5278cd45542Sraf 	(void) memcpy(&uc, ucp, sizeof (uc));
5287c478bd9Sstevel@tonic-gate 
5297c478bd9Sstevel@tonic-gate 	/*
5307c478bd9Sstevel@tonic-gate 	 * Restore previous signal mask and context link.
5317c478bd9Sstevel@tonic-gate 	 */
5327c478bd9Sstevel@tonic-gate 	if (uc.uc_flags & UC_SIGMASK) {
5337c478bd9Sstevel@tonic-gate 		block_all_signals(self);
5347c478bd9Sstevel@tonic-gate 		delete_reserved_signals(&uc.uc_sigmask);
5357c478bd9Sstevel@tonic-gate 		self->ul_sigmask = uc.uc_sigmask;
5367c478bd9Sstevel@tonic-gate 		if (self->ul_cursig) {
5377c478bd9Sstevel@tonic-gate 			/*
5387c478bd9Sstevel@tonic-gate 			 * We have a deferred signal present.
5397c478bd9Sstevel@tonic-gate 			 * The signal mask will be set when the
5407c478bd9Sstevel@tonic-gate 			 * signal is taken in take_deferred_signal().
5417c478bd9Sstevel@tonic-gate 			 */
5427c478bd9Sstevel@tonic-gate 			ASSERT(self->ul_critical + self->ul_sigdefer != 0);
5437c478bd9Sstevel@tonic-gate 			uc.uc_flags &= ~UC_SIGMASK;
5447c478bd9Sstevel@tonic-gate 		}
5457c478bd9Sstevel@tonic-gate 	}
5467c478bd9Sstevel@tonic-gate 	self->ul_siglink = uc.uc_link;
5477c478bd9Sstevel@tonic-gate 
5487c478bd9Sstevel@tonic-gate 	/*
5497c478bd9Sstevel@tonic-gate 	 * We don't know where this context structure has been.
5507c478bd9Sstevel@tonic-gate 	 * Preserve the curthread pointer, at least.
5519acbbeafSnn 	 *
5529acbbeafSnn 	 * Allow this feature to be disabled if a particular process
5539acbbeafSnn 	 * requests it.
5547c478bd9Sstevel@tonic-gate 	 */
5559acbbeafSnn 	if (setcontext_enforcement) {
5567c478bd9Sstevel@tonic-gate #if defined(__sparc)
5579acbbeafSnn 		uc.uc_mcontext.gregs[REG_G7] = (greg_t)self;
5587c478bd9Sstevel@tonic-gate #elif defined(__amd64)
559ae115bc7Smrj 		uc.uc_mcontext.gregs[REG_FS] = (greg_t)0; /* null for fsbase */
5607c478bd9Sstevel@tonic-gate #elif defined(__i386)
561ae115bc7Smrj 		uc.uc_mcontext.gregs[GS] = (greg_t)LWPGS_SEL;
5627c478bd9Sstevel@tonic-gate #else
5637c478bd9Sstevel@tonic-gate #error "none of __sparc, __amd64, __i386 defined"
5647c478bd9Sstevel@tonic-gate #endif
5659acbbeafSnn 	}
5669acbbeafSnn 
5677c478bd9Sstevel@tonic-gate 	/*
5687c478bd9Sstevel@tonic-gate 	 * Make sure that if we return to a call to __lwp_park()
5697c478bd9Sstevel@tonic-gate 	 * or ___lwp_cond_wait() that it returns right away
5707c478bd9Sstevel@tonic-gate 	 * (giving us a spurious wakeup but not a deadlock).
5717c478bd9Sstevel@tonic-gate 	 */
5727c478bd9Sstevel@tonic-gate 	set_parking_flag(self, 0);
5737c478bd9Sstevel@tonic-gate 	self->ul_sp = 0;
5748cd45542Sraf 	ret = __setcontext(&uc);
5757c478bd9Sstevel@tonic-gate 
5767c478bd9Sstevel@tonic-gate 	/*
5777c478bd9Sstevel@tonic-gate 	 * It is OK for setcontext() to return if the user has not specified
5787c478bd9Sstevel@tonic-gate 	 * UC_CPU.
5797c478bd9Sstevel@tonic-gate 	 */
5807c478bd9Sstevel@tonic-gate 	if (uc.uc_flags & UC_CPU)
5817c478bd9Sstevel@tonic-gate 		thr_panic("setcontext(): __setcontext() returned");
5827c478bd9Sstevel@tonic-gate 	return (ret);
5837c478bd9Sstevel@tonic-gate }
5847c478bd9Sstevel@tonic-gate 
5857257d1b4Sraf #pragma weak _thr_sigsetmask = thr_sigsetmask
5867c478bd9Sstevel@tonic-gate int
5877257d1b4Sraf thr_sigsetmask(int how, const sigset_t *set, sigset_t *oset)
5887c478bd9Sstevel@tonic-gate {
5897c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
5907c478bd9Sstevel@tonic-gate 	sigset_t saveset;
5917c478bd9Sstevel@tonic-gate 
5927c478bd9Sstevel@tonic-gate 	if (set == NULL) {
5937c478bd9Sstevel@tonic-gate 		enter_critical(self);
5947c478bd9Sstevel@tonic-gate 		if (oset != NULL)
5957c478bd9Sstevel@tonic-gate 			*oset = self->ul_sigmask;
5967c478bd9Sstevel@tonic-gate 		exit_critical(self);
5977c478bd9Sstevel@tonic-gate 	} else {
5987c478bd9Sstevel@tonic-gate 		switch (how) {
5997c478bd9Sstevel@tonic-gate 		case SIG_BLOCK:
6007c478bd9Sstevel@tonic-gate 		case SIG_UNBLOCK:
6017c478bd9Sstevel@tonic-gate 		case SIG_SETMASK:
6027c478bd9Sstevel@tonic-gate 			break;
6037c478bd9Sstevel@tonic-gate 		default:
6047c478bd9Sstevel@tonic-gate 			return (EINVAL);
6057c478bd9Sstevel@tonic-gate 		}
6067c478bd9Sstevel@tonic-gate 
6077c478bd9Sstevel@tonic-gate 		/*
6087c478bd9Sstevel@tonic-gate 		 * The assignments to self->ul_sigmask must be protected from
6097c478bd9Sstevel@tonic-gate 		 * signals.  The nuances of this code are subtle.  Be careful.
6107c478bd9Sstevel@tonic-gate 		 */
6117c478bd9Sstevel@tonic-gate 		block_all_signals(self);
6127c478bd9Sstevel@tonic-gate 		if (oset != NULL)
6137c478bd9Sstevel@tonic-gate 			saveset = self->ul_sigmask;
6147c478bd9Sstevel@tonic-gate 		switch (how) {
6157c478bd9Sstevel@tonic-gate 		case SIG_BLOCK:
6167c478bd9Sstevel@tonic-gate 			self->ul_sigmask.__sigbits[0] |= set->__sigbits[0];
6177c478bd9Sstevel@tonic-gate 			self->ul_sigmask.__sigbits[1] |= set->__sigbits[1];
6187c478bd9Sstevel@tonic-gate 			break;
6197c478bd9Sstevel@tonic-gate 		case SIG_UNBLOCK:
6207c478bd9Sstevel@tonic-gate 			self->ul_sigmask.__sigbits[0] &= ~set->__sigbits[0];
6217c478bd9Sstevel@tonic-gate 			self->ul_sigmask.__sigbits[1] &= ~set->__sigbits[1];
6227c478bd9Sstevel@tonic-gate 			break;
6237c478bd9Sstevel@tonic-gate 		case SIG_SETMASK:
6247c478bd9Sstevel@tonic-gate 			self->ul_sigmask.__sigbits[0] = set->__sigbits[0];
6257c478bd9Sstevel@tonic-gate 			self->ul_sigmask.__sigbits[1] = set->__sigbits[1];
6267c478bd9Sstevel@tonic-gate 			break;
6277c478bd9Sstevel@tonic-gate 		}
6287c478bd9Sstevel@tonic-gate 		delete_reserved_signals(&self->ul_sigmask);
6297c478bd9Sstevel@tonic-gate 		if (oset != NULL)
6307c478bd9Sstevel@tonic-gate 			*oset = saveset;
6317c478bd9Sstevel@tonic-gate 		restore_signals(self);
6327c478bd9Sstevel@tonic-gate 	}
6337c478bd9Sstevel@tonic-gate 
6347c478bd9Sstevel@tonic-gate 	return (0);
6357c478bd9Sstevel@tonic-gate }
6367c478bd9Sstevel@tonic-gate 
6377257d1b4Sraf #pragma weak _pthread_sigmask = pthread_sigmask
6387257d1b4Sraf int
6397257d1b4Sraf pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
6407257d1b4Sraf {
6417257d1b4Sraf 	return (thr_sigsetmask(how, set, oset));
6427257d1b4Sraf }
6437257d1b4Sraf 
6447257d1b4Sraf #pragma weak _sigprocmask = sigprocmask
6457c478bd9Sstevel@tonic-gate int
6467257d1b4Sraf sigprocmask(int how, const sigset_t *set, sigset_t *oset)
6477c478bd9Sstevel@tonic-gate {
6487c478bd9Sstevel@tonic-gate 	int error;
6497c478bd9Sstevel@tonic-gate 
6507c478bd9Sstevel@tonic-gate 	/*
6517c478bd9Sstevel@tonic-gate 	 * Guard against children of vfork().
6527c478bd9Sstevel@tonic-gate 	 */
6537c478bd9Sstevel@tonic-gate 	if (curthread->ul_vfork)
6547c478bd9Sstevel@tonic-gate 		return (__lwp_sigmask(how, set, oset));
6557c478bd9Sstevel@tonic-gate 
6567257d1b4Sraf 	if ((error = thr_sigsetmask(how, set, oset)) != 0) {
6577c478bd9Sstevel@tonic-gate 		errno = error;
6587c478bd9Sstevel@tonic-gate 		return (-1);
6597c478bd9Sstevel@tonic-gate 	}
6607c478bd9Sstevel@tonic-gate 
6617c478bd9Sstevel@tonic-gate 	return (0);
6627c478bd9Sstevel@tonic-gate }
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate /*
6657c478bd9Sstevel@tonic-gate  * Called at library initialization to set up signal handling.
66641efec22Sraf  * All we really do is initialize the sig_lock rwlocks.
6677c478bd9Sstevel@tonic-gate  * All signal handlers are either SIG_DFL or SIG_IGN on exec().
6687c478bd9Sstevel@tonic-gate  * However, if any signal handlers were established on alternate
6697c478bd9Sstevel@tonic-gate  * link maps before the primary link map has been initialized,
6707c478bd9Sstevel@tonic-gate  * then inform the kernel of the new sigacthandler.
6717c478bd9Sstevel@tonic-gate  */
6727c478bd9Sstevel@tonic-gate void
6737c478bd9Sstevel@tonic-gate signal_init()
6747c478bd9Sstevel@tonic-gate {
6757c478bd9Sstevel@tonic-gate 	uberdata_t *udp = curthread->ul_uberdata;
6767c478bd9Sstevel@tonic-gate 	struct sigaction *sap;
6777c478bd9Sstevel@tonic-gate 	struct sigaction act;
67841efec22Sraf 	rwlock_t *rwlp;
6797c478bd9Sstevel@tonic-gate 	int sig;
6807c478bd9Sstevel@tonic-gate 
6817c478bd9Sstevel@tonic-gate 	for (sig = 0; sig < NSIG; sig++) {
68241efec22Sraf 		rwlp = &udp->siguaction[sig].sig_lock;
68341efec22Sraf 		rwlp->rwlock_magic = RWL_MAGIC;
68441efec22Sraf 		rwlp->mutex.mutex_flag = LOCK_INITED;
68541efec22Sraf 		rwlp->mutex.mutex_magic = MUTEX_MAGIC;
6867c478bd9Sstevel@tonic-gate 		sap = &udp->siguaction[sig].sig_uaction;
6877c478bd9Sstevel@tonic-gate 		if (sap->sa_sigaction != SIG_DFL &&
6887c478bd9Sstevel@tonic-gate 		    sap->sa_sigaction != SIG_IGN &&
6897c478bd9Sstevel@tonic-gate 		    __sigaction(sig, NULL, &act) == 0 &&
6907c478bd9Sstevel@tonic-gate 		    act.sa_sigaction != SIG_DFL &&
6917c478bd9Sstevel@tonic-gate 		    act.sa_sigaction != SIG_IGN) {
6927c478bd9Sstevel@tonic-gate 			act = *sap;
6937c478bd9Sstevel@tonic-gate 			act.sa_flags &= ~SA_NODEFER;
6947c478bd9Sstevel@tonic-gate 			act.sa_sigaction = udp->sigacthandler;
6957c478bd9Sstevel@tonic-gate 			act.sa_mask = maskset;
6967c478bd9Sstevel@tonic-gate 			(void) __sigaction(sig, &act, NULL);
6977c478bd9Sstevel@tonic-gate 		}
6987c478bd9Sstevel@tonic-gate 	}
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate 
7017c478bd9Sstevel@tonic-gate /*
7027c478bd9Sstevel@tonic-gate  * Common code for cancelling self in _sigcancel() and pthread_cancel().
703a574db85Sraf  * First record the fact that a cancellation is pending.
704a574db85Sraf  * Then, if cancellation is disabled or if we are holding unprotected
705a574db85Sraf  * libc locks, just return to defer the cancellation.
706a574db85Sraf  * Then, if we are at a cancellation point (ul_cancelable) just
707a574db85Sraf  * return and let _canceloff() do the exit.
708a574db85Sraf  * Else exit immediately if async mode is in effect.
7097c478bd9Sstevel@tonic-gate  */
7107c478bd9Sstevel@tonic-gate void
711a574db85Sraf do_sigcancel(void)
7127c478bd9Sstevel@tonic-gate {
7137c478bd9Sstevel@tonic-gate 	ulwp_t *self = curthread;
7147c478bd9Sstevel@tonic-gate 
7157c478bd9Sstevel@tonic-gate 	ASSERT(self->ul_critical == 0);
7167c478bd9Sstevel@tonic-gate 	ASSERT(self->ul_sigdefer == 0);
7177c478bd9Sstevel@tonic-gate 	self->ul_cancel_pending = 1;
7187c478bd9Sstevel@tonic-gate 	if (self->ul_cancel_async &&
7197c478bd9Sstevel@tonic-gate 	    !self->ul_cancel_disabled &&
720a574db85Sraf 	    self->ul_libc_locks == 0 &&
7217c478bd9Sstevel@tonic-gate 	    !self->ul_cancelable)
7227257d1b4Sraf 		pthread_exit(PTHREAD_CANCELED);
723a574db85Sraf 	set_cancel_pending_flag(self, 0);
7247c478bd9Sstevel@tonic-gate }
7257c478bd9Sstevel@tonic-gate 
7267c478bd9Sstevel@tonic-gate /*
727f841f6adSraf  * Set up the SIGCANCEL handler for threads cancellation,
728f841f6adSraf  * needed only when we have more than one thread,
729f841f6adSraf  * or the SIGAIOCANCEL handler for aio cancellation,
730f841f6adSraf  * called when aio is initialized, in __uaio_init().
7317c478bd9Sstevel@tonic-gate  */
7327c478bd9Sstevel@tonic-gate void
733f841f6adSraf setup_cancelsig(int sig)
7347c478bd9Sstevel@tonic-gate {
7357c478bd9Sstevel@tonic-gate 	uberdata_t *udp = curthread->ul_uberdata;
73641efec22Sraf 	rwlock_t *rwlp = &udp->siguaction[sig].sig_lock;
7377c478bd9Sstevel@tonic-gate 	struct sigaction act;
7387c478bd9Sstevel@tonic-gate 
739f841f6adSraf 	ASSERT(sig == SIGCANCEL || sig == SIGAIOCANCEL);
74041efec22Sraf 	lrw_rdlock(rwlp);
741f841f6adSraf 	act = udp->siguaction[sig].sig_uaction;
74241efec22Sraf 	lrw_unlock(rwlp);
7437c478bd9Sstevel@tonic-gate 	if (act.sa_sigaction == SIG_DFL ||
7447c478bd9Sstevel@tonic-gate 	    act.sa_sigaction == SIG_IGN)
7457c478bd9Sstevel@tonic-gate 		act.sa_flags = SA_SIGINFO;
7467c478bd9Sstevel@tonic-gate 	else {
7477c478bd9Sstevel@tonic-gate 		act.sa_flags |= SA_SIGINFO;
748a574db85Sraf 		act.sa_flags &= ~(SA_NODEFER | SA_RESETHAND | SA_RESTART);
7497c478bd9Sstevel@tonic-gate 	}
7507c478bd9Sstevel@tonic-gate 	act.sa_sigaction = udp->sigacthandler;
7517c478bd9Sstevel@tonic-gate 	act.sa_mask = maskset;
752f841f6adSraf 	(void) __sigaction(sig, &act, NULL);
7537c478bd9Sstevel@tonic-gate }
754