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