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