19454b2d8SWarner Losh /*- 2df8bae1dSRodney W. Grimes * Copyright (c) 1982, 1986, 1989, 1991, 1993 3df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 4df8bae1dSRodney W. Grimes * (c) UNIX System Laboratories, Inc. 5df8bae1dSRodney W. Grimes * All or some portions of this file are derived from material licensed 6df8bae1dSRodney W. Grimes * to the University of California by American Telephone and Telegraph 7df8bae1dSRodney W. Grimes * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8df8bae1dSRodney W. Grimes * the permission of UNIX System Laboratories, Inc. 9df8bae1dSRodney W. Grimes * 10df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 11df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 12df8bae1dSRodney W. Grimes * are met: 13df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 14df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 15df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 16df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 17df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 18df8bae1dSRodney W. Grimes * 4. Neither the name of the University nor the names of its contributors 19df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 20df8bae1dSRodney W. Grimes * without specific prior written permission. 21df8bae1dSRodney W. Grimes * 22df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32df8bae1dSRodney W. Grimes * SUCH DAMAGE. 33df8bae1dSRodney W. Grimes * 34df8bae1dSRodney W. Grimes * @(#)kern_sig.c 8.7 (Berkeley) 4/18/94 35df8bae1dSRodney W. Grimes */ 36df8bae1dSRodney W. Grimes 37677b542eSDavid E. O'Brien #include <sys/cdefs.h> 38677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 39677b542eSDavid E. O'Brien 405591b823SEivind Eklund #include "opt_compat.h" 41db6a20e2SGarrett Wollman #include "opt_ktrace.h" 42db6a20e2SGarrett Wollman 43df8bae1dSRodney W. Grimes #include <sys/param.h> 4436240ea5SDoug Rabson #include <sys/systm.h> 45df8bae1dSRodney W. Grimes #include <sys/signalvar.h> 46df8bae1dSRodney W. Grimes #include <sys/vnode.h> 47df8bae1dSRodney W. Grimes #include <sys/acct.h> 48238510fcSJason Evans #include <sys/condvar.h> 49854dc8c2SJohn Baldwin #include <sys/event.h> 50854dc8c2SJohn Baldwin #include <sys/fcntl.h> 51854dc8c2SJohn Baldwin #include <sys/kernel.h> 529dde3bc9SDavid Xu #include <sys/kse.h> 530384fff8SJason Evans #include <sys/ktr.h> 54df8bae1dSRodney W. Grimes #include <sys/ktrace.h> 55854dc8c2SJohn Baldwin #include <sys/lock.h> 56854dc8c2SJohn Baldwin #include <sys/malloc.h> 57854dc8c2SJohn Baldwin #include <sys/mutex.h> 58854dc8c2SJohn Baldwin #include <sys/namei.h> 59854dc8c2SJohn Baldwin #include <sys/proc.h> 606aeb05d7STom Rhodes #include <sys/posix4.h> 61854dc8c2SJohn Baldwin #include <sys/pioctl.h> 62c31146a1SJohn Baldwin #include <sys/resourcevar.h> 6344f3b092SJohn Baldwin #include <sys/sleepqueue.h> 646caa8a15SJohn Baldwin #include <sys/smp.h> 65df8bae1dSRodney W. Grimes #include <sys/stat.h> 661005a129SJohn Baldwin #include <sys/sx.h> 678f19eb88SIan Dowse #include <sys/syscallsubr.h> 68c87e2930SDavid Greenman #include <sys/sysctl.h> 69854dc8c2SJohn Baldwin #include <sys/sysent.h> 70854dc8c2SJohn Baldwin #include <sys/syslog.h> 71854dc8c2SJohn Baldwin #include <sys/sysproto.h> 7256c06c4bSDavid Xu #include <sys/timers.h> 7306ae1e91SMatthew Dillon #include <sys/unistd.h> 74854dc8c2SJohn Baldwin #include <sys/wait.h> 759104847fSDavid Xu #include <vm/vm.h> 769104847fSDavid Xu #include <vm/vm_extern.h> 779104847fSDavid Xu #include <vm/uma.h> 78df8bae1dSRodney W. Grimes 79df8bae1dSRodney W. Grimes #include <machine/cpu.h> 80df8bae1dSRodney W. Grimes 81bfd7575aSWayne Salamon #include <security/audit/audit.h> 82bfd7575aSWayne Salamon 836f841fb7SMarcel Moolenaar #define ONSIG 32 /* NSIG for osig* syscalls. XXX. */ 846f841fb7SMarcel Moolenaar 854d77a549SAlfred Perlstein static int coredump(struct thread *); 864d77a549SAlfred Perlstein static char *expand_name(const char *, uid_t, pid_t); 871a88a252SMaxim Sobolev static int killpg1(struct thread *td, int sig, int pgid, int all); 886711f10fSJohn Baldwin static int issignal(struct thread *p); 894d77a549SAlfred Perlstein static int sigprop(int sig); 9094f0972bSDavid Xu static void tdsigwakeup(struct thread *, int, sig_t, int); 91d8267df7SDavid Xu static void sig_suspend_threads(struct thread *, struct proc *, int); 92cb679c38SJonathan Lemon static int filt_sigattach(struct knote *kn); 93cb679c38SJonathan Lemon static void filt_sigdetach(struct knote *kn); 94cb679c38SJonathan Lemon static int filt_signal(struct knote *kn, long hint); 954093529dSJeff Roberson static struct thread *sigtd(struct proc *p, int sig, int prop); 968460a577SJohn Birrell #ifdef KSE 976d7b314bSDavid Xu static int do_tdsignal(struct proc *, struct thread *, int, ksiginfo_t *); 988460a577SJohn Birrell #endif 999104847fSDavid Xu static void sigqueue_start(void); 100cb679c38SJonathan Lemon 1019104847fSDavid Xu static uma_zone_t ksiginfo_zone = NULL; 102cb679c38SJonathan Lemon struct filterops sig_filtops = 103cb679c38SJonathan Lemon { 0, filt_sigattach, filt_sigdetach, filt_signal }; 104cb679c38SJonathan Lemon 10557308494SJoerg Wunsch static int kern_logsigexit = 1; 1063d177f46SBill Fumerola SYSCTL_INT(_kern, KERN_LOGSIGEXIT, logsigexit, CTLFLAG_RW, 1073d177f46SBill Fumerola &kern_logsigexit, 0, 1083d177f46SBill Fumerola "Log processes quitting on abnormal signals to syslog(3)"); 10957308494SJoerg Wunsch 110f71a882fSDavid Xu static int kern_forcesigexit = 1; 111f71a882fSDavid Xu SYSCTL_INT(_kern, OID_AUTO, forcesigexit, CTLFLAG_RW, 112f71a882fSDavid Xu &kern_forcesigexit, 0, "Force trap signal to be handled"); 113f71a882fSDavid Xu 1149104847fSDavid Xu SYSCTL_NODE(_kern, OID_AUTO, sigqueue, CTLFLAG_RW, 0, "POSIX real time signal"); 1159104847fSDavid Xu 1169104847fSDavid Xu static int max_pending_per_proc = 128; 1179104847fSDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, max_pending_per_proc, CTLFLAG_RW, 1189104847fSDavid Xu &max_pending_per_proc, 0, "Max pending signals per proc"); 1199104847fSDavid Xu 1209104847fSDavid Xu static int preallocate_siginfo = 1024; 1219104847fSDavid Xu TUNABLE_INT("kern.sigqueue.preallocate", &preallocate_siginfo); 1229104847fSDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, preallocate, CTLFLAG_RD, 1239104847fSDavid Xu &preallocate_siginfo, 0, "Preallocated signal memory size"); 1249104847fSDavid Xu 1259104847fSDavid Xu static int signal_overflow = 0; 126761a4d94SDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, overflow, CTLFLAG_RD, 1279104847fSDavid Xu &signal_overflow, 0, "Number of signals overflew"); 1289104847fSDavid Xu 1299104847fSDavid Xu static int signal_alloc_fail = 0; 130761a4d94SDavid Xu SYSCTL_INT(_kern_sigqueue, OID_AUTO, alloc_fail, CTLFLAG_RD, 1319104847fSDavid Xu &signal_alloc_fail, 0, "signals failed to be allocated"); 1329104847fSDavid Xu 1339104847fSDavid Xu SYSINIT(signal, SI_SUB_P1003_1B, SI_ORDER_FIRST+3, sigqueue_start, NULL); 1349104847fSDavid Xu 1352b87b6d4SRobert Watson /* 1362b87b6d4SRobert Watson * Policy -- Can ucred cr1 send SIGIO to process cr2? 1372b87b6d4SRobert Watson * Should use cr_cansignal() once cr_cansignal() allows SIGIO and SIGURG 1382b87b6d4SRobert Watson * in the right situations. 1392b87b6d4SRobert Watson */ 1402b87b6d4SRobert Watson #define CANSIGIO(cr1, cr2) \ 1412b87b6d4SRobert Watson ((cr1)->cr_uid == 0 || \ 1422b87b6d4SRobert Watson (cr1)->cr_ruid == (cr2)->cr_ruid || \ 1432b87b6d4SRobert Watson (cr1)->cr_uid == (cr2)->cr_ruid || \ 1442b87b6d4SRobert Watson (cr1)->cr_ruid == (cr2)->cr_uid || \ 1452b87b6d4SRobert Watson (cr1)->cr_uid == (cr2)->cr_uid) 1462b87b6d4SRobert Watson 14722d4b0fbSJohn Polstra int sugid_coredump; 1483d177f46SBill Fumerola SYSCTL_INT(_kern, OID_AUTO, sugid_coredump, CTLFLAG_RW, 1493d177f46SBill Fumerola &sugid_coredump, 0, "Enable coredumping set user/group ID processes"); 150c87e2930SDavid Greenman 151e5a28db9SPaul Saab static int do_coredump = 1; 152e5a28db9SPaul Saab SYSCTL_INT(_kern, OID_AUTO, coredump, CTLFLAG_RW, 153e5a28db9SPaul Saab &do_coredump, 0, "Enable/Disable coredumps"); 154e5a28db9SPaul Saab 1556141e04aSJohn-Mark Gurney static int set_core_nodump_flag = 0; 1566141e04aSJohn-Mark Gurney SYSCTL_INT(_kern, OID_AUTO, nodump_coredump, CTLFLAG_RW, &set_core_nodump_flag, 1576141e04aSJohn-Mark Gurney 0, "Enable setting the NODUMP flag on coredump files"); 1586141e04aSJohn-Mark Gurney 1592c42a146SMarcel Moolenaar /* 1602c42a146SMarcel Moolenaar * Signal properties and actions. 1612c42a146SMarcel Moolenaar * The array below categorizes the signals and their default actions 1622c42a146SMarcel Moolenaar * according to the following properties: 1632c42a146SMarcel Moolenaar */ 1642c42a146SMarcel Moolenaar #define SA_KILL 0x01 /* terminates process by default */ 1652c42a146SMarcel Moolenaar #define SA_CORE 0x02 /* ditto and coredumps */ 1662c42a146SMarcel Moolenaar #define SA_STOP 0x04 /* suspend process */ 1672c42a146SMarcel Moolenaar #define SA_TTYSTOP 0x08 /* ditto, from tty */ 1682c42a146SMarcel Moolenaar #define SA_IGNORE 0x10 /* ignore by default */ 1692c42a146SMarcel Moolenaar #define SA_CONT 0x20 /* continue if suspended */ 1702c42a146SMarcel Moolenaar #define SA_CANTMASK 0x40 /* non-maskable, catchable */ 171da33176fSJeff Roberson #define SA_PROC 0x80 /* deliverable to any thread */ 172df8bae1dSRodney W. Grimes 1732c42a146SMarcel Moolenaar static int sigproptbl[NSIG] = { 174da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGHUP */ 175da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGINT */ 176da33176fSJeff Roberson SA_KILL|SA_CORE|SA_PROC, /* SIGQUIT */ 1772c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGILL */ 1782c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGTRAP */ 1792c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGABRT */ 180da33176fSJeff Roberson SA_KILL|SA_CORE|SA_PROC, /* SIGEMT */ 1812c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGFPE */ 182da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGKILL */ 1832c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGBUS */ 1842c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGSEGV */ 1852c42a146SMarcel Moolenaar SA_KILL|SA_CORE, /* SIGSYS */ 186da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGPIPE */ 187da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGALRM */ 188da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGTERM */ 189da33176fSJeff Roberson SA_IGNORE|SA_PROC, /* SIGURG */ 190da33176fSJeff Roberson SA_STOP|SA_PROC, /* SIGSTOP */ 191da33176fSJeff Roberson SA_STOP|SA_TTYSTOP|SA_PROC, /* SIGTSTP */ 192da33176fSJeff Roberson SA_IGNORE|SA_CONT|SA_PROC, /* SIGCONT */ 193da33176fSJeff Roberson SA_IGNORE|SA_PROC, /* SIGCHLD */ 194da33176fSJeff Roberson SA_STOP|SA_TTYSTOP|SA_PROC, /* SIGTTIN */ 195da33176fSJeff Roberson SA_STOP|SA_TTYSTOP|SA_PROC, /* SIGTTOU */ 196da33176fSJeff Roberson SA_IGNORE|SA_PROC, /* SIGIO */ 1972c42a146SMarcel Moolenaar SA_KILL, /* SIGXCPU */ 1982c42a146SMarcel Moolenaar SA_KILL, /* SIGXFSZ */ 199da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGVTALRM */ 200da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGPROF */ 201da33176fSJeff Roberson SA_IGNORE|SA_PROC, /* SIGWINCH */ 202da33176fSJeff Roberson SA_IGNORE|SA_PROC, /* SIGINFO */ 203da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGUSR1 */ 204da33176fSJeff Roberson SA_KILL|SA_PROC, /* SIGUSR2 */ 2052c42a146SMarcel Moolenaar }; 2062c42a146SMarcel Moolenaar 2079104847fSDavid Xu static void 2089104847fSDavid Xu sigqueue_start(void) 2099104847fSDavid Xu { 2109104847fSDavid Xu ksiginfo_zone = uma_zcreate("ksiginfo", sizeof(ksiginfo_t), 2119104847fSDavid Xu NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0); 2129104847fSDavid Xu uma_prealloc(ksiginfo_zone, preallocate_siginfo); 213b51d237aSDavid Xu p31b_setcfg(CTL_P1003_1B_REALTIME_SIGNALS, _POSIX_REALTIME_SIGNALS); 214b51d237aSDavid Xu p31b_setcfg(CTL_P1003_1B_RTSIG_MAX, SIGRTMAX - SIGRTMIN + 1); 215b51d237aSDavid Xu p31b_setcfg(CTL_P1003_1B_SIGQUEUE_MAX, max_pending_per_proc); 2169104847fSDavid Xu } 2179104847fSDavid Xu 2185da49fcbSDavid Xu ksiginfo_t * 219ebceaf6dSDavid Xu ksiginfo_alloc(int wait) 2209104847fSDavid Xu { 221ebceaf6dSDavid Xu int flags; 222ebceaf6dSDavid Xu 223ebceaf6dSDavid Xu flags = M_ZERO; 224ebceaf6dSDavid Xu if (! wait) 225ebceaf6dSDavid Xu flags |= M_NOWAIT; 2269104847fSDavid Xu if (ksiginfo_zone != NULL) 227ebceaf6dSDavid Xu return ((ksiginfo_t *)uma_zalloc(ksiginfo_zone, flags)); 2289104847fSDavid Xu return (NULL); 2299104847fSDavid Xu } 2309104847fSDavid Xu 2315da49fcbSDavid Xu void 2329104847fSDavid Xu ksiginfo_free(ksiginfo_t *ksi) 2339104847fSDavid Xu { 2349104847fSDavid Xu uma_zfree(ksiginfo_zone, ksi); 2359104847fSDavid Xu } 2369104847fSDavid Xu 2375da49fcbSDavid Xu static __inline int 2385da49fcbSDavid Xu ksiginfo_tryfree(ksiginfo_t *ksi) 2395da49fcbSDavid Xu { 2405da49fcbSDavid Xu if (!(ksi->ksi_flags & KSI_EXT)) { 2415da49fcbSDavid Xu uma_zfree(ksiginfo_zone, ksi); 2425da49fcbSDavid Xu return (1); 2435da49fcbSDavid Xu } 2445da49fcbSDavid Xu return (0); 2455da49fcbSDavid Xu } 2465da49fcbSDavid Xu 2479104847fSDavid Xu void 2489104847fSDavid Xu sigqueue_init(sigqueue_t *list, struct proc *p) 2499104847fSDavid Xu { 2509104847fSDavid Xu SIGEMPTYSET(list->sq_signals); 2513dfcaad6SDavid Xu SIGEMPTYSET(list->sq_kill); 2529104847fSDavid Xu TAILQ_INIT(&list->sq_list); 2539104847fSDavid Xu list->sq_proc = p; 2549104847fSDavid Xu list->sq_flags = SQ_INIT; 2559104847fSDavid Xu } 2569104847fSDavid Xu 2579104847fSDavid Xu /* 2589104847fSDavid Xu * Get a signal's ksiginfo. 2599104847fSDavid Xu * Return: 2609104847fSDavid Xu * 0 - signal not found 2619104847fSDavid Xu * others - signal number 2629104847fSDavid Xu */ 2639104847fSDavid Xu int 2649104847fSDavid Xu sigqueue_get(sigqueue_t *sq, int signo, ksiginfo_t *si) 2659104847fSDavid Xu { 2669104847fSDavid Xu struct proc *p = sq->sq_proc; 2679104847fSDavid Xu struct ksiginfo *ksi, *next; 2689104847fSDavid Xu int count = 0; 2699104847fSDavid Xu 2709104847fSDavid Xu KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited")); 2719104847fSDavid Xu 2729104847fSDavid Xu if (!SIGISMEMBER(sq->sq_signals, signo)) 2739104847fSDavid Xu return (0); 2749104847fSDavid Xu 2753dfcaad6SDavid Xu if (SIGISMEMBER(sq->sq_kill, signo)) { 2763dfcaad6SDavid Xu count++; 2773dfcaad6SDavid Xu SIGDELSET(sq->sq_kill, signo); 2783dfcaad6SDavid Xu } 2793dfcaad6SDavid Xu 2805c28a8d4SDavid Xu TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) { 2819104847fSDavid Xu if (ksi->ksi_signo == signo) { 2829104847fSDavid Xu if (count == 0) { 2839104847fSDavid Xu TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link); 2845da49fcbSDavid Xu ksi->ksi_sigq = NULL; 2859104847fSDavid Xu ksiginfo_copy(ksi, si); 2865da49fcbSDavid Xu if (ksiginfo_tryfree(ksi) && p != NULL) 2879104847fSDavid Xu p->p_pendingcnt--; 2889104847fSDavid Xu } 289016fa302SDavid Xu if (++count > 1) 290016fa302SDavid Xu break; 2919104847fSDavid Xu } 2929104847fSDavid Xu } 2939104847fSDavid Xu 2949104847fSDavid Xu if (count <= 1) 2959104847fSDavid Xu SIGDELSET(sq->sq_signals, signo); 2969104847fSDavid Xu si->ksi_signo = signo; 2979104847fSDavid Xu return (signo); 2989104847fSDavid Xu } 2999104847fSDavid Xu 3005da49fcbSDavid Xu void 3015da49fcbSDavid Xu sigqueue_take(ksiginfo_t *ksi) 3025da49fcbSDavid Xu { 3035da49fcbSDavid Xu struct ksiginfo *kp; 3045da49fcbSDavid Xu struct proc *p; 3055da49fcbSDavid Xu sigqueue_t *sq; 3065da49fcbSDavid Xu 307ebceaf6dSDavid Xu if (ksi == NULL || (sq = ksi->ksi_sigq) == NULL) 3085da49fcbSDavid Xu return; 3095da49fcbSDavid Xu 3105da49fcbSDavid Xu p = sq->sq_proc; 3115da49fcbSDavid Xu TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link); 3125da49fcbSDavid Xu ksi->ksi_sigq = NULL; 3135da49fcbSDavid Xu if (!(ksi->ksi_flags & KSI_EXT) && p != NULL) 3145da49fcbSDavid Xu p->p_pendingcnt--; 3155da49fcbSDavid Xu 3165da49fcbSDavid Xu for (kp = TAILQ_FIRST(&sq->sq_list); kp != NULL; 3175da49fcbSDavid Xu kp = TAILQ_NEXT(kp, ksi_link)) { 3185da49fcbSDavid Xu if (kp->ksi_signo == ksi->ksi_signo) 3195da49fcbSDavid Xu break; 3205da49fcbSDavid Xu } 3213dfcaad6SDavid Xu if (kp == NULL && !SIGISMEMBER(sq->sq_kill, ksi->ksi_signo)) 3225da49fcbSDavid Xu SIGDELSET(sq->sq_signals, ksi->ksi_signo); 3235da49fcbSDavid Xu } 3245da49fcbSDavid Xu 3259104847fSDavid Xu int 3269104847fSDavid Xu sigqueue_add(sigqueue_t *sq, int signo, ksiginfo_t *si) 3279104847fSDavid Xu { 3289104847fSDavid Xu struct proc *p = sq->sq_proc; 3299104847fSDavid Xu struct ksiginfo *ksi; 3309104847fSDavid Xu int ret = 0; 3319104847fSDavid Xu 3329104847fSDavid Xu KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited")); 3339104847fSDavid Xu 3343dfcaad6SDavid Xu if (signo == SIGKILL || signo == SIGSTOP || si == NULL) { 3353dfcaad6SDavid Xu SIGADDSET(sq->sq_kill, signo); 3369104847fSDavid Xu goto out_set_bit; 3373dfcaad6SDavid Xu } 3389104847fSDavid Xu 3395da49fcbSDavid Xu /* directly insert the ksi, don't copy it */ 3405da49fcbSDavid Xu if (si->ksi_flags & KSI_INS) { 3415da49fcbSDavid Xu TAILQ_INSERT_TAIL(&sq->sq_list, si, ksi_link); 3425da49fcbSDavid Xu si->ksi_sigq = sq; 3435da49fcbSDavid Xu goto out_set_bit; 3445da49fcbSDavid Xu } 3455da49fcbSDavid Xu 3463dfcaad6SDavid Xu if (__predict_false(ksiginfo_zone == NULL)) { 3473dfcaad6SDavid Xu SIGADDSET(sq->sq_kill, signo); 3489104847fSDavid Xu goto out_set_bit; 3493dfcaad6SDavid Xu } 3509104847fSDavid Xu 351ebceaf6dSDavid Xu if (p != NULL && p->p_pendingcnt >= max_pending_per_proc) { 3529104847fSDavid Xu signal_overflow++; 3539104847fSDavid Xu ret = EAGAIN; 354ebceaf6dSDavid Xu } else if ((ksi = ksiginfo_alloc(0)) == NULL) { 3559104847fSDavid Xu signal_alloc_fail++; 3569104847fSDavid Xu ret = EAGAIN; 3579104847fSDavid Xu } else { 3589104847fSDavid Xu if (p != NULL) 3599104847fSDavid Xu p->p_pendingcnt++; 3609104847fSDavid Xu ksiginfo_copy(si, ksi); 3619104847fSDavid Xu ksi->ksi_signo = signo; 3629104847fSDavid Xu TAILQ_INSERT_TAIL(&sq->sq_list, ksi, ksi_link); 3635da49fcbSDavid Xu ksi->ksi_sigq = sq; 3649104847fSDavid Xu } 3659104847fSDavid Xu 3669104847fSDavid Xu if ((si->ksi_flags & KSI_TRAP) != 0) { 3673dfcaad6SDavid Xu if (ret != 0) 3683dfcaad6SDavid Xu SIGADDSET(sq->sq_kill, signo); 3699104847fSDavid Xu ret = 0; 3709104847fSDavid Xu goto out_set_bit; 3719104847fSDavid Xu } 3729104847fSDavid Xu 3739104847fSDavid Xu if (ret != 0) 3749104847fSDavid Xu return (ret); 3759104847fSDavid Xu 3769104847fSDavid Xu out_set_bit: 3779104847fSDavid Xu SIGADDSET(sq->sq_signals, signo); 3789104847fSDavid Xu return (ret); 3799104847fSDavid Xu } 3809104847fSDavid Xu 3819104847fSDavid Xu void 3829104847fSDavid Xu sigqueue_flush(sigqueue_t *sq) 3839104847fSDavid Xu { 3849104847fSDavid Xu struct proc *p = sq->sq_proc; 3859104847fSDavid Xu ksiginfo_t *ksi; 3869104847fSDavid Xu 3879104847fSDavid Xu KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited")); 3889104847fSDavid Xu 3895da49fcbSDavid Xu if (p != NULL) 3905da49fcbSDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 3915da49fcbSDavid Xu 3929104847fSDavid Xu while ((ksi = TAILQ_FIRST(&sq->sq_list)) != NULL) { 3939104847fSDavid Xu TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link); 3945da49fcbSDavid Xu ksi->ksi_sigq = NULL; 3955da49fcbSDavid Xu if (ksiginfo_tryfree(ksi) && p != NULL) 3969104847fSDavid Xu p->p_pendingcnt--; 3979104847fSDavid Xu } 3989104847fSDavid Xu 3999104847fSDavid Xu SIGEMPTYSET(sq->sq_signals); 4003dfcaad6SDavid Xu SIGEMPTYSET(sq->sq_kill); 4019104847fSDavid Xu } 4029104847fSDavid Xu 4039104847fSDavid Xu void 4049104847fSDavid Xu sigqueue_collect_set(sigqueue_t *sq, sigset_t *set) 4059104847fSDavid Xu { 4069104847fSDavid Xu ksiginfo_t *ksi; 4079104847fSDavid Xu 4089104847fSDavid Xu KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited")); 4099104847fSDavid Xu 4109104847fSDavid Xu TAILQ_FOREACH(ksi, &sq->sq_list, ksi_link) 4119104847fSDavid Xu SIGADDSET(*set, ksi->ksi_signo); 4123dfcaad6SDavid Xu SIGSETOR(*set, sq->sq_kill); 4139104847fSDavid Xu } 4149104847fSDavid Xu 4159104847fSDavid Xu void 4169104847fSDavid Xu sigqueue_move_set(sigqueue_t *src, sigqueue_t *dst, sigset_t *setp) 4179104847fSDavid Xu { 4189104847fSDavid Xu sigset_t tmp, set; 4199104847fSDavid Xu struct proc *p1, *p2; 4209104847fSDavid Xu ksiginfo_t *ksi, *next; 4219104847fSDavid Xu 4229104847fSDavid Xu KASSERT(src->sq_flags & SQ_INIT, ("src sigqueue not inited")); 4239104847fSDavid Xu KASSERT(dst->sq_flags & SQ_INIT, ("dst sigqueue not inited")); 4249104847fSDavid Xu /* 4259104847fSDavid Xu * make a copy, this allows setp to point to src or dst 4269104847fSDavid Xu * sq_signals without trouble. 4279104847fSDavid Xu */ 4289104847fSDavid Xu set = *setp; 4299104847fSDavid Xu p1 = src->sq_proc; 4309104847fSDavid Xu p2 = dst->sq_proc; 4319104847fSDavid Xu /* Move siginfo to target list */ 4325c28a8d4SDavid Xu TAILQ_FOREACH_SAFE(ksi, &src->sq_list, ksi_link, next) { 4339104847fSDavid Xu if (SIGISMEMBER(set, ksi->ksi_signo)) { 4349104847fSDavid Xu TAILQ_REMOVE(&src->sq_list, ksi, ksi_link); 4359104847fSDavid Xu if (p1 != NULL) 4369104847fSDavid Xu p1->p_pendingcnt--; 4379104847fSDavid Xu TAILQ_INSERT_TAIL(&dst->sq_list, ksi, ksi_link); 4385da49fcbSDavid Xu ksi->ksi_sigq = dst; 4399104847fSDavid Xu if (p2 != NULL) 4409104847fSDavid Xu p2->p_pendingcnt++; 4419104847fSDavid Xu } 4429104847fSDavid Xu } 4439104847fSDavid Xu 4449104847fSDavid Xu /* Move pending bits to target list */ 4453dfcaad6SDavid Xu tmp = src->sq_kill; 4463dfcaad6SDavid Xu SIGSETAND(tmp, set); 4473dfcaad6SDavid Xu SIGSETOR(dst->sq_kill, tmp); 4483dfcaad6SDavid Xu SIGSETNAND(src->sq_kill, tmp); 4493dfcaad6SDavid Xu 4509104847fSDavid Xu tmp = src->sq_signals; 4519104847fSDavid Xu SIGSETAND(tmp, set); 4529104847fSDavid Xu SIGSETOR(dst->sq_signals, tmp); 4539104847fSDavid Xu SIGSETNAND(src->sq_signals, tmp); 4549104847fSDavid Xu 4559104847fSDavid Xu /* Finally, rescan src queue and set pending bits for it */ 4569104847fSDavid Xu sigqueue_collect_set(src, &src->sq_signals); 4579104847fSDavid Xu } 4589104847fSDavid Xu 4599104847fSDavid Xu void 4609104847fSDavid Xu sigqueue_move(sigqueue_t *src, sigqueue_t *dst, int signo) 4619104847fSDavid Xu { 4629104847fSDavid Xu sigset_t set; 4639104847fSDavid Xu 4649104847fSDavid Xu SIGEMPTYSET(set); 4659104847fSDavid Xu SIGADDSET(set, signo); 4669104847fSDavid Xu sigqueue_move_set(src, dst, &set); 4679104847fSDavid Xu } 4689104847fSDavid Xu 4699104847fSDavid Xu void 4709104847fSDavid Xu sigqueue_delete_set(sigqueue_t *sq, sigset_t *set) 4719104847fSDavid Xu { 4729104847fSDavid Xu struct proc *p = sq->sq_proc; 4739104847fSDavid Xu ksiginfo_t *ksi, *next; 4749104847fSDavid Xu 4759104847fSDavid Xu KASSERT(sq->sq_flags & SQ_INIT, ("src sigqueue not inited")); 4769104847fSDavid Xu 4779104847fSDavid Xu /* Remove siginfo queue */ 4785c28a8d4SDavid Xu TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) { 4799104847fSDavid Xu if (SIGISMEMBER(*set, ksi->ksi_signo)) { 4809104847fSDavid Xu TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link); 4815da49fcbSDavid Xu ksi->ksi_sigq = NULL; 4825da49fcbSDavid Xu if (ksiginfo_tryfree(ksi) && p != NULL) 4839104847fSDavid Xu p->p_pendingcnt--; 4849104847fSDavid Xu } 4859104847fSDavid Xu } 4863dfcaad6SDavid Xu SIGSETNAND(sq->sq_kill, *set); 4879104847fSDavid Xu SIGSETNAND(sq->sq_signals, *set); 4889104847fSDavid Xu /* Finally, rescan queue and set pending bits for it */ 4899104847fSDavid Xu sigqueue_collect_set(sq, &sq->sq_signals); 4909104847fSDavid Xu } 4919104847fSDavid Xu 4929104847fSDavid Xu void 4939104847fSDavid Xu sigqueue_delete(sigqueue_t *sq, int signo) 4949104847fSDavid Xu { 4959104847fSDavid Xu sigset_t set; 4969104847fSDavid Xu 4979104847fSDavid Xu SIGEMPTYSET(set); 4989104847fSDavid Xu SIGADDSET(set, signo); 4999104847fSDavid Xu sigqueue_delete_set(sq, &set); 5009104847fSDavid Xu } 5019104847fSDavid Xu 5029104847fSDavid Xu /* Remove a set of signals for a process */ 5039104847fSDavid Xu void 5049104847fSDavid Xu sigqueue_delete_set_proc(struct proc *p, sigset_t *set) 5059104847fSDavid Xu { 5069104847fSDavid Xu sigqueue_t worklist; 5079104847fSDavid Xu struct thread *td0; 5089104847fSDavid Xu 5099104847fSDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 5109104847fSDavid Xu 5119104847fSDavid Xu sigqueue_init(&worklist, NULL); 5129104847fSDavid Xu sigqueue_move_set(&p->p_sigqueue, &worklist, set); 5139104847fSDavid Xu 5149104847fSDavid Xu mtx_lock_spin(&sched_lock); 5159104847fSDavid Xu FOREACH_THREAD_IN_PROC(p, td0) 5169104847fSDavid Xu sigqueue_move_set(&td0->td_sigqueue, &worklist, set); 5179104847fSDavid Xu mtx_unlock_spin(&sched_lock); 5189104847fSDavid Xu 5199104847fSDavid Xu sigqueue_flush(&worklist); 5209104847fSDavid Xu } 5219104847fSDavid Xu 5229104847fSDavid Xu void 5239104847fSDavid Xu sigqueue_delete_proc(struct proc *p, int signo) 5249104847fSDavid Xu { 5259104847fSDavid Xu sigset_t set; 5269104847fSDavid Xu 5279104847fSDavid Xu SIGEMPTYSET(set); 5289104847fSDavid Xu SIGADDSET(set, signo); 5299104847fSDavid Xu sigqueue_delete_set_proc(p, &set); 5309104847fSDavid Xu } 5319104847fSDavid Xu 5329104847fSDavid Xu void 5339104847fSDavid Xu sigqueue_delete_stopmask_proc(struct proc *p) 5349104847fSDavid Xu { 5359104847fSDavid Xu sigset_t set; 5369104847fSDavid Xu 5379104847fSDavid Xu SIGEMPTYSET(set); 5389104847fSDavid Xu SIGADDSET(set, SIGSTOP); 5399104847fSDavid Xu SIGADDSET(set, SIGTSTP); 5409104847fSDavid Xu SIGADDSET(set, SIGTTIN); 5419104847fSDavid Xu SIGADDSET(set, SIGTTOU); 5429104847fSDavid Xu sigqueue_delete_set_proc(p, &set); 5439104847fSDavid Xu } 5449104847fSDavid Xu 545fbbeeb6cSBruce Evans /* 546fbbeeb6cSBruce Evans * Determine signal that should be delivered to process p, the current 547fbbeeb6cSBruce Evans * process, 0 if none. If there is a pending stop signal with default 548fbbeeb6cSBruce Evans * action, the process stops in issignal(). 549fbbeeb6cSBruce Evans */ 550fbbeeb6cSBruce Evans int 551e602ba25SJulian Elischer cursig(struct thread *td) 552fbbeeb6cSBruce Evans { 553c9dfa2e0SJeff Roberson PROC_LOCK_ASSERT(td->td_proc, MA_OWNED); 55490af4afaSJohn Baldwin mtx_assert(&td->td_proc->p_sigacts->ps_mtx, MA_OWNED); 555179235b3SBruce Evans mtx_assert(&sched_lock, MA_NOTOWNED); 5564093529dSJeff Roberson return (SIGPENDING(td) ? issignal(td) : 0); 557fbbeeb6cSBruce Evans } 558fbbeeb6cSBruce Evans 55979065dbaSBruce Evans /* 56079065dbaSBruce Evans * Arrange for ast() to handle unmasked pending signals on return to user 5619104847fSDavid Xu * mode. This must be called whenever a signal is added to td_sigqueue or 5624093529dSJeff Roberson * unmasked in td_sigmask. 56379065dbaSBruce Evans */ 56479065dbaSBruce Evans void 5654093529dSJeff Roberson signotify(struct thread *td) 56679065dbaSBruce Evans { 5674093529dSJeff Roberson struct proc *p; 5688460a577SJohn Birrell #ifdef KSE 5699dde3bc9SDavid Xu sigset_t set, saved; 5708460a577SJohn Birrell #else 5718460a577SJohn Birrell sigset_t set; 5728460a577SJohn Birrell #endif 5734093529dSJeff Roberson 5744093529dSJeff Roberson p = td->td_proc; 57579065dbaSBruce Evans 57679065dbaSBruce Evans PROC_LOCK_ASSERT(p, MA_OWNED); 5774093529dSJeff Roberson 5784093529dSJeff Roberson /* 5794093529dSJeff Roberson * If our mask changed we may have to move signal that were 5809104847fSDavid Xu * previously masked by all threads to our sigqueue. 5814093529dSJeff Roberson */ 5829104847fSDavid Xu set = p->p_sigqueue.sq_signals; 5838460a577SJohn Birrell #ifdef KSE 5849dde3bc9SDavid Xu if (p->p_flag & P_SA) 5859104847fSDavid Xu saved = p->p_sigqueue.sq_signals; 5868460a577SJohn Birrell #endif 5874093529dSJeff Roberson SIGSETNAND(set, td->td_sigmask); 5889104847fSDavid Xu if (! SIGISEMPTY(set)) 5899104847fSDavid Xu sigqueue_move_set(&p->p_sigqueue, &td->td_sigqueue, &set); 5908b94a061SJohn Baldwin if (SIGPENDING(td)) { 59179065dbaSBruce Evans mtx_lock_spin(&sched_lock); 5924093529dSJeff Roberson td->td_flags |= TDF_NEEDSIGCHK | TDF_ASTPENDING; 59379065dbaSBruce Evans mtx_unlock_spin(&sched_lock); 59479065dbaSBruce Evans } 5958460a577SJohn Birrell #ifdef KSE 5969dde3bc9SDavid Xu if ((p->p_flag & P_SA) && !(p->p_flag & P_SIGEVENT)) { 5979104847fSDavid Xu if (!SIGSETEQ(saved, p->p_sigqueue.sq_signals)) { 5989dde3bc9SDavid Xu /* pending set changed */ 5999dde3bc9SDavid Xu p->p_flag |= P_SIGEVENT; 6009dde3bc9SDavid Xu wakeup(&p->p_siglist); 6019dde3bc9SDavid Xu } 6029dde3bc9SDavid Xu } 6038460a577SJohn Birrell #endif 6048b94a061SJohn Baldwin } 6058b94a061SJohn Baldwin 6068b94a061SJohn Baldwin int 6078b94a061SJohn Baldwin sigonstack(size_t sp) 6088b94a061SJohn Baldwin { 609a30ec4b9SDavid Xu struct thread *td = curthread; 6108b94a061SJohn Baldwin 611a30ec4b9SDavid Xu return ((td->td_pflags & TDP_ALTSTACK) ? 6121930e303SPoul-Henning Kamp #if defined(COMPAT_43) 613a30ec4b9SDavid Xu ((td->td_sigstk.ss_size == 0) ? 614a30ec4b9SDavid Xu (td->td_sigstk.ss_flags & SS_ONSTACK) : 615a30ec4b9SDavid Xu ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size)) 6168b94a061SJohn Baldwin #else 617a30ec4b9SDavid Xu ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size) 6188b94a061SJohn Baldwin #endif 6198b94a061SJohn Baldwin : 0); 6208b94a061SJohn Baldwin } 62179065dbaSBruce Evans 6226f841fb7SMarcel Moolenaar static __inline int 6236f841fb7SMarcel Moolenaar sigprop(int sig) 6242c42a146SMarcel Moolenaar { 6256f841fb7SMarcel Moolenaar 6262c42a146SMarcel Moolenaar if (sig > 0 && sig < NSIG) 6272c42a146SMarcel Moolenaar return (sigproptbl[_SIG_IDX(sig)]); 6282c42a146SMarcel Moolenaar return (0); 629df8bae1dSRodney W. Grimes } 6302c42a146SMarcel Moolenaar 6314093529dSJeff Roberson int 6326f841fb7SMarcel Moolenaar sig_ffs(sigset_t *set) 6332c42a146SMarcel Moolenaar { 6342c42a146SMarcel Moolenaar int i; 6352c42a146SMarcel Moolenaar 6366f841fb7SMarcel Moolenaar for (i = 0; i < _SIG_WORDS; i++) 6372c42a146SMarcel Moolenaar if (set->__bits[i]) 6382c42a146SMarcel Moolenaar return (ffs(set->__bits[i]) + (i * 32)); 639df8bae1dSRodney W. Grimes return (0); 640df8bae1dSRodney W. Grimes } 641df8bae1dSRodney W. Grimes 6422c42a146SMarcel Moolenaar /* 6438f19eb88SIan Dowse * kern_sigaction 6442c42a146SMarcel Moolenaar * sigaction 64523eeeff7SPeter Wemm * freebsd4_sigaction 6462c42a146SMarcel Moolenaar * osigaction 6472c42a146SMarcel Moolenaar */ 6488f19eb88SIan Dowse int 64923eeeff7SPeter Wemm kern_sigaction(td, sig, act, oact, flags) 6508f19eb88SIan Dowse struct thread *td; 6512c42a146SMarcel Moolenaar register int sig; 6522c42a146SMarcel Moolenaar struct sigaction *act, *oact; 65323eeeff7SPeter Wemm int flags; 654df8bae1dSRodney W. Grimes { 65590af4afaSJohn Baldwin struct sigacts *ps; 6568f19eb88SIan Dowse struct proc *p = td->td_proc; 657df8bae1dSRodney W. Grimes 6582899d606SDag-Erling Smørgrav if (!_SIG_VALID(sig)) 6592c42a146SMarcel Moolenaar return (EINVAL); 6602c42a146SMarcel Moolenaar 661628d2653SJohn Baldwin PROC_LOCK(p); 662628d2653SJohn Baldwin ps = p->p_sigacts; 66390af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 6642c42a146SMarcel Moolenaar if (oact) { 6652c42a146SMarcel Moolenaar oact->sa_handler = ps->ps_sigact[_SIG_IDX(sig)]; 6662c42a146SMarcel Moolenaar oact->sa_mask = ps->ps_catchmask[_SIG_IDX(sig)]; 6672c42a146SMarcel Moolenaar oact->sa_flags = 0; 6682c42a146SMarcel Moolenaar if (SIGISMEMBER(ps->ps_sigonstack, sig)) 6692c42a146SMarcel Moolenaar oact->sa_flags |= SA_ONSTACK; 6702c42a146SMarcel Moolenaar if (!SIGISMEMBER(ps->ps_sigintr, sig)) 6712c42a146SMarcel Moolenaar oact->sa_flags |= SA_RESTART; 6722c42a146SMarcel Moolenaar if (SIGISMEMBER(ps->ps_sigreset, sig)) 6732c42a146SMarcel Moolenaar oact->sa_flags |= SA_RESETHAND; 6742c42a146SMarcel Moolenaar if (SIGISMEMBER(ps->ps_signodefer, sig)) 6752c42a146SMarcel Moolenaar oact->sa_flags |= SA_NODEFER; 6762c42a146SMarcel Moolenaar if (SIGISMEMBER(ps->ps_siginfo, sig)) 6772c42a146SMarcel Moolenaar oact->sa_flags |= SA_SIGINFO; 67890af4afaSJohn Baldwin if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDSTOP) 6792c42a146SMarcel Moolenaar oact->sa_flags |= SA_NOCLDSTOP; 68090af4afaSJohn Baldwin if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDWAIT) 6812c42a146SMarcel Moolenaar oact->sa_flags |= SA_NOCLDWAIT; 6822c42a146SMarcel Moolenaar } 6832c42a146SMarcel Moolenaar if (act) { 6842c42a146SMarcel Moolenaar if ((sig == SIGKILL || sig == SIGSTOP) && 685628d2653SJohn Baldwin act->sa_handler != SIG_DFL) { 68690af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 687628d2653SJohn Baldwin PROC_UNLOCK(p); 6882c42a146SMarcel Moolenaar return (EINVAL); 689628d2653SJohn Baldwin } 6902c42a146SMarcel Moolenaar 691df8bae1dSRodney W. Grimes /* 692df8bae1dSRodney W. Grimes * Change setting atomically. 693df8bae1dSRodney W. Grimes */ 6942c42a146SMarcel Moolenaar 6952c42a146SMarcel Moolenaar ps->ps_catchmask[_SIG_IDX(sig)] = act->sa_mask; 6962c42a146SMarcel Moolenaar SIG_CANTMASK(ps->ps_catchmask[_SIG_IDX(sig)]); 6972c42a146SMarcel Moolenaar if (act->sa_flags & SA_SIGINFO) { 698aa7a4daeSPeter Wemm ps->ps_sigact[_SIG_IDX(sig)] = 699aa7a4daeSPeter Wemm (__sighandler_t *)act->sa_sigaction; 70080f42b55SIan Dowse SIGADDSET(ps->ps_siginfo, sig); 70180f42b55SIan Dowse } else { 70280f42b55SIan Dowse ps->ps_sigact[_SIG_IDX(sig)] = act->sa_handler; 7032c42a146SMarcel Moolenaar SIGDELSET(ps->ps_siginfo, sig); 7042c42a146SMarcel Moolenaar } 7052c42a146SMarcel Moolenaar if (!(act->sa_flags & SA_RESTART)) 7062c42a146SMarcel Moolenaar SIGADDSET(ps->ps_sigintr, sig); 707df8bae1dSRodney W. Grimes else 7082c42a146SMarcel Moolenaar SIGDELSET(ps->ps_sigintr, sig); 7092c42a146SMarcel Moolenaar if (act->sa_flags & SA_ONSTACK) 7102c42a146SMarcel Moolenaar SIGADDSET(ps->ps_sigonstack, sig); 711df8bae1dSRodney W. Grimes else 7122c42a146SMarcel Moolenaar SIGDELSET(ps->ps_sigonstack, sig); 7132c42a146SMarcel Moolenaar if (act->sa_flags & SA_RESETHAND) 7142c42a146SMarcel Moolenaar SIGADDSET(ps->ps_sigreset, sig); 7151e41c1b5SSteven Wallace else 7162c42a146SMarcel Moolenaar SIGDELSET(ps->ps_sigreset, sig); 7172c42a146SMarcel Moolenaar if (act->sa_flags & SA_NODEFER) 7182c42a146SMarcel Moolenaar SIGADDSET(ps->ps_signodefer, sig); 719289ccde0SPeter Wemm else 7202c42a146SMarcel Moolenaar SIGDELSET(ps->ps_signodefer, sig); 7212c42a146SMarcel Moolenaar if (sig == SIGCHLD) { 7222c42a146SMarcel Moolenaar if (act->sa_flags & SA_NOCLDSTOP) 72390af4afaSJohn Baldwin ps->ps_flag |= PS_NOCLDSTOP; 7246626c604SJulian Elischer else 72590af4afaSJohn Baldwin ps->ps_flag &= ~PS_NOCLDSTOP; 726ba1551caSIan Dowse if (act->sa_flags & SA_NOCLDWAIT) { 727245f17d4SJoerg Wunsch /* 7282c42a146SMarcel Moolenaar * Paranoia: since SA_NOCLDWAIT is implemented 7292c42a146SMarcel Moolenaar * by reparenting the dying child to PID 1 (and 7302c42a146SMarcel Moolenaar * trust it to reap the zombie), PID 1 itself 7312c42a146SMarcel Moolenaar * is forbidden to set SA_NOCLDWAIT. 732245f17d4SJoerg Wunsch */ 733245f17d4SJoerg Wunsch if (p->p_pid == 1) 73490af4afaSJohn Baldwin ps->ps_flag &= ~PS_NOCLDWAIT; 7356626c604SJulian Elischer else 73690af4afaSJohn Baldwin ps->ps_flag |= PS_NOCLDWAIT; 737245f17d4SJoerg Wunsch } else 73890af4afaSJohn Baldwin ps->ps_flag &= ~PS_NOCLDWAIT; 739ba1551caSIan Dowse if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN) 74090af4afaSJohn Baldwin ps->ps_flag |= PS_CLDSIGIGN; 741ba1551caSIan Dowse else 74290af4afaSJohn Baldwin ps->ps_flag &= ~PS_CLDSIGIGN; 743df8bae1dSRodney W. Grimes } 744df8bae1dSRodney W. Grimes /* 74590af4afaSJohn Baldwin * Set bit in ps_sigignore for signals that are set to SIG_IGN, 7462c42a146SMarcel Moolenaar * and for signals set to SIG_DFL where the default is to 74790af4afaSJohn Baldwin * ignore. However, don't put SIGCONT in ps_sigignore, as we 7482c42a146SMarcel Moolenaar * have to restart the process. 749df8bae1dSRodney W. Grimes */ 7502c42a146SMarcel Moolenaar if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN || 7512c42a146SMarcel Moolenaar (sigprop(sig) & SA_IGNORE && 7522c42a146SMarcel Moolenaar ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) { 7538460a577SJohn Birrell #ifdef KSE 7549dde3bc9SDavid Xu if ((p->p_flag & P_SA) && 7559104847fSDavid Xu SIGISMEMBER(p->p_sigqueue.sq_signals, sig)) { 7569dde3bc9SDavid Xu p->p_flag |= P_SIGEVENT; 7579dde3bc9SDavid Xu wakeup(&p->p_siglist); 7589dde3bc9SDavid Xu } 7598460a577SJohn Birrell #endif 7602c42a146SMarcel Moolenaar /* never to be seen again */ 7619104847fSDavid Xu sigqueue_delete_proc(p, sig); 7622c42a146SMarcel Moolenaar if (sig != SIGCONT) 7632c42a146SMarcel Moolenaar /* easier in psignal */ 76490af4afaSJohn Baldwin SIGADDSET(ps->ps_sigignore, sig); 76590af4afaSJohn Baldwin SIGDELSET(ps->ps_sigcatch, sig); 766645682fdSLuoqi Chen } else { 76790af4afaSJohn Baldwin SIGDELSET(ps->ps_sigignore, sig); 7682c42a146SMarcel Moolenaar if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL) 76990af4afaSJohn Baldwin SIGDELSET(ps->ps_sigcatch, sig); 7702c42a146SMarcel Moolenaar else 77190af4afaSJohn Baldwin SIGADDSET(ps->ps_sigcatch, sig); 7722c42a146SMarcel Moolenaar } 77323eeeff7SPeter Wemm #ifdef COMPAT_FREEBSD4 77423eeeff7SPeter Wemm if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN || 77523eeeff7SPeter Wemm ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL || 77623eeeff7SPeter Wemm (flags & KSA_FREEBSD4) == 0) 77723eeeff7SPeter Wemm SIGDELSET(ps->ps_freebsd4, sig); 77823eeeff7SPeter Wemm else 77923eeeff7SPeter Wemm SIGADDSET(ps->ps_freebsd4, sig); 78023eeeff7SPeter Wemm #endif 781e8ebc08fSPeter Wemm #ifdef COMPAT_43 782645682fdSLuoqi Chen if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN || 78323eeeff7SPeter Wemm ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL || 78423eeeff7SPeter Wemm (flags & KSA_OSIGSET) == 0) 785645682fdSLuoqi Chen SIGDELSET(ps->ps_osigset, sig); 786645682fdSLuoqi Chen else 787645682fdSLuoqi Chen SIGADDSET(ps->ps_osigset, sig); 788e8ebc08fSPeter Wemm #endif 789df8bae1dSRodney W. Grimes } 79090af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 791628d2653SJohn Baldwin PROC_UNLOCK(p); 7922c42a146SMarcel Moolenaar return (0); 7932c42a146SMarcel Moolenaar } 7942c42a146SMarcel Moolenaar 7952c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_ 7962c42a146SMarcel Moolenaar struct sigaction_args { 7972c42a146SMarcel Moolenaar int sig; 7982c42a146SMarcel Moolenaar struct sigaction *act; 7992c42a146SMarcel Moolenaar struct sigaction *oact; 8002c42a146SMarcel Moolenaar }; 8012c42a146SMarcel Moolenaar #endif 8022c42a146SMarcel Moolenaar int 803b40ce416SJulian Elischer sigaction(td, uap) 804b40ce416SJulian Elischer struct thread *td; 8052c42a146SMarcel Moolenaar register struct sigaction_args *uap; 8062c42a146SMarcel Moolenaar { 8072c42a146SMarcel Moolenaar struct sigaction act, oact; 8082c42a146SMarcel Moolenaar register struct sigaction *actp, *oactp; 8092c42a146SMarcel Moolenaar int error; 8102c42a146SMarcel Moolenaar 8116f841fb7SMarcel Moolenaar actp = (uap->act != NULL) ? &act : NULL; 8126f841fb7SMarcel Moolenaar oactp = (uap->oact != NULL) ? &oact : NULL; 8132c42a146SMarcel Moolenaar if (actp) { 8146f841fb7SMarcel Moolenaar error = copyin(uap->act, actp, sizeof(act)); 8152c42a146SMarcel Moolenaar if (error) 81644443757STim J. Robbins return (error); 8172c42a146SMarcel Moolenaar } 8188f19eb88SIan Dowse error = kern_sigaction(td, uap->sig, actp, oactp, 0); 81925d6dc06SJohn Baldwin if (oactp && !error) 8206f841fb7SMarcel Moolenaar error = copyout(oactp, uap->oact, sizeof(oact)); 8212c42a146SMarcel Moolenaar return (error); 8222c42a146SMarcel Moolenaar } 8232c42a146SMarcel Moolenaar 82423eeeff7SPeter Wemm #ifdef COMPAT_FREEBSD4 82523eeeff7SPeter Wemm #ifndef _SYS_SYSPROTO_H_ 82623eeeff7SPeter Wemm struct freebsd4_sigaction_args { 82723eeeff7SPeter Wemm int sig; 82823eeeff7SPeter Wemm struct sigaction *act; 82923eeeff7SPeter Wemm struct sigaction *oact; 83023eeeff7SPeter Wemm }; 83123eeeff7SPeter Wemm #endif 83223eeeff7SPeter Wemm int 83323eeeff7SPeter Wemm freebsd4_sigaction(td, uap) 83423eeeff7SPeter Wemm struct thread *td; 83523eeeff7SPeter Wemm register struct freebsd4_sigaction_args *uap; 83623eeeff7SPeter Wemm { 83723eeeff7SPeter Wemm struct sigaction act, oact; 83823eeeff7SPeter Wemm register struct sigaction *actp, *oactp; 83923eeeff7SPeter Wemm int error; 84023eeeff7SPeter Wemm 84123eeeff7SPeter Wemm 84223eeeff7SPeter Wemm actp = (uap->act != NULL) ? &act : NULL; 84323eeeff7SPeter Wemm oactp = (uap->oact != NULL) ? &oact : NULL; 84423eeeff7SPeter Wemm if (actp) { 84523eeeff7SPeter Wemm error = copyin(uap->act, actp, sizeof(act)); 84623eeeff7SPeter Wemm if (error) 84744443757STim J. Robbins return (error); 84823eeeff7SPeter Wemm } 84923eeeff7SPeter Wemm error = kern_sigaction(td, uap->sig, actp, oactp, KSA_FREEBSD4); 850a14e1189SJohn Baldwin if (oactp && !error) 85123eeeff7SPeter Wemm error = copyout(oactp, uap->oact, sizeof(oact)); 85223eeeff7SPeter Wemm return (error); 85323eeeff7SPeter Wemm } 85423eeeff7SPeter Wemm #endif /* COMAPT_FREEBSD4 */ 85523eeeff7SPeter Wemm 85631c8f3f0SMarcel Moolenaar #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */ 8572c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_ 8582c42a146SMarcel Moolenaar struct osigaction_args { 8592c42a146SMarcel Moolenaar int signum; 8602c42a146SMarcel Moolenaar struct osigaction *nsa; 8612c42a146SMarcel Moolenaar struct osigaction *osa; 8622c42a146SMarcel Moolenaar }; 8632c42a146SMarcel Moolenaar #endif 8642c42a146SMarcel Moolenaar int 865b40ce416SJulian Elischer osigaction(td, uap) 866b40ce416SJulian Elischer struct thread *td; 8672c42a146SMarcel Moolenaar register struct osigaction_args *uap; 8682c42a146SMarcel Moolenaar { 8692c42a146SMarcel Moolenaar struct osigaction sa; 8702c42a146SMarcel Moolenaar struct sigaction nsa, osa; 8712c42a146SMarcel Moolenaar register struct sigaction *nsap, *osap; 8722c42a146SMarcel Moolenaar int error; 8732c42a146SMarcel Moolenaar 8746f841fb7SMarcel Moolenaar if (uap->signum <= 0 || uap->signum >= ONSIG) 8756f841fb7SMarcel Moolenaar return (EINVAL); 876fb99ab88SMatthew Dillon 8776f841fb7SMarcel Moolenaar nsap = (uap->nsa != NULL) ? &nsa : NULL; 8786f841fb7SMarcel Moolenaar osap = (uap->osa != NULL) ? &osa : NULL; 879fb99ab88SMatthew Dillon 8802c42a146SMarcel Moolenaar if (nsap) { 8816f841fb7SMarcel Moolenaar error = copyin(uap->nsa, &sa, sizeof(sa)); 8822c42a146SMarcel Moolenaar if (error) 88344443757STim J. Robbins return (error); 8842c42a146SMarcel Moolenaar nsap->sa_handler = sa.sa_handler; 8852c42a146SMarcel Moolenaar nsap->sa_flags = sa.sa_flags; 8862c42a146SMarcel Moolenaar OSIG2SIG(sa.sa_mask, nsap->sa_mask); 8872c42a146SMarcel Moolenaar } 88823eeeff7SPeter Wemm error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET); 8892c42a146SMarcel Moolenaar if (osap && !error) { 8902c42a146SMarcel Moolenaar sa.sa_handler = osap->sa_handler; 8912c42a146SMarcel Moolenaar sa.sa_flags = osap->sa_flags; 8922c42a146SMarcel Moolenaar SIG2OSIG(osap->sa_mask, sa.sa_mask); 8936f841fb7SMarcel Moolenaar error = copyout(&sa, uap->osa, sizeof(sa)); 8942c42a146SMarcel Moolenaar } 8952c42a146SMarcel Moolenaar return (error); 8962c42a146SMarcel Moolenaar } 89723eeeff7SPeter Wemm 89873dbd3daSJohn Baldwin #if !defined(__i386__) 89923eeeff7SPeter Wemm /* Avoid replicating the same stub everywhere */ 90023eeeff7SPeter Wemm int 90123eeeff7SPeter Wemm osigreturn(td, uap) 90223eeeff7SPeter Wemm struct thread *td; 90323eeeff7SPeter Wemm struct osigreturn_args *uap; 90423eeeff7SPeter Wemm { 90523eeeff7SPeter Wemm 90623eeeff7SPeter Wemm return (nosys(td, (struct nosys_args *)uap)); 90723eeeff7SPeter Wemm } 90823eeeff7SPeter Wemm #endif 90931c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */ 910df8bae1dSRodney W. Grimes 911df8bae1dSRodney W. Grimes /* 912df8bae1dSRodney W. Grimes * Initialize signal state for process 0; 913df8bae1dSRodney W. Grimes * set to ignore signals that are ignored by default. 914df8bae1dSRodney W. Grimes */ 915df8bae1dSRodney W. Grimes void 916df8bae1dSRodney W. Grimes siginit(p) 917df8bae1dSRodney W. Grimes struct proc *p; 918df8bae1dSRodney W. Grimes { 919df8bae1dSRodney W. Grimes register int i; 92090af4afaSJohn Baldwin struct sigacts *ps; 921df8bae1dSRodney W. Grimes 922628d2653SJohn Baldwin PROC_LOCK(p); 92390af4afaSJohn Baldwin ps = p->p_sigacts; 92490af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 9252c42a146SMarcel Moolenaar for (i = 1; i <= NSIG; i++) 9262c42a146SMarcel Moolenaar if (sigprop(i) & SA_IGNORE && i != SIGCONT) 92790af4afaSJohn Baldwin SIGADDSET(ps->ps_sigignore, i); 92890af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 929628d2653SJohn Baldwin PROC_UNLOCK(p); 930df8bae1dSRodney W. Grimes } 931df8bae1dSRodney W. Grimes 932df8bae1dSRodney W. Grimes /* 933df8bae1dSRodney W. Grimes * Reset signals for an exec of the specified process. 934df8bae1dSRodney W. Grimes */ 935df8bae1dSRodney W. Grimes void 936a30ec4b9SDavid Xu execsigs(struct proc *p) 937df8bae1dSRodney W. Grimes { 938a30ec4b9SDavid Xu struct sigacts *ps; 939a30ec4b9SDavid Xu int sig; 940a30ec4b9SDavid Xu struct thread *td; 941df8bae1dSRodney W. Grimes 942df8bae1dSRodney W. Grimes /* 943df8bae1dSRodney W. Grimes * Reset caught signals. Held signals remain held 9444093529dSJeff Roberson * through td_sigmask (unless they were caught, 945df8bae1dSRodney W. Grimes * and are now ignored by default). 946df8bae1dSRodney W. Grimes */ 9479b3b1c5fSJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 948a30ec4b9SDavid Xu td = FIRST_THREAD_IN_PROC(p); 949628d2653SJohn Baldwin ps = p->p_sigacts; 95090af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 95190af4afaSJohn Baldwin while (SIGNOTEMPTY(ps->ps_sigcatch)) { 95290af4afaSJohn Baldwin sig = sig_ffs(&ps->ps_sigcatch); 95390af4afaSJohn Baldwin SIGDELSET(ps->ps_sigcatch, sig); 9542c42a146SMarcel Moolenaar if (sigprop(sig) & SA_IGNORE) { 9552c42a146SMarcel Moolenaar if (sig != SIGCONT) 95690af4afaSJohn Baldwin SIGADDSET(ps->ps_sigignore, sig); 9579104847fSDavid Xu sigqueue_delete_proc(p, sig); 958df8bae1dSRodney W. Grimes } 9592c42a146SMarcel Moolenaar ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; 960df8bae1dSRodney W. Grimes } 961df8bae1dSRodney W. Grimes /* 962df8bae1dSRodney W. Grimes * Reset stack state to the user stack. 963df8bae1dSRodney W. Grimes * Clear set of signals caught on the signal stack. 964df8bae1dSRodney W. Grimes */ 965a30ec4b9SDavid Xu td->td_sigstk.ss_flags = SS_DISABLE; 966a30ec4b9SDavid Xu td->td_sigstk.ss_size = 0; 967a30ec4b9SDavid Xu td->td_sigstk.ss_sp = 0; 968a30ec4b9SDavid Xu td->td_pflags &= ~TDP_ALTSTACK; 96980e907a1SPeter Wemm /* 97080e907a1SPeter Wemm * Reset no zombies if child dies flag as Solaris does. 97180e907a1SPeter Wemm */ 97290af4afaSJohn Baldwin ps->ps_flag &= ~(PS_NOCLDWAIT | PS_CLDSIGIGN); 973c7fd62daSDavid Malone if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN) 974c7fd62daSDavid Malone ps->ps_sigact[_SIG_IDX(SIGCHLD)] = SIG_DFL; 97590af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 976df8bae1dSRodney W. Grimes } 977df8bae1dSRodney W. Grimes 978df8bae1dSRodney W. Grimes /* 979e77daab1SJohn Baldwin * kern_sigprocmask() 9807c8fdcbdSMatthew Dillon * 981628d2653SJohn Baldwin * Manipulate signal mask. 982df8bae1dSRodney W. Grimes */ 983e77daab1SJohn Baldwin int 984e77daab1SJohn Baldwin kern_sigprocmask(td, how, set, oset, old) 9854093529dSJeff Roberson struct thread *td; 9862c42a146SMarcel Moolenaar int how; 9872c42a146SMarcel Moolenaar sigset_t *set, *oset; 988645682fdSLuoqi Chen int old; 9892c42a146SMarcel Moolenaar { 9902c42a146SMarcel Moolenaar int error; 9912c42a146SMarcel Moolenaar 9924093529dSJeff Roberson PROC_LOCK(td->td_proc); 9932c42a146SMarcel Moolenaar if (oset != NULL) 9944093529dSJeff Roberson *oset = td->td_sigmask; 9952c42a146SMarcel Moolenaar 9962c42a146SMarcel Moolenaar error = 0; 9972c42a146SMarcel Moolenaar if (set != NULL) { 9982c42a146SMarcel Moolenaar switch (how) { 9992c42a146SMarcel Moolenaar case SIG_BLOCK: 1000645682fdSLuoqi Chen SIG_CANTMASK(*set); 10014093529dSJeff Roberson SIGSETOR(td->td_sigmask, *set); 10022c42a146SMarcel Moolenaar break; 10032c42a146SMarcel Moolenaar case SIG_UNBLOCK: 10044093529dSJeff Roberson SIGSETNAND(td->td_sigmask, *set); 10054093529dSJeff Roberson signotify(td); 10062c42a146SMarcel Moolenaar break; 10072c42a146SMarcel Moolenaar case SIG_SETMASK: 1008645682fdSLuoqi Chen SIG_CANTMASK(*set); 1009645682fdSLuoqi Chen if (old) 10104093529dSJeff Roberson SIGSETLO(td->td_sigmask, *set); 1011645682fdSLuoqi Chen else 10124093529dSJeff Roberson td->td_sigmask = *set; 10134093529dSJeff Roberson signotify(td); 10142c42a146SMarcel Moolenaar break; 10152c42a146SMarcel Moolenaar default: 10162c42a146SMarcel Moolenaar error = EINVAL; 10172c42a146SMarcel Moolenaar break; 10182c42a146SMarcel Moolenaar } 10192c42a146SMarcel Moolenaar } 10204093529dSJeff Roberson PROC_UNLOCK(td->td_proc); 10212c42a146SMarcel Moolenaar return (error); 10222c42a146SMarcel Moolenaar } 10232c42a146SMarcel Moolenaar 1024d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1025df8bae1dSRodney W. Grimes struct sigprocmask_args { 1026df8bae1dSRodney W. Grimes int how; 10272c42a146SMarcel Moolenaar const sigset_t *set; 10282c42a146SMarcel Moolenaar sigset_t *oset; 1029df8bae1dSRodney W. Grimes }; 1030d2d3e875SBruce Evans #endif 103126f9a767SRodney W. Grimes int 1032b40ce416SJulian Elischer sigprocmask(td, uap) 1033b40ce416SJulian Elischer register struct thread *td; 1034df8bae1dSRodney W. Grimes struct sigprocmask_args *uap; 1035df8bae1dSRodney W. Grimes { 10362c42a146SMarcel Moolenaar sigset_t set, oset; 10372c42a146SMarcel Moolenaar sigset_t *setp, *osetp; 10382c42a146SMarcel Moolenaar int error; 1039df8bae1dSRodney W. Grimes 10406f841fb7SMarcel Moolenaar setp = (uap->set != NULL) ? &set : NULL; 10416f841fb7SMarcel Moolenaar osetp = (uap->oset != NULL) ? &oset : NULL; 10422c42a146SMarcel Moolenaar if (setp) { 10436f841fb7SMarcel Moolenaar error = copyin(uap->set, setp, sizeof(set)); 10442c42a146SMarcel Moolenaar if (error) 10452c42a146SMarcel Moolenaar return (error); 1046df8bae1dSRodney W. Grimes } 1047e77daab1SJohn Baldwin error = kern_sigprocmask(td, uap->how, setp, osetp, 0); 10482c42a146SMarcel Moolenaar if (osetp && !error) { 10496f841fb7SMarcel Moolenaar error = copyout(osetp, uap->oset, sizeof(oset)); 10502c42a146SMarcel Moolenaar } 10512c42a146SMarcel Moolenaar return (error); 10522c42a146SMarcel Moolenaar } 10532c42a146SMarcel Moolenaar 105431c8f3f0SMarcel Moolenaar #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */ 10552c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_ 10562c42a146SMarcel Moolenaar struct osigprocmask_args { 10572c42a146SMarcel Moolenaar int how; 10582c42a146SMarcel Moolenaar osigset_t mask; 10592c42a146SMarcel Moolenaar }; 10602c42a146SMarcel Moolenaar #endif 10612c42a146SMarcel Moolenaar int 1062b40ce416SJulian Elischer osigprocmask(td, uap) 1063b40ce416SJulian Elischer register struct thread *td; 10642c42a146SMarcel Moolenaar struct osigprocmask_args *uap; 10652c42a146SMarcel Moolenaar { 10662c42a146SMarcel Moolenaar sigset_t set, oset; 10672c42a146SMarcel Moolenaar int error; 10682c42a146SMarcel Moolenaar 10692c42a146SMarcel Moolenaar OSIG2SIG(uap->mask, set); 1070e77daab1SJohn Baldwin error = kern_sigprocmask(td, uap->how, &set, &oset, 1); 1071b40ce416SJulian Elischer SIG2OSIG(oset, td->td_retval[0]); 1072df8bae1dSRodney W. Grimes return (error); 1073df8bae1dSRodney W. Grimes } 107431c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */ 1075df8bae1dSRodney W. Grimes 107626f9a767SRodney W. Grimes int 1077a447cd8bSJeff Roberson sigwait(struct thread *td, struct sigwait_args *uap) 1078a447cd8bSJeff Roberson { 10799104847fSDavid Xu ksiginfo_t ksi; 1080a447cd8bSJeff Roberson sigset_t set; 1081a447cd8bSJeff Roberson int error; 1082a447cd8bSJeff Roberson 1083a447cd8bSJeff Roberson error = copyin(uap->set, &set, sizeof(set)); 108436939a0aSDavid Xu if (error) { 108536939a0aSDavid Xu td->td_retval[0] = error; 108636939a0aSDavid Xu return (0); 108736939a0aSDavid Xu } 1088a447cd8bSJeff Roberson 10899104847fSDavid Xu error = kern_sigtimedwait(td, set, &ksi, NULL); 109036939a0aSDavid Xu if (error) { 109136939a0aSDavid Xu if (error == ERESTART) 1092a447cd8bSJeff Roberson return (error); 109336939a0aSDavid Xu td->td_retval[0] = error; 109436939a0aSDavid Xu return (0); 109536939a0aSDavid Xu } 1096a447cd8bSJeff Roberson 10979104847fSDavid Xu error = copyout(&ksi.ksi_signo, uap->sig, sizeof(ksi.ksi_signo)); 109836939a0aSDavid Xu td->td_retval[0] = error; 109936939a0aSDavid Xu return (0); 1100a447cd8bSJeff Roberson } 11010c14ff0eSRobert Watson 1102a447cd8bSJeff Roberson int 1103a447cd8bSJeff Roberson sigtimedwait(struct thread *td, struct sigtimedwait_args *uap) 1104a447cd8bSJeff Roberson { 1105a447cd8bSJeff Roberson struct timespec ts; 1106a447cd8bSJeff Roberson struct timespec *timeout; 1107a447cd8bSJeff Roberson sigset_t set; 11089104847fSDavid Xu ksiginfo_t ksi; 1109a447cd8bSJeff Roberson int error; 1110a447cd8bSJeff Roberson 1111a447cd8bSJeff Roberson if (uap->timeout) { 1112a447cd8bSJeff Roberson error = copyin(uap->timeout, &ts, sizeof(ts)); 1113a447cd8bSJeff Roberson if (error) 1114a447cd8bSJeff Roberson return (error); 1115a447cd8bSJeff Roberson 1116a447cd8bSJeff Roberson timeout = &ts; 1117a447cd8bSJeff Roberson } else 1118a447cd8bSJeff Roberson timeout = NULL; 1119a447cd8bSJeff Roberson 1120a447cd8bSJeff Roberson error = copyin(uap->set, &set, sizeof(set)); 1121a447cd8bSJeff Roberson if (error) 1122a447cd8bSJeff Roberson return (error); 1123a447cd8bSJeff Roberson 11249104847fSDavid Xu error = kern_sigtimedwait(td, set, &ksi, timeout); 1125a447cd8bSJeff Roberson if (error) 1126a447cd8bSJeff Roberson return (error); 11279dde3bc9SDavid Xu 1128418228dfSDavid Xu if (uap->info) 11299104847fSDavid Xu error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t)); 11309104847fSDavid Xu 11319104847fSDavid Xu if (error == 0) 11329104847fSDavid Xu td->td_retval[0] = ksi.ksi_signo; 1133a447cd8bSJeff Roberson return (error); 1134a447cd8bSJeff Roberson } 1135a447cd8bSJeff Roberson 1136a447cd8bSJeff Roberson int 1137a447cd8bSJeff Roberson sigwaitinfo(struct thread *td, struct sigwaitinfo_args *uap) 1138a447cd8bSJeff Roberson { 11399104847fSDavid Xu ksiginfo_t ksi; 1140a447cd8bSJeff Roberson sigset_t set; 1141a447cd8bSJeff Roberson int error; 1142a447cd8bSJeff Roberson 1143a447cd8bSJeff Roberson error = copyin(uap->set, &set, sizeof(set)); 1144a447cd8bSJeff Roberson if (error) 1145a447cd8bSJeff Roberson return (error); 1146a447cd8bSJeff Roberson 11479104847fSDavid Xu error = kern_sigtimedwait(td, set, &ksi, NULL); 1148a447cd8bSJeff Roberson if (error) 1149a447cd8bSJeff Roberson return (error); 1150a447cd8bSJeff Roberson 1151418228dfSDavid Xu if (uap->info) 11529104847fSDavid Xu error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t)); 11539104847fSDavid Xu 11549104847fSDavid Xu if (error == 0) 11559104847fSDavid Xu td->td_retval[0] = ksi.ksi_signo; 1156a447cd8bSJeff Roberson return (error); 1157a447cd8bSJeff Roberson } 1158a447cd8bSJeff Roberson 1159c6511aeaSDavid Xu int 11609104847fSDavid Xu kern_sigtimedwait(struct thread *td, sigset_t waitset, ksiginfo_t *ksi, 1161a447cd8bSJeff Roberson struct timespec *timeout) 1162a447cd8bSJeff Roberson { 11633074d1b4SDavid Xu struct sigacts *ps; 11646675b36eSDavid Xu sigset_t savedmask; 1165a447cd8bSJeff Roberson struct proc *p; 11661089f031SDavid Xu int error, sig, hz, i, timevalid = 0; 11671089f031SDavid Xu struct timespec rts, ets, ts; 11681089f031SDavid Xu struct timeval tv; 1169a447cd8bSJeff Roberson 1170a447cd8bSJeff Roberson p = td->td_proc; 1171a447cd8bSJeff Roberson error = 0; 1172a447cd8bSJeff Roberson sig = 0; 11733074d1b4SDavid Xu SIG_CANTMASK(waitset); 1174a447cd8bSJeff Roberson 1175a447cd8bSJeff Roberson PROC_LOCK(p); 1176a447cd8bSJeff Roberson ps = p->p_sigacts; 11773074d1b4SDavid Xu savedmask = td->td_sigmask; 11781089f031SDavid Xu if (timeout) { 11791089f031SDavid Xu if (timeout->tv_nsec >= 0 && timeout->tv_nsec < 1000000000) { 11801089f031SDavid Xu timevalid = 1; 11811089f031SDavid Xu getnanouptime(&rts); 11821089f031SDavid Xu ets = rts; 11831089f031SDavid Xu timespecadd(&ets, timeout); 11841089f031SDavid Xu } 11851089f031SDavid Xu } 11863074d1b4SDavid Xu 11877e0221a2SDavid Xu restart: 11883074d1b4SDavid Xu for (i = 1; i <= _SIG_MAXSIG; ++i) { 11893074d1b4SDavid Xu if (!SIGISMEMBER(waitset, i)) 11903074d1b4SDavid Xu continue; 11917e0221a2SDavid Xu if (!SIGISMEMBER(td->td_sigqueue.sq_signals, i)) { 11927e0221a2SDavid Xu if (SIGISMEMBER(p->p_sigqueue.sq_signals, i)) { 11938460a577SJohn Birrell #ifdef KSE 11943074d1b4SDavid Xu if (p->p_flag & P_SA) { 11953074d1b4SDavid Xu p->p_flag |= P_SIGEVENT; 11963074d1b4SDavid Xu wakeup(&p->p_siglist); 11973074d1b4SDavid Xu } 11988460a577SJohn Birrell #endif 11997e0221a2SDavid Xu sigqueue_move(&p->p_sigqueue, 12007e0221a2SDavid Xu &td->td_sigqueue, i); 12017e0221a2SDavid Xu } else 12027e0221a2SDavid Xu continue; 12037e0221a2SDavid Xu } 12047e0221a2SDavid Xu 12053074d1b4SDavid Xu SIGFILLSET(td->td_sigmask); 12063074d1b4SDavid Xu SIG_CANTMASK(td->td_sigmask); 12073074d1b4SDavid Xu SIGDELSET(td->td_sigmask, i); 12083074d1b4SDavid Xu mtx_lock(&ps->ps_mtx); 12093074d1b4SDavid Xu sig = cursig(td); 12103074d1b4SDavid Xu mtx_unlock(&ps->ps_mtx); 12116675b36eSDavid Xu if (sig) 1212a447cd8bSJeff Roberson goto out; 12137e0221a2SDavid Xu else { 12147e0221a2SDavid Xu /* 12157e0221a2SDavid Xu * Because cursig() may have stopped current thread, 12167e0221a2SDavid Xu * after it is resumed, things may have already been 12177e0221a2SDavid Xu * changed, it should rescan any pending signals. 12187e0221a2SDavid Xu */ 12197e0221a2SDavid Xu goto restart; 12203074d1b4SDavid Xu } 12217e0221a2SDavid Xu } 12227e0221a2SDavid Xu 12233074d1b4SDavid Xu if (error) 12243074d1b4SDavid Xu goto out; 12253074d1b4SDavid Xu 1226a447cd8bSJeff Roberson /* 1227a447cd8bSJeff Roberson * POSIX says this must be checked after looking for pending 1228a447cd8bSJeff Roberson * signals. 1229a447cd8bSJeff Roberson */ 1230a447cd8bSJeff Roberson if (timeout) { 12311089f031SDavid Xu if (!timevalid) { 1232a447cd8bSJeff Roberson error = EINVAL; 1233a447cd8bSJeff Roberson goto out; 1234a447cd8bSJeff Roberson } 12351089f031SDavid Xu getnanouptime(&rts); 12361089f031SDavid Xu if (timespeccmp(&rts, &ets, >=)) { 12373074d1b4SDavid Xu error = EAGAIN; 12383074d1b4SDavid Xu goto out; 12393074d1b4SDavid Xu } 12401089f031SDavid Xu ts = ets; 12411089f031SDavid Xu timespecsub(&ts, &rts); 12421089f031SDavid Xu TIMESPEC_TO_TIMEVAL(&tv, &ts); 1243a447cd8bSJeff Roberson hz = tvtohz(&tv); 1244a447cd8bSJeff Roberson } else 1245a447cd8bSJeff Roberson hz = 0; 1246a447cd8bSJeff Roberson 12476675b36eSDavid Xu td->td_sigmask = savedmask; 12486675b36eSDavid Xu SIGSETNAND(td->td_sigmask, waitset); 12496675b36eSDavid Xu signotify(td); 125086b5e563SDag-Erling Smørgrav error = msleep(&ps, &p->p_mtx, PPAUSE|PCATCH, "sigwait", hz); 12511089f031SDavid Xu if (timeout) { 12521089f031SDavid Xu if (error == ERESTART) { 12531089f031SDavid Xu /* timeout can not be restarted. */ 12543074d1b4SDavid Xu error = EINTR; 12551089f031SDavid Xu } else if (error == EAGAIN) { 12561089f031SDavid Xu /* will calculate timeout by ourself. */ 12571089f031SDavid Xu error = 0; 12581089f031SDavid Xu } 12591089f031SDavid Xu } 12607e0221a2SDavid Xu goto restart; 12619dde3bc9SDavid Xu 1262a447cd8bSJeff Roberson out: 12637e0221a2SDavid Xu td->td_sigmask = savedmask; 12647e0221a2SDavid Xu signotify(td); 1265a447cd8bSJeff Roberson if (sig) { 12665da49fcbSDavid Xu ksiginfo_init(ksi); 12679104847fSDavid Xu sigqueue_get(&td->td_sigqueue, sig, ksi); 12689104847fSDavid Xu ksi->ksi_signo = sig; 126956c06c4bSDavid Xu if (ksi->ksi_code == SI_TIMER) 127056c06c4bSDavid Xu itimer_accept(p, ksi->ksi_timerid, ksi); 12713074d1b4SDavid Xu error = 0; 12727e0221a2SDavid Xu 12737e0221a2SDavid Xu #ifdef KTRACE 12747e0221a2SDavid Xu if (KTRPOINT(td, KTR_PSIG)) { 12757e0221a2SDavid Xu sig_t action; 12767e0221a2SDavid Xu 12773074d1b4SDavid Xu mtx_lock(&ps->ps_mtx); 1278a447cd8bSJeff Roberson action = ps->ps_sigact[_SIG_IDX(sig)]; 127990af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 12803074d1b4SDavid Xu ktrpsig(sig, action, &td->td_sigmask, 0); 12817e0221a2SDavid Xu } 1282a447cd8bSJeff Roberson #endif 12837b8d5e48SDavid Xu if (sig == SIGKILL) 12847e0221a2SDavid Xu sigexit(td, sig); 12853074d1b4SDavid Xu } 1286a447cd8bSJeff Roberson PROC_UNLOCK(p); 1287a447cd8bSJeff Roberson return (error); 1288a447cd8bSJeff Roberson } 1289a447cd8bSJeff Roberson 12909104847fSDavid Xu #ifndef _SYS_SYSPROTO_H_ 12919104847fSDavid Xu struct sigpending_args { 12929104847fSDavid Xu sigset_t *set; 12939104847fSDavid Xu }; 12949104847fSDavid Xu #endif 1295a447cd8bSJeff Roberson int 1296b40ce416SJulian Elischer sigpending(td, uap) 1297b40ce416SJulian Elischer struct thread *td; 1298df8bae1dSRodney W. Grimes struct sigpending_args *uap; 1299df8bae1dSRodney W. Grimes { 1300b40ce416SJulian Elischer struct proc *p = td->td_proc; 13019104847fSDavid Xu sigset_t pending; 1302df8bae1dSRodney W. Grimes 1303628d2653SJohn Baldwin PROC_LOCK(p); 13049104847fSDavid Xu pending = p->p_sigqueue.sq_signals; 13059104847fSDavid Xu SIGSETOR(pending, td->td_sigqueue.sq_signals); 1306628d2653SJohn Baldwin PROC_UNLOCK(p); 13079104847fSDavid Xu return (copyout(&pending, uap->set, sizeof(sigset_t))); 13082c42a146SMarcel Moolenaar } 13092c42a146SMarcel Moolenaar 131031c8f3f0SMarcel Moolenaar #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */ 13112c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_ 13122c42a146SMarcel Moolenaar struct osigpending_args { 13132c42a146SMarcel Moolenaar int dummy; 13142c42a146SMarcel Moolenaar }; 13152c42a146SMarcel Moolenaar #endif 13162c42a146SMarcel Moolenaar int 1317b40ce416SJulian Elischer osigpending(td, uap) 1318b40ce416SJulian Elischer struct thread *td; 13192c42a146SMarcel Moolenaar struct osigpending_args *uap; 13202c42a146SMarcel Moolenaar { 1321b40ce416SJulian Elischer struct proc *p = td->td_proc; 13229104847fSDavid Xu sigset_t pending; 1323b40ce416SJulian Elischer 1324628d2653SJohn Baldwin PROC_LOCK(p); 13259104847fSDavid Xu pending = p->p_sigqueue.sq_signals; 13269104847fSDavid Xu SIGSETOR(pending, td->td_sigqueue.sq_signals); 1327628d2653SJohn Baldwin PROC_UNLOCK(p); 13289104847fSDavid Xu SIG2OSIG(pending, td->td_retval[0]); 1329df8bae1dSRodney W. Grimes return (0); 1330df8bae1dSRodney W. Grimes } 133131c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */ 1332df8bae1dSRodney W. Grimes 13331930e303SPoul-Henning Kamp #if defined(COMPAT_43) 1334df8bae1dSRodney W. Grimes /* 1335df8bae1dSRodney W. Grimes * Generalized interface signal handler, 4.3-compatible. 1336df8bae1dSRodney W. Grimes */ 1337d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1338df8bae1dSRodney W. Grimes struct osigvec_args { 1339df8bae1dSRodney W. Grimes int signum; 1340df8bae1dSRodney W. Grimes struct sigvec *nsv; 1341df8bae1dSRodney W. Grimes struct sigvec *osv; 1342df8bae1dSRodney W. Grimes }; 1343d2d3e875SBruce Evans #endif 1344df8bae1dSRodney W. Grimes /* ARGSUSED */ 134526f9a767SRodney W. Grimes int 1346b40ce416SJulian Elischer osigvec(td, uap) 1347b40ce416SJulian Elischer struct thread *td; 1348df8bae1dSRodney W. Grimes register struct osigvec_args *uap; 1349df8bae1dSRodney W. Grimes { 1350df8bae1dSRodney W. Grimes struct sigvec vec; 13512c42a146SMarcel Moolenaar struct sigaction nsa, osa; 13522c42a146SMarcel Moolenaar register struct sigaction *nsap, *osap; 13532c42a146SMarcel Moolenaar int error; 1354df8bae1dSRodney W. Grimes 13556f841fb7SMarcel Moolenaar if (uap->signum <= 0 || uap->signum >= ONSIG) 13566f841fb7SMarcel Moolenaar return (EINVAL); 13576f841fb7SMarcel Moolenaar nsap = (uap->nsv != NULL) ? &nsa : NULL; 13586f841fb7SMarcel Moolenaar osap = (uap->osv != NULL) ? &osa : NULL; 13592c42a146SMarcel Moolenaar if (nsap) { 13606f841fb7SMarcel Moolenaar error = copyin(uap->nsv, &vec, sizeof(vec)); 13612c42a146SMarcel Moolenaar if (error) 1362df8bae1dSRodney W. Grimes return (error); 13632c42a146SMarcel Moolenaar nsap->sa_handler = vec.sv_handler; 13642c42a146SMarcel Moolenaar OSIG2SIG(vec.sv_mask, nsap->sa_mask); 13652c42a146SMarcel Moolenaar nsap->sa_flags = vec.sv_flags; 13662c42a146SMarcel Moolenaar nsap->sa_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */ 1367df8bae1dSRodney W. Grimes } 13685edadff9SJohn Baldwin error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET); 13692c42a146SMarcel Moolenaar if (osap && !error) { 13702c42a146SMarcel Moolenaar vec.sv_handler = osap->sa_handler; 13712c42a146SMarcel Moolenaar SIG2OSIG(osap->sa_mask, vec.sv_mask); 13722c42a146SMarcel Moolenaar vec.sv_flags = osap->sa_flags; 13732c42a146SMarcel Moolenaar vec.sv_flags &= ~SA_NOCLDWAIT; 13742c42a146SMarcel Moolenaar vec.sv_flags ^= SA_RESTART; 13756f841fb7SMarcel Moolenaar error = copyout(&vec, uap->osv, sizeof(vec)); 13762c42a146SMarcel Moolenaar } 13772c42a146SMarcel Moolenaar return (error); 1378df8bae1dSRodney W. Grimes } 1379df8bae1dSRodney W. Grimes 1380d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1381df8bae1dSRodney W. Grimes struct osigblock_args { 1382df8bae1dSRodney W. Grimes int mask; 1383df8bae1dSRodney W. Grimes }; 1384d2d3e875SBruce Evans #endif 138526f9a767SRodney W. Grimes int 1386b40ce416SJulian Elischer osigblock(td, uap) 1387b40ce416SJulian Elischer register struct thread *td; 1388df8bae1dSRodney W. Grimes struct osigblock_args *uap; 1389df8bae1dSRodney W. Grimes { 1390b40ce416SJulian Elischer struct proc *p = td->td_proc; 13912c42a146SMarcel Moolenaar sigset_t set; 1392df8bae1dSRodney W. Grimes 13932c42a146SMarcel Moolenaar OSIG2SIG(uap->mask, set); 13942c42a146SMarcel Moolenaar SIG_CANTMASK(set); 1395628d2653SJohn Baldwin PROC_LOCK(p); 13964093529dSJeff Roberson SIG2OSIG(td->td_sigmask, td->td_retval[0]); 13974093529dSJeff Roberson SIGSETOR(td->td_sigmask, set); 1398628d2653SJohn Baldwin PROC_UNLOCK(p); 1399df8bae1dSRodney W. Grimes return (0); 1400df8bae1dSRodney W. Grimes } 1401df8bae1dSRodney W. Grimes 1402d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1403df8bae1dSRodney W. Grimes struct osigsetmask_args { 1404df8bae1dSRodney W. Grimes int mask; 1405df8bae1dSRodney W. Grimes }; 1406d2d3e875SBruce Evans #endif 140726f9a767SRodney W. Grimes int 1408b40ce416SJulian Elischer osigsetmask(td, uap) 1409b40ce416SJulian Elischer struct thread *td; 1410df8bae1dSRodney W. Grimes struct osigsetmask_args *uap; 1411df8bae1dSRodney W. Grimes { 1412b40ce416SJulian Elischer struct proc *p = td->td_proc; 14132c42a146SMarcel Moolenaar sigset_t set; 1414df8bae1dSRodney W. Grimes 14152c42a146SMarcel Moolenaar OSIG2SIG(uap->mask, set); 14162c42a146SMarcel Moolenaar SIG_CANTMASK(set); 1417628d2653SJohn Baldwin PROC_LOCK(p); 14184093529dSJeff Roberson SIG2OSIG(td->td_sigmask, td->td_retval[0]); 14194093529dSJeff Roberson SIGSETLO(td->td_sigmask, set); 14204093529dSJeff Roberson signotify(td); 1421628d2653SJohn Baldwin PROC_UNLOCK(p); 1422df8bae1dSRodney W. Grimes return (0); 1423df8bae1dSRodney W. Grimes } 14241930e303SPoul-Henning Kamp #endif /* COMPAT_43 */ 1425df8bae1dSRodney W. Grimes 1426df8bae1dSRodney W. Grimes /* 1427873fbcd7SRobert Watson * Suspend calling thread until signal, providing mask to be set in the 1428873fbcd7SRobert Watson * meantime. 1429df8bae1dSRodney W. Grimes */ 1430d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1431df8bae1dSRodney W. Grimes struct sigsuspend_args { 14322c42a146SMarcel Moolenaar const sigset_t *sigmask; 1433df8bae1dSRodney W. Grimes }; 1434d2d3e875SBruce Evans #endif 1435df8bae1dSRodney W. Grimes /* ARGSUSED */ 143626f9a767SRodney W. Grimes int 1437b40ce416SJulian Elischer sigsuspend(td, uap) 1438b40ce416SJulian Elischer struct thread *td; 1439df8bae1dSRodney W. Grimes struct sigsuspend_args *uap; 1440df8bae1dSRodney W. Grimes { 14412c42a146SMarcel Moolenaar sigset_t mask; 14422c42a146SMarcel Moolenaar int error; 14432c42a146SMarcel Moolenaar 14446f841fb7SMarcel Moolenaar error = copyin(uap->sigmask, &mask, sizeof(mask)); 14452c42a146SMarcel Moolenaar if (error) 14462c42a146SMarcel Moolenaar return (error); 14478f19eb88SIan Dowse return (kern_sigsuspend(td, mask)); 14488f19eb88SIan Dowse } 14498f19eb88SIan Dowse 14508f19eb88SIan Dowse int 14518f19eb88SIan Dowse kern_sigsuspend(struct thread *td, sigset_t mask) 14528f19eb88SIan Dowse { 14538f19eb88SIan Dowse struct proc *p = td->td_proc; 1454df8bae1dSRodney W. Grimes 1455df8bae1dSRodney W. Grimes /* 1456645682fdSLuoqi Chen * When returning from sigsuspend, we want 1457df8bae1dSRodney W. Grimes * the old mask to be restored after the 1458df8bae1dSRodney W. Grimes * signal handler has finished. Thus, we 1459df8bae1dSRodney W. Grimes * save it here and mark the sigacts structure 1460df8bae1dSRodney W. Grimes * to indicate this. 1461df8bae1dSRodney W. Grimes */ 1462628d2653SJohn Baldwin PROC_LOCK(p); 14634093529dSJeff Roberson td->td_oldsigmask = td->td_sigmask; 14645e26dcb5SJohn Baldwin td->td_pflags |= TDP_OLDMASK; 1465645682fdSLuoqi Chen SIG_CANTMASK(mask); 14664093529dSJeff Roberson td->td_sigmask = mask; 14674093529dSJeff Roberson signotify(td); 146886b5e563SDag-Erling Smørgrav while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "pause", 0) == 0) 14692c42a146SMarcel Moolenaar /* void */; 1470628d2653SJohn Baldwin PROC_UNLOCK(p); 14712c42a146SMarcel Moolenaar /* always return EINTR rather than ERESTART... */ 14722c42a146SMarcel Moolenaar return (EINTR); 14732c42a146SMarcel Moolenaar } 14742c42a146SMarcel Moolenaar 147531c8f3f0SMarcel Moolenaar #ifdef COMPAT_43 /* XXX - COMPAT_FBSD3 */ 147697563428SAlexander Kabaev /* 147797563428SAlexander Kabaev * Compatibility sigsuspend call for old binaries. Note nonstandard calling 147897563428SAlexander Kabaev * convention: libc stub passes mask, not pointer, to save a copyin. 147997563428SAlexander Kabaev */ 14802c42a146SMarcel Moolenaar #ifndef _SYS_SYSPROTO_H_ 14812c42a146SMarcel Moolenaar struct osigsuspend_args { 14822c42a146SMarcel Moolenaar osigset_t mask; 14832c42a146SMarcel Moolenaar }; 14842c42a146SMarcel Moolenaar #endif 14852c42a146SMarcel Moolenaar /* ARGSUSED */ 14862c42a146SMarcel Moolenaar int 1487b40ce416SJulian Elischer osigsuspend(td, uap) 1488b40ce416SJulian Elischer struct thread *td; 14892c42a146SMarcel Moolenaar struct osigsuspend_args *uap; 14902c42a146SMarcel Moolenaar { 1491b40ce416SJulian Elischer struct proc *p = td->td_proc; 1492645682fdSLuoqi Chen sigset_t mask; 14932c42a146SMarcel Moolenaar 1494628d2653SJohn Baldwin PROC_LOCK(p); 14954093529dSJeff Roberson td->td_oldsigmask = td->td_sigmask; 14965e26dcb5SJohn Baldwin td->td_pflags |= TDP_OLDMASK; 1497645682fdSLuoqi Chen OSIG2SIG(uap->mask, mask); 1498645682fdSLuoqi Chen SIG_CANTMASK(mask); 14994093529dSJeff Roberson SIGSETLO(td->td_sigmask, mask); 15004093529dSJeff Roberson signotify(td); 150186b5e563SDag-Erling Smørgrav while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "opause", 0) == 0) 1502df8bae1dSRodney W. Grimes /* void */; 1503628d2653SJohn Baldwin PROC_UNLOCK(p); 1504df8bae1dSRodney W. Grimes /* always return EINTR rather than ERESTART... */ 1505df8bae1dSRodney W. Grimes return (EINTR); 1506df8bae1dSRodney W. Grimes } 150731c8f3f0SMarcel Moolenaar #endif /* COMPAT_43 */ 1508df8bae1dSRodney W. Grimes 15091930e303SPoul-Henning Kamp #if defined(COMPAT_43) 1510d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1511df8bae1dSRodney W. Grimes struct osigstack_args { 1512df8bae1dSRodney W. Grimes struct sigstack *nss; 1513df8bae1dSRodney W. Grimes struct sigstack *oss; 1514df8bae1dSRodney W. Grimes }; 1515d2d3e875SBruce Evans #endif 1516df8bae1dSRodney W. Grimes /* ARGSUSED */ 151726f9a767SRodney W. Grimes int 1518b40ce416SJulian Elischer osigstack(td, uap) 1519b40ce416SJulian Elischer struct thread *td; 1520df8bae1dSRodney W. Grimes register struct osigstack_args *uap; 1521df8bae1dSRodney W. Grimes { 15225afe0c99SJohn Baldwin struct sigstack nss, oss; 1523fb99ab88SMatthew Dillon int error = 0; 1524fb99ab88SMatthew Dillon 1525d034d459SMarcel Moolenaar if (uap->nss != NULL) { 15265afe0c99SJohn Baldwin error = copyin(uap->nss, &nss, sizeof(nss)); 15275afe0c99SJohn Baldwin if (error) 15285afe0c99SJohn Baldwin return (error); 1529df8bae1dSRodney W. Grimes } 1530a30ec4b9SDavid Xu oss.ss_sp = td->td_sigstk.ss_sp; 15315afe0c99SJohn Baldwin oss.ss_onstack = sigonstack(cpu_getstack(td)); 15325afe0c99SJohn Baldwin if (uap->nss != NULL) { 1533a30ec4b9SDavid Xu td->td_sigstk.ss_sp = nss.ss_sp; 1534a30ec4b9SDavid Xu td->td_sigstk.ss_size = 0; 1535a30ec4b9SDavid Xu td->td_sigstk.ss_flags |= nss.ss_onstack & SS_ONSTACK; 1536a30ec4b9SDavid Xu td->td_pflags |= TDP_ALTSTACK; 15375afe0c99SJohn Baldwin } 15385afe0c99SJohn Baldwin if (uap->oss != NULL) 15395afe0c99SJohn Baldwin error = copyout(&oss, uap->oss, sizeof(oss)); 15405afe0c99SJohn Baldwin 1541fb99ab88SMatthew Dillon return (error); 1542df8bae1dSRodney W. Grimes } 15431930e303SPoul-Henning Kamp #endif /* COMPAT_43 */ 1544df8bae1dSRodney W. Grimes 1545d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1546df8bae1dSRodney W. Grimes struct sigaltstack_args { 15472c42a146SMarcel Moolenaar stack_t *ss; 15482c42a146SMarcel Moolenaar stack_t *oss; 1549df8bae1dSRodney W. Grimes }; 1550d2d3e875SBruce Evans #endif 1551df8bae1dSRodney W. Grimes /* ARGSUSED */ 155226f9a767SRodney W. Grimes int 1553b40ce416SJulian Elischer sigaltstack(td, uap) 1554b40ce416SJulian Elischer struct thread *td; 1555df8bae1dSRodney W. Grimes register struct sigaltstack_args *uap; 1556df8bae1dSRodney W. Grimes { 15578f19eb88SIan Dowse stack_t ss, oss; 15588f19eb88SIan Dowse int error; 15598f19eb88SIan Dowse 15608f19eb88SIan Dowse if (uap->ss != NULL) { 15618f19eb88SIan Dowse error = copyin(uap->ss, &ss, sizeof(ss)); 15628f19eb88SIan Dowse if (error) 15638f19eb88SIan Dowse return (error); 15648f19eb88SIan Dowse } 15658f19eb88SIan Dowse error = kern_sigaltstack(td, (uap->ss != NULL) ? &ss : NULL, 15668f19eb88SIan Dowse (uap->oss != NULL) ? &oss : NULL); 15678f19eb88SIan Dowse if (error) 15688f19eb88SIan Dowse return (error); 15698f19eb88SIan Dowse if (uap->oss != NULL) 15708f19eb88SIan Dowse error = copyout(&oss, uap->oss, sizeof(stack_t)); 15718f19eb88SIan Dowse return (error); 15728f19eb88SIan Dowse } 15738f19eb88SIan Dowse 15748f19eb88SIan Dowse int 15758f19eb88SIan Dowse kern_sigaltstack(struct thread *td, stack_t *ss, stack_t *oss) 15768f19eb88SIan Dowse { 1577b40ce416SJulian Elischer struct proc *p = td->td_proc; 1578fb99ab88SMatthew Dillon int oonstack; 1579fb99ab88SMatthew Dillon 1580b40ce416SJulian Elischer oonstack = sigonstack(cpu_getstack(td)); 1581d034d459SMarcel Moolenaar 15828f19eb88SIan Dowse if (oss != NULL) { 1583a30ec4b9SDavid Xu *oss = td->td_sigstk; 1584a30ec4b9SDavid Xu oss->ss_flags = (td->td_pflags & TDP_ALTSTACK) 1585d034d459SMarcel Moolenaar ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE; 1586df8bae1dSRodney W. Grimes } 1587d034d459SMarcel Moolenaar 15888f19eb88SIan Dowse if (ss != NULL) { 1589a30ec4b9SDavid Xu if (oonstack) 1590cf60731bSJohn Baldwin return (EPERM); 1591a30ec4b9SDavid Xu if ((ss->ss_flags & ~SS_DISABLE) != 0) 1592cf60731bSJohn Baldwin return (EINVAL); 15938f19eb88SIan Dowse if (!(ss->ss_flags & SS_DISABLE)) { 15949104847fSDavid Xu if (ss->ss_size < p->p_sysent->sv_minsigstksz) 1595cf60731bSJohn Baldwin return (ENOMEM); 15969104847fSDavid Xu 1597a30ec4b9SDavid Xu td->td_sigstk = *ss; 1598a30ec4b9SDavid Xu td->td_pflags |= TDP_ALTSTACK; 1599628d2653SJohn Baldwin } else { 1600a30ec4b9SDavid Xu td->td_pflags &= ~TDP_ALTSTACK; 1601628d2653SJohn Baldwin } 1602d034d459SMarcel Moolenaar } 1603cf60731bSJohn Baldwin return (0); 1604df8bae1dSRodney W. Grimes } 1605df8bae1dSRodney W. Grimes 1606d93f860cSPoul-Henning Kamp /* 1607d93f860cSPoul-Henning Kamp * Common code for kill process group/broadcast kill. 1608d93f860cSPoul-Henning Kamp * cp is calling process. 1609d93f860cSPoul-Henning Kamp */ 161037c84183SPoul-Henning Kamp static int 16111a88a252SMaxim Sobolev killpg1(td, sig, pgid, all) 16129c1ab3e0SJohn Baldwin register struct thread *td; 16131a88a252SMaxim Sobolev int sig, pgid, all; 1614d93f860cSPoul-Henning Kamp { 1615d93f860cSPoul-Henning Kamp register struct proc *p; 1616d93f860cSPoul-Henning Kamp struct pgrp *pgrp; 1617d93f860cSPoul-Henning Kamp int nfound = 0; 1618d93f860cSPoul-Henning Kamp 1619553629ebSJake Burkholder if (all) { 1620d93f860cSPoul-Henning Kamp /* 1621d93f860cSPoul-Henning Kamp * broadcast 1622d93f860cSPoul-Henning Kamp */ 16231005a129SJohn Baldwin sx_slock(&allproc_lock); 16244f506694SXin LI FOREACH_PROC_IN_SYSTEM(p) { 1625628d2653SJohn Baldwin PROC_LOCK(p); 16269c1ab3e0SJohn Baldwin if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || 162795f16c1eSPaul Saab p == td->td_proc || p->p_state == PRS_NEW) { 1628628d2653SJohn Baldwin PROC_UNLOCK(p); 1629628d2653SJohn Baldwin continue; 1630628d2653SJohn Baldwin } 16311a88a252SMaxim Sobolev if (p_cansignal(td, p, sig) == 0) { 1632d93f860cSPoul-Henning Kamp nfound++; 163333a9ed9dSJohn Baldwin if (sig) 16342c42a146SMarcel Moolenaar psignal(p, sig); 1635628d2653SJohn Baldwin } 163633a9ed9dSJohn Baldwin PROC_UNLOCK(p); 1637d93f860cSPoul-Henning Kamp } 16381005a129SJohn Baldwin sx_sunlock(&allproc_lock); 1639553629ebSJake Burkholder } else { 1640ba626c1dSJohn Baldwin sx_slock(&proctree_lock); 1641f591779bSSeigo Tanimura if (pgid == 0) { 1642d93f860cSPoul-Henning Kamp /* 1643d93f860cSPoul-Henning Kamp * zero pgid means send to my process group. 1644d93f860cSPoul-Henning Kamp */ 16459c1ab3e0SJohn Baldwin pgrp = td->td_proc->p_pgrp; 1646f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 1647f591779bSSeigo Tanimura } else { 1648d93f860cSPoul-Henning Kamp pgrp = pgfind(pgid); 1649f591779bSSeigo Tanimura if (pgrp == NULL) { 1650ba626c1dSJohn Baldwin sx_sunlock(&proctree_lock); 1651d93f860cSPoul-Henning Kamp return (ESRCH); 1652d93f860cSPoul-Henning Kamp } 1653f591779bSSeigo Tanimura } 1654ba626c1dSJohn Baldwin sx_sunlock(&proctree_lock); 16552e3c8fcbSPoul-Henning Kamp LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 1656628d2653SJohn Baldwin PROC_LOCK(p); 165795f16c1eSPaul Saab if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || 165895f16c1eSPaul Saab p->p_state == PRS_NEW ) { 1659628d2653SJohn Baldwin PROC_UNLOCK(p); 1660628d2653SJohn Baldwin continue; 1661628d2653SJohn Baldwin } 16621a88a252SMaxim Sobolev if (p_cansignal(td, p, sig) == 0) { 1663d93f860cSPoul-Henning Kamp nfound++; 166433a9ed9dSJohn Baldwin if (sig) 16652c42a146SMarcel Moolenaar psignal(p, sig); 1666628d2653SJohn Baldwin } 166733a9ed9dSJohn Baldwin PROC_UNLOCK(p); 1668d93f860cSPoul-Henning Kamp } 1669f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 1670d93f860cSPoul-Henning Kamp } 1671d93f860cSPoul-Henning Kamp return (nfound ? 0 : ESRCH); 1672d93f860cSPoul-Henning Kamp } 1673d93f860cSPoul-Henning Kamp 1674d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1675df8bae1dSRodney W. Grimes struct kill_args { 1676df8bae1dSRodney W. Grimes int pid; 1677df8bae1dSRodney W. Grimes int signum; 1678df8bae1dSRodney W. Grimes }; 1679d2d3e875SBruce Evans #endif 1680df8bae1dSRodney W. Grimes /* ARGSUSED */ 168126f9a767SRodney W. Grimes int 1682b40ce416SJulian Elischer kill(td, uap) 1683b40ce416SJulian Elischer register struct thread *td; 1684df8bae1dSRodney W. Grimes register struct kill_args *uap; 1685df8bae1dSRodney W. Grimes { 1686df8bae1dSRodney W. Grimes register struct proc *p; 168790af4afaSJohn Baldwin int error; 1688df8bae1dSRodney W. Grimes 1689bfd7575aSWayne Salamon AUDIT_ARG(signum, uap->signum); 16906c1534a7SPeter Wemm if ((u_int)uap->signum > _SIG_MAXSIG) 1691df8bae1dSRodney W. Grimes return (EINVAL); 1692fb99ab88SMatthew Dillon 1693df8bae1dSRodney W. Grimes if (uap->pid > 0) { 1694df8bae1dSRodney W. Grimes /* kill single process */ 16950b011ea3SPawel Jakub Dawidek if ((p = pfind(uap->pid)) == NULL) { 169624b2151fSPawel Jakub Dawidek if ((p = zpfind(uap->pid)) == NULL) 169790af4afaSJohn Baldwin return (ESRCH); 16980b011ea3SPawel Jakub Dawidek } 1699bfd7575aSWayne Salamon AUDIT_ARG(process, p); 17001a88a252SMaxim Sobolev error = p_cansignal(td, p, uap->signum); 170190af4afaSJohn Baldwin if (error == 0 && uap->signum) 1702df8bae1dSRodney W. Grimes psignal(p, uap->signum); 1703628d2653SJohn Baldwin PROC_UNLOCK(p); 170490af4afaSJohn Baldwin return (error); 1705df8bae1dSRodney W. Grimes } 1706bfd7575aSWayne Salamon AUDIT_ARG(pid, uap->pid); 1707df8bae1dSRodney W. Grimes switch (uap->pid) { 1708df8bae1dSRodney W. Grimes case -1: /* broadcast signal */ 17091a88a252SMaxim Sobolev return (killpg1(td, uap->signum, 0, 1)); 1710df8bae1dSRodney W. Grimes case 0: /* signal own process group */ 17111a88a252SMaxim Sobolev return (killpg1(td, uap->signum, 0, 0)); 1712df8bae1dSRodney W. Grimes default: /* negative explicit process group */ 17131a88a252SMaxim Sobolev return (killpg1(td, uap->signum, -uap->pid, 0)); 1714df8bae1dSRodney W. Grimes } 171590af4afaSJohn Baldwin /* NOTREACHED */ 1716df8bae1dSRodney W. Grimes } 1717df8bae1dSRodney W. Grimes 17181930e303SPoul-Henning Kamp #if defined(COMPAT_43) 1719d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 1720df8bae1dSRodney W. Grimes struct okillpg_args { 1721df8bae1dSRodney W. Grimes int pgid; 1722df8bae1dSRodney W. Grimes int signum; 1723df8bae1dSRodney W. Grimes }; 1724d2d3e875SBruce Evans #endif 1725df8bae1dSRodney W. Grimes /* ARGSUSED */ 172626f9a767SRodney W. Grimes int 1727b40ce416SJulian Elischer okillpg(td, uap) 1728b40ce416SJulian Elischer struct thread *td; 1729df8bae1dSRodney W. Grimes register struct okillpg_args *uap; 1730df8bae1dSRodney W. Grimes { 1731df8bae1dSRodney W. Grimes 1732bfd7575aSWayne Salamon AUDIT_ARG(signum, uap->signum); 1733bfd7575aSWayne Salamon AUDIT_ARG(pid, uap->pgid); 17346c1534a7SPeter Wemm if ((u_int)uap->signum > _SIG_MAXSIG) 1735df8bae1dSRodney W. Grimes return (EINVAL); 17369104847fSDavid Xu 17371a88a252SMaxim Sobolev return (killpg1(td, uap->signum, uap->pgid, 0)); 1738df8bae1dSRodney W. Grimes } 17391930e303SPoul-Henning Kamp #endif /* COMPAT_43 */ 1740df8bae1dSRodney W. Grimes 17419104847fSDavid Xu #ifndef _SYS_SYSPROTO_H_ 17429104847fSDavid Xu struct sigqueue_args { 17439104847fSDavid Xu pid_t pid; 17449104847fSDavid Xu int signum; 17459104847fSDavid Xu /* union sigval */ void *value; 17469104847fSDavid Xu }; 17479104847fSDavid Xu #endif 17489104847fSDavid Xu int 17499104847fSDavid Xu sigqueue(struct thread *td, struct sigqueue_args *uap) 17509104847fSDavid Xu { 17519104847fSDavid Xu ksiginfo_t ksi; 17529104847fSDavid Xu struct proc *p; 17539104847fSDavid Xu int error; 17549104847fSDavid Xu 17559104847fSDavid Xu if ((u_int)uap->signum > _SIG_MAXSIG) 17569104847fSDavid Xu return (EINVAL); 17579104847fSDavid Xu 17589104847fSDavid Xu /* 17599104847fSDavid Xu * Specification says sigqueue can only send signal to 17609104847fSDavid Xu * single process. 17619104847fSDavid Xu */ 17629104847fSDavid Xu if (uap->pid <= 0) 17639104847fSDavid Xu return (EINVAL); 17649104847fSDavid Xu 17659104847fSDavid Xu if ((p = pfind(uap->pid)) == NULL) { 17669104847fSDavid Xu if ((p = zpfind(uap->pid)) == NULL) 17679104847fSDavid Xu return (ESRCH); 17689104847fSDavid Xu } 17699104847fSDavid Xu error = p_cansignal(td, p, uap->signum); 17709104847fSDavid Xu if (error == 0 && uap->signum != 0) { 17719104847fSDavid Xu ksiginfo_init(&ksi); 17729104847fSDavid Xu ksi.ksi_signo = uap->signum; 17739104847fSDavid Xu ksi.ksi_code = SI_QUEUE; 17749104847fSDavid Xu ksi.ksi_pid = td->td_proc->p_pid; 17759104847fSDavid Xu ksi.ksi_uid = td->td_ucred->cr_ruid; 17768f0371f1SDavid Xu ksi.ksi_value.sival_ptr = uap->value; 17776d7b314bSDavid Xu error = tdsignal(p, NULL, ksi.ksi_signo, &ksi); 17789104847fSDavid Xu } 17799104847fSDavid Xu PROC_UNLOCK(p); 17809104847fSDavid Xu return (error); 17819104847fSDavid Xu } 17829104847fSDavid Xu 1783df8bae1dSRodney W. Grimes /* 1784df8bae1dSRodney W. Grimes * Send a signal to a process group. 1785df8bae1dSRodney W. Grimes */ 1786df8bae1dSRodney W. Grimes void 17872c42a146SMarcel Moolenaar gsignal(pgid, sig) 17882c42a146SMarcel Moolenaar int pgid, sig; 1789df8bae1dSRodney W. Grimes { 1790df8bae1dSRodney W. Grimes struct pgrp *pgrp; 1791df8bae1dSRodney W. Grimes 1792f591779bSSeigo Tanimura if (pgid != 0) { 1793ba626c1dSJohn Baldwin sx_slock(&proctree_lock); 1794f591779bSSeigo Tanimura pgrp = pgfind(pgid); 1795ba626c1dSJohn Baldwin sx_sunlock(&proctree_lock); 1796f591779bSSeigo Tanimura if (pgrp != NULL) { 17972c42a146SMarcel Moolenaar pgsignal(pgrp, sig, 0); 1798f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 1799f591779bSSeigo Tanimura } 1800f591779bSSeigo Tanimura } 1801df8bae1dSRodney W. Grimes } 1802df8bae1dSRodney W. Grimes 1803df8bae1dSRodney W. Grimes /* 1804df8bae1dSRodney W. Grimes * Send a signal to a process group. If checktty is 1, 1805df8bae1dSRodney W. Grimes * limit to members which have a controlling terminal. 1806df8bae1dSRodney W. Grimes */ 1807df8bae1dSRodney W. Grimes void 18082c42a146SMarcel Moolenaar pgsignal(pgrp, sig, checkctty) 1809df8bae1dSRodney W. Grimes struct pgrp *pgrp; 18102c42a146SMarcel Moolenaar int sig, checkctty; 1811df8bae1dSRodney W. Grimes { 1812df8bae1dSRodney W. Grimes register struct proc *p; 1813df8bae1dSRodney W. Grimes 1814628d2653SJohn Baldwin if (pgrp) { 1815f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_OWNED); 1816628d2653SJohn Baldwin LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 1817628d2653SJohn Baldwin PROC_LOCK(p); 1818df8bae1dSRodney W. Grimes if (checkctty == 0 || p->p_flag & P_CONTROLT) 18192c42a146SMarcel Moolenaar psignal(p, sig); 1820628d2653SJohn Baldwin PROC_UNLOCK(p); 1821628d2653SJohn Baldwin } 1822628d2653SJohn Baldwin } 1823df8bae1dSRodney W. Grimes } 1824df8bae1dSRodney W. Grimes 1825df8bae1dSRodney W. Grimes /* 18260c14ff0eSRobert Watson * Send a signal caused by a trap to the current thread. If it will be 18270c14ff0eSRobert Watson * caught immediately, deliver it with correct code. Otherwise, post it 18280c14ff0eSRobert Watson * normally. 1829df8bae1dSRodney W. Grimes */ 1830df8bae1dSRodney W. Grimes void 18319104847fSDavid Xu trapsignal(struct thread *td, ksiginfo_t *ksi) 1832df8bae1dSRodney W. Grimes { 18331bf4700bSJeff Roberson struct sigacts *ps; 18341bf4700bSJeff Roberson struct proc *p; 18358460a577SJohn Birrell #ifdef KSE 18369dde3bc9SDavid Xu int error; 18378460a577SJohn Birrell #endif 18389104847fSDavid Xu int sig; 18399104847fSDavid Xu int code; 18401bf4700bSJeff Roberson 18411bf4700bSJeff Roberson p = td->td_proc; 18429104847fSDavid Xu sig = ksi->ksi_signo; 18439104847fSDavid Xu code = ksi->ksi_code; 18449104847fSDavid Xu KASSERT(_SIG_VALID(sig), ("invalid signal")); 18459104847fSDavid Xu 18468460a577SJohn Birrell #ifdef KSE 1847aa0aa7a1STim J. Robbins if (td->td_pflags & TDP_SA) { 18487eeaaf9bSDavid Xu if (td->td_mailbox == NULL) 18495995adc2SJulian Elischer thread_user_enter(td); 1850628d2653SJohn Baldwin PROC_LOCK(p); 18519dde3bc9SDavid Xu SIGDELSET(td->td_sigmask, sig); 18529dde3bc9SDavid Xu mtx_lock_spin(&sched_lock); 18539dde3bc9SDavid Xu /* 18549dde3bc9SDavid Xu * Force scheduling an upcall, so UTS has chance to 18559dde3bc9SDavid Xu * process the signal before thread runs again in 18569dde3bc9SDavid Xu * userland. 18579dde3bc9SDavid Xu */ 18589dde3bc9SDavid Xu if (td->td_upcall) 18599dde3bc9SDavid Xu td->td_upcall->ku_flags |= KUF_DOUPCALL; 18609dde3bc9SDavid Xu mtx_unlock_spin(&sched_lock); 1861432b45deSDavid Xu } else { 18629dde3bc9SDavid Xu PROC_LOCK(p); 18639dde3bc9SDavid Xu } 18648460a577SJohn Birrell #else 18658460a577SJohn Birrell PROC_LOCK(p); 18668460a577SJohn Birrell #endif 1867ef3dab76STim J. Robbins ps = p->p_sigacts; 186890af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 186990af4afaSJohn Baldwin if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(ps->ps_sigcatch, sig) && 18704093529dSJeff Roberson !SIGISMEMBER(td->td_sigmask, sig)) { 1871df8bae1dSRodney W. Grimes p->p_stats->p_ru.ru_nsignals++; 1872df8bae1dSRodney W. Grimes #ifdef KTRACE 1873374a15aaSJohn Baldwin if (KTRPOINT(curthread, KTR_PSIG)) 1874374a15aaSJohn Baldwin ktrpsig(sig, ps->ps_sigact[_SIG_IDX(sig)], 18754093529dSJeff Roberson &td->td_sigmask, code); 1876df8bae1dSRodney W. Grimes #endif 18778460a577SJohn Birrell #ifdef KSE 1878aa0aa7a1STim J. Robbins if (!(td->td_pflags & TDP_SA)) 18799104847fSDavid Xu (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)], 18809104847fSDavid Xu ksi, &td->td_sigmask); 18818460a577SJohn Birrell #else 18828460a577SJohn Birrell (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)], 18838460a577SJohn Birrell ksi, &td->td_sigmask); 18848460a577SJohn Birrell #endif 18858460a577SJohn Birrell #ifdef KSE 1886cbf4e354SDavid Xu else if (td->td_mailbox == NULL) { 1887cbf4e354SDavid Xu mtx_unlock(&ps->ps_mtx); 1888cbf4e354SDavid Xu /* UTS caused a sync signal */ 1889cbf4e354SDavid Xu p->p_code = code; /* XXX for core dump/debugger */ 1890cbf4e354SDavid Xu p->p_sig = sig; /* XXX to verify code */ 1891cbf4e354SDavid Xu sigexit(td, sig); 1892cbf4e354SDavid Xu } else { 18939dde3bc9SDavid Xu mtx_unlock(&ps->ps_mtx); 1894cbf4e354SDavid Xu SIGADDSET(td->td_sigmask, sig); 18959dde3bc9SDavid Xu PROC_UNLOCK(p); 18969104847fSDavid Xu error = copyout(&ksi->ksi_info, &td->td_mailbox->tm_syncsig, 18979104847fSDavid Xu sizeof(siginfo_t)); 18989dde3bc9SDavid Xu PROC_LOCK(p); 1899432b45deSDavid Xu /* UTS memory corrupted */ 19009dde3bc9SDavid Xu if (error) 1901cbf4e354SDavid Xu sigexit(td, SIGSEGV); 19029dde3bc9SDavid Xu mtx_lock(&ps->ps_mtx); 19039dde3bc9SDavid Xu } 19048460a577SJohn Birrell #endif 19054093529dSJeff Roberson SIGSETOR(td->td_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]); 19062c42a146SMarcel Moolenaar if (!SIGISMEMBER(ps->ps_signodefer, sig)) 19074093529dSJeff Roberson SIGADDSET(td->td_sigmask, sig); 19082c42a146SMarcel Moolenaar if (SIGISMEMBER(ps->ps_sigreset, sig)) { 1909289ccde0SPeter Wemm /* 19108f19eb88SIan Dowse * See kern_sigaction() for origin of this code. 1911289ccde0SPeter Wemm */ 191290af4afaSJohn Baldwin SIGDELSET(ps->ps_sigcatch, sig); 19132c42a146SMarcel Moolenaar if (sig != SIGCONT && 19142c42a146SMarcel Moolenaar sigprop(sig) & SA_IGNORE) 191590af4afaSJohn Baldwin SIGADDSET(ps->ps_sigignore, sig); 19162c42a146SMarcel Moolenaar ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; 1917dedc04feSPeter Wemm } 191890af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 19196f841fb7SMarcel Moolenaar } else { 1920f71a882fSDavid Xu /* 1921f71a882fSDavid Xu * Avoid a possible infinite loop if the thread 1922f71a882fSDavid Xu * masking the signal or process is ignoring the 1923f71a882fSDavid Xu * signal. 1924f71a882fSDavid Xu */ 1925f71a882fSDavid Xu if (kern_forcesigexit && 1926f71a882fSDavid Xu (SIGISMEMBER(td->td_sigmask, sig) || 1927f71a882fSDavid Xu ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN)) { 1928f71a882fSDavid Xu SIGDELSET(td->td_sigmask, sig); 1929f71a882fSDavid Xu SIGDELSET(ps->ps_sigcatch, sig); 1930f71a882fSDavid Xu SIGDELSET(ps->ps_sigignore, sig); 1931f71a882fSDavid Xu ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; 1932f71a882fSDavid Xu } 193390af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 19346626c604SJulian Elischer p->p_code = code; /* XXX for core dump/debugger */ 19352c42a146SMarcel Moolenaar p->p_sig = sig; /* XXX to verify code */ 19366d7b314bSDavid Xu tdsignal(p, td, sig, ksi); 1937df8bae1dSRodney W. Grimes } 1938628d2653SJohn Baldwin PROC_UNLOCK(p); 1939df8bae1dSRodney W. Grimes } 1940df8bae1dSRodney W. Grimes 19414093529dSJeff Roberson static struct thread * 19424093529dSJeff Roberson sigtd(struct proc *p, int sig, int prop) 19434093529dSJeff Roberson { 19443074d1b4SDavid Xu struct thread *td, *signal_td; 19454093529dSJeff Roberson 19464093529dSJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 19474093529dSJeff Roberson 19484093529dSJeff Roberson /* 1949627451c1SDavid Xu * Check if current thread can handle the signal without 1950627451c1SDavid Xu * switching conetxt to another thread. 19514093529dSJeff Roberson */ 1952627451c1SDavid Xu if (curproc == p && !SIGISMEMBER(curthread->td_sigmask, sig)) 1953627451c1SDavid Xu return (curthread); 19543074d1b4SDavid Xu signal_td = NULL; 1955a9a48d68SDavid Xu mtx_lock_spin(&sched_lock); 19563074d1b4SDavid Xu FOREACH_THREAD_IN_PROC(p, td) { 19573074d1b4SDavid Xu if (!SIGISMEMBER(td->td_sigmask, sig)) { 19583074d1b4SDavid Xu signal_td = td; 1959627451c1SDavid Xu break; 19603074d1b4SDavid Xu } 19613074d1b4SDavid Xu } 19623074d1b4SDavid Xu if (signal_td == NULL) 19633074d1b4SDavid Xu signal_td = FIRST_THREAD_IN_PROC(p); 1964a9a48d68SDavid Xu mtx_unlock_spin(&sched_lock); 19653074d1b4SDavid Xu return (signal_td); 19664093529dSJeff Roberson } 19674093529dSJeff Roberson 1968df8bae1dSRodney W. Grimes /* 1969df8bae1dSRodney W. Grimes * Send the signal to the process. If the signal has an action, the action 1970df8bae1dSRodney W. Grimes * is usually performed by the target process rather than the caller; we add 1971df8bae1dSRodney W. Grimes * the signal to the set of pending signals for the process. 1972df8bae1dSRodney W. Grimes * 1973df8bae1dSRodney W. Grimes * Exceptions: 1974df8bae1dSRodney W. Grimes * o When a stop signal is sent to a sleeping process that takes the 1975df8bae1dSRodney W. Grimes * default action, the process is stopped without awakening it. 1976df8bae1dSRodney W. Grimes * o SIGCONT restarts stopped processes (or puts them back to sleep) 1977df8bae1dSRodney W. Grimes * regardless of the signal action (eg, blocked or ignored). 1978df8bae1dSRodney W. Grimes * 1979df8bae1dSRodney W. Grimes * Other ignored signals are discarded immediately. 1980df8bae1dSRodney W. Grimes */ 1981df8bae1dSRodney W. Grimes void 19824093529dSJeff Roberson psignal(struct proc *p, int sig) 1983df8bae1dSRodney W. Grimes { 19846d7b314bSDavid Xu (void) tdsignal(p, NULL, sig, NULL); 19859104847fSDavid Xu } 19869104847fSDavid Xu 19879104847fSDavid Xu int 19886d7b314bSDavid Xu psignal_event(struct proc *p, struct sigevent *sigev, ksiginfo_t *ksi) 19899104847fSDavid Xu { 19906d7b314bSDavid Xu struct thread *td = NULL; 199141b3077aSJacques Vidrine 19924093529dSJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 19936d7b314bSDavid Xu 19946d7b314bSDavid Xu KASSERT(!KSI_ONQ(ksi), ("psignal_event: ksi on queue")); 19954093529dSJeff Roberson 19964093529dSJeff Roberson /* 19976d7b314bSDavid Xu * ksi_code and other fields should be set before 19986d7b314bSDavid Xu * calling this function. 19994093529dSJeff Roberson */ 20006d7b314bSDavid Xu ksi->ksi_signo = sigev->sigev_signo; 20016d7b314bSDavid Xu ksi->ksi_value = sigev->sigev_value; 20026d7b314bSDavid Xu if (sigev->sigev_notify == SIGEV_THREAD_ID) { 20036d7b314bSDavid Xu td = thread_find(p, sigev->sigev_notify_thread_id); 20046d7b314bSDavid Xu if (td == NULL) 20056d7b314bSDavid Xu return (ESRCH); 20066d7b314bSDavid Xu } 20076d7b314bSDavid Xu return (tdsignal(p, td, ksi->ksi_signo, ksi)); 20084093529dSJeff Roberson } 20094093529dSJeff Roberson 20109104847fSDavid Xu int 20116d7b314bSDavid Xu tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi) 20124093529dSJeff Roberson { 20138460a577SJohn Birrell #ifdef KSE 20149dde3bc9SDavid Xu sigset_t saved; 20159104847fSDavid Xu int ret; 20169dde3bc9SDavid Xu 20179dde3bc9SDavid Xu if (p->p_flag & P_SA) 20189104847fSDavid Xu saved = p->p_sigqueue.sq_signals; 20196d7b314bSDavid Xu ret = do_tdsignal(p, td, sig, ksi); 20209dde3bc9SDavid Xu if ((p->p_flag & P_SA) && !(p->p_flag & P_SIGEVENT)) { 20219104847fSDavid Xu if (!SIGSETEQ(saved, p->p_sigqueue.sq_signals)) { 20229dde3bc9SDavid Xu /* pending set changed */ 20239dde3bc9SDavid Xu p->p_flag |= P_SIGEVENT; 20249dde3bc9SDavid Xu wakeup(&p->p_siglist); 20259dde3bc9SDavid Xu } 20269dde3bc9SDavid Xu } 20279104847fSDavid Xu return (ret); 20289dde3bc9SDavid Xu } 20299dde3bc9SDavid Xu 20309104847fSDavid Xu static int 20316d7b314bSDavid Xu do_tdsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi) 20329dde3bc9SDavid Xu { 20338460a577SJohn Birrell #endif 20349104847fSDavid Xu sig_t action; 20359104847fSDavid Xu sigqueue_t *sigqueue; 20369104847fSDavid Xu int prop; 203790af4afaSJohn Baldwin struct sigacts *ps; 203894f0972bSDavid Xu int intrval; 20399104847fSDavid Xu int ret = 0; 2040df8bae1dSRodney W. Grimes 20416d7b314bSDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 20426d7b314bSDavid Xu 204341b3077aSJacques Vidrine if (!_SIG_VALID(sig)) 20448460a577SJohn Birrell #ifdef KSE 2045d60226bdSXin LI panic("do_tdsignal(): invalid signal %d", sig); 20468460a577SJohn Birrell #else 2047d60226bdSXin LI panic("tdsignal(): invalid signal %d", sig); 20488460a577SJohn Birrell #endif 20494093529dSJeff Roberson 20508460a577SJohn Birrell #ifdef KSE 20516d7b314bSDavid Xu KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("do_tdsignal: ksi on queue")); 20528460a577SJohn Birrell #else 20538460a577SJohn Birrell KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("tdsignal: ksi on queue")); 20548460a577SJohn Birrell #endif 20556d7b314bSDavid Xu 20566d7b314bSDavid Xu /* 20576d7b314bSDavid Xu * IEEE Std 1003.1-2001: return success when killing a zombie. 20586d7b314bSDavid Xu */ 20596d7b314bSDavid Xu if (p->p_state == PRS_ZOMBIE) { 20606d7b314bSDavid Xu if (ksi && (ksi->ksi_flags & KSI_INS)) 20616d7b314bSDavid Xu ksiginfo_tryfree(ksi); 20626d7b314bSDavid Xu return (ret); 20636d7b314bSDavid Xu } 20646d7b314bSDavid Xu 206590af4afaSJohn Baldwin ps = p->p_sigacts; 2066ad3b9257SJohn-Mark Gurney KNOTE_LOCKED(&p->p_klist, NOTE_SIGNAL | sig); 20672c42a146SMarcel Moolenaar prop = sigprop(sig); 20684093529dSJeff Roberson 20694093529dSJeff Roberson /* 207014b5ae1aSMike Makonnen * If the signal is blocked and not destined for this thread, then 207114b5ae1aSMike Makonnen * assign it to the process so that we can find it later in the first 207214b5ae1aSMike Makonnen * thread that unblocks it. Otherwise, assign it to this thread now. 20734093529dSJeff Roberson */ 20746d7b314bSDavid Xu if (td == NULL) { 20756d7b314bSDavid Xu td = sigtd(p, sig, prop); 20766d7b314bSDavid Xu if (SIGISMEMBER(td->td_sigmask, sig)) 20776d7b314bSDavid Xu sigqueue = &p->p_sigqueue; 20786d7b314bSDavid Xu else 20799104847fSDavid Xu sigqueue = &td->td_sigqueue; 20803074d1b4SDavid Xu } else { 20816d7b314bSDavid Xu KASSERT(td->td_proc == p, ("invalid thread")); 20829104847fSDavid Xu sigqueue = &td->td_sigqueue; 20833074d1b4SDavid Xu } 20844093529dSJeff Roberson 2085df8bae1dSRodney W. Grimes /* 2086df8bae1dSRodney W. Grimes * If the signal is being ignored, 2087df8bae1dSRodney W. Grimes * then we forget about it immediately. 208890af4afaSJohn Baldwin * (Note: we don't set SIGCONT in ps_sigignore, 2089df8bae1dSRodney W. Grimes * and if it is set to SIG_IGN, 2090df8bae1dSRodney W. Grimes * action will be SIG_DFL here.) 2091df8bae1dSRodney W. Grimes */ 209290af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 20930fc32899SJohn Baldwin if (SIGISMEMBER(ps->ps_sigignore, sig)) { 209490af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 20956d7b314bSDavid Xu if (ksi && (ksi->ksi_flags & KSI_INS)) 20966d7b314bSDavid Xu ksiginfo_tryfree(ksi); 20979104847fSDavid Xu return (ret); 209890af4afaSJohn Baldwin } 20996675b36eSDavid Xu if (SIGISMEMBER(td->td_sigmask, sig)) 2100df8bae1dSRodney W. Grimes action = SIG_HOLD; 210190af4afaSJohn Baldwin else if (SIGISMEMBER(ps->ps_sigcatch, sig)) 2102df8bae1dSRodney W. Grimes action = SIG_CATCH; 2103df8bae1dSRodney W. Grimes else 2104df8bae1dSRodney W. Grimes action = SIG_DFL; 210594f0972bSDavid Xu if (SIGISMEMBER(ps->ps_sigintr, sig)) 210694f0972bSDavid Xu intrval = EINTR; 210794f0972bSDavid Xu else 210894f0972bSDavid Xu intrval = ERESTART; 210990af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 2110df8bae1dSRodney W. Grimes 21119104847fSDavid Xu if (prop & SA_CONT) 21129104847fSDavid Xu sigqueue_delete_stopmask_proc(p); 21139104847fSDavid Xu else if (prop & SA_STOP) { 2114df8bae1dSRodney W. Grimes /* 2115df8bae1dSRodney W. Grimes * If sending a tty stop signal to a member of an orphaned 2116df8bae1dSRodney W. Grimes * process group, discard the signal here if the action 2117df8bae1dSRodney W. Grimes * is default; don't stop the process below if sleeping, 2118df8bae1dSRodney W. Grimes * and don't clear any pending SIGCONT. 2119df8bae1dSRodney W. Grimes */ 2120e602ba25SJulian Elischer if ((prop & SA_TTYSTOP) && 2121e602ba25SJulian Elischer (p->p_pgrp->pg_jobc == 0) && 21226d7b314bSDavid Xu (action == SIG_DFL)) { 21236d7b314bSDavid Xu if (ksi && (ksi->ksi_flags & KSI_INS)) 21246d7b314bSDavid Xu ksiginfo_tryfree(ksi); 21259104847fSDavid Xu return (ret); 21266d7b314bSDavid Xu } 21279104847fSDavid Xu sigqueue_delete_proc(p, SIGCONT); 2128ebceaf6dSDavid Xu if (p->p_flag & P_CONTINUED) { 21296933e3c1SJulian Elischer p->p_flag &= ~P_CONTINUED; 2130ebceaf6dSDavid Xu PROC_LOCK(p->p_pptr); 2131ebceaf6dSDavid Xu sigqueue_take(p->p_ksi); 2132ebceaf6dSDavid Xu PROC_UNLOCK(p->p_pptr); 2133ebceaf6dSDavid Xu } 2134df8bae1dSRodney W. Grimes } 21353074d1b4SDavid Xu 21369104847fSDavid Xu ret = sigqueue_add(sigqueue, sig, ksi); 21379104847fSDavid Xu if (ret != 0) 21389104847fSDavid Xu return (ret); 21396d7b314bSDavid Xu signotify(td); 21405312b1c7SDavid Xu /* 21415312b1c7SDavid Xu * Defer further processing for signals which are held, 21425312b1c7SDavid Xu * except that stopped processes must be continued by SIGCONT. 21435312b1c7SDavid Xu */ 21445312b1c7SDavid Xu if (action == SIG_HOLD && 21455312b1c7SDavid Xu !((prop & SA_CONT) && (p->p_flag & P_STOPPED_SIG))) 21469104847fSDavid Xu return (ret); 2147df8bae1dSRodney W. Grimes /* 214890d75f78SAlfred Perlstein * SIGKILL: Remove procfs STOPEVENTs. 214990d75f78SAlfred Perlstein */ 215090d75f78SAlfred Perlstein if (sig == SIGKILL) { 215190d75f78SAlfred Perlstein /* from procfs_ioctl.c: PIOCBIC */ 215290d75f78SAlfred Perlstein p->p_stops = 0; 215390d75f78SAlfred Perlstein /* from procfs_ioctl.c: PIOCCONT */ 215490d75f78SAlfred Perlstein p->p_step = 0; 215590d75f78SAlfred Perlstein wakeup(&p->p_step); 215690d75f78SAlfred Perlstein } 215790d75f78SAlfred Perlstein /* 2158e602ba25SJulian Elischer * Some signals have a process-wide effect and a per-thread 2159e602ba25SJulian Elischer * component. Most processing occurs when the process next 2160e602ba25SJulian Elischer * tries to cross the user boundary, however there are some 2161e602ba25SJulian Elischer * times when processing needs to be done immediatly, such as 2162e602ba25SJulian Elischer * waking up threads so that they can cross the user boundary. 2163e602ba25SJulian Elischer * We try do the per-process part here. 2164df8bae1dSRodney W. Grimes */ 2165e602ba25SJulian Elischer if (P_SHOULDSTOP(p)) { 2166e602ba25SJulian Elischer /* 2167e602ba25SJulian Elischer * The process is in stopped mode. All the threads should be 2168e602ba25SJulian Elischer * either winding down or already on the suspended queue. 2169e602ba25SJulian Elischer */ 2170e602ba25SJulian Elischer if (p->p_flag & P_TRACED) { 2171e602ba25SJulian Elischer /* 2172e602ba25SJulian Elischer * The traced process is already stopped, 2173e602ba25SJulian Elischer * so no further action is necessary. 2174e602ba25SJulian Elischer * No signal can restart us. 2175e602ba25SJulian Elischer */ 2176e602ba25SJulian Elischer goto out; 21771c32c37cSJohn Baldwin } 2178b40ce416SJulian Elischer 2179e602ba25SJulian Elischer if (sig == SIGKILL) { 2180df8bae1dSRodney W. Grimes /* 2181e602ba25SJulian Elischer * SIGKILL sets process running. 2182e602ba25SJulian Elischer * It will die elsewhere. 2183e602ba25SJulian Elischer * All threads must be restarted. 2184df8bae1dSRodney W. Grimes */ 2185482d099cSDavid Xu p->p_flag &= ~P_STOPPED_SIG; 2186e602ba25SJulian Elischer goto runfast; 2187e602ba25SJulian Elischer } 2188e602ba25SJulian Elischer 2189e602ba25SJulian Elischer if (prop & SA_CONT) { 2190e602ba25SJulian Elischer /* 2191e602ba25SJulian Elischer * If SIGCONT is default (or ignored), we continue the 21929104847fSDavid Xu * process but don't leave the signal in sigqueue as 21931d9c5696SJuli Mallett * it has no further action. If SIGCONT is held, we 2194e602ba25SJulian Elischer * continue the process and leave the signal in 21959104847fSDavid Xu * sigqueue. If the process catches SIGCONT, let it 2196e602ba25SJulian Elischer * handle the signal itself. If it isn't waiting on 2197e602ba25SJulian Elischer * an event, it goes back to run state. 2198e602ba25SJulian Elischer * Otherwise, process goes back to sleep state. 2199e602ba25SJulian Elischer */ 22001279572aSDavid Xu p->p_flag &= ~P_STOPPED_SIG; 2201ebceaf6dSDavid Xu if (p->p_numthreads == p->p_suspcount) { 22026933e3c1SJulian Elischer p->p_flag |= P_CONTINUED; 22037f96995eSDavid Xu p->p_xstat = SIGCONT; 22047f96995eSDavid Xu PROC_LOCK(p->p_pptr); 2205ebceaf6dSDavid Xu childproc_continued(p); 22067f96995eSDavid Xu PROC_UNLOCK(p->p_pptr); 2207ebceaf6dSDavid Xu } 2208e602ba25SJulian Elischer if (action == SIG_DFL) { 22099104847fSDavid Xu sigqueue_delete(sigqueue, sig); 2210e602ba25SJulian Elischer } else if (action == SIG_CATCH) { 22118460a577SJohn Birrell #ifdef KSE 2212e602ba25SJulian Elischer /* 2213e602ba25SJulian Elischer * The process wants to catch it so it needs 2214e602ba25SJulian Elischer * to run at least one thread, but which one? 2215e602ba25SJulian Elischer * It would seem that the answer would be to 2216e602ba25SJulian Elischer * run an upcall in the next KSE to run, and 2217e602ba25SJulian Elischer * deliver the signal that way. In a NON KSE 2218e602ba25SJulian Elischer * process, we need to make sure that the 2219e602ba25SJulian Elischer * single thread is runnable asap. 2220e602ba25SJulian Elischer * XXXKSE for now however, make them all run. 2221e602ba25SJulian Elischer */ 22228460a577SJohn Birrell #else 22238460a577SJohn Birrell /* 22248460a577SJohn Birrell * The process wants to catch it so it needs 22258460a577SJohn Birrell * to run at least one thread, but which one? 22268460a577SJohn Birrell */ 22278460a577SJohn Birrell #endif 2228e602ba25SJulian Elischer goto runfast; 2229e602ba25SJulian Elischer } 2230e602ba25SJulian Elischer /* 2231e602ba25SJulian Elischer * The signal is not ignored or caught. 2232e602ba25SJulian Elischer */ 2233e602ba25SJulian Elischer mtx_lock_spin(&sched_lock); 223404774f23SJulian Elischer thread_unsuspend(p); 2235e602ba25SJulian Elischer mtx_unlock_spin(&sched_lock); 2236e602ba25SJulian Elischer goto out; 2237e602ba25SJulian Elischer } 2238e602ba25SJulian Elischer 2239e602ba25SJulian Elischer if (prop & SA_STOP) { 2240e602ba25SJulian Elischer /* 2241e602ba25SJulian Elischer * Already stopped, don't need to stop again 2242e602ba25SJulian Elischer * (If we did the shell could get confused). 224304774f23SJulian Elischer * Just make sure the signal STOP bit set. 2244e602ba25SJulian Elischer */ 22451279572aSDavid Xu p->p_flag |= P_STOPPED_SIG; 22469104847fSDavid Xu sigqueue_delete(sigqueue, sig); 2247e602ba25SJulian Elischer goto out; 2248e602ba25SJulian Elischer } 2249e602ba25SJulian Elischer 2250e602ba25SJulian Elischer /* 2251e602ba25SJulian Elischer * All other kinds of signals: 2252e602ba25SJulian Elischer * If a thread is sleeping interruptibly, simulate a 2253e602ba25SJulian Elischer * wakeup so that when it is continued it will be made 2254e602ba25SJulian Elischer * runnable and can look at the signal. However, don't make 225504774f23SJulian Elischer * the PROCESS runnable, leave it stopped. 2256e602ba25SJulian Elischer * It may run a bit until it hits a thread_suspend_check(). 2257e602ba25SJulian Elischer */ 2258e602ba25SJulian Elischer mtx_lock_spin(&sched_lock); 225944f3b092SJohn Baldwin if (TD_ON_SLEEPQ(td) && (td->td_flags & TDF_SINTR)) 226094f0972bSDavid Xu sleepq_abort(td, intrval); 2261e602ba25SJulian Elischer mtx_unlock_spin(&sched_lock); 2262df8bae1dSRodney W. Grimes goto out; 2263df8bae1dSRodney W. Grimes /* 22649a6a4cb5SPeter Wemm * Mutexes are short lived. Threads waiting on them will 22659a6a4cb5SPeter Wemm * hit thread_suspend_check() soon. 2266df8bae1dSRodney W. Grimes */ 2267e602ba25SJulian Elischer } else if (p->p_state == PRS_NORMAL) { 2268ec8297bdSDavid Xu if (p->p_flag & P_TRACED || action == SIG_CATCH) { 2269721e5910SJulian Elischer mtx_lock_spin(&sched_lock); 227094f0972bSDavid Xu tdsigwakeup(td, sig, action, intrval); 2271721e5910SJulian Elischer mtx_unlock_spin(&sched_lock); 2272df8bae1dSRodney W. Grimes goto out; 227304774f23SJulian Elischer } 2274ec8297bdSDavid Xu 2275ec8297bdSDavid Xu MPASS(action == SIG_DFL); 2276ec8297bdSDavid Xu 227735c32a76SDavid Xu if (prop & SA_STOP) { 227835c32a76SDavid Xu if (p->p_flag & P_PPWAIT) 227935c32a76SDavid Xu goto out; 2280e574e444SDavid Xu p->p_flag |= P_STOPPED_SIG; 2281e574e444SDavid Xu p->p_xstat = sig; 228235c32a76SDavid Xu mtx_lock_spin(&sched_lock); 2283d8267df7SDavid Xu sig_suspend_threads(td, p, 1); 22844093529dSJeff Roberson if (p->p_numthreads == p->p_suspcount) { 2285ebceaf6dSDavid Xu /* 2286ebceaf6dSDavid Xu * only thread sending signal to another 2287ebceaf6dSDavid Xu * process can reach here, if thread is sending 2288ebceaf6dSDavid Xu * signal to its process, because thread does 2289ebceaf6dSDavid Xu * not suspend itself here, p_numthreads 2290ebceaf6dSDavid Xu * should never be equal to p_suspcount. 2291ebceaf6dSDavid Xu */ 2292ebceaf6dSDavid Xu thread_stopped(p); 22939104847fSDavid Xu mtx_unlock_spin(&sched_lock); 22949104847fSDavid Xu sigqueue_delete_proc(p, p->p_xstat); 22959104847fSDavid Xu } else 229635c32a76SDavid Xu mtx_unlock_spin(&sched_lock); 229735c32a76SDavid Xu goto out; 229835c32a76SDavid Xu } 2299721e5910SJulian Elischer else 2300df8bae1dSRodney W. Grimes goto runfast; 2301df8bae1dSRodney W. Grimes /* NOTREACHED */ 2302e602ba25SJulian Elischer } else { 2303e602ba25SJulian Elischer /* Not in "NORMAL" state. discard the signal. */ 23049104847fSDavid Xu sigqueue_delete(sigqueue, sig); 2305e602ba25SJulian Elischer goto out; 2306e602ba25SJulian Elischer } 2307e602ba25SJulian Elischer 2308b40ce416SJulian Elischer /* 2309e602ba25SJulian Elischer * The process is not stopped so we need to apply the signal to all the 2310e602ba25SJulian Elischer * running threads. 2311b40ce416SJulian Elischer */ 2312e602ba25SJulian Elischer 2313e602ba25SJulian Elischer runfast: 2314aa0fa334SJulian Elischer mtx_lock_spin(&sched_lock); 231594f0972bSDavid Xu tdsigwakeup(td, sig, action, intrval); 2316e602ba25SJulian Elischer thread_unsuspend(p); 2317e602ba25SJulian Elischer mtx_unlock_spin(&sched_lock); 2318e602ba25SJulian Elischer out: 2319e602ba25SJulian Elischer /* If we jump here, sched_lock should not be owned. */ 2320e602ba25SJulian Elischer mtx_assert(&sched_lock, MA_NOTOWNED); 23219104847fSDavid Xu return (ret); 2322e602ba25SJulian Elischer } 2323e602ba25SJulian Elischer 2324e602ba25SJulian Elischer /* 2325e602ba25SJulian Elischer * The force of a signal has been directed against a single 2326e602ba25SJulian Elischer * thread. We need to see what we can do about knocking it 2327e602ba25SJulian Elischer * out of any sleep it may be in etc. 2328e602ba25SJulian Elischer */ 2329e602ba25SJulian Elischer static void 233094f0972bSDavid Xu tdsigwakeup(struct thread *td, int sig, sig_t action, int intrval) 2331e602ba25SJulian Elischer { 2332e602ba25SJulian Elischer struct proc *p = td->td_proc; 2333e602ba25SJulian Elischer register int prop; 2334e602ba25SJulian Elischer 23358b94a061SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 2336aa0fa334SJulian Elischer mtx_assert(&sched_lock, MA_OWNED); 2337e602ba25SJulian Elischer prop = sigprop(sig); 2338a4c2da15SBruce Evans 2339e602ba25SJulian Elischer /* 2340aa0fa334SJulian Elischer * Bring the priority of a thread up if we want it to get 2341e602ba25SJulian Elischer * killed in this lifetime. 2342e602ba25SJulian Elischer */ 2343a4c2da15SBruce Evans if (action == SIG_DFL && (prop & SA_KILL)) { 23443ef6ac33SJeff Roberson if (p->p_nice > 0) 23453ef6ac33SJeff Roberson sched_nice(td->td_proc, 0); 2346a4c2da15SBruce Evans if (td->td_priority > PUSER) 2347b3a4fb14SDavid Xu sched_prio(td, PUSER); 2348b40ce416SJulian Elischer } 2349a4c2da15SBruce Evans 235080c4433cSJohn Baldwin if (TD_ON_SLEEPQ(td)) { 2351e602ba25SJulian Elischer /* 2352e602ba25SJulian Elischer * If thread is sleeping uninterruptibly 2353e602ba25SJulian Elischer * we can't interrupt the sleep... the signal will 2354e602ba25SJulian Elischer * be noticed when the process returns through 2355e602ba25SJulian Elischer * trap() or syscall(). 2356e602ba25SJulian Elischer */ 235744f3b092SJohn Baldwin if ((td->td_flags & TDF_SINTR) == 0) 2358aa0fa334SJulian Elischer return; 2359e602ba25SJulian Elischer /* 2360e602ba25SJulian Elischer * If SIGCONT is default (or ignored) and process is 2361e602ba25SJulian Elischer * asleep, we are finished; the process should not 2362e602ba25SJulian Elischer * be awakened. 2363df8bae1dSRodney W. Grimes */ 2364e602ba25SJulian Elischer if ((prop & SA_CONT) && action == SIG_DFL) { 23659104847fSDavid Xu mtx_unlock_spin(&sched_lock); 23669104847fSDavid Xu sigqueue_delete(&p->p_sigqueue, sig); 23674093529dSJeff Roberson /* 23684093529dSJeff Roberson * It may be on either list in this state. 23694093529dSJeff Roberson * Remove from both for now. 23704093529dSJeff Roberson */ 23719104847fSDavid Xu sigqueue_delete(&td->td_sigqueue, sig); 23729104847fSDavid Xu mtx_lock_spin(&sched_lock); 2373aa0fa334SJulian Elischer return; 2374df8bae1dSRodney W. Grimes } 2375df8bae1dSRodney W. Grimes 2376aa0fa334SJulian Elischer /* 2377a4c2da15SBruce Evans * Give low priority threads a better chance to run. 2378aa0fa334SJulian Elischer */ 237944f3b092SJohn Baldwin if (td->td_priority > PUSER) 2380b3a4fb14SDavid Xu sched_prio(td, PUSER); 2381ec8297bdSDavid Xu 238294f0972bSDavid Xu sleepq_abort(td, intrval); 2383a4c2da15SBruce Evans } else { 2384df8bae1dSRodney W. Grimes /* 2385a4c2da15SBruce Evans * Other states do nothing with the signal immediately, 2386df8bae1dSRodney W. Grimes * other than kicking ourselves if we are running. 2387df8bae1dSRodney W. Grimes * It will either never be noticed, or noticed very soon. 2388df8bae1dSRodney W. Grimes */ 2389a4c2da15SBruce Evans #ifdef SMP 239044f3b092SJohn Baldwin if (TD_IS_RUNNING(td) && td != curthread) 2391e602ba25SJulian Elischer forward_signal(td); 23923163861cSTor Egge #endif 23936caa8a15SJohn Baldwin } 2394a4c2da15SBruce Evans } 2395df8bae1dSRodney W. Grimes 2396d8267df7SDavid Xu static void 2397d8267df7SDavid Xu sig_suspend_threads(struct thread *td, struct proc *p, int sending) 2398d8267df7SDavid Xu { 2399d8267df7SDavid Xu struct thread *td2; 2400d8267df7SDavid Xu 2401d8267df7SDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 2402d8267df7SDavid Xu mtx_assert(&sched_lock, MA_OWNED); 2403d8267df7SDavid Xu 2404d8267df7SDavid Xu FOREACH_THREAD_IN_PROC(p, td2) { 2405d8267df7SDavid Xu if ((TD_IS_SLEEPING(td2) || TD_IS_SWAPPED(td2)) && 2406d8267df7SDavid Xu (td2->td_flags & TDF_SINTR) && 2407d8267df7SDavid Xu !TD_IS_SUSPENDED(td2)) { 2408d8267df7SDavid Xu thread_suspend_one(td2); 2409d8267df7SDavid Xu } else { 2410d8267df7SDavid Xu if (sending || td != td2) 2411d8267df7SDavid Xu td2->td_flags |= TDF_ASTPENDING; 2412d8267df7SDavid Xu #ifdef SMP 2413d8267df7SDavid Xu if (TD_IS_RUNNING(td2) && td2 != td) 2414d8267df7SDavid Xu forward_signal(td2); 2415d8267df7SDavid Xu #endif 2416d8267df7SDavid Xu } 2417d8267df7SDavid Xu } 2418d8267df7SDavid Xu } 2419d8267df7SDavid Xu 2420cbf4e354SDavid Xu int 24214cc9f52fSRobert Drehmel ptracestop(struct thread *td, int sig) 24224cc9f52fSRobert Drehmel { 24234cc9f52fSRobert Drehmel struct proc *p = td->td_proc; 24244cc9f52fSRobert Drehmel 242530a9f26dSRobert Watson PROC_LOCK_ASSERT(p, MA_OWNED); 24264cc9f52fSRobert Drehmel WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, 24274cc9f52fSRobert Drehmel &p->p_mtx.mtx_object, "Stopping for traced signal"); 24284cc9f52fSRobert Drehmel 24294cc9f52fSRobert Drehmel mtx_lock_spin(&sched_lock); 2430cbf4e354SDavid Xu td->td_flags |= TDF_XSIG; 2431cbf4e354SDavid Xu mtx_unlock_spin(&sched_lock); 2432cbf4e354SDavid Xu td->td_xsig = sig; 2433cbf4e354SDavid Xu while ((p->p_flag & P_TRACED) && (td->td_flags & TDF_XSIG)) { 2434cbf4e354SDavid Xu if (p->p_flag & P_SINGLE_EXIT) { 2435cbf4e354SDavid Xu mtx_lock_spin(&sched_lock); 2436cbf4e354SDavid Xu td->td_flags &= ~TDF_XSIG; 2437cbf4e354SDavid Xu mtx_unlock_spin(&sched_lock); 2438cbf4e354SDavid Xu return (sig); 2439cbf4e354SDavid Xu } 2440cbf4e354SDavid Xu /* 2441cbf4e354SDavid Xu * Just make wait() to work, the last stopped thread 2442cbf4e354SDavid Xu * will win. 2443cbf4e354SDavid Xu */ 2444cbf4e354SDavid Xu p->p_xstat = sig; 2445cbf4e354SDavid Xu p->p_xthread = td; 2446cbf4e354SDavid Xu p->p_flag |= (P_STOPPED_SIG|P_STOPPED_TRACE); 2447cbf4e354SDavid Xu mtx_lock_spin(&sched_lock); 2448d8267df7SDavid Xu sig_suspend_threads(td, p, 0); 2449cbf4e354SDavid Xu stopme: 2450cbf4e354SDavid Xu thread_stopped(p); 24514cc9f52fSRobert Drehmel thread_suspend_one(td); 24524cc9f52fSRobert Drehmel PROC_UNLOCK(p); 24534cc9f52fSRobert Drehmel DROP_GIANT(); 2454cbf4e354SDavid Xu mi_switch(SW_VOL, NULL); 24554cc9f52fSRobert Drehmel mtx_unlock_spin(&sched_lock); 24564cc9f52fSRobert Drehmel PICKUP_GIANT(); 2457cbf4e354SDavid Xu PROC_LOCK(p); 2458cbf4e354SDavid Xu if (!(p->p_flag & P_TRACED)) 2459cbf4e354SDavid Xu break; 2460cbf4e354SDavid Xu if (td->td_flags & TDF_DBSUSPEND) { 2461cbf4e354SDavid Xu if (p->p_flag & P_SINGLE_EXIT) 2462cbf4e354SDavid Xu break; 2463cbf4e354SDavid Xu mtx_lock_spin(&sched_lock); 2464cbf4e354SDavid Xu goto stopme; 2465cbf4e354SDavid Xu } 2466cbf4e354SDavid Xu } 2467cbf4e354SDavid Xu return (td->td_xsig); 24684cc9f52fSRobert Drehmel } 24694cc9f52fSRobert Drehmel 2470df8bae1dSRodney W. Grimes /* 2471df8bae1dSRodney W. Grimes * If the current process has received a signal (should be caught or cause 2472df8bae1dSRodney W. Grimes * termination, should interrupt current syscall), return the signal number. 2473df8bae1dSRodney W. Grimes * Stop signals with default action are processed immediately, then cleared; 2474df8bae1dSRodney W. Grimes * they aren't returned. This is checked after each entry to the system for 2475df8bae1dSRodney W. Grimes * a syscall or trap (though this can usually be done without calling issignal 2476628855e7SJulian Elischer * by checking the pending signal masks in cursig.) The normal call 2477df8bae1dSRodney W. Grimes * sequence is 2478df8bae1dSRodney W. Grimes * 2479e602ba25SJulian Elischer * while (sig = cursig(curthread)) 24802c42a146SMarcel Moolenaar * postsig(sig); 2481df8bae1dSRodney W. Grimes */ 24826711f10fSJohn Baldwin static int 2483e602ba25SJulian Elischer issignal(td) 2484e602ba25SJulian Elischer struct thread *td; 2485df8bae1dSRodney W. Grimes { 2486e602ba25SJulian Elischer struct proc *p; 248790af4afaSJohn Baldwin struct sigacts *ps; 24884093529dSJeff Roberson sigset_t sigpending; 2489cbf4e354SDavid Xu int sig, prop, newsig; 2490df8bae1dSRodney W. Grimes 2491e602ba25SJulian Elischer p = td->td_proc; 249290af4afaSJohn Baldwin ps = p->p_sigacts; 249390af4afaSJohn Baldwin mtx_assert(&ps->ps_mtx, MA_OWNED); 2494628d2653SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 2495df8bae1dSRodney W. Grimes for (;;) { 24962a024a2bSSean Eric Fagan int traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG); 24972a024a2bSSean Eric Fagan 24989104847fSDavid Xu sigpending = td->td_sigqueue.sq_signals; 24994093529dSJeff Roberson SIGSETNAND(sigpending, td->td_sigmask); 25004093529dSJeff Roberson 2501df8bae1dSRodney W. Grimes if (p->p_flag & P_PPWAIT) 25024093529dSJeff Roberson SIG_STOPSIGMASK(sigpending); 25034093529dSJeff Roberson if (SIGISEMPTY(sigpending)) /* no signal to send */ 2504df8bae1dSRodney W. Grimes return (0); 25054093529dSJeff Roberson sig = sig_ffs(&sigpending); 25062a024a2bSSean Eric Fagan 2507047aa39bSRobert Watson if (p->p_stops & S_SIG) { 2508047aa39bSRobert Watson mtx_unlock(&ps->ps_mtx); 2509047aa39bSRobert Watson stopevent(p, S_SIG, sig); 2510047aa39bSRobert Watson mtx_lock(&ps->ps_mtx); 2511047aa39bSRobert Watson } 25122a024a2bSSean Eric Fagan 2513df8bae1dSRodney W. Grimes /* 2514df8bae1dSRodney W. Grimes * We should see pending but ignored signals 2515df8bae1dSRodney W. Grimes * only if P_TRACED was on when they were posted. 2516df8bae1dSRodney W. Grimes */ 251790af4afaSJohn Baldwin if (SIGISMEMBER(ps->ps_sigignore, sig) && (traced == 0)) { 25189104847fSDavid Xu sigqueue_delete(&td->td_sigqueue, sig); 25198460a577SJohn Birrell #ifdef KSE 2520cbf4e354SDavid Xu if (td->td_pflags & TDP_SA) 2521cbf4e354SDavid Xu SIGADDSET(td->td_sigmask, sig); 25228460a577SJohn Birrell #endif 2523df8bae1dSRodney W. Grimes continue; 2524df8bae1dSRodney W. Grimes } 2525df8bae1dSRodney W. Grimes if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) { 2526df8bae1dSRodney W. Grimes /* 2527d8f4f6a4SJonathan Mini * If traced, always stop. 2528df8bae1dSRodney W. Grimes */ 252990af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 2530cbf4e354SDavid Xu newsig = ptracestop(td, sig); 253190af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 2532df8bae1dSRodney W. Grimes 25338460a577SJohn Birrell #ifdef KSE 25349104847fSDavid Xu if (td->td_pflags & TDP_SA) 25359104847fSDavid Xu SIGADDSET(td->td_sigmask, sig); 25369104847fSDavid Xu 25378460a577SJohn Birrell #endif 25389104847fSDavid Xu if (sig != newsig) { 2539413cf3bbSDavid Xu ksiginfo_t ksi; 25409104847fSDavid Xu /* 25419104847fSDavid Xu * clear old signal. 25429104847fSDavid Xu * XXX shrug off debugger, it causes siginfo to 25439104847fSDavid Xu * be thrown away. 25449104847fSDavid Xu */ 2545413cf3bbSDavid Xu sigqueue_get(&td->td_sigqueue, sig, &ksi); 25469104847fSDavid Xu 2547df8bae1dSRodney W. Grimes /* 2548df8bae1dSRodney W. Grimes * If parent wants us to take the signal, 2549df8bae1dSRodney W. Grimes * then it will leave it in p->p_xstat; 2550df8bae1dSRodney W. Grimes * otherwise we just look for signals again. 2551df8bae1dSRodney W. Grimes */ 2552cbf4e354SDavid Xu if (newsig == 0) 2553df8bae1dSRodney W. Grimes continue; 2554cbf4e354SDavid Xu sig = newsig; 25559104847fSDavid Xu 25569104847fSDavid Xu /* 25579104847fSDavid Xu * Put the new signal into td_sigqueue. If the 25589104847fSDavid Xu * signal is being masked, look for other signals. 25599104847fSDavid Xu */ 25609104847fSDavid Xu SIGADDSET(td->td_sigqueue.sq_signals, sig); 25618460a577SJohn Birrell #ifdef KSE 25629104847fSDavid Xu if (td->td_pflags & TDP_SA) 25639104847fSDavid Xu SIGDELSET(td->td_sigmask, sig); 25648460a577SJohn Birrell #endif 25659104847fSDavid Xu if (SIGISMEMBER(td->td_sigmask, sig)) 25669104847fSDavid Xu continue; 25679104847fSDavid Xu signotify(td); 25689104847fSDavid Xu } 25699104847fSDavid Xu 2570df8bae1dSRodney W. Grimes /* 25718d542cb5SDavid E. O'Brien * If the traced bit got turned off, go back up 25728d542cb5SDavid E. O'Brien * to the top to rescan signals. This ensures 25738d542cb5SDavid E. O'Brien * that p_sig* and p_sigact are consistent. 25748d542cb5SDavid E. O'Brien */ 25758d542cb5SDavid E. O'Brien if ((p->p_flag & P_TRACED) == 0) 25768d542cb5SDavid E. O'Brien continue; 2577df8bae1dSRodney W. Grimes } 2578df8bae1dSRodney W. Grimes 25798d542cb5SDavid E. O'Brien prop = sigprop(sig); 25808d542cb5SDavid E. O'Brien 2581df8bae1dSRodney W. Grimes /* 2582df8bae1dSRodney W. Grimes * Decide whether the signal should be returned. 2583df8bae1dSRodney W. Grimes * Return the signal's number, or fall through 2584df8bae1dSRodney W. Grimes * to clear it from the pending mask. 2585df8bae1dSRodney W. Grimes */ 2586d321df47SPoul-Henning Kamp switch ((intptr_t)p->p_sigacts->ps_sigact[_SIG_IDX(sig)]) { 2587df8bae1dSRodney W. Grimes 2588d321df47SPoul-Henning Kamp case (intptr_t)SIG_DFL: 2589df8bae1dSRodney W. Grimes /* 2590df8bae1dSRodney W. Grimes * Don't take default actions on system processes. 2591df8bae1dSRodney W. Grimes */ 2592df8bae1dSRodney W. Grimes if (p->p_pid <= 1) { 2593df8bae1dSRodney W. Grimes #ifdef DIAGNOSTIC 2594df8bae1dSRodney W. Grimes /* 2595df8bae1dSRodney W. Grimes * Are you sure you want to ignore SIGSEGV 2596df8bae1dSRodney W. Grimes * in init? XXX 2597df8bae1dSRodney W. Grimes */ 2598d93f860cSPoul-Henning Kamp printf("Process (pid %lu) got signal %d\n", 25992c42a146SMarcel Moolenaar (u_long)p->p_pid, sig); 2600df8bae1dSRodney W. Grimes #endif 2601df8bae1dSRodney W. Grimes break; /* == ignore */ 2602df8bae1dSRodney W. Grimes } 2603df8bae1dSRodney W. Grimes /* 2604df8bae1dSRodney W. Grimes * If there is a pending stop signal to process 2605df8bae1dSRodney W. Grimes * with default action, stop here, 2606df8bae1dSRodney W. Grimes * then clear the signal. However, 2607df8bae1dSRodney W. Grimes * if process is member of an orphaned 2608df8bae1dSRodney W. Grimes * process group, ignore tty stop signals. 2609df8bae1dSRodney W. Grimes */ 2610df8bae1dSRodney W. Grimes if (prop & SA_STOP) { 2611df8bae1dSRodney W. Grimes if (p->p_flag & P_TRACED || 2612df8bae1dSRodney W. Grimes (p->p_pgrp->pg_jobc == 0 && 2613df8bae1dSRodney W. Grimes prop & SA_TTYSTOP)) 2614df8bae1dSRodney W. Grimes break; /* == ignore */ 261590af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 261690af4afaSJohn Baldwin WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, 261790af4afaSJohn Baldwin &p->p_mtx.mtx_object, "Catching SIGSTOP"); 2618e574e444SDavid Xu p->p_flag |= P_STOPPED_SIG; 26192c42a146SMarcel Moolenaar p->p_xstat = sig; 2620721e5910SJulian Elischer mtx_lock_spin(&sched_lock); 2621d8267df7SDavid Xu sig_suspend_threads(td, p, 0); 2622e574e444SDavid Xu thread_stopped(p); 262371fad9fdSJulian Elischer thread_suspend_one(td); 2624721e5910SJulian Elischer PROC_UNLOCK(p); 2625721e5910SJulian Elischer DROP_GIANT(); 2626bf0acc27SJohn Baldwin mi_switch(SW_INVOL, NULL); 2627721e5910SJulian Elischer mtx_unlock_spin(&sched_lock); 2628721e5910SJulian Elischer PICKUP_GIANT(); 2629721e5910SJulian Elischer PROC_LOCK(p); 263090af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 2631df8bae1dSRodney W. Grimes break; 263221b68415SDavid E. O'Brien } else if (prop & SA_IGNORE) { 2633df8bae1dSRodney W. Grimes /* 2634df8bae1dSRodney W. Grimes * Except for SIGCONT, shouldn't get here. 2635df8bae1dSRodney W. Grimes * Default action is to ignore; drop it. 2636df8bae1dSRodney W. Grimes */ 2637df8bae1dSRodney W. Grimes break; /* == ignore */ 2638df8bae1dSRodney W. Grimes } else 26392c42a146SMarcel Moolenaar return (sig); 2640df8bae1dSRodney W. Grimes /*NOTREACHED*/ 2641df8bae1dSRodney W. Grimes 2642d321df47SPoul-Henning Kamp case (intptr_t)SIG_IGN: 2643df8bae1dSRodney W. Grimes /* 2644df8bae1dSRodney W. Grimes * Masking above should prevent us ever trying 2645df8bae1dSRodney W. Grimes * to take action on an ignored signal other 2646df8bae1dSRodney W. Grimes * than SIGCONT, unless process is traced. 2647df8bae1dSRodney W. Grimes */ 2648df8bae1dSRodney W. Grimes if ((prop & SA_CONT) == 0 && 2649df8bae1dSRodney W. Grimes (p->p_flag & P_TRACED) == 0) 2650df8bae1dSRodney W. Grimes printf("issignal\n"); 2651df8bae1dSRodney W. Grimes break; /* == ignore */ 2652df8bae1dSRodney W. Grimes 2653df8bae1dSRodney W. Grimes default: 2654df8bae1dSRodney W. Grimes /* 2655df8bae1dSRodney W. Grimes * This signal has an action, let 2656df8bae1dSRodney W. Grimes * postsig() process it. 2657df8bae1dSRodney W. Grimes */ 26582c42a146SMarcel Moolenaar return (sig); 2659df8bae1dSRodney W. Grimes } 26609104847fSDavid Xu sigqueue_delete(&td->td_sigqueue, sig); /* take the signal! */ 2661df8bae1dSRodney W. Grimes } 2662df8bae1dSRodney W. Grimes /* NOTREACHED */ 2663df8bae1dSRodney W. Grimes } 2664df8bae1dSRodney W. Grimes 2665e574e444SDavid Xu void 2666e574e444SDavid Xu thread_stopped(struct proc *p) 2667e574e444SDavid Xu { 2668e574e444SDavid Xu int n; 2669e574e444SDavid Xu 2670e574e444SDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 2671e574e444SDavid Xu mtx_assert(&sched_lock, MA_OWNED); 2672e574e444SDavid Xu n = p->p_suspcount; 26737c9a98f1SDavid Xu if (p == curproc) 2674e574e444SDavid Xu n++; 2675e574e444SDavid Xu if ((p->p_flag & P_STOPPED_SIG) && (n == p->p_numthreads)) { 2676e574e444SDavid Xu mtx_unlock_spin(&sched_lock); 2677407948a5SDavid Xu p->p_flag &= ~P_WAITED; 2678e574e444SDavid Xu PROC_LOCK(p->p_pptr); 26797f96995eSDavid Xu childproc_stopped(p, (p->p_flag & P_TRACED) ? 2680ebceaf6dSDavid Xu CLD_TRAPPED : CLD_STOPPED); 2681e574e444SDavid Xu PROC_UNLOCK(p->p_pptr); 2682e574e444SDavid Xu mtx_lock_spin(&sched_lock); 2683e574e444SDavid Xu } 2684e574e444SDavid Xu } 2685e574e444SDavid Xu 2686df8bae1dSRodney W. Grimes /* 2687df8bae1dSRodney W. Grimes * Take the action for the specified signal 2688df8bae1dSRodney W. Grimes * from the current set of pending signals. 2689df8bae1dSRodney W. Grimes */ 2690df8bae1dSRodney W. Grimes void 26912c42a146SMarcel Moolenaar postsig(sig) 26922c42a146SMarcel Moolenaar register int sig; 2693df8bae1dSRodney W. Grimes { 2694b40ce416SJulian Elischer struct thread *td = curthread; 2695b40ce416SJulian Elischer register struct proc *p = td->td_proc; 2696628d2653SJohn Baldwin struct sigacts *ps; 26972c42a146SMarcel Moolenaar sig_t action; 26989104847fSDavid Xu ksiginfo_t ksi; 26992c42a146SMarcel Moolenaar sigset_t returnmask; 27002c42a146SMarcel Moolenaar int code; 2701df8bae1dSRodney W. Grimes 27022c42a146SMarcel Moolenaar KASSERT(sig != 0, ("postsig")); 27035526d2d9SEivind Eklund 27042ad7d304SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 2705628d2653SJohn Baldwin ps = p->p_sigacts; 270690af4afaSJohn Baldwin mtx_assert(&ps->ps_mtx, MA_OWNED); 27075da49fcbSDavid Xu ksiginfo_init(&ksi); 27089104847fSDavid Xu sigqueue_get(&td->td_sigqueue, sig, &ksi); 27099104847fSDavid Xu ksi.ksi_signo = sig; 271056c06c4bSDavid Xu if (ksi.ksi_code == SI_TIMER) 271156c06c4bSDavid Xu itimer_accept(p, ksi.ksi_timerid, &ksi); 27122c42a146SMarcel Moolenaar action = ps->ps_sigact[_SIG_IDX(sig)]; 2713df8bae1dSRodney W. Grimes #ifdef KTRACE 2714374a15aaSJohn Baldwin if (KTRPOINT(td, KTR_PSIG)) 27155e26dcb5SJohn Baldwin ktrpsig(sig, action, td->td_pflags & TDP_OLDMASK ? 27164093529dSJeff Roberson &td->td_oldsigmask : &td->td_sigmask, 0); 2717df8bae1dSRodney W. Grimes #endif 2718047aa39bSRobert Watson if (p->p_stops & S_SIG) { 2719047aa39bSRobert Watson mtx_unlock(&ps->ps_mtx); 2720047aa39bSRobert Watson stopevent(p, S_SIG, sig); 2721047aa39bSRobert Watson mtx_lock(&ps->ps_mtx); 2722047aa39bSRobert Watson } 27232a024a2bSSean Eric Fagan 27248460a577SJohn Birrell #ifdef KSE 2725cbf4e354SDavid Xu if (!(td->td_pflags & TDP_SA) && action == SIG_DFL) { 27268460a577SJohn Birrell #else 27278460a577SJohn Birrell if (action == SIG_DFL) { 27288460a577SJohn Birrell #endif 2729df8bae1dSRodney W. Grimes /* 2730df8bae1dSRodney W. Grimes * Default action, where the default is to kill 2731df8bae1dSRodney W. Grimes * the process. (Other cases were ignored above.) 2732df8bae1dSRodney W. Grimes */ 273390af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 2734b40ce416SJulian Elischer sigexit(td, sig); 2735df8bae1dSRodney W. Grimes /* NOTREACHED */ 2736df8bae1dSRodney W. Grimes } else { 27378460a577SJohn Birrell #ifdef KSE 2738cbf4e354SDavid Xu if (td->td_pflags & TDP_SA) { 2739432b45deSDavid Xu if (sig == SIGKILL) { 2740432b45deSDavid Xu mtx_unlock(&ps->ps_mtx); 2741432b45deSDavid Xu sigexit(td, sig); 2742432b45deSDavid Xu } 2743432b45deSDavid Xu } 2744432b45deSDavid Xu 27458460a577SJohn Birrell #endif 2746df8bae1dSRodney W. Grimes /* 2747df8bae1dSRodney W. Grimes * If we get here, the signal must be caught. 2748df8bae1dSRodney W. Grimes */ 27494093529dSJeff Roberson KASSERT(action != SIG_IGN && !SIGISMEMBER(td->td_sigmask, sig), 27505526d2d9SEivind Eklund ("postsig action")); 2751df8bae1dSRodney W. Grimes /* 2752df8bae1dSRodney W. Grimes * Set the new mask value and also defer further 2753645682fdSLuoqi Chen * occurrences of this signal. 2754df8bae1dSRodney W. Grimes * 2755645682fdSLuoqi Chen * Special case: user has done a sigsuspend. Here the 2756df8bae1dSRodney W. Grimes * current mask is not of interest, but rather the 2757645682fdSLuoqi Chen * mask from before the sigsuspend is what we want 2758df8bae1dSRodney W. Grimes * restored after the signal processing is completed. 2759df8bae1dSRodney W. Grimes */ 27605e26dcb5SJohn Baldwin if (td->td_pflags & TDP_OLDMASK) { 27614093529dSJeff Roberson returnmask = td->td_oldsigmask; 27625e26dcb5SJohn Baldwin td->td_pflags &= ~TDP_OLDMASK; 2763df8bae1dSRodney W. Grimes } else 27644093529dSJeff Roberson returnmask = td->td_sigmask; 27652c42a146SMarcel Moolenaar 27664093529dSJeff Roberson SIGSETOR(td->td_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]); 27672c42a146SMarcel Moolenaar if (!SIGISMEMBER(ps->ps_signodefer, sig)) 27684093529dSJeff Roberson SIGADDSET(td->td_sigmask, sig); 27692c42a146SMarcel Moolenaar 27702c42a146SMarcel Moolenaar if (SIGISMEMBER(ps->ps_sigreset, sig)) { 2771289ccde0SPeter Wemm /* 27728f19eb88SIan Dowse * See kern_sigaction() for origin of this code. 2773289ccde0SPeter Wemm */ 277490af4afaSJohn Baldwin SIGDELSET(ps->ps_sigcatch, sig); 27752c42a146SMarcel Moolenaar if (sig != SIGCONT && 27762c42a146SMarcel Moolenaar sigprop(sig) & SA_IGNORE) 277790af4afaSJohn Baldwin SIGADDSET(ps->ps_sigignore, sig); 27782c42a146SMarcel Moolenaar ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; 2779dedc04feSPeter Wemm } 2780df8bae1dSRodney W. Grimes p->p_stats->p_ru.ru_nsignals++; 27812c42a146SMarcel Moolenaar if (p->p_sig != sig) { 2782df8bae1dSRodney W. Grimes code = 0; 2783df8bae1dSRodney W. Grimes } else { 27846626c604SJulian Elischer code = p->p_code; 27856626c604SJulian Elischer p->p_code = 0; 27866626c604SJulian Elischer p->p_sig = 0; 2787df8bae1dSRodney W. Grimes } 27888460a577SJohn Birrell #ifdef KSE 2789cbf4e354SDavid Xu if (td->td_pflags & TDP_SA) 27909104847fSDavid Xu thread_signal_add(curthread, &ksi); 279158a3c273SJeff Roberson else 27929104847fSDavid Xu (*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask); 27938460a577SJohn Birrell #else 27948460a577SJohn Birrell (*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask); 27958460a577SJohn Birrell #endif 2796df8bae1dSRodney W. Grimes } 2797df8bae1dSRodney W. Grimes } 2798df8bae1dSRodney W. Grimes 2799df8bae1dSRodney W. Grimes /* 2800df8bae1dSRodney W. Grimes * Kill the current process for stated reason. 2801df8bae1dSRodney W. Grimes */ 280226f9a767SRodney W. Grimes void 2803df8bae1dSRodney W. Grimes killproc(p, why) 2804df8bae1dSRodney W. Grimes struct proc *p; 2805df8bae1dSRodney W. Grimes char *why; 2806df8bae1dSRodney W. Grimes { 28079081e5e8SJohn Baldwin 28089081e5e8SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 28090384fff8SJason Evans CTR3(KTR_PROC, "killproc: proc %p (pid %d, %s)", 28100384fff8SJason Evans p, p->p_pid, p->p_comm); 2811729b1e51SDavid Greenman log(LOG_ERR, "pid %d (%s), uid %d, was killed: %s\n", p->p_pid, p->p_comm, 2812b1fc0ec1SRobert Watson p->p_ucred ? p->p_ucred->cr_uid : -1, why); 2813df8bae1dSRodney W. Grimes psignal(p, SIGKILL); 2814df8bae1dSRodney W. Grimes } 2815df8bae1dSRodney W. Grimes 2816df8bae1dSRodney W. Grimes /* 2817df8bae1dSRodney W. Grimes * Force the current process to exit with the specified signal, dumping core 2818df8bae1dSRodney W. Grimes * if appropriate. We bypass the normal tests for masked and caught signals, 2819df8bae1dSRodney W. Grimes * allowing unrecoverable failures to terminate the process without changing 2820df8bae1dSRodney W. Grimes * signal state. Mark the accounting record with the signal termination. 2821df8bae1dSRodney W. Grimes * If dumping core, save the signal number for the debugger. Calls exit and 2822df8bae1dSRodney W. Grimes * does not return. 2823df8bae1dSRodney W. Grimes */ 282426f9a767SRodney W. Grimes void 2825b40ce416SJulian Elischer sigexit(td, sig) 2826b40ce416SJulian Elischer struct thread *td; 28272c42a146SMarcel Moolenaar int sig; 2828df8bae1dSRodney W. Grimes { 2829b40ce416SJulian Elischer struct proc *p = td->td_proc; 2830df8bae1dSRodney W. Grimes 2831628d2653SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 2832df8bae1dSRodney W. Grimes p->p_acflag |= AXSIG; 2833f97c3df1SDavid Schultz /* 2834f97c3df1SDavid Schultz * We must be single-threading to generate a core dump. This 2835f97c3df1SDavid Schultz * ensures that the registers in the core file are up-to-date. 2836f97c3df1SDavid Schultz * Also, the ELF dump handler assumes that the thread list doesn't 2837f97c3df1SDavid Schultz * change out from under it. 2838f97c3df1SDavid Schultz * 2839f97c3df1SDavid Schultz * XXX If another thread attempts to single-thread before us 2840f97c3df1SDavid Schultz * (e.g. via fork()), we won't get a dump at all. 2841f97c3df1SDavid Schultz */ 2842f97c3df1SDavid Schultz if ((sigprop(sig) & SA_CORE) && (thread_single(SINGLE_NO_EXIT) == 0)) { 28432c42a146SMarcel Moolenaar p->p_sig = sig; 2844c364e17eSAndrey A. Chernov /* 2845c364e17eSAndrey A. Chernov * Log signals which would cause core dumps 2846c364e17eSAndrey A. Chernov * (Log as LOG_INFO to appease those who don't want 2847c364e17eSAndrey A. Chernov * these messages.) 2848c364e17eSAndrey A. Chernov * XXX : Todo, as well as euid, write out ruid too 28494ae89b95SJohn Baldwin * Note that coredump() drops proc lock. 2850c364e17eSAndrey A. Chernov */ 2851b40ce416SJulian Elischer if (coredump(td) == 0) 28522c42a146SMarcel Moolenaar sig |= WCOREFLAG; 285357308494SJoerg Wunsch if (kern_logsigexit) 285457308494SJoerg Wunsch log(LOG_INFO, 285557308494SJoerg Wunsch "pid %d (%s), uid %d: exited on signal %d%s\n", 28563d1b21c6SAndrey A. Chernov p->p_pid, p->p_comm, 28579c1ab3e0SJohn Baldwin td->td_ucred ? td->td_ucred->cr_uid : -1, 28582c42a146SMarcel Moolenaar sig &~ WCOREFLAG, 28592c42a146SMarcel Moolenaar sig & WCOREFLAG ? " (core dumped)" : ""); 28604ae89b95SJohn Baldwin } else 2861628d2653SJohn Baldwin PROC_UNLOCK(p); 2862b40ce416SJulian Elischer exit1(td, W_EXITCODE(0, sig)); 2863df8bae1dSRodney W. Grimes /* NOTREACHED */ 2864df8bae1dSRodney W. Grimes } 2865df8bae1dSRodney W. Grimes 2866ebceaf6dSDavid Xu /* 28677f96995eSDavid Xu * Send queued SIGCHLD to parent when child process's state 28687f96995eSDavid Xu * is changed. 2869ebceaf6dSDavid Xu */ 28707f96995eSDavid Xu static void 28717f96995eSDavid Xu sigparent(struct proc *p, int reason, int status) 2872ebceaf6dSDavid Xu { 2873ebceaf6dSDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 2874ebceaf6dSDavid Xu PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED); 2875ebceaf6dSDavid Xu 2876ebceaf6dSDavid Xu if (p->p_ksi != NULL) { 2877ebceaf6dSDavid Xu p->p_ksi->ksi_signo = SIGCHLD; 2878ebceaf6dSDavid Xu p->p_ksi->ksi_code = reason; 28797f96995eSDavid Xu p->p_ksi->ksi_status = status; 2880ebceaf6dSDavid Xu p->p_ksi->ksi_pid = p->p_pid; 2881ebceaf6dSDavid Xu p->p_ksi->ksi_uid = p->p_ucred->cr_ruid; 2882ebceaf6dSDavid Xu if (KSI_ONQ(p->p_ksi)) 2883ebceaf6dSDavid Xu return; 2884ebceaf6dSDavid Xu } 2885ebceaf6dSDavid Xu tdsignal(p->p_pptr, NULL, SIGCHLD, p->p_ksi); 2886ebceaf6dSDavid Xu } 2887ebceaf6dSDavid Xu 28887f96995eSDavid Xu static void 28897f96995eSDavid Xu childproc_jobstate(struct proc *p, int reason, int status) 28907f96995eSDavid Xu { 28917f96995eSDavid Xu struct sigacts *ps; 28927f96995eSDavid Xu 28937f96995eSDavid Xu PROC_LOCK_ASSERT(p, MA_OWNED); 28947f96995eSDavid Xu PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED); 28957f96995eSDavid Xu 28967f96995eSDavid Xu /* 28977f96995eSDavid Xu * Wake up parent sleeping in kern_wait(), also send 28987f96995eSDavid Xu * SIGCHLD to parent, but SIGCHLD does not guarantee 28997f96995eSDavid Xu * that parent will awake, because parent may masked 29007f96995eSDavid Xu * the signal. 29017f96995eSDavid Xu */ 29027f96995eSDavid Xu p->p_pptr->p_flag |= P_STATCHILD; 29037f96995eSDavid Xu wakeup(p->p_pptr); 29047f96995eSDavid Xu 29057f96995eSDavid Xu ps = p->p_pptr->p_sigacts; 29067f96995eSDavid Xu mtx_lock(&ps->ps_mtx); 29077f96995eSDavid Xu if ((ps->ps_flag & PS_NOCLDSTOP) == 0) { 29087f96995eSDavid Xu mtx_unlock(&ps->ps_mtx); 29097f96995eSDavid Xu sigparent(p, reason, status); 29107f96995eSDavid Xu } else 29117f96995eSDavid Xu mtx_unlock(&ps->ps_mtx); 29127f96995eSDavid Xu } 29137f96995eSDavid Xu 29147f96995eSDavid Xu void 29157f96995eSDavid Xu childproc_stopped(struct proc *p, int reason) 29167f96995eSDavid Xu { 29177f96995eSDavid Xu childproc_jobstate(p, reason, p->p_xstat); 29187f96995eSDavid Xu } 29197f96995eSDavid Xu 2920ebceaf6dSDavid Xu void 2921ebceaf6dSDavid Xu childproc_continued(struct proc *p) 2922ebceaf6dSDavid Xu { 29237f96995eSDavid Xu childproc_jobstate(p, CLD_CONTINUED, SIGCONT); 2924ebceaf6dSDavid Xu } 2925ebceaf6dSDavid Xu 2926ebceaf6dSDavid Xu void 2927ebceaf6dSDavid Xu childproc_exited(struct proc *p) 2928ebceaf6dSDavid Xu { 2929ebceaf6dSDavid Xu int reason; 2930f4d85223SDavid Xu int status = p->p_xstat; /* convert to int */ 2931ebceaf6dSDavid Xu 2932ebceaf6dSDavid Xu reason = CLD_EXITED; 2933f4d85223SDavid Xu if (WCOREDUMP(status)) 2934ebceaf6dSDavid Xu reason = CLD_DUMPED; 2935f4d85223SDavid Xu else if (WIFSIGNALED(status)) 2936ebceaf6dSDavid Xu reason = CLD_KILLED; 29377f96995eSDavid Xu /* 29387f96995eSDavid Xu * XXX avoid calling wakeup(p->p_pptr), the work is 29397f96995eSDavid Xu * done in exit1(). 29407f96995eSDavid Xu */ 29417f96995eSDavid Xu sigparent(p, reason, status); 2942ebceaf6dSDavid Xu } 2943ebceaf6dSDavid Xu 29446d1ab6edSWarner Losh static char corefilename[MAXPATHLEN] = {"%N.core"}; 2945c5edb423SSean Eric Fagan SYSCTL_STRING(_kern, OID_AUTO, corefile, CTLFLAG_RW, corefilename, 2946c5edb423SSean Eric Fagan sizeof(corefilename), "process corefile name format string"); 2947c5edb423SSean Eric Fagan 2948c5edb423SSean Eric Fagan /* 2949c5edb423SSean Eric Fagan * expand_name(name, uid, pid) 2950c5edb423SSean Eric Fagan * Expand the name described in corefilename, using name, uid, and pid. 2951c5edb423SSean Eric Fagan * corefilename is a printf-like string, with three format specifiers: 2952c5edb423SSean Eric Fagan * %N name of process ("name") 2953c5edb423SSean Eric Fagan * %P process id (pid) 2954c5edb423SSean Eric Fagan * %U user id (uid) 2955c5edb423SSean Eric Fagan * For example, "%N.core" is the default; they can be disabled completely 2956c5edb423SSean Eric Fagan * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P". 2957c5edb423SSean Eric Fagan * This is controlled by the sysctl variable kern.corefile (see above). 2958c5edb423SSean Eric Fagan */ 2959c5edb423SSean Eric Fagan 2960fca666a1SJulian Elischer static char * 2961c5edb423SSean Eric Fagan expand_name(name, uid, pid) 29628b43b535SAlfred Perlstein const char *name; 29638b43b535SAlfred Perlstein uid_t uid; 29648b43b535SAlfred Perlstein pid_t pid; 29658b43b535SAlfred Perlstein { 29668b43b535SAlfred Perlstein const char *format, *appendstr; 2967c5edb423SSean Eric Fagan char *temp; 2968c5edb423SSean Eric Fagan char buf[11]; /* Buffer for pid/uid -- max 4B */ 29698b43b535SAlfred Perlstein size_t i, l, n; 2970c5edb423SSean Eric Fagan 29718b43b535SAlfred Perlstein format = corefilename; 29728b43b535SAlfred Perlstein temp = malloc(MAXPATHLEN, M_TEMP, M_NOWAIT | M_ZERO); 29730bfe2990SEivind Eklund if (temp == NULL) 29748b43b535SAlfred Perlstein return (NULL); 2975ce38ca0fSAlfred Perlstein for (i = 0, n = 0; n < MAXPATHLEN && format[i]; i++) { 2976c5edb423SSean Eric Fagan switch (format[i]) { 2977c5edb423SSean Eric Fagan case '%': /* Format character */ 2978c5edb423SSean Eric Fagan i++; 2979c5edb423SSean Eric Fagan switch (format[i]) { 2980c5edb423SSean Eric Fagan case '%': 29818b43b535SAlfred Perlstein appendstr = "%"; 2982c5edb423SSean Eric Fagan break; 2983c5edb423SSean Eric Fagan case 'N': /* process name */ 29848b43b535SAlfred Perlstein appendstr = name; 2985c5edb423SSean Eric Fagan break; 2986c5edb423SSean Eric Fagan case 'P': /* process id */ 29878b43b535SAlfred Perlstein sprintf(buf, "%u", pid); 29888b43b535SAlfred Perlstein appendstr = buf; 2989c5edb423SSean Eric Fagan break; 2990c5edb423SSean Eric Fagan case 'U': /* user id */ 29918b43b535SAlfred Perlstein sprintf(buf, "%u", uid); 29928b43b535SAlfred Perlstein appendstr = buf; 2993c5edb423SSean Eric Fagan break; 2994c5edb423SSean Eric Fagan default: 29958b43b535SAlfred Perlstein appendstr = ""; 29968b43b535SAlfred Perlstein log(LOG_ERR, 29978b43b535SAlfred Perlstein "Unknown format character %c in `%s'\n", 29988b43b535SAlfred Perlstein format[i], format); 2999c5edb423SSean Eric Fagan } 30008b43b535SAlfred Perlstein l = strlen(appendstr); 30018b43b535SAlfred Perlstein if ((n + l) >= MAXPATHLEN) 30028b43b535SAlfred Perlstein goto toolong; 30038b43b535SAlfred Perlstein memcpy(temp + n, appendstr, l); 30048b43b535SAlfred Perlstein n += l; 3005c5edb423SSean Eric Fagan break; 3006c5edb423SSean Eric Fagan default: 3007c5edb423SSean Eric Fagan temp[n++] = format[i]; 3008c5edb423SSean Eric Fagan } 3009c5edb423SSean Eric Fagan } 30108b43b535SAlfred Perlstein if (format[i] != '\0') 30118b43b535SAlfred Perlstein goto toolong; 30128b43b535SAlfred Perlstein return (temp); 30138b43b535SAlfred Perlstein toolong: 30148b43b535SAlfred Perlstein log(LOG_ERR, "pid %ld (%s), uid (%lu): corename is too long\n", 30158b43b535SAlfred Perlstein (long)pid, name, (u_long)uid); 30168b43b535SAlfred Perlstein free(temp, M_TEMP); 30178b43b535SAlfred Perlstein return (NULL); 3018c5edb423SSean Eric Fagan } 3019c5edb423SSean Eric Fagan 3020df8bae1dSRodney W. Grimes /* 3021fca666a1SJulian Elischer * Dump a process' core. The main routine does some 3022fca666a1SJulian Elischer * policy checking, and creates the name of the coredump; 3023fca666a1SJulian Elischer * then it passes on a vnode and a size limit to the process-specific 3024fca666a1SJulian Elischer * coredump routine if there is one; if there _is not_ one, it returns 3025fca666a1SJulian Elischer * ENOSYS; otherwise it returns the error from the process-specific routine. 3026fca666a1SJulian Elischer */ 3027fca666a1SJulian Elischer 3028fca666a1SJulian Elischer static int 3029b40ce416SJulian Elischer coredump(struct thread *td) 3030fca666a1SJulian Elischer { 3031b40ce416SJulian Elischer struct proc *p = td->td_proc; 3032fca666a1SJulian Elischer register struct vnode *vp; 30339c1ab3e0SJohn Baldwin register struct ucred *cred = td->td_ucred; 303406ae1e91SMatthew Dillon struct flock lf; 3035fca666a1SJulian Elischer struct nameidata nd; 3036fca666a1SJulian Elischer struct vattr vattr; 3037c447f5b2SRobert Watson int error, error1, flags, locked; 3038f2a2857bSKirk McKusick struct mount *mp; 3039fca666a1SJulian Elischer char *name; /* name of corefile */ 3040fca666a1SJulian Elischer off_t limit; 304133f19beeSJohn Baldwin int vfslocked; 3042fca666a1SJulian Elischer 30434ae89b95SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 3044f97c3df1SDavid Schultz MPASS((p->p_flag & P_HADTHREADS) == 0 || p->p_singlethread == td); 3045628d2653SJohn Baldwin _STOPEVENT(p, S_CORE, 0); 3046fca666a1SJulian Elischer 3047628d2653SJohn Baldwin if (((sugid_coredump == 0) && p->p_flag & P_SUGID) || do_coredump == 0) { 3048628d2653SJohn Baldwin PROC_UNLOCK(p); 3049fca666a1SJulian Elischer return (EFAULT); 3050628d2653SJohn Baldwin } 3051fca666a1SJulian Elischer 3052fca666a1SJulian Elischer /* 305335a2598fSSean Eric Fagan * Note that the bulk of limit checking is done after 305435a2598fSSean Eric Fagan * the corefile is created. The exception is if the limit 305535a2598fSSean Eric Fagan * for corefiles is 0, in which case we don't bother 305635a2598fSSean Eric Fagan * creating the corefile at all. This layout means that 305735a2598fSSean Eric Fagan * a corefile is truncated instead of not being created, 305835a2598fSSean Eric Fagan * if it is larger than the limit. 3059fca666a1SJulian Elischer */ 306091d5354aSJohn Baldwin limit = (off_t)lim_cur(p, RLIMIT_CORE); 3061628d2653SJohn Baldwin PROC_UNLOCK(p); 306291d5354aSJohn Baldwin if (limit == 0) 306391d5354aSJohn Baldwin return (EFBIG); 306435a2598fSSean Eric Fagan 3065f2a2857bSKirk McKusick restart: 30669c1ab3e0SJohn Baldwin name = expand_name(p->p_comm, td->td_ucred->cr_uid, p->p_pid); 306733f19beeSJohn Baldwin if (name == NULL) 3068ccdbd10cSPeter Pentchev return (EINVAL); 306933f19beeSJohn Baldwin NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE, UIO_SYSSPACE, name, td); 3070e6796b67SKirk McKusick flags = O_CREAT | FWRITE | O_NOFOLLOW; 30717c89f162SPoul-Henning Kamp error = vn_open(&nd, &flags, S_IRUSR | S_IWUSR, -1); 3072fca666a1SJulian Elischer free(name, M_TEMP); 307333f19beeSJohn Baldwin if (error) 3074fca666a1SJulian Elischer return (error); 307533f19beeSJohn Baldwin vfslocked = NDHASGIANT(&nd); 3076762e6b85SEivind Eklund NDFREE(&nd, NDF_ONLY_PNBUF); 3077fca666a1SJulian Elischer vp = nd.ni_vp; 307806ae1e91SMatthew Dillon 3079832dafadSDon Lewis /* Don't dump to non-regular files or files with links. */ 3080832dafadSDon Lewis if (vp->v_type != VREG || 3081832dafadSDon Lewis VOP_GETATTR(vp, &vattr, cred, td) || vattr.va_nlink != 1) { 3082832dafadSDon Lewis VOP_UNLOCK(vp, 0, td); 3083832dafadSDon Lewis error = EFAULT; 308433f19beeSJohn Baldwin goto close; 3085832dafadSDon Lewis } 3086832dafadSDon Lewis 3087b40ce416SJulian Elischer VOP_UNLOCK(vp, 0, td); 308806ae1e91SMatthew Dillon lf.l_whence = SEEK_SET; 308906ae1e91SMatthew Dillon lf.l_start = 0; 309006ae1e91SMatthew Dillon lf.l_len = 0; 309106ae1e91SMatthew Dillon lf.l_type = F_WRLCK; 3092c447f5b2SRobert Watson locked = (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &lf, F_FLOCK) == 0); 309306ae1e91SMatthew Dillon 309406ae1e91SMatthew Dillon if (vn_start_write(vp, &mp, V_NOWAIT) != 0) { 309506ae1e91SMatthew Dillon lf.l_type = F_UNLCK; 309636bbf86bSRobert Watson if (locked) 309706ae1e91SMatthew Dillon VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK); 3098b40ce416SJulian Elischer if ((error = vn_close(vp, FWRITE, cred, td)) != 0) 309933f19beeSJohn Baldwin goto out; 3100f2a2857bSKirk McKusick if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 310133f19beeSJohn Baldwin goto out; 310233f19beeSJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 3103f2a2857bSKirk McKusick goto restart; 3104f2a2857bSKirk McKusick } 3105fca666a1SJulian Elischer 3106fca666a1SJulian Elischer VATTR_NULL(&vattr); 3107fca666a1SJulian Elischer vattr.va_size = 0; 31086141e04aSJohn-Mark Gurney if (set_core_nodump_flag) 31096141e04aSJohn-Mark Gurney vattr.va_flags = UF_NODUMP; 311088b1d98fSPaul Saab vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3111b40ce416SJulian Elischer VOP_LEASE(vp, td, cred, LEASE_WRITE); 3112b40ce416SJulian Elischer VOP_SETATTR(vp, &vattr, cred, td); 311388b1d98fSPaul Saab VOP_UNLOCK(vp, 0, td); 311411991ab4STor Egge vn_finished_write(mp); 3115628d2653SJohn Baldwin PROC_LOCK(p); 3116fca666a1SJulian Elischer p->p_acflag |= ACORE; 3117628d2653SJohn Baldwin PROC_UNLOCK(p); 3118fca666a1SJulian Elischer 3119fca666a1SJulian Elischer error = p->p_sysent->sv_coredump ? 3120b40ce416SJulian Elischer p->p_sysent->sv_coredump(td, vp, limit) : 3121fca666a1SJulian Elischer ENOSYS; 3122fca666a1SJulian Elischer 3123c447f5b2SRobert Watson if (locked) { 312406ae1e91SMatthew Dillon lf.l_type = F_UNLCK; 312506ae1e91SMatthew Dillon VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK); 3126c447f5b2SRobert Watson } 312733f19beeSJohn Baldwin close: 3128b40ce416SJulian Elischer error1 = vn_close(vp, FWRITE, cred, td); 3129fca666a1SJulian Elischer if (error == 0) 3130fca666a1SJulian Elischer error = error1; 313133f19beeSJohn Baldwin out: 313233f19beeSJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 3133fca666a1SJulian Elischer return (error); 3134fca666a1SJulian Elischer } 3135fca666a1SJulian Elischer 3136fca666a1SJulian Elischer /* 31370c14ff0eSRobert Watson * Nonexistent system call-- signal process (may want to handle it). Flag 31380c14ff0eSRobert Watson * error in case process won't see signal immediately (blocked or ignored). 3139df8bae1dSRodney W. Grimes */ 3140d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 3141df8bae1dSRodney W. Grimes struct nosys_args { 3142df8bae1dSRodney W. Grimes int dummy; 3143df8bae1dSRodney W. Grimes }; 3144d2d3e875SBruce Evans #endif 3145df8bae1dSRodney W. Grimes /* ARGSUSED */ 314626f9a767SRodney W. Grimes int 3147b40ce416SJulian Elischer nosys(td, args) 3148b40ce416SJulian Elischer struct thread *td; 3149df8bae1dSRodney W. Grimes struct nosys_args *args; 3150df8bae1dSRodney W. Grimes { 3151b40ce416SJulian Elischer struct proc *p = td->td_proc; 3152b40ce416SJulian Elischer 3153628d2653SJohn Baldwin PROC_LOCK(p); 3154df8bae1dSRodney W. Grimes psignal(p, SIGSYS); 3155628d2653SJohn Baldwin PROC_UNLOCK(p); 3156f5216b9aSBruce Evans return (ENOSYS); 3157df8bae1dSRodney W. Grimes } 3158831d27a9SDon Lewis 3159831d27a9SDon Lewis /* 31600c14ff0eSRobert Watson * Send a SIGIO or SIGURG signal to a process or process group using stored 31610c14ff0eSRobert Watson * credentials rather than those of the current process. 3162831d27a9SDon Lewis */ 3163831d27a9SDon Lewis void 3164f1320723SAlfred Perlstein pgsigio(sigiop, sig, checkctty) 3165f1320723SAlfred Perlstein struct sigio **sigiop; 31662c42a146SMarcel Moolenaar int sig, checkctty; 3167831d27a9SDon Lewis { 3168f1320723SAlfred Perlstein struct sigio *sigio; 3169831d27a9SDon Lewis 3170f1320723SAlfred Perlstein SIGIO_LOCK(); 3171f1320723SAlfred Perlstein sigio = *sigiop; 3172f1320723SAlfred Perlstein if (sigio == NULL) { 3173f1320723SAlfred Perlstein SIGIO_UNLOCK(); 3174f1320723SAlfred Perlstein return; 3175f1320723SAlfred Perlstein } 3176831d27a9SDon Lewis if (sigio->sio_pgid > 0) { 3177628d2653SJohn Baldwin PROC_LOCK(sigio->sio_proc); 31782b87b6d4SRobert Watson if (CANSIGIO(sigio->sio_ucred, sigio->sio_proc->p_ucred)) 31792c42a146SMarcel Moolenaar psignal(sigio->sio_proc, sig); 3180628d2653SJohn Baldwin PROC_UNLOCK(sigio->sio_proc); 3181831d27a9SDon Lewis } else if (sigio->sio_pgid < 0) { 3182831d27a9SDon Lewis struct proc *p; 3183831d27a9SDon Lewis 3184f591779bSSeigo Tanimura PGRP_LOCK(sigio->sio_pgrp); 3185628d2653SJohn Baldwin LIST_FOREACH(p, &sigio->sio_pgrp->pg_members, p_pglist) { 3186628d2653SJohn Baldwin PROC_LOCK(p); 31872b87b6d4SRobert Watson if (CANSIGIO(sigio->sio_ucred, p->p_ucred) && 3188831d27a9SDon Lewis (checkctty == 0 || (p->p_flag & P_CONTROLT))) 31892c42a146SMarcel Moolenaar psignal(p, sig); 3190628d2653SJohn Baldwin PROC_UNLOCK(p); 3191628d2653SJohn Baldwin } 3192f591779bSSeigo Tanimura PGRP_UNLOCK(sigio->sio_pgrp); 3193831d27a9SDon Lewis } 3194f1320723SAlfred Perlstein SIGIO_UNLOCK(); 3195831d27a9SDon Lewis } 3196cb679c38SJonathan Lemon 3197cb679c38SJonathan Lemon static int 3198cb679c38SJonathan Lemon filt_sigattach(struct knote *kn) 3199cb679c38SJonathan Lemon { 3200cb679c38SJonathan Lemon struct proc *p = curproc; 3201cb679c38SJonathan Lemon 3202cb679c38SJonathan Lemon kn->kn_ptr.p_proc = p; 3203cb679c38SJonathan Lemon kn->kn_flags |= EV_CLEAR; /* automatically set */ 3204cb679c38SJonathan Lemon 3205ad3b9257SJohn-Mark Gurney knlist_add(&p->p_klist, kn, 0); 3206cb679c38SJonathan Lemon 3207cb679c38SJonathan Lemon return (0); 3208cb679c38SJonathan Lemon } 3209cb679c38SJonathan Lemon 3210cb679c38SJonathan Lemon static void 3211cb679c38SJonathan Lemon filt_sigdetach(struct knote *kn) 3212cb679c38SJonathan Lemon { 3213cb679c38SJonathan Lemon struct proc *p = kn->kn_ptr.p_proc; 3214cb679c38SJonathan Lemon 3215ad3b9257SJohn-Mark Gurney knlist_remove(&p->p_klist, kn, 0); 3216cb679c38SJonathan Lemon } 3217cb679c38SJonathan Lemon 3218cb679c38SJonathan Lemon /* 3219cb679c38SJonathan Lemon * signal knotes are shared with proc knotes, so we apply a mask to 3220cb679c38SJonathan Lemon * the hint in order to differentiate them from process hints. This 3221cb679c38SJonathan Lemon * could be avoided by using a signal-specific knote list, but probably 3222cb679c38SJonathan Lemon * isn't worth the trouble. 3223cb679c38SJonathan Lemon */ 3224cb679c38SJonathan Lemon static int 3225cb679c38SJonathan Lemon filt_signal(struct knote *kn, long hint) 3226cb679c38SJonathan Lemon { 3227cb679c38SJonathan Lemon 3228cb679c38SJonathan Lemon if (hint & NOTE_SIGNAL) { 3229cb679c38SJonathan Lemon hint &= ~NOTE_SIGNAL; 3230cb679c38SJonathan Lemon 3231cb679c38SJonathan Lemon if (kn->kn_id == hint) 3232cb679c38SJonathan Lemon kn->kn_data++; 3233cb679c38SJonathan Lemon } 3234cb679c38SJonathan Lemon return (kn->kn_data != 0); 3235cb679c38SJonathan Lemon } 323690af4afaSJohn Baldwin 323790af4afaSJohn Baldwin struct sigacts * 323890af4afaSJohn Baldwin sigacts_alloc(void) 323990af4afaSJohn Baldwin { 324090af4afaSJohn Baldwin struct sigacts *ps; 324190af4afaSJohn Baldwin 324290af4afaSJohn Baldwin ps = malloc(sizeof(struct sigacts), M_SUBPROC, M_WAITOK | M_ZERO); 324390af4afaSJohn Baldwin ps->ps_refcnt = 1; 324490af4afaSJohn Baldwin mtx_init(&ps->ps_mtx, "sigacts", NULL, MTX_DEF); 324590af4afaSJohn Baldwin return (ps); 324690af4afaSJohn Baldwin } 324790af4afaSJohn Baldwin 324890af4afaSJohn Baldwin void 324990af4afaSJohn Baldwin sigacts_free(struct sigacts *ps) 325090af4afaSJohn Baldwin { 325190af4afaSJohn Baldwin 325290af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 325390af4afaSJohn Baldwin ps->ps_refcnt--; 325490af4afaSJohn Baldwin if (ps->ps_refcnt == 0) { 325590af4afaSJohn Baldwin mtx_destroy(&ps->ps_mtx); 325690af4afaSJohn Baldwin free(ps, M_SUBPROC); 325790af4afaSJohn Baldwin } else 325890af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 325990af4afaSJohn Baldwin } 326090af4afaSJohn Baldwin 326190af4afaSJohn Baldwin struct sigacts * 326290af4afaSJohn Baldwin sigacts_hold(struct sigacts *ps) 326390af4afaSJohn Baldwin { 326490af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 326590af4afaSJohn Baldwin ps->ps_refcnt++; 326690af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 326790af4afaSJohn Baldwin return (ps); 326890af4afaSJohn Baldwin } 326990af4afaSJohn Baldwin 327090af4afaSJohn Baldwin void 327190af4afaSJohn Baldwin sigacts_copy(struct sigacts *dest, struct sigacts *src) 327290af4afaSJohn Baldwin { 327390af4afaSJohn Baldwin 327490af4afaSJohn Baldwin KASSERT(dest->ps_refcnt == 1, ("sigacts_copy to shared dest")); 327590af4afaSJohn Baldwin mtx_lock(&src->ps_mtx); 327690af4afaSJohn Baldwin bcopy(src, dest, offsetof(struct sigacts, ps_refcnt)); 327790af4afaSJohn Baldwin mtx_unlock(&src->ps_mtx); 327890af4afaSJohn Baldwin } 327990af4afaSJohn Baldwin 328090af4afaSJohn Baldwin int 328190af4afaSJohn Baldwin sigacts_shared(struct sigacts *ps) 328290af4afaSJohn Baldwin { 328390af4afaSJohn Baldwin int shared; 328490af4afaSJohn Baldwin 328590af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 328690af4afaSJohn Baldwin shared = ps->ps_refcnt > 1; 328790af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 328890af4afaSJohn Baldwin return (shared); 328990af4afaSJohn Baldwin } 3290