![[BACK]](/icons/back.gif){kind=icon}
Return to kern_sig.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to kern_sig.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: kern_sig.c,v 1.94 2007/05/30 07:42:52 moritz Exp $ */
2: /* $NetBSD: kern_sig.c,v 1.54 1996/04/22 01:38:32 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1997 Theo de Raadt. All rights reserved.
6: * Copyright (c) 1982, 1986, 1989, 1991, 1993
7: * The Regents of the University of California. All rights reserved.
8: * (c) UNIX System Laboratories, Inc.
9: * All or some portions of this file are derived from material licensed
10: * to the University of California by American Telephone and Telegraph
11: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
12: * the permission of UNIX System Laboratories, Inc.
13: *
14: * Redistribution and use in source and binary forms, with or without
15: * modification, are permitted provided that the following conditions
16: * are met:
17: * 1. Redistributions of source code must retain the above copyright
18: * notice, this list of conditions and the following disclaimer.
19: * 2. Redistributions in binary form must reproduce the above copyright
20: * notice, this list of conditions and the following disclaimer in the
21: * documentation and/or other materials provided with the distribution.
22: * 3. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * @(#)kern_sig.c 8.7 (Berkeley) 4/18/94
39: */
40:
41: #define SIGPROP /* include signal properties table */
42: #include <sys/param.h>
43: #include <sys/signalvar.h>
44: #include <sys/resourcevar.h>
45: #include <sys/queue.h>
46: #include <sys/namei.h>
47: #include <sys/vnode.h>
48: #include <sys/event.h>
49: #include <sys/proc.h>
50: #include <sys/systm.h>
51: #include <sys/timeb.h>
52: #include <sys/times.h>
53: #include <sys/buf.h>
54: #include <sys/acct.h>
55: #include <sys/file.h>
56: #include <sys/kernel.h>
57: #include <sys/wait.h>
58: #include <sys/ktrace.h>
59: #include <sys/stat.h>
60: #include <sys/core.h>
61: #include <sys/malloc.h>
62: #include <sys/pool.h>
63: #include <sys/ptrace.h>
64: #include <sys/sched.h>
65:
66: #include <sys/mount.h>
67: #include <sys/syscallargs.h>
68:
69: #include <machine/cpu.h>
70:
71: #include <uvm/uvm_extern.h>
72: #include <sys/user.h> /* for coredump */
73:
74: int filt_sigattach(struct knote *kn);
75: void filt_sigdetach(struct knote *kn);
76: int filt_signal(struct knote *kn, long hint);
77:
78: struct filterops sig_filtops =
79: { 0, filt_sigattach, filt_sigdetach, filt_signal };
80:
81: void proc_stop(struct proc *p, int);
82: void proc_stop_sweep(void *);
83: struct timeout proc_stop_to;
84:
85: int cansignal(struct proc *, struct pcred *, struct proc *, int);
86:
87: struct pool sigacts_pool; /* memory pool for sigacts structures */
88:
89: /*
90: * Can process p, with pcred pc, send the signal signum to process q?
91: */
92: int
93: cansignal(struct proc *p, struct pcred *pc, struct proc *q, int signum)
94: {
95: if (pc->pc_ucred->cr_uid == 0)
96: return (1); /* root can always signal */
97:
98: if (p == q)
99: return (1); /* process can always signal itself */
100:
101: #ifdef RTHREADS
102: /* a thread can only be signalled from within the same process */
103: if (q->p_flag & P_THREAD) {
104: return (p->p_p == q->p_p);
105: }
106: #endif
107:
108: if (signum == SIGCONT && q->p_session == p->p_session)
109: return (1); /* SIGCONT in session */
110:
111: /*
112: * Using kill(), only certain signals can be sent to setugid
113: * child processes
114: */
115: if (q->p_flag & P_SUGID) {
116: switch (signum) {
117: case 0:
118: case SIGKILL:
119: case SIGINT:
120: case SIGTERM:
121: case SIGALRM:
122: case SIGSTOP:
123: case SIGTTIN:
124: case SIGTTOU:
125: case SIGTSTP:
126: case SIGHUP:
127: case SIGUSR1:
128: case SIGUSR2:
129: if (pc->p_ruid == q->p_cred->p_ruid ||
130: pc->pc_ucred->cr_uid == q->p_cred->p_ruid ||
131: pc->p_ruid == q->p_ucred->cr_uid ||
132: pc->pc_ucred->cr_uid == q->p_ucred->cr_uid)
133: return (1);
134: }
135: return (0);
136: }
137:
138: /* XXX
139: * because the P_SUGID test exists, this has extra tests which
140: * could be removed.
141: */
142: if (pc->p_ruid == q->p_cred->p_ruid ||
143: pc->p_ruid == q->p_cred->p_svuid ||
144: pc->pc_ucred->cr_uid == q->p_cred->p_ruid ||
145: pc->pc_ucred->cr_uid == q->p_cred->p_svuid ||
146: pc->p_ruid == q->p_ucred->cr_uid ||
147: pc->pc_ucred->cr_uid == q->p_ucred->cr_uid)
148: return (1);
149: return (0);
150: }
151:
152: /*
153: * Initialize signal-related data structures.
154: */
155: void
156: signal_init(void)
157: {
158: timeout_set(&proc_stop_to, proc_stop_sweep, NULL);
159:
160: pool_init(&sigacts_pool, sizeof(struct sigacts), 0, 0, 0, "sigapl",
161: &pool_allocator_nointr);
162: }
163:
164: /*
165: * Create an initial sigacts structure, using the same signal state
166: * as p.
167: */
168: struct sigacts *
169: sigactsinit(struct proc *p)
170: {
171: struct sigacts *ps;
172:
173: ps = pool_get(&sigacts_pool, PR_WAITOK);
174: memcpy(ps, p->p_sigacts, sizeof(struct sigacts));
175: ps->ps_refcnt = 1;
176: return (ps);
177: }
178:
179: /*
180: * Make p2 share p1's sigacts.
181: */
182: void
183: sigactsshare(struct proc *p1, struct proc *p2)
184: {
185:
186: p2->p_sigacts = p1->p_sigacts;
187: p1->p_sigacts->ps_refcnt++;
188: }
189:
190: /*
191: * Make this process not share its sigacts, maintaining all
192: * signal state.
193: */
194: void
195: sigactsunshare(struct proc *p)
196: {
197: struct sigacts *newps;
198:
199: if (p->p_sigacts->ps_refcnt == 1)
200: return;
201:
202: newps = sigactsinit(p);
203: sigactsfree(p);
204: p->p_sigacts = newps;
205: }
206:
207: /*
208: * Release a sigacts structure.
209: */
210: void
211: sigactsfree(struct proc *p)
212: {
213: struct sigacts *ps = p->p_sigacts;
214:
215: if (--ps->ps_refcnt > 0)
216: return;
217:
218: p->p_sigacts = NULL;
219:
220: pool_put(&sigacts_pool, ps);
221: }
222:
223: /* ARGSUSED */
224: int
225: sys_sigaction(struct proc *p, void *v, register_t *retval)
226: {
227: struct sys_sigaction_args /* {
228: syscallarg(int) signum;
229: syscallarg(const struct sigaction *) nsa;
230: syscallarg(struct sigaction *) osa;
231: } */ *uap = v;
232: struct sigaction vec;
233: struct sigaction *sa;
234: struct sigacts *ps = p->p_sigacts;
235: int signum;
236: int bit, error;
237:
238: signum = SCARG(uap, signum);
239: if (signum <= 0 || signum >= NSIG ||
240: (SCARG(uap, nsa) && (signum == SIGKILL || signum == SIGSTOP)))
241: return (EINVAL);
242: sa = &vec;
243: if (SCARG(uap, osa)) {
244: sa->sa_handler = ps->ps_sigact[signum];
245: sa->sa_mask = ps->ps_catchmask[signum];
246: bit = sigmask(signum);
247: sa->sa_flags = 0;
248: if ((ps->ps_sigonstack & bit) != 0)
249: sa->sa_flags |= SA_ONSTACK;
250: if ((ps->ps_sigintr & bit) == 0)
251: sa->sa_flags |= SA_RESTART;
252: if ((ps->ps_sigreset & bit) != 0)
253: sa->sa_flags |= SA_RESETHAND;
254: if ((ps->ps_siginfo & bit) != 0)
255: sa->sa_flags |= SA_SIGINFO;
256: if (signum == SIGCHLD) {
257: if ((p->p_flag & P_NOCLDSTOP) != 0)
258: sa->sa_flags |= SA_NOCLDSTOP;
259: if ((p->p_flag & P_NOCLDWAIT) != 0)
260: sa->sa_flags |= SA_NOCLDWAIT;
261: }
262: if ((sa->sa_mask & bit) == 0)
263: sa->sa_flags |= SA_NODEFER;
264: sa->sa_mask &= ~bit;
265: error = copyout(sa, SCARG(uap, osa), sizeof (vec));
266: if (error)
267: return (error);
268: }
269: if (SCARG(uap, nsa)) {
270: error = copyin(SCARG(uap, nsa), sa, sizeof (vec));
271: if (error)
272: return (error);
273: setsigvec(p, signum, sa);
274: }
275: return (0);
276: }
277:
278: void
279: setsigvec(struct proc *p, int signum, struct sigaction *sa)
280: {
281: struct sigacts *ps = p->p_sigacts;
282: int bit;
283: int s;
284:
285: bit = sigmask(signum);
286: /*
287: * Change setting atomically.
288: */
289: s = splhigh();
290: ps->ps_sigact[signum] = sa->sa_handler;
291: if ((sa->sa_flags & SA_NODEFER) == 0)
292: sa->sa_mask |= sigmask(signum);
293: ps->ps_catchmask[signum] = sa->sa_mask &~ sigcantmask;
294: if (signum == SIGCHLD) {
295: if (sa->sa_flags & SA_NOCLDSTOP)
296: atomic_setbits_int(&p->p_flag, P_NOCLDSTOP);
297: else
298: atomic_clearbits_int(&p->p_flag, P_NOCLDSTOP);
299: /*
300: * If the SA_NOCLDWAIT flag is set or the handler
301: * is SIG_IGN we reparent the dying child to PID 1
302: * (init) which will reap the zombie. Because we use
303: * init to do our dirty work we never set P_NOCLDWAIT
304: * for PID 1.
305: */
306: if (p->p_pid != 1 && ((sa->sa_flags & SA_NOCLDWAIT) ||
307: sa->sa_handler == SIG_IGN))
308: atomic_setbits_int(&p->p_flag, P_NOCLDWAIT);
309: else
310: atomic_clearbits_int(&p->p_flag, P_NOCLDWAIT);
311: }
312: if ((sa->sa_flags & SA_RESETHAND) != 0)
313: ps->ps_sigreset |= bit;
314: else
315: ps->ps_sigreset &= ~bit;
316: if ((sa->sa_flags & SA_SIGINFO) != 0)
317: ps->ps_siginfo |= bit;
318: else
319: ps->ps_siginfo &= ~bit;
320: if ((sa->sa_flags & SA_RESTART) == 0)
321: ps->ps_sigintr |= bit;
322: else
323: ps->ps_sigintr &= ~bit;
324: if ((sa->sa_flags & SA_ONSTACK) != 0)
325: ps->ps_sigonstack |= bit;
326: else
327: ps->ps_sigonstack &= ~bit;
328: #ifdef COMPAT_SUNOS
329: {
330: extern struct emul emul_sunos;
331: if (p->p_emul == &emul_sunos) {
332: if (sa->sa_flags & SA_USERTRAMP)
333: ps->ps_usertramp |= bit;
334: else
335: ps->ps_usertramp &= ~bit;
336: }
337: }
338: #endif
339: /*
340: * Set bit in p_sigignore for signals that are set to SIG_IGN,
341: * and for signals set to SIG_DFL where the default is to ignore.
342: * However, don't put SIGCONT in p_sigignore,
343: * as we have to restart the process.
344: */
345: if (sa->sa_handler == SIG_IGN ||
346: (sigprop[signum] & SA_IGNORE && sa->sa_handler == SIG_DFL)) {
347: atomic_clearbits_int(&p->p_siglist, bit);
348: if (signum != SIGCONT)
349: p->p_sigignore |= bit; /* easier in psignal */
350: p->p_sigcatch &= ~bit;
351: } else {
352: p->p_sigignore &= ~bit;
353: if (sa->sa_handler == SIG_DFL)
354: p->p_sigcatch &= ~bit;
355: else
356: p->p_sigcatch |= bit;
357: }
358: splx(s);
359: }
360:
361: /*
362: * Initialize signal state for process 0;
363: * set to ignore signals that are ignored by default.
364: */
365: void
366: siginit(struct proc *p)
367: {
368: int i;
369:
370: for (i = 0; i < NSIG; i++)
371: if (sigprop[i] & SA_IGNORE && i != SIGCONT)
372: p->p_sigignore |= sigmask(i);
373: }
374:
375: /*
376: * Reset signals for an exec of the specified process.
377: */
378: void
379: execsigs(struct proc *p)
380: {
381: struct sigacts *ps;
382: int nc, mask;
383:
384: sigactsunshare(p);
385: ps = p->p_sigacts;
386:
387: /*
388: * Reset caught signals. Held signals remain held
389: * through p_sigmask (unless they were caught,
390: * and are now ignored by default).
391: */
392: while (p->p_sigcatch) {
393: nc = ffs((long)p->p_sigcatch);
394: mask = sigmask(nc);
395: p->p_sigcatch &= ~mask;
396: if (sigprop[nc] & SA_IGNORE) {
397: if (nc != SIGCONT)
398: p->p_sigignore |= mask;
399: atomic_clearbits_int(&p->p_siglist, mask);
400: }
401: ps->ps_sigact[nc] = SIG_DFL;
402: }
403: /*
404: * Reset stack state to the user stack.
405: * Clear set of signals caught on the signal stack.
406: */
407: ps->ps_sigstk.ss_flags = SS_DISABLE;
408: ps->ps_sigstk.ss_size = 0;
409: ps->ps_sigstk.ss_sp = 0;
410: ps->ps_flags = 0;
411: atomic_clearbits_int(&p->p_flag, P_NOCLDWAIT);
412: if (ps->ps_sigact[SIGCHLD] == SIG_IGN)
413: ps->ps_sigact[SIGCHLD] = SIG_DFL;
414: }
415:
416: /*
417: * Manipulate signal mask.
418: * Note that we receive new mask, not pointer,
419: * and return old mask as return value;
420: * the library stub does the rest.
421: */
422: int
423: sys_sigprocmask(struct proc *p, void *v, register_t *retval)
424: {
425: struct sys_sigprocmask_args /* {
426: syscallarg(int) how;
427: syscallarg(sigset_t) mask;
428: } */ *uap = v;
429: int error = 0;
430: int s;
431:
432: *retval = p->p_sigmask;
433: s = splhigh();
434:
435: switch (SCARG(uap, how)) {
436: case SIG_BLOCK:
437: p->p_sigmask |= SCARG(uap, mask) &~ sigcantmask;
438: break;
439:
440: case SIG_UNBLOCK:
441: p->p_sigmask &= ~SCARG(uap, mask);
442: break;
443:
444: case SIG_SETMASK:
445: p->p_sigmask = SCARG(uap, mask) &~ sigcantmask;
446: break;
447:
448: default:
449: error = EINVAL;
450: break;
451: }
452: splx(s);
453: return (error);
454: }
455:
456: /* ARGSUSED */
457: int
458: sys_sigpending(struct proc *p, void *v, register_t *retval)
459: {
460:
461: *retval = p->p_siglist;
462: return (0);
463: }
464:
465: /*
466: * Suspend process until signal, providing mask to be set
467: * in the meantime. Note nonstandard calling convention:
468: * libc stub passes mask, not pointer, to save a copyin.
469: */
470: /* ARGSUSED */
471: int
472: sys_sigsuspend(struct proc *p, void *v, register_t *retval)
473: {
474: struct sys_sigsuspend_args /* {
475: syscallarg(int) mask;
476: } */ *uap = v;
477: struct sigacts *ps = p->p_sigacts;
478:
479: /*
480: * When returning from sigpause, we want
481: * the old mask to be restored after the
482: * signal handler has finished. Thus, we
483: * save it here and mark the sigacts structure
484: * to indicate this.
485: */
486: ps->ps_oldmask = p->p_sigmask;
487: ps->ps_flags |= SAS_OLDMASK;
488: p->p_sigmask = SCARG(uap, mask) &~ sigcantmask;
489: while (tsleep(ps, PPAUSE|PCATCH, "pause", 0) == 0)
490: /* void */;
491: /* always return EINTR rather than ERESTART... */
492: return (EINTR);
493: }
494:
495: /* ARGSUSED */
496: int
497: sys_osigaltstack(struct proc *p, void *v, register_t *retval)
498: {
499: struct sys_osigaltstack_args /* {
500: syscallarg(const struct osigaltstack *) nss;
501: syscallarg(struct osigaltstack *) oss;
502: } */ *uap = v;
503: struct sigacts *psp;
504: struct osigaltstack ss;
505: int error;
506:
507: psp = p->p_sigacts;
508: if ((psp->ps_flags & SAS_ALTSTACK) == 0)
509: psp->ps_sigstk.ss_flags |= SS_DISABLE;
510: if (SCARG(uap, oss)) {
511: ss.ss_sp = psp->ps_sigstk.ss_sp;
512: ss.ss_size = psp->ps_sigstk.ss_size;
513: ss.ss_flags = psp->ps_sigstk.ss_flags;
514: if ((error = copyout(&ss, SCARG(uap, oss), sizeof(ss))))
515: return (error);
516: }
517: if (SCARG(uap, nss) == NULL)
518: return (0);
519: error = copyin(SCARG(uap, nss), &ss, sizeof(ss));
520: if (error)
521: return (error);
522: if (ss.ss_flags & SS_DISABLE) {
523: if (psp->ps_sigstk.ss_flags & SS_ONSTACK)
524: return (EINVAL);
525: psp->ps_flags &= ~SAS_ALTSTACK;
526: psp->ps_sigstk.ss_flags = ss.ss_flags;
527: return (0);
528: }
529: if (ss.ss_size < MINSIGSTKSZ)
530: return (ENOMEM);
531: psp->ps_flags |= SAS_ALTSTACK;
532: psp->ps_sigstk.ss_sp = ss.ss_sp;
533: psp->ps_sigstk.ss_size = ss.ss_size;
534: psp->ps_sigstk.ss_flags = ss.ss_flags;
535: return (0);
536: }
537:
538: int
539: sys_sigaltstack(struct proc *p, void *v, register_t *retval)
540: {
541: struct sys_sigaltstack_args /* {
542: syscallarg(const struct sigaltstack *) nss;
543: syscallarg(struct sigaltstack *) oss;
544: } */ *uap = v;
545: struct sigacts *psp;
546: struct sigaltstack ss;
547: int error;
548:
549: psp = p->p_sigacts;
550: if ((psp->ps_flags & SAS_ALTSTACK) == 0)
551: psp->ps_sigstk.ss_flags |= SS_DISABLE;
552: if (SCARG(uap, oss) && (error = copyout(&psp->ps_sigstk,
553: SCARG(uap, oss), sizeof(struct sigaltstack))))
554: return (error);
555: if (SCARG(uap, nss) == NULL)
556: return (0);
557: error = copyin(SCARG(uap, nss), &ss, sizeof(ss));
558: if (error)
559: return (error);
560: if (ss.ss_flags & SS_DISABLE) {
561: if (psp->ps_sigstk.ss_flags & SS_ONSTACK)
562: return (EINVAL);
563: psp->ps_flags &= ~SAS_ALTSTACK;
564: psp->ps_sigstk.ss_flags = ss.ss_flags;
565: return (0);
566: }
567: if (ss.ss_size < MINSIGSTKSZ)
568: return (ENOMEM);
569: psp->ps_flags |= SAS_ALTSTACK;
570: psp->ps_sigstk = ss;
571: return (0);
572: }
573:
574: /* ARGSUSED */
575: int
576: sys_kill(struct proc *cp, void *v, register_t *retval)
577: {
578: struct sys_kill_args /* {
579: syscallarg(int) pid;
580: syscallarg(int) signum;
581: } */ *uap = v;
582: struct proc *p;
583: struct pcred *pc = cp->p_cred;
584:
585: if ((u_int)SCARG(uap, signum) >= NSIG)
586: return (EINVAL);
587: if (SCARG(uap, pid) > 0) {
588: /* kill single process */
589: if ((p = pfind(SCARG(uap, pid))) == NULL)
590: return (ESRCH);
591: if (!cansignal(cp, pc, p, SCARG(uap, signum)))
592: return (EPERM);
593: if (SCARG(uap, signum))
594: psignal(p, SCARG(uap, signum));
595: return (0);
596: }
597: switch (SCARG(uap, pid)) {
598: case -1: /* broadcast signal */
599: return (killpg1(cp, SCARG(uap, signum), 0, 1));
600: case 0: /* signal own process group */
601: return (killpg1(cp, SCARG(uap, signum), 0, 0));
602: default: /* negative explicit process group */
603: return (killpg1(cp, SCARG(uap, signum), -SCARG(uap, pid), 0));
604: }
605: /* NOTREACHED */
606: }
607:
608: /*
609: * Common code for kill process group/broadcast kill.
610: * cp is calling process.
611: */
612: int
613: killpg1(struct proc *cp, int signum, int pgid, int all)
614: {
615: struct proc *p;
616: struct pcred *pc = cp->p_cred;
617: struct pgrp *pgrp;
618: int nfound = 0;
619:
620: if (all)
621: /*
622: * broadcast
623: */
624: for (p = LIST_FIRST(&allproc); p; p = LIST_NEXT(p, p_list)) {
625: if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
626: p == cp || !cansignal(cp, pc, p, signum))
627: continue;
628: nfound++;
629: if (signum)
630: psignal(p, signum);
631: }
632: else {
633: if (pgid == 0)
634: /*
635: * zero pgid means send to my process group.
636: */
637: pgrp = cp->p_pgrp;
638: else {
639: pgrp = pgfind(pgid);
640: if (pgrp == NULL)
641: return (ESRCH);
642: }
643: LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
644: if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
645: !cansignal(cp, pc, p, signum))
646: continue;
647: nfound++;
648: if (signum && P_ZOMBIE(p) == 0)
649: psignal(p, signum);
650: }
651: }
652: return (nfound ? 0 : ESRCH);
653: }
654:
655: #define CANDELIVER(uid, euid, p) \
656: (euid == 0 || \
657: (uid) == (p)->p_cred->p_ruid || \
658: (uid) == (p)->p_cred->p_svuid || \
659: (uid) == (p)->p_ucred->cr_uid || \
660: (euid) == (p)->p_cred->p_ruid || \
661: (euid) == (p)->p_cred->p_svuid || \
662: (euid) == (p)->p_ucred->cr_uid)
663:
664: /*
665: * Deliver signum to pgid, but first check uid/euid against each
666: * process and see if it is permitted.
667: */
668: void
669: csignal(pid_t pgid, int signum, uid_t uid, uid_t euid)
670: {
671: struct pgrp *pgrp;
672: struct proc *p;
673:
674: if (pgid == 0)
675: return;
676: if (pgid < 0) {
677: pgid = -pgid;
678: if ((pgrp = pgfind(pgid)) == NULL)
679: return;
680: LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
681: if (CANDELIVER(uid, euid, p))
682: psignal(p, signum);
683: } else {
684: if ((p = pfind(pgid)) == NULL)
685: return;
686: if (CANDELIVER(uid, euid, p))
687: psignal(p, signum);
688: }
689: }
690:
691: /*
692: * Send a signal to a process group.
693: */
694: void
695: gsignal(int pgid, int signum)
696: {
697: struct pgrp *pgrp;
698:
699: if (pgid && (pgrp = pgfind(pgid)))
700: pgsignal(pgrp, signum, 0);
701: }
702:
703: /*
704: * Send a signal to a process group. If checktty is 1,
705: * limit to members which have a controlling terminal.
706: */
707: void
708: pgsignal(struct pgrp *pgrp, int signum, int checkctty)
709: {
710: struct proc *p;
711:
712: if (pgrp)
713: LIST_FOREACH(p, &pgrp->pg_members, p_pglist)
714: if ((checkctty == 0 || p->p_flag & P_CONTROLT) &&
715: (p->p_flag & P_THREAD) == 0)
716: psignal(p, signum);
717: }
718:
719: /*
720: * Send a signal caused by a trap to the current process.
721: * If it will be caught immediately, deliver it with correct code.
722: * Otherwise, post it normally.
723: */
724: void
725: trapsignal(struct proc *p, int signum, u_long code, int type,
726: union sigval sigval)
727: {
728: struct sigacts *ps = p->p_sigacts;
729: int mask;
730:
731: mask = sigmask(signum);
732: if ((p->p_flag & P_TRACED) == 0 && (p->p_sigcatch & mask) != 0 &&
733: (p->p_sigmask & mask) == 0) {
734: #ifdef KTRACE
735: if (KTRPOINT(p, KTR_PSIG)) {
736: siginfo_t si;
737:
738: initsiginfo(&si, signum, code, type, sigval);
739: ktrpsig(p, signum, ps->ps_sigact[signum],
740: p->p_sigmask, type, &si);
741: }
742: #endif
743: p->p_stats->p_ru.ru_nsignals++;
744: (*p->p_emul->e_sendsig)(ps->ps_sigact[signum], signum,
745: p->p_sigmask, code, type, sigval);
746: p->p_sigmask |= ps->ps_catchmask[signum];
747: if ((ps->ps_sigreset & mask) != 0) {
748: p->p_sigcatch &= ~mask;
749: if (signum != SIGCONT && sigprop[signum] & SA_IGNORE)
750: p->p_sigignore |= mask;
751: ps->ps_sigact[signum] = SIG_DFL;
752: }
753: } else {
754: ps->ps_sig = signum;
755: ps->ps_code = code; /* XXX for core dump/debugger */
756: ps->ps_type = type;
757: ps->ps_sigval = sigval;
758: psignal(p, signum);
759: }
760: }
761:
762: /*
763: * Send the signal to the process. If the signal has an action, the action
764: * is usually performed by the target process rather than the caller; we add
765: * the signal to the set of pending signals for the process.
766: *
767: * Exceptions:
768: * o When a stop signal is sent to a sleeping process that takes the
769: * default action, the process is stopped without awakening it.
770: * o SIGCONT restarts stopped processes (or puts them back to sleep)
771: * regardless of the signal action (eg, blocked or ignored).
772: *
773: * Other ignored signals are discarded immediately.
774: */
775: void
776: psignal(struct proc *p, int signum)
777: {
778: int s, prop;
779: sig_t action;
780: int mask;
781: #ifdef RTHREADS
782: struct proc *q;
783: #endif
784: int wakeparent = 0;
785:
786: #ifdef DIAGNOSTIC
787: if ((u_int)signum >= NSIG || signum == 0)
788: panic("psignal signal number");
789: #endif
790:
791: /* Ignore signal if we are exiting */
792: if (p->p_flag & P_WEXIT)
793: return;
794:
795: #ifdef RTHREADS
796: TAILQ_FOREACH(q, &p->p_p->ps_threads, p_thr_link) {
797: if (q == p)
798: continue;
799: if (q->p_sigdivert & (1 << signum)) {
800: q->p_sigdivert = 0;
801: psignal(q, signum);
802: return;
803: }
804: }
805: #endif
806:
807: KNOTE(&p->p_klist, NOTE_SIGNAL | signum);
808:
809: mask = sigmask(signum);
810: prop = sigprop[signum];
811:
812: /*
813: * If proc is traced, always give parent a chance.
814: */
815: if (p->p_flag & P_TRACED)
816: action = SIG_DFL;
817: else {
818: /*
819: * If the signal is being ignored,
820: * then we forget about it immediately.
821: * (Note: we don't set SIGCONT in p_sigignore,
822: * and if it is set to SIG_IGN,
823: * action will be SIG_DFL here.)
824: */
825: if (p->p_sigignore & mask)
826: return;
827: if (p->p_sigmask & mask)
828: action = SIG_HOLD;
829: else if (p->p_sigcatch & mask)
830: action = SIG_CATCH;
831: else {
832: action = SIG_DFL;
833:
834: if (prop & SA_KILL && p->p_nice > NZERO)
835: p->p_nice = NZERO;
836:
837: /*
838: * If sending a tty stop signal to a member of an
839: * orphaned process group, discard the signal here if
840: * the action is default; don't stop the process below
841: * if sleeping, and don't clear any pending SIGCONT.
842: */
843: if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0)
844: return;
845: }
846: }
847:
848: if (prop & SA_CONT) {
849: #ifdef RTHREADS
850: TAILQ_FOREACH(q, &p->p_p->ps_threads, p_thr_link) {
851: if (q != p)
852: psignal(q, signum);
853: }
854: #endif
855: atomic_clearbits_int(&p->p_siglist, stopsigmask);
856: }
857:
858: if (prop & SA_STOP) {
859: #ifdef RTHREADS
860:
861: TAILQ_FOREACH(q, &p->p_p->ps_threads, p_thr_link) {
862: if (q != p)
863: psignal(q, signum);
864: }
865: #endif
866: atomic_clearbits_int(&p->p_siglist, contsigmask);
867: atomic_clearbits_int(&p->p_flag, P_CONTINUED);
868: }
869:
870: atomic_setbits_int(&p->p_siglist, mask);
871:
872: /*
873: * Defer further processing for signals which are held,
874: * except that stopped processes must be continued by SIGCONT.
875: */
876: if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP))
877: return;
878:
879: SCHED_LOCK(s);
880:
881: switch (p->p_stat) {
882:
883: case SSLEEP:
884: /*
885: * If process is sleeping uninterruptibly
886: * we can't interrupt the sleep... the signal will
887: * be noticed when the process returns through
888: * trap() or syscall().
889: */
890: if ((p->p_flag & P_SINTR) == 0)
891: goto out;
892: /*
893: * Process is sleeping and traced... make it runnable
894: * so it can discover the signal in issignal() and stop
895: * for the parent.
896: */
897: if (p->p_flag & P_TRACED)
898: goto run;
899: /*
900: * If SIGCONT is default (or ignored) and process is
901: * asleep, we are finished; the process should not
902: * be awakened.
903: */
904: if ((prop & SA_CONT) && action == SIG_DFL) {
905: atomic_clearbits_int(&p->p_siglist, mask);
906: goto out;
907: }
908: /*
909: * When a sleeping process receives a stop
910: * signal, process immediately if possible.
911: */
912: if ((prop & SA_STOP) && action == SIG_DFL) {
913: /*
914: * If a child holding parent blocked,
915: * stopping could cause deadlock.
916: */
917: if (p->p_flag & P_PPWAIT)
918: goto out;
919: atomic_clearbits_int(&p->p_siglist, mask);
920: p->p_xstat = signum;
921: proc_stop(p, 0);
922: goto out;
923: }
924: /*
925: * All other (caught or default) signals
926: * cause the process to run.
927: */
928: goto runfast;
929: /*NOTREACHED*/
930:
931: case SSTOP:
932: /*
933: * If traced process is already stopped,
934: * then no further action is necessary.
935: */
936: if (p->p_flag & P_TRACED)
937: goto out;
938:
939: /*
940: * Kill signal always sets processes running.
941: */
942: if (signum == SIGKILL)
943: goto runfast;
944:
945: if (prop & SA_CONT) {
946: /*
947: * If SIGCONT is default (or ignored), we continue the
948: * process but don't leave the signal in p_siglist, as
949: * it has no further action. If SIGCONT is held, we
950: * continue the process and leave the signal in
951: * p_siglist. If the process catches SIGCONT, let it
952: * handle the signal itself. If it isn't waiting on
953: * an event, then it goes back to run state.
954: * Otherwise, process goes back to sleep state.
955: */
956: atomic_setbits_int(&p->p_flag, P_CONTINUED);
957: wakeparent = 1;
958: if (action == SIG_DFL)
959: atomic_clearbits_int(&p->p_siglist, mask);
960: if (action == SIG_CATCH)
961: goto runfast;
962: if (p->p_wchan == 0)
963: goto run;
964: p->p_stat = SSLEEP;
965: goto out;
966: }
967:
968: if (prop & SA_STOP) {
969: /*
970: * Already stopped, don't need to stop again.
971: * (If we did the shell could get confused.)
972: */
973: atomic_clearbits_int(&p->p_siglist, mask);
974: goto out;
975: }
976:
977: /*
978: * If process is sleeping interruptibly, then simulate a
979: * wakeup so that when it is continued, it will be made
980: * runnable and can look at the signal. But don't make
981: * the process runnable, leave it stopped.
982: */
983: if (p->p_wchan && p->p_flag & P_SINTR)
984: unsleep(p);
985: goto out;
986:
987: case SONPROC:
988: signotify(p);
989: /* FALLTHROUGH */
990: default:
991: /*
992: * SRUN, SIDL, SZOMB do nothing with the signal,
993: * other than kicking ourselves if we are running.
994: * It will either never be noticed, or noticed very soon.
995: */
996: goto out;
997: }
998: /*NOTREACHED*/
999:
1000: runfast:
1001: /*
1002: * Raise priority to at least PUSER.
1003: */
1004: if (p->p_priority > PUSER)
1005: p->p_priority = PUSER;
1006: run:
1007: setrunnable(p);
1008: out:
1009: SCHED_UNLOCK(s);
1010: if (wakeparent)
1011: wakeup(p->p_pptr);
1012: }
1013:
1014: /*
1015: * If the current process has received a signal (should be caught or cause
1016: * termination, should interrupt current syscall), return the signal number.
1017: * Stop signals with default action are processed immediately, then cleared;
1018: * they aren't returned. This is checked after each entry to the system for
1019: * a syscall or trap (though this can usually be done without calling issignal
1020: * by checking the pending signal masks in the CURSIG macro.) The normal call
1021: * sequence is
1022: *
1023: * while (signum = CURSIG(curproc))
1024: * postsig(signum);
1025: */
1026: int
1027: issignal(struct proc *p)
1028: {
1029: int signum, mask, prop;
1030: int dolock = (p->p_flag & P_SINTR) == 0;
1031: int s;
1032:
1033: for (;;) {
1034: mask = p->p_siglist & ~p->p_sigmask;
1035: if (p->p_flag & P_PPWAIT)
1036: mask &= ~stopsigmask;
1037: if (mask == 0) /* no signal to send */
1038: return (0);
1039: signum = ffs((long)mask);
1040: mask = sigmask(signum);
1041: atomic_clearbits_int(&p->p_siglist, mask);
1042:
1043: /*
1044: * We should see pending but ignored signals
1045: * only if P_TRACED was on when they were posted.
1046: */
1047: if (mask & p->p_sigignore && (p->p_flag & P_TRACED) == 0)
1048: continue;
1049:
1050: if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) {
1051: /*
1052: * If traced, always stop, and stay
1053: * stopped until released by the debugger.
1054: */
1055: p->p_xstat = signum;
1056:
1057: if (dolock)
1058: SCHED_LOCK(s);
1059: proc_stop(p, 1);
1060: if (dolock)
1061: SCHED_UNLOCK(s);
1062:
1063: /*
1064: * If we are no longer being traced, or the parent
1065: * didn't give us a signal, look for more signals.
1066: */
1067: if ((p->p_flag & P_TRACED) == 0 || p->p_xstat == 0)
1068: continue;
1069:
1070: /*
1071: * If the new signal is being masked, look for other
1072: * signals.
1073: */
1074: signum = p->p_xstat;
1075: mask = sigmask(signum);
1076: if ((p->p_sigmask & mask) != 0)
1077: continue;
1078:
1079: /* take the signal! */
1080: atomic_clearbits_int(&p->p_siglist, mask);
1081: }
1082:
1083: prop = sigprop[signum];
1084:
1085: /*
1086: * Decide whether the signal should be returned.
1087: * Return the signal's number, or fall through
1088: * to clear it from the pending mask.
1089: */
1090: switch ((long)p->p_sigacts->ps_sigact[signum]) {
1091:
1092: case (long)SIG_DFL:
1093: /*
1094: * Don't take default actions on system processes.
1095: */
1096: if (p->p_pid <= 1) {
1097: #ifdef DIAGNOSTIC
1098: /*
1099: * Are you sure you want to ignore SIGSEGV
1100: * in init? XXX
1101: */
1102: printf("Process (pid %d) got signal %d\n",
1103: p->p_pid, signum);
1104: #endif
1105: break; /* == ignore */
1106: }
1107: /*
1108: * If there is a pending stop signal to process
1109: * with default action, stop here,
1110: * then clear the signal. However,
1111: * if process is member of an orphaned
1112: * process group, ignore tty stop signals.
1113: */
1114: if (prop & SA_STOP) {
1115: if (p->p_flag & P_TRACED ||
1116: (p->p_pgrp->pg_jobc == 0 &&
1117: prop & SA_TTYSTOP))
1118: break; /* == ignore */
1119: p->p_xstat = signum;
1120: if (dolock)
1121: SCHED_LOCK(s);
1122: proc_stop(p, 1);
1123: if (dolock)
1124: SCHED_UNLOCK(s);
1125: break;
1126: } else if (prop & SA_IGNORE) {
1127: /*
1128: * Except for SIGCONT, shouldn't get here.
1129: * Default action is to ignore; drop it.
1130: */
1131: break; /* == ignore */
1132: } else
1133: goto keep;
1134: /*NOTREACHED*/
1135:
1136: case (long)SIG_IGN:
1137: /*
1138: * Masking above should prevent us ever trying
1139: * to take action on an ignored signal other
1140: * than SIGCONT, unless process is traced.
1141: */
1142: if ((prop & SA_CONT) == 0 &&
1143: (p->p_flag & P_TRACED) == 0)
1144: printf("issignal\n");
1145: break; /* == ignore */
1146:
1147: default:
1148: /*
1149: * This signal has an action, let
1150: * postsig() process it.
1151: */
1152: goto keep;
1153: }
1154: }
1155: /* NOTREACHED */
1156:
1157: keep:
1158: atomic_setbits_int(&p->p_siglist, mask); /*leave the signal for later */
1159: return (signum);
1160: }
1161:
1162: /*
1163: * Put the argument process into the stopped state and notify the parent
1164: * via wakeup. Signals are handled elsewhere. The process must not be
1165: * on the run queue.
1166: */
1167: void
1168: proc_stop(struct proc *p, int sw)
1169: {
1170: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
1171: extern void *softclock_si;
1172: #endif
1173: #ifdef MULTIPROCESSOR
1174: SCHED_ASSERT_LOCKED();
1175: #endif
1176:
1177: p->p_stat = SSTOP;
1178: atomic_clearbits_int(&p->p_flag, P_WAITED);
1179: atomic_setbits_int(&p->p_flag, P_STOPPED);
1180: if (!timeout_pending(&proc_stop_to)) {
1181: timeout_add(&proc_stop_to, 0);
1182: /*
1183: * We need this soft interrupt to be handled fast.
1184: * Extra calls to softclock don't hurt.
1185: */
1186: #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
1187: softintr_schedule(softclock_si);
1188: #else
1189: setsoftclock();
1190: #endif
1191: }
1192: if (sw)
1193: mi_switch();
1194: }
1195:
1196: /*
1197: * Called from a timeout to send signals to the parents of stopped processes.
1198: * We can't do this in proc_stop because it's called with nasty locks held
1199: * and we would need recursive scheduler lock to deal with that.
1200: */
1201: void
1202: proc_stop_sweep(void *v)
1203: {
1204: struct proc *p;
1205:
1206: LIST_FOREACH(p, &allproc, p_list) {
1207: if ((p->p_flag & P_STOPPED) == 0)
1208: continue;
1209: atomic_clearbits_int(&p->p_flag, P_STOPPED);
1210:
1211: if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0)
1212: psignal(p->p_pptr, SIGCHLD);
1213: wakeup(p->p_pptr);
1214: }
1215: }
1216:
1217: /*
1218: * Take the action for the specified signal
1219: * from the current set of pending signals.
1220: */
1221: void
1222: postsig(int signum)
1223: {
1224: struct proc *p = curproc;
1225: struct sigacts *ps = p->p_sigacts;
1226: sig_t action;
1227: u_long code;
1228: int mask, returnmask;
1229: union sigval sigval;
1230: int s, type;
1231:
1232: #ifdef DIAGNOSTIC
1233: if (signum == 0)
1234: panic("postsig");
1235: #endif
1236:
1237: KERNEL_PROC_LOCK(p);
1238:
1239: mask = sigmask(signum);
1240: atomic_clearbits_int(&p->p_siglist, mask);
1241: action = ps->ps_sigact[signum];
1242: sigval.sival_ptr = 0;
1243: type = SI_USER;
1244:
1245: if (ps->ps_sig != signum) {
1246: code = 0;
1247: type = SI_USER;
1248: sigval.sival_ptr = 0;
1249: } else {
1250: code = ps->ps_code;
1251: type = ps->ps_type;
1252: sigval = ps->ps_sigval;
1253: }
1254:
1255: #ifdef KTRACE
1256: if (KTRPOINT(p, KTR_PSIG)) {
1257: siginfo_t si;
1258:
1259: initsiginfo(&si, signum, code, type, sigval);
1260: ktrpsig(p, signum, action, ps->ps_flags & SAS_OLDMASK ?
1261: ps->ps_oldmask : p->p_sigmask, type, &si);
1262: }
1263: #endif
1264: if (action == SIG_DFL) {
1265: /*
1266: * Default action, where the default is to kill
1267: * the process. (Other cases were ignored above.)
1268: */
1269: sigexit(p, signum);
1270: /* NOTREACHED */
1271: } else {
1272: /*
1273: * If we get here, the signal must be caught.
1274: */
1275: #ifdef DIAGNOSTIC
1276: if (action == SIG_IGN || (p->p_sigmask & mask))
1277: panic("postsig action");
1278: #endif
1279: /*
1280: * Set the new mask value and also defer further
1281: * occurences of this signal.
1282: *
1283: * Special case: user has done a sigpause. Here the
1284: * current mask is not of interest, but rather the
1285: * mask from before the sigpause is what we want
1286: * restored after the signal processing is completed.
1287: */
1288: #ifdef MULTIPROCESSOR
1289: s = splsched();
1290: #else
1291: s = splhigh();
1292: #endif
1293: if (ps->ps_flags & SAS_OLDMASK) {
1294: returnmask = ps->ps_oldmask;
1295: ps->ps_flags &= ~SAS_OLDMASK;
1296: } else
1297: returnmask = p->p_sigmask;
1298: p->p_sigmask |= ps->ps_catchmask[signum];
1299: if ((ps->ps_sigreset & mask) != 0) {
1300: p->p_sigcatch &= ~mask;
1301: if (signum != SIGCONT && sigprop[signum] & SA_IGNORE)
1302: p->p_sigignore |= mask;
1303: ps->ps_sigact[signum] = SIG_DFL;
1304: }
1305: splx(s);
1306: p->p_stats->p_ru.ru_nsignals++;
1307: if (ps->ps_sig == signum) {
1308: ps->ps_sig = 0;
1309: ps->ps_code = 0;
1310: ps->ps_type = SI_USER;
1311: ps->ps_sigval.sival_ptr = NULL;
1312: }
1313:
1314: (*p->p_emul->e_sendsig)(action, signum, returnmask, code,
1315: type, sigval);
1316: }
1317:
1318: KERNEL_PROC_UNLOCK(p);
1319: }
1320:
1321: /*
1322: * Force the current process to exit with the specified signal, dumping core
1323: * if appropriate. We bypass the normal tests for masked and caught signals,
1324: * allowing unrecoverable failures to terminate the process without changing
1325: * signal state. Mark the accounting record with the signal termination.
1326: * If dumping core, save the signal number for the debugger. Calls exit and
1327: * does not return.
1328: */
1329: void
1330: sigexit(struct proc *p, int signum)
1331: {
1332: /* Mark process as going away */
1333: atomic_setbits_int(&p->p_flag, P_WEXIT);
1334:
1335: p->p_acflag |= AXSIG;
1336: if (sigprop[signum] & SA_CORE) {
1337: p->p_sigacts->ps_sig = signum;
1338: if (coredump(p) == 0)
1339: signum |= WCOREFLAG;
1340: }
1341: exit1(p, W_EXITCODE(0, signum), EXIT_NORMAL);
1342: /* NOTREACHED */
1343: }
1344:
1345: int nosuidcoredump = 1;
1346:
1347: /*
1348: * Dump core, into a file named "progname.core", unless the process was
1349: * setuid/setgid.
1350: */
1351: int
1352: coredump(struct proc *p)
1353: {
1354: struct vnode *vp;
1355: struct ucred *cred = p->p_ucred;
1356: struct vmspace *vm = p->p_vmspace;
1357: struct nameidata nd;
1358: struct vattr vattr;
1359: int error, error1, len;
1360: char name[sizeof("/var/crash/") + MAXCOMLEN + sizeof(".core")];
1361: char *dir = "";
1362: struct core core;
1363:
1364: /*
1365: * Don't dump if not root and the process has used set user or
1366: * group privileges, unless the nosuidcoredump sysctl is set to 2,
1367: * in which case dumps are put into /var/crash/.
1368: */
1369: if (((p->p_flag & P_SUGID) && (error = suser(p, 0))) ||
1370: ((p->p_flag & P_SUGID) && nosuidcoredump)) {
1371: if (nosuidcoredump == 2)
1372: dir = "/var/crash/";
1373: else
1374: return (EPERM);
1375: }
1376:
1377: /* Don't dump if will exceed file size limit. */
1378: if (USPACE + ctob(vm->vm_dsize + vm->vm_ssize) >=
1379: p->p_rlimit[RLIMIT_CORE].rlim_cur)
1380: return (EFBIG);
1381:
1382: len = snprintf(name, sizeof(name), "%s%s.core", dir, p->p_comm);
1383: if (len >= sizeof(name))
1384: return (EACCES);
1385:
1386: /*
1387: * ... but actually write it as UID
1388: */
1389: cred = crdup(cred);
1390: cred->cr_uid = p->p_cred->p_ruid;
1391: cred->cr_gid = p->p_cred->p_rgid;
1392:
1393: NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, p);
1394:
1395: error = vn_open(&nd, O_CREAT | FWRITE | O_NOFOLLOW, S_IRUSR | S_IWUSR);
1396:
1397: if (error) {
1398: crfree(cred);
1399: return (error);
1400: }
1401:
1402: /*
1403: * Don't dump to non-regular files, files with links, or files
1404: * owned by someone else.
1405: */
1406: vp = nd.ni_vp;
1407: if ((error = VOP_GETATTR(vp, &vattr, cred, p)) != 0)
1408: goto out;
1409: /* Don't dump to non-regular files or files with links. */
1410: if (vp->v_type != VREG || vattr.va_nlink != 1 ||
1411: vattr.va_mode & ((VREAD | VWRITE) >> 3 | (VREAD | VWRITE) >> 6)) {
1412: error = EACCES;
1413: goto out;
1414: }
1415: VATTR_NULL(&vattr);
1416: vattr.va_size = 0;
1417: VOP_SETATTR(vp, &vattr, cred, p);
1418: p->p_acflag |= ACORE;
1419: bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc));
1420: fill_eproc(p, &p->p_addr->u_kproc.kp_eproc);
1421:
1422: core.c_midmag = 0;
1423: strlcpy(core.c_name, p->p_comm, sizeof(core.c_name));
1424: core.c_nseg = 0;
1425: core.c_signo = p->p_sigacts->ps_sig;
1426: core.c_ucode = p->p_sigacts->ps_code;
1427: core.c_cpusize = 0;
1428: core.c_tsize = (u_long)ctob(vm->vm_tsize);
1429: core.c_dsize = (u_long)ctob(vm->vm_dsize);
1430: core.c_ssize = (u_long)round_page(ctob(vm->vm_ssize));
1431: error = cpu_coredump(p, vp, cred, &core);
1432: if (error)
1433: goto out;
1434: /*
1435: * uvm_coredump() spits out all appropriate segments.
1436: * All that's left to do is to write the core header.
1437: */
1438: error = uvm_coredump(p, vp, cred, &core);
1439: if (error)
1440: goto out;
1441: error = vn_rdwr(UIO_WRITE, vp, (caddr_t)&core,
1442: (int)core.c_hdrsize, (off_t)0,
1443: UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, NULL, p);
1444: out:
1445: VOP_UNLOCK(vp, 0, p);
1446: error1 = vn_close(vp, FWRITE, cred, p);
1447: crfree(cred);
1448: if (error == 0)
1449: error = error1;
1450: return (error);
1451: }
1452:
1453: /*
1454: * Nonexistent system call-- signal process (may want to handle it).
1455: * Flag error in case process won't see signal immediately (blocked or ignored).
1456: */
1457: /* ARGSUSED */
1458: int
1459: sys_nosys(struct proc *p, void *v, register_t *retval)
1460: {
1461:
1462: psignal(p, SIGSYS);
1463: return (ENOSYS);
1464: }
1465:
1466: #ifdef RTHREADS
1467: int
1468: sys_thrsigdivert(struct proc *p, void *v, register_t *retval)
1469: {
1470: struct sys_thrsigdivert_args *uap = v;
1471:
1472: p->p_sigdivert = SCARG(uap, sigmask);
1473:
1474: return (0);
1475: }
1476: #endif
1477:
1478: void
1479: initsiginfo(siginfo_t *si, int sig, u_long code, int type, union sigval val)
1480: {
1481: bzero(si, sizeof *si);
1482:
1483: si->si_signo = sig;
1484: si->si_code = type;
1485: if (type == SI_USER) {
1486: si->si_value = val;
1487: } else {
1488: switch (sig) {
1489: case SIGSEGV:
1490: case SIGILL:
1491: case SIGBUS:
1492: case SIGFPE:
1493: si->si_addr = val.sival_ptr;
1494: si->si_trapno = code;
1495: break;
1496: case SIGXFSZ:
1497: break;
1498: }
1499: }
1500: }
1501:
1502: int
1503: filt_sigattach(struct knote *kn)
1504: {
1505: struct proc *p = curproc;
1506:
1507: kn->kn_ptr.p_proc = p;
1508: kn->kn_flags |= EV_CLEAR; /* automatically set */
1509:
1510: /* XXX lock the proc here while adding to the list? */
1511: SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext);
1512:
1513: return (0);
1514: }
1515:
1516: void
1517: filt_sigdetach(struct knote *kn)
1518: {
1519: struct proc *p = kn->kn_ptr.p_proc;
1520:
1521: SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext);
1522: }
1523:
1524: /*
1525: * signal knotes are shared with proc knotes, so we apply a mask to
1526: * the hint in order to differentiate them from process hints. This
1527: * could be avoided by using a signal-specific knote list, but probably
1528: * isn't worth the trouble.
1529: */
1530: int
1531: filt_signal(struct knote *kn, long hint)
1532: {
1533:
1534: if (hint & NOTE_SIGNAL) {
1535: hint &= ~NOTE_SIGNAL;
1536:
1537: if (kn->kn_id == hint)
1538: kn->kn_data++;
1539: }
1540: return (kn->kn_data != 0);
1541: }