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