1 /* $NetBSD: kern_sig.c,v 1.272 2008/02/20 11:48:46 yamt Exp $ */ 2 3 /*- 4 * Copyright (c) 2006, 2007 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Copyright (c) 1982, 1986, 1989, 1991, 1993 41 * The Regents of the University of California. All rights reserved. 42 * (c) UNIX System Laboratories, Inc. 43 * All or some portions of this file are derived from material licensed 44 * to the University of California by American Telephone and Telegraph 45 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 46 * the permission of UNIX System Laboratories, Inc. 47 * 48 * Redistribution and use in source and binary forms, with or without 49 * modification, are permitted provided that the following conditions 50 * are met: 51 * 1. Redistributions of source code must retain the above copyright 52 * notice, this list of conditions and the following disclaimer. 53 * 2. Redistributions in binary form must reproduce the above copyright 54 * notice, this list of conditions and the following disclaimer in the 55 * documentation and/or other materials provided with the distribution. 56 * 3. Neither the name of the University nor the names of its contributors 57 * may be used to endorse or promote products derived from this software 58 * without specific prior written permission. 59 * 60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 63 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 70 * SUCH DAMAGE. 71 * 72 * @(#)kern_sig.c 8.14 (Berkeley) 5/14/95 73 */ 74 75 #include <sys/cdefs.h> 76 __KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.272 2008/02/20 11:48:46 yamt Exp $"); 77 78 #include "opt_ptrace.h" 79 #include "opt_multiprocessor.h" 80 #include "opt_compat_sunos.h" 81 #include "opt_compat_netbsd.h" 82 #include "opt_compat_netbsd32.h" 83 #include "opt_pax.h" 84 85 #define SIGPROP /* include signal properties table */ 86 #include <sys/param.h> 87 #include <sys/signalvar.h> 88 #include <sys/proc.h> 89 #include <sys/systm.h> 90 #include <sys/wait.h> 91 #include <sys/ktrace.h> 92 #include <sys/syslog.h> 93 #include <sys/filedesc.h> 94 #include <sys/file.h> 95 #include <sys/malloc.h> 96 #include <sys/pool.h> 97 #include <sys/ucontext.h> 98 #include <sys/exec.h> 99 #include <sys/kauth.h> 100 #include <sys/acct.h> 101 #include <sys/callout.h> 102 #include <sys/atomic.h> 103 #include <sys/cpu.h> 104 105 #ifdef PAX_SEGVGUARD 106 #include <sys/pax.h> 107 #endif /* PAX_SEGVGUARD */ 108 109 #include <uvm/uvm.h> 110 #include <uvm/uvm_extern.h> 111 112 static void ksiginfo_exechook(struct proc *, void *); 113 static void proc_stop_callout(void *); 114 115 int sigunwait(struct proc *, const ksiginfo_t *); 116 void sigput(sigpend_t *, struct proc *, ksiginfo_t *); 117 int sigpost(struct lwp *, sig_t, int, int); 118 int sigchecktrace(sigpend_t **); 119 void sigswitch(bool, int, int); 120 void sigrealloc(ksiginfo_t *); 121 122 sigset_t contsigmask, stopsigmask, sigcantmask; 123 struct pool sigacts_pool; /* memory pool for sigacts structures */ 124 static void sigacts_poolpage_free(struct pool *, void *); 125 static void *sigacts_poolpage_alloc(struct pool *, int); 126 static callout_t proc_stop_ch; 127 128 static struct pool_allocator sigactspool_allocator = { 129 .pa_alloc = sigacts_poolpage_alloc, 130 .pa_free = sigacts_poolpage_free, 131 }; 132 133 #ifdef DEBUG 134 int kern_logsigexit = 1; 135 #else 136 int kern_logsigexit = 0; 137 #endif 138 139 static const char logcoredump[] = 140 "pid %d (%s), uid %d: exited on signal %d (core dumped)\n"; 141 static const char lognocoredump[] = 142 "pid %d (%s), uid %d: exited on signal %d (core not dumped, err = %d)\n"; 143 144 POOL_INIT(siginfo_pool, sizeof(siginfo_t), 0, 0, 0, "siginfo", 145 &pool_allocator_nointr, IPL_NONE); 146 POOL_INIT(ksiginfo_pool, sizeof(ksiginfo_t), 0, 0, 0, "ksiginfo", 147 NULL, IPL_VM); 148 149 /* 150 * signal_init: 151 * 152 * Initialize global signal-related data structures. 153 */ 154 void 155 signal_init(void) 156 { 157 158 sigactspool_allocator.pa_pagesz = (PAGE_SIZE)*2; 159 160 pool_init(&sigacts_pool, sizeof(struct sigacts), 0, 0, 0, "sigapl", 161 sizeof(struct sigacts) > PAGE_SIZE ? 162 &sigactspool_allocator : &pool_allocator_nointr, 163 IPL_NONE); 164 165 exechook_establish(ksiginfo_exechook, NULL); 166 167 callout_init(&proc_stop_ch, CALLOUT_MPSAFE); 168 callout_setfunc(&proc_stop_ch, proc_stop_callout, NULL); 169 } 170 171 /* 172 * sigacts_poolpage_alloc: 173 * 174 * Allocate a page for the sigacts memory pool. 175 */ 176 static void * 177 sigacts_poolpage_alloc(struct pool *pp, int flags) 178 { 179 180 return (void *)uvm_km_alloc(kernel_map, 181 (PAGE_SIZE)*2, (PAGE_SIZE)*2, 182 ((flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK) 183 | UVM_KMF_WIRED); 184 } 185 186 /* 187 * sigacts_poolpage_free: 188 * 189 * Free a page on behalf of the sigacts memory pool. 190 */ 191 static void 192 sigacts_poolpage_free(struct pool *pp, void *v) 193 { 194 uvm_km_free(kernel_map, (vaddr_t)v, (PAGE_SIZE)*2, UVM_KMF_WIRED); 195 } 196 197 /* 198 * sigactsinit: 199 * 200 * Create an initial sigctx structure, using the same signal state as 201 * p. If 'share' is set, share the sigctx_proc part, otherwise just 202 * copy it from parent. 203 */ 204 struct sigacts * 205 sigactsinit(struct proc *pp, int share) 206 { 207 struct sigacts *ps, *ps2; 208 209 ps = pp->p_sigacts; 210 211 if (share) { 212 mutex_enter(&ps->sa_mutex); 213 ps->sa_refcnt++; 214 mutex_exit(&ps->sa_mutex); 215 ps2 = ps; 216 } else { 217 ps2 = pool_get(&sigacts_pool, PR_WAITOK); 218 /* XXX IPL_SCHED to match p_smutex */ 219 mutex_init(&ps2->sa_mutex, MUTEX_DEFAULT, IPL_SCHED); 220 mutex_enter(&ps->sa_mutex); 221 memcpy(&ps2->sa_sigdesc, ps->sa_sigdesc, 222 sizeof(ps2->sa_sigdesc)); 223 mutex_exit(&ps->sa_mutex); 224 ps2->sa_refcnt = 1; 225 } 226 227 return ps2; 228 } 229 230 /* 231 * sigactsunshare: 232 * 233 * Make this process not share its sigctx, maintaining all 234 * signal state. 235 */ 236 void 237 sigactsunshare(struct proc *p) 238 { 239 struct sigacts *ps, *oldps; 240 241 oldps = p->p_sigacts; 242 if (oldps->sa_refcnt == 1) 243 return; 244 ps = pool_get(&sigacts_pool, PR_WAITOK); 245 /* XXX IPL_SCHED to match p_smutex */ 246 mutex_init(&ps->sa_mutex, MUTEX_DEFAULT, IPL_SCHED); 247 memset(&ps->sa_sigdesc, 0, sizeof(ps->sa_sigdesc)); 248 p->p_sigacts = ps; 249 sigactsfree(oldps); 250 } 251 252 /* 253 * sigactsfree; 254 * 255 * Release a sigctx structure. 256 */ 257 void 258 sigactsfree(struct sigacts *ps) 259 { 260 int refcnt; 261 262 mutex_enter(&ps->sa_mutex); 263 refcnt = --ps->sa_refcnt; 264 mutex_exit(&ps->sa_mutex); 265 266 if (refcnt == 0) { 267 mutex_destroy(&ps->sa_mutex); 268 pool_put(&sigacts_pool, ps); 269 } 270 } 271 272 /* 273 * siginit: 274 * 275 * Initialize signal state for process 0; set to ignore signals that 276 * are ignored by default and disable the signal stack. Locking not 277 * required as the system is still cold. 278 */ 279 void 280 siginit(struct proc *p) 281 { 282 struct lwp *l; 283 struct sigacts *ps; 284 int signo, prop; 285 286 ps = p->p_sigacts; 287 sigemptyset(&contsigmask); 288 sigemptyset(&stopsigmask); 289 sigemptyset(&sigcantmask); 290 for (signo = 1; signo < NSIG; signo++) { 291 prop = sigprop[signo]; 292 if (prop & SA_CONT) 293 sigaddset(&contsigmask, signo); 294 if (prop & SA_STOP) 295 sigaddset(&stopsigmask, signo); 296 if (prop & SA_CANTMASK) 297 sigaddset(&sigcantmask, signo); 298 if (prop & SA_IGNORE && signo != SIGCONT) 299 sigaddset(&p->p_sigctx.ps_sigignore, signo); 300 sigemptyset(&SIGACTION_PS(ps, signo).sa_mask); 301 SIGACTION_PS(ps, signo).sa_flags = SA_RESTART; 302 } 303 sigemptyset(&p->p_sigctx.ps_sigcatch); 304 p->p_sflag &= ~PS_NOCLDSTOP; 305 306 ksiginfo_queue_init(&p->p_sigpend.sp_info); 307 sigemptyset(&p->p_sigpend.sp_set); 308 309 /* 310 * Reset per LWP state. 311 */ 312 l = LIST_FIRST(&p->p_lwps); 313 l->l_sigwaited = NULL; 314 l->l_sigstk.ss_flags = SS_DISABLE; 315 l->l_sigstk.ss_size = 0; 316 l->l_sigstk.ss_sp = 0; 317 ksiginfo_queue_init(&l->l_sigpend.sp_info); 318 sigemptyset(&l->l_sigpend.sp_set); 319 320 /* One reference. */ 321 ps->sa_refcnt = 1; 322 } 323 324 /* 325 * execsigs: 326 * 327 * Reset signals for an exec of the specified process. 328 */ 329 void 330 execsigs(struct proc *p) 331 { 332 struct sigacts *ps; 333 struct lwp *l; 334 int signo, prop; 335 sigset_t tset; 336 ksiginfoq_t kq; 337 338 KASSERT(p->p_nlwps == 1); 339 340 sigactsunshare(p); 341 ps = p->p_sigacts; 342 343 /* 344 * Reset caught signals. Held signals remain held through 345 * l->l_sigmask (unless they were caught, and are now ignored 346 * by default). 347 * 348 * No need to lock yet, the process has only one LWP and 349 * at this point the sigacts are private to the process. 350 */ 351 sigemptyset(&tset); 352 for (signo = 1; signo < NSIG; signo++) { 353 if (sigismember(&p->p_sigctx.ps_sigcatch, signo)) { 354 prop = sigprop[signo]; 355 if (prop & SA_IGNORE) { 356 if ((prop & SA_CONT) == 0) 357 sigaddset(&p->p_sigctx.ps_sigignore, 358 signo); 359 sigaddset(&tset, signo); 360 } 361 SIGACTION_PS(ps, signo).sa_handler = SIG_DFL; 362 } 363 sigemptyset(&SIGACTION_PS(ps, signo).sa_mask); 364 SIGACTION_PS(ps, signo).sa_flags = SA_RESTART; 365 } 366 ksiginfo_queue_init(&kq); 367 368 mutex_enter(&p->p_smutex); 369 sigclearall(p, &tset, &kq); 370 sigemptyset(&p->p_sigctx.ps_sigcatch); 371 372 /* 373 * Reset no zombies if child dies flag as Solaris does. 374 */ 375 p->p_flag &= ~(PK_NOCLDWAIT | PK_CLDSIGIGN); 376 if (SIGACTION_PS(ps, SIGCHLD).sa_handler == SIG_IGN) 377 SIGACTION_PS(ps, SIGCHLD).sa_handler = SIG_DFL; 378 379 /* 380 * Reset per-LWP state. 381 */ 382 l = LIST_FIRST(&p->p_lwps); 383 l->l_sigwaited = NULL; 384 l->l_sigstk.ss_flags = SS_DISABLE; 385 l->l_sigstk.ss_size = 0; 386 l->l_sigstk.ss_sp = 0; 387 ksiginfo_queue_init(&l->l_sigpend.sp_info); 388 sigemptyset(&l->l_sigpend.sp_set); 389 mutex_exit(&p->p_smutex); 390 391 ksiginfo_queue_drain(&kq); 392 } 393 394 /* 395 * ksiginfo_exechook: 396 * 397 * Free all pending ksiginfo entries from a process on exec. 398 * Additionally, drain any unused ksiginfo structures in the 399 * system back to the pool. 400 * 401 * XXX This should not be a hook, every process has signals. 402 */ 403 static void 404 ksiginfo_exechook(struct proc *p, void *v) 405 { 406 ksiginfoq_t kq; 407 408 ksiginfo_queue_init(&kq); 409 410 mutex_enter(&p->p_smutex); 411 sigclearall(p, NULL, &kq); 412 mutex_exit(&p->p_smutex); 413 414 ksiginfo_queue_drain(&kq); 415 } 416 417 /* 418 * ksiginfo_alloc: 419 * 420 * Allocate a new ksiginfo structure from the pool, and optionally copy 421 * an existing one. If the existing ksiginfo_t is from the pool, and 422 * has not been queued somewhere, then just return it. Additionally, 423 * if the existing ksiginfo_t does not contain any information beyond 424 * the signal number, then just return it. 425 */ 426 ksiginfo_t * 427 ksiginfo_alloc(struct proc *p, ksiginfo_t *ok, int flags) 428 { 429 ksiginfo_t *kp; 430 int s; 431 432 if (ok != NULL) { 433 if ((ok->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) == 434 KSI_FROMPOOL) 435 return ok; 436 if (KSI_EMPTY_P(ok)) 437 return ok; 438 } 439 440 s = splvm(); 441 kp = pool_get(&ksiginfo_pool, flags); 442 splx(s); 443 if (kp == NULL) { 444 #ifdef DIAGNOSTIC 445 printf("Out of memory allocating ksiginfo for pid %d\n", 446 p->p_pid); 447 #endif 448 return NULL; 449 } 450 451 if (ok != NULL) { 452 memcpy(kp, ok, sizeof(*kp)); 453 kp->ksi_flags &= ~KSI_QUEUED; 454 } else 455 KSI_INIT_EMPTY(kp); 456 457 kp->ksi_flags |= KSI_FROMPOOL; 458 459 return kp; 460 } 461 462 /* 463 * ksiginfo_free: 464 * 465 * If the given ksiginfo_t is from the pool and has not been queued, 466 * then free it. 467 */ 468 void 469 ksiginfo_free(ksiginfo_t *kp) 470 { 471 int s; 472 473 if ((kp->ksi_flags & (KSI_QUEUED | KSI_FROMPOOL)) != KSI_FROMPOOL) 474 return; 475 s = splvm(); 476 pool_put(&ksiginfo_pool, kp); 477 splx(s); 478 } 479 480 /* 481 * ksiginfo_queue_drain: 482 * 483 * Drain a non-empty ksiginfo_t queue. 484 */ 485 void 486 ksiginfo_queue_drain0(ksiginfoq_t *kq) 487 { 488 ksiginfo_t *ksi; 489 int s; 490 491 KASSERT(!CIRCLEQ_EMPTY(kq)); 492 493 KERNEL_LOCK(1, curlwp); /* XXXSMP */ 494 while (!CIRCLEQ_EMPTY(kq)) { 495 ksi = CIRCLEQ_FIRST(kq); 496 CIRCLEQ_REMOVE(kq, ksi, ksi_list); 497 s = splvm(); 498 pool_put(&ksiginfo_pool, ksi); 499 splx(s); 500 } 501 KERNEL_UNLOCK_ONE(curlwp); /* XXXSMP */ 502 } 503 504 /* 505 * sigget: 506 * 507 * Fetch the first pending signal from a set. Optionally, also fetch 508 * or manufacture a ksiginfo element. Returns the number of the first 509 * pending signal, or zero. 510 */ 511 int 512 sigget(sigpend_t *sp, ksiginfo_t *out, int signo, const sigset_t *mask) 513 { 514 ksiginfo_t *ksi; 515 sigset_t tset; 516 517 /* If there's no pending set, the signal is from the debugger. */ 518 if (sp == NULL) { 519 if (out != NULL) { 520 KSI_INIT(out); 521 out->ksi_info._signo = signo; 522 out->ksi_info._code = SI_USER; 523 } 524 return signo; 525 } 526 527 /* Construct mask from signo, and 'mask'. */ 528 if (signo == 0) { 529 if (mask != NULL) { 530 tset = *mask; 531 __sigandset(&sp->sp_set, &tset); 532 } else 533 tset = sp->sp_set; 534 535 /* If there are no signals pending, that's it. */ 536 if ((signo = firstsig(&tset)) == 0) 537 return 0; 538 } else { 539 KASSERT(sigismember(&sp->sp_set, signo)); 540 } 541 542 sigdelset(&sp->sp_set, signo); 543 544 /* Find siginfo and copy it out. */ 545 CIRCLEQ_FOREACH(ksi, &sp->sp_info, ksi_list) { 546 if (ksi->ksi_signo == signo) { 547 CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list); 548 KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0); 549 KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0); 550 ksi->ksi_flags &= ~KSI_QUEUED; 551 if (out != NULL) { 552 memcpy(out, ksi, sizeof(*out)); 553 out->ksi_flags &= ~(KSI_FROMPOOL | KSI_QUEUED); 554 } 555 ksiginfo_free(ksi); 556 return signo; 557 } 558 } 559 560 /* If there's no siginfo, then manufacture it. */ 561 if (out != NULL) { 562 KSI_INIT(out); 563 out->ksi_info._signo = signo; 564 out->ksi_info._code = SI_USER; 565 } 566 567 return signo; 568 } 569 570 /* 571 * sigput: 572 * 573 * Append a new ksiginfo element to the list of pending ksiginfo's, if 574 * we need to (e.g. SA_SIGINFO was requested). 575 */ 576 void 577 sigput(sigpend_t *sp, struct proc *p, ksiginfo_t *ksi) 578 { 579 ksiginfo_t *kp; 580 struct sigaction *sa = &SIGACTION_PS(p->p_sigacts, ksi->ksi_signo); 581 582 KASSERT(mutex_owned(&p->p_smutex)); 583 KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0); 584 585 sigaddset(&sp->sp_set, ksi->ksi_signo); 586 587 /* 588 * If siginfo is not required, or there is none, then just mark the 589 * signal as pending. 590 */ 591 if ((sa->sa_flags & SA_SIGINFO) == 0 || KSI_EMPTY_P(ksi)) 592 return; 593 594 KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0); 595 596 #ifdef notyet /* XXX: QUEUING */ 597 if (ksi->ksi_signo < SIGRTMIN) 598 #endif 599 { 600 CIRCLEQ_FOREACH(kp, &sp->sp_info, ksi_list) { 601 if (kp->ksi_signo == ksi->ksi_signo) { 602 KSI_COPY(ksi, kp); 603 kp->ksi_flags |= KSI_QUEUED; 604 return; 605 } 606 } 607 } 608 609 ksi->ksi_flags |= KSI_QUEUED; 610 CIRCLEQ_INSERT_TAIL(&sp->sp_info, ksi, ksi_list); 611 } 612 613 /* 614 * sigclear: 615 * 616 * Clear all pending signals in the specified set. 617 */ 618 void 619 sigclear(sigpend_t *sp, const sigset_t *mask, ksiginfoq_t *kq) 620 { 621 ksiginfo_t *ksi, *next; 622 623 if (mask == NULL) 624 sigemptyset(&sp->sp_set); 625 else 626 sigminusset(mask, &sp->sp_set); 627 628 ksi = CIRCLEQ_FIRST(&sp->sp_info); 629 for (; ksi != (void *)&sp->sp_info; ksi = next) { 630 next = CIRCLEQ_NEXT(ksi, ksi_list); 631 if (mask == NULL || sigismember(mask, ksi->ksi_signo)) { 632 CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list); 633 KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0); 634 KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0); 635 CIRCLEQ_INSERT_TAIL(kq, ksi, ksi_list); 636 } 637 } 638 } 639 640 /* 641 * sigclearall: 642 * 643 * Clear all pending signals in the specified set from a process and 644 * its LWPs. 645 */ 646 void 647 sigclearall(struct proc *p, const sigset_t *mask, ksiginfoq_t *kq) 648 { 649 struct lwp *l; 650 651 KASSERT(mutex_owned(&p->p_smutex)); 652 653 sigclear(&p->p_sigpend, mask, kq); 654 655 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 656 sigclear(&l->l_sigpend, mask, kq); 657 } 658 } 659 660 /* 661 * sigispending: 662 * 663 * Return true if there are pending signals for the current LWP. May 664 * be called unlocked provided that LW_PENDSIG is set, and that the 665 * signal has been posted to the appopriate queue before LW_PENDSIG is 666 * set. 667 */ 668 int 669 sigispending(struct lwp *l, int signo) 670 { 671 struct proc *p = l->l_proc; 672 sigset_t tset; 673 674 membar_consumer(); 675 676 tset = l->l_sigpend.sp_set; 677 sigplusset(&p->p_sigpend.sp_set, &tset); 678 sigminusset(&p->p_sigctx.ps_sigignore, &tset); 679 sigminusset(&l->l_sigmask, &tset); 680 681 if (signo == 0) { 682 if (firstsig(&tset) != 0) 683 return EINTR; 684 } else if (sigismember(&tset, signo)) 685 return EINTR; 686 687 return 0; 688 } 689 690 /* 691 * siginfo_alloc: 692 * 693 * Allocate a new siginfo_t structure from the pool. 694 */ 695 siginfo_t * 696 siginfo_alloc(int flags) 697 { 698 699 return pool_get(&siginfo_pool, flags); 700 } 701 702 /* 703 * siginfo_free: 704 * 705 * Return a siginfo_t structure to the pool. 706 */ 707 void 708 siginfo_free(void *arg) 709 { 710 711 pool_put(&siginfo_pool, arg); 712 } 713 714 void 715 getucontext(struct lwp *l, ucontext_t *ucp) 716 { 717 struct proc *p = l->l_proc; 718 719 KASSERT(mutex_owned(&p->p_smutex)); 720 721 ucp->uc_flags = 0; 722 ucp->uc_link = l->l_ctxlink; 723 724 ucp->uc_sigmask = l->l_sigmask; 725 ucp->uc_flags |= _UC_SIGMASK; 726 727 /* 728 * The (unsupplied) definition of the `current execution stack' 729 * in the System V Interface Definition appears to allow returning 730 * the main context stack. 731 */ 732 if ((l->l_sigstk.ss_flags & SS_ONSTACK) == 0) { 733 ucp->uc_stack.ss_sp = (void *)l->l_proc->p_stackbase; 734 ucp->uc_stack.ss_size = ctob(l->l_proc->p_vmspace->vm_ssize); 735 ucp->uc_stack.ss_flags = 0; /* XXX, def. is Very Fishy */ 736 } else { 737 /* Simply copy alternate signal execution stack. */ 738 ucp->uc_stack = l->l_sigstk; 739 } 740 ucp->uc_flags |= _UC_STACK; 741 mutex_exit(&p->p_smutex); 742 cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags); 743 mutex_enter(&p->p_smutex); 744 } 745 746 int 747 setucontext(struct lwp *l, const ucontext_t *ucp) 748 { 749 struct proc *p = l->l_proc; 750 int error; 751 752 KASSERT(mutex_owned(&p->p_smutex)); 753 754 if ((ucp->uc_flags & _UC_SIGMASK) != 0) { 755 error = sigprocmask1(l, SIG_SETMASK, &ucp->uc_sigmask, NULL); 756 if (error != 0) 757 return error; 758 } 759 760 mutex_exit(&p->p_smutex); 761 error = cpu_setmcontext(l, &ucp->uc_mcontext, ucp->uc_flags); 762 mutex_enter(&p->p_smutex); 763 if (error != 0) 764 return (error); 765 766 l->l_ctxlink = ucp->uc_link; 767 768 /* 769 * If there was stack information, update whether or not we are 770 * still running on an alternate signal stack. 771 */ 772 if ((ucp->uc_flags & _UC_STACK) != 0) { 773 if (ucp->uc_stack.ss_flags & SS_ONSTACK) 774 l->l_sigstk.ss_flags |= SS_ONSTACK; 775 else 776 l->l_sigstk.ss_flags &= ~SS_ONSTACK; 777 } 778 779 return 0; 780 } 781 782 /* 783 * Common code for kill process group/broadcast kill. cp is calling 784 * process. 785 */ 786 int 787 killpg1(struct lwp *l, ksiginfo_t *ksi, int pgid, int all) 788 { 789 struct proc *p, *cp; 790 kauth_cred_t pc; 791 struct pgrp *pgrp; 792 int nfound; 793 int signo = ksi->ksi_signo; 794 795 cp = l->l_proc; 796 pc = l->l_cred; 797 nfound = 0; 798 799 mutex_enter(&proclist_lock); 800 if (all) { 801 /* 802 * broadcast 803 */ 804 PROCLIST_FOREACH(p, &allproc) { 805 if (p->p_pid <= 1 || p->p_flag & PK_SYSTEM || p == cp) 806 continue; 807 mutex_enter(&p->p_mutex); 808 if (kauth_authorize_process(pc, 809 KAUTH_PROCESS_SIGNAL, p, KAUTH_ARG(signo), NULL, 810 NULL) == 0) { 811 nfound++; 812 if (signo) { 813 mutex_enter(&proclist_mutex); 814 mutex_enter(&p->p_smutex); 815 kpsignal2(p, ksi); 816 mutex_exit(&p->p_smutex); 817 mutex_exit(&proclist_mutex); 818 } 819 } 820 mutex_exit(&p->p_mutex); 821 } 822 } else { 823 if (pgid == 0) 824 /* 825 * zero pgid means send to my process group. 826 */ 827 pgrp = cp->p_pgrp; 828 else { 829 pgrp = pg_find(pgid, PFIND_LOCKED); 830 if (pgrp == NULL) 831 goto out; 832 } 833 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 834 if (p->p_pid <= 1 || p->p_flag & PK_SYSTEM) 835 continue; 836 mutex_enter(&p->p_mutex); 837 if (kauth_authorize_process(pc, KAUTH_PROCESS_SIGNAL, 838 p, KAUTH_ARG(signo), NULL, NULL) == 0) { 839 nfound++; 840 if (signo) { 841 mutex_enter(&proclist_mutex); 842 mutex_enter(&p->p_smutex); 843 if (P_ZOMBIE(p) == 0) 844 kpsignal2(p, ksi); 845 mutex_exit(&p->p_smutex); 846 mutex_exit(&proclist_mutex); 847 } 848 } 849 mutex_exit(&p->p_mutex); 850 } 851 } 852 out: 853 mutex_exit(&proclist_lock); 854 return (nfound ? 0 : ESRCH); 855 } 856 857 /* 858 * Send a signal to a process group. If checktty is 1, limit to members 859 * which have a controlling terminal. 860 */ 861 void 862 pgsignal(struct pgrp *pgrp, int sig, int checkctty) 863 { 864 ksiginfo_t ksi; 865 866 KASSERT(mutex_owned(&proclist_mutex)); 867 868 KSI_INIT_EMPTY(&ksi); 869 ksi.ksi_signo = sig; 870 kpgsignal(pgrp, &ksi, NULL, checkctty); 871 } 872 873 void 874 kpgsignal(struct pgrp *pgrp, ksiginfo_t *ksi, void *data, int checkctty) 875 { 876 struct proc *p; 877 878 KASSERT(mutex_owned(&proclist_mutex)); 879 880 if (pgrp) 881 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) 882 if (checkctty == 0 || p->p_lflag & PL_CONTROLT) 883 kpsignal(p, ksi, data); 884 } 885 886 /* 887 * Send a signal caused by a trap to the current LWP. If it will be caught 888 * immediately, deliver it with correct code. Otherwise, post it normally. 889 */ 890 void 891 trapsignal(struct lwp *l, ksiginfo_t *ksi) 892 { 893 struct proc *p; 894 struct sigacts *ps; 895 int signo = ksi->ksi_signo; 896 897 KASSERT(KSI_TRAP_P(ksi)); 898 899 ksi->ksi_lid = l->l_lid; 900 p = l->l_proc; 901 902 mutex_enter(&proclist_mutex); 903 mutex_enter(&p->p_smutex); 904 ps = p->p_sigacts; 905 if ((p->p_slflag & PSL_TRACED) == 0 && 906 sigismember(&p->p_sigctx.ps_sigcatch, signo) && 907 !sigismember(&l->l_sigmask, signo)) { 908 mutex_exit(&proclist_mutex); 909 p->p_stats->p_ru.ru_nsignals++; 910 kpsendsig(l, ksi, &l->l_sigmask); 911 mutex_exit(&p->p_smutex); 912 ktrpsig(signo, SIGACTION_PS(ps, signo).sa_handler, 913 &l->l_sigmask, ksi); 914 } else { 915 /* XXX for core dump/debugger */ 916 p->p_sigctx.ps_lwp = l->l_lid; 917 p->p_sigctx.ps_signo = ksi->ksi_signo; 918 p->p_sigctx.ps_code = ksi->ksi_trap; 919 kpsignal2(p, ksi); 920 mutex_exit(&proclist_mutex); 921 mutex_exit(&p->p_smutex); 922 } 923 } 924 925 /* 926 * Fill in signal information and signal the parent for a child status change. 927 */ 928 void 929 child_psignal(struct proc *p, int mask) 930 { 931 ksiginfo_t ksi; 932 struct proc *q; 933 int xstat; 934 935 KASSERT(mutex_owned(&proclist_mutex)); 936 KASSERT(mutex_owned(&p->p_smutex)); 937 938 xstat = p->p_xstat; 939 940 KSI_INIT(&ksi); 941 ksi.ksi_signo = SIGCHLD; 942 ksi.ksi_code = (xstat == SIGCONT ? CLD_CONTINUED : CLD_STOPPED); 943 ksi.ksi_pid = p->p_pid; 944 ksi.ksi_uid = kauth_cred_geteuid(p->p_cred); 945 ksi.ksi_status = xstat; 946 ksi.ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec; 947 ksi.ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec; 948 949 q = p->p_pptr; 950 951 mutex_exit(&p->p_smutex); 952 mutex_enter(&q->p_smutex); 953 954 if ((q->p_sflag & mask) == 0) 955 kpsignal2(q, &ksi); 956 957 mutex_exit(&q->p_smutex); 958 mutex_enter(&p->p_smutex); 959 } 960 961 void 962 psignal(struct proc *p, int signo) 963 { 964 ksiginfo_t ksi; 965 966 KASSERT(mutex_owned(&proclist_mutex)); 967 968 KSI_INIT_EMPTY(&ksi); 969 ksi.ksi_signo = signo; 970 mutex_enter(&p->p_smutex); 971 kpsignal2(p, &ksi); 972 mutex_exit(&p->p_smutex); 973 } 974 975 void 976 kpsignal(struct proc *p, ksiginfo_t *ksi, void *data) 977 { 978 979 KASSERT(mutex_owned(&proclist_mutex)); 980 981 /* XXXSMP Why is this here? */ 982 if ((p->p_sflag & PS_WEXIT) == 0 && data) { 983 size_t fd; 984 struct filedesc *fdp = p->p_fd; 985 986 ksi->ksi_fd = -1; 987 for (fd = 0; fd < fdp->fd_nfiles; fd++) { 988 struct file *fp = fdp->fd_ofiles[fd]; 989 /* XXX: lock? */ 990 if (fp && fp->f_data == data) { 991 ksi->ksi_fd = fd; 992 break; 993 } 994 } 995 } 996 mutex_enter(&p->p_smutex); 997 kpsignal2(p, ksi); 998 mutex_exit(&p->p_smutex); 999 } 1000 1001 /* 1002 * sigismasked: 1003 * 1004 * Returns true if signal is ignored or masked for the specified LWP. 1005 */ 1006 int 1007 sigismasked(struct lwp *l, int sig) 1008 { 1009 struct proc *p = l->l_proc; 1010 1011 return (sigismember(&p->p_sigctx.ps_sigignore, sig) || 1012 sigismember(&l->l_sigmask, sig)); 1013 } 1014 1015 /* 1016 * sigpost: 1017 * 1018 * Post a pending signal to an LWP. Returns non-zero if the LWP was 1019 * able to take the signal. 1020 */ 1021 int 1022 sigpost(struct lwp *l, sig_t action, int prop, int sig) 1023 { 1024 int rv, masked; 1025 1026 KASSERT(mutex_owned(&l->l_proc->p_smutex)); 1027 1028 /* 1029 * If the LWP is on the way out, sigclear() will be busy draining all 1030 * pending signals. Don't give it more. 1031 */ 1032 if (l->l_refcnt == 0) 1033 return 0; 1034 1035 lwp_lock(l); 1036 1037 /* 1038 * Have the LWP check for signals. This ensures that even if no LWP 1039 * is found to take the signal immediately, it should be taken soon. 1040 */ 1041 l->l_flag |= LW_PENDSIG; 1042 1043 /* 1044 * SIGCONT can be masked, but must always restart stopped LWPs. 1045 */ 1046 masked = sigismember(&l->l_sigmask, sig); 1047 if (masked && ((prop & SA_CONT) == 0 || l->l_stat != LSSTOP)) { 1048 lwp_unlock(l); 1049 return 0; 1050 } 1051 1052 /* 1053 * If killing the process, make it run fast. 1054 */ 1055 if (__predict_false((prop & SA_KILL) != 0) && 1056 action == SIG_DFL && l->l_priority < MAXPRI_USER) { 1057 KASSERT(l->l_class == SCHED_OTHER); 1058 lwp_changepri(l, MAXPRI_USER); 1059 } 1060 1061 /* 1062 * If the LWP is running or on a run queue, then we win. If it's 1063 * sleeping interruptably, wake it and make it take the signal. If 1064 * the sleep isn't interruptable, then the chances are it will get 1065 * to see the signal soon anyhow. If suspended, it can't take the 1066 * signal right now. If it's LWP private or for all LWPs, save it 1067 * for later; otherwise punt. 1068 */ 1069 rv = 0; 1070 1071 switch (l->l_stat) { 1072 case LSRUN: 1073 case LSONPROC: 1074 lwp_need_userret(l); 1075 rv = 1; 1076 break; 1077 1078 case LSSLEEP: 1079 if ((l->l_flag & LW_SINTR) != 0) { 1080 /* setrunnable() will release the lock. */ 1081 setrunnable(l); 1082 return 1; 1083 } 1084 break; 1085 1086 case LSSUSPENDED: 1087 if ((prop & SA_KILL) != 0) { 1088 /* lwp_continue() will release the lock. */ 1089 lwp_continue(l); 1090 return 1; 1091 } 1092 break; 1093 1094 case LSSTOP: 1095 if ((prop & SA_STOP) != 0) 1096 break; 1097 1098 /* 1099 * If the LWP is stopped and we are sending a continue 1100 * signal, then start it again. 1101 */ 1102 if ((prop & SA_CONT) != 0) { 1103 if (l->l_wchan != NULL) { 1104 l->l_stat = LSSLEEP; 1105 l->l_proc->p_nrlwps++; 1106 rv = 1; 1107 break; 1108 } 1109 /* setrunnable() will release the lock. */ 1110 setrunnable(l); 1111 return 1; 1112 } else if (l->l_wchan == NULL || (l->l_flag & LW_SINTR) != 0) { 1113 /* setrunnable() will release the lock. */ 1114 setrunnable(l); 1115 return 1; 1116 } 1117 break; 1118 1119 default: 1120 break; 1121 } 1122 1123 lwp_unlock(l); 1124 return rv; 1125 } 1126 1127 /* 1128 * Notify an LWP that it has a pending signal. 1129 */ 1130 void 1131 signotify(struct lwp *l) 1132 { 1133 KASSERT(lwp_locked(l, NULL)); 1134 1135 l->l_flag |= LW_PENDSIG; 1136 lwp_need_userret(l); 1137 } 1138 1139 /* 1140 * Find an LWP within process p that is waiting on signal ksi, and hand 1141 * it on. 1142 */ 1143 int 1144 sigunwait(struct proc *p, const ksiginfo_t *ksi) 1145 { 1146 struct lwp *l; 1147 int signo; 1148 1149 KASSERT(mutex_owned(&p->p_smutex)); 1150 1151 signo = ksi->ksi_signo; 1152 1153 if (ksi->ksi_lid != 0) { 1154 /* 1155 * Signal came via _lwp_kill(). Find the LWP and see if 1156 * it's interested. 1157 */ 1158 if ((l = lwp_find(p, ksi->ksi_lid)) == NULL) 1159 return 0; 1160 if (l->l_sigwaited == NULL || 1161 !sigismember(&l->l_sigwaitset, signo)) 1162 return 0; 1163 } else { 1164 /* 1165 * Look for any LWP that may be interested. 1166 */ 1167 LIST_FOREACH(l, &p->p_sigwaiters, l_sigwaiter) { 1168 KASSERT(l->l_sigwaited != NULL); 1169 if (sigismember(&l->l_sigwaitset, signo)) 1170 break; 1171 } 1172 } 1173 1174 if (l != NULL) { 1175 l->l_sigwaited->ksi_info = ksi->ksi_info; 1176 l->l_sigwaited = NULL; 1177 LIST_REMOVE(l, l_sigwaiter); 1178 cv_signal(&l->l_sigcv); 1179 return 1; 1180 } 1181 1182 return 0; 1183 } 1184 1185 /* 1186 * Send the signal to the process. If the signal has an action, the action 1187 * is usually performed by the target process rather than the caller; we add 1188 * the signal to the set of pending signals for the process. 1189 * 1190 * Exceptions: 1191 * o When a stop signal is sent to a sleeping process that takes the 1192 * default action, the process is stopped without awakening it. 1193 * o SIGCONT restarts stopped processes (or puts them back to sleep) 1194 * regardless of the signal action (eg, blocked or ignored). 1195 * 1196 * Other ignored signals are discarded immediately. 1197 */ 1198 void 1199 kpsignal2(struct proc *p, ksiginfo_t *ksi) 1200 { 1201 int prop, lid, toall, signo = ksi->ksi_signo; 1202 struct sigacts *sa; 1203 struct lwp *l; 1204 ksiginfo_t *kp; 1205 ksiginfoq_t kq; 1206 sig_t action; 1207 1208 KASSERT(mutex_owned(&proclist_mutex)); 1209 KASSERT(mutex_owned(&p->p_smutex)); 1210 KASSERT((ksi->ksi_flags & KSI_QUEUED) == 0); 1211 KASSERT(signo > 0 && signo < NSIG); 1212 1213 /* 1214 * If the process is being created by fork, is a zombie or is 1215 * exiting, then just drop the signal here and bail out. 1216 */ 1217 if (p->p_stat != SACTIVE && p->p_stat != SSTOP) 1218 return; 1219 1220 /* 1221 * Notify any interested parties of the signal. 1222 */ 1223 KNOTE(&p->p_klist, NOTE_SIGNAL | signo); 1224 1225 /* 1226 * Some signals including SIGKILL must act on the entire process. 1227 */ 1228 kp = NULL; 1229 prop = sigprop[signo]; 1230 toall = ((prop & SA_TOALL) != 0); 1231 1232 if (toall) 1233 lid = 0; 1234 else 1235 lid = ksi->ksi_lid; 1236 1237 /* 1238 * If proc is traced, always give parent a chance. 1239 */ 1240 if (p->p_slflag & PSL_TRACED) { 1241 action = SIG_DFL; 1242 1243 if (lid == 0) { 1244 /* 1245 * If the process is being traced and the signal 1246 * is being caught, make sure to save any ksiginfo. 1247 */ 1248 if ((kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL) 1249 return; 1250 sigput(&p->p_sigpend, p, kp); 1251 } 1252 } else { 1253 /* 1254 * If the signal was the result of a trap and is not being 1255 * caught, then reset it to default action so that the 1256 * process dumps core immediately. 1257 */ 1258 if (KSI_TRAP_P(ksi)) { 1259 sa = p->p_sigacts; 1260 mutex_enter(&sa->sa_mutex); 1261 if (!sigismember(&p->p_sigctx.ps_sigcatch, signo)) { 1262 sigdelset(&p->p_sigctx.ps_sigignore, signo); 1263 SIGACTION(p, signo).sa_handler = SIG_DFL; 1264 } 1265 mutex_exit(&sa->sa_mutex); 1266 } 1267 1268 /* 1269 * If the signal is being ignored, then drop it. Note: we 1270 * don't set SIGCONT in ps_sigignore, and if it is set to 1271 * SIG_IGN, action will be SIG_DFL here. 1272 */ 1273 if (sigismember(&p->p_sigctx.ps_sigignore, signo)) 1274 return; 1275 1276 else if (sigismember(&p->p_sigctx.ps_sigcatch, signo)) 1277 action = SIG_CATCH; 1278 else { 1279 action = SIG_DFL; 1280 1281 /* 1282 * If sending a tty stop signal to a member of an 1283 * orphaned process group, discard the signal here if 1284 * the action is default; don't stop the process below 1285 * if sleeping, and don't clear any pending SIGCONT. 1286 */ 1287 if (prop & SA_TTYSTOP && 1288 (p->p_sflag & PS_ORPHANPG) != 0) 1289 return; 1290 1291 if (prop & SA_KILL && p->p_nice > NZERO) 1292 p->p_nice = NZERO; 1293 } 1294 } 1295 1296 /* 1297 * If stopping or continuing a process, discard any pending 1298 * signals that would do the inverse. 1299 */ 1300 if ((prop & (SA_CONT | SA_STOP)) != 0) { 1301 ksiginfo_queue_init(&kq); 1302 if ((prop & SA_CONT) != 0) 1303 sigclear(&p->p_sigpend, &stopsigmask, &kq); 1304 if ((prop & SA_STOP) != 0) 1305 sigclear(&p->p_sigpend, &contsigmask, &kq); 1306 ksiginfo_queue_drain(&kq); /* XXXSMP */ 1307 } 1308 1309 /* 1310 * If the signal doesn't have SA_CANTMASK (no override for SIGKILL, 1311 * please!), check if any LWPs are waiting on it. If yes, pass on 1312 * the signal info. The signal won't be processed further here. 1313 */ 1314 if ((prop & SA_CANTMASK) == 0 && !LIST_EMPTY(&p->p_sigwaiters) && 1315 p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0 && 1316 sigunwait(p, ksi)) 1317 return; 1318 1319 /* 1320 * XXXSMP Should be allocated by the caller, we're holding locks 1321 * here. 1322 */ 1323 if (kp == NULL && (kp = ksiginfo_alloc(p, ksi, PR_NOWAIT)) == NULL) 1324 return; 1325 1326 /* 1327 * LWP private signals are easy - just find the LWP and post 1328 * the signal to it. 1329 */ 1330 if (lid != 0) { 1331 l = lwp_find(p, lid); 1332 if (l != NULL) { 1333 sigput(&l->l_sigpend, p, kp); 1334 membar_producer(); 1335 (void)sigpost(l, action, prop, kp->ksi_signo); 1336 } 1337 goto out; 1338 } 1339 1340 /* 1341 * Some signals go to all LWPs, even if posted with _lwp_kill(). 1342 */ 1343 if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) { 1344 if ((p->p_slflag & PSL_TRACED) != 0) 1345 goto deliver; 1346 1347 /* 1348 * If SIGCONT is default (or ignored) and process is 1349 * asleep, we are finished; the process should not 1350 * be awakened. 1351 */ 1352 if ((prop & SA_CONT) != 0 && action == SIG_DFL) 1353 goto out; 1354 1355 if ((prop & SA_STOP) != 0 && action == SIG_DFL) { 1356 /* 1357 * If a child holding parent blocked, stopping could 1358 * cause deadlock: discard the signal. 1359 */ 1360 if ((p->p_sflag & PS_PPWAIT) == 0) { 1361 p->p_xstat = signo; 1362 proc_stop(p, 1, signo); 1363 } 1364 goto out; 1365 } else { 1366 /* 1367 * Stop signals with the default action are handled 1368 * specially in issignal(), and so are not enqueued. 1369 */ 1370 sigput(&p->p_sigpend, p, kp); 1371 } 1372 } else { 1373 /* 1374 * Process is stopped or stopping. If traced, then no 1375 * further action is necessary. 1376 */ 1377 if ((p->p_slflag & PSL_TRACED) != 0 && signo != SIGKILL) 1378 goto out; 1379 1380 if ((prop & (SA_CONT | SA_KILL)) != 0) { 1381 /* 1382 * Re-adjust p_nstopchild if the process wasn't 1383 * collected by its parent. 1384 */ 1385 p->p_stat = SACTIVE; 1386 p->p_sflag &= ~PS_STOPPING; 1387 if (!p->p_waited) 1388 p->p_pptr->p_nstopchild--; 1389 1390 /* 1391 * If SIGCONT is default (or ignored), we continue 1392 * the process but don't leave the signal in 1393 * ps_siglist, as it has no further action. If 1394 * SIGCONT is held, we continue the process and 1395 * leave the signal in ps_siglist. If the process 1396 * catches SIGCONT, let it handle the signal itself. 1397 * If it isn't waiting on an event, then it goes 1398 * back to run state. Otherwise, process goes back 1399 * to sleep state. 1400 */ 1401 if ((prop & SA_CONT) == 0 || action != SIG_DFL) 1402 sigput(&p->p_sigpend, p, kp); 1403 } else if ((prop & SA_STOP) != 0) { 1404 /* 1405 * Already stopped, don't need to stop again. 1406 * (If we did the shell could get confused.) 1407 */ 1408 goto out; 1409 } else 1410 sigput(&p->p_sigpend, p, kp); 1411 } 1412 1413 deliver: 1414 /* 1415 * Before we set LW_PENDSIG on any LWP, ensure that the signal is 1416 * visible on the per process list (for sigispending()). This 1417 * is unlikely to be needed in practice, but... 1418 */ 1419 membar_producer(); 1420 1421 /* 1422 * Try to find an LWP that can take the signal. 1423 */ 1424 LIST_FOREACH(l, &p->p_lwps, l_sibling) 1425 if (sigpost(l, action, prop, kp->ksi_signo) && !toall) 1426 break; 1427 1428 out: 1429 /* 1430 * If the ksiginfo wasn't used, then bin it. XXXSMP freeing memory 1431 * with locks held. The caller should take care of this. 1432 */ 1433 ksiginfo_free(kp); 1434 } 1435 1436 void 1437 kpsendsig(struct lwp *l, const ksiginfo_t *ksi, const sigset_t *mask) 1438 { 1439 struct proc *p = l->l_proc; 1440 1441 KASSERT(mutex_owned(&p->p_smutex)); 1442 1443 (*p->p_emul->e_sendsig)(ksi, mask); 1444 } 1445 1446 /* 1447 * Stop any LWPs sleeping interruptably. 1448 */ 1449 static void 1450 proc_stop_lwps(struct proc *p) 1451 { 1452 struct lwp *l; 1453 1454 KASSERT(mutex_owned(&p->p_smutex)); 1455 KASSERT((p->p_sflag & PS_STOPPING) != 0); 1456 1457 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 1458 lwp_lock(l); 1459 if (l->l_stat == LSSLEEP && (l->l_flag & LW_SINTR) != 0) { 1460 l->l_stat = LSSTOP; 1461 p->p_nrlwps--; 1462 } 1463 lwp_unlock(l); 1464 } 1465 } 1466 1467 /* 1468 * Finish stopping of a process. Mark it stopped and notify the parent. 1469 * 1470 * Drop p_smutex briefly if PS_NOTIFYSTOP is set and ppsig is true. 1471 */ 1472 static void 1473 proc_stop_done(struct proc *p, bool ppsig, int ppmask) 1474 { 1475 1476 KASSERT(mutex_owned(&proclist_mutex)); 1477 KASSERT(mutex_owned(&p->p_smutex)); 1478 KASSERT((p->p_sflag & PS_STOPPING) != 0); 1479 KASSERT(p->p_nrlwps == 0 || (p->p_nrlwps == 1 && p == curproc)); 1480 1481 p->p_sflag &= ~PS_STOPPING; 1482 p->p_stat = SSTOP; 1483 p->p_waited = 0; 1484 p->p_pptr->p_nstopchild++; 1485 if ((p->p_sflag & PS_NOTIFYSTOP) != 0) { 1486 if (ppsig) { 1487 /* child_psignal drops p_smutex briefly. */ 1488 child_psignal(p, ppmask); 1489 } 1490 cv_broadcast(&p->p_pptr->p_waitcv); 1491 } 1492 } 1493 1494 /* 1495 * Stop the current process and switch away when being stopped or traced. 1496 */ 1497 void 1498 sigswitch(bool ppsig, int ppmask, int signo) 1499 { 1500 struct lwp *l = curlwp; 1501 struct proc *p = l->l_proc; 1502 #ifdef MULTIPROCESSOR 1503 int biglocks; 1504 #endif 1505 1506 KASSERT(mutex_owned(&p->p_smutex)); 1507 KASSERT(l->l_stat == LSONPROC); 1508 KASSERT(p->p_nrlwps > 0); 1509 1510 /* 1511 * On entry we know that the process needs to stop. If it's 1512 * the result of a 'sideways' stop signal that has been sourced 1513 * through issignal(), then stop other LWPs in the process too. 1514 */ 1515 if (p->p_stat == SACTIVE && (p->p_sflag & PS_STOPPING) == 0) { 1516 KASSERT(signo != 0); 1517 proc_stop(p, 1, signo); 1518 KASSERT(p->p_nrlwps > 0); 1519 } 1520 1521 /* 1522 * If we are the last live LWP, and the stop was a result of 1523 * a new signal, then signal the parent. 1524 */ 1525 if ((p->p_sflag & PS_STOPPING) != 0) { 1526 if (!mutex_tryenter(&proclist_mutex)) { 1527 mutex_exit(&p->p_smutex); 1528 mutex_enter(&proclist_mutex); 1529 mutex_enter(&p->p_smutex); 1530 } 1531 1532 if (p->p_nrlwps == 1 && (p->p_sflag & PS_STOPPING) != 0) { 1533 /* 1534 * Note that proc_stop_done() can drop 1535 * p->p_smutex briefly. 1536 */ 1537 proc_stop_done(p, ppsig, ppmask); 1538 } 1539 1540 mutex_exit(&proclist_mutex); 1541 } 1542 1543 /* 1544 * Unlock and switch away. 1545 */ 1546 KERNEL_UNLOCK_ALL(l, &biglocks); 1547 if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) { 1548 p->p_nrlwps--; 1549 lwp_lock(l); 1550 KASSERT(l->l_stat == LSONPROC || l->l_stat == LSSLEEP); 1551 l->l_stat = LSSTOP; 1552 lwp_unlock(l); 1553 } 1554 1555 mutex_exit(&p->p_smutex); 1556 lwp_lock(l); 1557 mi_switch(l); 1558 KERNEL_LOCK(biglocks, l); 1559 mutex_enter(&p->p_smutex); 1560 } 1561 1562 /* 1563 * Check for a signal from the debugger. 1564 */ 1565 int 1566 sigchecktrace(sigpend_t **spp) 1567 { 1568 struct lwp *l = curlwp; 1569 struct proc *p = l->l_proc; 1570 int signo; 1571 1572 KASSERT(mutex_owned(&p->p_smutex)); 1573 1574 /* 1575 * If we are no longer being traced, or the parent didn't 1576 * give us a signal, look for more signals. 1577 */ 1578 if ((p->p_slflag & PSL_TRACED) == 0 || p->p_xstat == 0) 1579 return 0; 1580 1581 /* If there's a pending SIGKILL, process it immediately. */ 1582 if (sigismember(&p->p_sigpend.sp_set, SIGKILL)) 1583 return 0; 1584 1585 /* 1586 * If the new signal is being masked, look for other signals. 1587 * `p->p_sigctx.ps_siglist |= mask' is done in setrunnable(). 1588 */ 1589 signo = p->p_xstat; 1590 p->p_xstat = 0; 1591 if ((sigprop[signo] & SA_TOLWP) != 0) 1592 *spp = &l->l_sigpend; 1593 else 1594 *spp = &p->p_sigpend; 1595 if (sigismember(&l->l_sigmask, signo)) 1596 signo = 0; 1597 1598 return signo; 1599 } 1600 1601 /* 1602 * If the current process has received a signal (should be caught or cause 1603 * termination, should interrupt current syscall), return the signal number. 1604 * 1605 * Stop signals with default action are processed immediately, then cleared; 1606 * they aren't returned. This is checked after each entry to the system for 1607 * a syscall or trap. 1608 * 1609 * We will also return -1 if the process is exiting and the current LWP must 1610 * follow suit. 1611 * 1612 * Note that we may be called while on a sleep queue, so MUST NOT sleep. We 1613 * can switch away, though. 1614 */ 1615 int 1616 issignal(struct lwp *l) 1617 { 1618 struct proc *p = l->l_proc; 1619 int signo = 0, prop; 1620 sigpend_t *sp = NULL; 1621 sigset_t ss; 1622 1623 KASSERT(mutex_owned(&p->p_smutex)); 1624 1625 for (;;) { 1626 /* Discard any signals that we have decided not to take. */ 1627 if (signo != 0) 1628 (void)sigget(sp, NULL, signo, NULL); 1629 1630 /* 1631 * If the process is stopped/stopping, then stop ourselves 1632 * now that we're on the kernel/userspace boundary. When 1633 * we awaken, check for a signal from the debugger. 1634 */ 1635 if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) { 1636 sigswitch(true, PS_NOCLDSTOP, 0); 1637 signo = sigchecktrace(&sp); 1638 } else 1639 signo = 0; 1640 1641 /* 1642 * If the debugger didn't provide a signal, find a pending 1643 * signal from our set. Check per-LWP signals first, and 1644 * then per-process. 1645 */ 1646 if (signo == 0) { 1647 sp = &l->l_sigpend; 1648 ss = sp->sp_set; 1649 if ((p->p_sflag & PS_PPWAIT) != 0) 1650 sigminusset(&stopsigmask, &ss); 1651 sigminusset(&l->l_sigmask, &ss); 1652 1653 if ((signo = firstsig(&ss)) == 0) { 1654 sp = &p->p_sigpend; 1655 ss = sp->sp_set; 1656 if ((p->p_sflag & PS_PPWAIT) != 0) 1657 sigminusset(&stopsigmask, &ss); 1658 sigminusset(&l->l_sigmask, &ss); 1659 1660 if ((signo = firstsig(&ss)) == 0) { 1661 /* 1662 * No signal pending - clear the 1663 * indicator and bail out. 1664 */ 1665 lwp_lock(l); 1666 l->l_flag &= ~LW_PENDSIG; 1667 lwp_unlock(l); 1668 sp = NULL; 1669 break; 1670 } 1671 } 1672 } 1673 1674 /* 1675 * We should see pending but ignored signals only if 1676 * we are being traced. 1677 */ 1678 if (sigismember(&p->p_sigctx.ps_sigignore, signo) && 1679 (p->p_slflag & PSL_TRACED) == 0) { 1680 /* Discard the signal. */ 1681 continue; 1682 } 1683 1684 /* 1685 * If traced, always stop, and stay stopped until released 1686 * by the debugger. If the our parent process is waiting 1687 * for us, don't hang as we could deadlock. 1688 */ 1689 if ((p->p_slflag & PSL_TRACED) != 0 && 1690 (p->p_sflag & PS_PPWAIT) == 0 && signo != SIGKILL) { 1691 /* Take the signal. */ 1692 (void)sigget(sp, NULL, signo, NULL); 1693 p->p_xstat = signo; 1694 1695 /* Emulation-specific handling of signal trace */ 1696 if (p->p_emul->e_tracesig == NULL || 1697 (*p->p_emul->e_tracesig)(p, signo) == 0) 1698 sigswitch(!(p->p_slflag & PSL_FSTRACE), 0, 1699 signo); 1700 1701 /* Check for a signal from the debugger. */ 1702 if ((signo = sigchecktrace(&sp)) == 0) 1703 continue; 1704 } 1705 1706 prop = sigprop[signo]; 1707 1708 /* 1709 * Decide whether the signal should be returned. 1710 */ 1711 switch ((long)SIGACTION(p, signo).sa_handler) { 1712 case (long)SIG_DFL: 1713 /* 1714 * Don't take default actions on system processes. 1715 */ 1716 if (p->p_pid <= 1) { 1717 #ifdef DIAGNOSTIC 1718 /* 1719 * Are you sure you want to ignore SIGSEGV 1720 * in init? XXX 1721 */ 1722 printf_nolog("Process (pid %d) got sig %d\n", 1723 p->p_pid, signo); 1724 #endif 1725 continue; 1726 } 1727 1728 /* 1729 * If there is a pending stop signal to process with 1730 * default action, stop here, then clear the signal. 1731 * However, if process is member of an orphaned 1732 * process group, ignore tty stop signals. 1733 */ 1734 if (prop & SA_STOP) { 1735 if (p->p_slflag & PSL_TRACED || 1736 ((p->p_sflag & PS_ORPHANPG) != 0 && 1737 prop & SA_TTYSTOP)) { 1738 /* Ignore the signal. */ 1739 continue; 1740 } 1741 /* Take the signal. */ 1742 (void)sigget(sp, NULL, signo, NULL); 1743 p->p_xstat = signo; 1744 signo = 0; 1745 sigswitch(true, PS_NOCLDSTOP, p->p_xstat); 1746 } else if (prop & SA_IGNORE) { 1747 /* 1748 * Except for SIGCONT, shouldn't get here. 1749 * Default action is to ignore; drop it. 1750 */ 1751 continue; 1752 } 1753 break; 1754 1755 case (long)SIG_IGN: 1756 #ifdef DEBUG_ISSIGNAL 1757 /* 1758 * Masking above should prevent us ever trying 1759 * to take action on an ignored signal other 1760 * than SIGCONT, unless process is traced. 1761 */ 1762 if ((prop & SA_CONT) == 0 && 1763 (p->p_slflag & PSL_TRACED) == 0) 1764 printf_nolog("issignal\n"); 1765 #endif 1766 continue; 1767 1768 default: 1769 /* 1770 * This signal has an action, let postsig() process 1771 * it. 1772 */ 1773 break; 1774 } 1775 1776 break; 1777 } 1778 1779 l->l_sigpendset = sp; 1780 return signo; 1781 } 1782 1783 /* 1784 * Take the action for the specified signal 1785 * from the current set of pending signals. 1786 */ 1787 void 1788 postsig(int signo) 1789 { 1790 struct lwp *l; 1791 struct proc *p; 1792 struct sigacts *ps; 1793 sig_t action; 1794 sigset_t *returnmask; 1795 ksiginfo_t ksi; 1796 1797 l = curlwp; 1798 p = l->l_proc; 1799 ps = p->p_sigacts; 1800 1801 KASSERT(mutex_owned(&p->p_smutex)); 1802 KASSERT(signo > 0); 1803 1804 /* 1805 * Set the new mask value and also defer further occurrences of this 1806 * signal. 1807 * 1808 * Special case: user has done a sigsuspend. Here the current mask is 1809 * not of interest, but rather the mask from before the sigsuspen is 1810 * what we want restored after the signal processing is completed. 1811 */ 1812 if (l->l_sigrestore) { 1813 returnmask = &l->l_sigoldmask; 1814 l->l_sigrestore = 0; 1815 } else 1816 returnmask = &l->l_sigmask; 1817 1818 /* 1819 * Commit to taking the signal before releasing the mutex. 1820 */ 1821 action = SIGACTION_PS(ps, signo).sa_handler; 1822 p->p_stats->p_ru.ru_nsignals++; 1823 sigget(l->l_sigpendset, &ksi, signo, NULL); 1824 1825 if (ktrpoint(KTR_PSIG)) { 1826 mutex_exit(&p->p_smutex); 1827 ktrpsig(signo, action, returnmask, NULL); 1828 mutex_enter(&p->p_smutex); 1829 } 1830 1831 if (action == SIG_DFL) { 1832 /* 1833 * Default action, where the default is to kill 1834 * the process. (Other cases were ignored above.) 1835 */ 1836 sigexit(l, signo); 1837 return; 1838 } 1839 1840 /* 1841 * If we get here, the signal must be caught. 1842 */ 1843 #ifdef DIAGNOSTIC 1844 if (action == SIG_IGN || sigismember(&l->l_sigmask, signo)) 1845 panic("postsig action"); 1846 #endif 1847 1848 kpsendsig(l, &ksi, returnmask); 1849 } 1850 1851 /* 1852 * sendsig_reset: 1853 * 1854 * Reset the signal action. Called from emulation specific sendsig() 1855 * before unlocking to deliver the signal. 1856 */ 1857 void 1858 sendsig_reset(struct lwp *l, int signo) 1859 { 1860 struct proc *p = l->l_proc; 1861 struct sigacts *ps = p->p_sigacts; 1862 1863 KASSERT(mutex_owned(&p->p_smutex)); 1864 1865 p->p_sigctx.ps_lwp = 0; 1866 p->p_sigctx.ps_code = 0; 1867 p->p_sigctx.ps_signo = 0; 1868 1869 mutex_enter(&ps->sa_mutex); 1870 sigplusset(&SIGACTION_PS(ps, signo).sa_mask, &l->l_sigmask); 1871 if (SIGACTION_PS(ps, signo).sa_flags & SA_RESETHAND) { 1872 sigdelset(&p->p_sigctx.ps_sigcatch, signo); 1873 if (signo != SIGCONT && sigprop[signo] & SA_IGNORE) 1874 sigaddset(&p->p_sigctx.ps_sigignore, signo); 1875 SIGACTION_PS(ps, signo).sa_handler = SIG_DFL; 1876 } 1877 mutex_exit(&ps->sa_mutex); 1878 } 1879 1880 /* 1881 * Kill the current process for stated reason. 1882 */ 1883 void 1884 killproc(struct proc *p, const char *why) 1885 { 1886 log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why); 1887 uprintf_locked("sorry, pid %d was killed: %s\n", p->p_pid, why); 1888 mutex_enter(&proclist_mutex); /* XXXSMP */ 1889 psignal(p, SIGKILL); 1890 mutex_exit(&proclist_mutex); /* XXXSMP */ 1891 } 1892 1893 /* 1894 * Force the current process to exit with the specified signal, dumping core 1895 * if appropriate. We bypass the normal tests for masked and caught 1896 * signals, allowing unrecoverable failures to terminate the process without 1897 * changing signal state. Mark the accounting record with the signal 1898 * termination. If dumping core, save the signal number for the debugger. 1899 * Calls exit and does not return. 1900 */ 1901 void 1902 sigexit(struct lwp *l, int signo) 1903 { 1904 int exitsig, error, docore; 1905 struct proc *p; 1906 struct lwp *t; 1907 1908 p = l->l_proc; 1909 1910 KASSERT(mutex_owned(&p->p_smutex)); 1911 KERNEL_UNLOCK_ALL(l, NULL); 1912 1913 /* 1914 * Don't permit coredump() multiple times in the same process. 1915 * Call back into sigexit, where we will be suspended until 1916 * the deed is done. Note that this is a recursive call, but 1917 * LW_WCORE will prevent us from coming back this way. 1918 */ 1919 if ((p->p_sflag & PS_WCORE) != 0) { 1920 lwp_lock(l); 1921 l->l_flag |= (LW_WCORE | LW_WEXIT | LW_WSUSPEND); 1922 lwp_unlock(l); 1923 mutex_exit(&p->p_smutex); 1924 lwp_userret(l); 1925 #ifdef DIAGNOSTIC 1926 panic("sigexit"); 1927 #endif 1928 /* NOTREACHED */ 1929 } 1930 1931 /* 1932 * Prepare all other LWPs for exit. If dumping core, suspend them 1933 * so that their registers are available long enough to be dumped. 1934 */ 1935 if ((docore = (sigprop[signo] & SA_CORE)) != 0) { 1936 p->p_sflag |= PS_WCORE; 1937 for (;;) { 1938 LIST_FOREACH(t, &p->p_lwps, l_sibling) { 1939 lwp_lock(t); 1940 if (t == l) { 1941 t->l_flag &= ~LW_WSUSPEND; 1942 lwp_unlock(t); 1943 continue; 1944 } 1945 t->l_flag |= (LW_WCORE | LW_WEXIT); 1946 lwp_suspend(l, t); 1947 } 1948 1949 if (p->p_nrlwps == 1) 1950 break; 1951 1952 /* 1953 * Kick any LWPs sitting in lwp_wait1(), and wait 1954 * for everyone else to stop before proceeding. 1955 */ 1956 p->p_nlwpwait++; 1957 cv_broadcast(&p->p_lwpcv); 1958 cv_wait(&p->p_lwpcv, &p->p_smutex); 1959 p->p_nlwpwait--; 1960 } 1961 } 1962 1963 exitsig = signo; 1964 p->p_acflag |= AXSIG; 1965 p->p_sigctx.ps_signo = signo; 1966 mutex_exit(&p->p_smutex); 1967 1968 KERNEL_LOCK(1, l); 1969 1970 if (docore) { 1971 if ((error = coredump(l, NULL)) == 0) 1972 exitsig |= WCOREFLAG; 1973 1974 if (kern_logsigexit) { 1975 int uid = l->l_cred ? 1976 (int)kauth_cred_geteuid(l->l_cred) : -1; 1977 1978 if (error) 1979 log(LOG_INFO, lognocoredump, p->p_pid, 1980 p->p_comm, uid, signo, error); 1981 else 1982 log(LOG_INFO, logcoredump, p->p_pid, 1983 p->p_comm, uid, signo); 1984 } 1985 1986 #ifdef PAX_SEGVGUARD 1987 pax_segvguard(l, p->p_textvp, p->p_comm, true); 1988 #endif /* PAX_SEGVGUARD */ 1989 } 1990 1991 /* Acquire the sched state mutex. exit1() will release it. */ 1992 mutex_enter(&p->p_smutex); 1993 1994 /* No longer dumping core. */ 1995 p->p_sflag &= ~PS_WCORE; 1996 1997 exit1(l, W_EXITCODE(0, exitsig)); 1998 /* NOTREACHED */ 1999 } 2000 2001 /* 2002 * Put process 'p' into the stopped state and optionally, notify the parent. 2003 */ 2004 void 2005 proc_stop(struct proc *p, int notify, int signo) 2006 { 2007 struct lwp *l; 2008 2009 KASSERT(mutex_owned(&p->p_smutex)); 2010 2011 /* 2012 * First off, set the stopping indicator and bring all sleeping 2013 * LWPs to a halt so they are included in p->p_nrlwps. We musn't 2014 * unlock between here and the p->p_nrlwps check below. 2015 */ 2016 p->p_sflag |= PS_STOPPING; 2017 if (notify) 2018 p->p_sflag |= PS_NOTIFYSTOP; 2019 else 2020 p->p_sflag &= ~PS_NOTIFYSTOP; 2021 membar_producer(); 2022 2023 proc_stop_lwps(p); 2024 2025 /* 2026 * If there are no LWPs available to take the signal, then we 2027 * signal the parent process immediately. Otherwise, the last 2028 * LWP to stop will take care of it. 2029 */ 2030 2031 if (p->p_nrlwps == 0) { 2032 proc_stop_done(p, true, PS_NOCLDSTOP); 2033 } else { 2034 /* 2035 * Have the remaining LWPs come to a halt, and trigger 2036 * proc_stop_callout() to ensure that they do. 2037 */ 2038 LIST_FOREACH(l, &p->p_lwps, l_sibling) 2039 sigpost(l, SIG_DFL, SA_STOP, signo); 2040 callout_schedule(&proc_stop_ch, 1); 2041 } 2042 } 2043 2044 /* 2045 * When stopping a process, we do not immediatly set sleeping LWPs stopped, 2046 * but wait for them to come to a halt at the kernel-user boundary. This is 2047 * to allow LWPs to release any locks that they may hold before stopping. 2048 * 2049 * Non-interruptable sleeps can be long, and there is the potential for an 2050 * LWP to begin sleeping interruptably soon after the process has been set 2051 * stopping (PS_STOPPING). These LWPs will not notice that the process is 2052 * stopping, and so complete halt of the process and the return of status 2053 * information to the parent could be delayed indefinitely. 2054 * 2055 * To handle this race, proc_stop_callout() runs once per tick while there 2056 * are stopping processes in the system. It sets LWPs that are sleeping 2057 * interruptably into the LSSTOP state. 2058 * 2059 * Note that we are not concerned about keeping all LWPs stopped while the 2060 * process is stopped: stopped LWPs can awaken briefly to handle signals. 2061 * What we do need to ensure is that all LWPs in a stopping process have 2062 * stopped at least once, so that notification can be sent to the parent 2063 * process. 2064 */ 2065 static void 2066 proc_stop_callout(void *cookie) 2067 { 2068 bool more, restart; 2069 struct proc *p; 2070 2071 (void)cookie; 2072 2073 do { 2074 restart = false; 2075 more = false; 2076 2077 mutex_enter(&proclist_lock); 2078 mutex_enter(&proclist_mutex); 2079 PROCLIST_FOREACH(p, &allproc) { 2080 mutex_enter(&p->p_smutex); 2081 2082 if ((p->p_sflag & PS_STOPPING) == 0) { 2083 mutex_exit(&p->p_smutex); 2084 continue; 2085 } 2086 2087 /* Stop any LWPs sleeping interruptably. */ 2088 proc_stop_lwps(p); 2089 if (p->p_nrlwps == 0) { 2090 /* 2091 * We brought the process to a halt. 2092 * Mark it as stopped and notify the 2093 * parent. 2094 */ 2095 if ((p->p_sflag & PS_NOTIFYSTOP) != 0) { 2096 /* 2097 * Note that proc_stop_done() will 2098 * drop p->p_smutex briefly. 2099 * Arrange to restart and check 2100 * all processes again. 2101 */ 2102 restart = true; 2103 } 2104 proc_stop_done(p, true, PS_NOCLDSTOP); 2105 } else 2106 more = true; 2107 2108 mutex_exit(&p->p_smutex); 2109 if (restart) 2110 break; 2111 } 2112 mutex_exit(&proclist_mutex); 2113 mutex_exit(&proclist_lock); 2114 } while (restart); 2115 2116 /* 2117 * If we noted processes that are stopping but still have 2118 * running LWPs, then arrange to check again in 1 tick. 2119 */ 2120 if (more) 2121 callout_schedule(&proc_stop_ch, 1); 2122 } 2123 2124 /* 2125 * Given a process in state SSTOP, set the state back to SACTIVE and 2126 * move LSSTOP'd LWPs to LSSLEEP or make them runnable. 2127 */ 2128 void 2129 proc_unstop(struct proc *p) 2130 { 2131 struct lwp *l; 2132 int sig; 2133 2134 KASSERT(mutex_owned(&proclist_mutex)); 2135 KASSERT(mutex_owned(&p->p_smutex)); 2136 2137 p->p_stat = SACTIVE; 2138 p->p_sflag &= ~PS_STOPPING; 2139 sig = p->p_xstat; 2140 2141 if (!p->p_waited) 2142 p->p_pptr->p_nstopchild--; 2143 2144 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 2145 lwp_lock(l); 2146 if (l->l_stat != LSSTOP) { 2147 lwp_unlock(l); 2148 continue; 2149 } 2150 if (l->l_wchan == NULL) { 2151 setrunnable(l); 2152 continue; 2153 } 2154 if (sig && (l->l_flag & LW_SINTR) != 0) { 2155 setrunnable(l); 2156 sig = 0; 2157 } else { 2158 l->l_stat = LSSLEEP; 2159 p->p_nrlwps++; 2160 lwp_unlock(l); 2161 } 2162 } 2163 } 2164 2165 static int 2166 filt_sigattach(struct knote *kn) 2167 { 2168 struct proc *p = curproc; 2169 2170 kn->kn_ptr.p_proc = p; 2171 kn->kn_flags |= EV_CLEAR; /* automatically set */ 2172 2173 mutex_enter(&p->p_smutex); 2174 SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext); 2175 mutex_exit(&p->p_smutex); 2176 2177 return (0); 2178 } 2179 2180 static void 2181 filt_sigdetach(struct knote *kn) 2182 { 2183 struct proc *p = kn->kn_ptr.p_proc; 2184 2185 mutex_enter(&p->p_smutex); 2186 SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext); 2187 mutex_exit(&p->p_smutex); 2188 } 2189 2190 /* 2191 * signal knotes are shared with proc knotes, so we apply a mask to 2192 * the hint in order to differentiate them from process hints. This 2193 * could be avoided by using a signal-specific knote list, but probably 2194 * isn't worth the trouble. 2195 */ 2196 static int 2197 filt_signal(struct knote *kn, long hint) 2198 { 2199 2200 if (hint & NOTE_SIGNAL) { 2201 hint &= ~NOTE_SIGNAL; 2202 2203 if (kn->kn_id == hint) 2204 kn->kn_data++; 2205 } 2206 return (kn->kn_data != 0); 2207 } 2208 2209 const struct filterops sig_filtops = { 2210 0, filt_sigattach, filt_sigdetach, filt_signal 2211 }; 2212