1 /* $NetBSD: sys_sig.c,v 1.51 2020/05/23 23:42:43 ad 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.51 2020/05/23 23:42:43 ad 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 struct sigaltstack 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 0 is reserved for the legacy kernel 398 * provided on-stack trampoline. Conversely, if we are using a 399 * non-0 ABI version, we must have a trampoline. Only validate the 400 * vers if a new sigaction was supplied and there was an actual 401 * handler specified (not SIG_IGN or SIG_DFL), which don't require 402 * a trampoline. Emulations use legacy kernel trampolines with 403 * version 0, alternatively check for that too. 404 * 405 * If version < 2, we try to autoload the compat module. Note 406 * that we interlock with the unload check in compat_modcmd() 407 * using kernconfig_lock. If the autoload fails, we don't try it 408 * 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 < 2)) { 413 if (p->p_flag & PK_32) 414 v0v1valid = true; 415 else if ((p->p_lflag & PL_SIGCOMPAT) == 0) { 416 kernconfig_lock(); 417 (void)module_autoload("compat_16", 418 MODULE_CLASS_ANY); 419 if (sendsig_sigcontext_16_hook.hooked) { 420 /* 421 * We need to remember if the 422 * sigcontext method may be useable, 423 * because libc may use it even 424 * if siginfo is available. 425 */ 426 v0v1valid = true; 427 } 428 mutex_enter(&proc_lock); 429 /* 430 * Prevent unload of compat module while 431 * this process remains. 432 */ 433 p->p_lflag |= PL_SIGCOMPAT; 434 mutex_exit(&proc_lock); 435 kernconfig_unlock(); 436 } 437 } 438 439 switch (vers) { 440 case 0: 441 /* sigcontext, kernel supplied trampoline. */ 442 if (tramp != NULL || !v0v1valid) { 443 return EINVAL; 444 } 445 break; 446 case 1: 447 /* sigcontext, user supplied trampoline. */ 448 if (tramp == NULL || !v0v1valid) { 449 return EINVAL; 450 } 451 break; 452 case 2: 453 case 3: 454 /* siginfo, user supplied trampoline. */ 455 if (tramp == NULL) { 456 return EINVAL; 457 } 458 break; 459 default: 460 return EINVAL; 461 } 462 } 463 464 mutex_enter(p->p_lock); 465 466 ps = p->p_sigacts; 467 if (osa) 468 sigaction_copy(osa, &SIGACTION_PS(ps, signum)); 469 if (!nsa) 470 goto out; 471 472 prop = sigprop[signum]; 473 if ((nsa->sa_flags & ~SA_ALLBITS) || (prop & SA_CANTMASK)) { 474 error = EINVAL; 475 goto out; 476 } 477 478 sigaction_copy(&SIGACTION_PS(ps, signum), nsa); 479 ps->sa_sigdesc[signum].sd_tramp = tramp; 480 ps->sa_sigdesc[signum].sd_vers = vers; 481 sigminusset(&sigcantmask, &SIGACTION_PS(ps, signum).sa_mask); 482 483 if ((prop & SA_NORESET) != 0) 484 SIGACTION_PS(ps, signum).sa_flags &= ~SA_RESETHAND; 485 486 if (signum == SIGCHLD) { 487 if (nsa->sa_flags & SA_NOCLDSTOP) 488 p->p_sflag |= PS_NOCLDSTOP; 489 else 490 p->p_sflag &= ~PS_NOCLDSTOP; 491 if (nsa->sa_flags & SA_NOCLDWAIT) { 492 /* 493 * Paranoia: since SA_NOCLDWAIT is implemented by 494 * reparenting the dying child to PID 1 (and trust 495 * it to reap the zombie), PID 1 itself is forbidden 496 * to set SA_NOCLDWAIT. 497 */ 498 if (p->p_pid == 1) 499 p->p_flag &= ~PK_NOCLDWAIT; 500 else 501 p->p_flag |= PK_NOCLDWAIT; 502 } else 503 p->p_flag &= ~PK_NOCLDWAIT; 504 505 if (nsa->sa_handler == SIG_IGN) { 506 /* 507 * Paranoia: same as above. 508 */ 509 if (p->p_pid == 1) 510 p->p_flag &= ~PK_CLDSIGIGN; 511 else 512 p->p_flag |= PK_CLDSIGIGN; 513 } else 514 p->p_flag &= ~PK_CLDSIGIGN; 515 } 516 517 if ((nsa->sa_flags & SA_NODEFER) == 0) 518 sigaddset(&SIGACTION_PS(ps, signum).sa_mask, signum); 519 else 520 sigdelset(&SIGACTION_PS(ps, signum).sa_mask, signum); 521 522 /* 523 * Set bit in p_sigctx.ps_sigignore for signals that are set to 524 * SIG_IGN, and for signals set to SIG_DFL where the default is to 525 * ignore. However, don't put SIGCONT in p_sigctx.ps_sigignore, as 526 * we have to restart the process. 527 */ 528 if (nsa->sa_handler == SIG_IGN || 529 (nsa->sa_handler == SIG_DFL && (prop & SA_IGNORE) != 0)) { 530 /* Never to be seen again. */ 531 sigemptyset(&tset); 532 sigaddset(&tset, signum); 533 sigclearall(p, &tset, &kq); 534 if (signum != SIGCONT) { 535 /* Easier in psignal */ 536 sigaddset(&p->p_sigctx.ps_sigignore, signum); 537 } 538 sigdelset(&p->p_sigctx.ps_sigcatch, signum); 539 } else { 540 sigdelset(&p->p_sigctx.ps_sigignore, signum); 541 if (nsa->sa_handler == SIG_DFL) 542 sigdelset(&p->p_sigctx.ps_sigcatch, signum); 543 else 544 sigaddset(&p->p_sigctx.ps_sigcatch, signum); 545 } 546 547 /* 548 * Previously held signals may now have become visible. Ensure that 549 * we check for them before returning to userspace. 550 */ 551 if (sigispending(l, 0)) { 552 lwp_lock(l); 553 l->l_flag |= LW_PENDSIG; 554 lwp_unlock(l); 555 } 556 out: 557 mutex_exit(p->p_lock); 558 ksiginfo_queue_drain(&kq); 559 560 return error; 561 } 562 563 int 564 sigprocmask1(struct lwp *l, int how, const sigset_t *nss, sigset_t *oss) 565 { 566 sigset_t *mask = &l->l_sigmask; 567 bool more; 568 569 KASSERT(mutex_owned(l->l_proc->p_lock)); 570 571 if (oss) { 572 *oss = *mask; 573 } 574 575 if (nss == NULL) { 576 return 0; 577 } 578 579 switch (how) { 580 case SIG_BLOCK: 581 sigplusset(nss, mask); 582 more = false; 583 break; 584 case SIG_UNBLOCK: 585 sigminusset(nss, mask); 586 more = true; 587 break; 588 case SIG_SETMASK: 589 *mask = *nss; 590 more = true; 591 break; 592 default: 593 return EINVAL; 594 } 595 sigminusset(&sigcantmask, mask); 596 if (more && sigispending(l, 0)) { 597 /* 598 * Check for pending signals on return to user. 599 */ 600 lwp_lock(l); 601 l->l_flag |= LW_PENDSIG; 602 lwp_unlock(l); 603 } 604 return 0; 605 } 606 607 void 608 sigpending1(struct lwp *l, sigset_t *ss) 609 { 610 struct proc *p = l->l_proc; 611 612 mutex_enter(p->p_lock); 613 *ss = l->l_sigpend.sp_set; 614 sigplusset(&p->p_sigpend.sp_set, ss); 615 mutex_exit(p->p_lock); 616 } 617 618 void 619 sigsuspendsetup(struct lwp *l, const sigset_t *ss) 620 { 621 struct proc *p = l->l_proc; 622 623 /* 624 * When returning from sigsuspend/pselect/pollts, we want 625 * the old mask to be restored after the 626 * signal handler has finished. Thus, we 627 * save it here and mark the sigctx structure 628 * to indicate this. 629 */ 630 mutex_enter(p->p_lock); 631 l->l_sigrestore = 1; 632 l->l_sigoldmask = l->l_sigmask; 633 l->l_sigmask = *ss; 634 sigminusset(&sigcantmask, &l->l_sigmask); 635 636 /* Check for pending signals when sleeping. */ 637 if (sigispending(l, 0)) { 638 lwp_lock(l); 639 l->l_flag |= LW_PENDSIG; 640 lwp_unlock(l); 641 } 642 mutex_exit(p->p_lock); 643 } 644 645 void 646 sigsuspendteardown(struct lwp *l) 647 { 648 struct proc *p = l->l_proc; 649 650 mutex_enter(p->p_lock); 651 /* Check for pending signals when sleeping. */ 652 if (l->l_sigrestore) { 653 if (sigispending(l, 0)) { 654 lwp_lock(l); 655 l->l_flag |= LW_PENDSIG; 656 lwp_unlock(l); 657 } else { 658 l->l_sigrestore = 0; 659 l->l_sigmask = l->l_sigoldmask; 660 } 661 } 662 mutex_exit(p->p_lock); 663 } 664 665 int 666 sigsuspend1(struct lwp *l, const sigset_t *ss) 667 { 668 669 if (ss) 670 sigsuspendsetup(l, ss); 671 672 while (kpause("pause", true, 0, NULL) == 0) 673 ; 674 675 /* always return EINTR rather than ERESTART... */ 676 return EINTR; 677 } 678 679 int 680 sigaltstack1(struct lwp *l, const struct sigaltstack *nss, 681 struct sigaltstack *oss) 682 { 683 struct proc *p = l->l_proc; 684 int error = 0; 685 686 mutex_enter(p->p_lock); 687 688 if (oss) 689 *oss = l->l_sigstk; 690 691 if (nss) { 692 if (nss->ss_flags & ~SS_ALLBITS) 693 error = EINVAL; 694 else if (nss->ss_flags & SS_DISABLE) { 695 if (l->l_sigstk.ss_flags & SS_ONSTACK) 696 error = EINVAL; 697 } else if (nss->ss_size < MINSIGSTKSZ) 698 error = ENOMEM; 699 700 if (!error) 701 l->l_sigstk = *nss; 702 } 703 704 mutex_exit(p->p_lock); 705 706 return error; 707 } 708 709 int 710 sigtimedwait1(struct lwp *l, const struct sys_____sigtimedwait50_args *uap, 711 register_t *retval, copyin_t fetchss, copyout_t storeinf, copyin_t fetchts, 712 copyout_t storets) 713 { 714 /* { 715 syscallarg(const sigset_t *) set; 716 syscallarg(siginfo_t *) info; 717 syscallarg(struct timespec *) timeout; 718 } */ 719 struct proc *p = l->l_proc; 720 int error, signum, timo; 721 struct timespec ts, tsstart, tsnow; 722 ksiginfo_t ksi; 723 724 /* 725 * Calculate timeout, if it was specified. 726 * 727 * NULL pointer means an infinite timeout. 728 * {.tv_sec = 0, .tv_nsec = 0} means do not block. 729 */ 730 if (SCARG(uap, timeout)) { 731 error = (*fetchts)(SCARG(uap, timeout), &ts, sizeof(ts)); 732 if (error) 733 return error; 734 735 if ((error = itimespecfix(&ts)) != 0) 736 return error; 737 738 timo = tstohz(&ts); 739 if (timo == 0) { 740 if (ts.tv_sec == 0 && ts.tv_nsec == 0) 741 timo = -1; /* do not block */ 742 else 743 timo = 1; /* the shortest possible timeout */ 744 } 745 746 /* 747 * Remember current uptime, it would be used in 748 * ECANCELED/ERESTART case. 749 */ 750 getnanouptime(&tsstart); 751 } else { 752 memset(&tsstart, 0, sizeof(tsstart)); /* XXXgcc */ 753 timo = 0; /* infinite timeout */ 754 } 755 756 error = (*fetchss)(SCARG(uap, set), &l->l_sigwaitset, 757 sizeof(l->l_sigwaitset)); 758 if (error) 759 return error; 760 761 /* 762 * Silently ignore SA_CANTMASK signals. psignal1() would ignore 763 * SA_CANTMASK signals in waitset, we do this only for the below 764 * siglist check. 765 */ 766 sigminusset(&sigcantmask, &l->l_sigwaitset); 767 768 memset(&ksi.ksi_info, 0, sizeof(ksi.ksi_info)); 769 770 mutex_enter(p->p_lock); 771 772 /* Check for pending signals in the process, if no - then in LWP. */ 773 if ((signum = sigget(&p->p_sigpend, &ksi, 0, &l->l_sigwaitset)) == 0) 774 signum = sigget(&l->l_sigpend, &ksi, 0, &l->l_sigwaitset); 775 776 if (signum != 0) { 777 /* If found a pending signal, just copy it out to the user. */ 778 mutex_exit(p->p_lock); 779 goto out; 780 } 781 782 if (timo < 0) { 783 /* If not allowed to block, return an error */ 784 mutex_exit(p->p_lock); 785 return EAGAIN; 786 } 787 788 /* 789 * Set up the sigwait list and wait for signal to arrive. 790 * We can either be woken up or time out. 791 */ 792 l->l_sigwaited = &ksi; 793 LIST_INSERT_HEAD(&p->p_sigwaiters, l, l_sigwaiter); 794 error = cv_timedwait_sig(&l->l_sigcv, p->p_lock, timo); 795 796 /* 797 * Need to find out if we woke as a result of _lwp_wakeup() or a 798 * signal outside our wait set. 799 */ 800 if (l->l_sigwaited != NULL) { 801 if (error == EINTR) { 802 /* Wakeup via _lwp_wakeup(). */ 803 error = ECANCELED; 804 } else if (!error) { 805 /* Spurious wakeup - arrange for syscall restart. */ 806 error = ERESTART; 807 } 808 l->l_sigwaited = NULL; 809 LIST_REMOVE(l, l_sigwaiter); 810 } 811 mutex_exit(p->p_lock); 812 813 /* 814 * If the sleep was interrupted (either by signal or wakeup), update 815 * the timeout and copyout new value back. It would be used when 816 * the syscall would be restarted or called again. 817 */ 818 if (timo && (error == ERESTART || error == ECANCELED)) { 819 getnanouptime(&tsnow); 820 821 /* Compute how much time has passed since start. */ 822 timespecsub(&tsnow, &tsstart, &tsnow); 823 824 /* Substract passed time from timeout. */ 825 timespecsub(&ts, &tsnow, &ts); 826 827 if (ts.tv_sec < 0) 828 error = EAGAIN; 829 else { 830 /* Copy updated timeout to userland. */ 831 error = (*storets)(&ts, SCARG(uap, timeout), 832 sizeof(ts)); 833 } 834 } 835 out: 836 /* 837 * If a signal from the wait set arrived, copy it to userland. 838 * Copy only the used part of siginfo, the padding part is 839 * left unchanged (userland is not supposed to touch it anyway). 840 */ 841 if (error == 0 && SCARG(uap, info)) { 842 error = (*storeinf)(&ksi.ksi_info, SCARG(uap, info), 843 sizeof(ksi.ksi_info)); 844 } 845 if (error == 0) { 846 *retval = ksi.ksi_info._signo; 847 SDT_PROBE(proc, kernel, , signal__clear, *retval, 848 &ksi, 0, 0, 0); 849 } 850 return error; 851 } 852