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