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-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: kern_sig.c,v 1.202.2.3 2007/01/19 21:46:54 bouyer Exp $        */
    2 
    3 /*
    4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  * (c) UNIX System Laboratories, Inc.
    7  * All or some portions of this file are derived from material licensed
    8  * to the University of California by American Telephone and Telegraph
    9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   10  * the permission of UNIX System Laboratories, Inc.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. Neither the name of the University nor the names of its contributors
   21  *    may be used to endorse or promote products derived from this software
   22  *    without specific prior written permission.
   23  *
   24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   34  * SUCH DAMAGE.
   35  *
   36  *      @(#)kern_sig.c  8.14 (Berkeley) 5/14/95
   37  */
   38 
   39 #include <sys/cdefs.h>
   40 __KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.202.2.3 2007/01/19 21:46:54 bouyer Exp $");
   41 
   42 #include "opt_ktrace.h"
   43 #include "opt_compat_sunos.h"
   44 #include "opt_compat_netbsd.h"
   45 #include "opt_compat_netbsd32.h"
   46 
   47 #define SIGPROP         /* include signal properties table */
   48 #include <sys/param.h>
   49 #include <sys/signalvar.h>
   50 #include <sys/resourcevar.h>
   51 #include <sys/namei.h>
   52 #include <sys/vnode.h>
   53 #include <sys/proc.h>
   54 #include <sys/systm.h>
   55 #include <sys/timeb.h>
   56 #include <sys/times.h>
   57 #include <sys/buf.h>
   58 #include <sys/acct.h>
   59 #include <sys/file.h>
   60 #include <sys/kernel.h>
   61 #include <sys/wait.h>
   62 #include <sys/ktrace.h>
   63 #include <sys/syslog.h>
   64 #include <sys/stat.h>
   65 #include <sys/core.h>
   66 #include <sys/filedesc.h>
   67 #include <sys/malloc.h>
   68 #include <sys/pool.h>
   69 #include <sys/ucontext.h>
   70 #include <sys/sa.h>
   71 #include <sys/savar.h>
   72 #include <sys/exec.h>
   73 
   74 #include <sys/mount.h>
   75 #include <sys/syscallargs.h>
   76 
   77 #include <machine/cpu.h>
   78 
   79 #include <sys/user.h>           /* for coredump */
   80 
   81 #include <uvm/uvm.h>
   82 #include <uvm/uvm_extern.h>
   83 
   84 static void     child_psignal(struct proc *, int);
   85 static int      build_corename(struct proc *, char *, const char *, size_t);
   86 static void     ksiginfo_exithook(struct proc *, void *);
   87 static void     ksiginfo_put(struct proc *, const ksiginfo_t *);
   88 static ksiginfo_t *ksiginfo_get(struct proc *, int);
   89 static void     kpsignal2(struct proc *, const ksiginfo_t *, int);
   90 
   91 sigset_t        contsigmask, stopsigmask, sigcantmask;
   92 
   93 struct pool     sigacts_pool;   /* memory pool for sigacts structures */
   94 
   95 /*
   96  * struct sigacts memory pool allocator.
   97  */
   98 
   99 static void *
  100 sigacts_poolpage_alloc(struct pool *pp, int flags)
  101 {
  102 
  103         return (void *)uvm_km_kmemalloc1(kernel_map,
  104             uvm.kernel_object, (PAGE_SIZE)*2, (PAGE_SIZE)*2, UVM_UNKNOWN_OFFSET,
  105             (flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK);
  106 }
  107 
  108 static void
  109 sigacts_poolpage_free(struct pool *pp, void *v)
  110 {
  111         uvm_km_free(kernel_map, (vaddr_t)v, (PAGE_SIZE)*2);
  112 }
  113 
  114 static struct pool_allocator sigactspool_allocator = {
  115         sigacts_poolpage_alloc, sigacts_poolpage_free,
  116 };
  117 
  118 POOL_INIT(siginfo_pool, sizeof(siginfo_t), 0, 0, 0, "siginfo",
  119     &pool_allocator_nointr);
  120 POOL_INIT(ksiginfo_pool, sizeof(ksiginfo_t), 0, 0, 0, "ksiginfo", NULL);
  121 
  122 /*
  123  * Can process p, with pcred pc, send the signal signum to process q?
  124  */
  125 #define CANSIGNAL(p, pc, q, signum) \
  126         ((pc)->pc_ucred->cr_uid == 0 || \
  127             (pc)->p_ruid == (q)->p_cred->p_ruid || \
  128             (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \
  129             (pc)->p_ruid == (q)->p_ucred->cr_uid || \
  130             (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \
  131             ((signum) == SIGCONT && (q)->p_session == (p)->p_session))
  132 
  133 /*
  134  * Remove and return the first ksiginfo element that matches our requested
  135  * signal, or return NULL if one not found.
  136  */
  137 static ksiginfo_t *
  138 ksiginfo_get(struct proc *p, int signo)
  139 {
  140         ksiginfo_t *ksi;
  141         int s;
  142 
  143         s = splsoftclock();
  144         simple_lock(&p->p_sigctx.ps_silock);
  145         CIRCLEQ_FOREACH(ksi, &p->p_sigctx.ps_siginfo, ksi_list) {
  146                 if (ksi->ksi_signo == signo) {
  147                         CIRCLEQ_REMOVE(&p->p_sigctx.ps_siginfo, ksi, ksi_list);
  148                         goto out;
  149                 }
  150         }
  151         ksi = NULL;
  152 out:
  153         simple_unlock(&p->p_sigctx.ps_silock);
  154         splx(s);
  155         return ksi;
  156 }
  157 
  158 /*
  159  * Append a new ksiginfo element to the list of pending ksiginfo's, if
  160  * we need to (SA_SIGINFO was requested). We replace non RT signals if
  161  * they already existed in the queue and we add new entries for RT signals,
  162  * or for non RT signals with non-existing entries.
  163  */
  164 static void
  165 ksiginfo_put(struct proc *p, const ksiginfo_t *ksi)
  166 {
  167         ksiginfo_t *kp;
  168         struct sigaction *sa = &SIGACTION_PS(p->p_sigacts, ksi->ksi_signo);
  169         int s;
  170 
  171         if ((sa->sa_flags & SA_SIGINFO) == 0)
  172                 return;
  173         /*
  174          * If there's no info, don't save it.
  175          */
  176         if (KSI_EMPTY_P(ksi))
  177                 return;
  178 
  179         s = splsoftclock();
  180         simple_lock(&p->p_sigctx.ps_silock);
  181 #ifdef notyet   /* XXX: QUEUING */
  182         if (ksi->ksi_signo < SIGRTMIN)
  183 #endif
  184         {
  185                 CIRCLEQ_FOREACH(kp, &p->p_sigctx.ps_siginfo, ksi_list) {
  186                         if (kp->ksi_signo == ksi->ksi_signo) {
  187                                 KSI_COPY(ksi, kp);
  188                                 goto out;
  189                         }
  190                 }
  191         }
  192         kp = pool_get(&ksiginfo_pool, PR_NOWAIT);
  193         if (kp == NULL) {
  194 #ifdef DIAGNOSTIC
  195                 printf("Out of memory allocating siginfo for pid %d\n",
  196                     p->p_pid);
  197 #endif
  198                 goto out;
  199         }
  200         *kp = *ksi;
  201         CIRCLEQ_INSERT_TAIL(&p->p_sigctx.ps_siginfo, kp, ksi_list);
  202 out:
  203         simple_unlock(&p->p_sigctx.ps_silock);
  204         splx(s);
  205 }
  206 
  207 /*
  208  * free all pending ksiginfo on exit
  209  */
  210 static void
  211 ksiginfo_exithook(struct proc *p, void *v)
  212 {
  213         int s;
  214 
  215         s = splsoftclock();
  216         simple_lock(&p->p_sigctx.ps_silock);
  217         while (!CIRCLEQ_EMPTY(&p->p_sigctx.ps_siginfo)) {
  218                 ksiginfo_t *ksi = CIRCLEQ_FIRST(&p->p_sigctx.ps_siginfo);
  219                 CIRCLEQ_REMOVE(&p->p_sigctx.ps_siginfo, ksi, ksi_list);
  220                 pool_put(&ksiginfo_pool, ksi);
  221         }
  222         simple_unlock(&p->p_sigctx.ps_silock);
  223         splx(s);
  224 }
  225 
  226 /*
  227  * Initialize signal-related data structures.
  228  */
  229 void
  230 signal_init(void)
  231 {
  232 
  233         sigactspool_allocator.pa_pagesz = (PAGE_SIZE)*2;
  234 
  235         pool_init(&sigacts_pool, sizeof(struct sigacts), 0, 0, 0, "sigapl",
  236             sizeof(struct sigacts) > PAGE_SIZE ?
  237             &sigactspool_allocator : &pool_allocator_nointr);
  238 
  239         exithook_establish(ksiginfo_exithook, NULL);
  240         exechook_establish(ksiginfo_exithook, NULL);
  241 }
  242 
  243 /*
  244  * Create an initial sigctx structure, using the same signal state
  245  * as p. If 'share' is set, share the sigctx_proc part, otherwise just
  246  * copy it from parent.
  247  */
  248 void
  249 sigactsinit(struct proc *np, struct proc *pp, int share)
  250 {
  251         struct sigacts *ps;
  252 
  253         if (share) {
  254                 np->p_sigacts = pp->p_sigacts;
  255                 pp->p_sigacts->sa_refcnt++;
  256         } else {
  257                 ps = pool_get(&sigacts_pool, PR_WAITOK);
  258                 if (pp)
  259                         memcpy(ps, pp->p_sigacts, sizeof(struct sigacts));
  260                 else
  261                         memset(ps, '\0', sizeof(struct sigacts));
  262                 ps->sa_refcnt = 1;
  263                 np->p_sigacts = ps;
  264         }
  265 }
  266 
  267 /*
  268  * Make this process not share its sigctx, maintaining all
  269  * signal state.
  270  */
  271 void
  272 sigactsunshare(struct proc *p)
  273 {
  274         struct sigacts *oldps;
  275 
  276         if (p->p_sigacts->sa_refcnt == 1)
  277                 return;
  278 
  279         oldps = p->p_sigacts;
  280         sigactsinit(p, NULL, 0);
  281 
  282         if (--oldps->sa_refcnt == 0)
  283                 pool_put(&sigacts_pool, oldps);
  284 }
  285 
  286 /*
  287  * Release a sigctx structure.
  288  */
  289 void
  290 sigactsfree(struct sigacts *ps)
  291 {
  292 
  293         if (--ps->sa_refcnt > 0)
  294                 return;
  295 
  296         pool_put(&sigacts_pool, ps);
  297 }
  298 
  299 int
  300 sigaction1(struct proc *p, int signum, const struct sigaction *nsa,
  301         struct sigaction *osa, const void *tramp, int vers)
  302 {
  303         struct sigacts  *ps;
  304         int             prop;
  305 
  306         ps = p->p_sigacts;
  307         if (signum <= 0 || signum >= NSIG)
  308                 return (EINVAL);
  309 
  310         /*
  311          * Trampoline ABI version 0 is reserved for the legacy
  312          * kernel-provided on-stack trampoline.  Conversely, if we are
  313          * using a non-0 ABI version, we must have a trampoline.  Only
  314          * validate the vers if a new sigaction was supplied. Emulations
  315          * use legacy kernel trampolines with version 0, alternatively
  316          * check for that too.
  317          */
  318         if ((vers != 0 && tramp == NULL) ||
  319 #ifdef SIGTRAMP_VALID
  320             (nsa != NULL &&
  321             ((vers == 0) ?
  322                 (p->p_emul->e_sigcode == NULL) :
  323                 !SIGTRAMP_VALID(vers))) ||
  324 #endif
  325             (vers == 0 && tramp != NULL))
  326                 return (EINVAL);
  327 
  328         if (osa)
  329                 *osa = SIGACTION_PS(ps, signum);
  330 
  331         if (nsa) {
  332                 if (nsa->sa_flags & ~SA_ALLBITS)
  333                         return (EINVAL);
  334 
  335                 prop = sigprop[signum];
  336                 if (prop & SA_CANTMASK)
  337                         return (EINVAL);
  338 
  339                 (void) splsched();      /* XXXSMP */
  340                 SIGACTION_PS(ps, signum) = *nsa;
  341                 ps->sa_sigdesc[signum].sd_tramp = tramp;
  342                 ps->sa_sigdesc[signum].sd_vers = vers;
  343                 sigminusset(&sigcantmask, &SIGACTION_PS(ps, signum).sa_mask);
  344                 if ((prop & SA_NORESET) != 0)
  345                         SIGACTION_PS(ps, signum).sa_flags &= ~SA_RESETHAND;
  346                 if (signum == SIGCHLD) {
  347                         if (nsa->sa_flags & SA_NOCLDSTOP)
  348                                 p->p_flag |= P_NOCLDSTOP;
  349                         else
  350                                 p->p_flag &= ~P_NOCLDSTOP;
  351                         if (nsa->sa_flags & SA_NOCLDWAIT) {
  352                                 /*
  353                                  * Paranoia: since SA_NOCLDWAIT is implemented
  354                                  * by reparenting the dying child to PID 1 (and
  355                                  * trust it to reap the zombie), PID 1 itself
  356                                  * is forbidden to set SA_NOCLDWAIT.
  357                                  */
  358                                 if (p->p_pid == 1)
  359                                         p->p_flag &= ~P_NOCLDWAIT;
  360                                 else
  361                                         p->p_flag |= P_NOCLDWAIT;
  362                         } else
  363                                 p->p_flag &= ~P_NOCLDWAIT;
  364                 }
  365                 if ((nsa->sa_flags & SA_NODEFER) == 0)
  366                         sigaddset(&SIGACTION_PS(ps, signum).sa_mask, signum);
  367                 else
  368                         sigdelset(&SIGACTION_PS(ps, signum).sa_mask, signum);
  369                 /*
  370                  * Set bit in p_sigctx.ps_sigignore for signals that are set to
  371                  * SIG_IGN, and for signals set to SIG_DFL where the default is
  372                  * to ignore. However, don't put SIGCONT in
  373                  * p_sigctx.ps_sigignore, as we have to restart the process.
  374                  */
  375                 if (nsa->sa_handler == SIG_IGN ||
  376                     (nsa->sa_handler == SIG_DFL && (prop & SA_IGNORE) != 0)) {
  377                                                 /* never to be seen again */
  378                         sigdelset(&p->p_sigctx.ps_siglist, signum);
  379                         if (signum != SIGCONT) {
  380                                                 /* easier in psignal */
  381                                 sigaddset(&p->p_sigctx.ps_sigignore, signum);
  382                         }
  383                         sigdelset(&p->p_sigctx.ps_sigcatch, signum);
  384                 } else {
  385                         sigdelset(&p->p_sigctx.ps_sigignore, signum);
  386                         if (nsa->sa_handler == SIG_DFL)
  387                                 sigdelset(&p->p_sigctx.ps_sigcatch, signum);
  388                         else
  389                                 sigaddset(&p->p_sigctx.ps_sigcatch, signum);
  390                 }
  391                 (void) spl0();
  392         }
  393 
  394         return (0);
  395 }
  396 
  397 #ifdef COMPAT_16
  398 /* ARGSUSED */
  399 int
  400 compat_16_sys___sigaction14(struct lwp *l, void *v, register_t *retval)
  401 {
  402         struct compat_16_sys___sigaction14_args /* {
  403                 syscallarg(int)                         signum;
  404                 syscallarg(const struct sigaction *)    nsa;
  405                 syscallarg(struct sigaction *)          osa;
  406         } */ *uap = v;
  407         struct proc             *p;
  408         struct sigaction        nsa, osa;
  409         int                     error;
  410 
  411         if (SCARG(uap, nsa)) {
  412                 error = copyin(SCARG(uap, nsa), &nsa, sizeof(nsa));
  413                 if (error)
  414                         return (error);
  415         }
  416         p = l->l_proc;
  417         error = sigaction1(p, SCARG(uap, signum),
  418             SCARG(uap, nsa) ? &nsa : 0, SCARG(uap, osa) ? &osa : 0,
  419             NULL, 0);
  420         if (error)
  421                 return (error);
  422         if (SCARG(uap, osa)) {
  423                 error = copyout(&osa, SCARG(uap, osa), sizeof(osa));
  424                 if (error)
  425                         return (error);
  426         }
  427         return (0);
  428 }
  429 #endif
  430 
  431 /* ARGSUSED */
  432 int
  433 sys___sigaction_sigtramp(struct lwp *l, void *v, register_t *retval)
  434 {
  435         struct sys___sigaction_sigtramp_args /* {
  436                 syscallarg(int)                         signum;
  437                 syscallarg(const struct sigaction *)    nsa;
  438                 syscallarg(struct sigaction *)          osa;
  439                 syscallarg(void *)                      tramp;
  440                 syscallarg(int)                         vers;
  441         } */ *uap = v;
  442         struct proc *p = l->l_proc;
  443         struct sigaction nsa, osa;
  444         int error;
  445 
  446         if (SCARG(uap, nsa)) {
  447                 error = copyin(SCARG(uap, nsa), &nsa, sizeof(nsa));
  448                 if (error)
  449                         return (error);
  450         }
  451         error = sigaction1(p, SCARG(uap, signum),
  452             SCARG(uap, nsa) ? &nsa : 0, SCARG(uap, osa) ? &osa : 0,
  453             SCARG(uap, tramp), SCARG(uap, vers));
  454         if (error)
  455                 return (error);
  456         if (SCARG(uap, osa)) {
  457                 error = copyout(&osa, SCARG(uap, osa), sizeof(osa));
  458                 if (error)
  459                         return (error);
  460         }
  461         return (0);
  462 }
  463 
  464 /*
  465  * Initialize signal state for process 0;
  466  * set to ignore signals that are ignored by default and disable the signal
  467  * stack.
  468  */
  469 void
  470 siginit(struct proc *p)
  471 {
  472         struct sigacts  *ps;
  473         int             signum, prop;
  474 
  475         ps = p->p_sigacts;
  476         sigemptyset(&contsigmask);
  477         sigemptyset(&stopsigmask);
  478         sigemptyset(&sigcantmask);
  479         for (signum = 1; signum < NSIG; signum++) {
  480                 prop = sigprop[signum];
  481                 if (prop & SA_CONT)
  482                         sigaddset(&contsigmask, signum);
  483                 if (prop & SA_STOP)
  484                         sigaddset(&stopsigmask, signum);
  485                 if (prop & SA_CANTMASK)
  486                         sigaddset(&sigcantmask, signum);
  487                 if (prop & SA_IGNORE && signum != SIGCONT)
  488                         sigaddset(&p->p_sigctx.ps_sigignore, signum);
  489                 sigemptyset(&SIGACTION_PS(ps, signum).sa_mask);
  490                 SIGACTION_PS(ps, signum).sa_flags = SA_RESTART;
  491         }
  492         sigemptyset(&p->p_sigctx.ps_sigcatch);
  493         p->p_sigctx.ps_sigwaited = NULL;
  494         p->p_flag &= ~P_NOCLDSTOP;
  495 
  496         /*
  497          * Reset stack state to the user stack.
  498          */
  499         p->p_sigctx.ps_sigstk.ss_flags = SS_DISABLE;
  500         p->p_sigctx.ps_sigstk.ss_size = 0;
  501         p->p_sigctx.ps_sigstk.ss_sp = 0;
  502 
  503         /* One reference. */
  504         ps->sa_refcnt = 1;
  505 }
  506 
  507 /*
  508  * Reset signals for an exec of the specified process.
  509  */
  510 void
  511 execsigs(struct proc *p)
  512 {
  513         struct sigacts  *ps;
  514         int             signum, prop;
  515 
  516         sigactsunshare(p);
  517 
  518         ps = p->p_sigacts;
  519 
  520         /*
  521          * Reset caught signals.  Held signals remain held
  522          * through p_sigctx.ps_sigmask (unless they were caught,
  523          * and are now ignored by default).
  524          */
  525         for (signum = 1; signum < NSIG; signum++) {
  526                 if (sigismember(&p->p_sigctx.ps_sigcatch, signum)) {
  527                         prop = sigprop[signum];
  528                         if (prop & SA_IGNORE) {
  529                                 if ((prop & SA_CONT) == 0)
  530                                         sigaddset(&p->p_sigctx.ps_sigignore,
  531                                             signum);
  532                                 sigdelset(&p->p_sigctx.ps_siglist, signum);
  533                         }
  534                         SIGACTION_PS(ps, signum).sa_handler = SIG_DFL;
  535                 }
  536                 sigemptyset(&SIGACTION_PS(ps, signum).sa_mask);
  537                 SIGACTION_PS(ps, signum).sa_flags = SA_RESTART;
  538         }
  539         sigemptyset(&p->p_sigctx.ps_sigcatch);
  540         p->p_sigctx.ps_sigwaited = NULL;
  541         p->p_flag &= ~P_NOCLDSTOP;
  542 
  543         /*
  544          * Reset stack state to the user stack.
  545          */
  546         p->p_sigctx.ps_sigstk.ss_flags = SS_DISABLE;
  547         p->p_sigctx.ps_sigstk.ss_size = 0;
  548         p->p_sigctx.ps_sigstk.ss_sp = 0;
  549 }
  550 
  551 int
  552 sigprocmask1(struct proc *p, int how, const sigset_t *nss, sigset_t *oss)
  553 {
  554 
  555         if (oss)
  556                 *oss = p->p_sigctx.ps_sigmask;
  557 
  558         if (nss) {
  559                 (void)splsched();       /* XXXSMP */
  560                 switch (how) {
  561                 case SIG_BLOCK:
  562                         sigplusset(nss, &p->p_sigctx.ps_sigmask);
  563                         break;
  564                 case SIG_UNBLOCK:
  565                         sigminusset(nss, &p->p_sigctx.ps_sigmask);
  566                         CHECKSIGS(p);
  567                         break;
  568                 case SIG_SETMASK:
  569                         p->p_sigctx.ps_sigmask = *nss;
  570                         CHECKSIGS(p);
  571                         break;
  572                 default:
  573                         (void)spl0();   /* XXXSMP */
  574                         return (EINVAL);
  575                 }
  576                 sigminusset(&sigcantmask, &p->p_sigctx.ps_sigmask);
  577                 (void)spl0();           /* XXXSMP */
  578         }
  579 
  580         return (0);
  581 }
  582 
  583 /*
  584  * Manipulate signal mask.
  585  * Note that we receive new mask, not pointer,
  586  * and return old mask as return value;
  587  * the library stub does the rest.
  588  */
  589 int
  590 sys___sigprocmask14(struct lwp *l, void *v, register_t *retval)
  591 {
  592         struct sys___sigprocmask14_args /* {
  593                 syscallarg(int)                 how;
  594                 syscallarg(const sigset_t *)    set;
  595                 syscallarg(sigset_t *)          oset;
  596         } */ *uap = v;
  597         struct proc     *p;
  598         sigset_t        nss, oss;
  599         int             error;
  600 
  601         if (SCARG(uap, set)) {
  602                 error = copyin(SCARG(uap, set), &nss, sizeof(nss));
  603                 if (error)
  604                         return (error);
  605         }
  606         p = l->l_proc;
  607         error = sigprocmask1(p, SCARG(uap, how),
  608             SCARG(uap, set) ? &nss : 0, SCARG(uap, oset) ? &oss : 0);
  609         if (error)
  610                 return (error);
  611         if (SCARG(uap, oset)) {
  612                 error = copyout(&oss, SCARG(uap, oset), sizeof(oss));
  613                 if (error)
  614                         return (error);
  615         }
  616         return (0);
  617 }
  618 
  619 void
  620 sigpending1(struct proc *p, sigset_t *ss)
  621 {
  622 
  623         *ss = p->p_sigctx.ps_siglist;
  624         sigminusset(&p->p_sigctx.ps_sigmask, ss);
  625 }
  626 
  627 /* ARGSUSED */
  628 int
  629 sys___sigpending14(struct lwp *l, void *v, register_t *retval)
  630 {
  631         struct sys___sigpending14_args /* {
  632                 syscallarg(sigset_t *)  set;
  633         } */ *uap = v;
  634         struct proc     *p;
  635         sigset_t        ss;
  636 
  637         p = l->l_proc;
  638         sigpending1(p, &ss);
  639         return (copyout(&ss, SCARG(uap, set), sizeof(ss)));
  640 }
  641 
  642 int
  643 sigsuspend1(struct proc *p, const sigset_t *ss)
  644 {
  645         struct sigacts *ps;
  646 
  647         ps = p->p_sigacts;
  648         if (ss) {
  649                 /*
  650                  * When returning from sigpause, we want
  651                  * the old mask to be restored after the
  652                  * signal handler has finished.  Thus, we
  653                  * save it here and mark the sigctx structure
  654                  * to indicate this.
  655                  */
  656                 p->p_sigctx.ps_oldmask = p->p_sigctx.ps_sigmask;
  657                 p->p_sigctx.ps_flags |= SAS_OLDMASK;
  658                 (void) splsched();      /* XXXSMP */
  659                 p->p_sigctx.ps_sigmask = *ss;
  660                 CHECKSIGS(p);
  661                 sigminusset(&sigcantmask, &p->p_sigctx.ps_sigmask);
  662                 (void) spl0();          /* XXXSMP */
  663         }
  664 
  665         while (tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0) == 0)
  666                 /* void */;
  667 
  668         /* always return EINTR rather than ERESTART... */
  669         return (EINTR);
  670 }
  671 
  672 /*
  673  * Suspend process until signal, providing mask to be set
  674  * in the meantime.  Note nonstandard calling convention:
  675  * libc stub passes mask, not pointer, to save a copyin.
  676  */
  677 /* ARGSUSED */
  678 int
  679 sys___sigsuspend14(struct lwp *l, void *v, register_t *retval)
  680 {
  681         struct sys___sigsuspend14_args /* {
  682                 syscallarg(const sigset_t *)    set;
  683         } */ *uap = v;
  684         struct proc     *p;
  685         sigset_t        ss;
  686         int             error;
  687 
  688         if (SCARG(uap, set)) {
  689                 error = copyin(SCARG(uap, set), &ss, sizeof(ss));
  690                 if (error)
  691                         return (error);
  692         }
  693 
  694         p = l->l_proc;
  695         return (sigsuspend1(p, SCARG(uap, set) ? &ss : 0));
  696 }
  697 
  698 int
  699 sigaltstack1(struct proc *p, const struct sigaltstack *nss,
  700         struct sigaltstack *oss)
  701 {
  702 
  703         if (oss)
  704                 *oss = p->p_sigctx.ps_sigstk;
  705 
  706         if (nss) {
  707                 if (nss->ss_flags & ~SS_ALLBITS)
  708                         return (EINVAL);
  709 
  710                 if (nss->ss_flags & SS_DISABLE) {
  711                         if (p->p_sigctx.ps_sigstk.ss_flags & SS_ONSTACK)
  712                                 return (EINVAL);
  713                 } else {
  714                         if (nss->ss_size < MINSIGSTKSZ)
  715                                 return (ENOMEM);
  716                 }
  717                 p->p_sigctx.ps_sigstk = *nss;
  718         }
  719 
  720         return (0);
  721 }
  722 
  723 /* ARGSUSED */
  724 int
  725 sys___sigaltstack14(struct lwp *l, void *v, register_t *retval)
  726 {
  727         struct sys___sigaltstack14_args /* {
  728                 syscallarg(const struct sigaltstack *)  nss;
  729                 syscallarg(struct sigaltstack *)        oss;
  730         } */ *uap = v;
  731         struct proc             *p;
  732         struct sigaltstack      nss, oss;
  733         int                     error;
  734 
  735         if (SCARG(uap, nss)) {
  736                 error = copyin(SCARG(uap, nss), &nss, sizeof(nss));
  737                 if (error)
  738                         return (error);
  739         }
  740         p = l->l_proc;
  741         error = sigaltstack1(p,
  742             SCARG(uap, nss) ? &nss : 0, SCARG(uap, oss) ? &oss : 0);
  743         if (error)
  744                 return (error);
  745         if (SCARG(uap, oss)) {
  746                 error = copyout(&oss, SCARG(uap, oss), sizeof(oss));
  747                 if (error)
  748                         return (error);
  749         }
  750         return (0);
  751 }
  752 
  753 /* ARGSUSED */
  754 int
  755 sys_kill(struct lwp *l, void *v, register_t *retval)
  756 {
  757         struct sys_kill_args /* {
  758                 syscallarg(int) pid;
  759                 syscallarg(int) signum;
  760         } */ *uap = v;
  761         struct proc     *cp, *p;
  762         struct pcred    *pc;
  763         ksiginfo_t      ksi;
  764 
  765         cp = l->l_proc;
  766         pc = cp->p_cred;
  767         if ((u_int)SCARG(uap, signum) >= NSIG)
  768                 return (EINVAL);
  769         KSI_INIT(&ksi);
  770         ksi.ksi_signo = SCARG(uap, signum);
  771         ksi.ksi_code = SI_USER;
  772         ksi.ksi_pid = cp->p_pid;
  773         ksi.ksi_uid = cp->p_ucred->cr_uid;
  774         if (SCARG(uap, pid) > 0) {
  775                 /* kill single process */
  776                 if ((p = pfind(SCARG(uap, pid))) == NULL)
  777                         return (ESRCH);
  778                 if (!CANSIGNAL(cp, pc, p, SCARG(uap, signum)))
  779                         return (EPERM);
  780                 if (SCARG(uap, signum))
  781                         kpsignal2(p, &ksi, 1);
  782                 return (0);
  783         }
  784         switch (SCARG(uap, pid)) {
  785         case -1:                /* broadcast signal */
  786                 return (killpg1(cp, &ksi, 0, 1));
  787         case 0:                 /* signal own process group */
  788                 return (killpg1(cp, &ksi, 0, 0));
  789         default:                /* negative explicit process group */
  790                 return (killpg1(cp, &ksi, -SCARG(uap, pid), 0));
  791         }
  792         /* NOTREACHED */
  793 }
  794 
  795 /*
  796  * Common code for kill process group/broadcast kill.
  797  * cp is calling process.
  798  */
  799 int
  800 killpg1(struct proc *cp, ksiginfo_t *ksi, int pgid, int all)
  801 {
  802         struct proc     *p;
  803         struct pcred    *pc;
  804         struct pgrp     *pgrp;
  805         int             nfound;
  806         int             signum = ksi->ksi_signo;
  807 
  808         pc = cp->p_cred;
  809         nfound = 0;
  810         if (all) {
  811                 /*
  812                  * broadcast
  813                  */
  814                 proclist_lock_read();
  815                 PROCLIST_FOREACH(p, &allproc) {
  816                         if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
  817                             p == cp || !CANSIGNAL(cp, pc, p, signum))
  818                                 continue;
  819                         nfound++;
  820                         if (signum)
  821                                 kpsignal2(p, ksi, 1);
  822                 }
  823                 proclist_unlock_read();
  824         } else {
  825                 if (pgid == 0)
  826                         /*
  827                          * zero pgid means send to my process group.
  828                          */
  829                         pgrp = cp->p_pgrp;
  830                 else {
  831                         pgrp = pgfind(pgid);
  832                         if (pgrp == NULL)
  833                                 return (ESRCH);
  834                 }
  835                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
  836                         if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
  837                             !CANSIGNAL(cp, pc, p, signum))
  838                                 continue;
  839                         nfound++;
  840                         if (signum && P_ZOMBIE(p) == 0)
  841                                 kpsignal2(p, ksi, 1);
  842                 }
  843         }
  844         return (nfound ? 0 : ESRCH);
  845 }
  846 
  847 /*
  848  * Send a signal to a process group.
  849  */
  850 void
  851 gsignal(int pgid, int signum)
  852 {
  853         ksiginfo_t ksi;
  854         KSI_INIT_EMPTY(&ksi);
  855         ksi.ksi_signo = signum;
  856         kgsignal(pgid, &ksi, NULL);
  857 }
  858 
  859 void
  860 kgsignal(int pgid, ksiginfo_t *ksi, void *data)
  861 {
  862         struct pgrp *pgrp;
  863 
  864         if (pgid && (pgrp = pgfind(pgid)))
  865                 kpgsignal(pgrp, ksi, data, 0);
  866 }
  867 
  868 /*
  869  * Send a signal to a process group. If checktty is 1,
  870  * limit to members which have a controlling terminal.
  871  */
  872 void
  873 pgsignal(struct pgrp *pgrp, int sig, int checkctty)
  874 {
  875         ksiginfo_t ksi;
  876         KSI_INIT_EMPTY(&ksi);
  877         ksi.ksi_signo = sig;
  878         kpgsignal(pgrp, &ksi, NULL, checkctty);
  879 }
  880 
  881 void
  882 kpgsignal(struct pgrp *pgrp, ksiginfo_t *ksi, void *data, int checkctty)
  883 {
  884         struct proc *p;
  885 
  886         if (pgrp)
  887                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
  888                         if (checkctty == 0 || p->p_flag & P_CONTROLT)
  889                                 kpsignal(p, ksi, data);
  890 }
  891 
  892 /*
  893  * Send a signal caused by a trap to the current process.
  894  * If it will be caught immediately, deliver it with correct code.
  895  * Otherwise, post it normally.
  896  */
  897 void
  898 trapsignal(struct lwp *l, const ksiginfo_t *ksi)
  899 {
  900         struct proc     *p;
  901         struct sigacts  *ps;
  902         int signum = ksi->ksi_signo;
  903 
  904         KASSERT(KSI_TRAP_P(ksi));
  905 
  906         p = l->l_proc;
  907         ps = p->p_sigacts;
  908         if ((p->p_flag & P_TRACED) == 0 &&
  909             sigismember(&p->p_sigctx.ps_sigcatch, signum) &&
  910             !sigismember(&p->p_sigctx.ps_sigmask, signum)) {
  911                 p->p_stats->p_ru.ru_nsignals++;
  912 #ifdef KTRACE
  913                 if (KTRPOINT(p, KTR_PSIG))
  914                         ktrpsig(p, signum, SIGACTION_PS(ps, signum).sa_handler,
  915                             &p->p_sigctx.ps_sigmask, ksi);
  916 #endif
  917                 kpsendsig(l, ksi, &p->p_sigctx.ps_sigmask);
  918                 (void) splsched();      /* XXXSMP */
  919                 sigplusset(&SIGACTION_PS(ps, signum).sa_mask,
  920                     &p->p_sigctx.ps_sigmask);
  921                 if (SIGACTION_PS(ps, signum).sa_flags & SA_RESETHAND) {
  922                         sigdelset(&p->p_sigctx.ps_sigcatch, signum);
  923                         if (signum != SIGCONT && sigprop[signum] & SA_IGNORE)
  924                                 sigaddset(&p->p_sigctx.ps_sigignore, signum);
  925                         SIGACTION_PS(ps, signum).sa_handler = SIG_DFL;
  926                 }
  927                 (void) spl0();          /* XXXSMP */
  928         } else {
  929                 p->p_sigctx.ps_lwp = l->l_lid;
  930                 /* XXX for core dump/debugger */
  931                 p->p_sigctx.ps_signo = ksi->ksi_signo;
  932                 p->p_sigctx.ps_code = ksi->ksi_trap;
  933                 kpsignal2(p, ksi, 1);
  934         }
  935 }
  936 
  937 /*
  938  * Fill in signal information and signal the parent for a child status change.
  939  */
  940 static void
  941 child_psignal(struct proc *p, int dolock)
  942 {
  943         ksiginfo_t ksi;
  944 
  945         KSI_INIT(&ksi);
  946         ksi.ksi_signo = SIGCHLD;
  947         ksi.ksi_code = p->p_xstat == SIGCONT ? CLD_CONTINUED : CLD_STOPPED;
  948         ksi.ksi_pid = p->p_pid;
  949         ksi.ksi_uid = p->p_ucred->cr_uid;
  950         ksi.ksi_status = p->p_xstat;
  951         ksi.ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec;
  952         ksi.ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec;
  953         kpsignal2(p->p_pptr, &ksi, dolock);
  954 }
  955 
  956 /*
  957  * Send the signal to the process.  If the signal has an action, the action
  958  * is usually performed by the target process rather than the caller; we add
  959  * the signal to the set of pending signals for the process.
  960  *
  961  * Exceptions:
  962  *   o When a stop signal is sent to a sleeping process that takes the
  963  *     default action, the process is stopped without awakening it.
  964  *   o SIGCONT restarts stopped processes (or puts them back to sleep)
  965  *     regardless of the signal action (eg, blocked or ignored).
  966  *
  967  * Other ignored signals are discarded immediately.
  968  *
  969  * XXXSMP: Invoked as psignal() or sched_psignal().
  970  */
  971 void
  972 psignal1(struct proc *p, int signum, int dolock)
  973 {
  974         ksiginfo_t ksi;
  975 
  976         KSI_INIT_EMPTY(&ksi);
  977         ksi.ksi_signo = signum;
  978         kpsignal2(p, &ksi, dolock);
  979 }
  980 
  981 void
  982 kpsignal1(struct proc *p, ksiginfo_t *ksi, void *data, int dolock)
  983 {
  984 
  985         if ((p->p_flag & P_WEXIT) == 0 && data) {
  986                 size_t fd;
  987                 struct filedesc *fdp = p->p_fd;
  988 
  989                 ksi->ksi_fd = -1;
  990                 for (fd = 0; fd < fdp->fd_nfiles; fd++) {
  991                         struct file *fp = fdp->fd_ofiles[fd];
  992                         /* XXX: lock? */
  993                         if (fp && fp->f_data == data) {
  994                                 ksi->ksi_fd = fd;
  995                                 break;
  996                         }
  997                 }
  998         }
  999         kpsignal2(p, ksi, dolock);
 1000 }
 1001 
 1002 static void
 1003 kpsignal2(struct proc *p, const ksiginfo_t *ksi, int dolock)
 1004 {
 1005         struct lwp *l, *suspended = NULL;
 1006         struct sadata_vp *vp;
 1007         int     s = 0, prop, allsusp;
 1008         sig_t   action;
 1009         int     signum = ksi->ksi_signo;
 1010 
 1011 #ifdef DIAGNOSTIC
 1012         if (signum <= 0 || signum >= NSIG)
 1013                 panic("psignal signal number %d", signum);
 1014 
 1015         /* XXXSMP: works, but icky */
 1016         if (dolock)
 1017                 SCHED_ASSERT_UNLOCKED();
 1018         else
 1019                 SCHED_ASSERT_LOCKED();
 1020 #endif
 1021 
 1022         /*
 1023          * Notify any interested parties in the signal.
 1024          */
 1025         KNOTE(&p->p_klist, NOTE_SIGNAL | signum);
 1026 
 1027         prop = sigprop[signum];
 1028 
 1029         /*
 1030          * If proc is traced, always give parent a chance.
 1031          */
 1032         if (p->p_flag & P_TRACED) {
 1033                 action = SIG_DFL;
 1034 
 1035                 /*
 1036                  * If the process is being traced and the signal is being
 1037                  * caught, make sure to save any ksiginfo.
 1038                  */
 1039                 if (sigismember(&p->p_sigctx.ps_sigcatch, signum))
 1040                         ksiginfo_put(p, ksi);
 1041         } else {
 1042                 /*
 1043                  * If the signal was the result of a trap, reset it
 1044                  * to default action if it's currently masked, so that it would
 1045                  * coredump immediatelly instead of spinning repeatedly
 1046                  * taking the signal.
 1047                  */
 1048                 if (KSI_TRAP_P(ksi)
 1049                     && sigismember(&p->p_sigctx.ps_sigmask, signum)
 1050                     && !sigismember(&p->p_sigctx.ps_sigcatch, signum)) {
 1051                         sigdelset(&p->p_sigctx.ps_sigignore, signum);
 1052                         sigdelset(&p->p_sigctx.ps_sigcatch, signum);
 1053                         sigdelset(&p->p_sigctx.ps_sigmask, signum);
 1054                         SIGACTION(p, signum).sa_handler = SIG_DFL;
 1055                 }
 1056 
 1057                 /*
 1058                  * If the signal is being ignored,
 1059                  * then we forget about it immediately.
 1060                  * (Note: we don't set SIGCONT in p_sigctx.ps_sigignore,
 1061                  * and if it is set to SIG_IGN,
 1062                  * action will be SIG_DFL here.)
 1063                  */
 1064                 if (sigismember(&p->p_sigctx.ps_sigignore, signum))
 1065                         return;
 1066                 if (sigismember(&p->p_sigctx.ps_sigmask, signum))
 1067                         action = SIG_HOLD;
 1068                 else if (sigismember(&p->p_sigctx.ps_sigcatch, signum))
 1069                         action = SIG_CATCH;
 1070                 else {
 1071                         action = SIG_DFL;
 1072 
 1073                         if (prop & SA_KILL && p->p_nice > NZERO)
 1074                                 p->p_nice = NZERO;
 1075 
 1076                         /*
 1077                          * If sending a tty stop signal to a member of an
 1078                          * orphaned process group, discard the signal here if
 1079                          * the action is default; don't stop the process below
 1080                          * if sleeping, and don't clear any pending SIGCONT.
 1081                          */
 1082                         if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0)
 1083                                 return;
 1084                 }
 1085         }
 1086 
 1087         if (prop & SA_CONT)
 1088                 sigminusset(&stopsigmask, &p->p_sigctx.ps_siglist);
 1089 
 1090         if (prop & SA_STOP)
 1091                 sigminusset(&contsigmask, &p->p_sigctx.ps_siglist);
 1092 
 1093         /*
 1094          * If the signal doesn't have SA_CANTMASK (no override for SIGKILL,
 1095          * please!), check if anything waits on it. If yes, save the
 1096          * info into provided ps_sigwaited, and wake-up the waiter.
 1097          * The signal won't be processed further here.
 1098          */
 1099         if ((prop & SA_CANTMASK) == 0
 1100             && p->p_sigctx.ps_sigwaited
 1101             && sigismember(p->p_sigctx.ps_sigwait, signum)
 1102             && p->p_stat != SSTOP) {
 1103                 p->p_sigctx.ps_sigwaited->ksi_info = ksi->ksi_info;
 1104                 p->p_sigctx.ps_sigwaited = NULL;
 1105                 if (dolock)
 1106                         wakeup_one(&p->p_sigctx.ps_sigwait);
 1107                 else
 1108                         sched_wakeup(&p->p_sigctx.ps_sigwait);
 1109                 return;
 1110         }
 1111 
 1112         sigaddset(&p->p_sigctx.ps_siglist, signum);
 1113 
 1114         /* CHECKSIGS() is "inlined" here. */
 1115         p->p_sigctx.ps_sigcheck = 1;
 1116 
 1117         /*
 1118          * Defer further processing for signals which are held,
 1119          * except that stopped processes must be continued by SIGCONT.
 1120          */
 1121         if (action == SIG_HOLD &&
 1122             ((prop & SA_CONT) == 0 || p->p_stat != SSTOP)) {
 1123                 ksiginfo_put(p, ksi);
 1124                 return;
 1125         }
 1126         /* XXXSMP: works, but icky */
 1127         if (dolock)
 1128                 SCHED_LOCK(s);
 1129 
 1130         if (p->p_flag & P_SA) {
 1131                 allsusp = 0;
 1132                 l = NULL;
 1133                 if (p->p_stat == SACTIVE) {
 1134                         SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 1135                                 l = vp->savp_lwp;
 1136                                 KDASSERT(l != NULL);
 1137                                 if (l->l_flag & L_SA_IDLE) {
 1138                                         /* wakeup idle LWP */
 1139                                         goto found;
 1140                                         /*NOTREACHED*/
 1141                                 } else if (l->l_flag & L_SA_YIELD) {
 1142                                         /* idle LWP is already waking up */
 1143                                         goto out;
 1144                                         /*NOTREACHED*/
 1145                                 }
 1146                         }
 1147                         SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 1148                                 l = vp->savp_lwp;
 1149                                 if (l->l_stat == LSRUN ||
 1150                                     l->l_stat == LSONPROC) {
 1151                                         signotify(p);
 1152                                         goto out;
 1153                                         /*NOTREACHED*/
 1154                                 }
 1155                                 if (l->l_stat == LSSLEEP &&
 1156                                     l->l_flag & L_SINTR) {
 1157                                         /* ok to signal vp lwp */
 1158                                         break;
 1159                                 } else
 1160                                         l = NULL;
 1161                         }
 1162                 } else if (p->p_stat == SSTOP) {
 1163                         SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 1164                                 l = vp->savp_lwp;
 1165                                 if (l->l_stat == LSSLEEP && (l->l_flag & L_SINTR) != 0)
 1166                                         break;
 1167                                 l = NULL;
 1168                         }
 1169                 }
 1170         } else if (p->p_nrlwps > 0 && (p->p_stat != SSTOP)) {
 1171                 /*
 1172                  * At least one LWP is running or on a run queue.
 1173                  * The signal will be noticed when one of them returns
 1174                  * to userspace.
 1175                  */
 1176                 signotify(p);
 1177                 /*
 1178                  * The signal will be noticed very soon.
 1179                  */
 1180                 goto out;
 1181                 /*NOTREACHED*/
 1182         } else {
 1183                 /*
 1184                  * Find out if any of the sleeps are interruptable,
 1185                  * and if all the live LWPs remaining are suspended.
 1186                  */
 1187                 allsusp = 1;
 1188                 LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 1189                         if (l->l_stat == LSSLEEP &&
 1190                             l->l_flag & L_SINTR)
 1191                                 break;
 1192                         if (l->l_stat == LSSUSPENDED)
 1193                                 suspended = l;
 1194                         else if ((l->l_stat != LSZOMB) &&
 1195                             (l->l_stat != LSDEAD))
 1196                                 allsusp = 0;
 1197                 }
 1198         }
 1199 
 1200  found:
 1201         switch (p->p_stat) {
 1202         case SACTIVE:
 1203 
 1204                 if (l != NULL && (p->p_flag & P_TRACED))
 1205                         goto run;
 1206 
 1207                 /*
 1208                  * If SIGCONT is default (or ignored) and process is
 1209                  * asleep, we are finished; the process should not
 1210                  * be awakened.
 1211                  */
 1212                 if ((prop & SA_CONT) && action == SIG_DFL) {
 1213                         sigdelset(&p->p_sigctx.ps_siglist, signum);
 1214                         goto done;
 1215                 }
 1216 
 1217                 /*
 1218                  * When a sleeping process receives a stop
 1219                  * signal, process immediately if possible.
 1220                  */
 1221                 if ((prop & SA_STOP) && action == SIG_DFL) {
 1222                         /*
 1223                          * If a child holding parent blocked,
 1224                          * stopping could cause deadlock.
 1225                          */
 1226                         if (p->p_flag & P_PPWAIT) {
 1227                                 goto out;
 1228                         }
 1229                         sigdelset(&p->p_sigctx.ps_siglist, signum);
 1230                         p->p_xstat = signum;
 1231                         if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0) {
 1232                                 /*
 1233                                  * XXXSMP: recursive call; don't lock
 1234                                  * the second time around.
 1235                                  */
 1236                                 child_psignal(p, 0);
 1237                         }
 1238                         proc_stop(p, 1);        /* XXXSMP: recurse? */
 1239                         goto done;
 1240                 }
 1241 
 1242                 if (l == NULL) {
 1243                         /*
 1244                          * Special case: SIGKILL of a process
 1245                          * which is entirely composed of
 1246                          * suspended LWPs should succeed. We
 1247                          * make this happen by unsuspending one of
 1248                          * them.
 1249                          */
 1250                         if (allsusp && (signum == SIGKILL)) {
 1251                                 lwp_continue(suspended);
 1252                         }
 1253                         goto done;
 1254                 }
 1255                 /*
 1256                  * All other (caught or default) signals
 1257                  * cause the process to run.
 1258                  */
 1259                 goto runfast;
 1260                 /*NOTREACHED*/
 1261         case SSTOP:
 1262                 /* Process is stopped */
 1263                 /*
 1264                  * If traced process is already stopped,
 1265                  * then no further action is necessary.
 1266                  */
 1267                 if (p->p_flag & P_TRACED)
 1268                         goto done;
 1269 
 1270                 /*
 1271                  * Kill signal always sets processes running,
 1272                  * if possible.
 1273                  */
 1274                 if (signum == SIGKILL) {
 1275                         l = proc_unstop(p);
 1276                         if (l)
 1277                                 goto runfast;
 1278                         goto done;
 1279                 }
 1280 
 1281                 if (prop & SA_CONT) {
 1282                         /*
 1283                          * If SIGCONT is default (or ignored),
 1284                          * we continue the process but don't
 1285                          * leave the signal in ps_siglist, as
 1286                          * it has no further action.  If
 1287                          * SIGCONT is held, we continue the
 1288                          * process and leave the signal in
 1289                          * ps_siglist.  If the process catches
 1290                          * SIGCONT, let it handle the signal
 1291                          * itself.  If it isn't waiting on an
 1292                          * event, then it goes back to run
 1293                          * state.  Otherwise, process goes
 1294                          * back to sleep state.
 1295                          */
 1296                         if (action == SIG_DFL)
 1297                                 sigdelset(&p->p_sigctx.ps_siglist,
 1298                                     signum);
 1299                         l = proc_unstop(p);
 1300                         if (l && (action == SIG_CATCH))
 1301                                 goto runfast;
 1302                         goto out;
 1303                 }
 1304 
 1305                 if (prop & SA_STOP) {
 1306                         /*
 1307                          * Already stopped, don't need to stop again.
 1308                          * (If we did the shell could get confused.)
 1309                          */
 1310                         sigdelset(&p->p_sigctx.ps_siglist, signum);
 1311                         goto done;
 1312                 }
 1313 
 1314                 /*
 1315                  * If a lwp is sleeping interruptibly, then
 1316                  * wake it up; it will run until the kernel
 1317                  * boundary, where it will stop in issignal(),
 1318                  * since p->p_stat is still SSTOP. When the
 1319                  * process is continued, it will be made
 1320                  * runnable and can look at the signal.
 1321                  */
 1322                 if (l)
 1323                         goto run;
 1324                 goto out;
 1325         case SIDL:
 1326                 /* Process is being created by fork */
 1327                 /* XXX: We are not ready to receive signals yet */
 1328                 goto done;
 1329         default:
 1330                 /* Else what? */
 1331                 panic("psignal: Invalid process state %d.", p->p_stat);
 1332         }
 1333         /*NOTREACHED*/
 1334 
 1335  runfast:
 1336         if (action == SIG_CATCH) {
 1337                 ksiginfo_put(p, ksi);
 1338                 action = SIG_HOLD;
 1339         }
 1340         /*
 1341          * Raise priority to at least PUSER.
 1342          */
 1343         if (l->l_priority > PUSER)
 1344                 l->l_priority = PUSER;
 1345  run:
 1346         if (action == SIG_CATCH) {
 1347                 ksiginfo_put(p, ksi);
 1348                 action = SIG_HOLD;
 1349         }
 1350 
 1351         setrunnable(l);         /* XXXSMP: recurse? */
 1352  out:
 1353         if (action == SIG_CATCH)
 1354                 ksiginfo_put(p, ksi);
 1355  done:
 1356         /* XXXSMP: works, but icky */
 1357         if (dolock)
 1358                 SCHED_UNLOCK(s);
 1359 }
 1360 
 1361 siginfo_t *
 1362 siginfo_alloc(int flags)
 1363 {
 1364 
 1365         return pool_get(&siginfo_pool, flags);
 1366 }
 1367 
 1368 void
 1369 siginfo_free(void *arg)
 1370 {
 1371 
 1372         pool_put(&siginfo_pool, arg);
 1373 }
 1374 
 1375 void
 1376 kpsendsig(struct lwp *l, const ksiginfo_t *ksi, const sigset_t *mask)
 1377 {
 1378         struct proc *p = l->l_proc;
 1379         struct lwp *le, *li;
 1380         siginfo_t *si;
 1381         int f;
 1382 
 1383         if (p->p_flag & P_SA) {
 1384 
 1385                 /* XXXUPSXXX What if not on sa_vp ? */
 1386 
 1387                 f = l->l_flag & L_SA;
 1388                 l->l_flag &= ~L_SA;
 1389                 si = siginfo_alloc(PR_WAITOK);
 1390                 si->_info = ksi->ksi_info;
 1391                 le = li = NULL;
 1392                 if (KSI_TRAP_P(ksi))
 1393                         le = l;
 1394                 else
 1395                         li = l;
 1396                 if (sa_upcall(l, SA_UPCALL_SIGNAL | SA_UPCALL_DEFER, le, li,
 1397                     sizeof(*si), si, siginfo_free) != 0) {
 1398                         siginfo_free(si);
 1399                         if (KSI_TRAP_P(ksi))
 1400                                 /* XXX What do we do here?? */;
 1401                 }
 1402                 l->l_flag |= f;
 1403                 return;
 1404         }
 1405 
 1406         (*p->p_emul->e_sendsig)(ksi, mask);
 1407 }
 1408 
 1409 static __inline int firstsig(const sigset_t *);
 1410 
 1411 static __inline int
 1412 firstsig(const sigset_t *ss)
 1413 {
 1414         int sig;
 1415 
 1416         sig = ffs(ss->__bits[0]);
 1417         if (sig != 0)
 1418                 return (sig);
 1419 #if NSIG > 33
 1420         sig = ffs(ss->__bits[1]);
 1421         if (sig != 0)
 1422                 return (sig + 32);
 1423 #endif
 1424 #if NSIG > 65
 1425         sig = ffs(ss->__bits[2]);
 1426         if (sig != 0)
 1427                 return (sig + 64);
 1428 #endif
 1429 #if NSIG > 97
 1430         sig = ffs(ss->__bits[3]);
 1431         if (sig != 0)
 1432                 return (sig + 96);
 1433 #endif
 1434         return (0);
 1435 }
 1436 
 1437 /*
 1438  * If the current process has received a signal (should be caught or cause
 1439  * termination, should interrupt current syscall), return the signal number.
 1440  * Stop signals with default action are processed immediately, then cleared;
 1441  * they aren't returned.  This is checked after each entry to the system for
 1442  * a syscall or trap (though this can usually be done without calling issignal
 1443  * by checking the pending signal masks in the CURSIG macro.) The normal call
 1444  * sequence is
 1445  *
 1446  *      while (signum = CURSIG(curlwp))
 1447  *              postsig(signum);
 1448  */
 1449 int
 1450 issignal(struct lwp *l)
 1451 {
 1452         struct proc     *p = l->l_proc;
 1453         int             s = 0, signum, prop;
 1454         int             dolock = (l->l_flag & L_SINTR) == 0, locked = !dolock;
 1455         sigset_t        ss;
 1456 
 1457         /* Bail out if we do not own the virtual processor */
 1458         if (l->l_flag & L_SA && l->l_savp->savp_lwp != l)
 1459                 return 0;
 1460 
 1461         if (p->p_stat == SSTOP) {
 1462                 /*
 1463                  * The process is stopped/stopping. Stop ourselves now that
 1464                  * we're on the kernel/userspace boundary.
 1465                  */
 1466                 if (dolock)
 1467                         SCHED_LOCK(s);
 1468                 l->l_stat = LSSTOP;
 1469                 p->p_nrlwps--;
 1470                 if (p->p_flag & P_TRACED)
 1471                         goto sigtraceswitch;
 1472                 else
 1473                         goto sigswitch;
 1474         }
 1475         for (;;) {
 1476                 sigpending1(p, &ss);
 1477                 if (p->p_flag & P_PPWAIT)
 1478                         sigminusset(&stopsigmask, &ss);
 1479                 signum = firstsig(&ss);
 1480                 if (signum == 0) {                      /* no signal to send */
 1481                         p->p_sigctx.ps_sigcheck = 0;
 1482                         if (locked && dolock)
 1483                                 SCHED_LOCK(s);
 1484                         return (0);
 1485                 }
 1486                                                         /* take the signal! */
 1487                 sigdelset(&p->p_sigctx.ps_siglist, signum);
 1488 
 1489                 /*
 1490                  * We should see pending but ignored signals
 1491                  * only if P_TRACED was on when they were posted.
 1492                  */
 1493                 if (sigismember(&p->p_sigctx.ps_sigignore, signum) &&
 1494                     (p->p_flag & P_TRACED) == 0)
 1495                         continue;
 1496 
 1497                 if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) {
 1498                         /*
 1499                          * If traced, always stop, and stay
 1500                          * stopped until released by the debugger.
 1501                          */
 1502                         p->p_xstat = signum;
 1503 
 1504                         /* Emulation-specific handling of signal trace */
 1505                         if ((p->p_emul->e_tracesig != NULL) &&
 1506                             ((*p->p_emul->e_tracesig)(p, signum) != 0))
 1507                                 goto childresumed;
 1508 
 1509                         if ((p->p_flag & P_FSTRACE) == 0)
 1510                                 child_psignal(p, dolock);
 1511                         if (dolock)
 1512                                 SCHED_LOCK(s);
 1513                         proc_stop(p, 1);
 1514                 sigtraceswitch:
 1515                         mi_switch(l, NULL);
 1516                         SCHED_ASSERT_UNLOCKED();
 1517                         if (dolock)
 1518                                 splx(s);
 1519                         else
 1520                                 dolock = 1;
 1521 
 1522                 childresumed:
 1523                         /*
 1524                          * If we are no longer being traced, or the parent
 1525                          * didn't give us a signal, look for more signals.
 1526                          */
 1527                         if ((p->p_flag & P_TRACED) == 0 || p->p_xstat == 0)
 1528                                 continue;
 1529 
 1530                         /*
 1531                          * If the new signal is being masked, look for other
 1532                          * signals.
 1533                          */
 1534                         signum = p->p_xstat;
 1535                         p->p_xstat = 0;
 1536                         /*
 1537                          * `p->p_sigctx.ps_siglist |= mask' is done
 1538                          * in setrunnable().
 1539                          */
 1540                         if (sigismember(&p->p_sigctx.ps_sigmask, signum))
 1541                                 continue;
 1542                                                         /* take the signal! */
 1543                         sigdelset(&p->p_sigctx.ps_siglist, signum);
 1544                 }
 1545 
 1546                 prop = sigprop[signum];
 1547 
 1548                 /*
 1549                  * Decide whether the signal should be returned.
 1550                  * Return the signal's number, or fall through
 1551                  * to clear it from the pending mask.
 1552                  */
 1553                 switch ((long)SIGACTION(p, signum).sa_handler) {
 1554 
 1555                 case (long)SIG_DFL:
 1556                         /*
 1557                          * Don't take default actions on system processes.
 1558                          */
 1559                         if (p->p_pid <= 1) {
 1560 #ifdef DIAGNOSTIC
 1561                                 /*
 1562                                  * Are you sure you want to ignore SIGSEGV
 1563                                  * in init? XXX
 1564                                  */
 1565                                 printf("Process (pid %d) got signal %d\n",
 1566                                     p->p_pid, signum);
 1567 #endif
 1568                                 break;          /* == ignore */
 1569                         }
 1570                         /*
 1571                          * If there is a pending stop signal to process
 1572                          * with default action, stop here,
 1573                          * then clear the signal.  However,
 1574                          * if process is member of an orphaned
 1575                          * process group, ignore tty stop signals.
 1576                          */
 1577                         if (prop & SA_STOP) {
 1578                                 if (p->p_flag & P_TRACED ||
 1579                                     (p->p_pgrp->pg_jobc == 0 &&
 1580                                     prop & SA_TTYSTOP))
 1581                                         break;  /* == ignore */
 1582                                 p->p_xstat = signum;
 1583                                 if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
 1584                                         child_psignal(p, dolock);
 1585                                 if (dolock)
 1586                                         SCHED_LOCK(s);
 1587                                 proc_stop(p, 1);
 1588                         sigswitch:
 1589                                 mi_switch(l, NULL);
 1590                                 SCHED_ASSERT_UNLOCKED();
 1591                                 if (dolock)
 1592                                         splx(s);
 1593                                 else
 1594                                         dolock = 1;
 1595                                 break;
 1596                         } else if (prop & SA_IGNORE) {
 1597                                 /*
 1598                                  * Except for SIGCONT, shouldn't get here.
 1599                                  * Default action is to ignore; drop it.
 1600                                  */
 1601                                 break;          /* == ignore */
 1602                         } else
 1603                                 goto keep;
 1604                         /*NOTREACHED*/
 1605 
 1606                 case (long)SIG_IGN:
 1607                         /*
 1608                          * Masking above should prevent us ever trying
 1609                          * to take action on an ignored signal other
 1610                          * than SIGCONT, unless process is traced.
 1611                          */
 1612 #ifdef DEBUG_ISSIGNAL
 1613                         if ((prop & SA_CONT) == 0 &&
 1614                             (p->p_flag & P_TRACED) == 0)
 1615                                 printf("issignal\n");
 1616 #endif
 1617                         break;          /* == ignore */
 1618 
 1619                 default:
 1620                         /*
 1621                          * This signal has an action, let
 1622                          * postsig() process it.
 1623                          */
 1624                         goto keep;
 1625                 }
 1626         }
 1627         /* NOTREACHED */
 1628 
 1629  keep:
 1630                                                 /* leave the signal for later */
 1631         sigaddset(&p->p_sigctx.ps_siglist, signum);
 1632         CHECKSIGS(p);
 1633         if (locked && dolock)
 1634                 SCHED_LOCK(s);
 1635         return (signum);
 1636 }
 1637 
 1638 /*
 1639  * Put the argument process into the stopped state and notify the parent
 1640  * via wakeup.  Signals are handled elsewhere.  The process must not be
 1641  * on the run queue.
 1642  */
 1643 void
 1644 proc_stop(struct proc *p, int wakeup)
 1645 {
 1646         struct lwp *l;
 1647         struct proc *parent;
 1648         struct sadata_vp *vp;
 1649 
 1650         SCHED_ASSERT_LOCKED();
 1651 
 1652         /* XXX lock process LWP state */
 1653         p->p_flag &= ~P_WAITED;
 1654         p->p_stat = SSTOP;
 1655         parent = p->p_pptr;
 1656         parent->p_nstopchild++;
 1657 
 1658         if (p->p_flag & P_SA) {
 1659                 /*
 1660                  * Only (try to) put the LWP on the VP in stopped
 1661                  * state.
 1662                  * All other LWPs will suspend in sa_setwoken()
 1663                  * because the VP-LWP in stopped state cannot be
 1664                  * repossessed.
 1665                  */
 1666                 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 1667                         l = vp->savp_lwp;
 1668                         if (l->l_stat == LSONPROC && l->l_cpu == curcpu()) {
 1669                                 l->l_stat = LSSTOP;
 1670                                 p->p_nrlwps--;
 1671                         } else if (l->l_stat == LSRUN) {
 1672                                 /* Remove LWP from the run queue */
 1673                                 remrunqueue(l);
 1674                                 l->l_stat = LSSTOP;
 1675                                 p->p_nrlwps--;
 1676                         } else if (l->l_stat == LSSLEEP &&
 1677                             l->l_flag & L_SA_IDLE) {
 1678                                 l->l_flag &= ~L_SA_IDLE;
 1679                                 l->l_stat = LSSTOP;
 1680                         }
 1681                 }
 1682                 goto out;
 1683         }
 1684 
 1685         /*
 1686          * Put as many LWP's as possible in stopped state.
 1687          * Sleeping ones will notice the stopped state as they try to
 1688          * return to userspace.
 1689          */
 1690 
 1691         LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 1692                 if (l->l_stat == LSONPROC) {
 1693                         /* XXX SMP this assumes that a LWP that is LSONPROC
 1694                          * is curlwp and hence is about to be mi_switched
 1695                          * away; the only callers of proc_stop() are:
 1696                          * - psignal
 1697                          * - issignal()
 1698                          * For the former, proc_stop() is only called when
 1699                          * no processes are running, so we don't worry.
 1700                          * For the latter, proc_stop() is called right
 1701                          * before mi_switch().
 1702                          */
 1703                         l->l_stat = LSSTOP;
 1704                         p->p_nrlwps--;
 1705                 } else if (l->l_stat == LSRUN) {
 1706                         /* Remove LWP from the run queue */
 1707                         remrunqueue(l);
 1708                         l->l_stat = LSSTOP;
 1709                         p->p_nrlwps--;
 1710                 } else if ((l->l_stat == LSSLEEP) ||
 1711                     (l->l_stat == LSSUSPENDED) ||
 1712                     (l->l_stat == LSZOMB) ||
 1713                     (l->l_stat == LSDEAD)) {
 1714                         /*
 1715                          * Don't do anything; let sleeping LWPs
 1716                          * discover the stopped state of the process
 1717                          * on their way out of the kernel; otherwise,
 1718                          * things like NFS threads that sleep with
 1719                          * locks will block the rest of the system
 1720                          * from getting any work done.
 1721                          *
 1722                          * Suspended/dead/zombie LWPs aren't going
 1723                          * anywhere, so we don't need to touch them.
 1724                          */
 1725                 }
 1726 #ifdef DIAGNOSTIC
 1727                 else {
 1728                         panic("proc_stop: process %d lwp %d "
 1729                               "in unstoppable state %d.\n",
 1730                             p->p_pid, l->l_lid, l->l_stat);
 1731                 }
 1732 #endif
 1733         }
 1734 
 1735  out:
 1736         /* XXX unlock process LWP state */
 1737 
 1738         if (wakeup)
 1739                 sched_wakeup((caddr_t)p->p_pptr);
 1740 }
 1741 
 1742 /*
 1743  * Given a process in state SSTOP, set the state back to SACTIVE and
 1744  * move LSSTOP'd LWPs to LSSLEEP or make them runnable.
 1745  *
 1746  * If no LWPs ended up runnable (and therefore able to take a signal),
 1747  * return a LWP that is sleeping interruptably. The caller can wake
 1748  * that LWP up to take a signal.
 1749  */
 1750 struct lwp *
 1751 proc_unstop(struct proc *p)
 1752 {
 1753         struct lwp *l, *lr = NULL;
 1754         struct sadata_vp *vp;
 1755         int cantake = 0;
 1756 
 1757         SCHED_ASSERT_LOCKED();
 1758 
 1759         /*
 1760          * Our caller wants to be informed if there are only sleeping
 1761          * and interruptable LWPs left after we have run so that it
 1762          * can invoke setrunnable() if required - return one of the
 1763          * interruptable LWPs if this is the case.
 1764          */
 1765 
 1766         if (!(p->p_flag & P_WAITED))
 1767                 p->p_pptr->p_nstopchild--;
 1768         p->p_stat = SACTIVE;
 1769         LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 1770                 if (l->l_stat == LSRUN) {
 1771                         lr = NULL;
 1772                         cantake = 1;
 1773                 }
 1774                 if (l->l_stat != LSSTOP)
 1775                         continue;
 1776 
 1777                 if (l->l_wchan != NULL) {
 1778                         l->l_stat = LSSLEEP;
 1779                         if ((cantake == 0) && (l->l_flag & L_SINTR)) {
 1780                                 lr = l;
 1781                                 cantake = 1;
 1782                         }
 1783                 } else {
 1784                         setrunnable(l);
 1785                         lr = NULL;
 1786                         cantake = 1;
 1787                 }
 1788         }
 1789         if (p->p_flag & P_SA) {
 1790                 /* Only consider returning the LWP on the VP. */
 1791                 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
 1792                         lr = vp->savp_lwp;
 1793                         if (lr->l_stat == LSSLEEP) {
 1794                                 if (lr->l_flag & L_SA_YIELD) {
 1795                                         setrunnable(lr);
 1796                                         break;
 1797                                 } else if (lr->l_flag & L_SINTR)
 1798                                         return lr;
 1799                         }
 1800                 }
 1801                 return NULL;
 1802         }
 1803         return lr;
 1804 }
 1805 
 1806 /*
 1807  * Take the action for the specified signal
 1808  * from the current set of pending signals.
 1809  */
 1810 void
 1811 postsig(int signum)
 1812 {
 1813         struct lwp *l;
 1814         struct proc     *p;
 1815         struct sigacts  *ps;
 1816         sig_t           action;
 1817         sigset_t        *returnmask;
 1818 
 1819         l = curlwp;
 1820         p = l->l_proc;
 1821         ps = p->p_sigacts;
 1822 #ifdef DIAGNOSTIC
 1823         if (signum == 0)
 1824                 panic("postsig");
 1825 #endif
 1826 
 1827         KERNEL_PROC_LOCK(l);
 1828 
 1829 #ifdef MULTIPROCESSOR
 1830         /*
 1831          * On MP, issignal() can return the same signal to multiple
 1832          * LWPs.  The LWPs will block above waiting for the kernel
 1833          * lock and the first LWP which gets through will then remove
 1834          * the signal from ps_siglist.  All other LWPs exit here.
 1835          */
 1836         if (!sigismember(&p->p_sigctx.ps_siglist, signum)) {
 1837                 KERNEL_PROC_UNLOCK(l);
 1838                 return;
 1839         }
 1840 #endif
 1841         sigdelset(&p->p_sigctx.ps_siglist, signum);
 1842         action = SIGACTION_PS(ps, signum).sa_handler;
 1843         if (action == SIG_DFL) {
 1844 #ifdef KTRACE
 1845                 if (KTRPOINT(p, KTR_PSIG))
 1846                         ktrpsig(p, signum, action,
 1847                             p->p_sigctx.ps_flags & SAS_OLDMASK ?
 1848                             &p->p_sigctx.ps_oldmask : &p->p_sigctx.ps_sigmask,
 1849                             NULL);
 1850 #endif
 1851                 /*
 1852                  * Default action, where the default is to kill
 1853                  * the process.  (Other cases were ignored above.)
 1854                  */
 1855                 sigexit(l, signum);
 1856                 /* NOTREACHED */
 1857         } else {
 1858                 ksiginfo_t *ksi;
 1859                 /*
 1860                  * If we get here, the signal must be caught.
 1861                  */
 1862 #ifdef DIAGNOSTIC
 1863                 if (action == SIG_IGN ||
 1864                     sigismember(&p->p_sigctx.ps_sigmask, signum))
 1865                         panic("postsig action");
 1866 #endif
 1867                 /*
 1868                  * Set the new mask value and also defer further
 1869                  * occurrences of this signal.
 1870                  *
 1871                  * Special case: user has done a sigpause.  Here the
 1872                  * current mask is not of interest, but rather the
 1873                  * mask from before the sigpause is what we want
 1874                  * restored after the signal processing is completed.
 1875                  */
 1876                 if (p->p_sigctx.ps_flags & SAS_OLDMASK) {
 1877                         returnmask = &p->p_sigctx.ps_oldmask;
 1878                         p->p_sigctx.ps_flags &= ~SAS_OLDMASK;
 1879                 } else
 1880                         returnmask = &p->p_sigctx.ps_sigmask;
 1881                 p->p_stats->p_ru.ru_nsignals++;
 1882                 ksi = ksiginfo_get(p, signum);
 1883 #ifdef KTRACE
 1884                 if (KTRPOINT(p, KTR_PSIG))
 1885                         ktrpsig(p, signum, action,
 1886                             p->p_sigctx.ps_flags & SAS_OLDMASK ?
 1887                             &p->p_sigctx.ps_oldmask : &p->p_sigctx.ps_sigmask,
 1888                             ksi);
 1889 #endif
 1890                 if (ksi == NULL) {
 1891                         ksiginfo_t ksi1;
 1892                         /*
 1893                          * we did not save any siginfo for this, either
 1894                          * because the signal was not caught, or because the
 1895                          * user did not request SA_SIGINFO
 1896                          */
 1897                         KSI_INIT_EMPTY(&ksi1);
 1898                         ksi1.ksi_signo = signum;
 1899                         kpsendsig(l, &ksi1, returnmask);
 1900                 } else {
 1901                         kpsendsig(l, ksi, returnmask);
 1902                         pool_put(&ksiginfo_pool, ksi);
 1903                 }
 1904                 p->p_sigctx.ps_lwp = 0;
 1905                 p->p_sigctx.ps_code = 0;
 1906                 p->p_sigctx.ps_signo = 0;
 1907                 (void) splsched();      /* XXXSMP */
 1908                 sigplusset(&SIGACTION_PS(ps, signum).sa_mask,
 1909                     &p->p_sigctx.ps_sigmask);
 1910                 if (SIGACTION_PS(ps, signum).sa_flags & SA_RESETHAND) {
 1911                         sigdelset(&p->p_sigctx.ps_sigcatch, signum);
 1912                         if (signum != SIGCONT && sigprop[signum] & SA_IGNORE)
 1913                                 sigaddset(&p->p_sigctx.ps_sigignore, signum);
 1914                         SIGACTION_PS(ps, signum).sa_handler = SIG_DFL;
 1915                 }
 1916                 (void) spl0();          /* XXXSMP */
 1917         }
 1918 
 1919         KERNEL_PROC_UNLOCK(l);
 1920 }
 1921 
 1922 /*
 1923  * Kill the current process for stated reason.
 1924  */
 1925 void
 1926 killproc(struct proc *p, const char *why)
 1927 {
 1928         log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why);
 1929         uprintf("sorry, pid %d was killed: %s\n", p->p_pid, why);
 1930         psignal(p, SIGKILL);
 1931 }
 1932 
 1933 /*
 1934  * Force the current process to exit with the specified signal, dumping core
 1935  * if appropriate.  We bypass the normal tests for masked and caught signals,
 1936  * allowing unrecoverable failures to terminate the process without changing
 1937  * signal state.  Mark the accounting record with the signal termination.
 1938  * If dumping core, save the signal number for the debugger.  Calls exit and
 1939  * does not return.
 1940  */
 1941 
 1942 #if defined(DEBUG)
 1943 int     kern_logsigexit = 1;    /* not static to make public for sysctl */
 1944 #else
 1945 int     kern_logsigexit = 0;    /* not static to make public for sysctl */
 1946 #endif
 1947 
 1948 static  const char logcoredump[] =
 1949         "pid %d (%s), uid %d: exited on signal %d (core dumped)\n";
 1950 static  const char lognocoredump[] =
 1951         "pid %d (%s), uid %d: exited on signal %d (core not dumped, err = %d)\n";
 1952 
 1953 /* Wrapper function for use in p_userret */
 1954 static void
 1955 lwp_coredump_hook(struct lwp *l, void *arg)
 1956 {
 1957         int s;
 1958 
 1959         /*
 1960          * Suspend ourselves, so that the kernel stack and therefore
 1961          * the userland registers saved in the trapframe are around
 1962          * for coredump() to write them out.
 1963          */
 1964         KERNEL_PROC_LOCK(l);
 1965         l->l_flag &= ~L_DETACHED;
 1966         SCHED_LOCK(s);
 1967         l->l_stat = LSSUSPENDED;
 1968         l->l_proc->p_nrlwps--;
 1969         /* XXX NJWLWP check if this makes sense here: */
 1970         l->l_proc->p_stats->p_ru.ru_nvcsw++;
 1971         mi_switch(l, NULL);
 1972         SCHED_ASSERT_UNLOCKED();
 1973         splx(s);
 1974 
 1975         lwp_exit(l);
 1976 }
 1977 
 1978 void
 1979 sigexit(struct lwp *l, int signum)
 1980 {
 1981         struct proc     *p;
 1982 #if 0
 1983         struct lwp      *l2;
 1984 #endif
 1985         int             error, exitsig;
 1986 
 1987         p = l->l_proc;
 1988 
 1989         /*
 1990          * Don't permit coredump() or exit1() multiple times
 1991          * in the same process.
 1992          */
 1993         if (p->p_flag & P_WEXIT) {
 1994                 KERNEL_PROC_UNLOCK(l);
 1995                 (*p->p_userret)(l, p->p_userret_arg);
 1996         }
 1997         p->p_flag |= P_WEXIT;
 1998         /* We don't want to switch away from exiting. */
 1999         /* XXX multiprocessor: stop LWPs on other processors. */
 2000 #if 0
 2001         if (p->p_flag & P_SA) {
 2002                 LIST_FOREACH(l2, &p->p_lwps, l_sibling)
 2003                     l2->l_flag &= ~L_SA;
 2004                 p->p_flag &= ~P_SA;
 2005         }
 2006 #endif
 2007 
 2008         /* Make other LWPs stick around long enough to be dumped */
 2009         p->p_userret = lwp_coredump_hook;
 2010         p->p_userret_arg = NULL;
 2011 
 2012         exitsig = signum;
 2013         p->p_acflag |= AXSIG;
 2014         if (sigprop[signum] & SA_CORE) {
 2015                 p->p_sigctx.ps_signo = signum;
 2016                 if ((error = coredump(l, NULL)) == 0)
 2017                         exitsig |= WCOREFLAG;
 2018 
 2019                 if (kern_logsigexit) {
 2020                         /* XXX What if we ever have really large UIDs? */
 2021                         int uid = p->p_cred && p->p_ucred ?
 2022                                 (int) p->p_ucred->cr_uid : -1;
 2023 
 2024                         if (error)
 2025                                 log(LOG_INFO, lognocoredump, p->p_pid,
 2026                                     p->p_comm, uid, signum, error);
 2027                         else
 2028                                 log(LOG_INFO, logcoredump, p->p_pid,
 2029                                     p->p_comm, uid, signum);
 2030                 }
 2031 
 2032         }
 2033 
 2034         exit1(l, W_EXITCODE(0, exitsig));
 2035         /* NOTREACHED */
 2036 }
 2037 
 2038 /*
 2039  * Dump core, into a file named "progname.core" or "core" (depending on the
 2040  * value of shortcorename), unless the process was setuid/setgid.
 2041  */
 2042 int
 2043 coredump(struct lwp *l, const char *pattern)
 2044 {
 2045         struct vnode            *vp;
 2046         struct proc             *p;
 2047         struct vmspace          *vm;
 2048         struct ucred            *cred;
 2049         struct nameidata        nd;
 2050         struct vattr            vattr;
 2051         struct mount            *mp;
 2052         int                     error, error1;
 2053         char                    name[MAXPATHLEN];
 2054 
 2055         p = l->l_proc;
 2056         vm = p->p_vmspace;
 2057         cred = p->p_cred->pc_ucred;
 2058 
 2059         /*
 2060          * Make sure the process has not set-id, to prevent data leaks.
 2061          */
 2062         if (p->p_flag & P_SUGID)
 2063                 return (EPERM);
 2064 
 2065         /*
 2066          * Refuse to core if the data + stack + user size is larger than
 2067          * the core dump limit.  XXX THIS IS WRONG, because of mapped
 2068          * data.
 2069          */
 2070         if (USPACE + ctob(vm->vm_dsize + vm->vm_ssize) >=
 2071             p->p_rlimit[RLIMIT_CORE].rlim_cur)
 2072                 return (EFBIG);         /* better error code? */
 2073 
 2074 restart:
 2075         /*
 2076          * The core dump will go in the current working directory.  Make
 2077          * sure that the directory is still there and that the mount flags
 2078          * allow us to write core dumps there.
 2079          */
 2080         vp = p->p_cwdi->cwdi_cdir;
 2081         if (vp->v_mount == NULL ||
 2082             (vp->v_mount->mnt_flag & MNT_NOCOREDUMP) != 0)
 2083                 return (EPERM);
 2084 
 2085         if (pattern == NULL)
 2086                 pattern = p->p_limit->pl_corename;
 2087         if ((error = build_corename(p, name, pattern, sizeof(name))) != 0)
 2088                 return error;
 2089 
 2090         NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, p);
 2091         error = vn_open(&nd, O_CREAT | O_NOFOLLOW | FWRITE, S_IRUSR | S_IWUSR);
 2092         if (error)
 2093                 return (error);
 2094         vp = nd.ni_vp;
 2095 
 2096         if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
 2097                 VOP_UNLOCK(vp, 0);
 2098                 if ((error = vn_close(vp, FWRITE, cred, p)) != 0)
 2099                         return (error);
 2100                 if ((error = vn_start_write(NULL, &mp,
 2101                     V_WAIT | V_SLEEPONLY | V_PCATCH)) != 0)
 2102                         return (error);
 2103                 goto restart;
 2104         }
 2105 
 2106         /* Don't dump to non-regular files or files with links. */
 2107         if (vp->v_type != VREG ||
 2108             VOP_GETATTR(vp, &vattr, cred, p) || vattr.va_nlink != 1) {
 2109                 error = EINVAL;
 2110                 goto out;
 2111         }
 2112         VATTR_NULL(&vattr);
 2113         vattr.va_size = 0;
 2114         VOP_LEASE(vp, p, cred, LEASE_WRITE);
 2115         VOP_SETATTR(vp, &vattr, cred, p);
 2116         p->p_acflag |= ACORE;
 2117 
 2118         /* Now dump the actual core file. */
 2119         error = (*p->p_execsw->es_coredump)(l, vp, cred);
 2120  out:
 2121         VOP_UNLOCK(vp, 0);
 2122         vn_finished_write(mp, 0);
 2123         error1 = vn_close(vp, FWRITE, cred, p);
 2124         if (error == 0)
 2125                 error = error1;
 2126         return (error);
 2127 }
 2128 
 2129 /*
 2130  * Nonexistent system call-- signal process (may want to handle it).
 2131  * Flag error in case process won't see signal immediately (blocked or ignored).
 2132  */
 2133 /* ARGSUSED */
 2134 int
 2135 sys_nosys(struct lwp *l, void *v, register_t *retval)
 2136 {
 2137         struct proc     *p;
 2138 
 2139         p = l->l_proc;
 2140         psignal(p, SIGSYS);
 2141         return (ENOSYS);
 2142 }
 2143 
 2144 static int
 2145 build_corename(struct proc *p, char *dst, const char *src, size_t len)
 2146 {
 2147         const char      *s;
 2148         char            *d, *end;
 2149         int             i;
 2150 
 2151         for (s = src, d = dst, end = d + len; *s != '\0'; s++) {
 2152                 if (*s == '%') {
 2153                         switch (*(s + 1)) {
 2154                         case 'n':
 2155                                 i = snprintf(d, end - d, "%s", p->p_comm);
 2156                                 break;
 2157                         case 'p':
 2158                                 i = snprintf(d, end - d, "%d", p->p_pid);
 2159                                 break;
 2160                         case 'u':
 2161                                 i = snprintf(d, end - d, "%.*s",
 2162                                     (int)sizeof p->p_pgrp->pg_session->s_login,
 2163                                     p->p_pgrp->pg_session->s_login);
 2164                                 break;
 2165                         case 't':
 2166                                 i = snprintf(d, end - d, "%ld",
 2167                                     p->p_stats->p_start.tv_sec);
 2168                                 break;
 2169                         default:
 2170                                 goto copy;
 2171                         }
 2172                         d += i;
 2173                         s++;
 2174                 } else {
 2175  copy:                  *d = *s;
 2176                         d++;
 2177                 }
 2178                 if (d >= end)
 2179                         return (ENAMETOOLONG);
 2180         }
 2181         *d = '\0';
 2182         return 0;
 2183 }
 2184 
 2185 void
 2186 getucontext(struct lwp *l, ucontext_t *ucp)
 2187 {
 2188         struct proc     *p;
 2189 
 2190         p = l->l_proc;
 2191 
 2192         ucp->uc_flags = 0;
 2193         ucp->uc_link = l->l_ctxlink;
 2194 
 2195         (void)sigprocmask1(p, 0, NULL, &ucp->uc_sigmask);
 2196         ucp->uc_flags |= _UC_SIGMASK;
 2197 
 2198         /*
 2199          * The (unsupplied) definition of the `current execution stack'
 2200          * in the System V Interface Definition appears to allow returning
 2201          * the main context stack.
 2202          */
 2203         if ((p->p_sigctx.ps_sigstk.ss_flags & SS_ONSTACK) == 0) {
 2204                 ucp->uc_stack.ss_sp = (void *)USRSTACK;
 2205                 ucp->uc_stack.ss_size = ctob(p->p_vmspace->vm_ssize);
 2206                 ucp->uc_stack.ss_flags = 0;     /* XXX, def. is Very Fishy */
 2207         } else {
 2208                 /* Simply copy alternate signal execution stack. */
 2209                 ucp->uc_stack = p->p_sigctx.ps_sigstk;
 2210         }
 2211         ucp->uc_flags |= _UC_STACK;
 2212 
 2213         cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags);
 2214 }
 2215 
 2216 /* ARGSUSED */
 2217 int
 2218 sys_getcontext(struct lwp *l, void *v, register_t *retval)
 2219 {
 2220         struct sys_getcontext_args /* {
 2221                 syscallarg(struct __ucontext *) ucp;
 2222         } */ *uap = v;
 2223         ucontext_t uc;
 2224 
 2225         getucontext(l, &uc);
 2226 
 2227         return (copyout(&uc, SCARG(uap, ucp), sizeof (*SCARG(uap, ucp))));
 2228 }
 2229 
 2230 int
 2231 setucontext(struct lwp *l, const ucontext_t *ucp)
 2232 {
 2233         struct proc     *p;
 2234         int             error;
 2235 
 2236         p = l->l_proc;
 2237         if ((error = cpu_setmcontext(l, &ucp->uc_mcontext, ucp->uc_flags)) != 0)
 2238                 return (error);
 2239         l->l_ctxlink = ucp->uc_link;
 2240 
 2241         if ((ucp->uc_flags & _UC_SIGMASK) != 0)
 2242                 sigprocmask1(p, SIG_SETMASK, &ucp->uc_sigmask, NULL);
 2243 
 2244         /*
 2245          * If there was stack information, update whether or not we are
 2246          * still running on an alternate signal stack.
 2247          */
 2248         if ((ucp->uc_flags & _UC_STACK) != 0) {
 2249                 if (ucp->uc_stack.ss_flags & SS_ONSTACK)
 2250                         p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK;
 2251                 else
 2252                         p->p_sigctx.ps_sigstk.ss_flags &= ~SS_ONSTACK;
 2253         }
 2254 
 2255         return 0;
 2256 }
 2257 
 2258 /* ARGSUSED */
 2259 int
 2260 sys_setcontext(struct lwp *l, void *v, register_t *retval)
 2261 {
 2262         struct sys_setcontext_args /* {
 2263                 syscallarg(const ucontext_t *) ucp;
 2264         } */ *uap = v;
 2265         ucontext_t uc;
 2266         int error;
 2267 
 2268         if (SCARG(uap, ucp) == NULL)    /* i.e. end of uc_link chain */
 2269                 exit1(l, W_EXITCODE(0, 0));
 2270         else if ((error = copyin(SCARG(uap, ucp), &uc, sizeof (uc))) != 0 ||
 2271             (error = setucontext(l, &uc)) != 0)
 2272                 return (error);
 2273 
 2274         return (EJUSTRETURN);
 2275 }
 2276 
 2277 /*
 2278  * sigtimedwait(2) system call, used also for implementation
 2279  * of sigwaitinfo() and sigwait().
 2280  *
 2281  * This only handles single LWP in signal wait. libpthread provides
 2282  * it's own sigtimedwait() wrapper to DTRT WRT individual threads.
 2283  */
 2284 int
 2285 sys___sigtimedwait(struct lwp *l, void *v, register_t *retval)
 2286 {
 2287         struct sys___sigtimedwait_args /* {
 2288                 syscallarg(const sigset_t *) set;
 2289                 syscallarg(siginfo_t *) info;
 2290                 syscallarg(struct timespec *) timeout;
 2291         } */ *uap = v;
 2292         sigset_t *waitset, twaitset;
 2293         struct proc *p = l->l_proc;
 2294         int error, signum, s;
 2295         int timo = 0;
 2296         struct timeval tvstart;
 2297         struct timespec ts;
 2298         ksiginfo_t *ksi;
 2299 
 2300         MALLOC(waitset, sigset_t *, sizeof(sigset_t), M_TEMP, M_WAITOK);
 2301 
 2302         if ((error = copyin(SCARG(uap, set), waitset, sizeof(sigset_t))))
 2303                 goto free_waitset;
 2304 
 2305         /*
 2306          * Silently ignore SA_CANTMASK signals. psignal1() would
 2307          * ignore SA_CANTMASK signals in waitset, we do this
 2308          * only for the below siglist check.
 2309          */
 2310         sigminusset(&sigcantmask, waitset);
 2311 
 2312         /*
 2313          * First scan siglist and check if there is signal from
 2314          * our waitset already pending.
 2315          */
 2316         twaitset = *waitset;
 2317         __sigandset(&p->p_sigctx.ps_siglist, &twaitset);
 2318         if ((signum = firstsig(&twaitset))) {
 2319                 /* found pending signal */
 2320                 sigdelset(&p->p_sigctx.ps_siglist, signum);
 2321                 ksi = ksiginfo_get(p, signum);
 2322                 if (!ksi) {
 2323                         /* No queued siginfo, manufacture one */
 2324                         ksi = pool_get(&ksiginfo_pool, PR_WAITOK);
 2325                         KSI_INIT(ksi);
 2326                         ksi->ksi_info._signo = signum;
 2327                         ksi->ksi_info._code = SI_USER;
 2328                 }
 2329 
 2330                 goto sig;
 2331         }
 2332 
 2333         /*
 2334          * Calculate timeout, if it was specified.
 2335          */
 2336         if (SCARG(uap, timeout)) {
 2337                 uint64_t ms;
 2338 
 2339                 if ((error = copyin(SCARG(uap, timeout), &ts, sizeof(ts))))
 2340                         goto free_waitset;
 2341 
 2342                 ms = (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
 2343                 timo = mstohz(ms);
 2344                 if (timo == 0 && ts.tv_sec == 0 && ts.tv_nsec > 0)
 2345                         timo = 1;
 2346                 if (timo <= 0) {
 2347                         error = EAGAIN;
 2348                         goto free_waitset;
 2349                 }
 2350 
 2351                 /*
 2352                  * Remember current mono_time, it would be used in
 2353                  * ECANCELED/ERESTART case.
 2354                  */
 2355                 s = splclock();
 2356                 tvstart = mono_time;
 2357                 splx(s);
 2358         }
 2359 
 2360         /*
 2361          * Setup ps_sigwait list. Pass pointer to malloced memory
 2362          * here; it's not possible to pass pointer to a structure
 2363          * on current process's stack, the current process might
 2364          * be swapped out at the time the signal would get delivered.
 2365          */
 2366         ksi = pool_get(&ksiginfo_pool, PR_WAITOK);
 2367         p->p_sigctx.ps_sigwaited = ksi;
 2368         p->p_sigctx.ps_sigwait = waitset;
 2369 
 2370         /*
 2371          * Wait for signal to arrive. We can either be woken up or
 2372          * time out.
 2373          */
 2374         error = tsleep(&p->p_sigctx.ps_sigwait, PPAUSE|PCATCH, "sigwait", timo);
 2375 
 2376         /*
 2377          * Need to find out if we woke as a result of lwp_wakeup()
 2378          * or a signal outside our wait set.
 2379          */
 2380         if (error == EINTR && p->p_sigctx.ps_sigwaited
 2381             && !firstsig(&p->p_sigctx.ps_siglist)) {
 2382                 /* wakeup via _lwp_wakeup() */
 2383                 error = ECANCELED;
 2384         } else if (!error && p->p_sigctx.ps_sigwaited) {
 2385                 /* spurious wakeup - arrange for syscall restart */
 2386                 error = ERESTART;
 2387                 goto fail;
 2388         }
 2389 
 2390         /*
 2391          * On error, clear sigwait indication. psignal1() clears it
 2392          * in !error case.
 2393          */
 2394         if (error) {
 2395                 p->p_sigctx.ps_sigwaited = NULL;
 2396 
 2397                 /*
 2398                  * If the sleep was interrupted (either by signal or wakeup),
 2399                  * update the timeout and copyout new value back.
 2400                  * It would be used when the syscall would be restarted
 2401                  * or called again.
 2402                  */
 2403                 if (timo && (error == ERESTART || error == ECANCELED)) {
 2404                         struct timeval tvnow, tvtimo;
 2405                         int err;
 2406 
 2407                         s = splclock();
 2408                         tvnow = mono_time;
 2409                         splx(s);
 2410 
 2411                         TIMESPEC_TO_TIMEVAL(&tvtimo, &ts);
 2412 
 2413                         /* compute how much time has passed since start */
 2414                         timersub(&tvnow, &tvstart, &tvnow);
 2415                         /* substract passed time from timeout */
 2416                         timersub(&tvtimo, &tvnow, &tvtimo);
 2417 
 2418                         if (tvtimo.tv_sec < 0) {
 2419                                 error = EAGAIN;
 2420                                 goto fail;
 2421                         }
 2422 
 2423                         TIMEVAL_TO_TIMESPEC(&tvtimo, &ts);
 2424 
 2425                         /* copy updated timeout to userland */
 2426                         if ((err = copyout(&ts, SCARG(uap, timeout), sizeof(ts)))) {
 2427                                 error = err;
 2428                                 goto fail;
 2429                         }
 2430                 }
 2431 
 2432                 goto fail;
 2433         }
 2434 
 2435         /*
 2436          * If a signal from the wait set arrived, copy it to userland.
 2437          * Copy only the used part of siginfo, the padding part is
 2438          * left unchanged (userland is not supposed to touch it anyway).
 2439          */
 2440  sig:
 2441         error = copyout(&ksi->ksi_info, SCARG(uap, info), sizeof(ksi->ksi_info));
 2442 
 2443  fail:
 2444         pool_put(&ksiginfo_pool, ksi);
 2445         p->p_sigctx.ps_sigwait = NULL;
 2446  free_waitset:
 2447         FREE(waitset, M_TEMP);
 2448 
 2449         return (error);
 2450 }
 2451 
 2452 /*
 2453  * Returns true if signal is ignored or masked for passed process.
 2454  */
 2455 int
 2456 sigismasked(struct proc *p, int sig)
 2457 {
 2458 
 2459         return (sigismember(&p->p_sigctx.ps_sigignore, sig) ||
 2460             sigismember(&p->p_sigctx.ps_sigmask, sig));
 2461 }
 2462 
 2463 static int
 2464 filt_sigattach(struct knote *kn)
 2465 {
 2466         struct proc *p = curproc;
 2467 
 2468         kn->kn_ptr.p_proc = p;
 2469         kn->kn_flags |= EV_CLEAR;               /* automatically set */
 2470 
 2471         SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext);
 2472 
 2473         return (0);
 2474 }
 2475 
 2476 static void
 2477 filt_sigdetach(struct knote *kn)
 2478 {
 2479         struct proc *p = kn->kn_ptr.p_proc;
 2480 
 2481         SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext);
 2482 }
 2483 
 2484 /*
 2485  * signal knotes are shared with proc knotes, so we apply a mask to
 2486  * the hint in order to differentiate them from process hints.  This
 2487  * could be avoided by using a signal-specific knote list, but probably
 2488  * isn't worth the trouble.
 2489  */
 2490 static int
 2491 filt_signal(struct knote *kn, long hint)
 2492 {
 2493 
 2494         if (hint & NOTE_SIGNAL) {
 2495                 hint &= ~NOTE_SIGNAL;
 2496 
 2497                 if (kn->kn_id == hint)
 2498                         kn->kn_data++;
 2499         }
 2500         return (kn->kn_data != 0);
 2501 }
 2502 
 2503 const struct filterops sig_filtops = {
 2504         0, filt_sigattach, filt_sigdetach, filt_signal
 2505 };

Cache object: 1436b2267458a46d7ce9372efa5a938a


[ 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.