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