1 /* $NetBSD: sys_sig.c,v 1.58 2024/07/14 05:10:40 kre 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.58 2024/07/14 05:10:40 kre 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 if (pid <= INT_MIN) 276 return ESRCH; 277 return killpg1(l, ksi, -pid, 0); 278 } 279 /* NOTREACHED */ 280 } 281 282 int 283 sys_sigqueueinfo(struct lwp *l, const struct sys_sigqueueinfo_args *uap, 284 register_t *retval) 285 { 286 /* { 287 syscallarg(pid_t int) pid; 288 syscallarg(const siginfo_t *) info; 289 } */ 290 ksiginfo_t ksi; 291 int error; 292 293 KSI_INIT(&ksi); 294 295 if ((error = copyin(&SCARG(uap, info)->_info, &ksi.ksi_info, 296 sizeof(ksi.ksi_info))) != 0) 297 return error; 298 299 return kill1(l, SCARG(uap, pid), &ksi, retval); 300 } 301 302 int 303 sys_kill(struct lwp *l, const struct sys_kill_args *uap, register_t *retval) 304 { 305 /* { 306 syscallarg(pid_t) pid; 307 syscallarg(int) signum; 308 } */ 309 ksiginfo_t ksi; 310 311 KSI_INIT(&ksi); 312 313 ksi.ksi_signo = SCARG(uap, signum); 314 ksi.ksi_code = SI_USER; 315 ksi.ksi_pid = l->l_proc->p_pid; 316 ksi.ksi_uid = kauth_cred_geteuid(l->l_cred); 317 318 return kill1(l, SCARG(uap, pid), &ksi, retval); 319 } 320 321 int 322 sys_getcontext(struct lwp *l, const struct sys_getcontext_args *uap, 323 register_t *retval) 324 { 325 /* { 326 syscallarg(struct __ucontext *) ucp; 327 } */ 328 struct proc *p = l->l_proc; 329 ucontext_t uc; 330 331 memset(&uc, 0, sizeof(uc)); 332 333 mutex_enter(p->p_lock); 334 getucontext(l, &uc); 335 mutex_exit(p->p_lock); 336 337 return copyout(&uc, SCARG(uap, ucp), sizeof (*SCARG(uap, ucp))); 338 } 339 340 int 341 sys_setcontext(struct lwp *l, const struct sys_setcontext_args *uap, 342 register_t *retval) 343 { 344 /* { 345 syscallarg(const ucontext_t *) ucp; 346 } */ 347 struct proc *p = l->l_proc; 348 ucontext_t uc; 349 int error; 350 351 error = copyin(SCARG(uap, ucp), &uc, sizeof (uc)); 352 if (error) 353 return error; 354 if ((uc.uc_flags & _UC_CPU) == 0) 355 return EINVAL; 356 mutex_enter(p->p_lock); 357 error = setucontext(l, &uc); 358 mutex_exit(p->p_lock); 359 if (error) 360 return error; 361 362 return EJUSTRETURN; 363 } 364 365 /* 366 * sigtimedwait(2) system call, used also for implementation 367 * of sigwaitinfo() and sigwait(). 368 * 369 * This only handles single LWP in signal wait. libpthread provides 370 * its own sigtimedwait() wrapper to DTRT WRT individual threads. 371 */ 372 int 373 sys_____sigtimedwait50(struct lwp *l, 374 const struct sys_____sigtimedwait50_args *uap, register_t *retval) 375 { 376 377 return sigtimedwait1(l, uap, retval, copyin, copyout, copyin, copyout); 378 } 379 380 int 381 sigaction1(struct lwp *l, int signum, const struct sigaction *nsa, 382 struct sigaction *osa, const void *tramp, int vers) 383 { 384 struct proc *p; 385 struct sigacts *ps; 386 sigset_t tset; 387 int prop, error; 388 ksiginfoq_t kq; 389 static bool v0v1valid; 390 391 if (signum <= 0 || signum >= NSIG) 392 return EINVAL; 393 394 p = l->l_proc; 395 error = 0; 396 ksiginfo_queue_init(&kq); 397 398 /* 399 * Trampoline ABI version __SIGTRAMP_SIGCODE_VERSION (0) is reserved 400 * for the legacy kernel provided on-stack trampoline. Conversely, 401 * if we are using a non-0 ABI version, we must have a trampoline. 402 * Only validate the vers if a new sigaction was supplied and there 403 * was an actual handler specified (not SIG_IGN or SIG_DFL), which 404 * don't require a trampoline. Emulations use legacy kernel 405 * trampolines with version 0, alternatively check for that too. 406 * 407 * If version < __SIGTRAMP_SIGINFO_VERSION_MIN (usually 2), we try 408 * to autoload the compat module. Note that we interlock with the 409 * unload check in compat_modcmd() using kernconfig_lock. If the 410 * autoload fails, we don't try it again for this process. 411 */ 412 if (nsa != NULL && nsa->sa_handler != SIG_IGN 413 && nsa->sa_handler != SIG_DFL) { 414 if (__predict_false(vers < __SIGTRAMP_SIGINFO_VERSION_MIN)) { 415 if (vers == __SIGTRAMP_SIGCODE_VERSION && 416 p->p_sigctx.ps_sigcode != NULL) { 417 /* 418 * if sigcode is used for this emulation, 419 * version 0 is allowed. 420 */ 421 } 422 #ifdef __HAVE_STRUCT_SIGCONTEXT 423 else if (p->p_flag & PK_32) { 424 /* 425 * The 32-bit compat module will have 426 * pre-validated this for us. 427 */ 428 v0v1valid = true; 429 } else if ((p->p_lflag & PL_SIGCOMPAT) == 0) { 430 kernconfig_lock(); 431 (void)module_autoload("compat_16", 432 MODULE_CLASS_ANY); 433 if (sendsig_sigcontext_16_hook.hooked) { 434 /* 435 * We need to remember if the 436 * sigcontext method may be useable, 437 * because libc may use it even 438 * if siginfo is available. 439 */ 440 v0v1valid = true; 441 } 442 mutex_enter(&proc_lock); 443 /* 444 * Prevent unload of compat module while 445 * this process remains. 446 */ 447 p->p_lflag |= PL_SIGCOMPAT; 448 mutex_exit(&proc_lock); 449 kernconfig_unlock(); 450 } 451 #endif /* __HAVE_STRUCT_SIGCONTEXT */ 452 } 453 454 switch (vers) { 455 case __SIGTRAMP_SIGCODE_VERSION: 456 /* kernel supplied trampoline. */ 457 if (tramp != NULL || 458 (p->p_sigctx.ps_sigcode == NULL && !v0v1valid)) { 459 return EINVAL; 460 } 461 break; 462 #ifdef __HAVE_STRUCT_SIGCONTEXT 463 case __SIGTRAMP_SIGCONTEXT_VERSION_MIN ... 464 __SIGTRAMP_SIGCONTEXT_VERSION_MAX: 465 /* sigcontext, user supplied trampoline. */ 466 if (tramp == NULL || !v0v1valid) { 467 return EINVAL; 468 } 469 break; 470 #endif /* __HAVE_STRUCT_SIGCONTEXT */ 471 case __SIGTRAMP_SIGINFO_VERSION_MIN ... 472 __SIGTRAMP_SIGINFO_VERSION_MAX: 473 /* siginfo, user supplied trampoline. */ 474 if (tramp == NULL) { 475 return EINVAL; 476 } 477 break; 478 default: 479 /* Invalid trampoline version. */ 480 return EINVAL; 481 } 482 } 483 484 mutex_enter(p->p_lock); 485 486 ps = p->p_sigacts; 487 if (osa) 488 sigaction_copy(osa, &SIGACTION_PS(ps, signum)); 489 if (!nsa) 490 goto out; 491 492 prop = sigprop[signum]; 493 if ((nsa->sa_flags & ~SA_ALLBITS) || (prop & SA_CANTMASK)) { 494 error = EINVAL; 495 goto out; 496 } 497 498 sigaction_copy(&SIGACTION_PS(ps, signum), nsa); 499 ps->sa_sigdesc[signum].sd_tramp = tramp; 500 ps->sa_sigdesc[signum].sd_vers = vers; 501 sigminusset(&sigcantmask, &SIGACTION_PS(ps, signum).sa_mask); 502 503 if ((prop & SA_NORESET) != 0) 504 SIGACTION_PS(ps, signum).sa_flags &= ~SA_RESETHAND; 505 506 if (signum == SIGCHLD) { 507 if (nsa->sa_flags & SA_NOCLDSTOP) 508 p->p_sflag |= PS_NOCLDSTOP; 509 else 510 p->p_sflag &= ~PS_NOCLDSTOP; 511 if (nsa->sa_flags & SA_NOCLDWAIT) { 512 /* 513 * Paranoia: since SA_NOCLDWAIT is implemented by 514 * reparenting the dying child to PID 1 (and trust 515 * it to reap the zombie), PID 1 itself is forbidden 516 * to set SA_NOCLDWAIT. 517 */ 518 if (p->p_pid == 1) 519 p->p_flag &= ~PK_NOCLDWAIT; 520 else 521 p->p_flag |= PK_NOCLDWAIT; 522 } else 523 p->p_flag &= ~PK_NOCLDWAIT; 524 525 if (nsa->sa_handler == SIG_IGN) { 526 /* 527 * Paranoia: same as above. 528 */ 529 if (p->p_pid == 1) 530 p->p_flag &= ~PK_CLDSIGIGN; 531 else 532 p->p_flag |= PK_CLDSIGIGN; 533 } else 534 p->p_flag &= ~PK_CLDSIGIGN; 535 } 536 537 if ((nsa->sa_flags & SA_NODEFER) == 0) 538 sigaddset(&SIGACTION_PS(ps, signum).sa_mask, signum); 539 else 540 sigdelset(&SIGACTION_PS(ps, signum).sa_mask, signum); 541 542 /* 543 * Set bit in p_sigctx.ps_sigignore for signals that are set to 544 * SIG_IGN, and for signals set to SIG_DFL where the default is to 545 * ignore. However, don't put SIGCONT in p_sigctx.ps_sigignore, as 546 * we have to restart the process. 547 */ 548 if (nsa->sa_handler == SIG_IGN || 549 (nsa->sa_handler == SIG_DFL && (prop & SA_IGNORE) != 0)) { 550 /* Never to be seen again. */ 551 sigemptyset(&tset); 552 sigaddset(&tset, signum); 553 sigclearall(p, &tset, &kq); 554 if (signum != SIGCONT) { 555 /* Easier in psignal */ 556 sigaddset(&p->p_sigctx.ps_sigignore, signum); 557 } 558 sigdelset(&p->p_sigctx.ps_sigcatch, signum); 559 } else { 560 sigdelset(&p->p_sigctx.ps_sigignore, signum); 561 if (nsa->sa_handler == SIG_DFL) 562 sigdelset(&p->p_sigctx.ps_sigcatch, signum); 563 else 564 sigaddset(&p->p_sigctx.ps_sigcatch, signum); 565 } 566 567 /* 568 * Previously held signals may now have become visible. Ensure that 569 * we check for them before returning to userspace. 570 */ 571 if (sigispending(l, 0)) { 572 lwp_lock(l); 573 l->l_flag |= LW_PENDSIG; 574 lwp_need_userret(l); 575 lwp_unlock(l); 576 } 577 out: 578 mutex_exit(p->p_lock); 579 ksiginfo_queue_drain(&kq); 580 581 return error; 582 } 583 584 int 585 sigprocmask1(struct lwp *l, int how, const sigset_t *nss, sigset_t *oss) 586 { 587 sigset_t *mask = &l->l_sigmask; 588 bool more; 589 590 KASSERT(mutex_owned(l->l_proc->p_lock)); 591 592 if (oss) { 593 *oss = *mask; 594 } 595 596 if (nss == NULL) { 597 return 0; 598 } 599 600 switch (how) { 601 case SIG_BLOCK: 602 sigplusset(nss, mask); 603 more = false; 604 break; 605 case SIG_UNBLOCK: 606 sigminusset(nss, mask); 607 more = true; 608 break; 609 case SIG_SETMASK: 610 *mask = *nss; 611 more = true; 612 break; 613 default: 614 return EINVAL; 615 } 616 sigminusset(&sigcantmask, mask); 617 if (more && sigispending(l, 0)) { 618 /* 619 * Check for pending signals on return to user. 620 */ 621 lwp_lock(l); 622 l->l_flag |= LW_PENDSIG; 623 lwp_need_userret(l); 624 lwp_unlock(l); 625 } 626 return 0; 627 } 628 629 void 630 sigpending1(struct lwp *l, sigset_t *ss) 631 { 632 struct proc *p = l->l_proc; 633 634 mutex_enter(p->p_lock); 635 *ss = l->l_sigpend.sp_set; 636 sigplusset(&p->p_sigpend.sp_set, ss); 637 mutex_exit(p->p_lock); 638 } 639 640 void 641 sigsuspendsetup(struct lwp *l, const sigset_t *ss) 642 { 643 struct proc *p = l->l_proc; 644 645 /* 646 * When returning from sigsuspend/pselect/pollts, we want 647 * the old mask to be restored after the 648 * signal handler has finished. Thus, we 649 * save it here and mark the sigctx structure 650 * to indicate this. 651 */ 652 mutex_enter(p->p_lock); 653 l->l_sigrestore = 1; 654 l->l_sigoldmask = l->l_sigmask; 655 l->l_sigmask = *ss; 656 sigminusset(&sigcantmask, &l->l_sigmask); 657 658 /* Check for pending signals when sleeping. */ 659 if (sigispending(l, 0)) { 660 lwp_lock(l); 661 l->l_flag |= LW_PENDSIG; 662 lwp_need_userret(l); 663 lwp_unlock(l); 664 } 665 mutex_exit(p->p_lock); 666 } 667 668 void 669 sigsuspendteardown(struct lwp *l) 670 { 671 struct proc *p = l->l_proc; 672 673 mutex_enter(p->p_lock); 674 /* Check for pending signals when sleeping. */ 675 if (l->l_sigrestore) { 676 if (sigispending(l, 0)) { 677 lwp_lock(l); 678 l->l_flag |= LW_PENDSIG; 679 lwp_need_userret(l); 680 lwp_unlock(l); 681 } else { 682 l->l_sigrestore = 0; 683 l->l_sigmask = l->l_sigoldmask; 684 } 685 } 686 mutex_exit(p->p_lock); 687 } 688 689 int 690 sigsuspend1(struct lwp *l, const sigset_t *ss) 691 { 692 693 if (ss) 694 sigsuspendsetup(l, ss); 695 696 while (kpause("pause", true, 0, NULL) == 0) 697 ; 698 699 /* always return EINTR rather than ERESTART... */ 700 return EINTR; 701 } 702 703 int 704 sigaltstack1(struct lwp *l, const stack_t *nss, stack_t *oss) 705 { 706 struct proc *p = l->l_proc; 707 int error = 0; 708 709 mutex_enter(p->p_lock); 710 711 if (oss) 712 *oss = l->l_sigstk; 713 714 if (nss) { 715 if (nss->ss_flags & ~SS_ALLBITS) 716 error = EINVAL; 717 else if (nss->ss_flags & SS_DISABLE) { 718 if (l->l_sigstk.ss_flags & SS_ONSTACK) 719 error = EINVAL; 720 } else if (nss->ss_size < MINSIGSTKSZ) 721 error = ENOMEM; 722 723 if (!error) 724 l->l_sigstk = *nss; 725 } 726 727 mutex_exit(p->p_lock); 728 729 return error; 730 } 731 732 int 733 sigtimedwait1(struct lwp *l, const struct sys_____sigtimedwait50_args *uap, 734 register_t *retval, copyin_t fetchss, copyout_t storeinf, copyin_t fetchts, 735 copyout_t storets) 736 { 737 /* { 738 syscallarg(const sigset_t *) set; 739 syscallarg(siginfo_t *) info; 740 syscallarg(struct timespec *) timeout; 741 } */ 742 struct proc *p = l->l_proc; 743 int error, signum, timo; 744 struct timespec ts, tsstart, tsnow; 745 ksiginfo_t ksi; 746 747 /* 748 * Calculate timeout, if it was specified. 749 * 750 * NULL pointer means an infinite timeout. 751 * {.tv_sec = 0, .tv_nsec = 0} means do not block. 752 */ 753 if (SCARG(uap, timeout)) { 754 error = (*fetchts)(SCARG(uap, timeout), &ts, sizeof(ts)); 755 if (error) 756 return error; 757 758 if ((error = itimespecfix(&ts)) != 0) 759 return error; 760 761 timo = tstohz(&ts); 762 if (timo == 0) { 763 if (ts.tv_sec == 0 && ts.tv_nsec == 0) 764 timo = -1; /* do not block */ 765 else 766 timo = 1; /* the shortest possible timeout */ 767 } 768 769 /* 770 * Remember current uptime, it would be used in 771 * ECANCELED/ERESTART case. 772 */ 773 getnanouptime(&tsstart); 774 } else { 775 memset(&tsstart, 0, sizeof(tsstart)); /* XXXgcc */ 776 timo = 0; /* infinite timeout */ 777 } 778 779 error = (*fetchss)(SCARG(uap, set), &l->l_sigwaitset, 780 sizeof(l->l_sigwaitset)); 781 if (error) 782 return error; 783 784 /* 785 * Silently ignore SA_CANTMASK signals. psignal1() would ignore 786 * SA_CANTMASK signals in waitset, we do this only for the below 787 * siglist check. 788 */ 789 sigminusset(&sigcantmask, &l->l_sigwaitset); 790 791 memset(&ksi.ksi_info, 0, sizeof(ksi.ksi_info)); 792 793 mutex_enter(p->p_lock); 794 795 /* Check for pending signals in the process, if no - then in LWP. */ 796 if ((signum = sigget(&p->p_sigpend, &ksi, 0, &l->l_sigwaitset)) == 0) 797 signum = sigget(&l->l_sigpend, &ksi, 0, &l->l_sigwaitset); 798 799 if (signum != 0) { 800 /* If found a pending signal, just copy it out to the user. */ 801 mutex_exit(p->p_lock); 802 goto out; 803 } 804 805 if (timo < 0) { 806 /* If not allowed to block, return an error */ 807 mutex_exit(p->p_lock); 808 return EAGAIN; 809 } 810 811 /* 812 * Set up the sigwait list and wait for signal to arrive. 813 * We can either be woken up or time out. 814 */ 815 l->l_sigwaited = &ksi; 816 LIST_INSERT_HEAD(&p->p_sigwaiters, l, l_sigwaiter); 817 error = cv_timedwait_sig(&l->l_sigcv, p->p_lock, timo); 818 819 /* 820 * Need to find out if we woke as a result of _lwp_wakeup() or a 821 * signal outside our wait set. 822 */ 823 if (l->l_sigwaited != NULL) { 824 if (error == EINTR) { 825 /* Wakeup via _lwp_wakeup(). */ 826 error = ECANCELED; 827 } else if (!error) { 828 /* Spurious wakeup - arrange for syscall restart. */ 829 error = ERESTART; 830 } 831 l->l_sigwaited = NULL; 832 LIST_REMOVE(l, l_sigwaiter); 833 } 834 mutex_exit(p->p_lock); 835 836 /* 837 * If the sleep was interrupted (either by signal or wakeup), update 838 * the timeout and copyout new value back. It would be used when 839 * the syscall would be restarted or called again. 840 */ 841 if (timo && (error == ERESTART || error == ECANCELED)) { 842 getnanouptime(&tsnow); 843 844 /* Compute how much time has passed since start. */ 845 timespecsub(&tsnow, &tsstart, &tsnow); 846 847 /* Subtract passed time from timeout. */ 848 timespecsub(&ts, &tsnow, &ts); 849 850 if (ts.tv_sec < 0) 851 error = EAGAIN; 852 else { 853 /* Copy updated timeout to userland. */ 854 error = (*storets)(&ts, SCARG(uap, timeout), 855 sizeof(ts)); 856 } 857 } 858 out: 859 /* 860 * If a signal from the wait set arrived, copy it to userland. 861 * Copy only the used part of siginfo, the padding part is 862 * left unchanged (userland is not supposed to touch it anyway). 863 */ 864 if (error == 0 && SCARG(uap, info)) { 865 error = (*storeinf)(&ksi.ksi_info, SCARG(uap, info), 866 sizeof(ksi.ksi_info)); 867 } 868 if (error == 0) { 869 *retval = ksi.ksi_info._signo; 870 SDT_PROBE(proc, kernel, , signal__clear, *retval, 871 &ksi, 0, 0, 0); 872 } 873 return error; 874 } 875
Indexes created Sun Sep 21 14:09:52 GMT 2025