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