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