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