The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_sig.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * (c) UNIX System Laboratories, Inc.
    5  * All or some portions of this file are derived from material licensed
    6  * to the University of California by American Telephone and Telegraph
    7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    8  * the permission of UNIX System Laboratories, Inc.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)kern_sig.c  8.7 (Berkeley) 4/18/94
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD: releng/11.2/sys/kern/kern_sig.c 331922 2018-04-03 09:40:52Z kib $");
   39 
   40 #include "opt_compat.h"
   41 #include "opt_gzio.h"
   42 #include "opt_ktrace.h"
   43 
   44 #include <sys/param.h>
   45 #include <sys/ctype.h>
   46 #include <sys/systm.h>
   47 #include <sys/signalvar.h>
   48 #include <sys/vnode.h>
   49 #include <sys/acct.h>
   50 #include <sys/bus.h>
   51 #include <sys/capsicum.h>
   52 #include <sys/condvar.h>
   53 #include <sys/event.h>
   54 #include <sys/fcntl.h>
   55 #include <sys/imgact.h>
   56 #include <sys/kernel.h>
   57 #include <sys/ktr.h>
   58 #include <sys/ktrace.h>
   59 #include <sys/lock.h>
   60 #include <sys/malloc.h>
   61 #include <sys/mutex.h>
   62 #include <sys/refcount.h>
   63 #include <sys/namei.h>
   64 #include <sys/proc.h>
   65 #include <sys/procdesc.h>
   66 #include <sys/posix4.h>
   67 #include <sys/pioctl.h>
   68 #include <sys/racct.h>
   69 #include <sys/resourcevar.h>
   70 #include <sys/sdt.h>
   71 #include <sys/sbuf.h>
   72 #include <sys/sleepqueue.h>
   73 #include <sys/smp.h>
   74 #include <sys/stat.h>
   75 #include <sys/sx.h>
   76 #include <sys/syscallsubr.h>
   77 #include <sys/sysctl.h>
   78 #include <sys/sysent.h>
   79 #include <sys/syslog.h>
   80 #include <sys/sysproto.h>
   81 #include <sys/timers.h>
   82 #include <sys/unistd.h>
   83 #include <sys/wait.h>
   84 #include <vm/vm.h>
   85 #include <vm/vm_extern.h>
   86 #include <vm/uma.h>
   87 
   88 #include <sys/jail.h>
   89 
   90 #include <machine/cpu.h>
   91 
   92 #include <security/audit/audit.h>
   93 
   94 #define ONSIG   32              /* NSIG for osig* syscalls.  XXX. */
   95 
   96 SDT_PROVIDER_DECLARE(proc);
   97 SDT_PROBE_DEFINE3(proc, , , signal__send,
   98     "struct thread *", "struct proc *", "int");
   99 SDT_PROBE_DEFINE2(proc, , , signal__clear,
  100     "int", "ksiginfo_t *");
  101 SDT_PROBE_DEFINE3(proc, , , signal__discard,
  102     "struct thread *", "struct proc *", "int");
  103 
  104 static int      coredump(struct thread *);
  105 static int      killpg1(struct thread *td, int sig, int pgid, int all,
  106                     ksiginfo_t *ksi);
  107 static int      issignal(struct thread *td);
  108 static int      sigprop(int sig);
  109 static void     tdsigwakeup(struct thread *, int, sig_t, int);
  110 static int      sig_suspend_threads(struct thread *, struct proc *, int);
  111 static int      filt_sigattach(struct knote *kn);
  112 static void     filt_sigdetach(struct knote *kn);
  113 static int      filt_signal(struct knote *kn, long hint);
  114 static struct thread *sigtd(struct proc *p, int sig, int prop);
  115 static void     sigqueue_start(void);
  116 
  117 static uma_zone_t       ksiginfo_zone = NULL;
  118 struct filterops sig_filtops = {
  119         .f_isfd = 0,
  120         .f_attach = filt_sigattach,
  121         .f_detach = filt_sigdetach,
  122         .f_event = filt_signal,
  123 };
  124 
  125 static int      kern_logsigexit = 1;
  126 SYSCTL_INT(_kern, KERN_LOGSIGEXIT, logsigexit, CTLFLAG_RW,
  127     &kern_logsigexit, 0,
  128     "Log processes quitting on abnormal signals to syslog(3)");
  129 
  130 static int      kern_forcesigexit = 1;
  131 SYSCTL_INT(_kern, OID_AUTO, forcesigexit, CTLFLAG_RW,
  132     &kern_forcesigexit, 0, "Force trap signal to be handled");
  133 
  134 static SYSCTL_NODE(_kern, OID_AUTO, sigqueue, CTLFLAG_RW, 0,
  135     "POSIX real time signal");
  136 
  137 static int      max_pending_per_proc = 128;
  138 SYSCTL_INT(_kern_sigqueue, OID_AUTO, max_pending_per_proc, CTLFLAG_RW,
  139     &max_pending_per_proc, 0, "Max pending signals per proc");
  140 
  141 static int      preallocate_siginfo = 1024;
  142 SYSCTL_INT(_kern_sigqueue, OID_AUTO, preallocate, CTLFLAG_RDTUN,
  143     &preallocate_siginfo, 0, "Preallocated signal memory size");
  144 
  145 static int      signal_overflow = 0;
  146 SYSCTL_INT(_kern_sigqueue, OID_AUTO, overflow, CTLFLAG_RD,
  147     &signal_overflow, 0, "Number of signals overflew");
  148 
  149 static int      signal_alloc_fail = 0;
  150 SYSCTL_INT(_kern_sigqueue, OID_AUTO, alloc_fail, CTLFLAG_RD,
  151     &signal_alloc_fail, 0, "signals failed to be allocated");
  152 
  153 static int      kern_lognosys = 0;
  154 SYSCTL_INT(_kern, OID_AUTO, lognosys, CTLFLAG_RWTUN, &kern_lognosys, 0,
  155     "Log invalid syscalls");
  156 
  157 SYSINIT(signal, SI_SUB_P1003_1B, SI_ORDER_FIRST+3, sigqueue_start, NULL);
  158 
  159 /*
  160  * Policy -- Can ucred cr1 send SIGIO to process cr2?
  161  * Should use cr_cansignal() once cr_cansignal() allows SIGIO and SIGURG
  162  * in the right situations.
  163  */
  164 #define CANSIGIO(cr1, cr2) \
  165         ((cr1)->cr_uid == 0 || \
  166             (cr1)->cr_ruid == (cr2)->cr_ruid || \
  167             (cr1)->cr_uid == (cr2)->cr_ruid || \
  168             (cr1)->cr_ruid == (cr2)->cr_uid || \
  169             (cr1)->cr_uid == (cr2)->cr_uid)
  170 
  171 static int      sugid_coredump;
  172 SYSCTL_INT(_kern, OID_AUTO, sugid_coredump, CTLFLAG_RWTUN,
  173     &sugid_coredump, 0, "Allow setuid and setgid processes to dump core");
  174 
  175 static int      capmode_coredump;
  176 SYSCTL_INT(_kern, OID_AUTO, capmode_coredump, CTLFLAG_RWTUN,
  177     &capmode_coredump, 0, "Allow processes in capability mode to dump core");
  178 
  179 static int      do_coredump = 1;
  180 SYSCTL_INT(_kern, OID_AUTO, coredump, CTLFLAG_RW,
  181         &do_coredump, 0, "Enable/Disable coredumps");
  182 
  183 static int      set_core_nodump_flag = 0;
  184 SYSCTL_INT(_kern, OID_AUTO, nodump_coredump, CTLFLAG_RW, &set_core_nodump_flag,
  185         0, "Enable setting the NODUMP flag on coredump files");
  186 
  187 static int      coredump_devctl = 0;
  188 SYSCTL_INT(_kern, OID_AUTO, coredump_devctl, CTLFLAG_RW, &coredump_devctl,
  189         0, "Generate a devctl notification when processes coredump");
  190 
  191 /*
  192  * Signal properties and actions.
  193  * The array below categorizes the signals and their default actions
  194  * according to the following properties:
  195  */
  196 #define SA_KILL         0x01            /* terminates process by default */
  197 #define SA_CORE         0x02            /* ditto and coredumps */
  198 #define SA_STOP         0x04            /* suspend process */
  199 #define SA_TTYSTOP      0x08            /* ditto, from tty */
  200 #define SA_IGNORE       0x10            /* ignore by default */
  201 #define SA_CONT         0x20            /* continue if suspended */
  202 #define SA_CANTMASK     0x40            /* non-maskable, catchable */
  203 
  204 static int sigproptbl[NSIG] = {
  205         SA_KILL,                        /* SIGHUP */
  206         SA_KILL,                        /* SIGINT */
  207         SA_KILL|SA_CORE,                /* SIGQUIT */
  208         SA_KILL|SA_CORE,                /* SIGILL */
  209         SA_KILL|SA_CORE,                /* SIGTRAP */
  210         SA_KILL|SA_CORE,                /* SIGABRT */
  211         SA_KILL|SA_CORE,                /* SIGEMT */
  212         SA_KILL|SA_CORE,                /* SIGFPE */
  213         SA_KILL,                        /* SIGKILL */
  214         SA_KILL|SA_CORE,                /* SIGBUS */
  215         SA_KILL|SA_CORE,                /* SIGSEGV */
  216         SA_KILL|SA_CORE,                /* SIGSYS */
  217         SA_KILL,                        /* SIGPIPE */
  218         SA_KILL,                        /* SIGALRM */
  219         SA_KILL,                        /* SIGTERM */
  220         SA_IGNORE,                      /* SIGURG */
  221         SA_STOP,                        /* SIGSTOP */
  222         SA_STOP|SA_TTYSTOP,             /* SIGTSTP */
  223         SA_IGNORE|SA_CONT,              /* SIGCONT */
  224         SA_IGNORE,                      /* SIGCHLD */
  225         SA_STOP|SA_TTYSTOP,             /* SIGTTIN */
  226         SA_STOP|SA_TTYSTOP,             /* SIGTTOU */
  227         SA_IGNORE,                      /* SIGIO */
  228         SA_KILL,                        /* SIGXCPU */
  229         SA_KILL,                        /* SIGXFSZ */
  230         SA_KILL,                        /* SIGVTALRM */
  231         SA_KILL,                        /* SIGPROF */
  232         SA_IGNORE,                      /* SIGWINCH  */
  233         SA_IGNORE,                      /* SIGINFO */
  234         SA_KILL,                        /* SIGUSR1 */
  235         SA_KILL,                        /* SIGUSR2 */
  236 };
  237 
  238 static void reschedule_signals(struct proc *p, sigset_t block, int flags);
  239 
  240 static void
  241 sigqueue_start(void)
  242 {
  243         ksiginfo_zone = uma_zcreate("ksiginfo", sizeof(ksiginfo_t),
  244                 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
  245         uma_prealloc(ksiginfo_zone, preallocate_siginfo);
  246         p31b_setcfg(CTL_P1003_1B_REALTIME_SIGNALS, _POSIX_REALTIME_SIGNALS);
  247         p31b_setcfg(CTL_P1003_1B_RTSIG_MAX, SIGRTMAX - SIGRTMIN + 1);
  248         p31b_setcfg(CTL_P1003_1B_SIGQUEUE_MAX, max_pending_per_proc);
  249 }
  250 
  251 ksiginfo_t *
  252 ksiginfo_alloc(int wait)
  253 {
  254         int flags;
  255 
  256         flags = M_ZERO;
  257         if (! wait)
  258                 flags |= M_NOWAIT;
  259         if (ksiginfo_zone != NULL)
  260                 return ((ksiginfo_t *)uma_zalloc(ksiginfo_zone, flags));
  261         return (NULL);
  262 }
  263 
  264 void
  265 ksiginfo_free(ksiginfo_t *ksi)
  266 {
  267         uma_zfree(ksiginfo_zone, ksi);
  268 }
  269 
  270 static __inline int
  271 ksiginfo_tryfree(ksiginfo_t *ksi)
  272 {
  273         if (!(ksi->ksi_flags & KSI_EXT)) {
  274                 uma_zfree(ksiginfo_zone, ksi);
  275                 return (1);
  276         }
  277         return (0);
  278 }
  279 
  280 void
  281 sigqueue_init(sigqueue_t *list, struct proc *p)
  282 {
  283         SIGEMPTYSET(list->sq_signals);
  284         SIGEMPTYSET(list->sq_kill);
  285         SIGEMPTYSET(list->sq_ptrace);
  286         TAILQ_INIT(&list->sq_list);
  287         list->sq_proc = p;
  288         list->sq_flags = SQ_INIT;
  289 }
  290 
  291 /*
  292  * Get a signal's ksiginfo.
  293  * Return:
  294  *      0       -       signal not found
  295  *      others  -       signal number
  296  */
  297 static int
  298 sigqueue_get(sigqueue_t *sq, int signo, ksiginfo_t *si)
  299 {
  300         struct proc *p = sq->sq_proc;
  301         struct ksiginfo *ksi, *next;
  302         int count = 0;
  303 
  304         KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
  305 
  306         if (!SIGISMEMBER(sq->sq_signals, signo))
  307                 return (0);
  308 
  309         if (SIGISMEMBER(sq->sq_ptrace, signo)) {
  310                 count++;
  311                 SIGDELSET(sq->sq_ptrace, signo);
  312                 si->ksi_flags |= KSI_PTRACE;
  313         }
  314         if (SIGISMEMBER(sq->sq_kill, signo)) {
  315                 count++;
  316                 if (count == 1)
  317                         SIGDELSET(sq->sq_kill, signo);
  318         }
  319 
  320         TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) {
  321                 if (ksi->ksi_signo == signo) {
  322                         if (count == 0) {
  323                                 TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
  324                                 ksi->ksi_sigq = NULL;
  325                                 ksiginfo_copy(ksi, si);
  326                                 if (ksiginfo_tryfree(ksi) && p != NULL)
  327                                         p->p_pendingcnt--;
  328                         }
  329                         if (++count > 1)
  330                                 break;
  331                 }
  332         }
  333 
  334         if (count <= 1)
  335                 SIGDELSET(sq->sq_signals, signo);
  336         si->ksi_signo = signo;
  337         return (signo);
  338 }
  339 
  340 void
  341 sigqueue_take(ksiginfo_t *ksi)
  342 {
  343         struct ksiginfo *kp;
  344         struct proc     *p;
  345         sigqueue_t      *sq;
  346 
  347         if (ksi == NULL || (sq = ksi->ksi_sigq) == NULL)
  348                 return;
  349 
  350         p = sq->sq_proc;
  351         TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
  352         ksi->ksi_sigq = NULL;
  353         if (!(ksi->ksi_flags & KSI_EXT) && p != NULL)
  354                 p->p_pendingcnt--;
  355 
  356         for (kp = TAILQ_FIRST(&sq->sq_list); kp != NULL;
  357              kp = TAILQ_NEXT(kp, ksi_link)) {
  358                 if (kp->ksi_signo == ksi->ksi_signo)
  359                         break;
  360         }
  361         if (kp == NULL && !SIGISMEMBER(sq->sq_kill, ksi->ksi_signo) &&
  362             !SIGISMEMBER(sq->sq_ptrace, ksi->ksi_signo))
  363                 SIGDELSET(sq->sq_signals, ksi->ksi_signo);
  364 }
  365 
  366 static int
  367 sigqueue_add(sigqueue_t *sq, int signo, ksiginfo_t *si)
  368 {
  369         struct proc *p = sq->sq_proc;
  370         struct ksiginfo *ksi;
  371         int ret = 0;
  372 
  373         KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
  374 
  375         /*
  376          * SIGKILL/SIGSTOP cannot be caught or masked, so take the fast path
  377          * for these signals.
  378          */
  379         if (signo == SIGKILL || signo == SIGSTOP || si == NULL) {
  380                 SIGADDSET(sq->sq_kill, signo);
  381                 goto out_set_bit;
  382         }
  383 
  384         /* directly insert the ksi, don't copy it */
  385         if (si->ksi_flags & KSI_INS) {
  386                 if (si->ksi_flags & KSI_HEAD)
  387                         TAILQ_INSERT_HEAD(&sq->sq_list, si, ksi_link);
  388                 else
  389                         TAILQ_INSERT_TAIL(&sq->sq_list, si, ksi_link);
  390                 si->ksi_sigq = sq;
  391                 goto out_set_bit;
  392         }
  393 
  394         if (__predict_false(ksiginfo_zone == NULL)) {
  395                 SIGADDSET(sq->sq_kill, signo);
  396                 goto out_set_bit;
  397         }
  398 
  399         if (p != NULL && p->p_pendingcnt >= max_pending_per_proc) {
  400                 signal_overflow++;
  401                 ret = EAGAIN;
  402         } else if ((ksi = ksiginfo_alloc(0)) == NULL) {
  403                 signal_alloc_fail++;
  404                 ret = EAGAIN;
  405         } else {
  406                 if (p != NULL)
  407                         p->p_pendingcnt++;
  408                 ksiginfo_copy(si, ksi);
  409                 ksi->ksi_signo = signo;
  410                 if (si->ksi_flags & KSI_HEAD)
  411                         TAILQ_INSERT_HEAD(&sq->sq_list, ksi, ksi_link);
  412                 else
  413                         TAILQ_INSERT_TAIL(&sq->sq_list, ksi, ksi_link);
  414                 ksi->ksi_sigq = sq;
  415         }
  416 
  417         if (ret != 0) {
  418                 if ((si->ksi_flags & KSI_PTRACE) != 0) {
  419                         SIGADDSET(sq->sq_ptrace, signo);
  420                         ret = 0;
  421                         goto out_set_bit;
  422                 } else if ((si->ksi_flags & KSI_TRAP) != 0 ||
  423                     (si->ksi_flags & KSI_SIGQ) == 0) {
  424                         SIGADDSET(sq->sq_kill, signo);
  425                         ret = 0;
  426                         goto out_set_bit;
  427                 }
  428                 return (ret);
  429         }
  430 
  431 out_set_bit:
  432         SIGADDSET(sq->sq_signals, signo);
  433         return (ret);
  434 }
  435 
  436 void
  437 sigqueue_flush(sigqueue_t *sq)
  438 {
  439         struct proc *p = sq->sq_proc;
  440         ksiginfo_t *ksi;
  441 
  442         KASSERT(sq->sq_flags & SQ_INIT, ("sigqueue not inited"));
  443 
  444         if (p != NULL)
  445                 PROC_LOCK_ASSERT(p, MA_OWNED);
  446 
  447         while ((ksi = TAILQ_FIRST(&sq->sq_list)) != NULL) {
  448                 TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
  449                 ksi->ksi_sigq = NULL;
  450                 if (ksiginfo_tryfree(ksi) && p != NULL)
  451                         p->p_pendingcnt--;
  452         }
  453 
  454         SIGEMPTYSET(sq->sq_signals);
  455         SIGEMPTYSET(sq->sq_kill);
  456         SIGEMPTYSET(sq->sq_ptrace);
  457 }
  458 
  459 static void
  460 sigqueue_move_set(sigqueue_t *src, sigqueue_t *dst, const sigset_t *set)
  461 {
  462         sigset_t tmp;
  463         struct proc *p1, *p2;
  464         ksiginfo_t *ksi, *next;
  465 
  466         KASSERT(src->sq_flags & SQ_INIT, ("src sigqueue not inited"));
  467         KASSERT(dst->sq_flags & SQ_INIT, ("dst sigqueue not inited"));
  468         p1 = src->sq_proc;
  469         p2 = dst->sq_proc;
  470         /* Move siginfo to target list */
  471         TAILQ_FOREACH_SAFE(ksi, &src->sq_list, ksi_link, next) {
  472                 if (SIGISMEMBER(*set, ksi->ksi_signo)) {
  473                         TAILQ_REMOVE(&src->sq_list, ksi, ksi_link);
  474                         if (p1 != NULL)
  475                                 p1->p_pendingcnt--;
  476                         TAILQ_INSERT_TAIL(&dst->sq_list, ksi, ksi_link);
  477                         ksi->ksi_sigq = dst;
  478                         if (p2 != NULL)
  479                                 p2->p_pendingcnt++;
  480                 }
  481         }
  482 
  483         /* Move pending bits to target list */
  484         tmp = src->sq_kill;
  485         SIGSETAND(tmp, *set);
  486         SIGSETOR(dst->sq_kill, tmp);
  487         SIGSETNAND(src->sq_kill, tmp);
  488 
  489         tmp = src->sq_ptrace;
  490         SIGSETAND(tmp, *set);
  491         SIGSETOR(dst->sq_ptrace, tmp);
  492         SIGSETNAND(src->sq_ptrace, tmp);
  493 
  494         tmp = src->sq_signals;
  495         SIGSETAND(tmp, *set);
  496         SIGSETOR(dst->sq_signals, tmp);
  497         SIGSETNAND(src->sq_signals, tmp);
  498 }
  499 
  500 #if 0
  501 static void
  502 sigqueue_move(sigqueue_t *src, sigqueue_t *dst, int signo)
  503 {
  504         sigset_t set;
  505 
  506         SIGEMPTYSET(set);
  507         SIGADDSET(set, signo);
  508         sigqueue_move_set(src, dst, &set);
  509 }
  510 #endif
  511 
  512 static void
  513 sigqueue_delete_set(sigqueue_t *sq, const sigset_t *set)
  514 {
  515         struct proc *p = sq->sq_proc;
  516         ksiginfo_t *ksi, *next;
  517 
  518         KASSERT(sq->sq_flags & SQ_INIT, ("src sigqueue not inited"));
  519 
  520         /* Remove siginfo queue */
  521         TAILQ_FOREACH_SAFE(ksi, &sq->sq_list, ksi_link, next) {
  522                 if (SIGISMEMBER(*set, ksi->ksi_signo)) {
  523                         TAILQ_REMOVE(&sq->sq_list, ksi, ksi_link);
  524                         ksi->ksi_sigq = NULL;
  525                         if (ksiginfo_tryfree(ksi) && p != NULL)
  526                                 p->p_pendingcnt--;
  527                 }
  528         }
  529         SIGSETNAND(sq->sq_kill, *set);
  530         SIGSETNAND(sq->sq_ptrace, *set);
  531         SIGSETNAND(sq->sq_signals, *set);
  532 }
  533 
  534 void
  535 sigqueue_delete(sigqueue_t *sq, int signo)
  536 {
  537         sigset_t set;
  538 
  539         SIGEMPTYSET(set);
  540         SIGADDSET(set, signo);
  541         sigqueue_delete_set(sq, &set);
  542 }
  543 
  544 /* Remove a set of signals for a process */
  545 static void
  546 sigqueue_delete_set_proc(struct proc *p, const sigset_t *set)
  547 {
  548         sigqueue_t worklist;
  549         struct thread *td0;
  550 
  551         PROC_LOCK_ASSERT(p, MA_OWNED);
  552 
  553         sigqueue_init(&worklist, NULL);
  554         sigqueue_move_set(&p->p_sigqueue, &worklist, set);
  555 
  556         FOREACH_THREAD_IN_PROC(p, td0)
  557                 sigqueue_move_set(&td0->td_sigqueue, &worklist, set);
  558 
  559         sigqueue_flush(&worklist);
  560 }
  561 
  562 void
  563 sigqueue_delete_proc(struct proc *p, int signo)
  564 {
  565         sigset_t set;
  566 
  567         SIGEMPTYSET(set);
  568         SIGADDSET(set, signo);
  569         sigqueue_delete_set_proc(p, &set);
  570 }
  571 
  572 static void
  573 sigqueue_delete_stopmask_proc(struct proc *p)
  574 {
  575         sigset_t set;
  576 
  577         SIGEMPTYSET(set);
  578         SIGADDSET(set, SIGSTOP);
  579         SIGADDSET(set, SIGTSTP);
  580         SIGADDSET(set, SIGTTIN);
  581         SIGADDSET(set, SIGTTOU);
  582         sigqueue_delete_set_proc(p, &set);
  583 }
  584 
  585 /*
  586  * Determine signal that should be delivered to thread td, the current
  587  * thread, 0 if none.  If there is a pending stop signal with default
  588  * action, the process stops in issignal().
  589  */
  590 int
  591 cursig(struct thread *td)
  592 {
  593         PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
  594         mtx_assert(&td->td_proc->p_sigacts->ps_mtx, MA_OWNED);
  595         THREAD_LOCK_ASSERT(td, MA_NOTOWNED);
  596         return (SIGPENDING(td) ? issignal(td) : 0);
  597 }
  598 
  599 /*
  600  * Arrange for ast() to handle unmasked pending signals on return to user
  601  * mode.  This must be called whenever a signal is added to td_sigqueue or
  602  * unmasked in td_sigmask.
  603  */
  604 void
  605 signotify(struct thread *td)
  606 {
  607         struct proc *p;
  608 
  609         p = td->td_proc;
  610 
  611         PROC_LOCK_ASSERT(p, MA_OWNED);
  612 
  613         if (SIGPENDING(td)) {
  614                 thread_lock(td);
  615                 td->td_flags |= TDF_NEEDSIGCHK | TDF_ASTPENDING;
  616                 thread_unlock(td);
  617         }
  618 }
  619 
  620 int
  621 sigonstack(size_t sp)
  622 {
  623         struct thread *td = curthread;
  624 
  625         return ((td->td_pflags & TDP_ALTSTACK) ?
  626 #if defined(COMPAT_43)
  627             ((td->td_sigstk.ss_size == 0) ?
  628                 (td->td_sigstk.ss_flags & SS_ONSTACK) :
  629                 ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size))
  630 #else
  631             ((sp - (size_t)td->td_sigstk.ss_sp) < td->td_sigstk.ss_size)
  632 #endif
  633             : 0);
  634 }
  635 
  636 static __inline int
  637 sigprop(int sig)
  638 {
  639 
  640         if (sig > 0 && sig < NSIG)
  641                 return (sigproptbl[_SIG_IDX(sig)]);
  642         return (0);
  643 }
  644 
  645 int
  646 sig_ffs(sigset_t *set)
  647 {
  648         int i;
  649 
  650         for (i = 0; i < _SIG_WORDS; i++)
  651                 if (set->__bits[i])
  652                         return (ffs(set->__bits[i]) + (i * 32));
  653         return (0);
  654 }
  655 
  656 static bool
  657 sigact_flag_test(const struct sigaction *act, int flag)
  658 {
  659 
  660         /*
  661          * SA_SIGINFO is reset when signal disposition is set to
  662          * ignore or default.  Other flags are kept according to user
  663          * settings.
  664          */
  665         return ((act->sa_flags & flag) != 0 && (flag != SA_SIGINFO ||
  666             ((__sighandler_t *)act->sa_sigaction != SIG_IGN &&
  667             (__sighandler_t *)act->sa_sigaction != SIG_DFL)));
  668 }
  669 
  670 /*
  671  * kern_sigaction
  672  * sigaction
  673  * freebsd4_sigaction
  674  * osigaction
  675  */
  676 int
  677 kern_sigaction(struct thread *td, int sig, const struct sigaction *act,
  678     struct sigaction *oact, int flags)
  679 {
  680         struct sigacts *ps;
  681         struct proc *p = td->td_proc;
  682 
  683         if (!_SIG_VALID(sig))
  684                 return (EINVAL);
  685         if (act != NULL && act->sa_handler != SIG_DFL &&
  686             act->sa_handler != SIG_IGN && (act->sa_flags & ~(SA_ONSTACK |
  687             SA_RESTART | SA_RESETHAND | SA_NOCLDSTOP | SA_NODEFER |
  688             SA_NOCLDWAIT | SA_SIGINFO)) != 0)
  689                 return (EINVAL);
  690 
  691         PROC_LOCK(p);
  692         ps = p->p_sigacts;
  693         mtx_lock(&ps->ps_mtx);
  694         if (oact) {
  695                 memset(oact, 0, sizeof(*oact));
  696                 oact->sa_mask = ps->ps_catchmask[_SIG_IDX(sig)];
  697                 if (SIGISMEMBER(ps->ps_sigonstack, sig))
  698                         oact->sa_flags |= SA_ONSTACK;
  699                 if (!SIGISMEMBER(ps->ps_sigintr, sig))
  700                         oact->sa_flags |= SA_RESTART;
  701                 if (SIGISMEMBER(ps->ps_sigreset, sig))
  702                         oact->sa_flags |= SA_RESETHAND;
  703                 if (SIGISMEMBER(ps->ps_signodefer, sig))
  704                         oact->sa_flags |= SA_NODEFER;
  705                 if (SIGISMEMBER(ps->ps_siginfo, sig)) {
  706                         oact->sa_flags |= SA_SIGINFO;
  707                         oact->sa_sigaction =
  708                             (__siginfohandler_t *)ps->ps_sigact[_SIG_IDX(sig)];
  709                 } else
  710                         oact->sa_handler = ps->ps_sigact[_SIG_IDX(sig)];
  711                 if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDSTOP)
  712                         oact->sa_flags |= SA_NOCLDSTOP;
  713                 if (sig == SIGCHLD && ps->ps_flag & PS_NOCLDWAIT)
  714                         oact->sa_flags |= SA_NOCLDWAIT;
  715         }
  716         if (act) {
  717                 if ((sig == SIGKILL || sig == SIGSTOP) &&
  718                     act->sa_handler != SIG_DFL) {
  719                         mtx_unlock(&ps->ps_mtx);
  720                         PROC_UNLOCK(p);
  721                         return (EINVAL);
  722                 }
  723 
  724                 /*
  725                  * Change setting atomically.
  726                  */
  727 
  728                 ps->ps_catchmask[_SIG_IDX(sig)] = act->sa_mask;
  729                 SIG_CANTMASK(ps->ps_catchmask[_SIG_IDX(sig)]);
  730                 if (sigact_flag_test(act, SA_SIGINFO)) {
  731                         ps->ps_sigact[_SIG_IDX(sig)] =
  732                             (__sighandler_t *)act->sa_sigaction;
  733                         SIGADDSET(ps->ps_siginfo, sig);
  734                 } else {
  735                         ps->ps_sigact[_SIG_IDX(sig)] = act->sa_handler;
  736                         SIGDELSET(ps->ps_siginfo, sig);
  737                 }
  738                 if (!sigact_flag_test(act, SA_RESTART))
  739                         SIGADDSET(ps->ps_sigintr, sig);
  740                 else
  741                         SIGDELSET(ps->ps_sigintr, sig);
  742                 if (sigact_flag_test(act, SA_ONSTACK))
  743                         SIGADDSET(ps->ps_sigonstack, sig);
  744                 else
  745                         SIGDELSET(ps->ps_sigonstack, sig);
  746                 if (sigact_flag_test(act, SA_RESETHAND))
  747                         SIGADDSET(ps->ps_sigreset, sig);
  748                 else
  749                         SIGDELSET(ps->ps_sigreset, sig);
  750                 if (sigact_flag_test(act, SA_NODEFER))
  751                         SIGADDSET(ps->ps_signodefer, sig);
  752                 else
  753                         SIGDELSET(ps->ps_signodefer, sig);
  754                 if (sig == SIGCHLD) {
  755                         if (act->sa_flags & SA_NOCLDSTOP)
  756                                 ps->ps_flag |= PS_NOCLDSTOP;
  757                         else
  758                                 ps->ps_flag &= ~PS_NOCLDSTOP;
  759                         if (act->sa_flags & SA_NOCLDWAIT) {
  760                                 /*
  761                                  * Paranoia: since SA_NOCLDWAIT is implemented
  762                                  * by reparenting the dying child to PID 1 (and
  763                                  * trust it to reap the zombie), PID 1 itself
  764                                  * is forbidden to set SA_NOCLDWAIT.
  765                                  */
  766                                 if (p->p_pid == 1)
  767                                         ps->ps_flag &= ~PS_NOCLDWAIT;
  768                                 else
  769                                         ps->ps_flag |= PS_NOCLDWAIT;
  770                         } else
  771                                 ps->ps_flag &= ~PS_NOCLDWAIT;
  772                         if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN)
  773                                 ps->ps_flag |= PS_CLDSIGIGN;
  774                         else
  775                                 ps->ps_flag &= ~PS_CLDSIGIGN;
  776                 }
  777                 /*
  778                  * Set bit in ps_sigignore for signals that are set to SIG_IGN,
  779                  * and for signals set to SIG_DFL where the default is to
  780                  * ignore. However, don't put SIGCONT in ps_sigignore, as we
  781                  * have to restart the process.
  782                  */
  783                 if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
  784                     (sigprop(sig) & SA_IGNORE &&
  785                      ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) {
  786                         /* never to be seen again */
  787                         sigqueue_delete_proc(p, sig);
  788                         if (sig != SIGCONT)
  789                                 /* easier in psignal */
  790                                 SIGADDSET(ps->ps_sigignore, sig);
  791                         SIGDELSET(ps->ps_sigcatch, sig);
  792                 } else {
  793                         SIGDELSET(ps->ps_sigignore, sig);
  794                         if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)
  795                                 SIGDELSET(ps->ps_sigcatch, sig);
  796                         else
  797                                 SIGADDSET(ps->ps_sigcatch, sig);
  798                 }
  799 #ifdef COMPAT_FREEBSD4
  800                 if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
  801                     ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL ||
  802                     (flags & KSA_FREEBSD4) == 0)
  803                         SIGDELSET(ps->ps_freebsd4, sig);
  804                 else
  805                         SIGADDSET(ps->ps_freebsd4, sig);
  806 #endif
  807 #ifdef COMPAT_43
  808                 if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN ||
  809                     ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL ||
  810                     (flags & KSA_OSIGSET) == 0)
  811                         SIGDELSET(ps->ps_osigset, sig);
  812                 else
  813                         SIGADDSET(ps->ps_osigset, sig);
  814 #endif
  815         }
  816         mtx_unlock(&ps->ps_mtx);
  817         PROC_UNLOCK(p);
  818         return (0);
  819 }
  820 
  821 #ifndef _SYS_SYSPROTO_H_
  822 struct sigaction_args {
  823         int     sig;
  824         struct  sigaction *act;
  825         struct  sigaction *oact;
  826 };
  827 #endif
  828 int
  829 sys_sigaction(struct thread *td, struct sigaction_args *uap)
  830 {
  831         struct sigaction act, oact;
  832         struct sigaction *actp, *oactp;
  833         int error;
  834 
  835         actp = (uap->act != NULL) ? &act : NULL;
  836         oactp = (uap->oact != NULL) ? &oact : NULL;
  837         if (actp) {
  838                 error = copyin(uap->act, actp, sizeof(act));
  839                 if (error)
  840                         return (error);
  841         }
  842         error = kern_sigaction(td, uap->sig, actp, oactp, 0);
  843         if (oactp && !error)
  844                 error = copyout(oactp, uap->oact, sizeof(oact));
  845         return (error);
  846 }
  847 
  848 #ifdef COMPAT_FREEBSD4
  849 #ifndef _SYS_SYSPROTO_H_
  850 struct freebsd4_sigaction_args {
  851         int     sig;
  852         struct  sigaction *act;
  853         struct  sigaction *oact;
  854 };
  855 #endif
  856 int
  857 freebsd4_sigaction(struct thread *td, struct freebsd4_sigaction_args *uap)
  858 {
  859         struct sigaction act, oact;
  860         struct sigaction *actp, *oactp;
  861         int error;
  862 
  863 
  864         actp = (uap->act != NULL) ? &act : NULL;
  865         oactp = (uap->oact != NULL) ? &oact : NULL;
  866         if (actp) {
  867                 error = copyin(uap->act, actp, sizeof(act));
  868                 if (error)
  869                         return (error);
  870         }
  871         error = kern_sigaction(td, uap->sig, actp, oactp, KSA_FREEBSD4);
  872         if (oactp && !error)
  873                 error = copyout(oactp, uap->oact, sizeof(oact));
  874         return (error);
  875 }
  876 #endif  /* COMAPT_FREEBSD4 */
  877 
  878 #ifdef COMPAT_43        /* XXX - COMPAT_FBSD3 */
  879 #ifndef _SYS_SYSPROTO_H_
  880 struct osigaction_args {
  881         int     signum;
  882         struct  osigaction *nsa;
  883         struct  osigaction *osa;
  884 };
  885 #endif
  886 int
  887 osigaction(struct thread *td, struct osigaction_args *uap)
  888 {
  889         struct osigaction sa;
  890         struct sigaction nsa, osa;
  891         struct sigaction *nsap, *osap;
  892         int error;
  893 
  894         if (uap->signum <= 0 || uap->signum >= ONSIG)
  895                 return (EINVAL);
  896 
  897         nsap = (uap->nsa != NULL) ? &nsa : NULL;
  898         osap = (uap->osa != NULL) ? &osa : NULL;
  899 
  900         if (nsap) {
  901                 error = copyin(uap->nsa, &sa, sizeof(sa));
  902                 if (error)
  903                         return (error);
  904                 nsap->sa_handler = sa.sa_handler;
  905                 nsap->sa_flags = sa.sa_flags;
  906                 OSIG2SIG(sa.sa_mask, nsap->sa_mask);
  907         }
  908         error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET);
  909         if (osap && !error) {
  910                 sa.sa_handler = osap->sa_handler;
  911                 sa.sa_flags = osap->sa_flags;
  912                 SIG2OSIG(osap->sa_mask, sa.sa_mask);
  913                 error = copyout(&sa, uap->osa, sizeof(sa));
  914         }
  915         return (error);
  916 }
  917 
  918 #if !defined(__i386__)
  919 /* Avoid replicating the same stub everywhere */
  920 int
  921 osigreturn(struct thread *td, struct osigreturn_args *uap)
  922 {
  923 
  924         return (nosys(td, (struct nosys_args *)uap));
  925 }
  926 #endif
  927 #endif /* COMPAT_43 */
  928 
  929 /*
  930  * Initialize signal state for process 0;
  931  * set to ignore signals that are ignored by default.
  932  */
  933 void
  934 siginit(struct proc *p)
  935 {
  936         int i;
  937         struct sigacts *ps;
  938 
  939         PROC_LOCK(p);
  940         ps = p->p_sigacts;
  941         mtx_lock(&ps->ps_mtx);
  942         for (i = 1; i <= NSIG; i++) {
  943                 if (sigprop(i) & SA_IGNORE && i != SIGCONT) {
  944                         SIGADDSET(ps->ps_sigignore, i);
  945                 }
  946         }
  947         mtx_unlock(&ps->ps_mtx);
  948         PROC_UNLOCK(p);
  949 }
  950 
  951 /*
  952  * Reset specified signal to the default disposition.
  953  */
  954 static void
  955 sigdflt(struct sigacts *ps, int sig)
  956 {
  957 
  958         mtx_assert(&ps->ps_mtx, MA_OWNED);
  959         SIGDELSET(ps->ps_sigcatch, sig);
  960         if ((sigprop(sig) & SA_IGNORE) != 0 && sig != SIGCONT)
  961                 SIGADDSET(ps->ps_sigignore, sig);
  962         ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
  963         SIGDELSET(ps->ps_siginfo, sig);
  964 }
  965 
  966 /*
  967  * Reset signals for an exec of the specified process.
  968  */
  969 void
  970 execsigs(struct proc *p)
  971 {
  972         sigset_t osigignore;
  973         struct sigacts *ps;
  974         int sig;
  975         struct thread *td;
  976 
  977         /*
  978          * Reset caught signals.  Held signals remain held
  979          * through td_sigmask (unless they were caught,
  980          * and are now ignored by default).
  981          */
  982         PROC_LOCK_ASSERT(p, MA_OWNED);
  983         ps = p->p_sigacts;
  984         mtx_lock(&ps->ps_mtx);
  985         while (SIGNOTEMPTY(ps->ps_sigcatch)) {
  986                 sig = sig_ffs(&ps->ps_sigcatch);
  987                 sigdflt(ps, sig);
  988                 if ((sigprop(sig) & SA_IGNORE) != 0)
  989                         sigqueue_delete_proc(p, sig);
  990         }
  991 
  992         /*
  993          * As CloudABI processes cannot modify signal handlers, fully
  994          * reset all signals to their default behavior. Do ignore
  995          * SIGPIPE, as it would otherwise be impossible to recover from
  996          * writes to broken pipes and sockets.
  997          */
  998         if (SV_PROC_ABI(p) == SV_ABI_CLOUDABI) {
  999                 osigignore = ps->ps_sigignore;
 1000                 while (SIGNOTEMPTY(osigignore)) {
 1001                         sig = sig_ffs(&osigignore);
 1002                         SIGDELSET(osigignore, sig);
 1003                         if (sig != SIGPIPE)
 1004                                 sigdflt(ps, sig);
 1005                 }
 1006                 SIGADDSET(ps->ps_sigignore, SIGPIPE);
 1007         }
 1008 
 1009         /*
 1010          * Reset stack state to the user stack.
 1011          * Clear set of signals caught on the signal stack.
 1012          */
 1013         td = curthread;
 1014         MPASS(td->td_proc == p);
 1015         td->td_sigstk.ss_flags = SS_DISABLE;
 1016         td->td_sigstk.ss_size = 0;
 1017         td->td_sigstk.ss_sp = 0;
 1018         td->td_pflags &= ~TDP_ALTSTACK;
 1019         /*
 1020          * Reset no zombies if child dies flag as Solaris does.
 1021          */
 1022         ps->ps_flag &= ~(PS_NOCLDWAIT | PS_CLDSIGIGN);
 1023         if (ps->ps_sigact[_SIG_IDX(SIGCHLD)] == SIG_IGN)
 1024                 ps->ps_sigact[_SIG_IDX(SIGCHLD)] = SIG_DFL;
 1025         mtx_unlock(&ps->ps_mtx);
 1026 }
 1027 
 1028 /*
 1029  * kern_sigprocmask()
 1030  *
 1031  *      Manipulate signal mask.
 1032  */
 1033 int
 1034 kern_sigprocmask(struct thread *td, int how, sigset_t *set, sigset_t *oset,
 1035     int flags)
 1036 {
 1037         sigset_t new_block, oset1;
 1038         struct proc *p;
 1039         int error;
 1040 
 1041         p = td->td_proc;
 1042         if ((flags & SIGPROCMASK_PROC_LOCKED) != 0)
 1043                 PROC_LOCK_ASSERT(p, MA_OWNED);
 1044         else
 1045                 PROC_LOCK(p);
 1046         mtx_assert(&p->p_sigacts->ps_mtx, (flags & SIGPROCMASK_PS_LOCKED) != 0
 1047             ? MA_OWNED : MA_NOTOWNED);
 1048         if (oset != NULL)
 1049                 *oset = td->td_sigmask;
 1050 
 1051         error = 0;
 1052         if (set != NULL) {
 1053                 switch (how) {
 1054                 case SIG_BLOCK:
 1055                         SIG_CANTMASK(*set);
 1056                         oset1 = td->td_sigmask;
 1057                         SIGSETOR(td->td_sigmask, *set);
 1058                         new_block = td->td_sigmask;
 1059                         SIGSETNAND(new_block, oset1);
 1060                         break;
 1061                 case SIG_UNBLOCK:
 1062                         SIGSETNAND(td->td_sigmask, *set);
 1063                         signotify(td);
 1064                         goto out;
 1065                 case SIG_SETMASK:
 1066                         SIG_CANTMASK(*set);
 1067                         oset1 = td->td_sigmask;
 1068                         if (flags & SIGPROCMASK_OLD)
 1069                                 SIGSETLO(td->td_sigmask, *set);
 1070                         else
 1071                                 td->td_sigmask = *set;
 1072                         new_block = td->td_sigmask;
 1073                         SIGSETNAND(new_block, oset1);
 1074                         signotify(td);
 1075                         break;
 1076                 default:
 1077                         error = EINVAL;
 1078                         goto out;
 1079                 }
 1080 
 1081                 /*
 1082                  * The new_block set contains signals that were not previously
 1083                  * blocked, but are blocked now.
 1084                  *
 1085                  * In case we block any signal that was not previously blocked
 1086                  * for td, and process has the signal pending, try to schedule
 1087                  * signal delivery to some thread that does not block the
 1088                  * signal, possibly waking it up.
 1089                  */
 1090                 if (p->p_numthreads != 1)
 1091                         reschedule_signals(p, new_block, flags);
 1092         }
 1093 
 1094 out:
 1095         if (!(flags & SIGPROCMASK_PROC_LOCKED))
 1096                 PROC_UNLOCK(p);
 1097         return (error);
 1098 }
 1099 
 1100 #ifndef _SYS_SYSPROTO_H_
 1101 struct sigprocmask_args {
 1102         int     how;
 1103         const sigset_t *set;
 1104         sigset_t *oset;
 1105 };
 1106 #endif
 1107 int
 1108 sys_sigprocmask(struct thread *td, struct sigprocmask_args *uap)
 1109 {
 1110         sigset_t set, oset;
 1111         sigset_t *setp, *osetp;
 1112         int error;
 1113 
 1114         setp = (uap->set != NULL) ? &set : NULL;
 1115         osetp = (uap->oset != NULL) ? &oset : NULL;
 1116         if (setp) {
 1117                 error = copyin(uap->set, setp, sizeof(set));
 1118                 if (error)
 1119                         return (error);
 1120         }
 1121         error = kern_sigprocmask(td, uap->how, setp, osetp, 0);
 1122         if (osetp && !error) {
 1123                 error = copyout(osetp, uap->oset, sizeof(oset));
 1124         }
 1125         return (error);
 1126 }
 1127 
 1128 #ifdef COMPAT_43        /* XXX - COMPAT_FBSD3 */
 1129 #ifndef _SYS_SYSPROTO_H_
 1130 struct osigprocmask_args {
 1131         int     how;
 1132         osigset_t mask;
 1133 };
 1134 #endif
 1135 int
 1136 osigprocmask(struct thread *td, struct osigprocmask_args *uap)
 1137 {
 1138         sigset_t set, oset;
 1139         int error;
 1140 
 1141         OSIG2SIG(uap->mask, set);
 1142         error = kern_sigprocmask(td, uap->how, &set, &oset, 1);
 1143         SIG2OSIG(oset, td->td_retval[0]);
 1144         return (error);
 1145 }
 1146 #endif /* COMPAT_43 */
 1147 
 1148 int
 1149 sys_sigwait(struct thread *td, struct sigwait_args *uap)
 1150 {
 1151         ksiginfo_t ksi;
 1152         sigset_t set;
 1153         int error;
 1154 
 1155         error = copyin(uap->set, &set, sizeof(set));
 1156         if (error) {
 1157                 td->td_retval[0] = error;
 1158                 return (0);
 1159         }
 1160 
 1161         error = kern_sigtimedwait(td, set, &ksi, NULL);
 1162         if (error) {
 1163                 if (error == EINTR && td->td_proc->p_osrel < P_OSREL_SIGWAIT)
 1164                         error = ERESTART;
 1165                 if (error == ERESTART)
 1166                         return (error);
 1167                 td->td_retval[0] = error;
 1168                 return (0);
 1169         }
 1170 
 1171         error = copyout(&ksi.ksi_signo, uap->sig, sizeof(ksi.ksi_signo));
 1172         td->td_retval[0] = error;
 1173         return (0);
 1174 }
 1175 
 1176 int
 1177 sys_sigtimedwait(struct thread *td, struct sigtimedwait_args *uap)
 1178 {
 1179         struct timespec ts;
 1180         struct timespec *timeout;
 1181         sigset_t set;
 1182         ksiginfo_t ksi;
 1183         int error;
 1184 
 1185         if (uap->timeout) {
 1186                 error = copyin(uap->timeout, &ts, sizeof(ts));
 1187                 if (error)
 1188                         return (error);
 1189 
 1190                 timeout = &ts;
 1191         } else
 1192                 timeout = NULL;
 1193 
 1194         error = copyin(uap->set, &set, sizeof(set));
 1195         if (error)
 1196                 return (error);
 1197 
 1198         error = kern_sigtimedwait(td, set, &ksi, timeout);
 1199         if (error)
 1200                 return (error);
 1201 
 1202         if (uap->info)
 1203                 error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t));
 1204 
 1205         if (error == 0)
 1206                 td->td_retval[0] = ksi.ksi_signo;
 1207         return (error);
 1208 }
 1209 
 1210 int
 1211 sys_sigwaitinfo(struct thread *td, struct sigwaitinfo_args *uap)
 1212 {
 1213         ksiginfo_t ksi;
 1214         sigset_t set;
 1215         int error;
 1216 
 1217         error = copyin(uap->set, &set, sizeof(set));
 1218         if (error)
 1219                 return (error);
 1220 
 1221         error = kern_sigtimedwait(td, set, &ksi, NULL);
 1222         if (error)
 1223                 return (error);
 1224 
 1225         if (uap->info)
 1226                 error = copyout(&ksi.ksi_info, uap->info, sizeof(siginfo_t));
 1227 
 1228         if (error == 0)
 1229                 td->td_retval[0] = ksi.ksi_signo;
 1230         return (error);
 1231 }
 1232 
 1233 static void
 1234 proc_td_siginfo_capture(struct thread *td, siginfo_t *si)
 1235 {
 1236         struct thread *thr;
 1237 
 1238         FOREACH_THREAD_IN_PROC(td->td_proc, thr) {
 1239                 if (thr == td)
 1240                         thr->td_si = *si;
 1241                 else
 1242                         thr->td_si.si_signo = 0;
 1243         }
 1244 }
 1245 
 1246 int
 1247 kern_sigtimedwait(struct thread *td, sigset_t waitset, ksiginfo_t *ksi,
 1248         struct timespec *timeout)
 1249 {
 1250         struct sigacts *ps;
 1251         sigset_t saved_mask, new_block;
 1252         struct proc *p;
 1253         int error, sig, timo, timevalid = 0;
 1254         struct timespec rts, ets, ts;
 1255         struct timeval tv;
 1256 
 1257         p = td->td_proc;
 1258         error = 0;
 1259         ets.tv_sec = 0;
 1260         ets.tv_nsec = 0;
 1261 
 1262         if (timeout != NULL) {
 1263                 if (timeout->tv_nsec >= 0 && timeout->tv_nsec < 1000000000) {
 1264                         timevalid = 1;
 1265                         getnanouptime(&rts);
 1266                         ets = rts;
 1267                         timespecadd(&ets, timeout);
 1268                 }
 1269         }
 1270         ksiginfo_init(ksi);
 1271         /* Some signals can not be waited for. */
 1272         SIG_CANTMASK(waitset);
 1273         ps = p->p_sigacts;
 1274         PROC_LOCK(p);
 1275         saved_mask = td->td_sigmask;
 1276         SIGSETNAND(td->td_sigmask, waitset);
 1277         for (;;) {
 1278                 mtx_lock(&ps->ps_mtx);
 1279                 sig = cursig(td);
 1280                 mtx_unlock(&ps->ps_mtx);
 1281                 KASSERT(sig >= 0, ("sig %d", sig));
 1282                 if (sig != 0 && SIGISMEMBER(waitset, sig)) {
 1283                         if (sigqueue_get(&td->td_sigqueue, sig, ksi) != 0 ||
 1284                             sigqueue_get(&p->p_sigqueue, sig, ksi) != 0) {
 1285                                 error = 0;
 1286                                 break;
 1287                         }
 1288                 }
 1289 
 1290                 if (error != 0)
 1291                         break;
 1292 
 1293                 /*
 1294                  * POSIX says this must be checked after looking for pending
 1295                  * signals.
 1296                  */
 1297                 if (timeout != NULL) {
 1298                         if (!timevalid) {
 1299                                 error = EINVAL;
 1300                                 break;
 1301                         }
 1302                         getnanouptime(&rts);
 1303                         if (timespeccmp(&rts, &ets, >=)) {
 1304                                 error = EAGAIN;
 1305                                 break;
 1306                         }
 1307                         ts = ets;
 1308                         timespecsub(&ts, &rts);
 1309                         TIMESPEC_TO_TIMEVAL(&tv, &ts);
 1310                         timo = tvtohz(&tv);
 1311                 } else {
 1312                         timo = 0;
 1313                 }
 1314 
 1315                 error = msleep(ps, &p->p_mtx, PPAUSE|PCATCH, "sigwait", timo);
 1316 
 1317                 if (timeout != NULL) {
 1318                         if (error == ERESTART) {
 1319                                 /* Timeout can not be restarted. */
 1320                                 error = EINTR;
 1321                         } else if (error == EAGAIN) {
 1322                                 /* We will calculate timeout by ourself. */
 1323                                 error = 0;
 1324                         }
 1325                 }
 1326         }
 1327 
 1328         new_block = saved_mask;
 1329         SIGSETNAND(new_block, td->td_sigmask);
 1330         td->td_sigmask = saved_mask;
 1331         /*
 1332          * Fewer signals can be delivered to us, reschedule signal
 1333          * notification.
 1334          */
 1335         if (p->p_numthreads != 1)
 1336                 reschedule_signals(p, new_block, 0);
 1337 
 1338         if (error == 0) {
 1339                 SDT_PROBE2(proc, , , signal__clear, sig, ksi);
 1340 
 1341                 if (ksi->ksi_code == SI_TIMER)
 1342                         itimer_accept(p, ksi->ksi_timerid, ksi);
 1343 
 1344 #ifdef KTRACE
 1345                 if (KTRPOINT(td, KTR_PSIG)) {
 1346                         sig_t action;
 1347 
 1348                         mtx_lock(&ps->ps_mtx);
 1349                         action = ps->ps_sigact[_SIG_IDX(sig)];
 1350                         mtx_unlock(&ps->ps_mtx);
 1351                         ktrpsig(sig, action, &td->td_sigmask, ksi->ksi_code);
 1352                 }
 1353 #endif
 1354                 if (sig == SIGKILL) {
 1355                         proc_td_siginfo_capture(td, &ksi->ksi_info);
 1356                         sigexit(td, sig);
 1357                 }
 1358         }
 1359         PROC_UNLOCK(p);
 1360         return (error);
 1361 }
 1362 
 1363 #ifndef _SYS_SYSPROTO_H_
 1364 struct sigpending_args {
 1365         sigset_t        *set;
 1366 };
 1367 #endif
 1368 int
 1369 sys_sigpending(struct thread *td, struct sigpending_args *uap)
 1370 {
 1371         struct proc *p = td->td_proc;
 1372         sigset_t pending;
 1373 
 1374         PROC_LOCK(p);
 1375         pending = p->p_sigqueue.sq_signals;
 1376         SIGSETOR(pending, td->td_sigqueue.sq_signals);
 1377         PROC_UNLOCK(p);
 1378         return (copyout(&pending, uap->set, sizeof(sigset_t)));
 1379 }
 1380 
 1381 #ifdef COMPAT_43        /* XXX - COMPAT_FBSD3 */
 1382 #ifndef _SYS_SYSPROTO_H_
 1383 struct osigpending_args {
 1384         int     dummy;
 1385 };
 1386 #endif
 1387 int
 1388 osigpending(struct thread *td, struct osigpending_args *uap)
 1389 {
 1390         struct proc *p = td->td_proc;
 1391         sigset_t pending;
 1392 
 1393         PROC_LOCK(p);
 1394         pending = p->p_sigqueue.sq_signals;
 1395         SIGSETOR(pending, td->td_sigqueue.sq_signals);
 1396         PROC_UNLOCK(p);
 1397         SIG2OSIG(pending, td->td_retval[0]);
 1398         return (0);
 1399 }
 1400 #endif /* COMPAT_43 */
 1401 
 1402 #if defined(COMPAT_43)
 1403 /*
 1404  * Generalized interface signal handler, 4.3-compatible.
 1405  */
 1406 #ifndef _SYS_SYSPROTO_H_
 1407 struct osigvec_args {
 1408         int     signum;
 1409         struct  sigvec *nsv;
 1410         struct  sigvec *osv;
 1411 };
 1412 #endif
 1413 /* ARGSUSED */
 1414 int
 1415 osigvec(struct thread *td, struct osigvec_args *uap)
 1416 {
 1417         struct sigvec vec;
 1418         struct sigaction nsa, osa;
 1419         struct sigaction *nsap, *osap;
 1420         int error;
 1421 
 1422         if (uap->signum <= 0 || uap->signum >= ONSIG)
 1423                 return (EINVAL);
 1424         nsap = (uap->nsv != NULL) ? &nsa : NULL;
 1425         osap = (uap->osv != NULL) ? &osa : NULL;
 1426         if (nsap) {
 1427                 error = copyin(uap->nsv, &vec, sizeof(vec));
 1428                 if (error)
 1429                         return (error);
 1430                 nsap->sa_handler = vec.sv_handler;
 1431                 OSIG2SIG(vec.sv_mask, nsap->sa_mask);
 1432                 nsap->sa_flags = vec.sv_flags;
 1433                 nsap->sa_flags ^= SA_RESTART;   /* opposite of SV_INTERRUPT */
 1434         }
 1435         error = kern_sigaction(td, uap->signum, nsap, osap, KSA_OSIGSET);
 1436         if (osap && !error) {
 1437                 vec.sv_handler = osap->sa_handler;
 1438                 SIG2OSIG(osap->sa_mask, vec.sv_mask);
 1439                 vec.sv_flags = osap->sa_flags;
 1440                 vec.sv_flags &= ~SA_NOCLDWAIT;
 1441                 vec.sv_flags ^= SA_RESTART;
 1442                 error = copyout(&vec, uap->osv, sizeof(vec));
 1443         }
 1444         return (error);
 1445 }
 1446 
 1447 #ifndef _SYS_SYSPROTO_H_
 1448 struct osigblock_args {
 1449         int     mask;
 1450 };
 1451 #endif
 1452 int
 1453 osigblock(struct thread *td, struct osigblock_args *uap)
 1454 {
 1455         sigset_t set, oset;
 1456 
 1457         OSIG2SIG(uap->mask, set);
 1458         kern_sigprocmask(td, SIG_BLOCK, &set, &oset, 0);
 1459         SIG2OSIG(oset, td->td_retval[0]);
 1460         return (0);
 1461 }
 1462 
 1463 #ifndef _SYS_SYSPROTO_H_
 1464 struct osigsetmask_args {
 1465         int     mask;
 1466 };
 1467 #endif
 1468 int
 1469 osigsetmask(struct thread *td, struct osigsetmask_args *uap)
 1470 {
 1471         sigset_t set, oset;
 1472 
 1473         OSIG2SIG(uap->mask, set);
 1474         kern_sigprocmask(td, SIG_SETMASK, &set, &oset, 0);
 1475         SIG2OSIG(oset, td->td_retval[0]);
 1476         return (0);
 1477 }
 1478 #endif /* COMPAT_43 */
 1479 
 1480 /*
 1481  * Suspend calling thread until signal, providing mask to be set in the
 1482  * meantime.
 1483  */
 1484 #ifndef _SYS_SYSPROTO_H_
 1485 struct sigsuspend_args {
 1486         const sigset_t *sigmask;
 1487 };
 1488 #endif
 1489 /* ARGSUSED */
 1490 int
 1491 sys_sigsuspend(struct thread *td, struct sigsuspend_args *uap)
 1492 {
 1493         sigset_t mask;
 1494         int error;
 1495 
 1496         error = copyin(uap->sigmask, &mask, sizeof(mask));
 1497         if (error)
 1498                 return (error);
 1499         return (kern_sigsuspend(td, mask));
 1500 }
 1501 
 1502 int
 1503 kern_sigsuspend(struct thread *td, sigset_t mask)
 1504 {
 1505         struct proc *p = td->td_proc;
 1506         int has_sig, sig;
 1507 
 1508         /*
 1509          * When returning from sigsuspend, we want
 1510          * the old mask to be restored after the
 1511          * signal handler has finished.  Thus, we
 1512          * save it here and mark the sigacts structure
 1513          * to indicate this.
 1514          */
 1515         PROC_LOCK(p);
 1516         kern_sigprocmask(td, SIG_SETMASK, &mask, &td->td_oldsigmask,
 1517             SIGPROCMASK_PROC_LOCKED);
 1518         td->td_pflags |= TDP_OLDMASK;
 1519 
 1520         /*
 1521          * Process signals now. Otherwise, we can get spurious wakeup
 1522          * due to signal entered process queue, but delivered to other
 1523          * thread. But sigsuspend should return only on signal
 1524          * delivery.
 1525          */
 1526         (p->p_sysent->sv_set_syscall_retval)(td, EINTR);
 1527         for (has_sig = 0; !has_sig;) {
 1528                 while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "pause",
 1529                         0) == 0)
 1530                         /* void */;
 1531                 thread_suspend_check(0);
 1532                 mtx_lock(&p->p_sigacts->ps_mtx);
 1533                 while ((sig = cursig(td)) != 0) {
 1534                         KASSERT(sig >= 0, ("sig %d", sig));
 1535                         has_sig += postsig(sig);
 1536                 }
 1537                 mtx_unlock(&p->p_sigacts->ps_mtx);
 1538         }
 1539         PROC_UNLOCK(p);
 1540         td->td_errno = EINTR;
 1541         td->td_pflags |= TDP_NERRNO;
 1542         return (EJUSTRETURN);
 1543 }
 1544 
 1545 #ifdef COMPAT_43        /* XXX - COMPAT_FBSD3 */
 1546 /*
 1547  * Compatibility sigsuspend call for old binaries.  Note nonstandard calling
 1548  * convention: libc stub passes mask, not pointer, to save a copyin.
 1549  */
 1550 #ifndef _SYS_SYSPROTO_H_
 1551 struct osigsuspend_args {
 1552         osigset_t mask;
 1553 };
 1554 #endif
 1555 /* ARGSUSED */
 1556 int
 1557 osigsuspend(struct thread *td, struct osigsuspend_args *uap)
 1558 {
 1559         sigset_t mask;
 1560 
 1561         OSIG2SIG(uap->mask, mask);
 1562         return (kern_sigsuspend(td, mask));
 1563 }
 1564 #endif /* COMPAT_43 */
 1565 
 1566 #if defined(COMPAT_43)
 1567 #ifndef _SYS_SYSPROTO_H_
 1568 struct osigstack_args {
 1569         struct  sigstack *nss;
 1570         struct  sigstack *oss;
 1571 };
 1572 #endif
 1573 /* ARGSUSED */
 1574 int
 1575 osigstack(struct thread *td, struct osigstack_args *uap)
 1576 {
 1577         struct sigstack nss, oss;
 1578         int error = 0;
 1579 
 1580         if (uap->nss != NULL) {
 1581                 error = copyin(uap->nss, &nss, sizeof(nss));
 1582                 if (error)
 1583                         return (error);
 1584         }
 1585         oss.ss_sp = td->td_sigstk.ss_sp;
 1586         oss.ss_onstack = sigonstack(cpu_getstack(td));
 1587         if (uap->nss != NULL) {
 1588                 td->td_sigstk.ss_sp = nss.ss_sp;
 1589                 td->td_sigstk.ss_size = 0;
 1590                 td->td_sigstk.ss_flags |= nss.ss_onstack & SS_ONSTACK;
 1591                 td->td_pflags |= TDP_ALTSTACK;
 1592         }
 1593         if (uap->oss != NULL)
 1594                 error = copyout(&oss, uap->oss, sizeof(oss));
 1595 
 1596         return (error);
 1597 }
 1598 #endif /* COMPAT_43 */
 1599 
 1600 #ifndef _SYS_SYSPROTO_H_
 1601 struct sigaltstack_args {
 1602         stack_t *ss;
 1603         stack_t *oss;
 1604 };
 1605 #endif
 1606 /* ARGSUSED */
 1607 int
 1608 sys_sigaltstack(struct thread *td, struct sigaltstack_args *uap)
 1609 {
 1610         stack_t ss, oss;
 1611         int error;
 1612 
 1613         if (uap->ss != NULL) {
 1614                 error = copyin(uap->ss, &ss, sizeof(ss));
 1615                 if (error)
 1616                         return (error);
 1617         }
 1618         error = kern_sigaltstack(td, (uap->ss != NULL) ? &ss : NULL,
 1619             (uap->oss != NULL) ? &oss : NULL);
 1620         if (error)
 1621                 return (error);
 1622         if (uap->oss != NULL)
 1623                 error = copyout(&oss, uap->oss, sizeof(stack_t));
 1624         return (error);
 1625 }
 1626 
 1627 int
 1628 kern_sigaltstack(struct thread *td, stack_t *ss, stack_t *oss)
 1629 {
 1630         struct proc *p = td->td_proc;
 1631         int oonstack;
 1632 
 1633         oonstack = sigonstack(cpu_getstack(td));
 1634 
 1635         if (oss != NULL) {
 1636                 *oss = td->td_sigstk;
 1637                 oss->ss_flags = (td->td_pflags & TDP_ALTSTACK)
 1638                     ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
 1639         }
 1640 
 1641         if (ss != NULL) {
 1642                 if (oonstack)
 1643                         return (EPERM);
 1644                 if ((ss->ss_flags & ~SS_DISABLE) != 0)
 1645                         return (EINVAL);
 1646                 if (!(ss->ss_flags & SS_DISABLE)) {
 1647                         if (ss->ss_size < p->p_sysent->sv_minsigstksz)
 1648                                 return (ENOMEM);
 1649 
 1650                         td->td_sigstk = *ss;
 1651                         td->td_pflags |= TDP_ALTSTACK;
 1652                 } else {
 1653                         td->td_pflags &= ~TDP_ALTSTACK;
 1654                 }
 1655         }
 1656         return (0);
 1657 }
 1658 
 1659 /*
 1660  * Common code for kill process group/broadcast kill.
 1661  * cp is calling process.
 1662  */
 1663 static int
 1664 killpg1(struct thread *td, int sig, int pgid, int all, ksiginfo_t *ksi)
 1665 {
 1666         struct proc *p;
 1667         struct pgrp *pgrp;
 1668         int err;
 1669         int ret;
 1670 
 1671         ret = ESRCH;
 1672         if (all) {
 1673                 /*
 1674                  * broadcast
 1675                  */
 1676                 sx_slock(&allproc_lock);
 1677                 FOREACH_PROC_IN_SYSTEM(p) {
 1678                         PROC_LOCK(p);
 1679                         if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
 1680                             p == td->td_proc || p->p_state == PRS_NEW) {
 1681                                 PROC_UNLOCK(p);
 1682                                 continue;
 1683                         }
 1684                         err = p_cansignal(td, p, sig);
 1685                         if (err == 0) {
 1686                                 if (sig)
 1687                                         pksignal(p, sig, ksi);
 1688                                 ret = err;
 1689                         }
 1690                         else if (ret == ESRCH)
 1691                                 ret = err;
 1692                         PROC_UNLOCK(p);
 1693                 }
 1694                 sx_sunlock(&allproc_lock);
 1695         } else {
 1696                 sx_slock(&proctree_lock);
 1697                 if (pgid == 0) {
 1698                         /*
 1699                          * zero pgid means send to my process group.
 1700                          */
 1701                         pgrp = td->td_proc->p_pgrp;
 1702                         PGRP_LOCK(pgrp);
 1703                 } else {
 1704                         pgrp = pgfind(pgid);
 1705                         if (pgrp == NULL) {
 1706                                 sx_sunlock(&proctree_lock);
 1707                                 return (ESRCH);
 1708                         }
 1709                 }
 1710                 sx_sunlock(&proctree_lock);
 1711                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
 1712                         PROC_LOCK(p);
 1713                         if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
 1714                             p->p_state == PRS_NEW) {
 1715                                 PROC_UNLOCK(p);
 1716                                 continue;
 1717                         }
 1718                         err = p_cansignal(td, p, sig);
 1719                         if (err == 0) {
 1720                                 if (sig)
 1721                                         pksignal(p, sig, ksi);
 1722                                 ret = err;
 1723                         }
 1724                         else if (ret == ESRCH)
 1725                                 ret = err;
 1726                         PROC_UNLOCK(p);
 1727                 }
 1728                 PGRP_UNLOCK(pgrp);
 1729         }
 1730         return (ret);
 1731 }
 1732 
 1733 #ifndef _SYS_SYSPROTO_H_
 1734 struct kill_args {
 1735         int     pid;
 1736         int     signum;
 1737 };
 1738 #endif
 1739 /* ARGSUSED */
 1740 int
 1741 sys_kill(struct thread *td, struct kill_args *uap)
 1742 {
 1743         ksiginfo_t ksi;
 1744         struct proc *p;
 1745         int error;
 1746 
 1747         /*
 1748          * A process in capability mode can send signals only to himself.
 1749          * The main rationale behind this is that abort(3) is implemented as
 1750          * kill(getpid(), SIGABRT).
 1751          */
 1752         if (IN_CAPABILITY_MODE(td) && uap->pid != td->td_proc->p_pid)
 1753                 return (ECAPMODE);
 1754 
 1755         AUDIT_ARG_SIGNUM(uap->signum);
 1756         AUDIT_ARG_PID(uap->pid);
 1757         if ((u_int)uap->signum > _SIG_MAXSIG)
 1758                 return (EINVAL);
 1759 
 1760         ksiginfo_init(&ksi);
 1761         ksi.ksi_signo = uap->signum;
 1762         ksi.ksi_code = SI_USER;
 1763         ksi.ksi_pid = td->td_proc->p_pid;
 1764         ksi.ksi_uid = td->td_ucred->cr_ruid;
 1765 
 1766         if (uap->pid > 0) {
 1767                 /* kill single process */
 1768                 if ((p = pfind(uap->pid)) == NULL) {
 1769                         if ((p = zpfind(uap->pid)) == NULL)
 1770                                 return (ESRCH);
 1771                 }
 1772                 AUDIT_ARG_PROCESS(p);
 1773                 error = p_cansignal(td, p, uap->signum);
 1774                 if (error == 0 && uap->signum)
 1775                         pksignal(p, uap->signum, &ksi);
 1776                 PROC_UNLOCK(p);
 1777                 return (error);
 1778         }
 1779         switch (uap->pid) {
 1780         case -1:                /* broadcast signal */
 1781                 return (killpg1(td, uap->signum, 0, 1, &ksi));
 1782         case 0:                 /* signal own process group */
 1783                 return (killpg1(td, uap->signum, 0, 0, &ksi));
 1784         default:                /* negative explicit process group */
 1785                 return (killpg1(td, uap->signum, -uap->pid, 0, &ksi));
 1786         }
 1787         /* NOTREACHED */
 1788 }
 1789 
 1790 int
 1791 sys_pdkill(struct thread *td, struct pdkill_args *uap)
 1792 {
 1793         struct proc *p;
 1794         cap_rights_t rights;
 1795         int error;
 1796 
 1797         AUDIT_ARG_SIGNUM(uap->signum);
 1798         AUDIT_ARG_FD(uap->fd);
 1799         if ((u_int)uap->signum > _SIG_MAXSIG)
 1800                 return (EINVAL);
 1801 
 1802         error = procdesc_find(td, uap->fd,
 1803             cap_rights_init(&rights, CAP_PDKILL), &p);
 1804         if (error)
 1805                 return (error);
 1806         AUDIT_ARG_PROCESS(p);
 1807         error = p_cansignal(td, p, uap->signum);
 1808         if (error == 0 && uap->signum)
 1809                 kern_psignal(p, uap->signum);
 1810         PROC_UNLOCK(p);
 1811         return (error);
 1812 }
 1813 
 1814 #if defined(COMPAT_43)
 1815 #ifndef _SYS_SYSPROTO_H_
 1816 struct okillpg_args {
 1817         int     pgid;
 1818         int     signum;
 1819 };
 1820 #endif
 1821 /* ARGSUSED */
 1822 int
 1823 okillpg(struct thread *td, struct okillpg_args *uap)
 1824 {
 1825         ksiginfo_t ksi;
 1826 
 1827         AUDIT_ARG_SIGNUM(uap->signum);
 1828         AUDIT_ARG_PID(uap->pgid);
 1829         if ((u_int)uap->signum > _SIG_MAXSIG)
 1830                 return (EINVAL);
 1831 
 1832         ksiginfo_init(&ksi);
 1833         ksi.ksi_signo = uap->signum;
 1834         ksi.ksi_code = SI_USER;
 1835         ksi.ksi_pid = td->td_proc->p_pid;
 1836         ksi.ksi_uid = td->td_ucred->cr_ruid;
 1837         return (killpg1(td, uap->signum, uap->pgid, 0, &ksi));
 1838 }
 1839 #endif /* COMPAT_43 */
 1840 
 1841 #ifndef _SYS_SYSPROTO_H_
 1842 struct sigqueue_args {
 1843         pid_t pid;
 1844         int signum;
 1845         /* union sigval */ void *value;
 1846 };
 1847 #endif
 1848 int
 1849 sys_sigqueue(struct thread *td, struct sigqueue_args *uap)
 1850 {
 1851         union sigval sv;
 1852 
 1853         sv.sival_ptr = uap->value;
 1854 
 1855         return (kern_sigqueue(td, uap->pid, uap->signum, &sv));
 1856 }
 1857 
 1858 int
 1859 kern_sigqueue(struct thread *td, pid_t pid, int signum, union sigval *value)
 1860 {
 1861         ksiginfo_t ksi;
 1862         struct proc *p;
 1863         int error;
 1864 
 1865         if ((u_int)signum > _SIG_MAXSIG)
 1866                 return (EINVAL);
 1867 
 1868         /*
 1869          * Specification says sigqueue can only send signal to
 1870          * single process.
 1871          */
 1872         if (pid <= 0)
 1873                 return (EINVAL);
 1874 
 1875         if ((p = pfind(pid)) == NULL) {
 1876                 if ((p = zpfind(pid)) == NULL)
 1877                         return (ESRCH);
 1878         }
 1879         error = p_cansignal(td, p, signum);
 1880         if (error == 0 && signum != 0) {
 1881                 ksiginfo_init(&ksi);
 1882                 ksi.ksi_flags = KSI_SIGQ;
 1883                 ksi.ksi_signo = signum;
 1884                 ksi.ksi_code = SI_QUEUE;
 1885                 ksi.ksi_pid = td->td_proc->p_pid;
 1886                 ksi.ksi_uid = td->td_ucred->cr_ruid;
 1887                 ksi.ksi_value = *value;
 1888                 error = pksignal(p, ksi.ksi_signo, &ksi);
 1889         }
 1890         PROC_UNLOCK(p);
 1891         return (error);
 1892 }
 1893 
 1894 /*
 1895  * Send a signal to a process group.
 1896  */
 1897 void
 1898 gsignal(int pgid, int sig, ksiginfo_t *ksi)
 1899 {
 1900         struct pgrp *pgrp;
 1901 
 1902         if (pgid != 0) {
 1903                 sx_slock(&proctree_lock);
 1904                 pgrp = pgfind(pgid);
 1905                 sx_sunlock(&proctree_lock);
 1906                 if (pgrp != NULL) {
 1907                         pgsignal(pgrp, sig, 0, ksi);
 1908                         PGRP_UNLOCK(pgrp);
 1909                 }
 1910         }
 1911 }
 1912 
 1913 /*
 1914  * Send a signal to a process group.  If checktty is 1,
 1915  * limit to members which have a controlling terminal.
 1916  */
 1917 void
 1918 pgsignal(struct pgrp *pgrp, int sig, int checkctty, ksiginfo_t *ksi)
 1919 {
 1920         struct proc *p;
 1921 
 1922         if (pgrp) {
 1923                 PGRP_LOCK_ASSERT(pgrp, MA_OWNED);
 1924                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
 1925                         PROC_LOCK(p);
 1926                         if (p->p_state == PRS_NORMAL &&
 1927                             (checkctty == 0 || p->p_flag & P_CONTROLT))
 1928                                 pksignal(p, sig, ksi);
 1929                         PROC_UNLOCK(p);
 1930                 }
 1931         }
 1932 }
 1933 
 1934 
 1935 /*
 1936  * Recalculate the signal mask and reset the signal disposition after
 1937  * usermode frame for delivery is formed.  Should be called after
 1938  * mach-specific routine, because sysent->sv_sendsig() needs correct
 1939  * ps_siginfo and signal mask.
 1940  */
 1941 static void
 1942 postsig_done(int sig, struct thread *td, struct sigacts *ps)
 1943 {
 1944         sigset_t mask;
 1945 
 1946         mtx_assert(&ps->ps_mtx, MA_OWNED);
 1947         td->td_ru.ru_nsignals++;
 1948         mask = ps->ps_catchmask[_SIG_IDX(sig)];
 1949         if (!SIGISMEMBER(ps->ps_signodefer, sig))
 1950                 SIGADDSET(mask, sig);
 1951         kern_sigprocmask(td, SIG_BLOCK, &mask, NULL,
 1952             SIGPROCMASK_PROC_LOCKED | SIGPROCMASK_PS_LOCKED);
 1953         if (SIGISMEMBER(ps->ps_sigreset, sig))
 1954                 sigdflt(ps, sig);
 1955 }
 1956 
 1957 
 1958 /*
 1959  * Send a signal caused by a trap to the current thread.  If it will be
 1960  * caught immediately, deliver it with correct code.  Otherwise, post it
 1961  * normally.
 1962  */
 1963 void
 1964 trapsignal(struct thread *td, ksiginfo_t *ksi)
 1965 {
 1966         struct sigacts *ps;
 1967         struct proc *p;
 1968         int sig;
 1969         int code;
 1970 
 1971         p = td->td_proc;
 1972         sig = ksi->ksi_signo;
 1973         code = ksi->ksi_code;
 1974         KASSERT(_SIG_VALID(sig), ("invalid signal"));
 1975 
 1976         PROC_LOCK(p);
 1977         ps = p->p_sigacts;
 1978         mtx_lock(&ps->ps_mtx);
 1979         if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(ps->ps_sigcatch, sig) &&
 1980             !SIGISMEMBER(td->td_sigmask, sig)) {
 1981 #ifdef KTRACE
 1982                 if (KTRPOINT(curthread, KTR_PSIG))
 1983                         ktrpsig(sig, ps->ps_sigact[_SIG_IDX(sig)],
 1984                             &td->td_sigmask, code);
 1985 #endif
 1986                 (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)],
 1987                                 ksi, &td->td_sigmask);
 1988                 postsig_done(sig, td, ps);
 1989                 mtx_unlock(&ps->ps_mtx);
 1990         } else {
 1991                 /*
 1992                  * Avoid a possible infinite loop if the thread
 1993                  * masking the signal or process is ignoring the
 1994                  * signal.
 1995                  */
 1996                 if (kern_forcesigexit &&
 1997                     (SIGISMEMBER(td->td_sigmask, sig) ||
 1998                      ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN)) {
 1999                         SIGDELSET(td->td_sigmask, sig);
 2000                         SIGDELSET(ps->ps_sigcatch, sig);
 2001                         SIGDELSET(ps->ps_sigignore, sig);
 2002                         ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL;
 2003                 }
 2004                 mtx_unlock(&ps->ps_mtx);
 2005                 p->p_code = code;       /* XXX for core dump/debugger */
 2006                 p->p_sig = sig;         /* XXX to verify code */
 2007                 tdsendsignal(p, td, sig, ksi);
 2008         }
 2009         PROC_UNLOCK(p);
 2010 }
 2011 
 2012 static struct thread *
 2013 sigtd(struct proc *p, int sig, int prop)
 2014 {
 2015         struct thread *td, *signal_td;
 2016 
 2017         PROC_LOCK_ASSERT(p, MA_OWNED);
 2018 
 2019         /*
 2020          * Check if current thread can handle the signal without
 2021          * switching context to another thread.
 2022          */
 2023         if (curproc == p && !SIGISMEMBER(curthread->td_sigmask, sig))
 2024                 return (curthread);
 2025         signal_td = NULL;
 2026         FOREACH_THREAD_IN_PROC(p, td) {
 2027                 if (!SIGISMEMBER(td->td_sigmask, sig)) {
 2028                         signal_td = td;
 2029                         break;
 2030                 }
 2031         }
 2032         if (signal_td == NULL)
 2033                 signal_td = FIRST_THREAD_IN_PROC(p);
 2034         return (signal_td);
 2035 }
 2036 
 2037 /*
 2038  * Send the signal to the process.  If the signal has an action, the action
 2039  * is usually performed by the target process rather than the caller; we add
 2040  * the signal to the set of pending signals for the process.
 2041  *
 2042  * Exceptions:
 2043  *   o When a stop signal is sent to a sleeping process that takes the
 2044  *     default action, the process is stopped without awakening it.
 2045  *   o SIGCONT restarts stopped processes (or puts them back to sleep)
 2046  *     regardless of the signal action (eg, blocked or ignored).
 2047  *
 2048  * Other ignored signals are discarded immediately.
 2049  *
 2050  * NB: This function may be entered from the debugger via the "kill" DDB
 2051  * command.  There is little that can be done to mitigate the possibly messy
 2052  * side effects of this unwise possibility.
 2053  */
 2054 void
 2055 kern_psignal(struct proc *p, int sig)
 2056 {
 2057         ksiginfo_t ksi;
 2058 
 2059         ksiginfo_init(&ksi);
 2060         ksi.ksi_signo = sig;
 2061         ksi.ksi_code = SI_KERNEL;
 2062         (void) tdsendsignal(p, NULL, sig, &ksi);
 2063 }
 2064 
 2065 int
 2066 pksignal(struct proc *p, int sig, ksiginfo_t *ksi)
 2067 {
 2068 
 2069         return (tdsendsignal(p, NULL, sig, ksi));
 2070 }
 2071 
 2072 /* Utility function for finding a thread to send signal event to. */
 2073 int
 2074 sigev_findtd(struct proc *p ,struct sigevent *sigev, struct thread **ttd)
 2075 {
 2076         struct thread *td;
 2077 
 2078         if (sigev->sigev_notify == SIGEV_THREAD_ID) {
 2079                 td = tdfind(sigev->sigev_notify_thread_id, p->p_pid);
 2080                 if (td == NULL)
 2081                         return (ESRCH);
 2082                 *ttd = td;
 2083         } else {
 2084                 *ttd = NULL;
 2085                 PROC_LOCK(p);
 2086         }
 2087         return (0);
 2088 }
 2089 
 2090 void
 2091 tdsignal(struct thread *td, int sig)
 2092 {
 2093         ksiginfo_t ksi;
 2094 
 2095         ksiginfo_init(&ksi);
 2096         ksi.ksi_signo = sig;
 2097         ksi.ksi_code = SI_KERNEL;
 2098         (void) tdsendsignal(td->td_proc, td, sig, &ksi);
 2099 }
 2100 
 2101 void
 2102 tdksignal(struct thread *td, int sig, ksiginfo_t *ksi)
 2103 {
 2104 
 2105         (void) tdsendsignal(td->td_proc, td, sig, ksi);
 2106 }
 2107 
 2108 int
 2109 tdsendsignal(struct proc *p, struct thread *td, int sig, ksiginfo_t *ksi)
 2110 {
 2111         sig_t action;
 2112         sigqueue_t *sigqueue;
 2113         int prop;
 2114         struct sigacts *ps;
 2115         int intrval;
 2116         int ret = 0;
 2117         int wakeup_swapper;
 2118 
 2119         MPASS(td == NULL || p == td->td_proc);
 2120         PROC_LOCK_ASSERT(p, MA_OWNED);
 2121 
 2122         if (!_SIG_VALID(sig))
 2123                 panic("%s(): invalid signal %d", __func__, sig);
 2124 
 2125         KASSERT(ksi == NULL || !KSI_ONQ(ksi), ("%s: ksi on queue", __func__));
 2126 
 2127         /*
 2128          * IEEE Std 1003.1-2001: return success when killing a zombie.
 2129          */
 2130         if (p->p_state == PRS_ZOMBIE) {
 2131                 if (ksi && (ksi->ksi_flags & KSI_INS))
 2132                         ksiginfo_tryfree(ksi);
 2133                 return (ret);
 2134         }
 2135 
 2136         ps = p->p_sigacts;
 2137         KNOTE_LOCKED(p->p_klist, NOTE_SIGNAL | sig);
 2138         prop = sigprop(sig);
 2139 
 2140         if (td == NULL) {
 2141                 td = sigtd(p, sig, prop);
 2142                 sigqueue = &p->p_sigqueue;
 2143         } else
 2144                 sigqueue = &td->td_sigqueue;
 2145 
 2146         SDT_PROBE3(proc, , , signal__send, td, p, sig);
 2147 
 2148         /*
 2149          * If the signal is being ignored,
 2150          * then we forget about it immediately.
 2151          * (Note: we don't set SIGCONT in ps_sigignore,
 2152          * and if it is set to SIG_IGN,
 2153          * action will be SIG_DFL here.)
 2154          */
 2155         mtx_lock(&ps->ps_mtx);
 2156         if (SIGISMEMBER(ps->ps_sigignore, sig)) {
 2157                 SDT_PROBE3(proc, , , signal__discard, td, p, sig);
 2158 
 2159                 mtx_unlock(&ps->ps_mtx);
 2160                 if (ksi && (ksi->ksi_flags & KSI_INS))
 2161                         ksiginfo_tryfree(ksi);
 2162                 return (ret);
 2163         }
 2164         if (SIGISMEMBER(td->td_sigmask, sig))
 2165                 action = SIG_HOLD;
 2166         else if (SIGISMEMBER(ps->ps_sigcatch, sig))
 2167                 action = SIG_CATCH;
 2168         else
 2169                 action = SIG_DFL;
 2170         if (SIGISMEMBER(ps->ps_sigintr, sig))
 2171                 intrval = EINTR;
 2172         else
 2173                 intrval = ERESTART;
 2174         mtx_unlock(&ps->ps_mtx);
 2175 
 2176         if (prop & SA_CONT)
 2177                 sigqueue_delete_stopmask_proc(p);
 2178         else if (prop & SA_STOP) {
 2179                 /*
 2180                  * If sending a tty stop signal to a member of an orphaned
 2181                  * process group, discard the signal here if the action
 2182                  * is default; don't stop the process below if sleeping,
 2183                  * and don't clear any pending SIGCONT.
 2184                  */
 2185                 if ((prop & SA_TTYSTOP) &&
 2186                     (p->p_pgrp->pg_jobc == 0) &&
 2187                     (action == SIG_DFL)) {
 2188                         if (ksi && (ksi->ksi_flags & KSI_INS))
 2189                                 ksiginfo_tryfree(ksi);
 2190                         return (ret);
 2191                 }
 2192                 sigqueue_delete_proc(p, SIGCONT);
 2193                 if (p->p_flag & P_CONTINUED) {
 2194                         p->p_flag &= ~P_CONTINUED;
 2195                         PROC_LOCK(p->p_pptr);
 2196                         sigqueue_take(p->p_ksi);
 2197                         PROC_UNLOCK(p->p_pptr);
 2198                 }
 2199         }
 2200 
 2201         ret = sigqueue_add(sigqueue, sig, ksi);
 2202         if (ret != 0)
 2203                 return (ret);
 2204         signotify(td);
 2205         /*
 2206          * Defer further processing for signals which are held,
 2207          * except that stopped processes must be continued by SIGCONT.
 2208          */
 2209         if (action == SIG_HOLD &&
 2210             !((prop & SA_CONT) && (p->p_flag & P_STOPPED_SIG)))
 2211                 return (ret);
 2212 
 2213         /* SIGKILL: Remove procfs STOPEVENTs. */
 2214         if (sig == SIGKILL) {
 2215                 /* from procfs_ioctl.c: PIOCBIC */
 2216                 p->p_stops = 0;
 2217                 /* from procfs_ioctl.c: PIOCCONT */
 2218                 p->p_step = 0;
 2219                 wakeup(&p->p_step);
 2220         }
 2221         /*
 2222          * Some signals have a process-wide effect and a per-thread
 2223          * component.  Most processing occurs when the process next
 2224          * tries to cross the user boundary, however there are some
 2225          * times when processing needs to be done immediately, such as
 2226          * waking up threads so that they can cross the user boundary.
 2227          * We try to do the per-process part here.
 2228          */
 2229         if (P_SHOULDSTOP(p)) {
 2230                 KASSERT(!(p->p_flag & P_WEXIT),
 2231                     ("signal to stopped but exiting process"));
 2232                 if (sig == SIGKILL) {
 2233                         /*
 2234                          * If traced process is already stopped,
 2235                          * then no further action is necessary.
 2236                          */
 2237                         if (p->p_flag & P_TRACED)
 2238                                 goto out;
 2239                         /*
 2240                          * SIGKILL sets process running.
 2241                          * It will die elsewhere.
 2242                          * All threads must be restarted.
 2243                          */
 2244                         p->p_flag &= ~P_STOPPED_SIG;
 2245                         goto runfast;
 2246                 }
 2247 
 2248                 if (prop & SA_CONT) {
 2249                         /*
 2250                          * If traced process is already stopped,
 2251                          * then no further action is necessary.
 2252                          */
 2253                         if (p->p_flag & P_TRACED)
 2254                                 goto out;
 2255                         /*
 2256                          * If SIGCONT is default (or ignored), we continue the
 2257                          * process but don't leave the signal in sigqueue as
 2258                          * it has no further action.  If SIGCONT is held, we
 2259                          * continue the process and leave the signal in
 2260                          * sigqueue.  If the process catches SIGCONT, let it
 2261                          * handle the signal itself.  If it isn't waiting on
 2262                          * an event, it goes back to run state.
 2263                          * Otherwise, process goes back to sleep state.
 2264                          */
 2265                         p->p_flag &= ~P_STOPPED_SIG;
 2266                         PROC_SLOCK(p);
 2267                         if (p->p_numthreads == p->p_suspcount) {
 2268                                 PROC_SUNLOCK(p);
 2269                                 p->p_flag |= P_CONTINUED;
 2270                                 p->p_xsig = SIGCONT;
 2271                                 PROC_LOCK(p->p_pptr);
 2272                                 childproc_continued(p);
 2273                                 PROC_UNLOCK(p->p_pptr);
 2274                                 PROC_SLOCK(p);
 2275                         }
 2276                         if (action == SIG_DFL) {
 2277                                 thread_unsuspend(p);
 2278                                 PROC_SUNLOCK(p);
 2279                                 sigqueue_delete(sigqueue, sig);
 2280                                 goto out;
 2281                         }
 2282                         if (action == SIG_CATCH) {
 2283                                 /*
 2284                                  * The process wants to catch it so it needs
 2285                                  * to run at least one thread, but which one?
 2286                                  */
 2287                                 PROC_SUNLOCK(p);
 2288                                 goto runfast;
 2289                         }
 2290                         /*
 2291                          * The signal is not ignored or caught.
 2292                          */
 2293                         thread_unsuspend(p);
 2294                         PROC_SUNLOCK(p);
 2295                         goto out;
 2296                 }
 2297 
 2298                 if (prop & SA_STOP) {
 2299                         /*
 2300                          * If traced process is already stopped,
 2301                          * then no further action is necessary.
 2302                          */
 2303                         if (p->p_flag & P_TRACED)
 2304                                 goto out;
 2305                         /*
 2306                          * Already stopped, don't need to stop again
 2307                          * (If we did the shell could get confused).
 2308                          * Just make sure the signal STOP bit set.
 2309                          */
 2310                         p->p_flag |= P_STOPPED_SIG;
 2311                         sigqueue_delete(sigqueue, sig);
 2312                         goto out;
 2313                 }
 2314 
 2315                 /*
 2316                  * All other kinds of signals:
 2317                  * If a thread is sleeping interruptibly, simulate a
 2318                  * wakeup so that when it is continued it will be made
 2319                  * runnable and can look at the signal.  However, don't make
 2320                  * the PROCESS runnable, leave it stopped.
 2321                  * It may run a bit until it hits a thread_suspend_check().
 2322                  */
 2323                 wakeup_swapper = 0;
 2324                 PROC_SLOCK(p);
 2325                 thread_lock(td);
 2326                 if (TD_ON_SLEEPQ(td) && (td->td_flags & TDF_SINTR))
 2327                         wakeup_swapper = sleepq_abort(td, intrval);
 2328                 thread_unlock(td);
 2329                 PROC_SUNLOCK(p);
 2330                 if (wakeup_swapper)
 2331                         kick_proc0();
 2332                 goto out;
 2333                 /*
 2334                  * Mutexes are short lived. Threads waiting on them will
 2335                  * hit thread_suspend_check() soon.
 2336                  */
 2337         } else if (p->p_state == PRS_NORMAL) {
 2338                 if (p->p_flag & P_TRACED || action == SIG_CATCH) {
 2339                         tdsigwakeup(td, sig, action, intrval);
 2340                         goto out;
 2341                 }
 2342 
 2343                 MPASS(action == SIG_DFL);
 2344 
 2345                 if (prop & SA_STOP) {
 2346                         if (p->p_flag & (P_PPWAIT|P_WEXIT))
 2347                                 goto out;
 2348                         p->p_flag |= P_STOPPED_SIG;
 2349                         p->p_xsig = sig;
 2350                         PROC_SLOCK(p);
 2351                         wakeup_swapper = sig_suspend_threads(td, p, 1);
 2352                         if (p->p_numthreads == p->p_suspcount) {
 2353                                 /*
 2354                                  * only thread sending signal to another
 2355                                  * process can reach here, if thread is sending
 2356                                  * signal to its process, because thread does
 2357                                  * not suspend itself here, p_numthreads
 2358                                  * should never be equal to p_suspcount.
 2359                                  */
 2360                                 thread_stopped(p);
 2361                                 PROC_SUNLOCK(p);
 2362                                 sigqueue_delete_proc(p, p->p_xsig);
 2363                         } else
 2364                                 PROC_SUNLOCK(p);
 2365                         if (wakeup_swapper)
 2366                                 kick_proc0();
 2367                         goto out;
 2368                 }
 2369         } else {
 2370                 /* Not in "NORMAL" state. discard the signal. */
 2371                 sigqueue_delete(sigqueue, sig);
 2372                 goto out;
 2373         }
 2374 
 2375         /*
 2376          * The process is not stopped so we need to apply the signal to all the
 2377          * running threads.
 2378          */
 2379 runfast:
 2380         tdsigwakeup(td, sig, action, intrval);
 2381         PROC_SLOCK(p);
 2382         thread_unsuspend(p);
 2383         PROC_SUNLOCK(p);
 2384 out:
 2385         /* If we jump here, proc slock should not be owned. */
 2386         PROC_SLOCK_ASSERT(p, MA_NOTOWNED);
 2387         return (ret);
 2388 }
 2389 
 2390 /*
 2391  * The force of a signal has been directed against a single
 2392  * thread.  We need to see what we can do about knocking it
 2393  * out of any sleep it may be in etc.
 2394  */
 2395 static void
 2396 tdsigwakeup(struct thread *td, int sig, sig_t action, int intrval)
 2397 {
 2398         struct proc *p = td->td_proc;
 2399         int prop;
 2400         int wakeup_swapper;
 2401 
 2402         wakeup_swapper = 0;
 2403         PROC_LOCK_ASSERT(p, MA_OWNED);
 2404         prop = sigprop(sig);
 2405 
 2406         PROC_SLOCK(p);
 2407         thread_lock(td);
 2408         /*
 2409          * Bring the priority of a thread up if we want it to get
 2410          * killed in this lifetime.  Be careful to avoid bumping the
 2411          * priority of the idle thread, since we still allow to signal
 2412          * kernel processes.
 2413          */
 2414         if (action == SIG_DFL && (prop & SA_KILL) != 0 &&
 2415             td->td_priority > PUSER && !TD_IS_IDLETHREAD(td))
 2416                 sched_prio(td, PUSER);
 2417         if (TD_ON_SLEEPQ(td)) {
 2418                 /*
 2419                  * If thread is sleeping uninterruptibly
 2420                  * we can't interrupt the sleep... the signal will
 2421                  * be noticed when the process returns through
 2422                  * trap() or syscall().
 2423                  */
 2424                 if ((td->td_flags & TDF_SINTR) == 0)
 2425                         goto out;
 2426                 /*
 2427                  * If SIGCONT is default (or ignored) and process is
 2428                  * asleep, we are finished; the process should not
 2429                  * be awakened.
 2430                  */
 2431                 if ((prop & SA_CONT) && action == SIG_DFL) {
 2432                         thread_unlock(td);
 2433                         PROC_SUNLOCK(p);
 2434                         sigqueue_delete(&p->p_sigqueue, sig);
 2435                         /*
 2436                          * It may be on either list in this state.
 2437                          * Remove from both for now.
 2438                          */
 2439                         sigqueue_delete(&td->td_sigqueue, sig);
 2440                         return;
 2441                 }
 2442 
 2443                 /*
 2444                  * Don't awaken a sleeping thread for SIGSTOP if the
 2445                  * STOP signal is deferred.
 2446                  */
 2447                 if ((prop & SA_STOP) != 0 && (td->td_flags & (TDF_SBDRY |
 2448                     TDF_SERESTART | TDF_SEINTR)) == TDF_SBDRY)
 2449                         goto out;
 2450 
 2451                 /*
 2452                  * Give low priority threads a better chance to run.
 2453                  */
 2454                 if (td->td_priority > PUSER && !TD_IS_IDLETHREAD(td))
 2455                         sched_prio(td, PUSER);
 2456 
 2457                 wakeup_swapper = sleepq_abort(td, intrval);
 2458         } else {
 2459                 /*
 2460                  * Other states do nothing with the signal immediately,
 2461                  * other than kicking ourselves if we are running.
 2462                  * It will either never be noticed, or noticed very soon.
 2463                  */
 2464 #ifdef SMP
 2465                 if (TD_IS_RUNNING(td) && td != curthread)
 2466                         forward_signal(td);
 2467 #endif
 2468         }
 2469 out:
 2470         PROC_SUNLOCK(p);
 2471         thread_unlock(td);
 2472         if (wakeup_swapper)
 2473                 kick_proc0();
 2474 }
 2475 
 2476 static int
 2477 sig_suspend_threads(struct thread *td, struct proc *p, int sending)
 2478 {
 2479         struct thread *td2;
 2480         int wakeup_swapper;
 2481 
 2482         PROC_LOCK_ASSERT(p, MA_OWNED);
 2483         PROC_SLOCK_ASSERT(p, MA_OWNED);
 2484         MPASS(sending || td == curthread);
 2485 
 2486         wakeup_swapper = 0;
 2487         FOREACH_THREAD_IN_PROC(p, td2) {
 2488                 thread_lock(td2);
 2489                 td2->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK;
 2490                 if ((TD_IS_SLEEPING(td2) || TD_IS_SWAPPED(td2)) &&
 2491                     (td2->td_flags & TDF_SINTR)) {
 2492                         if (td2->td_flags & TDF_SBDRY) {
 2493                                 /*
 2494                                  * Once a thread is asleep with
 2495                                  * TDF_SBDRY and without TDF_SERESTART
 2496                                  * or TDF_SEINTR set, it should never
 2497                                  * become suspended due to this check.
 2498                                  */
 2499                                 KASSERT(!TD_IS_SUSPENDED(td2),
 2500                                     ("thread with deferred stops suspended"));
 2501                                 if (TD_SBDRY_INTR(td2))
 2502                                         wakeup_swapper |= sleepq_abort(td2,
 2503                                             TD_SBDRY_ERRNO(td2));
 2504                         } else if (!TD_IS_SUSPENDED(td2)) {
 2505                                 thread_suspend_one(td2);
 2506                         }
 2507                 } else if (!TD_IS_SUSPENDED(td2)) {
 2508                         if (sending || td != td2)
 2509                                 td2->td_flags |= TDF_ASTPENDING;
 2510 #ifdef SMP
 2511                         if (TD_IS_RUNNING(td2) && td2 != td)
 2512                                 forward_signal(td2);
 2513 #endif
 2514                 }
 2515                 thread_unlock(td2);
 2516         }
 2517         return (wakeup_swapper);
 2518 }
 2519 
 2520 /*
 2521  * Stop the process for an event deemed interesting to the debugger. If si is
 2522  * non-NULL, this is a signal exchange; the new signal requested by the
 2523  * debugger will be returned for handling. If si is NULL, this is some other
 2524  * type of interesting event. The debugger may request a signal be delivered in
 2525  * that case as well, however it will be deferred until it can be handled.
 2526  */
 2527 int
 2528 ptracestop(struct thread *td, int sig, ksiginfo_t *si)
 2529 {
 2530         struct proc *p = td->td_proc;
 2531         struct thread *td2;
 2532         ksiginfo_t ksi;
 2533         int prop;
 2534 
 2535         PROC_LOCK_ASSERT(p, MA_OWNED);
 2536         KASSERT(!(p->p_flag & P_WEXIT), ("Stopping exiting process"));
 2537         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
 2538             &p->p_mtx.lock_object, "Stopping for traced signal");
 2539 
 2540         td->td_xsig = sig;
 2541 
 2542         if (si == NULL || (si->ksi_flags & KSI_PTRACE) == 0) {
 2543                 td->td_dbgflags |= TDB_XSIG;
 2544                 CTR4(KTR_PTRACE, "ptracestop: tid %d (pid %d) flags %#x sig %d",
 2545                     td->td_tid, p->p_pid, td->td_dbgflags, sig);
 2546                 PROC_SLOCK(p);
 2547                 while ((p->p_flag & P_TRACED) && (td->td_dbgflags & TDB_XSIG)) {
 2548                         if (P_KILLED(p)) {
 2549                                 /*
 2550                                  * Ensure that, if we've been PT_KILLed, the
 2551                                  * exit status reflects that. Another thread
 2552                                  * may also be in ptracestop(), having just
 2553                                  * received the SIGKILL, but this thread was
 2554                                  * unsuspended first.
 2555                                  */
 2556                                 td->td_dbgflags &= ~TDB_XSIG;
 2557                                 td->td_xsig = SIGKILL;
 2558                                 p->p_ptevents = 0;
 2559                                 break;
 2560                         }
 2561                         if (p->p_flag & P_SINGLE_EXIT &&
 2562                             !(td->td_dbgflags & TDB_EXIT)) {
 2563                                 /*
 2564                                  * Ignore ptrace stops except for thread exit
 2565                                  * events when the process exits.
 2566                                  */
 2567                                 td->td_dbgflags &= ~TDB_XSIG;
 2568                                 PROC_SUNLOCK(p);
 2569                                 return (0);
 2570                         }
 2571 
 2572                         /*
 2573                          * Make wait(2) work.  Ensure that right after the
 2574                          * attach, the thread which was decided to become the
 2575                          * leader of attach gets reported to the waiter.
 2576                          * Otherwise, just avoid overwriting another thread's
 2577                          * assignment to p_xthread.  If another thread has
 2578                          * already set p_xthread, the current thread will get
 2579                          * a chance to report itself upon the next iteration.
 2580                          */
 2581                         if ((td->td_dbgflags & TDB_FSTP) != 0 ||
 2582                             ((p->p_flag2 & P2_PTRACE_FSTP) == 0 &&
 2583                             p->p_xthread == NULL)) {
 2584                                 p->p_xsig = sig;
 2585                                 p->p_xthread = td;
 2586                                 td->td_dbgflags &= ~TDB_FSTP;
 2587                                 p->p_flag2 &= ~P2_PTRACE_FSTP;
 2588                                 p->p_flag |= P_STOPPED_SIG | P_STOPPED_TRACE;
 2589                                 sig_suspend_threads(td, p, 0);
 2590                         }
 2591                         if ((td->td_dbgflags & TDB_STOPATFORK) != 0) {
 2592                                 td->td_dbgflags &= ~TDB_STOPATFORK;
 2593                                 cv_broadcast(&p->p_dbgwait);
 2594                         }
 2595 stopme:
 2596                         thread_suspend_switch(td, p);
 2597                         if (p->p_xthread == td)
 2598                                 p->p_xthread = NULL;
 2599                         if (!(p->p_flag & P_TRACED))
 2600                                 break;
 2601                         if (td->td_dbgflags & TDB_SUSPEND) {
 2602                                 if (p->p_flag & P_SINGLE_EXIT)
 2603                                         break;
 2604                                 goto stopme;
 2605                         }
 2606                 }
 2607                 PROC_SUNLOCK(p);
 2608         }
 2609 
 2610         if (si != NULL && sig == td->td_xsig) {
 2611                 /* Parent wants us to take the original signal unchanged. */
 2612                 si->ksi_flags |= KSI_HEAD;
 2613                 if (sigqueue_add(&td->td_sigqueue, sig, si) != 0)
 2614                         si->ksi_signo = 0;
 2615         } else if (td->td_xsig != 0) {
 2616                 /*
 2617                  * If parent wants us to take a new signal, then it will leave
 2618                  * it in td->td_xsig; otherwise we just look for signals again.
 2619                  */
 2620                 ksiginfo_init(&ksi);
 2621                 ksi.ksi_signo = td->td_xsig;
 2622                 ksi.ksi_flags |= KSI_PTRACE;
 2623                 prop = sigprop(td->td_xsig);
 2624                 td2 = sigtd(p, td->td_xsig, prop);
 2625                 tdsendsignal(p, td2, td->td_xsig, &ksi);
 2626                 if (td != td2)
 2627                         return (0);
 2628         }
 2629 
 2630         return (td->td_xsig);
 2631 }
 2632 
 2633 static void
 2634 reschedule_signals(struct proc *p, sigset_t block, int flags)
 2635 {
 2636         struct sigacts *ps;
 2637         struct thread *td;
 2638         int sig;
 2639 
 2640         PROC_LOCK_ASSERT(p, MA_OWNED);
 2641         ps = p->p_sigacts;
 2642         mtx_assert(&ps->ps_mtx, (flags & SIGPROCMASK_PS_LOCKED) != 0 ?
 2643             MA_OWNED : MA_NOTOWNED);
 2644         if (SIGISEMPTY(p->p_siglist))
 2645                 return;
 2646         SIGSETAND(block, p->p_siglist);
 2647         while ((sig = sig_ffs(&block)) != 0) {
 2648                 SIGDELSET(block, sig);
 2649                 td = sigtd(p, sig, 0);
 2650                 signotify(td);
 2651                 if (!(flags & SIGPROCMASK_PS_LOCKED))
 2652                         mtx_lock(&ps->ps_mtx);
 2653                 if (p->p_flag & P_TRACED ||
 2654                     (SIGISMEMBER(ps->ps_sigcatch, sig) &&
 2655                     !SIGISMEMBER(td->td_sigmask, sig)))
 2656                         tdsigwakeup(td, sig, SIG_CATCH,
 2657                             (SIGISMEMBER(ps->ps_sigintr, sig) ? EINTR :
 2658                              ERESTART));
 2659                 if (!(flags & SIGPROCMASK_PS_LOCKED))
 2660                         mtx_unlock(&ps->ps_mtx);
 2661         }
 2662 }
 2663 
 2664 void
 2665 tdsigcleanup(struct thread *td)
 2666 {
 2667         struct proc *p;
 2668         sigset_t unblocked;
 2669 
 2670         p = td->td_proc;
 2671         PROC_LOCK_ASSERT(p, MA_OWNED);
 2672 
 2673         sigqueue_flush(&td->td_sigqueue);
 2674         if (p->p_numthreads == 1)
 2675                 return;
 2676 
 2677         /*
 2678          * Since we cannot handle signals, notify signal post code
 2679          * about this by filling the sigmask.
 2680          *
 2681          * Also, if needed, wake up thread(s) that do not block the
 2682          * same signals as the exiting thread, since the thread might
 2683          * have been selected for delivery and woken up.
 2684          */
 2685         SIGFILLSET(unblocked);
 2686         SIGSETNAND(unblocked, td->td_sigmask);
 2687         SIGFILLSET(td->td_sigmask);
 2688         reschedule_signals(p, unblocked, 0);
 2689 
 2690 }
 2691 
 2692 static int
 2693 sigdeferstop_curr_flags(int cflags)
 2694 {
 2695 
 2696         MPASS((cflags & (TDF_SEINTR | TDF_SERESTART)) == 0 ||
 2697             (cflags & TDF_SBDRY) != 0);
 2698         return (cflags & (TDF_SBDRY | TDF_SEINTR | TDF_SERESTART));
 2699 }
 2700 
 2701 /*
 2702  * Defer the delivery of SIGSTOP for the current thread, according to
 2703  * the requested mode.  Returns previous flags, which must be restored
 2704  * by sigallowstop().
 2705  *
 2706  * TDF_SBDRY, TDF_SEINTR, and TDF_SERESTART flags are only set and
 2707  * cleared by the current thread, which allow the lock-less read-only
 2708  * accesses below.
 2709  */
 2710 int
 2711 sigdeferstop_impl(int mode)
 2712 {
 2713         struct thread *td;
 2714         int cflags, nflags;
 2715 
 2716         td = curthread;
 2717         cflags = sigdeferstop_curr_flags(td->td_flags);
 2718         switch (mode) {
 2719         case SIGDEFERSTOP_NOP:
 2720                 nflags = cflags;
 2721                 break;
 2722         case SIGDEFERSTOP_OFF:
 2723                 nflags = 0;
 2724                 break;
 2725         case SIGDEFERSTOP_SILENT:
 2726                 nflags = (cflags | TDF_SBDRY) & ~(TDF_SEINTR | TDF_SERESTART);
 2727                 break;
 2728         case SIGDEFERSTOP_EINTR:
 2729                 nflags = (cflags | TDF_SBDRY | TDF_SEINTR) & ~TDF_SERESTART;
 2730                 break;
 2731         case SIGDEFERSTOP_ERESTART:
 2732                 nflags = (cflags | TDF_SBDRY | TDF_SERESTART) & ~TDF_SEINTR;
 2733                 break;
 2734         default:
 2735                 panic("sigdeferstop: invalid mode %x", mode);
 2736                 break;
 2737         }
 2738         if (cflags == nflags)
 2739                 return (SIGDEFERSTOP_VAL_NCHG);
 2740         thread_lock(td);
 2741         td->td_flags = (td->td_flags & ~cflags) | nflags;
 2742         thread_unlock(td);
 2743         return (cflags);
 2744 }
 2745 
 2746 /*
 2747  * Restores the STOP handling mode, typically permitting the delivery
 2748  * of SIGSTOP for the current thread.  This does not immediately
 2749  * suspend if a stop was posted.  Instead, the thread will suspend
 2750  * either via ast() or a subsequent interruptible sleep.
 2751  */
 2752 void
 2753 sigallowstop_impl(int prev)
 2754 {
 2755         struct thread *td;
 2756         int cflags;
 2757 
 2758         KASSERT(prev != SIGDEFERSTOP_VAL_NCHG, ("failed sigallowstop"));
 2759         KASSERT((prev & ~(TDF_SBDRY | TDF_SEINTR | TDF_SERESTART)) == 0,
 2760             ("sigallowstop: incorrect previous mode %x", prev));
 2761         td = curthread;
 2762         cflags = sigdeferstop_curr_flags(td->td_flags);
 2763         if (cflags != prev) {
 2764                 thread_lock(td);
 2765                 td->td_flags = (td->td_flags & ~cflags) | prev;
 2766                 thread_unlock(td);
 2767         }
 2768 }
 2769 
 2770 /*
 2771  * If the current process has received a signal (should be caught or cause
 2772  * termination, should interrupt current syscall), return the signal number.
 2773  * Stop signals with default action are processed immediately, then cleared;
 2774  * they aren't returned.  This is checked after each entry to the system for
 2775  * a syscall or trap (though this can usually be done without calling issignal
 2776  * by checking the pending signal masks in cursig.) The normal call
 2777  * sequence is
 2778  *
 2779  *      while (sig = cursig(curthread))
 2780  *              postsig(sig);
 2781  */
 2782 static int
 2783 issignal(struct thread *td)
 2784 {
 2785         struct proc *p;
 2786         struct sigacts *ps;
 2787         struct sigqueue *queue;
 2788         sigset_t sigpending;
 2789         int prop, sig, traced;
 2790         ksiginfo_t ksi;
 2791 
 2792         p = td->td_proc;
 2793         ps = p->p_sigacts;
 2794         mtx_assert(&ps->ps_mtx, MA_OWNED);
 2795         PROC_LOCK_ASSERT(p, MA_OWNED);
 2796         for (;;) {
 2797                 traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG);
 2798 
 2799                 sigpending = td->td_sigqueue.sq_signals;
 2800                 SIGSETOR(sigpending, p->p_sigqueue.sq_signals);
 2801                 SIGSETNAND(sigpending, td->td_sigmask);
 2802 
 2803                 if ((p->p_flag & P_PPWAIT) != 0 || (td->td_flags &
 2804                     (TDF_SBDRY | TDF_SERESTART | TDF_SEINTR)) == TDF_SBDRY)
 2805                         SIG_STOPSIGMASK(sigpending);
 2806                 if (SIGISEMPTY(sigpending))     /* no signal to send */
 2807                         return (0);
 2808                 if ((p->p_flag & (P_TRACED | P_PPTRACE)) == P_TRACED &&
 2809                     (p->p_flag2 & P2_PTRACE_FSTP) != 0 &&
 2810                     SIGISMEMBER(sigpending, SIGSTOP)) {
 2811                         /*
 2812                          * If debugger just attached, always consume
 2813                          * SIGSTOP from ptrace(PT_ATTACH) first, to
 2814                          * execute the debugger attach ritual in
 2815                          * order.
 2816                          */
 2817                         sig = SIGSTOP;
 2818                         td->td_dbgflags |= TDB_FSTP;
 2819                 } else {
 2820                         sig = sig_ffs(&sigpending);
 2821                 }
 2822 
 2823                 if (p->p_stops & S_SIG) {
 2824                         mtx_unlock(&ps->ps_mtx);
 2825                         stopevent(p, S_SIG, sig);
 2826                         mtx_lock(&ps->ps_mtx);
 2827                 }
 2828 
 2829                 /*
 2830                  * We should see pending but ignored signals
 2831                  * only if P_TRACED was on when they were posted.
 2832                  */
 2833                 if (SIGISMEMBER(ps->ps_sigignore, sig) && (traced == 0)) {
 2834                         sigqueue_delete(&td->td_sigqueue, sig);
 2835                         sigqueue_delete(&p->p_sigqueue, sig);
 2836                         continue;
 2837                 }
 2838                 if ((p->p_flag & (P_TRACED | P_PPTRACE)) == P_TRACED) {
 2839                         /*
 2840                          * If traced, always stop.
 2841                          * Remove old signal from queue before the stop.
 2842                          * XXX shrug off debugger, it causes siginfo to
 2843                          * be thrown away.
 2844                          */
 2845                         queue = &td->td_sigqueue;
 2846                         ksiginfo_init(&ksi);
 2847                         if (sigqueue_get(queue, sig, &ksi) == 0) {
 2848                                 queue = &p->p_sigqueue;
 2849                                 sigqueue_get(queue, sig, &ksi);
 2850                         }
 2851                         td->td_si = ksi.ksi_info;
 2852 
 2853                         mtx_unlock(&ps->ps_mtx);
 2854                         sig = ptracestop(td, sig, &ksi);
 2855                         mtx_lock(&ps->ps_mtx);
 2856 
 2857                         /* 
 2858                          * Keep looking if the debugger discarded or
 2859                          * replaced the signal.
 2860                          */
 2861                         if (sig == 0)
 2862                                 continue;
 2863 
 2864                         /*
 2865                          * If the signal became masked, re-queue it.
 2866                          */
 2867                         if (SIGISMEMBER(td->td_sigmask, sig)) {
 2868                                 ksi.ksi_flags |= KSI_HEAD;
 2869                                 sigqueue_add(&p->p_sigqueue, sig, &ksi);
 2870                                 continue;
 2871                         }
 2872 
 2873                         /*
 2874                          * If the traced bit got turned off, requeue
 2875                          * the signal and go back up to the top to
 2876                          * rescan signals.  This ensures that p_sig*
 2877                          * and p_sigact are consistent.
 2878                          */
 2879                         if ((p->p_flag & P_TRACED) == 0) {
 2880                                 ksi.ksi_flags |= KSI_HEAD;
 2881                                 sigqueue_add(queue, sig, &ksi);
 2882                                 continue;
 2883                         }
 2884                 }
 2885 
 2886                 prop = sigprop(sig);
 2887 
 2888                 /*
 2889                  * Decide whether the signal should be returned.
 2890                  * Return the signal's number, or fall through
 2891                  * to clear it from the pending mask.
 2892                  */
 2893                 switch ((intptr_t)p->p_sigacts->ps_sigact[_SIG_IDX(sig)]) {
 2894 
 2895                 case (intptr_t)SIG_DFL:
 2896                         /*
 2897                          * Don't take default actions on system processes.
 2898                          */
 2899                         if (p->p_pid <= 1) {
 2900 #ifdef DIAGNOSTIC
 2901                                 /*
 2902                                  * Are you sure you want to ignore SIGSEGV
 2903                                  * in init? XXX
 2904                                  */
 2905                                 printf("Process (pid %lu) got signal %d\n",
 2906                                         (u_long)p->p_pid, sig);
 2907 #endif
 2908                                 break;          /* == ignore */
 2909                         }
 2910                         /*
 2911                          * If there is a pending stop signal to process with
 2912                          * default action, stop here, then clear the signal.
 2913                          * Traced or exiting processes should ignore stops.
 2914                          * Additionally, a member of an orphaned process group
 2915                          * should ignore tty stops.
 2916                          */
 2917                         if (prop & SA_STOP) {
 2918                                 if (p->p_flag &
 2919                                     (P_TRACED | P_WEXIT | P_SINGLE_EXIT) ||
 2920                                     (p->p_pgrp->pg_jobc == 0 &&
 2921                                      prop & SA_TTYSTOP))
 2922                                         break;  /* == ignore */
 2923                                 if (TD_SBDRY_INTR(td)) {
 2924                                         KASSERT((td->td_flags & TDF_SBDRY) != 0,
 2925                                             ("lost TDF_SBDRY"));
 2926                                         return (-1);
 2927                                 }
 2928                                 mtx_unlock(&ps->ps_mtx);
 2929                                 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
 2930                                     &p->p_mtx.lock_object, "Catching SIGSTOP");
 2931                                 sigqueue_delete(&td->td_sigqueue, sig);
 2932                                 sigqueue_delete(&p->p_sigqueue, sig);
 2933                                 p->p_flag |= P_STOPPED_SIG;
 2934                                 p->p_xsig = sig;
 2935                                 PROC_SLOCK(p);
 2936                                 sig_suspend_threads(td, p, 0);
 2937                                 thread_suspend_switch(td, p);
 2938                                 PROC_SUNLOCK(p);
 2939                                 mtx_lock(&ps->ps_mtx);
 2940                                 goto next;
 2941                         } else if (prop & SA_IGNORE) {
 2942                                 /*
 2943                                  * Except for SIGCONT, shouldn't get here.
 2944                                  * Default action is to ignore; drop it.
 2945                                  */
 2946                                 break;          /* == ignore */
 2947                         } else
 2948                                 return (sig);
 2949                         /*NOTREACHED*/
 2950 
 2951                 case (intptr_t)SIG_IGN:
 2952                         /*
 2953                          * Masking above should prevent us ever trying
 2954                          * to take action on an ignored signal other
 2955                          * than SIGCONT, unless process is traced.
 2956                          */
 2957                         if ((prop & SA_CONT) == 0 &&
 2958                             (p->p_flag & P_TRACED) == 0)
 2959                                 printf("issignal\n");
 2960                         break;          /* == ignore */
 2961 
 2962                 default:
 2963                         /*
 2964                          * This signal has an action, let
 2965                          * postsig() process it.
 2966                          */
 2967                         return (sig);
 2968                 }
 2969                 sigqueue_delete(&td->td_sigqueue, sig); /* take the signal! */
 2970                 sigqueue_delete(&p->p_sigqueue, sig);
 2971 next:;
 2972         }
 2973         /* NOTREACHED */
 2974 }
 2975 
 2976 void
 2977 thread_stopped(struct proc *p)
 2978 {
 2979         int n;
 2980 
 2981         PROC_LOCK_ASSERT(p, MA_OWNED);
 2982         PROC_SLOCK_ASSERT(p, MA_OWNED);
 2983         n = p->p_suspcount;
 2984         if (p == curproc)
 2985                 n++;
 2986         if ((p->p_flag & P_STOPPED_SIG) && (n == p->p_numthreads)) {
 2987                 PROC_SUNLOCK(p);
 2988                 p->p_flag &= ~P_WAITED;
 2989                 PROC_LOCK(p->p_pptr);
 2990                 childproc_stopped(p, (p->p_flag & P_TRACED) ?
 2991                         CLD_TRAPPED : CLD_STOPPED);
 2992                 PROC_UNLOCK(p->p_pptr);
 2993                 PROC_SLOCK(p);
 2994         }
 2995 }
 2996 
 2997 /*
 2998  * Take the action for the specified signal
 2999  * from the current set of pending signals.
 3000  */
 3001 int
 3002 postsig(int sig)
 3003 {
 3004         struct thread *td;
 3005         struct proc *p;
 3006         struct sigacts *ps;
 3007         sig_t action;
 3008         ksiginfo_t ksi;
 3009         sigset_t returnmask;
 3010 
 3011         KASSERT(sig != 0, ("postsig"));
 3012 
 3013         td = curthread;
 3014         p = td->td_proc;
 3015         PROC_LOCK_ASSERT(p, MA_OWNED);
 3016         ps = p->p_sigacts;
 3017         mtx_assert(&ps->ps_mtx, MA_OWNED);
 3018         ksiginfo_init(&ksi);
 3019         if (sigqueue_get(&td->td_sigqueue, sig, &ksi) == 0 &&
 3020             sigqueue_get(&p->p_sigqueue, sig, &ksi) == 0)
 3021                 return (0);
 3022         ksi.ksi_signo = sig;
 3023         if (ksi.ksi_code == SI_TIMER)
 3024                 itimer_accept(p, ksi.ksi_timerid, &ksi);
 3025         action = ps->ps_sigact[_SIG_IDX(sig)];
 3026 #ifdef KTRACE
 3027         if (KTRPOINT(td, KTR_PSIG))
 3028                 ktrpsig(sig, action, td->td_pflags & TDP_OLDMASK ?
 3029                     &td->td_oldsigmask : &td->td_sigmask, ksi.ksi_code);
 3030 #endif
 3031         if ((p->p_stops & S_SIG) != 0) {
 3032                 mtx_unlock(&ps->ps_mtx);
 3033                 stopevent(p, S_SIG, sig);
 3034                 mtx_lock(&ps->ps_mtx);
 3035         }
 3036 
 3037         if (action == SIG_DFL) {
 3038                 /*
 3039                  * Default action, where the default is to kill
 3040                  * the process.  (Other cases were ignored above.)
 3041                  */
 3042                 mtx_unlock(&ps->ps_mtx);
 3043                 proc_td_siginfo_capture(td, &ksi.ksi_info);
 3044                 sigexit(td, sig);
 3045                 /* NOTREACHED */
 3046         } else {
 3047                 /*
 3048                  * If we get here, the signal must be caught.
 3049                  */
 3050                 KASSERT(action != SIG_IGN, ("postsig action %p", action));
 3051                 KASSERT(!SIGISMEMBER(td->td_sigmask, sig),
 3052                     ("postsig action: blocked sig %d", sig));
 3053 
 3054                 /*
 3055                  * Set the new mask value and also defer further
 3056                  * occurrences of this signal.
 3057                  *
 3058                  * Special case: user has done a sigsuspend.  Here the
 3059                  * current mask is not of interest, but rather the
 3060                  * mask from before the sigsuspend is what we want
 3061                  * restored after the signal processing is completed.
 3062                  */
 3063                 if (td->td_pflags & TDP_OLDMASK) {
 3064                         returnmask = td->td_oldsigmask;
 3065                         td->td_pflags &= ~TDP_OLDMASK;
 3066                 } else
 3067                         returnmask = td->td_sigmask;
 3068 
 3069                 if (p->p_sig == sig) {
 3070                         p->p_code = 0;
 3071                         p->p_sig = 0;
 3072                 }
 3073                 (*p->p_sysent->sv_sendsig)(action, &ksi, &returnmask);
 3074                 postsig_done(sig, td, ps);
 3075         }
 3076         return (1);
 3077 }
 3078 
 3079 /*
 3080  * Kill the current process for stated reason.
 3081  */
 3082 void
 3083 killproc(struct proc *p, char *why)
 3084 {
 3085 
 3086         PROC_LOCK_ASSERT(p, MA_OWNED);
 3087         CTR3(KTR_PROC, "killproc: proc %p (pid %d, %s)", p, p->p_pid,
 3088             p->p_comm);
 3089         log(LOG_ERR, "pid %d (%s), uid %d, was killed: %s\n", p->p_pid,
 3090             p->p_comm, p->p_ucred ? p->p_ucred->cr_uid : -1, why);
 3091         p->p_flag |= P_WKILLED;
 3092         kern_psignal(p, SIGKILL);
 3093 }
 3094 
 3095 /*
 3096  * Force the current process to exit with the specified signal, dumping core
 3097  * if appropriate.  We bypass the normal tests for masked and caught signals,
 3098  * allowing unrecoverable failures to terminate the process without changing
 3099  * signal state.  Mark the accounting record with the signal termination.
 3100  * If dumping core, save the signal number for the debugger.  Calls exit and
 3101  * does not return.
 3102  */
 3103 void
 3104 sigexit(struct thread *td, int sig)
 3105 {
 3106         struct proc *p = td->td_proc;
 3107 
 3108         PROC_LOCK_ASSERT(p, MA_OWNED);
 3109         p->p_acflag |= AXSIG;
 3110         /*
 3111          * We must be single-threading to generate a core dump.  This
 3112          * ensures that the registers in the core file are up-to-date.
 3113          * Also, the ELF dump handler assumes that the thread list doesn't
 3114          * change out from under it.
 3115          *
 3116          * XXX If another thread attempts to single-thread before us
 3117          *     (e.g. via fork()), we won't get a dump at all.
 3118          */
 3119         if ((sigprop(sig) & SA_CORE) && thread_single(p, SINGLE_NO_EXIT) == 0) {
 3120                 p->p_sig = sig;
 3121                 /*
 3122                  * Log signals which would cause core dumps
 3123                  * (Log as LOG_INFO to appease those who don't want
 3124                  * these messages.)
 3125                  * XXX : Todo, as well as euid, write out ruid too
 3126                  * Note that coredump() drops proc lock.
 3127                  */
 3128                 if (coredump(td) == 0)
 3129                         sig |= WCOREFLAG;
 3130                 if (kern_logsigexit)
 3131                         log(LOG_INFO,
 3132                             "pid %d (%s), uid %d: exited on signal %d%s\n",
 3133                             p->p_pid, p->p_comm,
 3134                             td->td_ucred ? td->td_ucred->cr_uid : -1,
 3135                             sig &~ WCOREFLAG,
 3136                             sig & WCOREFLAG ? " (core dumped)" : "");
 3137         } else
 3138                 PROC_UNLOCK(p);
 3139         exit1(td, 0, sig);
 3140         /* NOTREACHED */
 3141 }
 3142 
 3143 /*
 3144  * Send queued SIGCHLD to parent when child process's state
 3145  * is changed.
 3146  */
 3147 static void
 3148 sigparent(struct proc *p, int reason, int status)
 3149 {
 3150         PROC_LOCK_ASSERT(p, MA_OWNED);
 3151         PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED);
 3152 
 3153         if (p->p_ksi != NULL) {
 3154                 p->p_ksi->ksi_signo  = SIGCHLD;
 3155                 p->p_ksi->ksi_code   = reason;
 3156                 p->p_ksi->ksi_status = status;
 3157                 p->p_ksi->ksi_pid    = p->p_pid;
 3158                 p->p_ksi->ksi_uid    = p->p_ucred->cr_ruid;
 3159                 if (KSI_ONQ(p->p_ksi))
 3160                         return;
 3161         }
 3162         pksignal(p->p_pptr, SIGCHLD, p->p_ksi);
 3163 }
 3164 
 3165 static void
 3166 childproc_jobstate(struct proc *p, int reason, int sig)
 3167 {
 3168         struct sigacts *ps;
 3169 
 3170         PROC_LOCK_ASSERT(p, MA_OWNED);
 3171         PROC_LOCK_ASSERT(p->p_pptr, MA_OWNED);
 3172 
 3173         /*
 3174          * Wake up parent sleeping in kern_wait(), also send
 3175          * SIGCHLD to parent, but SIGCHLD does not guarantee
 3176          * that parent will awake, because parent may masked
 3177          * the signal.
 3178          */
 3179         p->p_pptr->p_flag |= P_STATCHILD;
 3180         wakeup(p->p_pptr);
 3181 
 3182         ps = p->p_pptr->p_sigacts;
 3183         mtx_lock(&ps->ps_mtx);
 3184         if ((ps->ps_flag & PS_NOCLDSTOP) == 0) {
 3185                 mtx_unlock(&ps->ps_mtx);
 3186                 sigparent(p, reason, sig);
 3187         } else
 3188                 mtx_unlock(&ps->ps_mtx);
 3189 }
 3190 
 3191 void
 3192 childproc_stopped(struct proc *p, int reason)
 3193 {
 3194 
 3195         childproc_jobstate(p, reason, p->p_xsig);
 3196 }
 3197 
 3198 void
 3199 childproc_continued(struct proc *p)
 3200 {
 3201         childproc_jobstate(p, CLD_CONTINUED, SIGCONT);
 3202 }
 3203 
 3204 void
 3205 childproc_exited(struct proc *p)
 3206 {
 3207         int reason, status;
 3208 
 3209         if (WCOREDUMP(p->p_xsig)) {
 3210                 reason = CLD_DUMPED;
 3211                 status = WTERMSIG(p->p_xsig);
 3212         } else if (WIFSIGNALED(p->p_xsig)) {
 3213                 reason = CLD_KILLED;
 3214                 status = WTERMSIG(p->p_xsig);
 3215         } else {
 3216                 reason = CLD_EXITED;
 3217                 status = p->p_xexit;
 3218         }
 3219         /*
 3220          * XXX avoid calling wakeup(p->p_pptr), the work is
 3221          * done in exit1().
 3222          */
 3223         sigparent(p, reason, status);
 3224 }
 3225 
 3226 /*
 3227  * We only have 1 character for the core count in the format
 3228  * string, so the range will be 0-9
 3229  */
 3230 #define MAX_NUM_CORES 10
 3231 static int num_cores = 5;
 3232 
 3233 static int
 3234 sysctl_debug_num_cores_check (SYSCTL_HANDLER_ARGS)
 3235 {
 3236         int error;
 3237         int new_val;
 3238 
 3239         new_val = num_cores;
 3240         error = sysctl_handle_int(oidp, &new_val, 0, req);
 3241         if (error != 0 || req->newptr == NULL)
 3242                 return (error);
 3243         if (new_val > MAX_NUM_CORES)
 3244                 new_val = MAX_NUM_CORES;
 3245         if (new_val < 0)
 3246                 new_val = 0;
 3247         num_cores = new_val;
 3248         return (0);
 3249 }
 3250 SYSCTL_PROC(_debug, OID_AUTO, ncores, CTLTYPE_INT|CTLFLAG_RW,
 3251             0, sizeof(int), sysctl_debug_num_cores_check, "I", "");
 3252 
 3253 #define GZ_SUFFIX       ".gz"
 3254 
 3255 #ifdef GZIO
 3256 static int compress_user_cores = 1;
 3257 SYSCTL_INT(_kern, OID_AUTO, compress_user_cores, CTLFLAG_RWTUN,
 3258     &compress_user_cores, 0, "Compression of user corefiles");
 3259 
 3260 int compress_user_cores_gzlevel = 6;
 3261 SYSCTL_INT(_kern, OID_AUTO, compress_user_cores_gzlevel, CTLFLAG_RWTUN,
 3262     &compress_user_cores_gzlevel, 0, "Corefile gzip compression level");
 3263 #else
 3264 static int compress_user_cores = 0;
 3265 #endif
 3266 
 3267 /*
 3268  * Protect the access to corefilename[] by allproc_lock.
 3269  */
 3270 #define corefilename_lock       allproc_lock
 3271 
 3272 static char corefilename[MAXPATHLEN] = {"%N.core"};
 3273 TUNABLE_STR("kern.corefile", corefilename, sizeof(corefilename));
 3274 
 3275 static int
 3276 sysctl_kern_corefile(SYSCTL_HANDLER_ARGS)
 3277 {
 3278         int error;
 3279 
 3280         sx_xlock(&corefilename_lock);
 3281         error = sysctl_handle_string(oidp, corefilename, sizeof(corefilename),
 3282             req);
 3283         sx_xunlock(&corefilename_lock);
 3284 
 3285         return (error);
 3286 }
 3287 SYSCTL_PROC(_kern, OID_AUTO, corefile, CTLTYPE_STRING | CTLFLAG_RW |
 3288     CTLFLAG_MPSAFE, 0, 0, sysctl_kern_corefile, "A",
 3289     "Process corefile name format string");
 3290 
 3291 /*
 3292  * corefile_open(comm, uid, pid, td, compress, vpp, namep)
 3293  * Expand the name described in corefilename, using name, uid, and pid
 3294  * and open/create core file.
 3295  * corefilename is a printf-like string, with three format specifiers:
 3296  *      %N      name of process ("name")
 3297  *      %P      process id (pid)
 3298  *      %U      user id (uid)
 3299  * For example, "%N.core" is the default; they can be disabled completely
 3300  * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P".
 3301  * This is controlled by the sysctl variable kern.corefile (see above).
 3302  */
 3303 static int
 3304 corefile_open(const char *comm, uid_t uid, pid_t pid, struct thread *td,
 3305     int compress, struct vnode **vpp, char **namep)
 3306 {
 3307         struct nameidata nd;
 3308         struct sbuf sb;
 3309         const char *format;
 3310         char *hostname, *name;
 3311         int indexpos, i, error, cmode, flags, oflags;
 3312 
 3313         hostname = NULL;
 3314         format = corefilename;
 3315         name = malloc(MAXPATHLEN, M_TEMP, M_WAITOK | M_ZERO);
 3316         indexpos = -1;
 3317         (void)sbuf_new(&sb, name, MAXPATHLEN, SBUF_FIXEDLEN);
 3318         sx_slock(&corefilename_lock);
 3319         for (i = 0; format[i] != '\0'; i++) {
 3320                 switch (format[i]) {
 3321                 case '%':       /* Format character */
 3322                         i++;
 3323                         switch (format[i]) {
 3324                         case '%':
 3325                                 sbuf_putc(&sb, '%');
 3326                                 break;
 3327                         case 'H':       /* hostname */
 3328                                 if (hostname == NULL) {
 3329                                         hostname = malloc(MAXHOSTNAMELEN,
 3330                                             M_TEMP, M_WAITOK);
 3331                                 }
 3332                                 getcredhostname(td->td_ucred, hostname,
 3333                                     MAXHOSTNAMELEN);
 3334                                 sbuf_printf(&sb, "%s", hostname);
 3335                                 break;
 3336                         case 'I':       /* autoincrementing index */
 3337                                 sbuf_printf(&sb, "");
 3338                                 indexpos = sbuf_len(&sb) - 1;
 3339                                 break;
 3340                         case 'N':       /* process name */
 3341                                 sbuf_printf(&sb, "%s", comm);
 3342                                 break;
 3343                         case 'P':       /* process id */
 3344                                 sbuf_printf(&sb, "%u", pid);
 3345                                 break;
 3346                         case 'U':       /* user id */
 3347                                 sbuf_printf(&sb, "%u", uid);
 3348                                 break;
 3349                         default:
 3350                                 log(LOG_ERR,
 3351                                     "Unknown format character %c in "
 3352                                     "corename `%s'\n", format[i], format);
 3353                                 break;
 3354                         }
 3355                         break;
 3356                 default:
 3357                         sbuf_putc(&sb, format[i]);
 3358                         break;
 3359                 }
 3360         }
 3361         sx_sunlock(&corefilename_lock);
 3362         free(hostname, M_TEMP);
 3363         if (compress)
 3364                 sbuf_printf(&sb, GZ_SUFFIX);
 3365         if (sbuf_error(&sb) != 0) {
 3366                 log(LOG_ERR, "pid %ld (%s), uid (%lu): corename is too "
 3367                     "long\n", (long)pid, comm, (u_long)uid);
 3368                 sbuf_delete(&sb);
 3369                 free(name, M_TEMP);
 3370                 return (ENOMEM);
 3371         }
 3372         sbuf_finish(&sb);
 3373         sbuf_delete(&sb);
 3374 
 3375         cmode = S_IRUSR | S_IWUSR;
 3376         oflags = VN_OPEN_NOAUDIT | VN_OPEN_NAMECACHE |
 3377             (capmode_coredump ? VN_OPEN_NOCAPCHECK : 0);
 3378 
 3379         /*
 3380          * If the core format has a %I in it, then we need to check
 3381          * for existing corefiles before returning a name.
 3382          * To do this we iterate over 0..num_cores to find a
 3383          * non-existing core file name to use.
 3384          */
 3385         if (indexpos != -1) {
 3386                 for (i = 0; i < num_cores; i++) {
 3387                         flags = O_CREAT | O_EXCL | FWRITE | O_NOFOLLOW;
 3388                         name[indexpos] = '' + i;
 3389                         NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, td);
 3390                         error = vn_open_cred(&nd, &flags, cmode, oflags,
 3391                             td->td_ucred, NULL);
 3392                         if (error) {
 3393                                 if (error == EEXIST)
 3394                                         continue;
 3395                                 log(LOG_ERR,
 3396                                     "pid %d (%s), uid (%u):  Path `%s' failed "
 3397                                     "on initial open test, error = %d\n",
 3398                                     pid, comm, uid, name, error);
 3399                         }
 3400                         goto out;
 3401                 }
 3402         }
 3403 
 3404         flags = O_CREAT | FWRITE | O_NOFOLLOW;
 3405         NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, td);
 3406         error = vn_open_cred(&nd, &flags, cmode, oflags, td->td_ucred, NULL);
 3407 out:
 3408         if (error) {
 3409 #ifdef AUDIT
 3410                 audit_proc_coredump(td, name, error);
 3411 #endif
 3412                 free(name, M_TEMP);
 3413                 return (error);
 3414         }
 3415         NDFREE(&nd, NDF_ONLY_PNBUF);
 3416         *vpp = nd.ni_vp;
 3417         *namep = name;
 3418         return (0);
 3419 }
 3420 
 3421 static int
 3422 coredump_sanitise_path(const char *path)
 3423 {
 3424         size_t i;
 3425 
 3426         /*
 3427          * Only send a subset of ASCII to devd(8) because it
 3428          * might pass these strings to sh -c.
 3429          */
 3430         for (i = 0; path[i]; i++)
 3431                 if (!(isalpha(path[i]) || isdigit(path[i])) &&
 3432                     path[i] != '/' && path[i] != '.' &&
 3433                     path[i] != '-')
 3434                         return (0);
 3435 
 3436         return (1);
 3437 }
 3438 
 3439 /*
 3440  * Dump a process' core.  The main routine does some
 3441  * policy checking, and creates the name of the coredump;
 3442  * then it passes on a vnode and a size limit to the process-specific
 3443  * coredump routine if there is one; if there _is not_ one, it returns
 3444  * ENOSYS; otherwise it returns the error from the process-specific routine.
 3445  */
 3446 
 3447 static int
 3448 coredump(struct thread *td)
 3449 {
 3450         struct proc *p = td->td_proc;
 3451         struct ucred *cred = td->td_ucred;
 3452         struct vnode *vp;
 3453         struct flock lf;
 3454         struct vattr vattr;
 3455         int error, error1, locked;
 3456         char *name;                     /* name of corefile */
 3457         void *rl_cookie;
 3458         off_t limit;
 3459         char *data = NULL;
 3460         char *fullpath, *freepath = NULL;
 3461         size_t len;
 3462         static const char comm_name[] = "comm=";
 3463         static const char core_name[] = "core=";
 3464 
 3465         PROC_LOCK_ASSERT(p, MA_OWNED);
 3466         MPASS((p->p_flag & P_HADTHREADS) == 0 || p->p_singlethread == td);
 3467         _STOPEVENT(p, S_CORE, 0);
 3468 
 3469         if (!do_coredump || (!sugid_coredump && (p->p_flag & P_SUGID) != 0) ||
 3470             (p->p_flag2 & P2_NOTRACE) != 0) {
 3471                 PROC_UNLOCK(p);
 3472                 return (EFAULT);
 3473         }
 3474 
 3475         /*
 3476          * Note that the bulk of limit checking is done after
 3477          * the corefile is created.  The exception is if the limit
 3478          * for corefiles is 0, in which case we don't bother
 3479          * creating the corefile at all.  This layout means that
 3480          * a corefile is truncated instead of not being created,
 3481          * if it is larger than the limit.
 3482          */
 3483         limit = (off_t)lim_cur(td, RLIMIT_CORE);
 3484         if (limit == 0 || racct_get_available(p, RACCT_CORE) == 0) {
 3485                 PROC_UNLOCK(p);
 3486                 return (EFBIG);
 3487         }
 3488         PROC_UNLOCK(p);
 3489 
 3490         error = corefile_open(p->p_comm, cred->cr_uid, p->p_pid, td,
 3491             compress_user_cores, &vp, &name);
 3492         if (error != 0)
 3493                 return (error);
 3494 
 3495         /*
 3496          * Don't dump to non-regular files or files with links.
 3497          * Do not dump into system files.
 3498          */
 3499         if (vp->v_type != VREG || VOP_GETATTR(vp, &vattr, cred) != 0 ||
 3500             vattr.va_nlink != 1 || (vp->v_vflag & VV_SYSTEM) != 0) {
 3501                 VOP_UNLOCK(vp, 0);
 3502                 error = EFAULT;
 3503                 goto out;
 3504         }
 3505 
 3506         VOP_UNLOCK(vp, 0);
 3507 
 3508         /* Postpone other writers, including core dumps of other processes. */
 3509         rl_cookie = vn_rangelock_wlock(vp, 0, OFF_MAX);
 3510 
 3511         lf.l_whence = SEEK_SET;
 3512         lf.l_start = 0;
 3513         lf.l_len = 0;
 3514         lf.l_type = F_WRLCK;
 3515         locked = (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &lf, F_FLOCK) == 0);
 3516 
 3517         VATTR_NULL(&vattr);
 3518         vattr.va_size = 0;
 3519         if (set_core_nodump_flag)
 3520                 vattr.va_flags = UF_NODUMP;
 3521         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 3522         VOP_SETATTR(vp, &vattr, cred);
 3523         VOP_UNLOCK(vp, 0);
 3524         PROC_LOCK(p);
 3525         p->p_acflag |= ACORE;
 3526         PROC_UNLOCK(p);
 3527 
 3528         if (p->p_sysent->sv_coredump != NULL) {
 3529                 error = p->p_sysent->sv_coredump(td, vp, limit,
 3530                     compress_user_cores ? IMGACT_CORE_COMPRESS : 0);
 3531         } else {
 3532                 error = ENOSYS;
 3533         }
 3534 
 3535         if (locked) {
 3536                 lf.l_type = F_UNLCK;
 3537                 VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_FLOCK);
 3538         }
 3539         vn_rangelock_unlock(vp, rl_cookie);
 3540 
 3541         /*
 3542          * Notify the userland helper that a process triggered a core dump.
 3543          * This allows the helper to run an automated debugging session.
 3544          */
 3545         if (error != 0 || coredump_devctl == 0)
 3546                 goto out;
 3547         len = MAXPATHLEN * 2 + sizeof(comm_name) - 1 +
 3548             sizeof(' ') + sizeof(core_name) - 1;
 3549         data = malloc(len, M_TEMP, M_WAITOK);
 3550         if (vn_fullpath_global(td, p->p_textvp, &fullpath, &freepath) != 0)
 3551                 goto out;
 3552         if (!coredump_sanitise_path(fullpath))
 3553                 goto out;
 3554         snprintf(data, len, "%s%s ", comm_name, fullpath);
 3555         free(freepath, M_TEMP);
 3556         freepath = NULL;
 3557         if (vn_fullpath_global(td, vp, &fullpath, &freepath) != 0)
 3558                 goto out;
 3559         if (!coredump_sanitise_path(fullpath))
 3560                 goto out;
 3561         strlcat(data, core_name, len);
 3562         strlcat(data, fullpath, len);
 3563         devctl_notify("kernel", "signal", "coredump", data);
 3564 out:
 3565         error1 = vn_close(vp, FWRITE, cred, td);
 3566         if (error == 0)
 3567                 error = error1;
 3568 #ifdef AUDIT
 3569         audit_proc_coredump(td, name, error);
 3570 #endif
 3571         free(freepath, M_TEMP);
 3572         free(data, M_TEMP);
 3573         free(name, M_TEMP);
 3574         return (error);
 3575 }
 3576 
 3577 /*
 3578  * Nonexistent system call-- signal process (may want to handle it).  Flag
 3579  * error in case process won't see signal immediately (blocked or ignored).
 3580  */
 3581 #ifndef _SYS_SYSPROTO_H_
 3582 struct nosys_args {
 3583         int     dummy;
 3584 };
 3585 #endif
 3586 /* ARGSUSED */
 3587 int
 3588 nosys(struct thread *td, struct nosys_args *args)
 3589 {
 3590         struct proc *p;
 3591 
 3592         p = td->td_proc;
 3593 
 3594         PROC_LOCK(p);
 3595         tdsignal(td, SIGSYS);
 3596         PROC_UNLOCK(p);
 3597         if (kern_lognosys == 1 || kern_lognosys == 3) {
 3598                 uprintf("pid %d comm %s: nosys %d\n", p->p_pid, p->p_comm,
 3599                     td->td_sa.code);
 3600         }
 3601         if (kern_lognosys == 2 || kern_lognosys == 3) {
 3602                 printf("pid %d comm %s: nosys %d\n", p->p_pid, p->p_comm,
 3603                     td->td_sa.code);
 3604         }
 3605         return (ENOSYS);
 3606 }
 3607 
 3608 /*
 3609  * Send a SIGIO or SIGURG signal to a process or process group using stored
 3610  * credentials rather than those of the current process.
 3611  */
 3612 void
 3613 pgsigio(struct sigio **sigiop, int sig, int checkctty)
 3614 {
 3615         ksiginfo_t ksi;
 3616         struct sigio *sigio;
 3617 
 3618         ksiginfo_init(&ksi);
 3619         ksi.ksi_signo = sig;
 3620         ksi.ksi_code = SI_KERNEL;
 3621 
 3622         SIGIO_LOCK();
 3623         sigio = *sigiop;
 3624         if (sigio == NULL) {
 3625                 SIGIO_UNLOCK();
 3626                 return;
 3627         }
 3628         if (sigio->sio_pgid > 0) {
 3629                 PROC_LOCK(sigio->sio_proc);
 3630                 if (CANSIGIO(sigio->sio_ucred, sigio->sio_proc->p_ucred))
 3631                         kern_psignal(sigio->sio_proc, sig);
 3632                 PROC_UNLOCK(sigio->sio_proc);
 3633         } else if (sigio->sio_pgid < 0) {
 3634                 struct proc *p;
 3635 
 3636                 PGRP_LOCK(sigio->sio_pgrp);
 3637                 LIST_FOREACH(p, &sigio->sio_pgrp->pg_members, p_pglist) {
 3638                         PROC_LOCK(p);
 3639                         if (p->p_state == PRS_NORMAL &&
 3640                             CANSIGIO(sigio->sio_ucred, p->p_ucred) &&
 3641                             (checkctty == 0 || (p->p_flag & P_CONTROLT)))
 3642                                 kern_psignal(p, sig);
 3643                         PROC_UNLOCK(p);
 3644                 }
 3645                 PGRP_UNLOCK(sigio->sio_pgrp);
 3646         }
 3647         SIGIO_UNLOCK();
 3648 }
 3649 
 3650 static int
 3651 filt_sigattach(struct knote *kn)
 3652 {
 3653         struct proc *p = curproc;
 3654 
 3655         kn->kn_ptr.p_proc = p;
 3656         kn->kn_flags |= EV_CLEAR;               /* automatically set */
 3657 
 3658         knlist_add(p->p_klist, kn, 0);
 3659 
 3660         return (0);
 3661 }
 3662 
 3663 static void
 3664 filt_sigdetach(struct knote *kn)
 3665 {
 3666         struct proc *p = kn->kn_ptr.p_proc;
 3667 
 3668         knlist_remove(p->p_klist, kn, 0);
 3669 }
 3670 
 3671 /*
 3672  * signal knotes are shared with proc knotes, so we apply a mask to
 3673  * the hint in order to differentiate them from process hints.  This
 3674  * could be avoided by using a signal-specific knote list, but probably
 3675  * isn't worth the trouble.
 3676  */
 3677 static int
 3678 filt_signal(struct knote *kn, long hint)
 3679 {
 3680 
 3681         if (hint & NOTE_SIGNAL) {
 3682                 hint &= ~NOTE_SIGNAL;
 3683 
 3684                 if (kn->kn_id == hint)
 3685                         kn->kn_data++;
 3686         }
 3687         return (kn->kn_data != 0);
 3688 }
 3689 
 3690 struct sigacts *
 3691 sigacts_alloc(void)
 3692 {
 3693         struct sigacts *ps;
 3694 
 3695         ps = malloc(sizeof(struct sigacts), M_SUBPROC, M_WAITOK | M_ZERO);
 3696         refcount_init(&ps->ps_refcnt, 1);
 3697         mtx_init(&ps->ps_mtx, "sigacts", NULL, MTX_DEF);
 3698         return (ps);
 3699 }
 3700 
 3701 void
 3702 sigacts_free(struct sigacts *ps)
 3703 {
 3704 
 3705         if (refcount_release(&ps->ps_refcnt) == 0)
 3706                 return;
 3707         mtx_destroy(&ps->ps_mtx);
 3708         free(ps, M_SUBPROC);
 3709 }
 3710 
 3711 struct sigacts *
 3712 sigacts_hold(struct sigacts *ps)
 3713 {
 3714 
 3715         refcount_acquire(&ps->ps_refcnt);
 3716         return (ps);
 3717 }
 3718 
 3719 void
 3720 sigacts_copy(struct sigacts *dest, struct sigacts *src)
 3721 {
 3722 
 3723         KASSERT(dest->ps_refcnt == 1, ("sigacts_copy to shared dest"));
 3724         mtx_lock(&src->ps_mtx);
 3725         bcopy(src, dest, offsetof(struct sigacts, ps_refcnt));
 3726         mtx_unlock(&src->ps_mtx);
 3727 }
 3728 
 3729 int
 3730 sigacts_shared(struct sigacts *ps)
 3731 {
 3732 
 3733         return (ps->ps_refcnt > 1);
 3734 }

Cache object: c846fb56b050b94874466d9d7f9a36e9


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.