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