FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_sig.c
1 /* $NetBSD: kern_sig.c,v 1.189.2.7 2005/12/29 01:29:55 riz Exp $ */
2
3 /*
4 * Copyright (c) 1982, 1986, 1989, 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * @(#)kern_sig.c 8.14 (Berkeley) 5/14/95
37 */
38
39 #include <sys/cdefs.h>
40 __KERNEL_RCSID(0, "$NetBSD: kern_sig.c,v 1.189.2.7 2005/12/29 01:29:55 riz Exp $");
41
42 #include "opt_ktrace.h"
43 #include "opt_compat_sunos.h"
44 #include "opt_compat_netbsd.h"
45 #include "opt_compat_netbsd32.h"
46
47 #define SIGPROP /* include signal properties table */
48 #include <sys/param.h>
49 #include <sys/signalvar.h>
50 #include <sys/resourcevar.h>
51 #include <sys/namei.h>
52 #include <sys/vnode.h>
53 #include <sys/proc.h>
54 #include <sys/systm.h>
55 #include <sys/timeb.h>
56 #include <sys/times.h>
57 #include <sys/buf.h>
58 #include <sys/acct.h>
59 #include <sys/file.h>
60 #include <sys/kernel.h>
61 #include <sys/wait.h>
62 #include <sys/ktrace.h>
63 #include <sys/syslog.h>
64 #include <sys/stat.h>
65 #include <sys/core.h>
66 #include <sys/filedesc.h>
67 #include <sys/malloc.h>
68 #include <sys/pool.h>
69 #include <sys/ucontext.h>
70 #include <sys/sa.h>
71 #include <sys/savar.h>
72 #include <sys/exec.h>
73
74 #include <sys/mount.h>
75 #include <sys/syscallargs.h>
76
77 #include <machine/cpu.h>
78
79 #include <sys/user.h> /* for coredump */
80
81 #include <uvm/uvm.h>
82 #include <uvm/uvm_extern.h>
83
84 static void child_psignal(struct proc *, int);
85 static int build_corename(struct proc *, char [MAXPATHLEN]);
86 static void ksiginfo_exithook(struct proc *, void *);
87 static void ksiginfo_put(struct proc *, const ksiginfo_t *);
88 static ksiginfo_t *ksiginfo_get(struct proc *, int);
89 static void kpsignal2(struct proc *, const ksiginfo_t *, int);
90
91 sigset_t contsigmask, stopsigmask, sigcantmask;
92
93 struct pool sigacts_pool; /* memory pool for sigacts structures */
94
95 /*
96 * struct sigacts memory pool allocator.
97 */
98
99 static void *
100 sigacts_poolpage_alloc(struct pool *pp, int flags)
101 {
102
103 return (void *)uvm_km_kmemalloc1(kernel_map,
104 uvm.kernel_object, (PAGE_SIZE)*2, (PAGE_SIZE)*2, UVM_UNKNOWN_OFFSET,
105 (flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK);
106 }
107
108 static void
109 sigacts_poolpage_free(struct pool *pp, void *v)
110 {
111 uvm_km_free(kernel_map, (vaddr_t)v, (PAGE_SIZE)*2);
112 }
113
114 static struct pool_allocator sigactspool_allocator = {
115 sigacts_poolpage_alloc, sigacts_poolpage_free,
116 };
117
118 struct pool siginfo_pool; /* memory pool for siginfo structures */
119 struct pool ksiginfo_pool; /* memory pool for ksiginfo structures */
120
121 /*
122 * Can process p, with pcred pc, send the signal signum to process q?
123 */
124 #define CANSIGNAL(p, pc, q, signum) \
125 ((pc)->pc_ucred->cr_uid == 0 || \
126 (pc)->p_ruid == (q)->p_cred->p_ruid || \
127 (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \
128 (pc)->p_ruid == (q)->p_ucred->cr_uid || \
129 (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \
130 ((signum) == SIGCONT && (q)->p_session == (p)->p_session))
131
132 /*
133 * Remove and return the first ksiginfo element that matches our requested
134 * signal, or return NULL if one not found.
135 */
136 static ksiginfo_t *
137 ksiginfo_get(struct proc *p, int signo)
138 {
139 ksiginfo_t *ksi;
140 int s;
141
142 s = splsoftclock();
143 simple_lock(&p->p_sigctx.ps_silock);
144 CIRCLEQ_FOREACH(ksi, &p->p_sigctx.ps_siginfo, ksi_list) {
145 if (ksi->ksi_signo == signo) {
146 CIRCLEQ_REMOVE(&p->p_sigctx.ps_siginfo, ksi, ksi_list);
147 goto out;
148 }
149 }
150 ksi = NULL;
151 out:
152 simple_unlock(&p->p_sigctx.ps_silock);
153 splx(s);
154 return ksi;
155 }
156
157 /*
158 * Append a new ksiginfo element to the list of pending ksiginfo's, if
159 * we need to (SA_SIGINFO was requested). We replace non RT signals if
160 * they already existed in the queue and we add new entries for RT signals,
161 * or for non RT signals with non-existing entries.
162 */
163 static void
164 ksiginfo_put(struct proc *p, const ksiginfo_t *ksi)
165 {
166 ksiginfo_t *kp;
167 struct sigaction *sa = &SIGACTION_PS(p->p_sigacts, ksi->ksi_signo);
168 int s;
169
170 if ((sa->sa_flags & SA_SIGINFO) == 0)
171 return;
172 /*
173 * If there's no info, don't save it.
174 */
175 if (KSI_EMPTY_P(ksi))
176 return;
177
178 s = splsoftclock();
179 simple_lock(&p->p_sigctx.ps_silock);
180 #ifdef notyet /* XXX: QUEUING */
181 if (ksi->ksi_signo < SIGRTMIN)
182 #endif
183 {
184 CIRCLEQ_FOREACH(kp, &p->p_sigctx.ps_siginfo, ksi_list) {
185 if (kp->ksi_signo == ksi->ksi_signo) {
186 KSI_COPY(ksi, kp);
187 goto out;
188 }
189 }
190 }
191 kp = pool_get(&ksiginfo_pool, PR_NOWAIT);
192 if (kp == NULL) {
193 #ifdef DIAGNOSTIC
194 printf("Out of memory allocating siginfo for pid %d\n",
195 p->p_pid);
196 #endif
197 goto out;
198 }
199 *kp = *ksi;
200 CIRCLEQ_INSERT_TAIL(&p->p_sigctx.ps_siginfo, kp, ksi_list);
201 out:
202 simple_unlock(&p->p_sigctx.ps_silock);
203 splx(s);
204 }
205
206 /*
207 * free all pending ksiginfo on exit
208 */
209 static void
210 ksiginfo_exithook(struct proc *p, void *v)
211 {
212 int s;
213
214 s = splsoftclock();
215 simple_lock(&p->p_sigctx.ps_silock);
216 while (!CIRCLEQ_EMPTY(&p->p_sigctx.ps_siginfo)) {
217 ksiginfo_t *ksi = CIRCLEQ_FIRST(&p->p_sigctx.ps_siginfo);
218 CIRCLEQ_REMOVE(&p->p_sigctx.ps_siginfo, ksi, ksi_list);
219 pool_put(&ksiginfo_pool, ksi);
220 }
221 simple_unlock(&p->p_sigctx.ps_silock);
222 splx(s);
223 }
224
225 /*
226 * Initialize signal-related data structures.
227 */
228 void
229 signal_init(void)
230 {
231
232 sigactspool_allocator.pa_pagesz = (PAGE_SIZE)*2;
233
234 pool_init(&sigacts_pool, sizeof(struct sigacts), 0, 0, 0, "sigapl",
235 sizeof(struct sigacts) > PAGE_SIZE ?
236 &sigactspool_allocator : &pool_allocator_nointr);
237 pool_init(&siginfo_pool, sizeof(siginfo_t), 0, 0, 0, "siginfo",
238 &pool_allocator_nointr);
239 pool_init(&ksiginfo_pool, sizeof(ksiginfo_t), 0, 0, 0, "ksiginfo",
240 NULL);
241 exithook_establish(ksiginfo_exithook, NULL);
242 exechook_establish(ksiginfo_exithook, NULL);
243 }
244
245 /*
246 * Create an initial sigctx structure, using the same signal state
247 * as p. If 'share' is set, share the sigctx_proc part, otherwise just
248 * copy it from parent.
249 */
250 void
251 sigactsinit(struct proc *np, struct proc *pp, int share)
252 {
253 struct sigacts *ps;
254
255 if (share) {
256 np->p_sigacts = pp->p_sigacts;
257 pp->p_sigacts->sa_refcnt++;
258 } else {
259 ps = pool_get(&sigacts_pool, PR_WAITOK);
260 if (pp)
261 memcpy(ps, pp->p_sigacts, sizeof(struct sigacts));
262 else
263 memset(ps, '\0', sizeof(struct sigacts));
264 ps->sa_refcnt = 1;
265 np->p_sigacts = ps;
266 }
267 }
268
269 /*
270 * Make this process not share its sigctx, maintaining all
271 * signal state.
272 */
273 void
274 sigactsunshare(struct proc *p)
275 {
276 struct sigacts *oldps;
277
278 if (p->p_sigacts->sa_refcnt == 1)
279 return;
280
281 oldps = p->p_sigacts;
282 sigactsinit(p, NULL, 0);
283
284 if (--oldps->sa_refcnt == 0)
285 pool_put(&sigacts_pool, oldps);
286 }
287
288 /*
289 * Release a sigctx structure.
290 */
291 void
292 sigactsfree(struct proc *p)
293 {
294 struct sigacts *ps;
295
296 ps = p->p_sigacts;
297 if (--ps->sa_refcnt > 0)
298 return;
299
300 pool_put(&sigacts_pool, ps);
301 }
302
303 int
304 sigaction1(struct proc *p, int signum, const struct sigaction *nsa,
305 struct sigaction *osa, const void *tramp, int vers)
306 {
307 struct sigacts *ps;
308 int prop;
309
310 ps = p->p_sigacts;
311 if (signum <= 0 || signum >= NSIG)
312 return (EINVAL);
313
314 /*
315 * Trampoline ABI version 0 is reserved for the legacy
316 * kernel-provided on-stack trampoline. Conversely, if we are
317 * using a non-0 ABI version, we must have a trampoline. Only
318 * validate the vers if a new sigaction was supplied. Emulations
319 * use legacy kernel trampolines with version 0, alternatively
320 * check for that too.
321 */
322 if ((vers != 0 && tramp == NULL) ||
323 #ifdef SIGTRAMP_VALID
324 (nsa != NULL &&
325 ((vers == 0) ?
326 (p->p_emul->e_sigcode == NULL) :
327 !SIGTRAMP_VALID(vers))) ||
328 #endif
329 (vers == 0 && tramp != NULL))
330 return (EINVAL);
331
332 if (osa)
333 *osa = SIGACTION_PS(ps, signum);
334
335 if (nsa) {
336 if (nsa->sa_flags & ~SA_ALLBITS)
337 return (EINVAL);
338
339 prop = sigprop[signum];
340 if (prop & SA_CANTMASK)
341 return (EINVAL);
342
343 (void) splsched(); /* XXXSMP */
344 SIGACTION_PS(ps, signum) = *nsa;
345 ps->sa_sigdesc[signum].sd_tramp = tramp;
346 ps->sa_sigdesc[signum].sd_vers = vers;
347 sigminusset(&sigcantmask, &SIGACTION_PS(ps, signum).sa_mask);
348 if ((prop & SA_NORESET) != 0)
349 SIGACTION_PS(ps, signum).sa_flags &= ~SA_RESETHAND;
350 if (signum == SIGCHLD) {
351 if (nsa->sa_flags & SA_NOCLDSTOP)
352 p->p_flag |= P_NOCLDSTOP;
353 else
354 p->p_flag &= ~P_NOCLDSTOP;
355 if (nsa->sa_flags & SA_NOCLDWAIT) {
356 /*
357 * Paranoia: since SA_NOCLDWAIT is implemented
358 * by reparenting the dying child to PID 1 (and
359 * trust it to reap the zombie), PID 1 itself
360 * is forbidden to set SA_NOCLDWAIT.
361 */
362 if (p->p_pid == 1)
363 p->p_flag &= ~P_NOCLDWAIT;
364 else
365 p->p_flag |= P_NOCLDWAIT;
366 } else
367 p->p_flag &= ~P_NOCLDWAIT;
368 }
369 if ((nsa->sa_flags & SA_NODEFER) == 0)
370 sigaddset(&SIGACTION_PS(ps, signum).sa_mask, signum);
371 else
372 sigdelset(&SIGACTION_PS(ps, signum).sa_mask, signum);
373 /*
374 * Set bit in p_sigctx.ps_sigignore for signals that are set to
375 * SIG_IGN, and for signals set to SIG_DFL where the default is
376 * to ignore. However, don't put SIGCONT in
377 * p_sigctx.ps_sigignore, as we have to restart the process.
378 */
379 if (nsa->sa_handler == SIG_IGN ||
380 (nsa->sa_handler == SIG_DFL && (prop & SA_IGNORE) != 0)) {
381 /* never to be seen again */
382 sigdelset(&p->p_sigctx.ps_siglist, signum);
383 if (signum != SIGCONT) {
384 /* easier in psignal */
385 sigaddset(&p->p_sigctx.ps_sigignore, signum);
386 }
387 sigdelset(&p->p_sigctx.ps_sigcatch, signum);
388 } else {
389 sigdelset(&p->p_sigctx.ps_sigignore, signum);
390 if (nsa->sa_handler == SIG_DFL)
391 sigdelset(&p->p_sigctx.ps_sigcatch, signum);
392 else
393 sigaddset(&p->p_sigctx.ps_sigcatch, signum);
394 }
395 (void) spl0();
396 }
397
398 return (0);
399 }
400
401 #ifdef COMPAT_16
402 /* ARGSUSED */
403 int
404 compat_16_sys___sigaction14(struct lwp *l, void *v, register_t *retval)
405 {
406 struct compat_16_sys___sigaction14_args /* {
407 syscallarg(int) signum;
408 syscallarg(const struct sigaction *) nsa;
409 syscallarg(struct sigaction *) osa;
410 } */ *uap = v;
411 struct proc *p;
412 struct sigaction nsa, osa;
413 int error;
414
415 if (SCARG(uap, nsa)) {
416 error = copyin(SCARG(uap, nsa), &nsa, sizeof(nsa));
417 if (error)
418 return (error);
419 }
420 p = l->l_proc;
421 error = sigaction1(p, SCARG(uap, signum),
422 SCARG(uap, nsa) ? &nsa : 0, SCARG(uap, osa) ? &osa : 0,
423 NULL, 0);
424 if (error)
425 return (error);
426 if (SCARG(uap, osa)) {
427 error = copyout(&osa, SCARG(uap, osa), sizeof(osa));
428 if (error)
429 return (error);
430 }
431 return (0);
432 }
433 #endif
434
435 /* ARGSUSED */
436 int
437 sys___sigaction_sigtramp(struct lwp *l, void *v, register_t *retval)
438 {
439 struct sys___sigaction_sigtramp_args /* {
440 syscallarg(int) signum;
441 syscallarg(const struct sigaction *) nsa;
442 syscallarg(struct sigaction *) osa;
443 syscallarg(void *) tramp;
444 syscallarg(int) vers;
445 } */ *uap = v;
446 struct proc *p = l->l_proc;
447 struct sigaction nsa, osa;
448 int error;
449
450 if (SCARG(uap, nsa)) {
451 error = copyin(SCARG(uap, nsa), &nsa, sizeof(nsa));
452 if (error)
453 return (error);
454 }
455 error = sigaction1(p, SCARG(uap, signum),
456 SCARG(uap, nsa) ? &nsa : 0, SCARG(uap, osa) ? &osa : 0,
457 SCARG(uap, tramp), SCARG(uap, vers));
458 if (error)
459 return (error);
460 if (SCARG(uap, osa)) {
461 error = copyout(&osa, SCARG(uap, osa), sizeof(osa));
462 if (error)
463 return (error);
464 }
465 return (0);
466 }
467
468 /*
469 * Initialize signal state for process 0;
470 * set to ignore signals that are ignored by default and disable the signal
471 * stack.
472 */
473 void
474 siginit(struct proc *p)
475 {
476 struct sigacts *ps;
477 int signum, prop;
478
479 ps = p->p_sigacts;
480 sigemptyset(&contsigmask);
481 sigemptyset(&stopsigmask);
482 sigemptyset(&sigcantmask);
483 for (signum = 1; signum < NSIG; signum++) {
484 prop = sigprop[signum];
485 if (prop & SA_CONT)
486 sigaddset(&contsigmask, signum);
487 if (prop & SA_STOP)
488 sigaddset(&stopsigmask, signum);
489 if (prop & SA_CANTMASK)
490 sigaddset(&sigcantmask, signum);
491 if (prop & SA_IGNORE && signum != SIGCONT)
492 sigaddset(&p->p_sigctx.ps_sigignore, signum);
493 sigemptyset(&SIGACTION_PS(ps, signum).sa_mask);
494 SIGACTION_PS(ps, signum).sa_flags = SA_RESTART;
495 }
496 sigemptyset(&p->p_sigctx.ps_sigcatch);
497 p->p_sigctx.ps_sigwaited = NULL;
498 p->p_flag &= ~P_NOCLDSTOP;
499
500 /*
501 * Reset stack state to the user stack.
502 */
503 p->p_sigctx.ps_sigstk.ss_flags = SS_DISABLE;
504 p->p_sigctx.ps_sigstk.ss_size = 0;
505 p->p_sigctx.ps_sigstk.ss_sp = 0;
506
507 /* One reference. */
508 ps->sa_refcnt = 1;
509 }
510
511 /*
512 * Reset signals for an exec of the specified process.
513 */
514 void
515 execsigs(struct proc *p)
516 {
517 struct sigacts *ps;
518 int signum, prop;
519
520 sigactsunshare(p);
521
522 ps = p->p_sigacts;
523
524 /*
525 * Reset caught signals. Held signals remain held
526 * through p_sigctx.ps_sigmask (unless they were caught,
527 * and are now ignored by default).
528 */
529 for (signum = 1; signum < NSIG; signum++) {
530 if (sigismember(&p->p_sigctx.ps_sigcatch, signum)) {
531 prop = sigprop[signum];
532 if (prop & SA_IGNORE) {
533 if ((prop & SA_CONT) == 0)
534 sigaddset(&p->p_sigctx.ps_sigignore,
535 signum);
536 sigdelset(&p->p_sigctx.ps_siglist, signum);
537 }
538 SIGACTION_PS(ps, signum).sa_handler = SIG_DFL;
539 }
540 sigemptyset(&SIGACTION_PS(ps, signum).sa_mask);
541 SIGACTION_PS(ps, signum).sa_flags = SA_RESTART;
542 }
543 sigemptyset(&p->p_sigctx.ps_sigcatch);
544 p->p_sigctx.ps_sigwaited = NULL;
545 p->p_flag &= ~P_NOCLDSTOP;
546
547 /*
548 * Reset stack state to the user stack.
549 */
550 p->p_sigctx.ps_sigstk.ss_flags = SS_DISABLE;
551 p->p_sigctx.ps_sigstk.ss_size = 0;
552 p->p_sigctx.ps_sigstk.ss_sp = 0;
553 }
554
555 int
556 sigprocmask1(struct proc *p, int how, const sigset_t *nss, sigset_t *oss)
557 {
558
559 if (oss)
560 *oss = p->p_sigctx.ps_sigmask;
561
562 if (nss) {
563 (void)splsched(); /* XXXSMP */
564 switch (how) {
565 case SIG_BLOCK:
566 sigplusset(nss, &p->p_sigctx.ps_sigmask);
567 break;
568 case SIG_UNBLOCK:
569 sigminusset(nss, &p->p_sigctx.ps_sigmask);
570 CHECKSIGS(p);
571 break;
572 case SIG_SETMASK:
573 p->p_sigctx.ps_sigmask = *nss;
574 CHECKSIGS(p);
575 break;
576 default:
577 (void)spl0(); /* XXXSMP */
578 return (EINVAL);
579 }
580 sigminusset(&sigcantmask, &p->p_sigctx.ps_sigmask);
581 (void)spl0(); /* XXXSMP */
582 }
583
584 return (0);
585 }
586
587 /*
588 * Manipulate signal mask.
589 * Note that we receive new mask, not pointer,
590 * and return old mask as return value;
591 * the library stub does the rest.
592 */
593 int
594 sys___sigprocmask14(struct lwp *l, void *v, register_t *retval)
595 {
596 struct sys___sigprocmask14_args /* {
597 syscallarg(int) how;
598 syscallarg(const sigset_t *) set;
599 syscallarg(sigset_t *) oset;
600 } */ *uap = v;
601 struct proc *p;
602 sigset_t nss, oss;
603 int error;
604
605 if (SCARG(uap, set)) {
606 error = copyin(SCARG(uap, set), &nss, sizeof(nss));
607 if (error)
608 return (error);
609 }
610 p = l->l_proc;
611 error = sigprocmask1(p, SCARG(uap, how),
612 SCARG(uap, set) ? &nss : 0, SCARG(uap, oset) ? &oss : 0);
613 if (error)
614 return (error);
615 if (SCARG(uap, oset)) {
616 error = copyout(&oss, SCARG(uap, oset), sizeof(oss));
617 if (error)
618 return (error);
619 }
620 return (0);
621 }
622
623 void
624 sigpending1(struct proc *p, sigset_t *ss)
625 {
626
627 *ss = p->p_sigctx.ps_siglist;
628 sigminusset(&p->p_sigctx.ps_sigmask, ss);
629 }
630
631 /* ARGSUSED */
632 int
633 sys___sigpending14(struct lwp *l, void *v, register_t *retval)
634 {
635 struct sys___sigpending14_args /* {
636 syscallarg(sigset_t *) set;
637 } */ *uap = v;
638 struct proc *p;
639 sigset_t ss;
640
641 p = l->l_proc;
642 sigpending1(p, &ss);
643 return (copyout(&ss, SCARG(uap, set), sizeof(ss)));
644 }
645
646 int
647 sigsuspend1(struct proc *p, const sigset_t *ss)
648 {
649 struct sigacts *ps;
650
651 ps = p->p_sigacts;
652 if (ss) {
653 /*
654 * When returning from sigpause, we want
655 * the old mask to be restored after the
656 * signal handler has finished. Thus, we
657 * save it here and mark the sigctx structure
658 * to indicate this.
659 */
660 p->p_sigctx.ps_oldmask = p->p_sigctx.ps_sigmask;
661 p->p_sigctx.ps_flags |= SAS_OLDMASK;
662 (void) splsched(); /* XXXSMP */
663 p->p_sigctx.ps_sigmask = *ss;
664 CHECKSIGS(p);
665 sigminusset(&sigcantmask, &p->p_sigctx.ps_sigmask);
666 (void) spl0(); /* XXXSMP */
667 }
668
669 while (tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0) == 0)
670 /* void */;
671
672 /* always return EINTR rather than ERESTART... */
673 return (EINTR);
674 }
675
676 /*
677 * Suspend process until signal, providing mask to be set
678 * in the meantime. Note nonstandard calling convention:
679 * libc stub passes mask, not pointer, to save a copyin.
680 */
681 /* ARGSUSED */
682 int
683 sys___sigsuspend14(struct lwp *l, void *v, register_t *retval)
684 {
685 struct sys___sigsuspend14_args /* {
686 syscallarg(const sigset_t *) set;
687 } */ *uap = v;
688 struct proc *p;
689 sigset_t ss;
690 int error;
691
692 if (SCARG(uap, set)) {
693 error = copyin(SCARG(uap, set), &ss, sizeof(ss));
694 if (error)
695 return (error);
696 }
697
698 p = l->l_proc;
699 return (sigsuspend1(p, SCARG(uap, set) ? &ss : 0));
700 }
701
702 int
703 sigaltstack1(struct proc *p, const struct sigaltstack *nss,
704 struct sigaltstack *oss)
705 {
706
707 if (oss)
708 *oss = p->p_sigctx.ps_sigstk;
709
710 if (nss) {
711 if (nss->ss_flags & ~SS_ALLBITS)
712 return (EINVAL);
713
714 if (nss->ss_flags & SS_DISABLE) {
715 if (p->p_sigctx.ps_sigstk.ss_flags & SS_ONSTACK)
716 return (EINVAL);
717 } else {
718 if (nss->ss_size < MINSIGSTKSZ)
719 return (ENOMEM);
720 }
721 p->p_sigctx.ps_sigstk = *nss;
722 }
723
724 return (0);
725 }
726
727 /* ARGSUSED */
728 int
729 sys___sigaltstack14(struct lwp *l, void *v, register_t *retval)
730 {
731 struct sys___sigaltstack14_args /* {
732 syscallarg(const struct sigaltstack *) nss;
733 syscallarg(struct sigaltstack *) oss;
734 } */ *uap = v;
735 struct proc *p;
736 struct sigaltstack nss, oss;
737 int error;
738
739 if (SCARG(uap, nss)) {
740 error = copyin(SCARG(uap, nss), &nss, sizeof(nss));
741 if (error)
742 return (error);
743 }
744 p = l->l_proc;
745 error = sigaltstack1(p,
746 SCARG(uap, nss) ? &nss : 0, SCARG(uap, oss) ? &oss : 0);
747 if (error)
748 return (error);
749 if (SCARG(uap, oss)) {
750 error = copyout(&oss, SCARG(uap, oss), sizeof(oss));
751 if (error)
752 return (error);
753 }
754 return (0);
755 }
756
757 /* ARGSUSED */
758 int
759 sys_kill(struct lwp *l, void *v, register_t *retval)
760 {
761 struct sys_kill_args /* {
762 syscallarg(int) pid;
763 syscallarg(int) signum;
764 } */ *uap = v;
765 struct proc *cp, *p;
766 struct pcred *pc;
767 ksiginfo_t ksi;
768
769 cp = l->l_proc;
770 pc = cp->p_cred;
771 if ((u_int)SCARG(uap, signum) >= NSIG)
772 return (EINVAL);
773 KSI_INIT(&ksi);
774 ksi.ksi_signo = SCARG(uap, signum);
775 ksi.ksi_code = SI_USER;
776 ksi.ksi_pid = cp->p_pid;
777 ksi.ksi_uid = cp->p_ucred->cr_uid;
778 if (SCARG(uap, pid) > 0) {
779 /* kill single process */
780 if ((p = pfind(SCARG(uap, pid))) == NULL)
781 return (ESRCH);
782 if (!CANSIGNAL(cp, pc, p, SCARG(uap, signum)))
783 return (EPERM);
784 if (SCARG(uap, signum))
785 kpsignal2(p, &ksi, 1);
786 return (0);
787 }
788 switch (SCARG(uap, pid)) {
789 case -1: /* broadcast signal */
790 return (killpg1(cp, &ksi, 0, 1));
791 case 0: /* signal own process group */
792 return (killpg1(cp, &ksi, 0, 0));
793 default: /* negative explicit process group */
794 return (killpg1(cp, &ksi, -SCARG(uap, pid), 0));
795 }
796 /* NOTREACHED */
797 }
798
799 /*
800 * Common code for kill process group/broadcast kill.
801 * cp is calling process.
802 */
803 int
804 killpg1(struct proc *cp, ksiginfo_t *ksi, int pgid, int all)
805 {
806 struct proc *p;
807 struct pcred *pc;
808 struct pgrp *pgrp;
809 int nfound;
810 int signum = ksi->ksi_signo;
811
812 pc = cp->p_cred;
813 nfound = 0;
814 if (all) {
815 /*
816 * broadcast
817 */
818 proclist_lock_read();
819 LIST_FOREACH(p, &allproc, p_list) {
820 if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
821 p == cp || !CANSIGNAL(cp, pc, p, signum))
822 continue;
823 nfound++;
824 if (signum)
825 kpsignal2(p, ksi, 1);
826 }
827 proclist_unlock_read();
828 } else {
829 if (pgid == 0)
830 /*
831 * zero pgid means send to my process group.
832 */
833 pgrp = cp->p_pgrp;
834 else {
835 pgrp = pgfind(pgid);
836 if (pgrp == NULL)
837 return (ESRCH);
838 }
839 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
840 if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
841 !CANSIGNAL(cp, pc, p, signum))
842 continue;
843 nfound++;
844 if (signum && P_ZOMBIE(p) == 0)
845 kpsignal2(p, ksi, 1);
846 }
847 }
848 return (nfound ? 0 : ESRCH);
849 }
850
851 /*
852 * Send a signal to a process group.
853 */
854 void
855 gsignal(int pgid, int signum)
856 {
857 ksiginfo_t ksi;
858 KSI_INIT_EMPTY(&ksi);
859 ksi.ksi_signo = signum;
860 kgsignal(pgid, &ksi, NULL);
861 }
862
863 void
864 kgsignal(int pgid, ksiginfo_t *ksi, void *data)
865 {
866 struct pgrp *pgrp;
867
868 if (pgid && (pgrp = pgfind(pgid)))
869 kpgsignal(pgrp, ksi, data, 0);
870 }
871
872 /*
873 * Send a signal to a process group. If checktty is 1,
874 * limit to members which have a controlling terminal.
875 */
876 void
877 pgsignal(struct pgrp *pgrp, int sig, int checkctty)
878 {
879 ksiginfo_t ksi;
880 KSI_INIT_EMPTY(&ksi);
881 ksi.ksi_signo = sig;
882 kpgsignal(pgrp, &ksi, NULL, checkctty);
883 }
884
885 void
886 kpgsignal(struct pgrp *pgrp, ksiginfo_t *ksi, void *data, int checkctty)
887 {
888 struct proc *p;
889
890 if (pgrp)
891 LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
892 if (checkctty == 0 || p->p_flag & P_CONTROLT)
893 kpsignal(p, ksi, data);
894 }
895
896 /*
897 * Send a signal caused by a trap to the current process.
898 * If it will be caught immediately, deliver it with correct code.
899 * Otherwise, post it normally.
900 */
901 void
902 trapsignal(struct lwp *l, const ksiginfo_t *ksi)
903 {
904 struct proc *p;
905 struct sigacts *ps;
906 int signum = ksi->ksi_signo;
907
908 KASSERT(KSI_TRAP_P(ksi));
909
910 p = l->l_proc;
911 ps = p->p_sigacts;
912 if ((p->p_flag & P_TRACED) == 0 &&
913 sigismember(&p->p_sigctx.ps_sigcatch, signum) &&
914 !sigismember(&p->p_sigctx.ps_sigmask, signum)) {
915 p->p_stats->p_ru.ru_nsignals++;
916 #ifdef KTRACE
917 if (KTRPOINT(p, KTR_PSIG))
918 ktrpsig(p, signum, SIGACTION_PS(ps, signum).sa_handler,
919 &p->p_sigctx.ps_sigmask, ksi);
920 #endif
921 kpsendsig(l, ksi, &p->p_sigctx.ps_sigmask);
922 (void) splsched(); /* XXXSMP */
923 sigplusset(&SIGACTION_PS(ps, signum).sa_mask,
924 &p->p_sigctx.ps_sigmask);
925 if (SIGACTION_PS(ps, signum).sa_flags & SA_RESETHAND) {
926 sigdelset(&p->p_sigctx.ps_sigcatch, signum);
927 if (signum != SIGCONT && sigprop[signum] & SA_IGNORE)
928 sigaddset(&p->p_sigctx.ps_sigignore, signum);
929 SIGACTION_PS(ps, signum).sa_handler = SIG_DFL;
930 }
931 (void) spl0(); /* XXXSMP */
932 } else {
933 p->p_sigctx.ps_lwp = l->l_lid;
934 /* XXX for core dump/debugger */
935 p->p_sigctx.ps_signo = ksi->ksi_signo;
936 p->p_sigctx.ps_code = ksi->ksi_trap;
937 kpsignal2(p, ksi, 1);
938 }
939 }
940
941 /*
942 * Fill in signal information and signal the parent for a child status change.
943 */
944 static void
945 child_psignal(struct proc *p, int dolock)
946 {
947 ksiginfo_t ksi;
948
949 KSI_INIT(&ksi);
950 ksi.ksi_signo = SIGCHLD;
951 ksi.ksi_code = p->p_xstat == SIGCONT ? CLD_CONTINUED : CLD_STOPPED;
952 ksi.ksi_pid = p->p_pid;
953 ksi.ksi_uid = p->p_ucred->cr_uid;
954 ksi.ksi_status = p->p_xstat;
955 ksi.ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec;
956 ksi.ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec;
957 kpsignal2(p->p_pptr, &ksi, dolock);
958 }
959
960 /*
961 * Send the signal to the process. If the signal has an action, the action
962 * is usually performed by the target process rather than the caller; we add
963 * the signal to the set of pending signals for the process.
964 *
965 * Exceptions:
966 * o When a stop signal is sent to a sleeping process that takes the
967 * default action, the process is stopped without awakening it.
968 * o SIGCONT restarts stopped processes (or puts them back to sleep)
969 * regardless of the signal action (eg, blocked or ignored).
970 *
971 * Other ignored signals are discarded immediately.
972 *
973 * XXXSMP: Invoked as psignal() or sched_psignal().
974 */
975 void
976 psignal1(struct proc *p, int signum, int dolock)
977 {
978 ksiginfo_t ksi;
979
980 KSI_INIT_EMPTY(&ksi);
981 ksi.ksi_signo = signum;
982 kpsignal2(p, &ksi, dolock);
983 }
984
985 void
986 kpsignal1(struct proc *p, ksiginfo_t *ksi, void *data, int dolock)
987 {
988
989 if ((p->p_flag & P_WEXIT) == 0 && data) {
990 size_t fd;
991 struct filedesc *fdp = p->p_fd;
992
993 ksi->ksi_fd = -1;
994 for (fd = 0; fd < fdp->fd_nfiles; fd++) {
995 struct file *fp = fdp->fd_ofiles[fd];
996 /* XXX: lock? */
997 if (fp && fp->f_data == data) {
998 ksi->ksi_fd = fd;
999 break;
1000 }
1001 }
1002 }
1003 kpsignal2(p, ksi, dolock);
1004 }
1005
1006 static void
1007 kpsignal2(struct proc *p, const ksiginfo_t *ksi, int dolock)
1008 {
1009 struct lwp *l, *suspended = NULL;
1010 struct sadata_vp *vp;
1011 int s = 0, prop, allsusp;
1012 sig_t action;
1013 int signum = ksi->ksi_signo;
1014
1015 #ifdef DIAGNOSTIC
1016 if (signum <= 0 || signum >= NSIG)
1017 panic("psignal signal number %d", signum);
1018
1019 /* XXXSMP: works, but icky */
1020 if (dolock)
1021 SCHED_ASSERT_UNLOCKED();
1022 else
1023 SCHED_ASSERT_LOCKED();
1024 #endif
1025
1026 /*
1027 * Notify any interested parties in the signal.
1028 */
1029 KNOTE(&p->p_klist, NOTE_SIGNAL | signum);
1030
1031 prop = sigprop[signum];
1032
1033 /*
1034 * If proc is traced, always give parent a chance.
1035 */
1036 if (p->p_flag & P_TRACED) {
1037 action = SIG_DFL;
1038
1039 /*
1040 * If the process is being traced and the signal is being
1041 * caught, make sure to save any ksiginfo.
1042 */
1043 if (sigismember(&p->p_sigctx.ps_sigcatch, signum))
1044 ksiginfo_put(p, ksi);
1045 } else {
1046 /*
1047 * If the signal was the result of a trap, reset it
1048 * to default action if it's currently masked, so that it would
1049 * coredump immediatelly instead of spinning repeatedly
1050 * taking the signal.
1051 */
1052 if (KSI_TRAP_P(ksi)
1053 && sigismember(&p->p_sigctx.ps_sigmask, signum)
1054 && !sigismember(&p->p_sigctx.ps_sigcatch, signum)) {
1055 sigdelset(&p->p_sigctx.ps_sigignore, signum);
1056 sigdelset(&p->p_sigctx.ps_sigcatch, signum);
1057 sigdelset(&p->p_sigctx.ps_sigmask, signum);
1058 SIGACTION(p, signum).sa_handler = SIG_DFL;
1059 }
1060
1061 /*
1062 * If the signal is being ignored,
1063 * then we forget about it immediately.
1064 * (Note: we don't set SIGCONT in p_sigctx.ps_sigignore,
1065 * and if it is set to SIG_IGN,
1066 * action will be SIG_DFL here.)
1067 */
1068 if (sigismember(&p->p_sigctx.ps_sigignore, signum))
1069 return;
1070 if (sigismember(&p->p_sigctx.ps_sigmask, signum))
1071 action = SIG_HOLD;
1072 else if (sigismember(&p->p_sigctx.ps_sigcatch, signum))
1073 action = SIG_CATCH;
1074 else {
1075 action = SIG_DFL;
1076
1077 if (prop & SA_KILL && p->p_nice > NZERO)
1078 p->p_nice = NZERO;
1079
1080 /*
1081 * If sending a tty stop signal to a member of an
1082 * orphaned process group, discard the signal here if
1083 * the action is default; don't stop the process below
1084 * if sleeping, and don't clear any pending SIGCONT.
1085 */
1086 if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0)
1087 return;
1088 }
1089 }
1090
1091 if (prop & SA_CONT)
1092 sigminusset(&stopsigmask, &p->p_sigctx.ps_siglist);
1093
1094 if (prop & SA_STOP)
1095 sigminusset(&contsigmask, &p->p_sigctx.ps_siglist);
1096
1097 /*
1098 * If the signal doesn't have SA_CANTMASK (no override for SIGKILL,
1099 * please!), check if anything waits on it. If yes, save the
1100 * info into provided ps_sigwaited, and wake-up the waiter.
1101 * The signal won't be processed further here.
1102 */
1103 if ((prop & SA_CANTMASK) == 0
1104 && p->p_sigctx.ps_sigwaited
1105 && sigismember(p->p_sigctx.ps_sigwait, signum)
1106 && p->p_stat != SSTOP) {
1107 p->p_sigctx.ps_sigwaited->ksi_info = ksi->ksi_info;
1108 p->p_sigctx.ps_sigwaited = NULL;
1109 if (dolock)
1110 wakeup_one(&p->p_sigctx.ps_sigwait);
1111 else
1112 sched_wakeup(&p->p_sigctx.ps_sigwait);
1113 return;
1114 }
1115
1116 sigaddset(&p->p_sigctx.ps_siglist, signum);
1117
1118 /* CHECKSIGS() is "inlined" here. */
1119 p->p_sigctx.ps_sigcheck = 1;
1120
1121 /*
1122 * Defer further processing for signals which are held,
1123 * except that stopped processes must be continued by SIGCONT.
1124 */
1125 if (action == SIG_HOLD &&
1126 ((prop & SA_CONT) == 0 || p->p_stat != SSTOP)) {
1127 ksiginfo_put(p, ksi);
1128 return;
1129 }
1130 /* XXXSMP: works, but icky */
1131 if (dolock)
1132 SCHED_LOCK(s);
1133
1134 if (p->p_flag & P_SA) {
1135 allsusp = 0;
1136 l = NULL;
1137 if (p->p_stat == SACTIVE) {
1138 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
1139 l = vp->savp_lwp;
1140 KDASSERT(l != NULL);
1141 if (l->l_flag & L_SA_IDLE) {
1142 /* wakeup idle LWP */
1143 goto found;
1144 /*NOTREACHED*/
1145 } else if (l->l_flag & L_SA_YIELD) {
1146 /* idle LWP is already waking up */
1147 goto out;
1148 /*NOTREACHED*/
1149 }
1150 }
1151 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
1152 l = vp->savp_lwp;
1153 if (l->l_stat == LSRUN ||
1154 l->l_stat == LSONPROC) {
1155 signotify(p);
1156 goto out;
1157 /*NOTREACHED*/
1158 }
1159 if (l->l_stat == LSSLEEP &&
1160 l->l_flag & L_SINTR) {
1161 /* ok to signal vp lwp */
1162 break;
1163 } else
1164 l = NULL;
1165 }
1166 } else if (p->p_stat == SSTOP) {
1167 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
1168 l = vp->savp_lwp;
1169 if (l->l_stat == LSSLEEP && (l->l_flag & L_SINTR) != 0)
1170 break;
1171 l = NULL;
1172 }
1173 }
1174 } else if (p->p_nrlwps > 0 && (p->p_stat != SSTOP)) {
1175 /*
1176 * At least one LWP is running or on a run queue.
1177 * The signal will be noticed when one of them returns
1178 * to userspace.
1179 */
1180 signotify(p);
1181 /*
1182 * The signal will be noticed very soon.
1183 */
1184 goto out;
1185 /*NOTREACHED*/
1186 } else {
1187 /*
1188 * Find out if any of the sleeps are interruptable,
1189 * and if all the live LWPs remaining are suspended.
1190 */
1191 allsusp = 1;
1192 LIST_FOREACH(l, &p->p_lwps, l_sibling) {
1193 if (l->l_stat == LSSLEEP &&
1194 l->l_flag & L_SINTR)
1195 break;
1196 if (l->l_stat == LSSUSPENDED)
1197 suspended = l;
1198 else if ((l->l_stat != LSZOMB) &&
1199 (l->l_stat != LSDEAD))
1200 allsusp = 0;
1201 }
1202 }
1203
1204 found:
1205 switch (p->p_stat) {
1206 case SACTIVE:
1207
1208 if (l != NULL && (p->p_flag & P_TRACED))
1209 goto run;
1210
1211 /*
1212 * If SIGCONT is default (or ignored) and process is
1213 * asleep, we are finished; the process should not
1214 * be awakened.
1215 */
1216 if ((prop & SA_CONT) && action == SIG_DFL) {
1217 sigdelset(&p->p_sigctx.ps_siglist, signum);
1218 goto done;
1219 }
1220
1221 /*
1222 * When a sleeping process receives a stop
1223 * signal, process immediately if possible.
1224 */
1225 if ((prop & SA_STOP) && action == SIG_DFL) {
1226 /*
1227 * If a child holding parent blocked,
1228 * stopping could cause deadlock.
1229 */
1230 if (p->p_flag & P_PPWAIT) {
1231 goto out;
1232 }
1233 sigdelset(&p->p_sigctx.ps_siglist, signum);
1234 p->p_xstat = signum;
1235 if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0) {
1236 /*
1237 * XXXSMP: recursive call; don't lock
1238 * the second time around.
1239 */
1240 child_psignal(p, 0);
1241 }
1242 proc_stop(p, 1); /* XXXSMP: recurse? */
1243 goto done;
1244 }
1245
1246 if (l == NULL) {
1247 /*
1248 * Special case: SIGKILL of a process
1249 * which is entirely composed of
1250 * suspended LWPs should succeed. We
1251 * make this happen by unsuspending one of
1252 * them.
1253 */
1254 if (allsusp && (signum == SIGKILL)) {
1255 lwp_continue(suspended);
1256 }
1257 goto done;
1258 }
1259 /*
1260 * All other (caught or default) signals
1261 * cause the process to run.
1262 */
1263 goto runfast;
1264 /*NOTREACHED*/
1265 case SSTOP:
1266 /* Process is stopped */
1267 /*
1268 * If traced process is already stopped,
1269 * then no further action is necessary.
1270 */
1271 if (p->p_flag & P_TRACED)
1272 goto done;
1273
1274 /*
1275 * Kill signal always sets processes running,
1276 * if possible.
1277 */
1278 if (signum == SIGKILL) {
1279 l = proc_unstop(p);
1280 if (l)
1281 goto runfast;
1282 goto done;
1283 }
1284
1285 if (prop & SA_CONT) {
1286 /*
1287 * If SIGCONT is default (or ignored),
1288 * we continue the process but don't
1289 * leave the signal in ps_siglist, as
1290 * it has no further action. If
1291 * SIGCONT is held, we continue the
1292 * process and leave the signal in
1293 * ps_siglist. If the process catches
1294 * SIGCONT, let it handle the signal
1295 * itself. If it isn't waiting on an
1296 * event, then it goes back to run
1297 * state. Otherwise, process goes
1298 * back to sleep state.
1299 */
1300 if (action == SIG_DFL)
1301 sigdelset(&p->p_sigctx.ps_siglist,
1302 signum);
1303 l = proc_unstop(p);
1304 if (l && (action == SIG_CATCH))
1305 goto runfast;
1306 goto out;
1307 }
1308
1309 if (prop & SA_STOP) {
1310 /*
1311 * Already stopped, don't need to stop again.
1312 * (If we did the shell could get confused.)
1313 */
1314 sigdelset(&p->p_sigctx.ps_siglist, signum);
1315 goto done;
1316 }
1317
1318 /*
1319 * If a lwp is sleeping interruptibly, then
1320 * wake it up; it will run until the kernel
1321 * boundary, where it will stop in issignal(),
1322 * since p->p_stat is still SSTOP. When the
1323 * process is continued, it will be made
1324 * runnable and can look at the signal.
1325 */
1326 if (l)
1327 goto run;
1328 goto out;
1329 case SIDL:
1330 /* Process is being created by fork */
1331 /* XXX: We are not ready to receive signals yet */
1332 goto done;
1333 default:
1334 /* Else what? */
1335 panic("psignal: Invalid process state %d.", p->p_stat);
1336 }
1337 /*NOTREACHED*/
1338
1339 runfast:
1340 if (action == SIG_CATCH) {
1341 ksiginfo_put(p, ksi);
1342 action = SIG_HOLD;
1343 }
1344 /*
1345 * Raise priority to at least PUSER.
1346 */
1347 if (l->l_priority > PUSER)
1348 l->l_priority = PUSER;
1349 run:
1350 if (action == SIG_CATCH) {
1351 ksiginfo_put(p, ksi);
1352 action = SIG_HOLD;
1353 }
1354
1355 setrunnable(l); /* XXXSMP: recurse? */
1356 out:
1357 if (action == SIG_CATCH)
1358 ksiginfo_put(p, ksi);
1359 done:
1360 /* XXXSMP: works, but icky */
1361 if (dolock)
1362 SCHED_UNLOCK(s);
1363 }
1364
1365 void
1366 kpsendsig(struct lwp *l, const ksiginfo_t *ksi, const sigset_t *mask)
1367 {
1368 struct proc *p = l->l_proc;
1369 struct lwp *le, *li;
1370 siginfo_t *si;
1371 int f;
1372
1373 if (p->p_flag & P_SA) {
1374
1375 /* XXXUPSXXX What if not on sa_vp ? */
1376
1377 f = l->l_flag & L_SA;
1378 l->l_flag &= ~L_SA;
1379 si = pool_get(&siginfo_pool, PR_WAITOK);
1380 si->_info = ksi->ksi_info;
1381 le = li = NULL;
1382 if (KSI_TRAP_P(ksi))
1383 le = l;
1384 else
1385 li = l;
1386
1387 sa_upcall(l, SA_UPCALL_SIGNAL | SA_UPCALL_DEFER, le, li,
1388 sizeof(siginfo_t), si);
1389 l->l_flag |= f;
1390 return;
1391 }
1392
1393 (*p->p_emul->e_sendsig)(ksi, mask);
1394 }
1395
1396 static __inline int firstsig(const sigset_t *);
1397
1398 static __inline int
1399 firstsig(const sigset_t *ss)
1400 {
1401 int sig;
1402
1403 sig = ffs(ss->__bits[0]);
1404 if (sig != 0)
1405 return (sig);
1406 #if NSIG > 33
1407 sig = ffs(ss->__bits[1]);
1408 if (sig != 0)
1409 return (sig + 32);
1410 #endif
1411 #if NSIG > 65
1412 sig = ffs(ss->__bits[2]);
1413 if (sig != 0)
1414 return (sig + 64);
1415 #endif
1416 #if NSIG > 97
1417 sig = ffs(ss->__bits[3]);
1418 if (sig != 0)
1419 return (sig + 96);
1420 #endif
1421 return (0);
1422 }
1423
1424 /*
1425 * If the current process has received a signal (should be caught or cause
1426 * termination, should interrupt current syscall), return the signal number.
1427 * Stop signals with default action are processed immediately, then cleared;
1428 * they aren't returned. This is checked after each entry to the system for
1429 * a syscall or trap (though this can usually be done without calling issignal
1430 * by checking the pending signal masks in the CURSIG macro.) The normal call
1431 * sequence is
1432 *
1433 * while (signum = CURSIG(curlwp))
1434 * postsig(signum);
1435 */
1436 int
1437 issignal(struct lwp *l)
1438 {
1439 struct proc *p = l->l_proc;
1440 int s = 0, signum, prop;
1441 int dolock = (l->l_flag & L_SINTR) == 0, locked = !dolock;
1442 sigset_t ss;
1443
1444 /* Bail out if we do not own the virtual processor */
1445 if (l->l_flag & L_SA && l->l_savp->savp_lwp != l)
1446 return 0;
1447
1448 if (p->p_stat == SSTOP) {
1449 /*
1450 * The process is stopped/stopping. Stop ourselves now that
1451 * we're on the kernel/userspace boundary.
1452 */
1453 if (dolock)
1454 SCHED_LOCK(s);
1455 l->l_stat = LSSTOP;
1456 p->p_nrlwps--;
1457 if (p->p_flag & P_TRACED)
1458 goto sigtraceswitch;
1459 else
1460 goto sigswitch;
1461 }
1462 for (;;) {
1463 sigpending1(p, &ss);
1464 if (p->p_flag & P_PPWAIT)
1465 sigminusset(&stopsigmask, &ss);
1466 signum = firstsig(&ss);
1467 if (signum == 0) { /* no signal to send */
1468 p->p_sigctx.ps_sigcheck = 0;
1469 if (locked && dolock)
1470 SCHED_LOCK(s);
1471 return (0);
1472 }
1473 /* take the signal! */
1474 sigdelset(&p->p_sigctx.ps_siglist, signum);
1475
1476 /*
1477 * We should see pending but ignored signals
1478 * only if P_TRACED was on when they were posted.
1479 */
1480 if (sigismember(&p->p_sigctx.ps_sigignore, signum) &&
1481 (p->p_flag & P_TRACED) == 0)
1482 continue;
1483
1484 if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) {
1485 /*
1486 * If traced, always stop, and stay
1487 * stopped until released by the debugger.
1488 */
1489 p->p_xstat = signum;
1490
1491 /* Emulation-specific handling of signal trace */
1492 if ((p->p_emul->e_tracesig != NULL) &&
1493 ((*p->p_emul->e_tracesig)(p, signum) != 0))
1494 goto childresumed;
1495
1496 if ((p->p_flag & P_FSTRACE) == 0)
1497 child_psignal(p, dolock);
1498 if (dolock)
1499 SCHED_LOCK(s);
1500 proc_stop(p, 1);
1501 sigtraceswitch:
1502 mi_switch(l, NULL);
1503 SCHED_ASSERT_UNLOCKED();
1504 if (dolock)
1505 splx(s);
1506 else
1507 dolock = 1;
1508
1509 childresumed:
1510 /*
1511 * If we are no longer being traced, or the parent
1512 * didn't give us a signal, look for more signals.
1513 */
1514 if ((p->p_flag & P_TRACED) == 0 || p->p_xstat == 0)
1515 continue;
1516
1517 /*
1518 * If the new signal is being masked, look for other
1519 * signals.
1520 */
1521 signum = p->p_xstat;
1522 p->p_xstat = 0;
1523 /*
1524 * `p->p_sigctx.ps_siglist |= mask' is done
1525 * in setrunnable().
1526 */
1527 if (sigismember(&p->p_sigctx.ps_sigmask, signum))
1528 continue;
1529 /* take the signal! */
1530 sigdelset(&p->p_sigctx.ps_siglist, signum);
1531 }
1532
1533 prop = sigprop[signum];
1534
1535 /*
1536 * Decide whether the signal should be returned.
1537 * Return the signal's number, or fall through
1538 * to clear it from the pending mask.
1539 */
1540 switch ((long)SIGACTION(p, signum).sa_handler) {
1541
1542 case (long)SIG_DFL:
1543 /*
1544 * Don't take default actions on system processes.
1545 */
1546 if (p->p_pid <= 1) {
1547 #ifdef DIAGNOSTIC
1548 /*
1549 * Are you sure you want to ignore SIGSEGV
1550 * in init? XXX
1551 */
1552 printf("Process (pid %d) got signal %d\n",
1553 p->p_pid, signum);
1554 #endif
1555 break; /* == ignore */
1556 }
1557 /*
1558 * If there is a pending stop signal to process
1559 * with default action, stop here,
1560 * then clear the signal. However,
1561 * if process is member of an orphaned
1562 * process group, ignore tty stop signals.
1563 */
1564 if (prop & SA_STOP) {
1565 if (p->p_flag & P_TRACED ||
1566 (p->p_pgrp->pg_jobc == 0 &&
1567 prop & SA_TTYSTOP))
1568 break; /* == ignore */
1569 p->p_xstat = signum;
1570 if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
1571 child_psignal(p, dolock);
1572 if (dolock)
1573 SCHED_LOCK(s);
1574 proc_stop(p, 1);
1575 sigswitch:
1576 mi_switch(l, NULL);
1577 SCHED_ASSERT_UNLOCKED();
1578 if (dolock)
1579 splx(s);
1580 else
1581 dolock = 1;
1582 break;
1583 } else if (prop & SA_IGNORE) {
1584 /*
1585 * Except for SIGCONT, shouldn't get here.
1586 * Default action is to ignore; drop it.
1587 */
1588 break; /* == ignore */
1589 } else
1590 goto keep;
1591 /*NOTREACHED*/
1592
1593 case (long)SIG_IGN:
1594 /*
1595 * Masking above should prevent us ever trying
1596 * to take action on an ignored signal other
1597 * than SIGCONT, unless process is traced.
1598 */
1599 #ifdef DEBUG_ISSIGNAL
1600 if ((prop & SA_CONT) == 0 &&
1601 (p->p_flag & P_TRACED) == 0)
1602 printf("issignal\n");
1603 #endif
1604 break; /* == ignore */
1605
1606 default:
1607 /*
1608 * This signal has an action, let
1609 * postsig() process it.
1610 */
1611 goto keep;
1612 }
1613 }
1614 /* NOTREACHED */
1615
1616 keep:
1617 /* leave the signal for later */
1618 sigaddset(&p->p_sigctx.ps_siglist, signum);
1619 CHECKSIGS(p);
1620 if (locked && dolock)
1621 SCHED_LOCK(s);
1622 return (signum);
1623 }
1624
1625 /*
1626 * Put the argument process into the stopped state and notify the parent
1627 * via wakeup. Signals are handled elsewhere. The process must not be
1628 * on the run queue.
1629 */
1630 void
1631 proc_stop(struct proc *p, int wakeup)
1632 {
1633 struct lwp *l;
1634 struct proc *parent;
1635 struct sadata_vp *vp;
1636
1637 SCHED_ASSERT_LOCKED();
1638
1639 /* XXX lock process LWP state */
1640 p->p_flag &= ~P_WAITED;
1641 p->p_stat = SSTOP;
1642 parent = p->p_pptr;
1643 parent->p_nstopchild++;
1644
1645 if (p->p_flag & P_SA) {
1646 /*
1647 * Only (try to) put the LWP on the VP in stopped
1648 * state.
1649 * All other LWPs will suspend in sa_setwoken()
1650 * because the VP-LWP in stopped state cannot be
1651 * repossessed.
1652 */
1653 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
1654 l = vp->savp_lwp;
1655 if (l->l_stat == LSONPROC && l->l_cpu == curcpu()) {
1656 l->l_stat = LSSTOP;
1657 p->p_nrlwps--;
1658 } else if (l->l_stat == LSRUN) {
1659 /* Remove LWP from the run queue */
1660 remrunqueue(l);
1661 l->l_stat = LSSTOP;
1662 p->p_nrlwps--;
1663 } else if (l->l_stat == LSSLEEP &&
1664 l->l_flag & L_SA_IDLE) {
1665 l->l_flag &= ~L_SA_IDLE;
1666 l->l_stat = LSSTOP;
1667 }
1668 }
1669 goto out;
1670 }
1671
1672 /*
1673 * Put as many LWP's as possible in stopped state.
1674 * Sleeping ones will notice the stopped state as they try to
1675 * return to userspace.
1676 */
1677
1678 LIST_FOREACH(l, &p->p_lwps, l_sibling) {
1679 if (l->l_stat == LSONPROC) {
1680 /* XXX SMP this assumes that a LWP that is LSONPROC
1681 * is curlwp and hence is about to be mi_switched
1682 * away; the only callers of proc_stop() are:
1683 * - psignal
1684 * - issignal()
1685 * For the former, proc_stop() is only called when
1686 * no processes are running, so we don't worry.
1687 * For the latter, proc_stop() is called right
1688 * before mi_switch().
1689 */
1690 l->l_stat = LSSTOP;
1691 p->p_nrlwps--;
1692 } else if (l->l_stat == LSRUN) {
1693 /* Remove LWP from the run queue */
1694 remrunqueue(l);
1695 l->l_stat = LSSTOP;
1696 p->p_nrlwps--;
1697 } else if ((l->l_stat == LSSLEEP) ||
1698 (l->l_stat == LSSUSPENDED) ||
1699 (l->l_stat == LSZOMB) ||
1700 (l->l_stat == LSDEAD)) {
1701 /*
1702 * Don't do anything; let sleeping LWPs
1703 * discover the stopped state of the process
1704 * on their way out of the kernel; otherwise,
1705 * things like NFS threads that sleep with
1706 * locks will block the rest of the system
1707 * from getting any work done.
1708 *
1709 * Suspended/dead/zombie LWPs aren't going
1710 * anywhere, so we don't need to touch them.
1711 */
1712 }
1713 #ifdef DIAGNOSTIC
1714 else {
1715 panic("proc_stop: process %d lwp %d "
1716 "in unstoppable state %d.\n",
1717 p->p_pid, l->l_lid, l->l_stat);
1718 }
1719 #endif
1720 }
1721
1722 out:
1723 /* XXX unlock process LWP state */
1724
1725 if (wakeup)
1726 sched_wakeup((caddr_t)p->p_pptr);
1727 }
1728
1729 /*
1730 * Given a process in state SSTOP, set the state back to SACTIVE and
1731 * move LSSTOP'd LWPs to LSSLEEP or make them runnable.
1732 *
1733 * If no LWPs ended up runnable (and therefore able to take a signal),
1734 * return a LWP that is sleeping interruptably. The caller can wake
1735 * that LWP up to take a signal.
1736 */
1737 struct lwp *
1738 proc_unstop(struct proc *p)
1739 {
1740 struct lwp *l, *lr = NULL;
1741 struct sadata_vp *vp;
1742 int cantake = 0;
1743
1744 SCHED_ASSERT_LOCKED();
1745
1746 /*
1747 * Our caller wants to be informed if there are only sleeping
1748 * and interruptable LWPs left after we have run so that it
1749 * can invoke setrunnable() if required - return one of the
1750 * interruptable LWPs if this is the case.
1751 */
1752
1753 if (!(p->p_flag & P_WAITED))
1754 p->p_pptr->p_nstopchild--;
1755 p->p_stat = SACTIVE;
1756 LIST_FOREACH(l, &p->p_lwps, l_sibling) {
1757 if (l->l_stat == LSRUN) {
1758 lr = NULL;
1759 cantake = 1;
1760 }
1761 if (l->l_stat != LSSTOP)
1762 continue;
1763
1764 if (l->l_wchan != NULL) {
1765 l->l_stat = LSSLEEP;
1766 if ((cantake == 0) && (l->l_flag & L_SINTR)) {
1767 lr = l;
1768 cantake = 1;
1769 }
1770 } else {
1771 setrunnable(l);
1772 lr = NULL;
1773 cantake = 1;
1774 }
1775 }
1776 if (p->p_flag & P_SA) {
1777 /* Only consider returning the LWP on the VP. */
1778 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
1779 lr = vp->savp_lwp;
1780 if (lr->l_stat == LSSLEEP) {
1781 if (lr->l_flag & L_SA_YIELD) {
1782 setrunnable(lr);
1783 break;
1784 } else if (lr->l_flag & L_SINTR)
1785 return lr;
1786 }
1787 }
1788 return NULL;
1789 }
1790 return lr;
1791 }
1792
1793 /*
1794 * Take the action for the specified signal
1795 * from the current set of pending signals.
1796 */
1797 void
1798 postsig(int signum)
1799 {
1800 struct lwp *l;
1801 struct proc *p;
1802 struct sigacts *ps;
1803 sig_t action;
1804 sigset_t *returnmask;
1805
1806 l = curlwp;
1807 p = l->l_proc;
1808 ps = p->p_sigacts;
1809 #ifdef DIAGNOSTIC
1810 if (signum == 0)
1811 panic("postsig");
1812 #endif
1813
1814 KERNEL_PROC_LOCK(l);
1815
1816 #ifdef MULTIPROCESSOR
1817 /*
1818 * On MP, issignal() can return the same signal to multiple
1819 * LWPs. The LWPs will block above waiting for the kernel
1820 * lock and the first LWP which gets through will then remove
1821 * the signal from ps_siglist. All other LWPs exit here.
1822 */
1823 if (!sigismember(&p->p_sigctx.ps_siglist, signum)) {
1824 KERNEL_PROC_UNLOCK(l);
1825 return;
1826 }
1827 #endif
1828 sigdelset(&p->p_sigctx.ps_siglist, signum);
1829 action = SIGACTION_PS(ps, signum).sa_handler;
1830 if (action == SIG_DFL) {
1831 #ifdef KTRACE
1832 if (KTRPOINT(p, KTR_PSIG))
1833 ktrpsig(p, signum, action,
1834 p->p_sigctx.ps_flags & SAS_OLDMASK ?
1835 &p->p_sigctx.ps_oldmask : &p->p_sigctx.ps_sigmask,
1836 NULL);
1837 #endif
1838 /*
1839 * Default action, where the default is to kill
1840 * the process. (Other cases were ignored above.)
1841 */
1842 sigexit(l, signum);
1843 /* NOTREACHED */
1844 } else {
1845 ksiginfo_t *ksi;
1846 /*
1847 * If we get here, the signal must be caught.
1848 */
1849 #ifdef DIAGNOSTIC
1850 if (action == SIG_IGN ||
1851 sigismember(&p->p_sigctx.ps_sigmask, signum))
1852 panic("postsig action");
1853 #endif
1854 /*
1855 * Set the new mask value and also defer further
1856 * occurrences of this signal.
1857 *
1858 * Special case: user has done a sigpause. Here the
1859 * current mask is not of interest, but rather the
1860 * mask from before the sigpause is what we want
1861 * restored after the signal processing is completed.
1862 */
1863 if (p->p_sigctx.ps_flags & SAS_OLDMASK) {
1864 returnmask = &p->p_sigctx.ps_oldmask;
1865 p->p_sigctx.ps_flags &= ~SAS_OLDMASK;
1866 } else
1867 returnmask = &p->p_sigctx.ps_sigmask;
1868 p->p_stats->p_ru.ru_nsignals++;
1869 ksi = ksiginfo_get(p, signum);
1870 #ifdef KTRACE
1871 if (KTRPOINT(p, KTR_PSIG))
1872 ktrpsig(p, signum, action,
1873 p->p_sigctx.ps_flags & SAS_OLDMASK ?
1874 &p->p_sigctx.ps_oldmask : &p->p_sigctx.ps_sigmask,
1875 ksi);
1876 #endif
1877 if (ksi == NULL) {
1878 ksiginfo_t ksi1;
1879 /*
1880 * we did not save any siginfo for this, either
1881 * because the signal was not caught, or because the
1882 * user did not request SA_SIGINFO
1883 */
1884 KSI_INIT_EMPTY(&ksi1);
1885 ksi1.ksi_signo = signum;
1886 kpsendsig(l, &ksi1, returnmask);
1887 } else {
1888 kpsendsig(l, ksi, returnmask);
1889 pool_put(&ksiginfo_pool, ksi);
1890 }
1891 p->p_sigctx.ps_lwp = 0;
1892 p->p_sigctx.ps_code = 0;
1893 p->p_sigctx.ps_signo = 0;
1894 (void) splsched(); /* XXXSMP */
1895 sigplusset(&SIGACTION_PS(ps, signum).sa_mask,
1896 &p->p_sigctx.ps_sigmask);
1897 if (SIGACTION_PS(ps, signum).sa_flags & SA_RESETHAND) {
1898 sigdelset(&p->p_sigctx.ps_sigcatch, signum);
1899 if (signum != SIGCONT && sigprop[signum] & SA_IGNORE)
1900 sigaddset(&p->p_sigctx.ps_sigignore, signum);
1901 SIGACTION_PS(ps, signum).sa_handler = SIG_DFL;
1902 }
1903 (void) spl0(); /* XXXSMP */
1904 }
1905
1906 KERNEL_PROC_UNLOCK(l);
1907 }
1908
1909 /*
1910 * Kill the current process for stated reason.
1911 */
1912 void
1913 killproc(struct proc *p, const char *why)
1914 {
1915 log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why);
1916 uprintf("sorry, pid %d was killed: %s\n", p->p_pid, why);
1917 psignal(p, SIGKILL);
1918 }
1919
1920 /*
1921 * Force the current process to exit with the specified signal, dumping core
1922 * if appropriate. We bypass the normal tests for masked and caught signals,
1923 * allowing unrecoverable failures to terminate the process without changing
1924 * signal state. Mark the accounting record with the signal termination.
1925 * If dumping core, save the signal number for the debugger. Calls exit and
1926 * does not return.
1927 */
1928
1929 #if defined(DEBUG)
1930 int kern_logsigexit = 1; /* not static to make public for sysctl */
1931 #else
1932 int kern_logsigexit = 0; /* not static to make public for sysctl */
1933 #endif
1934
1935 static const char logcoredump[] =
1936 "pid %d (%s), uid %d: exited on signal %d (core dumped)\n";
1937 static const char lognocoredump[] =
1938 "pid %d (%s), uid %d: exited on signal %d (core not dumped, err = %d)\n";
1939
1940 /* Wrapper function for use in p_userret */
1941 static void
1942 lwp_coredump_hook(struct lwp *l, void *arg)
1943 {
1944 int s;
1945
1946 /*
1947 * Suspend ourselves, so that the kernel stack and therefore
1948 * the userland registers saved in the trapframe are around
1949 * for coredump() to write them out.
1950 */
1951 KERNEL_PROC_LOCK(l);
1952 l->l_flag &= ~L_DETACHED;
1953 SCHED_LOCK(s);
1954 l->l_stat = LSSUSPENDED;
1955 l->l_proc->p_nrlwps--;
1956 /* XXX NJWLWP check if this makes sense here: */
1957 l->l_proc->p_stats->p_ru.ru_nvcsw++;
1958 mi_switch(l, NULL);
1959 SCHED_ASSERT_UNLOCKED();
1960 splx(s);
1961
1962 lwp_exit(l);
1963 }
1964
1965 void
1966 sigexit(struct lwp *l, int signum)
1967 {
1968 struct proc *p;
1969 #if 0
1970 struct lwp *l2;
1971 #endif
1972 int error, exitsig;
1973
1974 p = l->l_proc;
1975
1976 /*
1977 * Don't permit coredump() or exit1() multiple times
1978 * in the same process.
1979 */
1980 if (p->p_flag & P_WEXIT) {
1981 KERNEL_PROC_UNLOCK(l);
1982 (*p->p_userret)(l, p->p_userret_arg);
1983 }
1984 p->p_flag |= P_WEXIT;
1985 /* We don't want to switch away from exiting. */
1986 /* XXX multiprocessor: stop LWPs on other processors. */
1987 #if 0
1988 if (p->p_flag & P_SA) {
1989 LIST_FOREACH(l2, &p->p_lwps, l_sibling)
1990 l2->l_flag &= ~L_SA;
1991 p->p_flag &= ~P_SA;
1992 }
1993 #endif
1994
1995 /* Make other LWPs stick around long enough to be dumped */
1996 p->p_userret = lwp_coredump_hook;
1997 p->p_userret_arg = NULL;
1998
1999 exitsig = signum;
2000 p->p_acflag |= AXSIG;
2001 if (sigprop[signum] & SA_CORE) {
2002 p->p_sigctx.ps_signo = signum;
2003 if ((error = coredump(l)) == 0)
2004 exitsig |= WCOREFLAG;
2005
2006 if (kern_logsigexit) {
2007 /* XXX What if we ever have really large UIDs? */
2008 int uid = p->p_cred && p->p_ucred ?
2009 (int) p->p_ucred->cr_uid : -1;
2010
2011 if (error)
2012 log(LOG_INFO, lognocoredump, p->p_pid,
2013 p->p_comm, uid, signum, error);
2014 else
2015 log(LOG_INFO, logcoredump, p->p_pid,
2016 p->p_comm, uid, signum);
2017 }
2018
2019 }
2020
2021 exit1(l, W_EXITCODE(0, exitsig));
2022 /* NOTREACHED */
2023 }
2024
2025 /*
2026 * Dump core, into a file named "progname.core" or "core" (depending on the
2027 * value of shortcorename), unless the process was setuid/setgid.
2028 */
2029 int
2030 coredump(struct lwp *l)
2031 {
2032 struct vnode *vp;
2033 struct proc *p;
2034 struct vmspace *vm;
2035 struct ucred *cred;
2036 struct nameidata nd;
2037 struct vattr vattr;
2038 struct mount *mp;
2039 int error, error1;
2040 char name[MAXPATHLEN];
2041
2042 p = l->l_proc;
2043 vm = p->p_vmspace;
2044 cred = p->p_cred->pc_ucred;
2045
2046 /*
2047 * Make sure the process has not set-id, to prevent data leaks.
2048 */
2049 if (p->p_flag & P_SUGID)
2050 return (EPERM);
2051
2052 /*
2053 * Refuse to core if the data + stack + user size is larger than
2054 * the core dump limit. XXX THIS IS WRONG, because of mapped
2055 * data.
2056 */
2057 if (USPACE + ctob(vm->vm_dsize + vm->vm_ssize) >=
2058 p->p_rlimit[RLIMIT_CORE].rlim_cur)
2059 return (EFBIG); /* better error code? */
2060
2061 restart:
2062 /*
2063 * The core dump will go in the current working directory. Make
2064 * sure that the directory is still there and that the mount flags
2065 * allow us to write core dumps there.
2066 */
2067 vp = p->p_cwdi->cwdi_cdir;
2068 if (vp->v_mount == NULL ||
2069 (vp->v_mount->mnt_flag & MNT_NOCOREDUMP) != 0)
2070 return (EPERM);
2071
2072 error = build_corename(p, name);
2073 if (error)
2074 return error;
2075
2076 NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, p);
2077 error = vn_open(&nd, O_CREAT | O_NOFOLLOW | FWRITE, S_IRUSR | S_IWUSR);
2078 if (error)
2079 return (error);
2080 vp = nd.ni_vp;
2081
2082 if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
2083 VOP_UNLOCK(vp, 0);
2084 if ((error = vn_close(vp, FWRITE, cred, p)) != 0)
2085 return (error);
2086 if ((error = vn_start_write(NULL, &mp,
2087 V_WAIT | V_SLEEPONLY | V_PCATCH)) != 0)
2088 return (error);
2089 goto restart;
2090 }
2091
2092 /* Don't dump to non-regular files or files with links. */
2093 if (vp->v_type != VREG ||
2094 VOP_GETATTR(vp, &vattr, cred, p) || vattr.va_nlink != 1) {
2095 error = EINVAL;
2096 goto out;
2097 }
2098 VATTR_NULL(&vattr);
2099 vattr.va_size = 0;
2100 VOP_LEASE(vp, p, cred, LEASE_WRITE);
2101 VOP_SETATTR(vp, &vattr, cred, p);
2102 p->p_acflag |= ACORE;
2103
2104 /* Now dump the actual core file. */
2105 error = (*p->p_execsw->es_coredump)(l, vp, cred);
2106 out:
2107 VOP_UNLOCK(vp, 0);
2108 vn_finished_write(mp, 0);
2109 error1 = vn_close(vp, FWRITE, cred, p);
2110 if (error == 0)
2111 error = error1;
2112 return (error);
2113 }
2114
2115 /*
2116 * Nonexistent system call-- signal process (may want to handle it).
2117 * Flag error in case process won't see signal immediately (blocked or ignored).
2118 */
2119 /* ARGSUSED */
2120 int
2121 sys_nosys(struct lwp *l, void *v, register_t *retval)
2122 {
2123 struct proc *p;
2124
2125 p = l->l_proc;
2126 psignal(p, SIGSYS);
2127 return (ENOSYS);
2128 }
2129
2130 static int
2131 build_corename(struct proc *p, char dst[MAXPATHLEN])
2132 {
2133 const char *s;
2134 char *d, *end;
2135 int i;
2136
2137 for (s = p->p_limit->pl_corename, d = dst, end = d + MAXPATHLEN;
2138 *s != '\0'; s++) {
2139 if (*s == '%') {
2140 switch (*(s + 1)) {
2141 case 'n':
2142 i = snprintf(d, end - d, "%s", p->p_comm);
2143 break;
2144 case 'p':
2145 i = snprintf(d, end - d, "%d", p->p_pid);
2146 break;
2147 case 'u':
2148 i = snprintf(d, end - d, "%.*s",
2149 (int)sizeof p->p_pgrp->pg_session->s_login,
2150 p->p_pgrp->pg_session->s_login);
2151 break;
2152 case 't':
2153 i = snprintf(d, end - d, "%ld",
2154 p->p_stats->p_start.tv_sec);
2155 break;
2156 default:
2157 goto copy;
2158 }
2159 d += i;
2160 s++;
2161 } else {
2162 copy: *d = *s;
2163 d++;
2164 }
2165 if (d >= end)
2166 return (ENAMETOOLONG);
2167 }
2168 *d = '\0';
2169 return 0;
2170 }
2171
2172 void
2173 getucontext(struct lwp *l, ucontext_t *ucp)
2174 {
2175 struct proc *p;
2176
2177 p = l->l_proc;
2178
2179 ucp->uc_flags = 0;
2180 ucp->uc_link = l->l_ctxlink;
2181
2182 (void)sigprocmask1(p, 0, NULL, &ucp->uc_sigmask);
2183 ucp->uc_flags |= _UC_SIGMASK;
2184
2185 /*
2186 * The (unsupplied) definition of the `current execution stack'
2187 * in the System V Interface Definition appears to allow returning
2188 * the main context stack.
2189 */
2190 if ((p->p_sigctx.ps_sigstk.ss_flags & SS_ONSTACK) == 0) {
2191 ucp->uc_stack.ss_sp = (void *)USRSTACK;
2192 ucp->uc_stack.ss_size = ctob(p->p_vmspace->vm_ssize);
2193 ucp->uc_stack.ss_flags = 0; /* XXX, def. is Very Fishy */
2194 } else {
2195 /* Simply copy alternate signal execution stack. */
2196 ucp->uc_stack = p->p_sigctx.ps_sigstk;
2197 }
2198 ucp->uc_flags |= _UC_STACK;
2199
2200 cpu_getmcontext(l, &ucp->uc_mcontext, &ucp->uc_flags);
2201 }
2202
2203 /* ARGSUSED */
2204 int
2205 sys_getcontext(struct lwp *l, void *v, register_t *retval)
2206 {
2207 struct sys_getcontext_args /* {
2208 syscallarg(struct __ucontext *) ucp;
2209 } */ *uap = v;
2210 ucontext_t uc;
2211
2212 getucontext(l, &uc);
2213
2214 return (copyout(&uc, SCARG(uap, ucp), sizeof (*SCARG(uap, ucp))));
2215 }
2216
2217 int
2218 setucontext(struct lwp *l, const ucontext_t *ucp)
2219 {
2220 struct proc *p;
2221 int error;
2222
2223 p = l->l_proc;
2224 if ((error = cpu_setmcontext(l, &ucp->uc_mcontext, ucp->uc_flags)) != 0)
2225 return (error);
2226 l->l_ctxlink = ucp->uc_link;
2227
2228 if ((ucp->uc_flags & _UC_SIGMASK) != 0)
2229 sigprocmask1(p, SIG_SETMASK, &ucp->uc_sigmask, NULL);
2230
2231 /*
2232 * If there was stack information, update whether or not we are
2233 * still running on an alternate signal stack.
2234 */
2235 if ((ucp->uc_flags & _UC_STACK) != 0) {
2236 if (ucp->uc_stack.ss_flags & SS_ONSTACK)
2237 p->p_sigctx.ps_sigstk.ss_flags |= SS_ONSTACK;
2238 else
2239 p->p_sigctx.ps_sigstk.ss_flags &= ~SS_ONSTACK;
2240 }
2241
2242 return 0;
2243 }
2244
2245 /* ARGSUSED */
2246 int
2247 sys_setcontext(struct lwp *l, void *v, register_t *retval)
2248 {
2249 struct sys_setcontext_args /* {
2250 syscallarg(const ucontext_t *) ucp;
2251 } */ *uap = v;
2252 ucontext_t uc;
2253 int error;
2254
2255 if (SCARG(uap, ucp) == NULL) /* i.e. end of uc_link chain */
2256 exit1(l, W_EXITCODE(0, 0));
2257 else if ((error = copyin(SCARG(uap, ucp), &uc, sizeof (uc))) != 0 ||
2258 (error = setucontext(l, &uc)) != 0)
2259 return (error);
2260
2261 return (EJUSTRETURN);
2262 }
2263
2264 /*
2265 * sigtimedwait(2) system call, used also for implementation
2266 * of sigwaitinfo() and sigwait().
2267 *
2268 * This only handles single LWP in signal wait. libpthread provides
2269 * it's own sigtimedwait() wrapper to DTRT WRT individual threads.
2270 */
2271 int
2272 sys___sigtimedwait(struct lwp *l, void *v, register_t *retval)
2273 {
2274 struct sys___sigtimedwait_args /* {
2275 syscallarg(const sigset_t *) set;
2276 syscallarg(siginfo_t *) info;
2277 syscallarg(struct timespec *) timeout;
2278 } */ *uap = v;
2279 sigset_t *waitset, twaitset;
2280 struct proc *p = l->l_proc;
2281 int error, signum, s;
2282 int timo = 0;
2283 struct timeval tvstart;
2284 struct timespec ts;
2285 ksiginfo_t *ksi;
2286
2287 MALLOC(waitset, sigset_t *, sizeof(sigset_t), M_TEMP, M_WAITOK);
2288
2289 if ((error = copyin(SCARG(uap, set), waitset, sizeof(sigset_t)))) {
2290 FREE(waitset, M_TEMP);
2291 return (error);
2292 }
2293
2294 /*
2295 * Silently ignore SA_CANTMASK signals. psignal1() would
2296 * ignore SA_CANTMASK signals in waitset, we do this
2297 * only for the below siglist check.
2298 */
2299 sigminusset(&sigcantmask, waitset);
2300
2301 /*
2302 * First scan siglist and check if there is signal from
2303 * our waitset already pending.
2304 */
2305 twaitset = *waitset;
2306 __sigandset(&p->p_sigctx.ps_siglist, &twaitset);
2307 if ((signum = firstsig(&twaitset))) {
2308 /* found pending signal */
2309 sigdelset(&p->p_sigctx.ps_siglist, signum);
2310 ksi = ksiginfo_get(p, signum);
2311 if (!ksi) {
2312 /* No queued siginfo, manufacture one */
2313 ksi = pool_get(&ksiginfo_pool, PR_WAITOK);
2314 KSI_INIT(ksi);
2315 ksi->ksi_info._signo = signum;
2316 ksi->ksi_info._code = SI_USER;
2317 }
2318
2319 goto sig;
2320 }
2321
2322 /*
2323 * Calculate timeout, if it was specified.
2324 */
2325 if (SCARG(uap, timeout)) {
2326 uint64_t ms;
2327
2328 if ((error = copyin(SCARG(uap, timeout), &ts, sizeof(ts))))
2329 return (error);
2330
2331 ms = (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
2332 timo = mstohz(ms);
2333 if (timo == 0 && ts.tv_sec == 0 && ts.tv_nsec > 0)
2334 timo = 1;
2335 if (timo <= 0)
2336 return (EAGAIN);
2337
2338 /*
2339 * Remember current mono_time, it would be used in
2340 * ECANCELED/ERESTART case.
2341 */
2342 s = splclock();
2343 tvstart = mono_time;
2344 splx(s);
2345 }
2346
2347 /*
2348 * Setup ps_sigwait list. Pass pointer to malloced memory
2349 * here; it's not possible to pass pointer to a structure
2350 * on current process's stack, the current process might
2351 * be swapped out at the time the signal would get delivered.
2352 */
2353 ksi = pool_get(&ksiginfo_pool, PR_WAITOK);
2354 p->p_sigctx.ps_sigwaited = ksi;
2355 p->p_sigctx.ps_sigwait = waitset;
2356
2357 /*
2358 * Wait for signal to arrive. We can either be woken up or
2359 * time out.
2360 */
2361 error = tsleep(&p->p_sigctx.ps_sigwait, PPAUSE|PCATCH, "sigwait", timo);
2362
2363 /*
2364 * Need to find out if we woke as a result of lwp_wakeup()
2365 * or a signal outside our wait set.
2366 */
2367 if (error == EINTR && p->p_sigctx.ps_sigwaited
2368 && !firstsig(&p->p_sigctx.ps_siglist)) {
2369 /* wakeup via _lwp_wakeup() */
2370 error = ECANCELED;
2371 } else if (!error && p->p_sigctx.ps_sigwaited) {
2372 /* spurious wakeup - arrange for syscall restart */
2373 error = ERESTART;
2374 goto fail;
2375 }
2376
2377 /*
2378 * On error, clear sigwait indication. psignal1() clears it
2379 * in !error case.
2380 */
2381 if (error) {
2382 p->p_sigctx.ps_sigwaited = NULL;
2383
2384 /*
2385 * If the sleep was interrupted (either by signal or wakeup),
2386 * update the timeout and copyout new value back.
2387 * It would be used when the syscall would be restarted
2388 * or called again.
2389 */
2390 if (timo && (error == ERESTART || error == ECANCELED)) {
2391 struct timeval tvnow, tvtimo;
2392 int err;
2393
2394 s = splclock();
2395 tvnow = mono_time;
2396 splx(s);
2397
2398 TIMESPEC_TO_TIMEVAL(&tvtimo, &ts);
2399
2400 /* compute how much time has passed since start */
2401 timersub(&tvnow, &tvstart, &tvnow);
2402 /* substract passed time from timeout */
2403 timersub(&tvtimo, &tvnow, &tvtimo);
2404
2405 if (tvtimo.tv_sec < 0) {
2406 error = EAGAIN;
2407 goto fail;
2408 }
2409
2410 TIMEVAL_TO_TIMESPEC(&tvtimo, &ts);
2411
2412 /* copy updated timeout to userland */
2413 if ((err = copyout(&ts, SCARG(uap, timeout), sizeof(ts)))) {
2414 error = err;
2415 goto fail;
2416 }
2417 }
2418
2419 goto fail;
2420 }
2421
2422 /*
2423 * If a signal from the wait set arrived, copy it to userland.
2424 * Copy only the used part of siginfo, the padding part is
2425 * left unchanged (userland is not supposed to touch it anyway).
2426 */
2427 sig:
2428 error = copyout(&ksi->ksi_info, SCARG(uap, info), sizeof(ksi->ksi_info));
2429
2430 fail:
2431 FREE(waitset, M_TEMP);
2432 pool_put(&ksiginfo_pool, ksi);
2433 p->p_sigctx.ps_sigwait = NULL;
2434
2435 return (error);
2436 }
2437
2438 /*
2439 * Returns true if signal is ignored or masked for passed process.
2440 */
2441 int
2442 sigismasked(struct proc *p, int sig)
2443 {
2444
2445 return (sigismember(&p->p_sigctx.ps_sigignore, sig) ||
2446 sigismember(&p->p_sigctx.ps_sigmask, sig));
2447 }
2448
2449 static int
2450 filt_sigattach(struct knote *kn)
2451 {
2452 struct proc *p = curproc;
2453
2454 kn->kn_ptr.p_proc = p;
2455 kn->kn_flags |= EV_CLEAR; /* automatically set */
2456
2457 SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext);
2458
2459 return (0);
2460 }
2461
2462 static void
2463 filt_sigdetach(struct knote *kn)
2464 {
2465 struct proc *p = kn->kn_ptr.p_proc;
2466
2467 SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext);
2468 }
2469
2470 /*
2471 * signal knotes are shared with proc knotes, so we apply a mask to
2472 * the hint in order to differentiate them from process hints. This
2473 * could be avoided by using a signal-specific knote list, but probably
2474 * isn't worth the trouble.
2475 */
2476 static int
2477 filt_signal(struct knote *kn, long hint)
2478 {
2479
2480 if (hint & NOTE_SIGNAL) {
2481 hint &= ~NOTE_SIGNAL;
2482
2483 if (kn->kn_id == hint)
2484 kn->kn_data++;
2485 }
2486 return (kn->kn_data != 0);
2487 }
2488
2489 const struct filterops sig_filtops = {
2490 0, filt_sigattach, filt_sigdetach, filt_signal
2491 };
Cache object: a5833f81fbd90098f95f5f6c98056fe1
|