1 /*
2 * Copyright (c) 1982, 1986, 1989, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
9 *
10 * %sccs.include.redist.c%
11 *
12 * @(#)kern_sig.c 8.14 (Berkeley) 05/14/95
13 */
14
15 #define SIGPROP /* include signal properties table */
16 #include <sys/param.h>
17 #include <sys/signalvar.h>
18 #include <sys/resourcevar.h>
19 #include <sys/namei.h>
20 #include <sys/vnode.h>
21 #include <sys/proc.h>
22 #include <sys/systm.h>
23 #include <sys/timeb.h>
24 #include <sys/times.h>
25 #include <sys/buf.h>
26 #include <sys/acct.h>
27 #include <sys/file.h>
28 #include <sys/kernel.h>
29 #include <sys/wait.h>
30 #include <sys/ktrace.h>
31 #include <sys/syslog.h>
32 #include <sys/stat.h>
33
34 #include <sys/mount.h>
35 #include <sys/syscallargs.h>
36
37 #include <machine/cpu.h>
38
39 #include <vm/vm.h>
40 #include <sys/user.h> /* for coredump */
41
42 void stop __P((struct proc *p));
43
44 /*
45 * Can process p, with pcred pc, send the signal signum to process q?
46 */
47 #define CANSIGNAL(p, pc, q, signum) \
48 ((pc)->pc_ucred->cr_uid == 0 || \
49 (pc)->p_ruid == (q)->p_cred->p_ruid || \
50 (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \
51 (pc)->p_ruid == (q)->p_ucred->cr_uid || \
52 (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \
53 ((signum) == SIGCONT && (q)->p_session == (p)->p_session))
54
55 /* ARGSUSED */
56 int
sigaction(p,uap,retval)57 sigaction(p, uap, retval)
58 struct proc *p;
59 register struct sigaction_args /* {
60 syscallarg(int) signum;
61 syscallarg(struct sigaction *) nsa;
62 syscallarg(struct sigaction *) osa;
63 } */ *uap;
64 register_t *retval;
65 {
66 struct sigaction vec;
67 register struct sigaction *sa;
68 register struct sigacts *ps = p->p_sigacts;
69 register int signum;
70 int bit, error;
71
72 signum = SCARG(uap, signum);
73 if (signum <= 0 || signum >= NSIG ||
74 signum == SIGKILL || signum == SIGSTOP)
75 return (EINVAL);
76 sa = &vec;
77 if (SCARG(uap, osa)) {
78 sa->sa_handler = ps->ps_sigact[signum];
79 sa->sa_mask = ps->ps_catchmask[signum];
80 bit = sigmask(signum);
81 sa->sa_flags = 0;
82 if ((ps->ps_sigonstack & bit) != 0)
83 sa->sa_flags |= SA_ONSTACK;
84 if ((ps->ps_sigintr & bit) == 0)
85 sa->sa_flags |= SA_RESTART;
86 if (p->p_flag & P_NOCLDSTOP)
87 sa->sa_flags |= SA_NOCLDSTOP;
88 if (error = copyout((caddr_t)sa, (caddr_t)SCARG(uap, osa),
89 sizeof (vec)))
90 return (error);
91 }
92 if (SCARG(uap, nsa)) {
93 if (error = copyin((caddr_t)SCARG(uap, nsa), (caddr_t)sa,
94 sizeof (vec)))
95 return (error);
96 setsigvec(p, signum, sa);
97 }
98 return (0);
99 }
100
101 void
setsigvec(p,signum,sa)102 setsigvec(p, signum, sa)
103 register struct proc *p;
104 int signum;
105 register struct sigaction *sa;
106 {
107 register struct sigacts *ps = p->p_sigacts;
108 register int bit;
109
110 bit = sigmask(signum);
111 /*
112 * Change setting atomically.
113 */
114 (void) splhigh();
115 ps->ps_sigact[signum] = sa->sa_handler;
116 ps->ps_catchmask[signum] = sa->sa_mask &~ sigcantmask;
117 if ((sa->sa_flags & SA_RESTART) == 0)
118 ps->ps_sigintr |= bit;
119 else
120 ps->ps_sigintr &= ~bit;
121 if (sa->sa_flags & SA_ONSTACK)
122 ps->ps_sigonstack |= bit;
123 else
124 ps->ps_sigonstack &= ~bit;
125 #ifdef COMPAT_SUNOS
126 if (sa->sa_flags & SA_USERTRAMP)
127 ps->ps_usertramp |= bit;
128 else
129 ps->ps_usertramp &= ~bit;
130 #endif
131 if (signum == SIGCHLD) {
132 if (sa->sa_flags & SA_NOCLDSTOP)
133 p->p_flag |= P_NOCLDSTOP;
134 else
135 p->p_flag &= ~P_NOCLDSTOP;
136 }
137 /*
138 * Set bit in p_sigignore for signals that are set to SIG_IGN,
139 * and for signals set to SIG_DFL where the default is to ignore.
140 * However, don't put SIGCONT in p_sigignore,
141 * as we have to restart the process.
142 */
143 if (sa->sa_handler == SIG_IGN ||
144 (sigprop[signum] & SA_IGNORE && sa->sa_handler == SIG_DFL)) {
145 p->p_siglist &= ~bit; /* never to be seen again */
146 if (signum != SIGCONT)
147 p->p_sigignore |= bit; /* easier in psignal */
148 p->p_sigcatch &= ~bit;
149 } else {
150 p->p_sigignore &= ~bit;
151 if (sa->sa_handler == SIG_DFL)
152 p->p_sigcatch &= ~bit;
153 else
154 p->p_sigcatch |= bit;
155 }
156 (void) spl0();
157 }
158
159 /*
160 * Initialize signal state for process 0;
161 * set to ignore signals that are ignored by default.
162 */
163 void
siginit(p)164 siginit(p)
165 struct proc *p;
166 {
167 register int i;
168
169 for (i = 0; i < NSIG; i++)
170 if (sigprop[i] & SA_IGNORE && i != SIGCONT)
171 p->p_sigignore |= sigmask(i);
172 }
173
174 /*
175 * Reset signals for an exec of the specified process.
176 */
177 void
execsigs(p)178 execsigs(p)
179 register struct proc *p;
180 {
181 register struct sigacts *ps = p->p_sigacts;
182 register int nc, mask;
183
184 /*
185 * Reset caught signals. Held signals remain held
186 * through p_sigmask (unless they were caught,
187 * and are now ignored by default).
188 */
189 while (p->p_sigcatch) {
190 nc = ffs((long)p->p_sigcatch);
191 mask = sigmask(nc);
192 p->p_sigcatch &= ~mask;
193 if (sigprop[nc] & SA_IGNORE) {
194 if (nc != SIGCONT)
195 p->p_sigignore |= mask;
196 p->p_siglist &= ~mask;
197 }
198 ps->ps_sigact[nc] = SIG_DFL;
199 }
200 /*
201 * Reset stack state to the user stack.
202 * Clear set of signals caught on the signal stack.
203 */
204 ps->ps_sigstk.ss_flags = SA_DISABLE;
205 ps->ps_sigstk.ss_size = 0;
206 ps->ps_sigstk.ss_base = 0;
207 ps->ps_flags = 0;
208 }
209
210 /*
211 * Manipulate signal mask.
212 * Note that we receive new mask, not pointer,
213 * and return old mask as return value;
214 * the library stub does the rest.
215 */
216 int
sigprocmask(p,uap,retval)217 sigprocmask(p, uap, retval)
218 register struct proc *p;
219 struct sigprocmask_args /* {
220 syscallarg(int) how;
221 syscallarg(sigset_t) mask;
222 } */ *uap;
223 register_t *retval;
224 {
225 int error = 0;
226
227 *retval = p->p_sigmask;
228 (void) splhigh();
229
230 switch (SCARG(uap, how)) {
231 case SIG_BLOCK:
232 p->p_sigmask |= SCARG(uap, mask) &~ sigcantmask;
233 break;
234
235 case SIG_UNBLOCK:
236 p->p_sigmask &= ~SCARG(uap, mask);
237 break;
238
239 case SIG_SETMASK:
240 p->p_sigmask = SCARG(uap, mask) &~ sigcantmask;
241 break;
242
243 default:
244 error = EINVAL;
245 break;
246 }
247 (void) spl0();
248 return (error);
249 }
250
251 /* ARGSUSED */
252 int
sigpending(p,uap,retval)253 sigpending(p, uap, retval)
254 struct proc *p;
255 void *uap;
256 register_t *retval;
257 {
258
259 *retval = p->p_siglist;
260 return (0);
261 }
262
263 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
264 /*
265 * Generalized interface signal handler, 4.3-compatible.
266 */
267 /* ARGSUSED */
268 int
compat_43_sigvec(p,uap,retval)269 compat_43_sigvec(p, uap, retval)
270 struct proc *p;
271 register struct compat_43_sigvec_args /* {
272 syscallarg(int) signum;
273 syscallarg(struct sigvec *) nsv;
274 syscallarg(struct sigvec *) osv;
275 } */ *uap;
276 register_t *retval;
277 {
278 struct sigvec vec;
279 register struct sigacts *ps = p->p_sigacts;
280 register struct sigvec *sv;
281 register int signum;
282 int bit, error;
283
284 signum = SCARG(uap, signum);
285 if (signum <= 0 || signum >= NSIG ||
286 signum == SIGKILL || signum == SIGSTOP)
287 return (EINVAL);
288 sv = &vec;
289 if (SCARG(uap, osv)) {
290 *(sig_t *)&sv->sv_handler = ps->ps_sigact[signum];
291 sv->sv_mask = ps->ps_catchmask[signum];
292 bit = sigmask(signum);
293 sv->sv_flags = 0;
294 if ((ps->ps_sigonstack & bit) != 0)
295 sv->sv_flags |= SV_ONSTACK;
296 if ((ps->ps_sigintr & bit) != 0)
297 sv->sv_flags |= SV_INTERRUPT;
298 #ifndef COMPAT_SUNOS
299 if (p->p_flag & P_NOCLDSTOP)
300 sv->sv_flags |= SA_NOCLDSTOP;
301 #endif
302 if (error = copyout((caddr_t)sv, (caddr_t)SCARG(uap, osv),
303 sizeof (vec)))
304 return (error);
305 }
306 if (SCARG(uap, nsv)) {
307 if (error = copyin((caddr_t)SCARG(uap, nsv), (caddr_t)sv,
308 sizeof (vec)))
309 return (error);
310 #ifdef COMPAT_SUNOS
311 /*
312 * SunOS uses this bit (4, aka SA_DISABLE) as SV_RESETHAND,
313 * `reset to SIG_DFL on delivery'. We have no such option
314 * now or ever!
315 */
316 if (sv->sv_flags & SA_DISABLE)
317 return (EINVAL);
318 sv->sv_flags |= SA_USERTRAMP;
319 #endif
320 sv->sv_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */
321 setsigvec(p, signum, (struct sigaction *)sv);
322 }
323 return (0);
324 }
325
326 int
compat_43_sigblock(p,uap,retval)327 compat_43_sigblock(p, uap, retval)
328 register struct proc *p;
329 struct compat_43_sigblock_args /* {
330 syscallarg(int) mask;
331 } */ *uap;
332 register_t *retval;
333 {
334
335 (void) splhigh();
336 *retval = p->p_sigmask;
337 p->p_sigmask |= SCARG(uap, mask) &~ sigcantmask;
338 (void) spl0();
339 return (0);
340 }
341
342 int
compat_43_sigsetmask(p,uap,retval)343 compat_43_sigsetmask(p, uap, retval)
344 struct proc *p;
345 struct compat_43_sigsetmask_args /* {
346 syscallarg(int) mask;
347 } */ *uap;
348 register_t *retval;
349 {
350
351 (void) splhigh();
352 *retval = p->p_sigmask;
353 p->p_sigmask = SCARG(uap, mask) &~ sigcantmask;
354 (void) spl0();
355 return (0);
356 }
357 #endif /* COMPAT_43 || COMPAT_SUNOS */
358
359 /*
360 * Suspend process until signal, providing mask to be set
361 * in the meantime. Note nonstandard calling convention:
362 * libc stub passes mask, not pointer, to save a copyin.
363 */
364 /* ARGSUSED */
365 int
sigsuspend(p,uap,retval)366 sigsuspend(p, uap, retval)
367 register struct proc *p;
368 struct sigsuspend_args /* {
369 syscallarg(int) mask;
370 } */ *uap;
371 register_t *retval;
372 {
373 register struct sigacts *ps = p->p_sigacts;
374
375 /*
376 * When returning from sigpause, we want
377 * the old mask to be restored after the
378 * signal handler has finished. Thus, we
379 * save it here and mark the sigacts structure
380 * to indicate this.
381 */
382 ps->ps_oldmask = p->p_sigmask;
383 ps->ps_flags |= SAS_OLDMASK;
384 p->p_sigmask = SCARG(uap, mask) &~ sigcantmask;
385 while (tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0) == 0)
386 /* void */;
387 /* always return EINTR rather than ERESTART... */
388 return (EINTR);
389 }
390
391 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
392 /* ARGSUSED */
393 int
compat_43_sigstack(p,uap,retval)394 compat_43_sigstack(p, uap, retval)
395 struct proc *p;
396 register struct compat_43_sigstack_args /* {
397 syscallarg(struct sigstack *) nss;
398 syscallarg(struct sigstack *) oss;
399 } */ *uap;
400 register_t *retval;
401 {
402 struct sigstack ss;
403 struct sigacts *psp;
404 int error = 0;
405
406 psp = p->p_sigacts;
407 ss.ss_sp = psp->ps_sigstk.ss_base;
408 ss.ss_onstack = psp->ps_sigstk.ss_flags & SA_ONSTACK;
409 if (SCARG(uap, oss) && (error = copyout((caddr_t)&ss,
410 (caddr_t)SCARG(uap, oss), sizeof (struct sigstack))))
411 return (error);
412 if (SCARG(uap, nss) && (error = copyin((caddr_t)SCARG(uap, nss),
413 (caddr_t)&ss, sizeof (ss))) == 0) {
414 psp->ps_sigstk.ss_base = ss.ss_sp;
415 psp->ps_sigstk.ss_size = 0;
416 psp->ps_sigstk.ss_flags |= ss.ss_onstack & SA_ONSTACK;
417 psp->ps_flags |= SAS_ALTSTACK;
418 }
419 return (error);
420 }
421 #endif /* COMPAT_43 || COMPAT_SUNOS */
422
423 /* ARGSUSED */
424 int
sigaltstack(p,uap,retval)425 sigaltstack(p, uap, retval)
426 struct proc *p;
427 register struct sigaltstack_args /* {
428 syscallarg(struct sigaltstack *) nss;
429 syscallarg(struct sigaltstack *) oss;
430 } */ *uap;
431 register_t *retval;
432 {
433 struct sigacts *psp;
434 struct sigaltstack ss;
435 int error;
436
437 psp = p->p_sigacts;
438 if ((psp->ps_flags & SAS_ALTSTACK) == 0)
439 psp->ps_sigstk.ss_flags |= SA_DISABLE;
440 if (SCARG(uap, oss) && (error = copyout((caddr_t)&psp->ps_sigstk,
441 (caddr_t)SCARG(uap, oss), sizeof (struct sigaltstack))))
442 return (error);
443 if (SCARG(uap, nss) == 0)
444 return (0);
445 if (error = copyin((caddr_t)SCARG(uap, nss), (caddr_t)&ss,
446 sizeof (ss)))
447 return (error);
448 if (ss.ss_flags & SA_DISABLE) {
449 if (psp->ps_sigstk.ss_flags & SA_ONSTACK)
450 return (EINVAL);
451 psp->ps_flags &= ~SAS_ALTSTACK;
452 psp->ps_sigstk.ss_flags = ss.ss_flags;
453 return (0);
454 }
455 if (ss.ss_size < MINSIGSTKSZ)
456 return (ENOMEM);
457 psp->ps_flags |= SAS_ALTSTACK;
458 psp->ps_sigstk= ss;
459 return (0);
460 }
461
462 /* ARGSUSED */
463 int
kill(cp,uap,retval)464 kill(cp, uap, retval)
465 register struct proc *cp;
466 register struct kill_args /* {
467 syscallarg(int) pid;
468 syscallarg(int) signum;
469 } */ *uap;
470 register_t *retval;
471 {
472 register struct proc *p;
473 register struct pcred *pc = cp->p_cred;
474
475 if ((u_int)SCARG(uap, signum) >= NSIG)
476 return (EINVAL);
477 if (SCARG(uap, pid) > 0) {
478 /* kill single process */
479 if ((p = pfind(SCARG(uap, pid))) == NULL)
480 return (ESRCH);
481 if (!CANSIGNAL(cp, pc, p, SCARG(uap, signum)))
482 return (EPERM);
483 if (SCARG(uap, signum))
484 psignal(p, SCARG(uap, signum));
485 return (0);
486 }
487 switch (SCARG(uap, pid)) {
488 case -1: /* broadcast signal */
489 return (killpg1(cp, SCARG(uap, signum), 0, 1));
490 case 0: /* signal own process group */
491 return (killpg1(cp, SCARG(uap, signum), 0, 0));
492 default: /* negative explicit process group */
493 return (killpg1(cp, SCARG(uap, signum), -SCARG(uap, pid), 0));
494 }
495 /* NOTREACHED */
496 }
497
498 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
499 /* ARGSUSED */
500 int
compat_43_killpg(p,uap,retval)501 compat_43_killpg(p, uap, retval)
502 struct proc *p;
503 register struct compat_43_killpg_args /* {
504 syscallarg(int) pgid;
505 syscallarg(int) signum;
506 } */ *uap;
507 register_t *retval;
508 {
509
510 if ((u_int)SCARG(uap, signum) >= NSIG)
511 return (EINVAL);
512 return (killpg1(p, SCARG(uap, signum), SCARG(uap, pgid), 0));
513 }
514 #endif /* COMPAT_43 || COMPAT_SUNOS */
515
516 /*
517 * Common code for kill process group/broadcast kill.
518 * cp is calling process.
519 */
520 int
killpg1(cp,signum,pgid,all)521 killpg1(cp, signum, pgid, all)
522 register struct proc *cp;
523 int signum, pgid, all;
524 {
525 register struct proc *p;
526 register struct pcred *pc = cp->p_cred;
527 struct pgrp *pgrp;
528 int nfound = 0;
529
530 if (all)
531 /*
532 * broadcast
533 */
534 for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
535 if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
536 p == cp || !CANSIGNAL(cp, pc, p, signum))
537 continue;
538 nfound++;
539 if (signum)
540 psignal(p, signum);
541 }
542 else {
543 if (pgid == 0)
544 /*
545 * zero pgid means send to my process group.
546 */
547 pgrp = cp->p_pgrp;
548 else {
549 pgrp = pgfind(pgid);
550 if (pgrp == NULL)
551 return (ESRCH);
552 }
553 for (p = pgrp->pg_members.lh_first; p != 0;
554 p = p->p_pglist.le_next) {
555 if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
556 p->p_stat == SZOMB ||
557 !CANSIGNAL(cp, pc, p, signum))
558 continue;
559 nfound++;
560 if (signum)
561 psignal(p, signum);
562 }
563 }
564 return (nfound ? 0 : ESRCH);
565 }
566
567 /*
568 * Send a signal to a process group.
569 */
570 void
gsignal(pgid,signum)571 gsignal(pgid, signum)
572 int pgid, signum;
573 {
574 struct pgrp *pgrp;
575
576 if (pgid && (pgrp = pgfind(pgid)))
577 pgsignal(pgrp, signum, 0);
578 }
579
580 /*
581 * Send a signal to a process group. If checktty is 1,
582 * limit to members which have a controlling terminal.
583 */
584 void
pgsignal(pgrp,signum,checkctty)585 pgsignal(pgrp, signum, checkctty)
586 struct pgrp *pgrp;
587 int signum, checkctty;
588 {
589 register struct proc *p;
590
591 if (pgrp)
592 for (p = pgrp->pg_members.lh_first; p != 0;
593 p = p->p_pglist.le_next)
594 if (checkctty == 0 || p->p_flag & P_CONTROLT)
595 psignal(p, signum);
596 }
597
598 /*
599 * Send a signal caused by a trap to the current process.
600 * If it will be caught immediately, deliver it with correct code.
601 * Otherwise, post it normally.
602 */
603 void
trapsignal(p,signum,code)604 trapsignal(p, signum, code)
605 struct proc *p;
606 register int signum;
607 u_long code;
608 {
609 register struct sigacts *ps = p->p_sigacts;
610 int mask;
611
612 mask = sigmask(signum);
613 if ((p->p_flag & P_TRACED) == 0 && (p->p_sigcatch & mask) != 0 &&
614 (p->p_sigmask & mask) == 0) {
615 p->p_stats->p_ru.ru_nsignals++;
616 #ifdef KTRACE
617 if (KTRPOINT(p, KTR_PSIG))
618 ktrpsig(p->p_tracep, signum, ps->ps_sigact[signum],
619 p->p_sigmask, code);
620 #endif
621 sendsig(ps->ps_sigact[signum], signum, p->p_sigmask, code);
622 p->p_sigmask |= ps->ps_catchmask[signum] | mask;
623 } else {
624 ps->ps_code = code; /* XXX for core dump/debugger */
625 ps->ps_sig = signum; /* XXX to verify code */
626 psignal(p, signum);
627 }
628 }
629
630 /*
631 * Send the signal to the process. If the signal has an action, the action
632 * is usually performed by the target process rather than the caller; we add
633 * the signal to the set of pending signals for the process.
634 *
635 * Exceptions:
636 * o When a stop signal is sent to a sleeping process that takes the
637 * default action, the process is stopped without awakening it.
638 * o SIGCONT restarts stopped processes (or puts them back to sleep)
639 * regardless of the signal action (eg, blocked or ignored).
640 *
641 * Other ignored signals are discarded immediately.
642 */
643 void
psignal(p,signum)644 psignal(p, signum)
645 register struct proc *p;
646 register int signum;
647 {
648 register int s, prop;
649 register sig_t action;
650 int mask;
651
652 if ((u_int)signum >= NSIG || signum == 0)
653 panic("psignal signal number");
654 mask = sigmask(signum);
655 prop = sigprop[signum];
656
657 /*
658 * If proc is traced, always give parent a chance.
659 */
660 if (p->p_flag & P_TRACED)
661 action = SIG_DFL;
662 else {
663 /*
664 * If the signal is being ignored,
665 * then we forget about it immediately.
666 * (Note: we don't set SIGCONT in p_sigignore,
667 * and if it is set to SIG_IGN,
668 * action will be SIG_DFL here.)
669 */
670 if (p->p_sigignore & mask)
671 return;
672 if (p->p_sigmask & mask)
673 action = SIG_HOLD;
674 else if (p->p_sigcatch & mask)
675 action = SIG_CATCH;
676 else
677 action = SIG_DFL;
678 }
679
680 if (p->p_nice > NZERO && action == SIG_DFL && (prop & SA_KILL) &&
681 (p->p_flag & P_TRACED) == 0)
682 p->p_nice = NZERO;
683
684 if (prop & SA_CONT)
685 p->p_siglist &= ~stopsigmask;
686
687 if (prop & SA_STOP) {
688 /*
689 * If sending a tty stop signal to a member of an orphaned
690 * process group, discard the signal here if the action
691 * is default; don't stop the process below if sleeping,
692 * and don't clear any pending SIGCONT.
693 */
694 if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0 &&
695 action == SIG_DFL)
696 return;
697 p->p_siglist &= ~contsigmask;
698 }
699 p->p_siglist |= mask;
700
701 /*
702 * Defer further processing for signals which are held,
703 * except that stopped processes must be continued by SIGCONT.
704 */
705 if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP))
706 return;
707 s = splhigh();
708 switch (p->p_stat) {
709
710 case SSLEEP:
711 /*
712 * If process is sleeping uninterruptibly
713 * we can't interrupt the sleep... the signal will
714 * be noticed when the process returns through
715 * trap() or syscall().
716 */
717 if ((p->p_flag & P_SINTR) == 0)
718 goto out;
719 /*
720 * Process is sleeping and traced... make it runnable
721 * so it can discover the signal in issignal() and stop
722 * for the parent.
723 */
724 if (p->p_flag & P_TRACED)
725 goto run;
726 /*
727 * If SIGCONT is default (or ignored) and process is
728 * asleep, we are finished; the process should not
729 * be awakened.
730 */
731 if ((prop & SA_CONT) && action == SIG_DFL) {
732 p->p_siglist &= ~mask;
733 goto out;
734 }
735 /*
736 * When a sleeping process receives a stop
737 * signal, process immediately if possible.
738 * All other (caught or default) signals
739 * cause the process to run.
740 */
741 if (prop & SA_STOP) {
742 if (action != SIG_DFL)
743 goto runfast;
744 /*
745 * If a child holding parent blocked,
746 * stopping could cause deadlock.
747 */
748 if (p->p_flag & P_PPWAIT)
749 goto out;
750 p->p_siglist &= ~mask;
751 p->p_xstat = signum;
752 if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
753 psignal(p->p_pptr, SIGCHLD);
754 stop(p);
755 goto out;
756 } else
757 goto runfast;
758 /*NOTREACHED*/
759
760 case SSTOP:
761 /*
762 * If traced process is already stopped,
763 * then no further action is necessary.
764 */
765 if (p->p_flag & P_TRACED)
766 goto out;
767
768 /*
769 * Kill signal always sets processes running.
770 */
771 if (signum == SIGKILL)
772 goto runfast;
773
774 if (prop & SA_CONT) {
775 /*
776 * If SIGCONT is default (or ignored), we continue the
777 * process but don't leave the signal in p_siglist, as
778 * it has no further action. If SIGCONT is held, we
779 * continue the process and leave the signal in
780 * p_siglist. If the process catches SIGCONT, let it
781 * handle the signal itself. If it isn't waiting on
782 * an event, then it goes back to run state.
783 * Otherwise, process goes back to sleep state.
784 */
785 if (action == SIG_DFL)
786 p->p_siglist &= ~mask;
787 if (action == SIG_CATCH)
788 goto runfast;
789 if (p->p_wchan == 0)
790 goto run;
791 p->p_stat = SSLEEP;
792 goto out;
793 }
794
795 if (prop & SA_STOP) {
796 /*
797 * Already stopped, don't need to stop again.
798 * (If we did the shell could get confused.)
799 */
800 p->p_siglist &= ~mask; /* take it away */
801 goto out;
802 }
803
804 /*
805 * If process is sleeping interruptibly, then simulate a
806 * wakeup so that when it is continued, it will be made
807 * runnable and can look at the signal. But don't make
808 * the process runnable, leave it stopped.
809 */
810 if (p->p_wchan && p->p_flag & P_SINTR)
811 unsleep(p);
812 goto out;
813
814 default:
815 /*
816 * SRUN, SIDL, SZOMB do nothing with the signal,
817 * other than kicking ourselves if we are running.
818 * It will either never be noticed, or noticed very soon.
819 */
820 if (p == curproc)
821 signotify(p);
822 goto out;
823 }
824 /*NOTREACHED*/
825
826 runfast:
827 /*
828 * Raise priority to at least PUSER.
829 */
830 if (p->p_priority > PUSER)
831 p->p_priority = PUSER;
832 run:
833 setrunnable(p);
834 out:
835 splx(s);
836 }
837
838 /*
839 * If the current process has received a signal (should be caught or cause
840 * termination, should interrupt current syscall), return the signal number.
841 * Stop signals with default action are processed immediately, then cleared;
842 * they aren't returned. This is checked after each entry to the system for
843 * a syscall or trap (though this can usually be done without calling issignal
844 * by checking the pending signal masks in the CURSIG macro.) The normal call
845 * sequence is
846 *
847 * while (signum = CURSIG(curproc))
848 * postsig(signum);
849 */
850 int
issignal(p)851 issignal(p)
852 register struct proc *p;
853 {
854 register int signum, mask, prop;
855
856 for (;;) {
857 mask = p->p_siglist & ~p->p_sigmask;
858 if (p->p_flag & P_PPWAIT)
859 mask &= ~stopsigmask;
860 if (mask == 0) /* no signal to send */
861 return (0);
862 signum = ffs((long)mask);
863 mask = sigmask(signum);
864 prop = sigprop[signum];
865 /*
866 * We should see pending but ignored signals
867 * only if P_TRACED was on when they were posted.
868 */
869 if (mask & p->p_sigignore && (p->p_flag & P_TRACED) == 0) {
870 p->p_siglist &= ~mask;
871 continue;
872 }
873 if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) {
874 /*
875 * If traced, always stop, and stay
876 * stopped until released by the parent.
877 *
878 * Note that we must clear the pending signal
879 * before we call trace_req since that routine
880 * might cause a fault, calling tsleep and
881 * leading us back here again with the same signal.
882 * Then we would be deadlocked because the tracer
883 * would still be blocked on the ipc struct from
884 * the initial request.
885 */
886 p->p_xstat = signum;
887 p->p_siglist &= ~mask;
888 psignal(p->p_pptr, SIGCHLD);
889 do {
890 stop(p);
891 mi_switch();
892 } while (!trace_req(p) && p->p_flag & P_TRACED);
893
894 /*
895 * If parent wants us to take the signal,
896 * then it will leave it in p->p_xstat;
897 * otherwise we just look for signals again.
898 */
899 signum = p->p_xstat;
900 if (signum == 0)
901 continue;
902
903 /*
904 * Put the new signal into p_siglist. If the
905 * signal is being masked, look for other signals.
906 */
907 mask = sigmask(signum);
908 p->p_siglist |= mask;
909 if (p->p_sigmask & mask)
910 continue;
911
912 /*
913 * If the traced bit got turned off, go back up
914 * to the top to rescan signals. This ensures
915 * that p_sig* and ps_sigact are consistent.
916 */
917 if ((p->p_flag & P_TRACED) == 0)
918 continue;
919 }
920
921 /*
922 * Decide whether the signal should be returned.
923 * Return the signal's number, or fall through
924 * to clear it from the pending mask.
925 */
926 switch ((long)p->p_sigacts->ps_sigact[signum]) {
927
928 case (long)SIG_DFL:
929 /*
930 * Don't take default actions on system processes.
931 */
932 if (p->p_pid <= 1) {
933 #ifdef DIAGNOSTIC
934 /*
935 * Are you sure you want to ignore SIGSEGV
936 * in init? XXX
937 */
938 printf("Process (pid %d) got signal %d\n",
939 p->p_pid, signum);
940 #endif
941 break; /* == ignore */
942 }
943 /*
944 * If there is a pending stop signal to process
945 * with default action, stop here,
946 * then clear the signal. However,
947 * if process is member of an orphaned
948 * process group, ignore tty stop signals.
949 */
950 if (prop & SA_STOP) {
951 if (p->p_flag & P_TRACED ||
952 (p->p_pgrp->pg_jobc == 0 &&
953 prop & SA_TTYSTOP))
954 break; /* == ignore */
955 p->p_xstat = signum;
956 stop(p);
957 if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
958 psignal(p->p_pptr, SIGCHLD);
959 mi_switch();
960 break;
961 } else if (prop & SA_IGNORE) {
962 /*
963 * Except for SIGCONT, shouldn't get here.
964 * Default action is to ignore; drop it.
965 */
966 break; /* == ignore */
967 } else
968 return (signum);
969 /*NOTREACHED*/
970
971 case (long)SIG_IGN:
972 /*
973 * Masking above should prevent us ever trying
974 * to take action on an ignored signal other
975 * than SIGCONT, unless process is traced.
976 */
977 if ((prop & SA_CONT) == 0 &&
978 (p->p_flag & P_TRACED) == 0)
979 printf("issignal\n");
980 break; /* == ignore */
981
982 default:
983 /*
984 * This signal has an action, let
985 * postsig() process it.
986 */
987 return (signum);
988 }
989 p->p_siglist &= ~mask; /* take the signal! */
990 }
991 /* NOTREACHED */
992 }
993
994 /*
995 * Put the argument process into the stopped state and notify the parent
996 * via wakeup. Signals are handled elsewhere. The process must not be
997 * on the run queue.
998 */
999 void
stop(p)1000 stop(p)
1001 register struct proc *p;
1002 {
1003
1004 p->p_stat = SSTOP;
1005 p->p_flag &= ~P_WAITED;
1006 wakeup((caddr_t)p->p_pptr);
1007 }
1008
1009 /*
1010 * Take the action for the specified signal
1011 * from the current set of pending signals.
1012 */
1013 void
postsig(signum)1014 postsig(signum)
1015 register int signum;
1016 {
1017 register struct proc *p = curproc;
1018 register struct sigacts *ps = p->p_sigacts;
1019 register sig_t action;
1020 u_long code;
1021 int mask, returnmask;
1022
1023 #ifdef DIAGNOSTIC
1024 if (signum == 0)
1025 panic("postsig");
1026 #endif
1027 mask = sigmask(signum);
1028 p->p_siglist &= ~mask;
1029 action = ps->ps_sigact[signum];
1030 #ifdef KTRACE
1031 if (KTRPOINT(p, KTR_PSIG))
1032 ktrpsig(p->p_tracep,
1033 signum, action, ps->ps_flags & SAS_OLDMASK ?
1034 ps->ps_oldmask : p->p_sigmask, 0);
1035 #endif
1036 if (action == SIG_DFL) {
1037 /*
1038 * Default action, where the default is to kill
1039 * the process. (Other cases were ignored above.)
1040 */
1041 sigexit(p, signum);
1042 /* NOTREACHED */
1043 } else {
1044 /*
1045 * If we get here, the signal must be caught.
1046 */
1047 #ifdef DIAGNOSTIC
1048 if (action == SIG_IGN || (p->p_sigmask & mask))
1049 panic("postsig action");
1050 #endif
1051 /*
1052 * Set the new mask value and also defer further
1053 * occurences of this signal.
1054 *
1055 * Special case: user has done a sigpause. Here the
1056 * current mask is not of interest, but rather the
1057 * mask from before the sigpause is what we want
1058 * restored after the signal processing is completed.
1059 */
1060 (void) splhigh();
1061 if (ps->ps_flags & SAS_OLDMASK) {
1062 returnmask = ps->ps_oldmask;
1063 ps->ps_flags &= ~SAS_OLDMASK;
1064 } else
1065 returnmask = p->p_sigmask;
1066 p->p_sigmask |= ps->ps_catchmask[signum] | mask;
1067 (void) spl0();
1068 p->p_stats->p_ru.ru_nsignals++;
1069 if (ps->ps_sig != signum) {
1070 code = 0;
1071 } else {
1072 code = ps->ps_code;
1073 ps->ps_code = 0;
1074 ps->ps_sig = 0;
1075 }
1076 sendsig(action, signum, returnmask, code);
1077 }
1078 }
1079
1080 /*
1081 * Kill the current process for stated reason.
1082 */
1083 void
killproc(p,why)1084 killproc(p, why)
1085 struct proc *p;
1086 char *why;
1087 {
1088
1089 log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why);
1090 uprintf("sorry, pid %d was killed: %s\n", p->p_pid, why);
1091 psignal(p, SIGKILL);
1092 }
1093
1094 /*
1095 * Force the current process to exit with the specified signal, dumping core
1096 * if appropriate. We bypass the normal tests for masked and caught signals,
1097 * allowing unrecoverable failures to terminate the process without changing
1098 * signal state. Mark the accounting record with the signal termination.
1099 * If dumping core, save the signal number for the debugger. Calls exit and
1100 * does not return.
1101 */
1102 void
sigexit(p,signum)1103 sigexit(p, signum)
1104 register struct proc *p;
1105 int signum;
1106 {
1107
1108 p->p_acflag |= AXSIG;
1109 if (sigprop[signum] & SA_CORE) {
1110 p->p_sigacts->ps_sig = signum;
1111 if (coredump(p) == 0)
1112 signum |= WCOREFLAG;
1113 }
1114 exit1(p, W_EXITCODE(0, signum));
1115 /* NOTREACHED */
1116 }
1117
1118 /*
1119 * Dump core, into a file named "progname.core", unless the process was
1120 * setuid/setgid.
1121 */
1122 int
coredump(p)1123 coredump(p)
1124 register struct proc *p;
1125 {
1126 register struct vnode *vp;
1127 register struct pcred *pcred = p->p_cred;
1128 register struct ucred *cred = pcred->pc_ucred;
1129 register struct vmspace *vm = p->p_vmspace;
1130 struct nameidata nd;
1131 struct vattr vattr;
1132 int error, error1;
1133 char name[MAXCOMLEN+6]; /* progname.core */
1134
1135 if (pcred->p_svuid != pcred->p_ruid || pcred->p_svgid != pcred->p_rgid)
1136 return (EFAULT);
1137 if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >=
1138 p->p_rlimit[RLIMIT_CORE].rlim_cur)
1139 return (EFAULT);
1140 sprintf(name, "%s.core", p->p_comm);
1141 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, name, p);
1142 if (error = vn_open(&nd,
1143 O_CREAT | FWRITE, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))
1144 return (error);
1145 vp = nd.ni_vp;
1146
1147 /* Don't dump to non-regular files or files with links. */
1148 if (vp->v_type != VREG ||
1149 VOP_GETATTR(vp, &vattr, cred, p) || vattr.va_nlink != 1) {
1150 error = EFAULT;
1151 goto out;
1152 }
1153 VATTR_NULL(&vattr);
1154 vattr.va_size = 0;
1155 VOP_LEASE(vp, p, cred, LEASE_WRITE);
1156 VOP_SETATTR(vp, &vattr, cred, p);
1157 p->p_acflag |= ACORE;
1158 bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc));
1159 fill_eproc(p, &p->p_addr->u_kproc.kp_eproc);
1160 error = cpu_coredump(p, vp, cred);
1161 if (error == 0)
1162 error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr,
1163 (int)ctob(vm->vm_dsize), (off_t)ctob(UPAGES), UIO_USERSPACE,
1164 IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p);
1165 if (error == 0)
1166 error = vn_rdwr(UIO_WRITE, vp,
1167 (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)),
1168 round_page(ctob(vm->vm_ssize)),
1169 (off_t)ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE,
1170 IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p);
1171 out:
1172 VOP_UNLOCK(vp, 0, p);
1173 error1 = vn_close(vp, FWRITE, cred, p);
1174 if (error == 0)
1175 error = error1;
1176 return (error);
1177 }
1178
1179 /*
1180 * Nonexistent system call-- signal process (may want to handle it).
1181 * Flag error in case process won't see signal immediately (blocked or ignored).
1182 */
1183 /* ARGSUSED */
1184 int
nosys(p,args,retval)1185 nosys(p, args, retval)
1186 struct proc *p;
1187 void *args;
1188 register_t *retval;
1189 {
1190
1191 psignal(p, SIGSYS);
1192 return (ENOSYS);
1193 }
1194