Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/kern/sys_sig.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: sys_sig.c,v 1.56 2022/04/21 21:31:11 andvar Exp $ */ 2 3 /*- 4 * Copyright (c) 2006, 2007, 2008 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 #include <sys/cdefs.h> 69 __KERNEL_RCSID(0, "$NetBSD: sys_sig.c,v 1.56 2022/04/21 21:31:11 andvar Exp $"); 70 71 #include "opt_dtrace.h" 72 73 #include <sys/param.h> 74 #include <sys/kernel.h> 75 #include <sys/signalvar.h> 76 #include <sys/proc.h> 77 #include <sys/pool.h> 78 #include <sys/syscallargs.h> 79 #include <sys/kauth.h> 80 #include <sys/wait.h> 81 #include <sys/kmem.h> 82 #include <sys/module.h> 83 #include <sys/sdt.h> 84 #include <sys/compat_stub.h> 85 86 SDT_PROVIDER_DECLARE(proc); 87 SDT_PROBE_DEFINE2(proc, kernel, , signal__clear, 88 "int", /* signal */ 89 "ksiginfo_t *"); /* signal-info */ 90 91 int 92 sys___sigaction_sigtramp(struct lwp *l, 93 const struct sys___sigaction_sigtramp_args *uap, register_t *retval) 94 { 95 /* { 96 syscallarg(int) signum; 97 syscallarg(const struct sigaction *) nsa; 98 syscallarg(struct sigaction *) osa; 99 syscallarg(void *) tramp; 100 syscallarg(int) vers; 101 } */ 102 struct sigaction nsa, osa; 103 int error; 104 105 if (SCARG(uap, nsa)) { 106 error = copyin(SCARG(uap, nsa), &nsa, sizeof(nsa)); 107 if (error) 108 return (error); 109 } 110 error = sigaction1(l, SCARG(uap, signum), 111 SCARG(uap, nsa) ? &nsa : 0, SCARG(uap, osa) ? &osa : 0, 112 SCARG(uap, tramp), SCARG(uap, vers)); 113 if (error) 114 return (error); 115 if (SCARG(uap, osa)) { 116 error = copyout(&osa, SCARG(uap, osa), sizeof(osa)); 117 if (error) 118 return (error); 119 } 120 return 0; 121 } 122 123 /* 124 * Manipulate signal mask. Note that we receive new mask, not pointer, and 125 * return old mask as return value; the library stub does the rest. 126 */ 127 int 128 sys___sigprocmask14(struct lwp *l, const struct sys___sigprocmask14_args *uap, 129 register_t *retval) 130 { 131 /* { 132 syscallarg(int) how; 133 syscallarg(const sigset_t *) set; 134 syscallarg(sigset_t *) oset; 135 } */ 136 struct proc *p = l->l_proc; 137 sigset_t nss, oss; 138 int error; 139 140 if (SCARG(uap, set)) { 141 error = copyin(SCARG(uap, set), &nss, sizeof(nss)); 142 if (error) 143 return error; 144 } 145 mutex_enter(p->p_lock); 146 error = sigprocmask1(l, SCARG(uap, how), 147 SCARG(uap, set) ? &nss : 0, SCARG(uap, oset) ? &oss : 0); 148 mutex_exit(p->p_lock); 149 if (error) 150 return error; 151 if (SCARG(uap, oset)) { 152 error = copyout(&oss, SCARG(uap, oset), sizeof(oss)); 153 if (error) 154 return error; 155 } 156 return 0; 157 } 158 159 int 160 sys___sigpending14(struct lwp *l, const struct sys___sigpending14_args *uap, 161 register_t *retval) 162 { 163 /* { 164 syscallarg(sigset_t *) set; 165 } */ 166 sigset_t ss; 167 168 sigpending1(l, &ss); 169 return copyout(&ss, SCARG(uap, set), sizeof(ss)); 170 } 171 172 /* 173 * Suspend process until signal, providing mask to be set in the meantime. 174 * Note nonstandard calling convention: libc stub passes mask, not pointer, 175 * to save a copyin. 176 */ 177 int 178 sys___sigsuspend14(struct lwp *l, const struct sys___sigsuspend14_args *uap, 179 register_t *retval) 180 { 181 /* { 182 syscallarg(const sigset_t *) set; 183 } */ 184 sigset_t ss; 185 int error; 186 187 if (SCARG(uap, set)) { 188 error = copyin(SCARG(uap, set), &ss, sizeof(ss)); 189 if (error) 190 return error; 191 } 192 return sigsuspend1(l, SCARG(uap, set) ? &ss : 0); 193 } 194 195 int 196 sys___sigaltstack14(struct lwp *l, const struct sys___sigaltstack14_args *uap, 197 register_t *retval) 198 { 199 /* { 200 syscallarg(const struct sigaltstack *) nss; 201 syscallarg(struct sigaltstack *) oss; 202 } */ 203 stack_t nss, oss; 204 int error; 205 206 if (SCARG(uap, nss)) { 207 error = copyin(SCARG(uap, nss), &nss, sizeof(nss)); 208 if (error) 209 return error; 210 } 211 error = sigaltstack1(l, 212 SCARG(uap, nss) ? &nss : 0, SCARG(uap, oss) ? &oss : 0); 213 if (error) 214 return error; 215 if (SCARG(uap, oss)) { 216 error = copyout(&oss, SCARG(uap, oss), sizeof(oss)); 217 if (error) 218 return error; 219 } 220 return 0; 221 } 222 223 int 224 kill1(struct lwp *l, pid_t pid, ksiginfo_t *ksi, register_t *retval) 225 { 226 int error; 227 struct proc *p; 228 229 if ((u_int)ksi->ksi_signo >= NSIG) 230 return EINVAL; 231 232 if (pid != l->l_proc->p_pid) { 233 if (ksi->ksi_pid != l->l_proc->p_pid) 234 return EPERM; 235 236 if (ksi->ksi_uid != kauth_cred_geteuid(l->l_cred)) 237 return EPERM; 238 239 switch (ksi->ksi_code) { 240 case SI_USER: 241 case SI_QUEUE: 242 break; 243 default: 244 return EPERM; 245 } 246 } 247 248 if (pid > 0) { 249 /* kill single process */ 250 mutex_enter(&proc_lock); 251 p = proc_find_raw(pid); 252 if (p == NULL || (p->p_stat != SACTIVE && p->p_stat != SSTOP)) { 253 mutex_exit(&proc_lock); 254 /* IEEE Std 1003.1-2001: return success for zombies */ 255 return p ? 0 : ESRCH; 256 } 257 mutex_enter(p->p_lock); 258 error = kauth_authorize_process(l->l_cred, 259 KAUTH_PROCESS_SIGNAL, p, KAUTH_ARG(ksi->ksi_signo), 260 NULL, NULL); 261 if (!error && ksi->ksi_signo) { 262 error = kpsignal2(p, ksi); 263 } 264 mutex_exit(p->p_lock); 265 mutex_exit(&proc_lock); 266 return error; 267 } 268 269 switch (pid) { 270 case -1: /* broadcast signal */ 271 return killpg1(l, ksi, 0, 1); 272 case 0: /* signal own process group */ 273 return killpg1(l, ksi, 0, 0); 274 default: /* negative explicit process group */ 275 return killpg1(l, ksi, -pid, 0); 276 } 277 /* NOTREACHED */ 278 } 279 280 int 281 sys_sigqueueinfo(struct lwp *l, const struct sys_sigqueueinfo_args *uap, 282 register_t *retval) 283 { 284 /* { 285 syscallarg(pid_t int) pid; 286 syscallarg(const siginfo_t *) info; 287 } */ 288 ksiginfo_t ksi; 289 int error; 290 291 KSI_INIT(&ksi); 292 293 if ((error = copyin(&SCARG(uap, info)->_info, &ksi.ksi_info, 294 sizeof(ksi.ksi_info))) != 0) 295 return error; 296 297 return kill1(l, SCARG(uap, pid), &ksi, retval); 298 } 299 300 int 301 sys_kill(struct lwp *l, const struct sys_kill_args *uap, register_t *retval) 302 { 303 /* { 304 syscallarg(pid_t) pid; 305 syscallarg(int) signum; 306 } */ 307 ksiginfo_t ksi; 308 309 KSI_INIT(&ksi); 310 311 ksi.ksi_signo = SCARG(uap, signum); 312 ksi.ksi_code = SI_USER; 313 ksi.ksi_pid = l->l_proc->p_pid; 314 ksi.ksi_uid = kauth_cred_geteuid(l->l_cred); 315 316 return kill1(l, SCARG(uap, pid), &ksi, retval); 317 } 318 319 int 320 sys_getcontext(struct lwp *l, const struct sys_getcontext_args *uap, 321 register_t *retval) 322 { 323 /* { 324 syscallarg(struct __ucontext *) ucp; 325 } */ 326 struct proc *p = l->l_proc; 327 ucontext_t uc; 328 329 memset(&uc, 0, sizeof(uc)); 330 331 mutex_enter(p->p_lock); 332 getucontext(l, &uc); 333 mutex_exit(p->p_lock); 334 335 return copyout(&uc, SCARG(uap, ucp), sizeof (*SCARG(uap, ucp))); 336 } 337 338 int 339 sys_setcontext(struct lwp *l, const struct sys_setcontext_args *uap, 340 register_t *retval) 341 { 342 /* { 343 syscallarg(const ucontext_t *) ucp; 344 } */ 345 struct proc *p = l->l_proc; 346 ucontext_t uc; 347 int error; 348 349 error = copyin(SCARG(uap, ucp), &uc, sizeof (uc)); 350 if (error) 351 return error; 352 if ((uc.uc_flags & _UC_CPU) == 0) 353 return EINVAL; 354 mutex_enter(p->p_lock); 355 error = setucontext(l, &uc); 356 mutex_exit(p->p_lock); 357 if (error) 358 return error; 359 360 return EJUSTRETURN; 361 } 362 363 /* 364 * sigtimedwait(2) system call, used also for implementation 365 * of sigwaitinfo() and sigwait(). 366 * 367 * This only handles single LWP in signal wait. libpthread provides 368 * its own sigtimedwait() wrapper to DTRT WRT individual threads. 369 */ 370 int 371 sys_____sigtimedwait50(struct lwp *l, 372 const struct sys_____sigtimedwait50_args *uap, register_t *retval) 373 { 374 375 return sigtimedwait1(l, uap, retval, copyin, copyout, copyin, copyout); 376 } 377 378 int 379 sigaction1(struct lwp *l, int signum, const struct sigaction *nsa, 380 struct sigaction *osa, const void *tramp, int vers) 381 { 382 struct proc *p; 383 struct sigacts *ps; 384 sigset_t tset; 385 int prop, error; 386 ksiginfoq_t kq; 387 static bool v0v1valid; 388 389 if (signum <= 0 || signum >= NSIG) 390 return EINVAL; 391 392 p = l->l_proc; 393 error = 0; 394 ksiginfo_queue_init(&kq); 395 396 /* 397 * Trampoline ABI version __SIGTRAMP_SIGCODE_VERSION (0) is reserved 398 * for the legacy kernel provided on-stack trampoline. Conversely, 399 * if we are using a non-0 ABI version, we must have a trampoline. 400 * Only validate the vers if a new sigaction was supplied and there 401 * was an actual handler specified (not SIG_IGN or SIG_DFL), which 402 * don't require a trampoline. Emulations use legacy kernel 403 * trampolines with version 0, alternatively check for that too. 404 * 405 * If version < __SIGTRAMP_SIGINFO_VERSION_MIN (usually 2), we try 406 * to autoload the compat module. Note that we interlock with the 407 * unload check in compat_modcmd() using kernconfig_lock. If the 408 * autoload fails, we don't try it again for this process. 409 */ 410 if (nsa != NULL && nsa->sa_handler != SIG_IGN 411 && nsa->sa_handler != SIG_DFL) { 412 if (__predict_false(vers < __SIGTRAMP_SIGINFO_VERSION_MIN)) { 413 if (vers == __SIGTRAMP_SIGCODE_VERSION && 414 p->p_sigctx.ps_sigcode != NULL) { 415 /* 416 * if sigcode is used for this emulation, 417 * version 0 is allowed. 418 */ 419 } 420 #ifdef __HAVE_STRUCT_SIGCONTEXT 421 else if (p->p_flag & PK_32) { 422 /* 423 * The 32-bit compat module will have 424 * pre-validated this for us. 425 */ 426 v0v1valid = true; 427 } else if ((p->p_lflag & PL_SIGCOMPAT) == 0) { 428 kernconfig_lock(); 429 (void)module_autoload("compat_16", 430 MODULE_CLASS_ANY); 431 if (sendsig_sigcontext_16_hook.hooked) { 432 /* 433 * We need to remember if the 434 * sigcontext method may be useable, 435 * because libc may use it even 436 * if siginfo is available. 437 */ 438 v0v1valid = true; 439 } 440 mutex_enter(&proc_lock); 441 /* 442 * Prevent unload of compat module while 443 * this process remains. 444 */ 445 p->p_lflag |= PL_SIGCOMPAT; 446 mutex_exit(&proc_lock); 447 kernconfig_unlock(); 448 } 449 #endif /* __HAVE_STRUCT_SIGCONTEXT */ 450 } 451 452 switch (vers) { 453 case __SIGTRAMP_SIGCODE_VERSION: 454 /* kernel supplied trampoline. */ 455 if (tramp != NULL || 456 (p->p_sigctx.ps_sigcode == NULL && !v0v1valid)) { 457 return EINVAL; 458 } 459 break; 460 #ifdef __HAVE_STRUCT_SIGCONTEXT 461 case __SIGTRAMP_SIGCONTEXT_VERSION_MIN ... 462 __SIGTRAMP_SIGCONTEXT_VERSION_MAX: 463 /* sigcontext, user supplied trampoline. */ 464 if (tramp == NULL || !v0v1valid) { 465 return EINVAL; 466 } 467 break; 468 #endif /* __HAVE_STRUCT_SIGCONTEXT */ 469 case __SIGTRAMP_SIGINFO_VERSION_MIN ... 470 __SIGTRAMP_SIGINFO_VERSION_MAX: 471 /* siginfo, user supplied trampoline. */ 472 if (tramp == NULL) { 473 return EINVAL; 474 } 475 break; 476 default: 477 /* Invalid trampoline version. */ 478 return EINVAL; 479 } 480 } 481 482 mutex_enter(p->p_lock); 483 484 ps = p->p_sigacts; 485 if (osa) 486 sigaction_copy(osa, &SIGACTION_PS(ps, signum)); 487 if (!nsa) 488 goto out; 489 490 prop = sigprop[signum]; 491 if ((nsa->sa_flags & ~SA_ALLBITS) || (prop & SA_CANTMASK)) { 492 error = EINVAL; 493 goto out; 494 } 495 496 sigaction_copy(&SIGACTION_PS(ps, signum), nsa); 497 ps->sa_sigdesc[signum].sd_tramp = tramp; 498 ps->sa_sigdesc[signum].sd_vers = vers; 499 sigminusset(&sigcantmask, &SIGACTION_PS(ps, signum).sa_mask); 500 501 if ((prop & SA_NORESET) != 0) 502 SIGACTION_PS(ps, signum).sa_flags &= ~SA_RESETHAND; 503 504 if (signum == SIGCHLD) { 505 if (nsa->sa_flags & SA_NOCLDSTOP) 506 p->p_sflag |= PS_NOCLDSTOP; 507 else 508 p->p_sflag &= ~PS_NOCLDSTOP; 509 if (nsa->sa_flags & SA_NOCLDWAIT) { 510 /* 511 * Paranoia: since SA_NOCLDWAIT is implemented by 512 * reparenting the dying child to PID 1 (and trust 513 * it to reap the zombie), PID 1 itself is forbidden 514 * to set SA_NOCLDWAIT. 515 */ 516 if (p->p_pid == 1) 517 p->p_flag &= ~PK_NOCLDWAIT; 518 else 519 p->p_flag |= PK_NOCLDWAIT; 520 } else 521 p->p_flag &= ~PK_NOCLDWAIT; 522 523 if (nsa->sa_handler == SIG_IGN) { 524 /* 525 * Paranoia: same as above. 526 */ 527 if (p->p_pid == 1) 528 p->p_flag &= ~PK_CLDSIGIGN; 529 else 530 p->p_flag |= PK_CLDSIGIGN; 531 } else 532 p->p_flag &= ~PK_CLDSIGIGN; 533 } 534 535 if ((nsa->sa_flags & SA_NODEFER) == 0) 536 sigaddset(&SIGACTION_PS(ps, signum).sa_mask, signum); 537 else 538 sigdelset(&SIGACTION_PS(ps, signum).sa_mask, signum); 539 540 /* 541 * Set bit in p_sigctx.ps_sigignore for signals that are set to 542 * SIG_IGN, and for signals set to SIG_DFL where the default is to 543 * ignore. However, don't put SIGCONT in p_sigctx.ps_sigignore, as 544 * we have to restart the process. 545 */ 546 if (nsa->sa_handler == SIG_IGN || 547 (nsa->sa_handler == SIG_DFL && (prop & SA_IGNORE) != 0)) { 548 /* Never to be seen again. */ 549 sigemptyset(&tset); 550 sigaddset(&tset, signum); 551 sigclearall(p, &tset, &kq); 552 if (signum != SIGCONT) { 553 /* Easier in psignal */ 554 sigaddset(&p->p_sigctx.ps_sigignore, signum); 555 } 556 sigdelset(&p->p_sigctx.ps_sigcatch, signum); 557 } else { 558 sigdelset(&p->p_sigctx.ps_sigignore, signum); 559 if (nsa->sa_handler == SIG_DFL) 560 sigdelset(&p->p_sigctx.ps_sigcatch, signum); 561 else 562 sigaddset(&p->p_sigctx.ps_sigcatch, signum); 563 } 564 565 /* 566 * Previously held signals may now have become visible. Ensure that 567 * we check for them before returning to userspace. 568 */ 569 if (sigispending(l, 0)) { 570 lwp_lock(l); 571 l->l_flag |= LW_PENDSIG; 572 lwp_unlock(l); 573 } 574 out: 575 mutex_exit(p->p_lock); 576 ksiginfo_queue_drain(&kq); 577 578 return error; 579 } 580 581 int 582 sigprocmask1(struct lwp *l, int how, const sigset_t *nss, sigset_t *oss) 583 { 584 sigset_t *mask = &l->l_sigmask; 585 bool more; 586 587 KASSERT(mutex_owned(l->l_proc->p_lock)); 588 589 if (oss) { 590 *oss = *mask; 591 } 592 593 if (nss == NULL) { 594 return 0; 595 } 596 597 switch (how) { 598 case SIG_BLOCK: 599 sigplusset(nss, mask); 600 more = false; 601 break; 602 case SIG_UNBLOCK: 603 sigminusset(nss, mask); 604 more = true; 605 break; 606 case SIG_SETMASK: 607 *mask = *nss; 608 more = true; 609 break; 610 default: 611 return EINVAL; 612 } 613 sigminusset(&sigcantmask, mask); 614 if (more && sigispending(l, 0)) { 615 /* 616 * Check for pending signals on return to user. 617 */ 618 lwp_lock(l); 619 l->l_flag |= LW_PENDSIG; 620 lwp_unlock(l); 621 } 622 return 0; 623 } 624 625 void 626 sigpending1(struct lwp *l, sigset_t *ss) 627 { 628 struct proc *p = l->l_proc; 629 630 mutex_enter(p->p_lock); 631 *ss = l->l_sigpend.sp_set; 632 sigplusset(&p->p_sigpend.sp_set, ss); 633 mutex_exit(p->p_lock); 634 } 635 636 void 637 sigsuspendsetup(struct lwp *l, const sigset_t *ss) 638 { 639 struct proc *p = l->l_proc; 640 641 /* 642 * When returning from sigsuspend/pselect/pollts, we want 643 * the old mask to be restored after the 644 * signal handler has finished. Thus, we 645 * save it here and mark the sigctx structure 646 * to indicate this. 647 */ 648 mutex_enter(p->p_lock); 649 l->l_sigrestore = 1; 650 l->l_sigoldmask = l->l_sigmask; 651 l->l_sigmask = *ss; 652 sigminusset(&sigcantmask, &l->l_sigmask); 653 654 /* Check for pending signals when sleeping. */ 655 if (sigispending(l, 0)) { 656 lwp_lock(l); 657 l->l_flag |= LW_PENDSIG; 658 lwp_unlock(l); 659 } 660 mutex_exit(p->p_lock); 661 } 662 663 void 664 sigsuspendteardown(struct lwp *l) 665 { 666 struct proc *p = l->l_proc; 667 668 mutex_enter(p->p_lock); 669 /* Check for pending signals when sleeping. */ 670 if (l->l_sigrestore) { 671 if (sigispending(l, 0)) { 672 lwp_lock(l); 673 l->l_flag |= LW_PENDSIG; 674 lwp_unlock(l); 675 } else { 676 l->l_sigrestore = 0; 677 l->l_sigmask = l->l_sigoldmask; 678 } 679 } 680 mutex_exit(p->p_lock); 681 } 682 683 int 684 sigsuspend1(struct lwp *l, const sigset_t *ss) 685 { 686 687 if (ss) 688 sigsuspendsetup(l, ss); 689 690 while (kpause("pause", true, 0, NULL) == 0) 691 ; 692 693 /* always return EINTR rather than ERESTART... */ 694 return EINTR; 695 } 696 697 int 698 sigaltstack1(struct lwp *l, const stack_t *nss, stack_t *oss) 699 { 700 struct proc *p = l->l_proc; 701 int error = 0; 702 703 mutex_enter(p->p_lock); 704 705 if (oss) 706 *oss = l->l_sigstk; 707 708 if (nss) { 709 if (nss->ss_flags & ~SS_ALLBITS) 710 error = EINVAL; 711 else if (nss->ss_flags & SS_DISABLE) { 712 if (l->l_sigstk.ss_flags & SS_ONSTACK) 713 error = EINVAL; 714 } else if (nss->ss_size < MINSIGSTKSZ) 715 error = ENOMEM; 716 717 if (!error) 718 l->l_sigstk = *nss; 719 } 720 721 mutex_exit(p->p_lock); 722 723 return error; 724 } 725 726 int 727 sigtimedwait1(struct lwp *l, const struct sys_____sigtimedwait50_args *uap, 728 register_t *retval, copyin_t fetchss, copyout_t storeinf, copyin_t fetchts, 729 copyout_t storets) 730 { 731 /* { 732 syscallarg(const sigset_t *) set; 733 syscallarg(siginfo_t *) info; 734 syscallarg(struct timespec *) timeout; 735 } */ 736 struct proc *p = l->l_proc; 737 int error, signum, timo; 738 struct timespec ts, tsstart, tsnow; 739 ksiginfo_t ksi; 740 741 /* 742 * Calculate timeout, if it was specified. 743 * 744 * NULL pointer means an infinite timeout. 745 * {.tv_sec = 0, .tv_nsec = 0} means do not block. 746 */ 747 if (SCARG(uap, timeout)) { 748 error = (*fetchts)(SCARG(uap, timeout), &ts, sizeof(ts)); 749 if (error) 750 return error; 751 752 if ((error = itimespecfix(&ts)) != 0) 753 return error; 754 755 timo = tstohz(&ts); 756 if (timo == 0) { 757 if (ts.tv_sec == 0 && ts.tv_nsec == 0) 758 timo = -1; /* do not block */ 759 else 760 timo = 1; /* the shortest possible timeout */ 761 } 762 763 /* 764 * Remember current uptime, it would be used in 765 * ECANCELED/ERESTART case. 766 */ 767 getnanouptime(&tsstart); 768 } else { 769 memset(&tsstart, 0, sizeof(tsstart)); /* XXXgcc */ 770 timo = 0; /* infinite timeout */ 771 } 772 773 error = (*fetchss)(SCARG(uap, set), &l->l_sigwaitset, 774 sizeof(l->l_sigwaitset)); 775 if (error) 776 return error; 777 778 /* 779 * Silently ignore SA_CANTMASK signals. psignal1() would ignore 780 * SA_CANTMASK signals in waitset, we do this only for the below 781 * siglist check. 782 */ 783 sigminusset(&sigcantmask, &l->l_sigwaitset); 784 785 memset(&ksi.ksi_info, 0, sizeof(ksi.ksi_info)); 786 787 mutex_enter(p->p_lock); 788 789 /* Check for pending signals in the process, if no - then in LWP. */ 790 if ((signum = sigget(&p->p_sigpend, &ksi, 0, &l->l_sigwaitset)) == 0) 791 signum = sigget(&l->l_sigpend, &ksi, 0, &l->l_sigwaitset); 792 793 if (signum != 0) { 794 /* If found a pending signal, just copy it out to the user. */ 795 mutex_exit(p->p_lock); 796 goto out; 797 } 798 799 if (timo < 0) { 800 /* If not allowed to block, return an error */ 801 mutex_exit(p->p_lock); 802 return EAGAIN; 803 } 804 805 /* 806 * Set up the sigwait list and wait for signal to arrive. 807 * We can either be woken up or time out. 808 */ 809 l->l_sigwaited = &ksi; 810 LIST_INSERT_HEAD(&p->p_sigwaiters, l, l_sigwaiter); 811 error = cv_timedwait_sig(&l->l_sigcv, p->p_lock, timo); 812 813 /* 814 * Need to find out if we woke as a result of _lwp_wakeup() or a 815 * signal outside our wait set. 816 */ 817 if (l->l_sigwaited != NULL) { 818 if (error == EINTR) { 819 /* Wakeup via _lwp_wakeup(). */ 820 error = ECANCELED; 821 } else if (!error) { 822 /* Spurious wakeup - arrange for syscall restart. */ 823 error = ERESTART; 824 } 825 l->l_sigwaited = NULL; 826 LIST_REMOVE(l, l_sigwaiter); 827 } 828 mutex_exit(p->p_lock); 829 830 /* 831 * If the sleep was interrupted (either by signal or wakeup), update 832 * the timeout and copyout new value back. It would be used when 833 * the syscall would be restarted or called again. 834 */ 835 if (timo && (error == ERESTART || error == ECANCELED)) { 836 getnanouptime(&tsnow); 837 838 /* Compute how much time has passed since start. */ 839 timespecsub(&tsnow, &tsstart, &tsnow); 840 841 /* Subtract passed time from timeout. */ 842 timespecsub(&ts, &tsnow, &ts); 843 844 if (ts.tv_sec < 0) 845 error = EAGAIN; 846 else { 847 /* Copy updated timeout to userland. */ 848 error = (*storets)(&ts, SCARG(uap, timeout), 849 sizeof(ts)); 850 } 851 } 852 out: 853 /* 854 * If a signal from the wait set arrived, copy it to userland. 855 * Copy only the used part of siginfo, the padding part is 856 * left unchanged (userland is not supposed to touch it anyway). 857 */ 858 if (error == 0 && SCARG(uap, info)) { 859 error = (*storeinf)(&ksi.ksi_info, SCARG(uap, info), 860 sizeof(ksi.ksi_info)); 861 } 862 if (error == 0) { 863 *retval = ksi.ksi_info._signo; 864 SDT_PROBE(proc, kernel, , signal__clear, *retval, 865 &ksi, 0, 0, 0); 866 } 867 return error; 868 }
Cache object: 89024debdbe8fd05fb1f9c1548f00350
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]