sys/kern/kern_sig.c

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