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