1 /* $NetBSD: kern_sig.c,v 1.405 2023/04/09 09:18:09 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2006, 2007, 2008, 2019 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran. 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 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 1982, 1986, 1989, 1991, 1993 34 * The Regents of the University of California. All rights reserved. 35 * (c) UNIX System Laboratories, Inc. 36 * All or some portions of this file are derived from material licensed 37 * to the University of California by American Telephone and Telegraph 38 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 39 * the permission of UNIX System Laboratories, Inc. 40 * 41 * Redistribution and use in source and binary forms, with or without 42 * modification, are permitted provided that the following conditions 43 * are met: 44 * 1. Redistributions of source code must retain the above copyright 45 * notice, this list of conditions and the following disclaimer. 46 * 2. Redistributions in binary form must reproduce the above copyright 47 * notice, this list of conditions and the following disclaimer in the 48 * documentation and/or other materials provided with the distribution. 49 * 3. Neither the name of the University nor the names of its contributors 50 * may be used to endorse or promote products derived from this software 51 * without specific prior written permission. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 63 * SUCH DAMAGE. 64 * 65 * @(#)kern_sig.c 8.14 (Berkeley) 5/14/95 66 */ 67 68 /* 69 * Signal subsystem. 70 */ 71 72 #include <sys/cdefs.h> 73 __KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.405 2023/04/09 09:18:09 riastradh Exp $"); 74 75 #include "opt_execfmt.h" 76 #include "opt_ptrace.h" 77 #include "opt_dtrace.h" 78 #include "opt_compat_sunos.h" 79 #include "opt_compat_netbsd.h" 80 #include "opt_compat_netbsd32.h" 81 #include "opt_pax.h" 82 83 #define SIGPROP /* include signal properties table */ 84 #include <sys/param.h> 85 #include <sys/signalvar.h> 86 #include <sys/proc.h> 87 #include <sys/ptrace.h> 88 #include <sys/systm.h> 89 #include <sys/wait.h> 90 #include <sys/ktrace.h> 91 #include <sys/syslog.h> 92 #include <sys/filedesc.h> 93 #include <sys/file.h> 94 #include <sys/pool.h> 95 #include <sys/ucontext.h> 96 #include <sys/exec.h> 97 #include <sys/kauth.h> 98 #include <sys/acct.h> 99 #include <sys/callout.h> 100 #include <sys/atomic.h> 101 #include <sys/cpu.h> 102 #include <sys/module.h> 103 #include <sys/sdt.h> 104 #include <sys/exec_elf.h> 105 #include <sys/compat_stub.h> 106 107 #ifdef PAX_SEGVGUARD 108 #include <sys/pax.h> 109 #endif /* PAX_SEGVGUARD */ 110 111 #include <uvm/uvm_extern.h> 112 113 /* Many hard-coded assumptions that there are <= 4 x 32bit signal mask bits */ 114 __CTASSERT(NSIG <= 128); 115 116 #define SIGQUEUE_MAX 32 117 static pool_cache_t sigacts_cache __read_mostly; 118 static pool_cache_t ksiginfo_cache __read_mostly; 119 static callout_t proc_stop_ch __cacheline_aligned; 120 121 sigset_t contsigmask __cacheline_aligned; 122 sigset_t stopsigmask __cacheline_aligned; 123 static sigset_t vforksigmask __cacheline_aligned; 124 sigset_t sigcantmask __cacheline_aligned; 125 126 static void ksiginfo_exechook(struct proc *, void *); 127 static void proc_stop(struct proc *, int); 128 static void proc_stop_done(struct proc *, int); 129 static void proc_stop_callout(void *); 130 static int sigchecktrace(void); 131 static int sigpost(struct lwp *, sig_t, int, int); 132 static int sigput(sigpend_t *, struct proc *, ksiginfo_t *); 133 static int sigunwait(struct proc *, const ksiginfo_t *); 134 static void sigswitch(int, int, bool); 135 static void sigswitch_unlock_and_switch_away(struct lwp *); 136 137 static void sigacts_poolpage_free(struct pool *, void *); 138 static void *sigacts_poolpage_alloc(struct pool *, int); 139 140 /* 141 * DTrace SDT provider definitions 142 */ 143 SDT_PROVIDER_DECLARE(proc); 144 SDT_PROBE_DEFINE3(proc, kernel, , signal__send, 145 "struct lwp *", /* target thread */ 146 "struct proc *", /* target process */ 147 "int"); /* signal */ 148 SDT_PROBE_DEFINE3(proc, kernel, , signal__discard, 149 "struct lwp *", /* target thread */ 150 "struct proc *", /* target process */ 151 "int"); /* signal */ 152 SDT_PROBE_DEFINE3(proc, kernel, , signal__handle, 153 "int", /* signal */ 154 "ksiginfo_t *", /* signal info */ 155 "void (*)(void)"); /* handler address */ 156 157 158 static struct pool_allocator sigactspool_allocator = { 159 .pa_alloc = sigacts_poolpage_alloc, 160 .pa_free = sigacts_poolpage_free 161 }; 162 163 #ifdef DEBUG 164 int kern_logsigexit = 1; 165 #else 166 int kern_logsigexit = 0; 167 #endif 168 169 static const char logcoredump[] = 170 "pid %d (%s), uid %d: exited on signal %d (core dumped)\n"; 171 static const char lognocoredump[] = 172 "pid %d (%s), uid %d: exited on signal %d (core not dumped, err = %d)\n"; 173 174 static kauth_listener_t signal_listener; 175 176 static int 177 signal_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, 178 void *arg0, void *arg1, void *arg2, void *arg3) 179 { 180 struct proc *p; 181 int result, signum; 182 183 result = KAUTH_RESULT_DEFER; 184 p = arg0; 185 signum = (int)(unsigned long)arg1; 186 187 if (action != KAUTH_PROCESS_SIGNAL) 188 return result; 189 190 if (kauth_cred_uidmatch(cred, p->p_cred) || 191 (signum == SIGCONT && (curproc->p_session == p->p_session))) 192 result = KAUTH_RESULT_ALLOW; 193 194 return result; 195 } 196 197 static int 198 sigacts_ctor(void *arg __unused, void *obj, int flags __unused) 199 { 200 memset(obj, 0, sizeof(struct sigacts)); 201 return 0; 202 } 203 204 /* 205 * signal_init: 206 * 207 * Initialize global signal-related data structures. 208 */ 209 void 210 signal_init(void) 211 { 212 213 sigactspool_allocator.pa_pagesz = (PAGE_SIZE)*2; 214 215 sigacts_cache = pool_cache_init(sizeof(struct sigacts), 0, 0, 0, 216 "sigacts", sizeof(struct sigacts) > PAGE_SIZE ? 217 &sigactspool_allocator : NULL, IPL_NONE, sigacts_ctor, NULL, NULL); 218 ksiginfo_cache = pool_cache_init(sizeof(ksiginfo_t), 0, 0, 0, 219 "ksiginfo", NULL, IPL_VM, NULL, NULL, NULL); 220 221 exechook_establish(ksiginfo_exechook, NULL); 222 223 callout_init(&proc_stop_ch, CALLOUT_MPSAFE); 224 callout_setfunc(&proc_stop_ch, proc_stop_callout, NULL); 225 226 signal_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS, 227 signal_listener_cb, NULL); 228 } 229 230 /* 231 * sigacts_poolpage_alloc: 232 * 233 * Allocate a page for the sigacts memory pool. 234 */ 235 static void * 236 sigacts_poolpage_alloc(struct pool *pp, int flags) 237 { 238 239 return (void *)uvm_km_alloc(kernel_map, 240 PAGE_SIZE * 2, PAGE_SIZE * 2, 241 ((flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK) 242 | UVM_KMF_WIRED); 243 } 244 245 /* 246 * sigacts_poolpage_free: 247 * 248 * Free a page on behalf of the sigacts memory pool. 249 */ 250 static void 251 sigacts_poolpage_free(struct pool *pp, void *v) 252 { 253 254 uvm_km_free(kernel_map, (vaddr_t)v, PAGE_SIZE * 2, UVM_KMF_WIRED); 255 } 256 257 /* 258 * sigactsinit: 259 * 260 * Create an initial sigacts structure, using the same signal state 261 * as of specified process. If 'share' is set, share the sigacts by 262 * holding a reference, otherwise just copy it from parent. 263 */ 264 struct sigacts * 265 sigactsinit(struct proc *pp, int share) 266 { 267 struct sigacts *ps = pp->p_sigacts, *ps2; 268 269 if (__predict_false(share)) { 270 atomic_inc_uint(&ps->sa_refcnt); 271 return ps; 272 } 273 ps2 = pool_cache_get(sigacts_cache, PR_WAITOK); 274 mutex_init(&ps2->sa_mutex, MUTEX_DEFAULT, IPL_SCHED); 275 ps2->sa_refcnt = 1; 276 277 mutex_enter(&ps->sa_mutex); 278 memcpy(ps2->sa_sigdesc, ps->sa_sigdesc, sizeof(ps2->sa_sigdesc)); 279 mutex_exit(&ps->sa_mutex); 280 return ps2; 281 } 282 283 /* 284 * sigactsunshare: 285 * 286 * Make this process not share its sigacts, maintaining all signal state. 287 */ 288 void 289 sigactsunshare(struct proc *p) 290 { 291 struct sigacts *ps, *oldps = p->p_sigacts; 292 293 if (__predict_true(oldps->sa_refcnt == 1)) 294 return; 295 296 ps = pool_cache_get(sigacts_cache, PR_WAITOK); 297 mutex_init(&ps->sa_mutex, MUTEX_DEFAULT, IPL_SCHED); 298 memcpy(ps->sa_sigdesc, oldps->sa_sigdesc, sizeof(ps->sa_sigdesc)); 299 ps->sa_refcnt = 1; 300 301 p->p_sigacts = ps; 302 sigactsfree(oldps); 303 } 304 305 /* 306 * sigactsfree; 307 * 308 * Release a sigacts structure. 309 */ 310 void 311 sigactsfree(struct sigacts *ps) 312 { 313 314 membar_release(); 315 if (atomic_dec_uint_nv(&ps->sa_refcnt) == 0) { 316 membar_acquire(); 317 mutex_destroy(&ps->sa_mutex); 318 pool_cache_put(sigacts_cache, ps); 319 } 320 } 321 322 /* 323 * siginit: 324 * 325 * Initialize signal state for process 0; set to ignore signals that 326 * are ignored by default and disable the signal stack. Locking not 327 * required as the system is still cold. 328 */ 329 void 330 siginit(struct proc *p) 331 { 332 struct lwp *l; 333 struct sigacts *ps; 334 int signo, prop; 335 336 ps = p->p_sigacts; 337 sigemptyset(&contsigmask); 338 sigemptyset(&stopsigmask); 339 sigemptyset(&vforksigmask); 340 sigemptyset(&sigcantmask); 341 for (signo = 1; signo < NSIG; signo++) { 342 prop = sigprop[signo]; 343 if (prop & SA_CONT) 344 sigaddset(&contsigmask, signo); 345 if (prop & SA_STOP) 346 sigaddset(&stopsigmask, signo); 347 if (prop & SA_STOP && signo != SIGSTOP) 348 sigaddset(&vforksigmask, signo); 349 if (prop & SA_CANTMASK) 350 sigaddset(&sigcantmask, signo); 351 if (prop & SA_IGNORE && signo != SIGCONT) 352 sigaddset(&p->p_sigctx.ps_sigignore, signo); 353 sigemptyset(&SIGACTION_PS(ps, signo).sa_mask); 354 SIGACTION_PS(ps, signo).sa_flags = SA_RESTART; 355 } 356 sigemptyset(&p->p_sigctx.ps_sigcatch); 357 p->p_sflag &= ~PS_NOCLDSTOP; 358 359 ksiginfo_queue_init(&p->p_sigpend.sp_info); 360 sigemptyset(&p->p_sigpend.sp_set); 361 362 /* 363 * Reset per LWP state. 364 */ 365 l = LIST_FIRST(&p->p_lwps); 366 l->l_sigwaited = NULL; 367 l->l_sigstk = SS_INIT; 368 ksiginfo_queue_init(&l->l_sigpend.sp_info); 369 sigemptyset(&l->l_sigpend.sp_set); 370 371 /* One reference. */ 372 ps->sa_refcnt = 1; 373 } 374 375 /* 376 * execsigs: 377 * 378 * Reset signals for an exec of the specified process. 379 */ 380 void 381 execsigs(struct proc *p) 382 { 383 struct sigacts *ps; 384 struct lwp *l; 385 int signo, prop; 386 sigset_t tset; 387 ksiginfoq_t kq; 388 389 KASSERT(p->p_nlwps == 1); 390 391 sigactsunshare(p); 392 ps = p->p_sigacts; 393 394 /* 395 * Reset caught signals. Held signals remain held through 396 * l->l_sigmask (unless they were caught, and are now ignored 397 * by default). 398 * 399 * No need to lock yet, the process has only one LWP and 400 * at this point the sigacts are private to the process. 401 */ 402 sigemptyset(&tset); 403 for (signo = 1; signo < NSIG; signo++) { 404 if (sigismember(&p->p_sigctx.ps_sigcatch, signo)) { 405 prop = sigprop[signo]; 406 if (prop & SA_IGNORE) { 407 if ((prop & SA_CONT) == 0) 408 sigaddset(&p->p_sigctx.ps_sigignore, 409 signo); 410 sigaddset(&tset, signo); 411 } 412 SIGACTION_PS(ps, signo).sa_handler = SIG_DFL; 413 } 414 sigemptyset(&SIGACTION_PS(ps, signo).sa_mask); 415 SIGACTION_PS(ps, signo).sa_flags = SA_RESTART; 416 } 417 ksiginfo_queue_init(&kq); 418 419 mutex_enter(p->p_lock); 420 sigclearall(p, &tset, &kq); 421 sigemptyset(&p->p_sigctx.ps_sigcatch); 422 423 /* 424 * Reset no zombies if child dies flag as Solaris does. 425 */ 426 p->p_flag &= ~(PK_NOCLDWAIT | PK_CLDSIGIGN); 427 if (SIGACTION_PS(ps, SIGCHLD).sa_handler == SIG_IGN) 428 SIGACTION_PS(ps, SIGCHLD).sa_handler = SIG_DFL; 429 430 /* 431 * Reset per-LWP state. 432 */ 433 l = LIST_FIRST(&p->p_lwps); 434 l->l_sigwaited = NULL; 435 l->l_sigstk = SS_INIT; 436 ksiginfo_queue_init(&l->l_sigpend.sp_info); 437 sigemptyset(&l->l_sigpend.sp_set); 438 mutex_exit(p->p_lock); 439 440 ksiginfo_queue_drain(&kq); 441 } 442 443 /* 444 * ksiginfo_exechook: 445 * 446 * Free all pending ksiginfo entries from a process on exec. 447 * Additionally, drain any unused ksiginfo structures in the 448 * system back to the pool. 449 * 450 * XXX This should not be a hook, every process has signals. 451 */ 452 static void 453 ksiginfo_exechook(struct proc *p, void *v) 454 { 455 ksiginfoq_t kq; 456 457 ksiginfo_queue_init(&kq); 458 459 mutex_enter(p->p_lock); 460 sigclearall(p, NULL, &kq); 461 mutex_exit(p->p_lock); 462 463 ksiginfo_queue_drain(&kq); 464 } 465 466 /* 467 * ksiginfo_alloc: 468 * 469 * Allocate a new ksiginfo structure from the pool, and optionally copy 470 * an existing one. If the existing ksiginfo_t is from the pool, and 471 * has not been queued somewhere, then just return it. Additionally, 472 * if the existing ksiginfo_t does not contain any information beyond 473 * the signal number, then just return it. 474 */ 475 ksiginfo_t * 476 ksiginfo_alloc(struct proc *p, ksiginfo_t *ok, int flags) 477 { 478 ksiginfo_t *kp; 479 480 if (ok != NULL) { 481 if ((ok->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) == 482 KSI_FROMPOOL) 483 return ok; 484 if (KSI_EMPTY_P(ok)) 485 return ok; 486 } 487 488 kp = pool_cache_get(ksiginfo_cache, flags); 489 if (kp == NULL) { 490 #ifdef DIAGNOSTIC 491 printf("Out of memory allocating ksiginfo for pid %d\n", 492 p->p_pid); 493 #endif 494 return NULL; 495 } 496 497 if (ok != NULL) { 498 memcpy(kp, ok, sizeof(*kp)); 499 kp->ksi_flags &= ~KSI_QUEUED; 500 } else 501 KSI_INIT_EMPTY(kp); 502 503 kp->ksi_flags |= KSI_FROMPOOL; 504 505 return kp; 506 } 507 508 /* 509 * ksiginfo_free: 510 * 511 * If the given ksiginfo_t is from the pool and has not been queued, 512 * then free it. 513 */ 514 void 515 ksiginfo_free(ksiginfo_t *kp) 516 { 517 518 if ((kp->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) != KSI_FROMPOOL) 519 return; 520 pool_cache_put(ksiginfo_cache, kp); 521 } 522 523 /* 524 * ksiginfo_queue_drain: 525 * 526 * Drain a non-empty ksiginfo_t queue. 527 */ 528 void 529 ksiginfo_queue_drain0(ksiginfoq_t *kq) 530 { 531 ksiginfo_t *ksi; 532 533 KASSERT(!TAILQ_EMPTY(kq)); 534 535 while (!TAILQ_EMPTY(kq)) { 536 ksi = TAILQ_FIRST(kq); 537 TAILQ_REMOVE(kq, ksi, ksi_list); 538 pool_cache_put(ksiginfo_cache, ksi); 539 } 540 } 541 542 static int 543 siggetinfo(sigpend_t *sp, ksiginfo_t *out, int signo) 544 { 545 ksiginfo_t *ksi, *nksi; 546 547 if (sp == NULL) 548 goto out; 549 550 /* Find siginfo and copy it out. */ 551 int count = 0; 552 TAILQ_FOREACH_SAFE(ksi, &sp->sp_info, ksi_list, nksi) { 553 if (ksi->ksi_signo != signo) 554 continue; 555 if (count++ > 0) /* Only remove the first, count all of them */ 556 continue; 557 TAILQ_REMOVE(&sp->sp_info, ksi, ksi_list); 558 KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0); 559 KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0); 560 ksi->ksi_flags &= ~KSI_QUEUED; 561 if (out != NULL) { 562 memcpy(out, ksi, sizeof(*out)); 563 out->ksi_flags &= ~(KSI_FROMPOOL | KSI_QUEUED); 564 } 565 ksiginfo_free(ksi); 566 } 567 if (count) 568 return count; 569 570 out: 571 /* If there is no siginfo, then manufacture it. */ 572 if (out != NULL) { 573 KSI_INIT(out); 574 out->ksi_info._signo = signo; 575 out->ksi_info._code = SI_NOINFO; 576 } 577 return 0; 578 } 579 580 /* 581 * sigget: 582 * 583 * Fetch the first pending signal from a set. Optionally, also fetch 584 * or manufacture a ksiginfo element. Returns the number of the first 585 * pending signal, or zero. 586 */ 587 int 588 sigget(sigpend_t *sp, ksiginfo_t *out, int signo, const sigset_t *mask) 589 { 590 sigset_t tset; 591 int count; 592 593 /* If there's no pending set, the signal is from the debugger. */ 594 if (sp == NULL) 595 goto out; 596 597 /* Construct mask from signo, and 'mask'. */ 598 if (signo == 0) { 599 if (mask != NULL) { 600 tset = *mask; 601 __sigandset(&sp->sp_set, &tset); 602 } else 603 tset = sp->sp_set; 604 605 /* If there are no signals pending - return. */ 606 if ((signo = firstsig(&tset)) == 0) 607 goto out; 608 } else { 609 KASSERT(sigismember(&sp->sp_set, signo)); 610 } 611 612 sigdelset(&sp->sp_set, signo); 613 out: 614 count = siggetinfo(sp, out, signo); 615 if (count > 1) 616 sigaddset(&sp->sp_set, signo); 617 return signo; 618 } 619 620 /* 621 * sigput: 622 * 623 * Append a new ksiginfo element to the list of pending ksiginfo's. 624 */ 625 static int 626 sigput(sigpend_t *sp, struct proc *p, ksiginfo_t *ksi) 627 { 628 ksiginfo_t *kp; 629 630 KASSERT(mutex_owned(p->p_lock)); 631 KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0); 632 633 sigaddset(&sp->sp_set, ksi->ksi_signo); 634 635 /* 636 * If there is no siginfo, we are done. 637 */ 638 if (KSI_EMPTY_P(ksi)) 639 return 0; 640 641 KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0); 642 643 size_t count = 0; 644 TAILQ_FOREACH(kp, &sp->sp_info, ksi_list) { 645 count++; 646 if (ksi->ksi_signo >= SIGRTMIN && ksi->ksi_signo <= SIGRTMAX) 647 continue; 648 if (kp->ksi_signo == ksi->ksi_signo) { 649 KSI_COPY(ksi, kp); 650 kp->ksi_flags |= KSI_QUEUED; 651 return 0; 652 } 653 } 654 655 if (count >= SIGQUEUE_MAX) { 656 #ifdef DIAGNOSTIC 657 printf("%s(%d): Signal queue is full signal=%d\n", 658 p->p_comm, p->p_pid, ksi->ksi_signo); 659 #endif 660 return EAGAIN; 661 } 662 ksi->ksi_flags |= KSI_QUEUED; 663 TAILQ_INSERT_TAIL(&sp->sp_info, ksi, ksi_list); 664 665 return 0; 666 } 667 668 /* 669 * sigclear: 670 * 671 * Clear all pending signals in the specified set. 672 */ 673 void 674 sigclear(sigpend_t *sp, const sigset_t *mask, ksiginfoq_t *kq) 675 { 676 ksiginfo_t *ksi, *next; 677 678 if (mask == NULL) 679 sigemptyset(&sp->sp_set); 680 else 681 sigminusset(mask, &sp->sp_set); 682 683 TAILQ_FOREACH_SAFE(ksi, &sp->sp_info, ksi_list, next) { 684 if (mask == NULL || sigismember(mask, ksi->ksi_signo)) { 685 TAILQ_REMOVE(&sp->sp_info, ksi, ksi_list); 686 KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0); 687 KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0); 688 TAILQ_INSERT_TAIL(kq, ksi, ksi_list); 689 } 690 } 691 } 692 693 /* 694 * sigclearall: 695 * 696 * Clear all pending signals in the specified set from a process and 697 * its LWPs. 698 */ 699 void 700 sigclearall(struct proc *p, const sigset_t *mask, ksiginfoq_t *kq) 701 { 702 struct lwp *l; 703 704 KASSERT(mutex_owned(p->p_lock)); 705 706 sigclear(&p->p_sigpend, mask, kq); 707 708 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 709 sigclear(&l->l_sigpend, mask, kq); 710 } 711 } 712 713 /* 714 * sigispending: 715 * 716 * Return the first signal number if there are pending signals for the 717 * current LWP. May be called unlocked provided that LW_PENDSIG is set, 718 * and that the signal has been posted to the appopriate queue before 719 * LW_PENDSIG is set. 720 * 721 * This should only ever be called with (l == curlwp), unless the 722 * result does not matter (procfs, sysctl). 723 */ 724 int 725 sigispending(struct lwp *l, int signo) 726 { 727 struct proc *p = l->l_proc; 728 sigset_t tset; 729 730 membar_consumer(); 731 732 tset = l->l_sigpend.sp_set; 733 sigplusset(&p->p_sigpend.sp_set, &tset); 734 sigminusset(&p->p_sigctx.ps_sigignore, &tset); 735 sigminusset(&l->l_sigmask, &tset); 736 737 if (signo == 0) { 738 return firstsig(&tset); 739 } 740 return sigismember(&tset, signo) ? signo : 0; 741 } 742 743 void 744 getucontext(struct lwp *l, ucontext_t *ucp) 745 { 746 struct proc *p = l->l_proc; 747 748 KASSERT(mutex_owned(p->p_lock)); 749 750 ucp->uc_flags = 0; 751 ucp->uc_link = l->l_ctxlink; 752 ucp->uc_sigmask = l->l_sigmask; 753 ucp->uc_flags |= _UC_SIGMASK; 754 755 /* 756 * The (unsupplied) definition of the `current execution stack' 757 * in the System V Interface Definition appears to allow returning 758 * the main context stack. 759 */ 760 if ((l->l_sigstk.ss_flags & SS_ONSTACK) == 0) { 761 ucp->uc_stack.ss_sp = (void *)l->l_proc->p_stackbase; 762 ucp->uc_stack.ss_size = ctob(l->l_proc->p_vmspace->vm_ssize); 763 ucp->uc_stack.ss_flags = 0; /* XXX, def. is Very Fishy */ 764 } else { 765 /* Simply copy alternate signal execution stack. */ 766 ucp->uc_stack = l->l_sigstk; 767 } 768 ucp->uc_flags |= _UC_STACK; 769 mutex_exit(p->p_lock); 770 cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags); 771 mutex_enter(p->p_lock); 772 } 773 774 int 775 setucontext(struct lwp *l, const ucontext_t *ucp) 776 { 777 struct proc *p = l->l_proc; 778 int error; 779 780 KASSERT(mutex_owned(p->p_lock)); 781 782 if ((ucp->uc_flags & _UC_SIGMASK) != 0) { 783 error = sigprocmask1(l, SIG_SETMASK, &ucp->uc_sigmask, NULL); 784 if (error != 0) 785 return error; 786 } 787 788 mutex_exit(p->p_lock); 789 error = cpu_setmcontext(l, &ucp->uc_mcontext, ucp->uc_flags); 790 mutex_enter(p->p_lock); 791 if (error != 0) 792 return (error); 793 794 l->l_ctxlink = ucp->uc_link; 795 796 /* 797 * If there was stack information, update whether or not we are 798 * still running on an alternate signal stack. 799 */ 800 if ((ucp->uc_flags & _UC_STACK) != 0) { 801 if (ucp->uc_stack.ss_flags & SS_ONSTACK) 802 l->l_sigstk.ss_flags |= SS_ONSTACK; 803 else 804 l->l_sigstk.ss_flags &= ~SS_ONSTACK; 805 } 806 807 return 0; 808 } 809 810 /* 811 * killpg1: common code for kill process group/broadcast kill. 812 */ 813 int 814 killpg1(struct lwp *l, ksiginfo_t *ksi, int pgid, int all) 815 { 816 struct proc *p, *cp; 817 kauth_cred_t pc; 818 struct pgrp *pgrp; 819 int nfound; 820 int signo = ksi->ksi_signo; 821 822 cp = l->l_proc; 823 pc = l->l_cred; 824 nfound = 0; 825 826 mutex_enter(&proc_lock); 827 if (all) { 828 /* 829 * Broadcast. 830 */ 831 PROCLIST_FOREACH(p, &allproc) { 832 if (p->p_pid <= 1 || p == cp || 833 (p->p_flag & PK_SYSTEM) != 0) 834 continue; 835 mutex_enter(p->p_lock); 836 if (kauth_authorize_process(pc, 837 KAUTH_PROCESS_SIGNAL, p, KAUTH_ARG(signo), NULL, 838 NULL) == 0) { 839 nfound++; 840 if (signo) 841 kpsignal2(p, ksi); 842 } 843 mutex_exit(p->p_lock); 844 } 845 } else { 846 if (pgid == 0) 847 /* Zero pgid means send to my process group. */ 848 pgrp = cp->p_pgrp; 849 else { 850 pgrp = pgrp_find(pgid); 851 if (pgrp == NULL) 852 goto out; 853 } 854 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 855 if (p->p_pid <= 1 || p->p_flag & PK_SYSTEM) 856 continue; 857 mutex_enter(p->p_lock); 858 if (kauth_authorize_process(pc, KAUTH_PROCESS_SIGNAL, 859 p, KAUTH_ARG(signo), NULL, NULL) == 0) { 860 nfound++; 861 if (signo && P_ZOMBIE(p) == 0) 862 kpsignal2(p, ksi); 863 } 864 mutex_exit(p->p_lock); 865 } 866 } 867 out: 868 mutex_exit(&proc_lock); 869 return nfound ? 0 : ESRCH; 870 } 871 872 /* 873 * Send a signal to a process group. If checktty is set, limit to members 874 * which have a controlling terminal. 875 */ 876 void 877 pgsignal(struct pgrp *pgrp, int sig, int checkctty) 878 { 879 ksiginfo_t ksi; 880 881 KASSERT(!cpu_intr_p()); 882 KASSERT(mutex_owned(&proc_lock)); 883 884 KSI_INIT_EMPTY(&ksi); 885 ksi.ksi_signo = sig; 886 kpgsignal(pgrp, &ksi, NULL, checkctty); 887 } 888 889 void 890 kpgsignal(struct pgrp *pgrp, ksiginfo_t *ksi, void *data, int checkctty) 891 { 892 struct proc *p; 893 894 KASSERT(!cpu_intr_p()); 895 KASSERT(mutex_owned(&proc_lock)); 896 KASSERT(pgrp != NULL); 897 898 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) 899 if (checkctty == 0 || p->p_lflag & PL_CONTROLT) 900 kpsignal(p, ksi, data); 901 } 902 903 /* 904 * Send a signal caused by a trap to the current LWP. If it will be caught 905 * immediately, deliver it with correct code. Otherwise, post it normally. 906 */ 907 void 908 trapsignal(struct lwp *l, ksiginfo_t *ksi) 909 { 910 struct proc *p; 911 struct sigacts *ps; 912 int signo = ksi->ksi_signo; 913 sigset_t *mask; 914 sig_t action; 915 916 KASSERT(KSI_TRAP_P(ksi)); 917 918 ksi->ksi_lid = l->l_lid; 919 p = l->l_proc; 920 921 KASSERT(!cpu_intr_p()); 922 mutex_enter(&proc_lock); 923 mutex_enter(p->p_lock); 924 925 repeat: 926 /* 927 * If we are exiting, demise now. 928 * 929 * This avoids notifying tracer and deadlocking. 930 */ 931 if (__predict_false(ISSET(p->p_sflag, PS_WEXIT))) { 932 mutex_exit(p->p_lock); 933 mutex_exit(&proc_lock); 934 lwp_exit(l); 935 panic("trapsignal"); 936 /* NOTREACHED */ 937 } 938 939 /* 940 * The process is already stopping. 941 */ 942 if ((p->p_sflag & PS_STOPPING) != 0) { 943 mutex_exit(&proc_lock); 944 sigswitch_unlock_and_switch_away(l); 945 mutex_enter(&proc_lock); 946 mutex_enter(p->p_lock); 947 goto repeat; 948 } 949 950 mask = &l->l_sigmask; 951 ps = p->p_sigacts; 952 action = SIGACTION_PS(ps, signo).sa_handler; 953 954 if (ISSET(p->p_slflag, PSL_TRACED) && 955 !(p->p_pptr == p->p_opptr && ISSET(p->p_lflag, PL_PPWAIT)) && 956 p->p_xsig != SIGKILL && 957 !sigismember(&p->p_sigpend.sp_set, SIGKILL)) { 958 p->p_xsig = signo; 959 p->p_sigctx.ps_faked = true; 960 p->p_sigctx.ps_lwp = ksi->ksi_lid; 961 p->p_sigctx.ps_info = ksi->ksi_info; 962 sigswitch(0, signo, true); 963 964 if (ktrpoint(KTR_PSIG)) { 965 if (p->p_emul->e_ktrpsig) 966 p->p_emul->e_ktrpsig(signo, action, mask, ksi); 967 else 968 ktrpsig(signo, action, mask, ksi); 969 } 970 return; 971 } 972 973 const bool caught = sigismember(&p->p_sigctx.ps_sigcatch, signo); 974 const bool masked = sigismember(mask, signo); 975 if (caught && !masked) { 976 mutex_exit(&proc_lock); 977 l->l_ru.ru_nsignals++; 978 kpsendsig(l, ksi, mask); 979 mutex_exit(p->p_lock); 980 981 if (ktrpoint(KTR_PSIG)) { 982 if (p->p_emul->e_ktrpsig) 983 p->p_emul->e_ktrpsig(signo, action, mask, ksi); 984 else 985 ktrpsig(signo, action, mask, ksi); 986 } 987 return; 988 } 989 990 /* 991 * If the signal is masked or ignored, then unmask it and 992 * reset it to the default action so that the process or 993 * its tracer will be notified. 994 */ 995 const bool ignored = action == SIG_IGN; 996 if (masked || ignored) { 997 mutex_enter(&ps->sa_mutex); 998 sigdelset(mask, signo); 999 sigdelset(&p->p_sigctx.ps_sigcatch, signo); 1000 sigdelset(&p->p_sigctx.ps_sigignore, signo); 1001 sigdelset(&SIGACTION_PS(ps, signo).sa_mask, signo); 1002 SIGACTION_PS(ps, signo).sa_handler = SIG_DFL; 1003 mutex_exit(&ps->sa_mutex); 1004 } 1005 1006 kpsignal2(p, ksi); 1007 mutex_exit(p->p_lock); 1008 mutex_exit(&proc_lock); 1009 } 1010 1011 /* 1012 * Fill in signal information and signal the parent for a child status change. 1013 */ 1014 void 1015 child_psignal(struct proc *p, int mask) 1016 { 1017 ksiginfo_t ksi; 1018 struct proc *q; 1019 int xsig; 1020 1021 KASSERT(mutex_owned(&proc_lock)); 1022 KASSERT(mutex_owned(p->p_lock)); 1023 1024 xsig = p->p_xsig; 1025 1026 KSI_INIT(&ksi); 1027 ksi.ksi_signo = SIGCHLD; 1028 ksi.ksi_code = (xsig == SIGCONT ? CLD_CONTINUED : CLD_STOPPED); 1029 ksi.ksi_pid = p->p_pid; 1030 ksi.ksi_uid = kauth_cred_geteuid(p->p_cred); 1031 ksi.ksi_status = xsig; 1032 ksi.ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec; 1033 ksi.ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec; 1034 1035 q = p->p_pptr; 1036 1037 mutex_exit(p->p_lock); 1038 mutex_enter(q->p_lock); 1039 1040 if ((q->p_sflag & mask) == 0) 1041 kpsignal2(q, &ksi); 1042 1043 mutex_exit(q->p_lock); 1044 mutex_enter(p->p_lock); 1045 } 1046 1047 void 1048 psignal(struct proc *p, int signo) 1049 { 1050 ksiginfo_t ksi; 1051 1052 KASSERT(!cpu_intr_p()); 1053 KASSERT(mutex_owned(&proc_lock)); 1054 1055 KSI_INIT_EMPTY(&ksi); 1056 ksi.ksi_signo = signo; 1057 mutex_enter(p->p_lock); 1058 kpsignal2(p, &ksi); 1059 mutex_exit(p->p_lock); 1060 } 1061 1062 void 1063 kpsignal(struct proc *p, ksiginfo_t *ksi, void *data) 1064 { 1065 fdfile_t *ff; 1066 file_t *fp; 1067 fdtab_t *dt; 1068 1069 KASSERT(!cpu_intr_p()); 1070 KASSERT(mutex_owned(&proc_lock)); 1071 1072 if ((p->p_sflag & PS_WEXIT) == 0 && data) { 1073 size_t fd; 1074 filedesc_t *fdp = p->p_fd; 1075 1076 /* XXXSMP locking */ 1077 ksi->ksi_fd = -1; 1078 dt = atomic_load_consume(&fdp->fd_dt); 1079 for (fd = 0; fd < dt->dt_nfiles; fd++) { 1080 if ((ff = dt->dt_ff[fd]) == NULL) 1081 continue; 1082 if ((fp = atomic_load_consume(&ff->ff_file)) == NULL) 1083 continue; 1084 if (fp->f_data == data) { 1085 ksi->ksi_fd = fd; 1086 break; 1087 } 1088 } 1089 } 1090 mutex_enter(p->p_lock); 1091 kpsignal2(p, ksi); 1092 mutex_exit(p->p_lock); 1093 } 1094 1095 /* 1096 * sigismasked: 1097 * 1098 * Returns true if signal is ignored or masked for the specified LWP. 1099 */ 1100 int 1101 sigismasked(struct lwp *l, int sig) 1102 { 1103 struct proc *p = l->l_proc; 1104 1105 return sigismember(&p->p_sigctx.ps_sigignore, sig) || 1106 sigismember(&l->l_sigmask, sig); 1107 } 1108 1109 /* 1110 * sigpost: 1111 * 1112 * Post a pending signal to an LWP. Returns non-zero if the LWP may 1113 * be able to take the signal. 1114 */ 1115 static int 1116 sigpost(struct lwp *l, sig_t action, int prop, int sig) 1117 { 1118 int rv, masked; 1119 struct proc *p = l->l_proc; 1120 1121 KASSERT(mutex_owned(p->p_lock)); 1122 1123 /* 1124 * If the LWP is on the way out, sigclear() will be busy draining all 1125 * pending signals. Don't give it more. 1126 */ 1127 if (l->l_stat == LSZOMB) 1128 return 0; 1129 1130 SDT_PROBE(proc, kernel, , signal__send, l, p, sig, 0, 0); 1131 1132 lwp_lock(l); 1133 if (__predict_false((l->l_flag & LW_DBGSUSPEND) != 0)) { 1134 if ((prop & SA_KILL) != 0) 1135 l->l_flag &= ~LW_DBGSUSPEND; 1136 else { 1137 lwp_unlock(l); 1138 return 0; 1139 } 1140 } 1141 1142 /* 1143 * Have the LWP check for signals. This ensures that even if no LWP 1144 * is found to take the signal immediately, it should be taken soon. 1145 */ 1146 signotify(l); 1147 1148 /* 1149 * SIGCONT can be masked, but if LWP is stopped, it needs restart. 1150 * Note: SIGKILL and SIGSTOP cannot be masked. 1151 */ 1152 masked = sigismember(&l->l_sigmask, sig); 1153 if (masked && ((prop & SA_CONT) == 0 || l->l_stat != LSSTOP)) { 1154 lwp_unlock(l); 1155 return 0; 1156 } 1157 1158 /* 1159 * If killing the process, make it run fast. 1160 */ 1161 if (__predict_false((prop & SA_KILL) != 0) && 1162 action == SIG_DFL && l->l_priority < MAXPRI_USER) { 1163 KASSERT(l->l_class == SCHED_OTHER); 1164 lwp_changepri(l, MAXPRI_USER); 1165 } 1166 1167 /* 1168 * If the LWP is running or on a run queue, then we win. If it's 1169 * sleeping interruptably, wake it and make it take the signal. If 1170 * the sleep isn't interruptable, then the chances are it will get 1171 * to see the signal soon anyhow. If suspended, it can't take the 1172 * signal right now. If it's LWP private or for all LWPs, save it 1173 * for later; otherwise punt. 1174 */ 1175 rv = 0; 1176 1177 switch (l->l_stat) { 1178 case LSRUN: 1179 case LSONPROC: 1180 rv = 1; 1181 break; 1182 1183 case LSSLEEP: 1184 if ((l->l_flag & LW_SINTR) != 0) { 1185 /* setrunnable() will release the lock. */ 1186 setrunnable(l); 1187 return 1; 1188 } 1189 break; 1190 1191 case LSSUSPENDED: 1192 if ((prop & SA_KILL) != 0 && (l->l_flag & LW_WCORE) != 0) { 1193 /* lwp_continue() will release the lock. */ 1194 lwp_continue(l); 1195 return 1; 1196 } 1197 break; 1198 1199 case LSSTOP: 1200 if ((prop & SA_STOP) != 0) 1201 break; 1202 1203 /* 1204 * If the LWP is stopped and we are sending a continue 1205 * signal, then start it again. 1206 */ 1207 if ((prop & SA_CONT) != 0) { 1208 if (l->l_wchan != NULL) { 1209 l->l_stat = LSSLEEP; 1210 p->p_nrlwps++; 1211 rv = 1; 1212 break; 1213 } 1214 /* setrunnable() will release the lock. */ 1215 setrunnable(l); 1216 return 1; 1217 } else if (l->l_wchan == NULL || (l->l_flag & LW_SINTR) != 0) { 1218 /* setrunnable() will release the lock. */ 1219 setrunnable(l); 1220 return 1; 1221 } 1222 break; 1223 1224 default: 1225 break; 1226 } 1227 1228 lwp_unlock(l); 1229 return rv; 1230 } 1231 1232 /* 1233 * Notify an LWP that it has a pending signal. 1234 */ 1235 void 1236 signotify(struct lwp *l) 1237 { 1238 KASSERT(lwp_locked(l, NULL)); 1239 1240 l->l_flag |= LW_PENDSIG; 1241 lwp_need_userret(l); 1242 } 1243 1244 /* 1245 * Find an LWP within process p that is waiting on signal ksi, and hand 1246 * it on. 1247 */ 1248 static int 1249 sigunwait(struct proc *p, const ksiginfo_t *ksi) 1250 { 1251 struct lwp *l; 1252 int signo; 1253 1254 KASSERT(mutex_owned(p->p_lock)); 1255 1256 signo = ksi->ksi_signo; 1257 1258 if (ksi->ksi_lid != 0) { 1259 /* 1260 * Signal came via _lwp_kill(). Find the LWP and see if 1261 * it's interested. 1262 */ 1263 if ((l = lwp_find(p, ksi->ksi_lid)) == NULL) 1264 return 0; 1265 if (l->l_sigwaited == NULL || 1266 !sigismember(&l->l_sigwaitset, signo)) 1267 return 0; 1268 } else { 1269 /* 1270 * Look for any LWP that may be interested. 1271 */ 1272 LIST_FOREACH(l, &p->p_sigwaiters, l_sigwaiter) { 1273 KASSERT(l->l_sigwaited != NULL); 1274 if (sigismember(&l->l_sigwaitset, signo)) 1275 break; 1276 } 1277 } 1278 1279 if (l != NULL) { 1280 l->l_sigwaited->ksi_info = ksi->ksi_info; 1281 l->l_sigwaited = NULL; 1282 LIST_REMOVE(l, l_sigwaiter); 1283 cv_signal(&l->l_sigcv); 1284 return 1; 1285 } 1286 1287 return 0; 1288 } 1289 1290 /* 1291 * Send the signal to the process. If the signal has an action, the action 1292 * is usually performed by the target process rather than the caller; we add 1293 * the signal to the set of pending signals for the process. 1294 * 1295 * Exceptions: 1296 * o When a stop signal is sent to a sleeping process that takes the 1297 * default action, the process is stopped without awakening it. 1298 * o SIGCONT restarts stopped processes (or puts them back to sleep) 1299 * regardless of the signal action (eg, blocked or ignored). 1300 * 1301 * Other ignored signals are discarded immediately. 1302 */ 1303 int 1304 kpsignal2(struct proc *p, ksiginfo_t *ksi) 1305 { 1306 int prop, signo = ksi->ksi_signo; 1307 struct lwp *l = NULL; 1308 ksiginfo_t *kp; 1309 lwpid_t lid; 1310 sig_t action; 1311 bool toall; 1312 bool traced; 1313 int error = 0; 1314 1315 KASSERT(!cpu_intr_p()); 1316 KASSERT(mutex_owned(&proc_lock)); 1317 KASSERT(mutex_owned(p->p_lock)); 1318 KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0); 1319 KASSERT(signo > 0); 1320 KASSERT(signo < NSIG); 1321 1322 /* 1323 * If the process is being created by fork, is a zombie or is 1324 * exiting, then just drop the signal here and bail out. 1325 */ 1326 if (p->p_stat != SACTIVE && p->p_stat != SSTOP) 1327 return 0; 1328 1329 /* 1330 * Notify any interested parties of the signal. 1331 */ 1332 KNOTE(&p->p_klist, NOTE_SIGNAL | signo); 1333 1334 /* 1335 * Some signals including SIGKILL must act on the entire process. 1336 */ 1337 kp = NULL; 1338 prop = sigprop[signo]; 1339 toall = ((prop & SA_TOALL) != 0); 1340 lid = toall ? 0 : ksi->ksi_lid; 1341 traced = ISSET(p->p_slflag, PSL_TRACED) && 1342 !sigismember(&p->p_sigctx.ps_sigpass, signo); 1343 1344 /* 1345 * If proc is traced, always give parent a chance. 1346 */ 1347 if (traced) { 1348 action = SIG_DFL; 1349 1350 if (lid == 0) { 1351 /* 1352 * If the process is being traced and the signal 1353 * is being caught, make sure to save any ksiginfo. 1354 */ 1355 if ((kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL) 1356 goto discard; 1357 if ((error = sigput(&p->p_sigpend, p, kp)) != 0) 1358 goto out; 1359 } 1360 } else { 1361 1362 /* 1363 * If the signal is being ignored, then drop it. Note: we 1364 * don't set SIGCONT in ps_sigignore, and if it is set to 1365 * SIG_IGN, action will be SIG_DFL here. 1366 */ 1367 if (sigismember(&p->p_sigctx.ps_sigignore, signo)) 1368 goto discard; 1369 1370 else if (sigismember(&p->p_sigctx.ps_sigcatch, signo)) 1371 action = SIG_CATCH; 1372 else { 1373 action = SIG_DFL; 1374 1375 /* 1376 * If sending a tty stop signal to a member of an 1377 * orphaned process group, discard the signal here if 1378 * the action is default; don't stop the process below 1379 * if sleeping, and don't clear any pending SIGCONT. 1380 */ 1381 if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0) 1382 goto discard; 1383 1384 if (prop & SA_KILL && p->p_nice > NZERO) 1385 p->p_nice = NZERO; 1386 } 1387 } 1388 1389 /* 1390 * If stopping or continuing a process, discard any pending 1391 * signals that would do the inverse. 1392 */ 1393 if ((prop & (SA_CONT | SA_STOP)) != 0) { 1394 ksiginfoq_t kq; 1395 1396 ksiginfo_queue_init(&kq); 1397 if ((prop & SA_CONT) != 0) 1398 sigclear(&p->p_sigpend, &stopsigmask, &kq); 1399 if ((prop & SA_STOP) != 0) 1400 sigclear(&p->p_sigpend, &contsigmask, &kq); 1401 ksiginfo_queue_drain(&kq); /* XXXSMP */ 1402 } 1403 1404 /* 1405 * If the signal doesn't have SA_CANTMASK (no override for SIGKILL, 1406 * please!), check if any LWPs are waiting on it. If yes, pass on 1407 * the signal info. The signal won't be processed further here. 1408 */ 1409 if ((prop & SA_CANTMASK) == 0 && !LIST_EMPTY(&p->p_sigwaiters) && 1410 p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0 && 1411 sigunwait(p, ksi)) 1412 goto discard; 1413 1414 /* 1415 * XXXSMP Should be allocated by the caller, we're holding locks 1416 * here. 1417 */ 1418 if (kp == NULL && (kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL) 1419 goto discard; 1420 1421 /* 1422 * LWP private signals are easy - just find the LWP and post 1423 * the signal to it. 1424 */ 1425 if (lid != 0) { 1426 l = lwp_find(p, lid); 1427 if (l != NULL) { 1428 if ((error = sigput(&l->l_sigpend, p, kp)) != 0) 1429 goto out; 1430 membar_producer(); 1431 if (sigpost(l, action, prop, kp->ksi_signo) != 0) 1432 signo = -1; 1433 } 1434 goto out; 1435 } 1436 1437 /* 1438 * Some signals go to all LWPs, even if posted with _lwp_kill() 1439 * or for an SA process. 1440 */ 1441 if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) { 1442 if (traced) 1443 goto deliver; 1444 1445 /* 1446 * If SIGCONT is default (or ignored) and process is 1447 * asleep, we are finished; the process should not 1448 * be awakened. 1449 */ 1450 if ((prop & SA_CONT) != 0 && action == SIG_DFL) 1451 goto out; 1452 } else { 1453 /* 1454 * Process is stopped or stopping. 1455 * - If traced, then no action is needed, unless killing. 1456 * - Run the process only if sending SIGCONT or SIGKILL. 1457 */ 1458 if (traced && signo != SIGKILL) { 1459 goto out; 1460 } 1461 if ((prop & SA_CONT) != 0 || signo == SIGKILL) { 1462 /* 1463 * Re-adjust p_nstopchild if the process was 1464 * stopped but not yet collected by its parent. 1465 */ 1466 if (p->p_stat == SSTOP && !p->p_waited) 1467 p->p_pptr->p_nstopchild--; 1468 p->p_stat = SACTIVE; 1469 p->p_sflag &= ~PS_STOPPING; 1470 if (traced) { 1471 KASSERT(signo == SIGKILL); 1472 goto deliver; 1473 } 1474 /* 1475 * Do not make signal pending if SIGCONT is default. 1476 * 1477 * If the process catches SIGCONT, let it handle the 1478 * signal itself (if waiting on event - process runs, 1479 * otherwise continues sleeping). 1480 */ 1481 if ((prop & SA_CONT) != 0) { 1482 p->p_xsig = SIGCONT; 1483 p->p_sflag |= PS_CONTINUED; 1484 child_psignal(p, 0); 1485 if (action == SIG_DFL) { 1486 KASSERT(signo != SIGKILL); 1487 goto deliver; 1488 } 1489 } 1490 } else if ((prop & SA_STOP) != 0) { 1491 /* 1492 * Already stopped, don't need to stop again. 1493 * (If we did the shell could get confused.) 1494 */ 1495 goto out; 1496 } 1497 } 1498 /* 1499 * Make signal pending. 1500 */ 1501 KASSERT(!traced); 1502 if ((error = sigput(&p->p_sigpend, p, kp)) != 0) 1503 goto out; 1504 deliver: 1505 /* 1506 * Before we set LW_PENDSIG on any LWP, ensure that the signal is 1507 * visible on the per process list (for sigispending()). This 1508 * is unlikely to be needed in practice, but... 1509 */ 1510 membar_producer(); 1511 1512 /* 1513 * Try to find an LWP that can take the signal. 1514 */ 1515 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 1516 if (sigpost(l, action, prop, kp->ksi_signo) && !toall) 1517 break; 1518 } 1519 signo = -1; 1520 out: 1521 /* 1522 * If the ksiginfo wasn't used, then bin it. XXXSMP freeing memory 1523 * with locks held. The caller should take care of this. 1524 */ 1525 ksiginfo_free(kp); 1526 if (signo == -1) 1527 return error; 1528 discard: 1529 SDT_PROBE(proc, kernel, , signal__discard, l, p, signo, 0, 0); 1530 return error; 1531 } 1532 1533 void 1534 kpsendsig(struct lwp *l, const ksiginfo_t *ksi, const sigset_t *mask) 1535 { 1536 struct proc *p = l->l_proc; 1537 1538 KASSERT(mutex_owned(p->p_lock)); 1539 (*p->p_emul->e_sendsig)(ksi, mask); 1540 } 1541 1542 /* 1543 * Stop any LWPs sleeping interruptably. 1544 */ 1545 static void 1546 proc_stop_lwps(struct proc *p) 1547 { 1548 struct lwp *l; 1549 1550 KASSERT(mutex_owned(p->p_lock)); 1551 KASSERT((p->p_sflag & PS_STOPPING) != 0); 1552 1553 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 1554 lwp_lock(l); 1555 if (l->l_stat == LSSLEEP && (l->l_flag & LW_SINTR) != 0) { 1556 l->l_stat = LSSTOP; 1557 p->p_nrlwps--; 1558 } 1559 lwp_unlock(l); 1560 } 1561 } 1562 1563 /* 1564 * Finish stopping of a process. Mark it stopped and notify the parent. 1565 * 1566 * Drop p_lock briefly if ppsig is true. 1567 */ 1568 static void 1569 proc_stop_done(struct proc *p, int ppmask) 1570 { 1571 1572 KASSERT(mutex_owned(&proc_lock)); 1573 KASSERT(mutex_owned(p->p_lock)); 1574 KASSERT((p->p_sflag & PS_STOPPING) != 0); 1575 KASSERT(p->p_nrlwps == 0 || p->p_nrlwps == 1); 1576 KASSERT(p->p_nrlwps == 0 || p == curproc); 1577 1578 p->p_sflag &= ~PS_STOPPING; 1579 p->p_stat = SSTOP; 1580 p->p_waited = 0; 1581 p->p_pptr->p_nstopchild++; 1582 1583 /* child_psignal drops p_lock briefly. */ 1584 child_psignal(p, ppmask); 1585 cv_broadcast(&p->p_pptr->p_waitcv); 1586 } 1587 1588 /* 1589 * Stop the current process and switch away to the debugger notifying 1590 * an event specific to a traced process only. 1591 */ 1592 void 1593 eventswitch(int code, int pe_report_event, int entity) 1594 { 1595 struct lwp *l = curlwp; 1596 struct proc *p = l->l_proc; 1597 struct sigacts *ps; 1598 sigset_t *mask; 1599 sig_t action; 1600 ksiginfo_t ksi; 1601 const int signo = SIGTRAP; 1602 1603 KASSERT(mutex_owned(&proc_lock)); 1604 KASSERT(mutex_owned(p->p_lock)); 1605 KASSERT(p->p_pptr != initproc); 1606 KASSERT(l->l_stat == LSONPROC); 1607 KASSERT(ISSET(p->p_slflag, PSL_TRACED)); 1608 KASSERT(!ISSET(l->l_flag, LW_SYSTEM)); 1609 KASSERT(p->p_nrlwps > 0); 1610 KASSERT((code == TRAP_CHLD) || (code == TRAP_LWP) || 1611 (code == TRAP_EXEC)); 1612 KASSERT((code != TRAP_CHLD) || (entity > 1)); /* prevent pid1 */ 1613 KASSERT((code != TRAP_LWP) || (entity > 0)); 1614 1615 repeat: 1616 /* 1617 * If we are exiting, demise now. 1618 * 1619 * This avoids notifying tracer and deadlocking. 1620 */ 1621 if (__predict_false(ISSET(p->p_sflag, PS_WEXIT))) { 1622 mutex_exit(p->p_lock); 1623 mutex_exit(&proc_lock); 1624 1625 if (pe_report_event == PTRACE_LWP_EXIT) { 1626 /* Avoid double lwp_exit() and panic. */ 1627 return; 1628 } 1629 1630 lwp_exit(l); 1631 panic("eventswitch"); 1632 /* NOTREACHED */ 1633 } 1634 1635 /* 1636 * If we are no longer traced, abandon this event signal. 1637 * 1638 * This avoids killing a process after detaching the debugger. 1639 */ 1640 if (__predict_false(!ISSET(p->p_slflag, PSL_TRACED))) { 1641 mutex_exit(p->p_lock); 1642 mutex_exit(&proc_lock); 1643 return; 1644 } 1645 1646 /* 1647 * If there's a pending SIGKILL process it immediately. 1648 */ 1649 if (p->p_xsig == SIGKILL || 1650 sigismember(&p->p_sigpend.sp_set, SIGKILL)) { 1651 mutex_exit(p->p_lock); 1652 mutex_exit(&proc_lock); 1653 return; 1654 } 1655 1656 /* 1657 * The process is already stopping. 1658 */ 1659 if ((p->p_sflag & PS_STOPPING) != 0) { 1660 mutex_exit(&proc_lock); 1661 sigswitch_unlock_and_switch_away(l); 1662 mutex_enter(&proc_lock); 1663 mutex_enter(p->p_lock); 1664 goto repeat; 1665 } 1666 1667 KSI_INIT_TRAP(&ksi); 1668 ksi.ksi_lid = l->l_lid; 1669 ksi.ksi_signo = signo; 1670 ksi.ksi_code = code; 1671 ksi.ksi_pe_report_event = pe_report_event; 1672 1673 CTASSERT(sizeof(ksi.ksi_pe_other_pid) == sizeof(ksi.ksi_pe_lwp)); 1674 ksi.ksi_pe_other_pid = entity; 1675 1676 /* Needed for ktrace */ 1677 ps = p->p_sigacts; 1678 action = SIGACTION_PS(ps, signo).sa_handler; 1679 mask = &l->l_sigmask; 1680 1681 p->p_xsig = signo; 1682 p->p_sigctx.ps_faked = true; 1683 p->p_sigctx.ps_lwp = ksi.ksi_lid; 1684 p->p_sigctx.ps_info = ksi.ksi_info; 1685 1686 sigswitch(0, signo, true); 1687 1688 if (code == TRAP_CHLD) { 1689 mutex_enter(&proc_lock); 1690 while (l->l_vforkwaiting) 1691 cv_wait(&l->l_waitcv, &proc_lock); 1692 mutex_exit(&proc_lock); 1693 } 1694 1695 if (ktrpoint(KTR_PSIG)) { 1696 if (p->p_emul->e_ktrpsig) 1697 p->p_emul->e_ktrpsig(signo, action, mask, &ksi); 1698 else 1699 ktrpsig(signo, action, mask, &ksi); 1700 } 1701 } 1702 1703 void 1704 eventswitchchild(struct proc *p, int code, int pe_report_event) 1705 { 1706 mutex_enter(&proc_lock); 1707 mutex_enter(p->p_lock); 1708 if ((p->p_slflag & (PSL_TRACED|PSL_TRACEDCHILD)) != 1709 (PSL_TRACED|PSL_TRACEDCHILD)) { 1710 mutex_exit(p->p_lock); 1711 mutex_exit(&proc_lock); 1712 return; 1713 } 1714 eventswitch(code, pe_report_event, p->p_oppid); 1715 } 1716 1717 /* 1718 * Stop the current process and switch away when being stopped or traced. 1719 */ 1720 static void 1721 sigswitch(int ppmask, int signo, bool proc_lock_held) 1722 { 1723 struct lwp *l = curlwp; 1724 struct proc *p = l->l_proc; 1725 1726 KASSERT(mutex_owned(p->p_lock)); 1727 KASSERT(l->l_stat == LSONPROC); 1728 KASSERT(p->p_nrlwps > 0); 1729 1730 if (proc_lock_held) { 1731 KASSERT(mutex_owned(&proc_lock)); 1732 } else { 1733 KASSERT(!mutex_owned(&proc_lock)); 1734 } 1735 1736 /* 1737 * On entry we know that the process needs to stop. If it's 1738 * the result of a 'sideways' stop signal that has been sourced 1739 * through issignal(), then stop other LWPs in the process too. 1740 */ 1741 if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) { 1742 KASSERT(signo != 0); 1743 proc_stop(p, signo); 1744 KASSERT(p->p_nrlwps > 0); 1745 } 1746 1747 /* 1748 * If we are the last live LWP, and the stop was a result of 1749 * a new signal, then signal the parent. 1750 */ 1751 if ((p->p_sflag & PS_STOPPING) != 0) { 1752 if (!proc_lock_held && !mutex_tryenter(&proc_lock)) { 1753 mutex_exit(p->p_lock); 1754 mutex_enter(&proc_lock); 1755 mutex_enter(p->p_lock); 1756 } 1757 1758 if (p->p_nrlwps == 1 && (p->p_sflag & PS_STOPPING) != 0) { 1759 /* 1760 * Note that proc_stop_done() can drop 1761 * p->p_lock briefly. 1762 */ 1763 proc_stop_done(p, ppmask); 1764 } 1765 1766 mutex_exit(&proc_lock); 1767 } 1768 1769 sigswitch_unlock_and_switch_away(l); 1770 } 1771 1772 /* 1773 * Unlock and switch away. 1774 */ 1775 static void 1776 sigswitch_unlock_and_switch_away(struct lwp *l) 1777 { 1778 struct proc *p; 1779 int biglocks; 1780 1781 p = l->l_proc; 1782 1783 KASSERT(mutex_owned(p->p_lock)); 1784 KASSERT(!mutex_owned(&proc_lock)); 1785 1786 KASSERT(l->l_stat == LSONPROC); 1787 KASSERT(p->p_nrlwps > 0); 1788 1789 KERNEL_UNLOCK_ALL(l, &biglocks); 1790 if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) { 1791 p->p_nrlwps--; 1792 lwp_lock(l); 1793 KASSERT(l->l_stat == LSONPROC || l->l_stat == LSSLEEP); 1794 l->l_stat = LSSTOP; 1795 lwp_unlock(l); 1796 } 1797 1798 mutex_exit(p->p_lock); 1799 lwp_lock(l); 1800 spc_lock(l->l_cpu); 1801 mi_switch(l); 1802 KERNEL_LOCK(biglocks, l); 1803 } 1804 1805 /* 1806 * Check for a signal from the debugger. 1807 */ 1808 static int 1809 sigchecktrace(void) 1810 { 1811 struct lwp *l = curlwp; 1812 struct proc *p = l->l_proc; 1813 int signo; 1814 1815 KASSERT(mutex_owned(p->p_lock)); 1816 1817 /* If there's a pending SIGKILL, process it immediately. */ 1818 if (sigismember(&p->p_sigpend.sp_set, SIGKILL)) 1819 return 0; 1820 1821 /* 1822 * If we are no longer being traced, or the parent didn't 1823 * give us a signal, or we're stopping, look for more signals. 1824 */ 1825 if ((p->p_slflag & PSL_TRACED) == 0 || p->p_xsig == 0 || 1826 (p->p_sflag & PS_STOPPING) != 0) 1827 return 0; 1828 1829 /* 1830 * If the new signal is being masked, look for other signals. 1831 * `p->p_sigctx.ps_siglist |= mask' is done in setrunnable(). 1832 */ 1833 signo = p->p_xsig; 1834 p->p_xsig = 0; 1835 if (sigismember(&l->l_sigmask, signo)) { 1836 signo = 0; 1837 } 1838 return signo; 1839 } 1840 1841 /* 1842 * If the current process has received a signal (should be caught or cause 1843 * termination, should interrupt current syscall), return the signal number. 1844 * 1845 * Stop signals with default action are processed immediately, then cleared; 1846 * they aren't returned. This is checked after each entry to the system for 1847 * a syscall or trap. 1848 * 1849 * We will also return -1 if the process is exiting and the current LWP must 1850 * follow suit. 1851 */ 1852 int 1853 issignal(struct lwp *l) 1854 { 1855 struct proc *p; 1856 int siglwp, signo, prop; 1857 sigpend_t *sp; 1858 sigset_t ss; 1859 bool traced; 1860 1861 p = l->l_proc; 1862 sp = NULL; 1863 signo = 0; 1864 1865 KASSERT(p == curproc); 1866 KASSERT(mutex_owned(p->p_lock)); 1867 1868 for (;;) { 1869 /* Discard any signals that we have decided not to take. */ 1870 if (signo != 0) { 1871 (void)sigget(sp, NULL, signo, NULL); 1872 } 1873 1874 /* 1875 * If the process is stopped/stopping, then stop ourselves 1876 * now that we're on the kernel/userspace boundary. When 1877 * we awaken, check for a signal from the debugger. 1878 */ 1879 if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) { 1880 sigswitch_unlock_and_switch_away(l); 1881 mutex_enter(p->p_lock); 1882 continue; 1883 } else if (p->p_stat == SACTIVE) 1884 signo = sigchecktrace(); 1885 else 1886 signo = 0; 1887 1888 /* Signals from the debugger are "out of band". */ 1889 sp = NULL; 1890 1891 /* 1892 * If the debugger didn't provide a signal, find a pending 1893 * signal from our set. Check per-LWP signals first, and 1894 * then per-process. 1895 */ 1896 if (signo == 0) { 1897 sp = &l->l_sigpend; 1898 ss = sp->sp_set; 1899 siglwp = l->l_lid; 1900 if ((p->p_lflag & PL_PPWAIT) != 0) 1901 sigminusset(&vforksigmask, &ss); 1902 sigminusset(&l->l_sigmask, &ss); 1903 1904 if ((signo = firstsig(&ss)) == 0) { 1905 sp = &p->p_sigpend; 1906 ss = sp->sp_set; 1907 siglwp = 0; 1908 if ((p->p_lflag & PL_PPWAIT) != 0) 1909 sigminusset(&vforksigmask, &ss); 1910 sigminusset(&l->l_sigmask, &ss); 1911 1912 if ((signo = firstsig(&ss)) == 0) { 1913 /* 1914 * No signal pending - clear the 1915 * indicator and bail out. 1916 */ 1917 lwp_lock(l); 1918 l->l_flag &= ~LW_PENDSIG; 1919 lwp_unlock(l); 1920 sp = NULL; 1921 break; 1922 } 1923 } 1924 } 1925 1926 traced = ISSET(p->p_slflag, PSL_TRACED) && 1927 !sigismember(&p->p_sigctx.ps_sigpass, signo); 1928 1929 if (sp) { 1930 /* Overwrite process' signal context to correspond 1931 * to the currently reported LWP. This is necessary 1932 * for PT_GET_SIGINFO to report the correct signal when 1933 * multiple LWPs have pending signals. We do this only 1934 * when the signal comes from the queue, for signals 1935 * created by the debugger we assume it set correct 1936 * siginfo. 1937 */ 1938 ksiginfo_t *ksi = TAILQ_FIRST(&sp->sp_info); 1939 if (ksi) { 1940 p->p_sigctx.ps_lwp = ksi->ksi_lid; 1941 p->p_sigctx.ps_info = ksi->ksi_info; 1942 } else { 1943 p->p_sigctx.ps_lwp = siglwp; 1944 memset(&p->p_sigctx.ps_info, 0, 1945 sizeof(p->p_sigctx.ps_info)); 1946 p->p_sigctx.ps_info._signo = signo; 1947 p->p_sigctx.ps_info._code = SI_NOINFO; 1948 } 1949 } 1950 1951 /* 1952 * We should see pending but ignored signals only if 1953 * we are being traced. 1954 */ 1955 if (sigismember(&p->p_sigctx.ps_sigignore, signo) && 1956 !traced) { 1957 /* Discard the signal. */ 1958 continue; 1959 } 1960 1961 /* 1962 * If traced, always stop, and stay stopped until released 1963 * by the debugger. If the our parent is our debugger waiting 1964 * for us and we vforked, don't hang as we could deadlock. 1965 */ 1966 if (traced && signo != SIGKILL && 1967 !(ISSET(p->p_lflag, PL_PPWAIT) && 1968 (p->p_pptr == p->p_opptr))) { 1969 /* 1970 * Take the signal, but don't remove it from the 1971 * siginfo queue, because the debugger can send 1972 * it later. 1973 */ 1974 if (sp) 1975 sigdelset(&sp->sp_set, signo); 1976 p->p_xsig = signo; 1977 1978 /* Handling of signal trace */ 1979 sigswitch(0, signo, false); 1980 mutex_enter(p->p_lock); 1981 1982 /* Check for a signal from the debugger. */ 1983 if ((signo = sigchecktrace()) == 0) 1984 continue; 1985 1986 /* Signals from the debugger are "out of band". */ 1987 sp = NULL; 1988 } 1989 1990 prop = sigprop[signo]; 1991 1992 /* 1993 * Decide whether the signal should be returned. 1994 */ 1995 switch ((long)SIGACTION(p, signo).sa_handler) { 1996 case (long)SIG_DFL: 1997 /* 1998 * Don't take default actions on system processes. 1999 */ 2000 if (p->p_pid <= 1) { 2001 #ifdef DIAGNOSTIC 2002 /* 2003 * Are you sure you want to ignore SIGSEGV 2004 * in init? XXX 2005 */ 2006 printf_nolog("Process (pid %d) got sig %d\n", 2007 p->p_pid, signo); 2008 #endif 2009 continue; 2010 } 2011 2012 /* 2013 * If there is a pending stop signal to process with 2014 * default action, stop here, then clear the signal. 2015 * However, if process is member of an orphaned 2016 * process group, ignore tty stop signals. 2017 */ 2018 if (prop & SA_STOP) { 2019 /* 2020 * XXX Don't hold proc_lock for p_lflag, 2021 * but it's not a big deal. 2022 */ 2023 if ((traced && 2024 !(ISSET(p->p_lflag, PL_PPWAIT) && 2025 (p->p_pptr == p->p_opptr))) || 2026 ((p->p_lflag & PL_ORPHANPG) != 0 && 2027 prop & SA_TTYSTOP)) { 2028 /* Ignore the signal. */ 2029 continue; 2030 } 2031 /* Take the signal. */ 2032 (void)sigget(sp, NULL, signo, NULL); 2033 p->p_xsig = signo; 2034 p->p_sflag &= ~PS_CONTINUED; 2035 signo = 0; 2036 sigswitch(PS_NOCLDSTOP, p->p_xsig, false); 2037 mutex_enter(p->p_lock); 2038 } else if (prop & SA_IGNORE) { 2039 /* 2040 * Except for SIGCONT, shouldn't get here. 2041 * Default action is to ignore; drop it. 2042 */ 2043 continue; 2044 } 2045 break; 2046 2047 case (long)SIG_IGN: 2048 #ifdef DEBUG_ISSIGNAL 2049 /* 2050 * Masking above should prevent us ever trying 2051 * to take action on an ignored signal other 2052 * than SIGCONT, unless process is traced. 2053 */ 2054 if ((prop & SA_CONT) == 0 && !traced) 2055 printf_nolog("issignal\n"); 2056 #endif 2057 continue; 2058 2059 default: 2060 /* 2061 * This signal has an action, let postsig() process 2062 * it. 2063 */ 2064 break; 2065 } 2066 2067 break; 2068 } 2069 2070 l->l_sigpendset = sp; 2071 return signo; 2072 } 2073 2074 /* 2075 * Take the action for the specified signal 2076 * from the current set of pending signals. 2077 */ 2078 void 2079 postsig(int signo) 2080 { 2081 struct lwp *l; 2082 struct proc *p; 2083 struct sigacts *ps; 2084 sig_t action; 2085 sigset_t *returnmask; 2086 ksiginfo_t ksi; 2087 2088 l = curlwp; 2089 p = l->l_proc; 2090 ps = p->p_sigacts; 2091 2092 KASSERT(mutex_owned(p->p_lock)); 2093 KASSERT(signo > 0); 2094 2095 /* 2096 * Set the new mask value and also defer further occurrences of this 2097 * signal. 2098 * 2099 * Special case: user has done a sigsuspend. Here the current mask is 2100 * not of interest, but rather the mask from before the sigsuspend is 2101 * what we want restored after the signal processing is completed. 2102 */ 2103 if (l->l_sigrestore) { 2104 returnmask = &l->l_sigoldmask; 2105 l->l_sigrestore = 0; 2106 } else 2107 returnmask = &l->l_sigmask; 2108 2109 /* 2110 * Commit to taking the signal before releasing the mutex. 2111 */ 2112 action = SIGACTION_PS(ps, signo).sa_handler; 2113 l->l_ru.ru_nsignals++; 2114 if (l->l_sigpendset == NULL) { 2115 /* From the debugger */ 2116 if (p->p_sigctx.ps_faked && 2117 signo == p->p_sigctx.ps_info._signo) { 2118 KSI_INIT(&ksi); 2119 ksi.ksi_info = p->p_sigctx.ps_info; 2120 ksi.ksi_lid = p->p_sigctx.ps_lwp; 2121 p->p_sigctx.ps_faked = false; 2122 } else { 2123 if (!siggetinfo(&l->l_sigpend, &ksi, signo)) 2124 (void)siggetinfo(&p->p_sigpend, &ksi, signo); 2125 } 2126 } else 2127 sigget(l->l_sigpendset, &ksi, signo, NULL); 2128 2129 if (ktrpoint(KTR_PSIG)) { 2130 mutex_exit(p->p_lock); 2131 if (p->p_emul->e_ktrpsig) 2132 p->p_emul->e_ktrpsig(signo, action, 2133 returnmask, &ksi); 2134 else 2135 ktrpsig(signo, action, returnmask, &ksi); 2136 mutex_enter(p->p_lock); 2137 } 2138 2139 SDT_PROBE(proc, kernel, , signal__handle, signo, &ksi, action, 0, 0); 2140 2141 if (action == SIG_DFL) { 2142 /* 2143 * Default action, where the default is to kill 2144 * the process. (Other cases were ignored above.) 2145 */ 2146 sigexit(l, signo); 2147 return; 2148 } 2149 2150 /* 2151 * If we get here, the signal must be caught. 2152 */ 2153 #ifdef DIAGNOSTIC 2154 if (action == SIG_IGN || sigismember(&l->l_sigmask, signo)) 2155 panic("postsig action"); 2156 #endif 2157 2158 kpsendsig(l, &ksi, returnmask); 2159 } 2160 2161 /* 2162 * sendsig: 2163 * 2164 * Default signal delivery method for NetBSD. 2165 */ 2166 void 2167 sendsig(const struct ksiginfo *ksi, const sigset_t *mask) 2168 { 2169 struct sigacts *sa; 2170 int sig; 2171 2172 sig = ksi->ksi_signo; 2173 sa = curproc->p_sigacts; 2174 2175 switch (sa->sa_sigdesc[sig].sd_vers) { 2176 case __SIGTRAMP_SIGCODE_VERSION: 2177 #ifdef __HAVE_STRUCT_SIGCONTEXT 2178 case __SIGTRAMP_SIGCONTEXT_VERSION_MIN ... 2179 __SIGTRAMP_SIGCONTEXT_VERSION_MAX: 2180 /* Compat for 1.6 and earlier. */ 2181 MODULE_HOOK_CALL_VOID(sendsig_sigcontext_16_hook, (ksi, mask), 2182 break); 2183 return; 2184 #endif /* __HAVE_STRUCT_SIGCONTEXT */ 2185 case __SIGTRAMP_SIGINFO_VERSION_MIN ... 2186 __SIGTRAMP_SIGINFO_VERSION_MAX: 2187 sendsig_siginfo(ksi, mask); 2188 return; 2189 default: 2190 break; 2191 } 2192 2193 printf("sendsig: bad version %d\n", sa->sa_sigdesc[sig].sd_vers); 2194 sigexit(curlwp, SIGILL); 2195 } 2196 2197 /* 2198 * sendsig_reset: 2199 * 2200 * Reset the signal action. Called from emulation specific sendsig() 2201 * before unlocking to deliver the signal. 2202 */ 2203 void 2204 sendsig_reset(struct lwp *l, int signo) 2205 { 2206 struct proc *p = l->l_proc; 2207 struct sigacts *ps = p->p_sigacts; 2208 2209 KASSERT(mutex_owned(p->p_lock)); 2210 2211 p->p_sigctx.ps_lwp = 0; 2212 memset(&p->p_sigctx.ps_info, 0, sizeof(p->p_sigctx.ps_info)); 2213 2214 mutex_enter(&ps->sa_mutex); 2215 sigplusset(&SIGACTION_PS(ps, signo).sa_mask, &l->l_sigmask); 2216 if (SIGACTION_PS(ps, signo).sa_flags & SA_RESETHAND) { 2217 sigdelset(&p->p_sigctx.ps_sigcatch, signo); 2218 if (signo != SIGCONT && sigprop[signo] & SA_IGNORE) 2219 sigaddset(&p->p_sigctx.ps_sigignore, signo); 2220 SIGACTION_PS(ps, signo).sa_handler = SIG_DFL; 2221 } 2222 mutex_exit(&ps->sa_mutex); 2223 } 2224 2225 /* 2226 * Kill the current process for stated reason. 2227 */ 2228 void 2229 killproc(struct proc *p, const char *why) 2230 { 2231 2232 KASSERT(mutex_owned(&proc_lock)); 2233 2234 log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why); 2235 uprintf_locked("sorry, pid %d was killed: %s\n", p->p_pid, why); 2236 psignal(p, SIGKILL); 2237 } 2238 2239 /* 2240 * Force the current process to exit with the specified signal, dumping core 2241 * if appropriate. We bypass the normal tests for masked and caught 2242 * signals, allowing unrecoverable failures to terminate the process without 2243 * changing signal state. Mark the accounting record with the signal 2244 * termination. If dumping core, save the signal number for the debugger. 2245 * Calls exit and does not return. 2246 */ 2247 void 2248 sigexit(struct lwp *l, int signo) 2249 { 2250 int exitsig, error, docore; 2251 struct proc *p; 2252 struct lwp *t; 2253 2254 p = l->l_proc; 2255 2256 KASSERT(mutex_owned(p->p_lock)); 2257 KERNEL_UNLOCK_ALL(l, NULL); 2258 2259 /* 2260 * Don't permit coredump() multiple times in the same process. 2261 * Call back into sigexit, where we will be suspended until 2262 * the deed is done. Note that this is a recursive call, but 2263 * LW_WCORE will prevent us from coming back this way. 2264 */ 2265 if ((p->p_sflag & PS_WCORE) != 0) { 2266 lwp_lock(l); 2267 l->l_flag |= (LW_WCORE | LW_WEXIT | LW_WSUSPEND); 2268 lwp_unlock(l); 2269 mutex_exit(p->p_lock); 2270 lwp_userret(l); 2271 panic("sigexit 1"); 2272 /* NOTREACHED */ 2273 } 2274 2275 /* If process is already on the way out, then bail now. */ 2276 if ((p->p_sflag & PS_WEXIT) != 0) { 2277 mutex_exit(p->p_lock); 2278 lwp_exit(l); 2279 panic("sigexit 2"); 2280 /* NOTREACHED */ 2281 } 2282 2283 /* 2284 * Prepare all other LWPs for exit. If dumping core, suspend them 2285 * so that their registers are available long enough to be dumped. 2286 */ 2287 if ((docore = (sigprop[signo] & SA_CORE)) != 0) { 2288 p->p_sflag |= PS_WCORE; 2289 for (;;) { 2290 LIST_FOREACH(t, &p->p_lwps, l_sibling) { 2291 lwp_lock(t); 2292 if (t == l) { 2293 t->l_flag &= 2294 ~(LW_WSUSPEND | LW_DBGSUSPEND); 2295 lwp_unlock(t); 2296 continue; 2297 } 2298 t->l_flag |= (LW_WCORE | LW_WEXIT); 2299 lwp_suspend(l, t); 2300 } 2301 2302 if (p->p_nrlwps == 1) 2303 break; 2304 2305 /* 2306 * Kick any LWPs sitting in lwp_wait1(), and wait 2307 * for everyone else to stop before proceeding. 2308 */ 2309 p->p_nlwpwait++; 2310 cv_broadcast(&p->p_lwpcv); 2311 cv_wait(&p->p_lwpcv, p->p_lock); 2312 p->p_nlwpwait--; 2313 } 2314 } 2315 2316 exitsig = signo; 2317 p->p_acflag |= AXSIG; 2318 memset(&p->p_sigctx.ps_info, 0, sizeof(p->p_sigctx.ps_info)); 2319 p->p_sigctx.ps_info._signo = signo; 2320 p->p_sigctx.ps_info._code = SI_NOINFO; 2321 2322 if (docore) { 2323 mutex_exit(p->p_lock); 2324 MODULE_HOOK_CALL(coredump_hook, (l, NULL), enosys(), error); 2325 2326 if (kern_logsigexit) { 2327 int uid = l->l_cred ? 2328 (int)kauth_cred_geteuid(l->l_cred) : -1; 2329 2330 if (error) 2331 log(LOG_INFO, lognocoredump, p->p_pid, 2332 p->p_comm, uid, signo, error); 2333 else 2334 log(LOG_INFO, logcoredump, p->p_pid, 2335 p->p_comm, uid, signo); 2336 } 2337 2338 #ifdef PAX_SEGVGUARD 2339 rw_enter(&exec_lock, RW_WRITER); 2340 pax_segvguard(l, p->p_textvp, p->p_comm, true); 2341 rw_exit(&exec_lock); 2342 #endif /* PAX_SEGVGUARD */ 2343 2344 /* Acquire the sched state mutex. exit1() will release it. */ 2345 mutex_enter(p->p_lock); 2346 if (error == 0) 2347 p->p_sflag |= PS_COREDUMP; 2348 } 2349 2350 /* No longer dumping core. */ 2351 p->p_sflag &= ~PS_WCORE; 2352 2353 exit1(l, 0, exitsig); 2354 /* NOTREACHED */ 2355 } 2356 2357 /* 2358 * Since the "real" code may (or may not) be present in loadable module, 2359 * we provide routines here which calls the module hooks. 2360 */ 2361 2362 int 2363 coredump_netbsd(struct lwp *l, struct coredump_iostate *iocookie) 2364 { 2365 2366 int retval; 2367 2368 MODULE_HOOK_CALL(coredump_netbsd_hook, (l, iocookie), ENOSYS, retval); 2369 return retval; 2370 } 2371 2372 int 2373 coredump_netbsd32(struct lwp *l, struct coredump_iostate *iocookie) 2374 { 2375 2376 int retval; 2377 2378 MODULE_HOOK_CALL(coredump_netbsd32_hook, (l, iocookie), ENOSYS, retval); 2379 return retval; 2380 } 2381 2382 int 2383 coredump_elf32(struct lwp *l, struct coredump_iostate *iocookie) 2384 { 2385 int retval; 2386 2387 MODULE_HOOK_CALL(coredump_elf32_hook, (l, iocookie), ENOSYS, retval); 2388 return retval; 2389 } 2390 2391 int 2392 coredump_elf64(struct lwp *l, struct coredump_iostate *iocookie) 2393 { 2394 int retval; 2395 2396 MODULE_HOOK_CALL(coredump_elf64_hook, (l, iocookie), ENOSYS, retval); 2397 return retval; 2398 } 2399 2400 /* 2401 * Put process 'p' into the stopped state and optionally, notify the parent. 2402 */ 2403 void 2404 proc_stop(struct proc *p, int signo) 2405 { 2406 struct lwp *l; 2407 2408 KASSERT(mutex_owned(p->p_lock)); 2409 2410 /* 2411 * First off, set the stopping indicator and bring all sleeping 2412 * LWPs to a halt so they are included in p->p_nrlwps. We musn't 2413 * unlock between here and the p->p_nrlwps check below. 2414 */ 2415 p->p_sflag |= PS_STOPPING; 2416 membar_producer(); 2417 2418 proc_stop_lwps(p); 2419 2420 /* 2421 * If there are no LWPs available to take the signal, then we 2422 * signal the parent process immediately. Otherwise, the last 2423 * LWP to stop will take care of it. 2424 */ 2425 2426 if (p->p_nrlwps == 0) { 2427 proc_stop_done(p, PS_NOCLDSTOP); 2428 } else { 2429 /* 2430 * Have the remaining LWPs come to a halt, and trigger 2431 * proc_stop_callout() to ensure that they do. 2432 */ 2433 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 2434 sigpost(l, SIG_DFL, SA_STOP, signo); 2435 } 2436 callout_schedule(&proc_stop_ch, 1); 2437 } 2438 } 2439 2440 /* 2441 * When stopping a process, we do not immediately set sleeping LWPs stopped, 2442 * but wait for them to come to a halt at the kernel-user boundary. This is 2443 * to allow LWPs to release any locks that they may hold before stopping. 2444 * 2445 * Non-interruptable sleeps can be long, and there is the potential for an 2446 * LWP to begin sleeping interruptably soon after the process has been set 2447 * stopping (PS_STOPPING). These LWPs will not notice that the process is 2448 * stopping, and so complete halt of the process and the return of status 2449 * information to the parent could be delayed indefinitely. 2450 * 2451 * To handle this race, proc_stop_callout() runs once per tick while there 2452 * are stopping processes in the system. It sets LWPs that are sleeping 2453 * interruptably into the LSSTOP state. 2454 * 2455 * Note that we are not concerned about keeping all LWPs stopped while the 2456 * process is stopped: stopped LWPs can awaken briefly to handle signals. 2457 * What we do need to ensure is that all LWPs in a stopping process have 2458 * stopped at least once, so that notification can be sent to the parent 2459 * process. 2460 */ 2461 static void 2462 proc_stop_callout(void *cookie) 2463 { 2464 bool more, restart; 2465 struct proc *p; 2466 2467 (void)cookie; 2468 2469 do { 2470 restart = false; 2471 more = false; 2472 2473 mutex_enter(&proc_lock); 2474 PROCLIST_FOREACH(p, &allproc) { 2475 mutex_enter(p->p_lock); 2476 2477 if ((p->p_sflag & PS_STOPPING) == 0) { 2478 mutex_exit(p->p_lock); 2479 continue; 2480 } 2481 2482 /* Stop any LWPs sleeping interruptably. */ 2483 proc_stop_lwps(p); 2484 if (p->p_nrlwps == 0) { 2485 /* 2486 * We brought the process to a halt. 2487 * Mark it as stopped and notify the 2488 * parent. 2489 * 2490 * Note that proc_stop_done() will 2491 * drop p->p_lock briefly. 2492 * Arrange to restart and check 2493 * all processes again. 2494 */ 2495 restart = true; 2496 proc_stop_done(p, PS_NOCLDSTOP); 2497 } else 2498 more = true; 2499 2500 mutex_exit(p->p_lock); 2501 if (restart) 2502 break; 2503 } 2504 mutex_exit(&proc_lock); 2505 } while (restart); 2506 2507 /* 2508 * If we noted processes that are stopping but still have 2509 * running LWPs, then arrange to check again in 1 tick. 2510 */ 2511 if (more) 2512 callout_schedule(&proc_stop_ch, 1); 2513 } 2514 2515 /* 2516 * Given a process in state SSTOP, set the state back to SACTIVE and 2517 * move LSSTOP'd LWPs to LSSLEEP or make them runnable. 2518 */ 2519 void 2520 proc_unstop(struct proc *p) 2521 { 2522 struct lwp *l; 2523 int sig; 2524 2525 KASSERT(mutex_owned(&proc_lock)); 2526 KASSERT(mutex_owned(p->p_lock)); 2527 2528 p->p_stat = SACTIVE; 2529 p->p_sflag &= ~PS_STOPPING; 2530 sig = p->p_xsig; 2531 2532 if (!p->p_waited) 2533 p->p_pptr->p_nstopchild--; 2534 2535 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 2536 lwp_lock(l); 2537 if (l->l_stat != LSSTOP || (l->l_flag & LW_DBGSUSPEND) != 0) { 2538 lwp_unlock(l); 2539 continue; 2540 } 2541 if (l->l_wchan == NULL) { 2542 setrunnable(l); 2543 continue; 2544 } 2545 if (sig && (l->l_flag & LW_SINTR) != 0) { 2546 setrunnable(l); 2547 sig = 0; 2548 } else { 2549 l->l_stat = LSSLEEP; 2550 p->p_nrlwps++; 2551 lwp_unlock(l); 2552 } 2553 } 2554 } 2555 2556 void 2557 proc_stoptrace(int trapno, int sysnum, const register_t args[], 2558 const register_t *ret, int error) 2559 { 2560 struct lwp *l = curlwp; 2561 struct proc *p = l->l_proc; 2562 struct sigacts *ps; 2563 sigset_t *mask; 2564 sig_t action; 2565 ksiginfo_t ksi; 2566 size_t i, sy_narg; 2567 const int signo = SIGTRAP; 2568 2569 KASSERT((trapno == TRAP_SCE) || (trapno == TRAP_SCX)); 2570 KASSERT(p->p_pptr != initproc); 2571 KASSERT(ISSET(p->p_slflag, PSL_TRACED)); 2572 KASSERT(ISSET(p->p_slflag, PSL_SYSCALL)); 2573 2574 sy_narg = p->p_emul->e_sysent[sysnum].sy_narg; 2575 2576 KSI_INIT_TRAP(&ksi); 2577 ksi.ksi_lid = l->l_lid; 2578 ksi.ksi_signo = signo; 2579 ksi.ksi_code = trapno; 2580 2581 ksi.ksi_sysnum = sysnum; 2582 if (trapno == TRAP_SCE) { 2583 ksi.ksi_retval[0] = 0; 2584 ksi.ksi_retval[1] = 0; 2585 ksi.ksi_error = 0; 2586 } else { 2587 ksi.ksi_retval[0] = ret[0]; 2588 ksi.ksi_retval[1] = ret[1]; 2589 ksi.ksi_error = error; 2590 } 2591 2592 memset(ksi.ksi_args, 0, sizeof(ksi.ksi_args)); 2593 2594 for (i = 0; i < sy_narg; i++) 2595 ksi.ksi_args[i] = args[i]; 2596 2597 mutex_enter(p->p_lock); 2598 2599 repeat: 2600 /* 2601 * If we are exiting, demise now. 2602 * 2603 * This avoids notifying tracer and deadlocking. 2604 */ 2605 if (__predict_false(ISSET(p->p_sflag, PS_WEXIT))) { 2606 mutex_exit(p->p_lock); 2607 lwp_exit(l); 2608 panic("proc_stoptrace"); 2609 /* NOTREACHED */ 2610 } 2611 2612 /* 2613 * If there's a pending SIGKILL process it immediately. 2614 */ 2615 if (p->p_xsig == SIGKILL || 2616 sigismember(&p->p_sigpend.sp_set, SIGKILL)) { 2617 mutex_exit(p->p_lock); 2618 return; 2619 } 2620 2621 /* 2622 * If we are no longer traced, abandon this event signal. 2623 * 2624 * This avoids killing a process after detaching the debugger. 2625 */ 2626 if (__predict_false(!ISSET(p->p_slflag, PSL_TRACED))) { 2627 mutex_exit(p->p_lock); 2628 return; 2629 } 2630 2631 /* 2632 * The process is already stopping. 2633 */ 2634 if ((p->p_sflag & PS_STOPPING) != 0) { 2635 sigswitch_unlock_and_switch_away(l); 2636 mutex_enter(p->p_lock); 2637 goto repeat; 2638 } 2639 2640 /* Needed for ktrace */ 2641 ps = p->p_sigacts; 2642 action = SIGACTION_PS(ps, signo).sa_handler; 2643 mask = &l->l_sigmask; 2644 2645 p->p_xsig = signo; 2646 p->p_sigctx.ps_lwp = ksi.ksi_lid; 2647 p->p_sigctx.ps_info = ksi.ksi_info; 2648 sigswitch(0, signo, false); 2649 2650 if (ktrpoint(KTR_PSIG)) { 2651 if (p->p_emul->e_ktrpsig) 2652 p->p_emul->e_ktrpsig(signo, action, mask, &ksi); 2653 else 2654 ktrpsig(signo, action, mask, &ksi); 2655 } 2656 } 2657 2658 static int 2659 filt_sigattach(struct knote *kn) 2660 { 2661 struct proc *p = curproc; 2662 2663 kn->kn_obj = p; 2664 kn->kn_flags |= EV_CLEAR; /* automatically set */ 2665 2666 mutex_enter(p->p_lock); 2667 klist_insert(&p->p_klist, kn); 2668 mutex_exit(p->p_lock); 2669 2670 return 0; 2671 } 2672 2673 static void 2674 filt_sigdetach(struct knote *kn) 2675 { 2676 struct proc *p = kn->kn_obj; 2677 2678 mutex_enter(p->p_lock); 2679 klist_remove(&p->p_klist, kn); 2680 mutex_exit(p->p_lock); 2681 } 2682 2683 /* 2684 * Signal knotes are shared with proc knotes, so we apply a mask to 2685 * the hint in order to differentiate them from process hints. This 2686 * could be avoided by using a signal-specific knote list, but probably 2687 * isn't worth the trouble. 2688 */ 2689 static int 2690 filt_signal(struct knote *kn, long hint) 2691 { 2692 2693 if (hint & NOTE_SIGNAL) { 2694 hint &= ~NOTE_SIGNAL; 2695 2696 if (kn->kn_id == hint) 2697 kn->kn_data++; 2698 } 2699 return (kn->kn_data != 0); 2700 } 2701 2702 const struct filterops sig_filtops = { 2703 .f_flags = FILTEROP_MPSAFE, 2704 .f_attach = filt_sigattach, 2705 .f_detach = filt_sigdetach, 2706 .f_event = filt_signal, 2707 }; 2708