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