xref: /csrg-svn/sys/kern/kern_sig.c (revision 52115)
123374Smckusick /*
247540Skarels  * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California.
337580Smckusick  * All rights reserved.
423374Smckusick  *
544440Sbostic  * %sccs.include.redist.c%
637580Smckusick  *
7*52115Skarels  *	@(#)kern_sig.c	7.38 (Berkeley) 01/07/92
823374Smckusick  */
97421Sroot 
1047540Skarels #define	SIGPROP		/* include signal properties table */
1117092Sbloom #include "param.h"
1247650Skarels #include "signalvar.h"
1347650Skarels #include "resourcevar.h"
1448020Smckusick #include "namei.h"
1537580Smckusick #include "vnode.h"
1617092Sbloom #include "proc.h"
1747540Skarels #include "systm.h"
1817092Sbloom #include "timeb.h"
1917092Sbloom #include "times.h"
2017092Sbloom #include "buf.h"
2117092Sbloom #include "acct.h"
2237580Smckusick #include "file.h"
2317092Sbloom #include "kernel.h"
2439513Skarels #include "wait.h"
2540807Smarc #include "ktrace.h"
267421Sroot 
2749102Skarels #include "machine/cpu.h"
2849102Skarels 
2947650Skarels #include "vm/vm.h"
3047650Skarels #include "kinfo_proc.h"
3147650Skarels #include "user.h"		/* for coredump */
3237581Smckusick 
3317013Smckusick /*
3447540Skarels  * Can process p, with pcred pc, send the signal signo to process q?
3517013Smckusick  */
3647540Skarels #define CANSIGNAL(p, pc, q, signo) \
3747540Skarels 	((pc)->pc_ucred->cr_uid == 0 || \
3847540Skarels 	    (pc)->p_ruid == (q)->p_cred->p_ruid || \
3947540Skarels 	    (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \
4047540Skarels 	    (pc)->p_ruid == (q)->p_ucred->cr_uid || \
4147540Skarels 	    (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \
4242920Skarels 	    ((signo) == SIGCONT && (q)->p_session == (p)->p_session))
4339513Skarels 
4442920Skarels /* ARGSUSED */
4542920Skarels sigaction(p, uap, retval)
4642920Skarels 	struct proc *p;
4742920Skarels 	register struct args {
4812882Ssam 		int	signo;
4939513Skarels 		struct	sigaction *nsa;
5039513Skarels 		struct	sigaction *osa;
5142920Skarels 	} *uap;
5242920Skarels 	int *retval;
5342920Skarels {
5439513Skarels 	struct sigaction vec;
5539513Skarels 	register struct sigaction *sa;
5647540Skarels 	register struct sigacts *ps = p->p_sigacts;
5712882Ssam 	register int sig;
5839513Skarels 	int bit, error;
597421Sroot 
6012882Ssam 	sig = uap->signo;
6139513Skarels 	if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
6244405Skarels 		return (EINVAL);
6339513Skarels 	sa = &vec;
6439513Skarels 	if (uap->osa) {
6547540Skarels 		sa->sa_handler = ps->ps_sigact[sig];
6647540Skarels 		sa->sa_mask = ps->ps_catchmask[sig];
6718308Smckusick 		bit = sigmask(sig);
6839513Skarels 		sa->sa_flags = 0;
6947540Skarels 		if ((ps->ps_sigonstack & bit) != 0)
7039513Skarels 			sa->sa_flags |= SA_ONSTACK;
7147540Skarels 		if ((ps->ps_sigintr & bit) == 0)
7239513Skarels 			sa->sa_flags |= SA_RESTART;
7342920Skarels 		if (p->p_flag & SNOCLDSTOP)
7439513Skarels 			sa->sa_flags |= SA_NOCLDSTOP;
7539513Skarels 		if (error = copyout((caddr_t)sa, (caddr_t)uap->osa,
7639513Skarels 		    sizeof (vec)))
7744405Skarels 			return (error);
7812951Ssam 	}
7939513Skarels 	if (uap->nsa) {
8039513Skarels 		if (error = copyin((caddr_t)uap->nsa, (caddr_t)sa,
8139513Skarels 		    sizeof (vec)))
8244405Skarels 			return (error);
8342920Skarels 		setsigvec(p, sig, sa);
8412951Ssam 	}
8544405Skarels 	return (0);
867421Sroot }
877421Sroot 
8842920Skarels setsigvec(p, sig, sa)
8942920Skarels 	register struct proc *p;
9012951Ssam 	int sig;
9139513Skarels 	register struct sigaction *sa;
9212882Ssam {
9347540Skarels 	register struct sigacts *ps = p->p_sigacts;
9412951Ssam 	register int bit;
9512882Ssam 
9617153Sbloom 	bit = sigmask(sig);
9712882Ssam 	/*
9812882Ssam 	 * Change setting atomically.
9912882Ssam 	 */
10017153Sbloom 	(void) splhigh();
10147540Skarels 	ps->ps_sigact[sig] = sa->sa_handler;
10247540Skarels 	ps->ps_catchmask[sig] = sa->sa_mask &~ sigcantmask;
10339513Skarels 	if ((sa->sa_flags & SA_RESTART) == 0)
10447540Skarels 		ps->ps_sigintr |= bit;
10518308Smckusick 	else
10647540Skarels 		ps->ps_sigintr &= ~bit;
10739513Skarels 	if (sa->sa_flags & SA_ONSTACK)
10847540Skarels 		ps->ps_sigonstack |= bit;
10912951Ssam 	else
11047540Skarels 		ps->ps_sigonstack &= ~bit;
11139513Skarels 	if (sig == SIGCHLD) {
11239513Skarels 		if (sa->sa_flags & SA_NOCLDSTOP)
11339513Skarels 			p->p_flag |= SNOCLDSTOP;
11439513Skarels 		else
11539513Skarels 			p->p_flag &= ~SNOCLDSTOP;
11639513Skarels 	}
11739513Skarels 	/*
11839513Skarels 	 * Set bit in p_sigignore for signals that are set to SIG_IGN,
11939513Skarels 	 * and for signals set to SIG_DFL where the default is to ignore.
12039513Skarels 	 * However, don't put SIGCONT in p_sigignore,
12139513Skarels 	 * as we have to restart the process.
12239513Skarels 	 */
12339513Skarels 	if (sa->sa_handler == SIG_IGN ||
12447540Skarels 	    (sigprop[sig] & SA_IGNORE && sa->sa_handler == SIG_DFL)) {
12512951Ssam 		p->p_sig &= ~bit;		/* never to be seen again */
12639513Skarels 		if (sig != SIGCONT)
12739513Skarels 			p->p_sigignore |= bit;	/* easier in psignal */
12812951Ssam 		p->p_sigcatch &= ~bit;
12912882Ssam 	} else {
13012951Ssam 		p->p_sigignore &= ~bit;
13139513Skarels 		if (sa->sa_handler == SIG_DFL)
13212951Ssam 			p->p_sigcatch &= ~bit;
13312882Ssam 		else
13412951Ssam 			p->p_sigcatch |= bit;
13512882Ssam 	}
13612882Ssam 	(void) spl0();
13712882Ssam }
13812882Ssam 
13939513Skarels /*
14039513Skarels  * Initialize signal state for process 0;
14139513Skarels  * set to ignore signals that are ignored by default.
14239513Skarels  */
14347540Skarels void
14439513Skarels siginit(p)
14539513Skarels 	struct proc *p;
1467421Sroot {
14747540Skarels 	register int i;
14839513Skarels 
14947540Skarels 	for (i = 0; i < NSIG; i++)
15047540Skarels 		if (sigprop[i] & SA_IGNORE && i != SIGCONT)
15147540Skarels 			p->p_sigignore |= sigmask(i);
15239513Skarels }
15339513Skarels 
15439513Skarels /*
15539513Skarels  * Reset signals for an exec of the specified process.
15639513Skarels  */
15747540Skarels void
15839513Skarels execsigs(p)
15939513Skarels 	register struct proc *p;
16039513Skarels {
16147540Skarels 	register struct sigacts *ps = p->p_sigacts;
16239513Skarels 	register int nc, mask;
16339513Skarels 
16439513Skarels 	/*
16539513Skarels 	 * Reset caught signals.  Held signals remain held
16639513Skarels 	 * through p_sigmask (unless they were caught,
16739513Skarels 	 * and are now ignored by default).
16839513Skarels 	 */
16939513Skarels 	while (p->p_sigcatch) {
17039513Skarels 		nc = ffs((long)p->p_sigcatch);
17139513Skarels 		mask = sigmask(nc);
17239513Skarels 		p->p_sigcatch &= ~mask;
17347540Skarels 		if (sigprop[nc] & SA_IGNORE) {
17439513Skarels 			if (nc != SIGCONT)
17539513Skarels 				p->p_sigignore |= mask;
17639513Skarels 			p->p_sig &= ~mask;
17739513Skarels 		}
17847540Skarels 		ps->ps_sigact[nc] = SIG_DFL;
17939513Skarels 	}
18039513Skarels 	/*
18139513Skarels 	 * Reset stack state to the user stack.
18239513Skarels 	 * Clear set of signals caught on the signal stack.
18339513Skarels 	 */
18447540Skarels 	ps->ps_onstack = 0;
18547540Skarels 	ps->ps_sigsp = 0;
18647540Skarels 	ps->ps_sigonstack = 0;
18739513Skarels }
18839513Skarels 
18939513Skarels /*
19039513Skarels  * Manipulate signal mask.
19139513Skarels  * Note that we receive new mask, not pointer,
19239513Skarels  * and return old mask as return value;
19339513Skarels  * the library stub does the rest.
19439513Skarels  */
19542920Skarels sigprocmask(p, uap, retval)
19642920Skarels 	register struct proc *p;
19742920Skarels 	struct args {
19839513Skarels 		int	how;
19939513Skarels 		sigset_t mask;
20042920Skarels 	} *uap;
20142920Skarels 	int *retval;
20242920Skarels {
20339513Skarels 	int error = 0;
20439513Skarels 
20542920Skarels 	*retval = p->p_sigmask;
20639513Skarels 	(void) splhigh();
20739513Skarels 
20839513Skarels 	switch (uap->how) {
20939513Skarels 	case SIG_BLOCK:
21039513Skarels 		p->p_sigmask |= uap->mask &~ sigcantmask;
21139513Skarels 		break;
21239513Skarels 
21339513Skarels 	case SIG_UNBLOCK:
21439513Skarels 		p->p_sigmask &= ~uap->mask;
21539513Skarels 		break;
21639513Skarels 
21739513Skarels 	case SIG_SETMASK:
21839513Skarels 		p->p_sigmask = uap->mask &~ sigcantmask;
21939513Skarels 		break;
22039513Skarels 
22139513Skarels 	default:
22239513Skarels 		error = EINVAL;
22339513Skarels 		break;
22439513Skarels 	}
22539513Skarels 	(void) spl0();
22644405Skarels 	return (error);
22739513Skarels }
22839513Skarels 
22942920Skarels /* ARGSUSED */
23042920Skarels sigpending(p, uap, retval)
23142920Skarels 	struct proc *p;
23242920Skarels 	void *uap;
23342920Skarels 	int *retval;
23439513Skarels {
23539513Skarels 
23642920Skarels 	*retval = p->p_sig;
23744405Skarels 	return (0);
23839513Skarels }
23939513Skarels 
24039513Skarels #ifdef COMPAT_43
24139513Skarels /*
24239513Skarels  * Generalized interface signal handler, 4.3-compatible.
24339513Skarels  */
24442920Skarels /* ARGSUSED */
24542920Skarels osigvec(p, uap, retval)
24642920Skarels 	struct proc *p;
24742920Skarels 	register struct args {
24839513Skarels 		int	signo;
24939513Skarels 		struct	sigvec *nsv;
25039513Skarels 		struct	sigvec *osv;
25142920Skarels 	} *uap;
25242920Skarels 	int *retval;
25342920Skarels {
25439513Skarels 	struct sigvec vec;
25547540Skarels 	register struct sigacts *ps = p->p_sigacts;
25639513Skarels 	register struct sigvec *sv;
25739513Skarels 	register int sig;
25839513Skarels 	int bit, error;
25939513Skarels 
26039513Skarels 	sig = uap->signo;
26139513Skarels 	if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
26244405Skarels 		return (EINVAL);
26339513Skarels 	sv = &vec;
26439513Skarels 	if (uap->osv) {
26547540Skarels 		*(sig_t *)&sv->sv_handler = ps->ps_sigact[sig];
26647540Skarels 		sv->sv_mask = ps->ps_catchmask[sig];
26739513Skarels 		bit = sigmask(sig);
26839513Skarels 		sv->sv_flags = 0;
26947540Skarels 		if ((ps->ps_sigonstack & bit) != 0)
27039513Skarels 			sv->sv_flags |= SV_ONSTACK;
27147540Skarels 		if ((ps->ps_sigintr & bit) != 0)
27239513Skarels 			sv->sv_flags |= SV_INTERRUPT;
27342920Skarels 		if (p->p_flag & SNOCLDSTOP)
27439513Skarels 			sv->sv_flags |= SA_NOCLDSTOP;
27539513Skarels 		if (error = copyout((caddr_t)sv, (caddr_t)uap->osv,
27639513Skarels 		    sizeof (vec)))
27744405Skarels 			return (error);
27839513Skarels 	}
27939513Skarels 	if (uap->nsv) {
28039513Skarels 		if (error = copyin((caddr_t)uap->nsv, (caddr_t)sv,
28139513Skarels 		    sizeof (vec)))
28244405Skarels 			return (error);
28339513Skarels 		sv->sv_flags ^= SA_RESTART;	/* opposite of SV_INTERRUPT */
28442920Skarels 		setsigvec(p, sig, (struct sigaction *)sv);
28539513Skarels 	}
28644405Skarels 	return (0);
28739513Skarels }
28839513Skarels 
28942920Skarels osigblock(p, uap, retval)
29042920Skarels 	register struct proc *p;
29142920Skarels 	struct args {
29242920Skarels 		int	mask;
29342920Skarels 	} *uap;
29442920Skarels 	int *retval;
29539513Skarels {
2967499Sroot 
29717153Sbloom 	(void) splhigh();
29842920Skarels 	*retval = p->p_sigmask;
29939513Skarels 	p->p_sigmask |= uap->mask &~ sigcantmask;
30012882Ssam 	(void) spl0();
30144405Skarels 	return (0);
3027499Sroot }
3037499Sroot 
30442920Skarels osigsetmask(p, uap, retval)
30542920Skarels 	struct proc *p;
30642920Skarels 	struct args {
30742920Skarels 		int	mask;
30842920Skarels 	} *uap;
30942920Skarels 	int *retval;
3107499Sroot {
3117499Sroot 
31217153Sbloom 	(void) splhigh();
31342920Skarels 	*retval = p->p_sigmask;
31439513Skarels 	p->p_sigmask = uap->mask &~ sigcantmask;
31512882Ssam 	(void) spl0();
31644405Skarels 	return (0);
3177499Sroot }
31839513Skarels #endif
3197499Sroot 
32039513Skarels /*
32139513Skarels  * Suspend process until signal, providing mask to be set
32239513Skarels  * in the meantime.  Note nonstandard calling convention:
32339513Skarels  * libc stub passes mask, not pointer, to save a copyin.
32439513Skarels  */
32542920Skarels /* ARGSUSED */
32642920Skarels sigsuspend(p, uap, retval)
32742920Skarels 	register struct proc *p;
32842920Skarels 	struct args {
32942920Skarels 		sigset_t mask;
33042920Skarels 	} *uap;
33142920Skarels 	int *retval;
3327499Sroot {
33347540Skarels 	register struct sigacts *ps = p->p_sigacts;
3347499Sroot 
33512882Ssam 	/*
33612882Ssam 	 * When returning from sigpause, we want
33712882Ssam 	 * the old mask to be restored after the
33812882Ssam 	 * signal handler has finished.  Thus, we
339*52115Skarels 	 * save it here and mark the sigacts structure
340*52115Skarels 	 * to indicate this.
34112882Ssam 	 */
34247540Skarels 	ps->ps_oldmask = p->p_sigmask;
34347540Skarels 	ps->ps_flags |= SA_OLDMASK;
34439513Skarels 	p->p_sigmask = uap->mask &~ sigcantmask;
34547540Skarels 	(void) tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0);
34640807Smarc 	/* always return EINTR rather than ERESTART... */
34744405Skarels 	return (EINTR);
3487499Sroot }
3497499Sroot 
35042920Skarels /* ARGSUSED */
35142920Skarels sigstack(p, uap, retval)
35242920Skarels 	struct proc *p;
35342920Skarels 	register struct args {
35412951Ssam 		struct	sigstack *nss;
35512951Ssam 		struct	sigstack *oss;
35642920Skarels 	} *uap;
35742920Skarels 	int *retval;
35842920Skarels {
35912951Ssam 	struct sigstack ss;
36039513Skarels 	int error = 0;
3617499Sroot 
36247540Skarels 	if (uap->oss && (error = copyout((caddr_t)&p->p_sigacts->ps_sigstack,
36339513Skarels 	    (caddr_t)uap->oss, sizeof (struct sigstack))))
36444405Skarels 		return (error);
36539513Skarels 	if (uap->nss && (error = copyin((caddr_t)uap->nss, (caddr_t)&ss,
36639513Skarels 	    sizeof (ss))) == 0)
36747540Skarels 		p->p_sigacts->ps_sigstack = ss;
36844405Skarels 	return (error);
3697499Sroot }
3707499Sroot 
37142920Skarels /* ARGSUSED */
37242920Skarels kill(cp, uap, retval)
37342920Skarels 	register struct proc *cp;
37442920Skarels 	register struct args {
37512882Ssam 		int	pid;
37612882Ssam 		int	signo;
37742920Skarels 	} *uap;
37842920Skarels 	int *retval;
37942920Skarels {
38018336Smckusick 	register struct proc *p;
38147540Skarels 	register struct pcred *pc = cp->p_cred;
3828032Sroot 
38339513Skarels 	if ((unsigned) uap->signo >= NSIG)
38444405Skarels 		return (EINVAL);
38518336Smckusick 	if (uap->pid > 0) {
38618336Smckusick 		/* kill single process */
38718336Smckusick 		p = pfind(uap->pid);
38839513Skarels 		if (p == 0)
38944405Skarels 			return (ESRCH);
39047540Skarels 		if (!CANSIGNAL(cp, pc, p, uap->signo))
39144405Skarels 			return (EPERM);
39239513Skarels 		if (uap->signo)
39318336Smckusick 			psignal(p, uap->signo);
39444405Skarels 		return (0);
39518336Smckusick 	}
39618336Smckusick 	switch (uap->pid) {
39718336Smckusick 	case -1:		/* broadcast signal */
39844405Skarels 		return (killpg1(cp, uap->signo, 0, 1));
39918336Smckusick 	case 0:			/* signal own process group */
40044405Skarels 		return (killpg1(cp, uap->signo, 0, 0));
40118336Smckusick 	default:		/* negative explicit process group */
40244405Skarels 		return (killpg1(cp, uap->signo, -uap->pid, 0));
40318336Smckusick 	}
40439513Skarels 	/* NOTREACHED */
4058032Sroot }
4068032Sroot 
40739513Skarels #ifdef COMPAT_43
40842920Skarels /* ARGSUSED */
40942920Skarels okillpg(p, uap, retval)
41042920Skarels 	struct proc *p;
41142920Skarels 	register struct args {
41237581Smckusick 		int	pgid;
4139989Ssam 		int	signo;
41442920Skarels 	} *uap;
41542920Skarels 	int *retval;
41642920Skarels {
4178032Sroot 
41839513Skarels 	if ((unsigned) uap->signo >= NSIG)
41944405Skarels 		return (EINVAL);
42044405Skarels 	return (killpg1(p, uap->signo, uap->pgid, 0));
4218032Sroot }
42239513Skarels #endif
4238032Sroot 
42442920Skarels /*
42542920Skarels  * Common code for kill process group/broadcast kill.
42642920Skarels  * cp is calling process.
42742920Skarels  */
42842920Skarels killpg1(cp, signo, pgid, all)
42942920Skarels 	register struct proc *cp;
43037581Smckusick 	int signo, pgid, all;
4319989Ssam {
4329989Ssam 	register struct proc *p;
43347540Skarels 	register struct pcred *pc = cp->p_cred;
43437581Smckusick 	struct pgrp *pgrp;
43547540Skarels 	int nfound = 0;
43637581Smckusick 
43737581Smckusick 	if (all)
43837581Smckusick 		/*
43937581Smckusick 		 * broadcast
4407421Sroot 		 */
44137581Smckusick 		for (p = allproc; p != NULL; p = p->p_nxt) {
44247540Skarels 			if (p->p_pid <= 1 || p->p_flag&SSYS ||
44347540Skarels 			    p == cp || !CANSIGNAL(cp, pc, p, signo))
44437581Smckusick 				continue;
44547540Skarels 			nfound++;
44637581Smckusick 			if (signo)
44737581Smckusick 				psignal(p, signo);
44837581Smckusick 		}
44937581Smckusick 	else {
45037581Smckusick 		if (pgid == 0)
45137581Smckusick 			/*
45237581Smckusick 			 * zero pgid means send to my process group.
45337581Smckusick 			 */
45447540Skarels 			pgrp = cp->p_pgrp;
45537581Smckusick 		else {
45637581Smckusick 			pgrp = pgfind(pgid);
45737581Smckusick 			if (pgrp == NULL)
45839513Skarels 				return (ESRCH);
45937581Smckusick 		}
46037581Smckusick 		for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) {
46147540Skarels 			if (p->p_pid <= 1 || p->p_flag&SSYS ||
46250128Skarels 			    p->p_stat == SZOMB || !CANSIGNAL(cp, pc, p, signo))
46337581Smckusick 				continue;
46447540Skarels 			nfound++;
46537581Smckusick 			if (signo)
46637581Smckusick 				psignal(p, signo);
46718336Smckusick 		}
4687421Sroot 	}
46947540Skarels 	return (nfound ? 0 : ESRCH);
4707421Sroot }
4717421Sroot 
47242920Skarels /*
4737421Sroot  * Send the specified signal to
47437581Smckusick  * all processes with 'pgid' as
4757421Sroot  * process group.
4767421Sroot  */
47747540Skarels void
47837581Smckusick gsignal(pgid, sig)
47947540Skarels 	int pgid, sig;
4807421Sroot {
48139513Skarels 	struct pgrp *pgrp;
4827421Sroot 
48339513Skarels 	if (pgid && (pgrp = pgfind(pgid)))
48442207Smarc 		pgsignal(pgrp, sig, 0);
4857421Sroot }
48642920Skarels 
48740807Smarc /*
48842207Smarc  * Send sig to every member of a process group.
48942207Smarc  * If checktty is 1, limit to members which have a controlling
49042207Smarc  * terminal.
49140807Smarc  */
49247540Skarels void
49342207Smarc pgsignal(pgrp, sig, checkctty)
49439513Skarels 	struct pgrp *pgrp;
49547540Skarels 	int sig, checkctty;
49637581Smckusick {
49737581Smckusick 	register struct proc *p;
49837581Smckusick 
49940807Smarc 	if (pgrp)
50040807Smarc 		for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt)
50142207Smarc 			if (checkctty == 0 || p->p_flag&SCTTY)
50242207Smarc 				psignal(p, sig);
50337581Smckusick }
50437581Smckusick 
5057421Sroot /*
50639513Skarels  * Send a signal caused by a trap to the current process.
50739513Skarels  * If it will be caught immediately, deliver it with correct code.
50839513Skarels  * Otherwise, post it normally.
50939513Skarels  */
51047540Skarels void
51147540Skarels trapsignal(p, sig, code)
51247540Skarels 	struct proc *p;
51339513Skarels 	register int sig;
51439513Skarels 	unsigned code;
51539513Skarels {
51647540Skarels 	register struct sigacts *ps = p->p_sigacts;
51739513Skarels 	int mask;
51839513Skarels 
51939513Skarels 	mask = sigmask(sig);
52039513Skarels 	if ((p->p_flag & STRC) == 0 && (p->p_sigcatch & mask) != 0 &&
52139513Skarels 	    (p->p_sigmask & mask) == 0) {
52247540Skarels 		p->p_stats->p_ru.ru_nsignals++;
52340807Smarc #ifdef KTRACE
52440807Smarc 		if (KTRPOINT(p, KTR_PSIG))
52547540Skarels 			ktrpsig(p->p_tracep, sig, ps->ps_sigact[sig],
52640807Smarc 				p->p_sigmask, code);
52740807Smarc #endif
52847540Skarels 		sendsig(ps->ps_sigact[sig], sig, p->p_sigmask, code);
52947540Skarels 		p->p_sigmask |= ps->ps_catchmask[sig] | mask;
53039513Skarels 	} else {
53147540Skarels 		ps->ps_code = code;	/* XXX for core dump/debugger */
53239513Skarels 		psignal(p, sig);
53339513Skarels 	}
53439513Skarels }
53539513Skarels 
53639513Skarels /*
53740807Smarc  * Send the specified signal to the specified process.
53847540Skarels  * If the signal has an action, the action is usually performed
53947540Skarels  * by the target process rather than the caller; we simply add
54047540Skarels  * the signal to the set of pending signals for the process.
54140807Smarc  * Exceptions:
54240807Smarc  *   o When a stop signal is sent to a sleeping process that takes the default
54340807Smarc  *     action, the process is stopped without awakening it.
54440807Smarc  *   o SIGCONT restarts stopped processes (or puts them back to sleep)
54540807Smarc  *     regardless of the signal action (eg, blocked or ignored).
54640807Smarc  * Other ignored signals are discarded immediately.
5477421Sroot  */
54847540Skarels void
5497421Sroot psignal(p, sig)
5507421Sroot 	register struct proc *p;
5517421Sroot 	register int sig;
5527421Sroot {
55347540Skarels 	register int s, prop;
55439513Skarels 	register sig_t action;
55517153Sbloom 	int mask;
5567421Sroot 
55739513Skarels 	if ((unsigned)sig >= NSIG || sig == 0)
55839513Skarels 		panic("psignal sig");
55917153Sbloom 	mask = sigmask(sig);
56047540Skarels 	prop = sigprop[sig];
5617421Sroot 
5627421Sroot 	/*
5637421Sroot 	 * If proc is traced, always give parent a chance.
5647421Sroot 	 */
5657421Sroot 	if (p->p_flag & STRC)
5667421Sroot 		action = SIG_DFL;
5677421Sroot 	else {
5687421Sroot 		/*
56912882Ssam 		 * If the signal is being ignored,
57012882Ssam 		 * then we forget about it immediately.
57139513Skarels 		 * (Note: we don't set SIGCONT in p_sigignore,
57239513Skarels 		 * and if it is set to SIG_IGN,
57339513Skarels 		 * action will be SIG_DFL here.)
5747421Sroot 		 */
57517153Sbloom 		if (p->p_sigignore & mask)
5767421Sroot 			return;
57717153Sbloom 		if (p->p_sigmask & mask)
57812882Ssam 			action = SIG_HOLD;
57917153Sbloom 		else if (p->p_sigcatch & mask)
58012882Ssam 			action = SIG_CATCH;
58142437Skarels 		else
58212882Ssam 			action = SIG_DFL;
5837421Sroot 	}
5847421Sroot 
58547540Skarels 	if (p->p_nice > NZERO && (sig == SIGKILL ||
58647540Skarels 	    sig == SIGTERM && (p->p_flag&STRC || action != SIG_DFL)))
58747540Skarels 		p->p_nice = NZERO;
5887421Sroot 
58947540Skarels 	if (prop & SA_CONT)
59039513Skarels 		p->p_sig &= ~stopsigmask;
59139513Skarels 
59247540Skarels 	if (prop & SA_STOP) {
59345672Skarels 		/*
59445672Skarels 		 * If sending a tty stop signal to a member of an orphaned
59545672Skarels 		 * process group, discard the signal here if the action
59645672Skarels 		 * is default; don't stop the process below if sleeping,
59745672Skarels 		 * and don't clear any pending SIGCONT.
59845672Skarels 		 */
59947540Skarels 		if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0 &&
60047540Skarels 		    action == SIG_DFL)
60145741Smckusick 		        return;
60247540Skarels 		p->p_sig &= ~contsigmask;
6037421Sroot 	}
60439513Skarels 	p->p_sig |= mask;
60539513Skarels 
6067421Sroot 	/*
60739513Skarels 	 * Defer further processing for signals which are held,
60839513Skarels 	 * except that stopped processes must be continued by SIGCONT.
6097421Sroot 	 */
61047540Skarels 	if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP))
6117421Sroot 		return;
61217153Sbloom 	s = splhigh();
6137421Sroot 	switch (p->p_stat) {
6147421Sroot 
6157421Sroot 	case SSLEEP:
6167421Sroot 		/*
61740807Smarc 		 * If process is sleeping uninterruptibly
6187421Sroot 		 * we can't interrupt the sleep... the signal will
6197421Sroot 		 * be noticed when the process returns through
6207421Sroot 		 * trap() or syscall().
6217421Sroot 		 */
62240807Smarc 		if ((p->p_flag & SSINTR) == 0)
6237421Sroot 			goto out;
6247421Sroot 		/*
6257421Sroot 		 * Process is sleeping and traced... make it runnable
6267421Sroot 		 * so it can discover the signal in issig() and stop
6277421Sroot 		 * for the parent.
6287421Sroot 		 */
6297421Sroot 		if (p->p_flag&STRC)
6307421Sroot 			goto run;
63139513Skarels 		/*
63239513Skarels 		 * When a sleeping process receives a stop
63339513Skarels 		 * signal, process immediately if possible.
63439513Skarels 		 * All other (caught or default) signals
63539513Skarels 		 * cause the process to run.
63639513Skarels 		 */
63747540Skarels 		if (prop & SA_STOP) {
6387421Sroot 			if (action != SIG_DFL)
63939513Skarels 				goto runfast;
6407421Sroot 			/*
64147540Skarels 			 * If a child holding parent blocked,
64247540Skarels 			 * stopping could cause deadlock.
6437421Sroot 			 */
64447540Skarels 			if (p->p_flag&SPPWAIT)
6457421Sroot 				goto out;
64617153Sbloom 			p->p_sig &= ~mask;
64743895Skarels 			p->p_xstat = sig;
64839513Skarels 			if ((p->p_pptr->p_flag & SNOCLDSTOP) == 0)
64939513Skarels 				psignal(p->p_pptr, SIGCHLD);
6507421Sroot 			stop(p);
6517421Sroot 			goto out;
65239513Skarels 		} else
65339513Skarels 			goto runfast;
6547421Sroot 		/*NOTREACHED*/
6557421Sroot 
6567421Sroot 	case SSTOP:
6577421Sroot 		/*
6587421Sroot 		 * If traced process is already stopped,
6597421Sroot 		 * then no further action is necessary.
6607421Sroot 		 */
6617421Sroot 		if (p->p_flag&STRC)
6627421Sroot 			goto out;
6637421Sroot 
66447540Skarels 		/*
66547540Skarels 		 * Kill signal always sets processes running.
66647540Skarels 		 */
66747540Skarels 		if (sig == SIGKILL)
66839513Skarels 			goto runfast;
6697421Sroot 
67047540Skarels 		if (prop & SA_CONT) {
6717421Sroot 			/*
67239513Skarels 			 * If SIGCONT is default (or ignored), we continue
67339513Skarels 			 * the process but don't leave the signal in p_sig,
67439513Skarels 			 * as it has no further action.  If SIGCONT is held,
67539513Skarels 			 * continue the process and leave the signal in p_sig.
6767421Sroot 			 * If the process catches SIGCONT, let it handle
6777421Sroot 			 * the signal itself.  If it isn't waiting on
6787421Sroot 			 * an event, then it goes back to run state.
6797421Sroot 			 * Otherwise, process goes back to sleep state.
6807421Sroot 			 */
68139513Skarels 			if (action == SIG_DFL)
68239513Skarels 				p->p_sig &= ~mask;
68339513Skarels 			if (action == SIG_CATCH)
68439513Skarels 				goto runfast;
68539513Skarels 			if (p->p_wchan == 0)
6867421Sroot 				goto run;
6877421Sroot 			p->p_stat = SSLEEP;
6887421Sroot 			goto out;
68947540Skarels 		}
6907421Sroot 
69147540Skarels 		if (prop & SA_STOP) {
6927421Sroot 			/*
6937421Sroot 			 * Already stopped, don't need to stop again.
6947421Sroot 			 * (If we did the shell could get confused.)
6957421Sroot 			 */
69617153Sbloom 			p->p_sig &= ~mask;		/* take it away */
6977421Sroot 			goto out;
6987421Sroot 		}
6997421Sroot 
70047540Skarels 		/*
70147540Skarels 		 * If process is sleeping interruptibly, then
70247540Skarels 		 * simulate a wakeup so that when it is continued,
70347540Skarels 		 * it will be made runnable and can look at the signal.
70447540Skarels 		 * But don't setrun the process, leave it stopped.
70547540Skarels 		 */
70647540Skarels 		if (p->p_wchan && p->p_flag & SSINTR)
70747540Skarels 			unsleep(p);
70847540Skarels 		goto out;
70947540Skarels 
7107421Sroot 	default:
7117421Sroot 		/*
7127421Sroot 		 * SRUN, SIDL, SZOMB do nothing with the signal,
7137421Sroot 		 * other than kicking ourselves if we are running.
7147421Sroot 		 * It will either never be noticed, or noticed very soon.
7157421Sroot 		 */
71647650Skarels 		if (p == curproc)
71749102Skarels 			signotify(p);
7187421Sroot 		goto out;
7197421Sroot 	}
7207421Sroot 	/*NOTREACHED*/
72139513Skarels 
72239513Skarels runfast:
7237421Sroot 	/*
7247421Sroot 	 * Raise priority to at least PUSER.
7257421Sroot 	 */
7267421Sroot 	if (p->p_pri > PUSER)
72717399Skarels 		p->p_pri = PUSER;
72839513Skarels run:
7297421Sroot 	setrun(p);
7307421Sroot out:
7317421Sroot 	splx(s);
7327421Sroot }
7337421Sroot 
7347421Sroot /*
73540807Smarc  * If the current process has a signal to process (should be caught
73640807Smarc  * or cause termination, should interrupt current syscall),
73740807Smarc  * return the signal number.  Stop signals with default action
73840807Smarc  * are processed immediately, then cleared; they aren't returned.
73947540Skarels  * This is checked after each entry to the system for a syscall
74047540Skarels  * or trap (though this can usually be done without actually calling
74147540Skarels  * issig by checking the pending signal masks in the CURSIG macro.)
74247540Skarels  * The normal call sequence is
74347540Skarels  *
74447540Skarels  *	while (sig = CURSIG(curproc))
74547540Skarels  *		psig(sig);
7467421Sroot  */
74747540Skarels issig(p)
74847540Skarels 	register struct proc *p;
7497421Sroot {
75047540Skarels 	register int sig, mask, prop;
7517421Sroot 
7527421Sroot 	for (;;) {
75339513Skarels 		mask = p->p_sig &~ p->p_sigmask;
75447540Skarels 		if (p->p_flag&SPPWAIT)
75539513Skarels 			mask &= ~stopsigmask;
75640807Smarc 		if (mask == 0)	 	/* no signal to send */
75740807Smarc 			return (0);
75839513Skarels 		sig = ffs((long)mask);
75917153Sbloom 		mask = sigmask(sig);
76047540Skarels 		prop = sigprop[sig];
76140807Smarc 		/*
76240807Smarc 		 * We should see pending but ignored signals
76340807Smarc 		 * only if STRC was on when they were posted.
76440807Smarc 		 */
76540807Smarc 		if (mask & p->p_sigignore && (p->p_flag&STRC) == 0) {
76640807Smarc 			p->p_sig &= ~mask;
76740807Smarc 			continue;
76840807Smarc 		}
76947540Skarels 		if (p->p_flag&STRC && (p->p_flag&SPPWAIT) == 0) {
7707421Sroot 			/*
7717421Sroot 			 * If traced, always stop, and stay
7727421Sroot 			 * stopped until released by the parent.
7737421Sroot 			 */
77443895Skarels 			p->p_xstat = sig;
77518331Skarels 			psignal(p->p_pptr, SIGCHLD);
7767421Sroot 			do {
7777421Sroot 				stop(p);
7787421Sroot 				swtch();
77942926Smckusick 			} while (!procxmt(p) && p->p_flag&STRC);
7807421Sroot 
7817421Sroot 			/*
78214782Ssam 			 * If the traced bit got turned off,
78340807Smarc 			 * go back up to the top to rescan signals.
78447650Skarels 			 * This ensures that p_sig* and ps_sigact
78547650Skarels 			 * are consistent.
7867421Sroot 			 */
78740807Smarc 			if ((p->p_flag&STRC) == 0)
7887421Sroot 				continue;
7897421Sroot 
7907421Sroot 			/*
7917421Sroot 			 * If parent wants us to take the signal,
79243895Skarels 			 * then it will leave it in p->p_xstat;
7937421Sroot 			 * otherwise we just look for signals again.
7947421Sroot 			 */
79540807Smarc 			p->p_sig &= ~mask;	/* clear the old signal */
79643895Skarels 			sig = p->p_xstat;
7977421Sroot 			if (sig == 0)
7987421Sroot 				continue;
79914782Ssam 
80014782Ssam 			/*
80140807Smarc 			 * Put the new signal into p_sig.
80240807Smarc 			 * If signal is being masked,
80340807Smarc 			 * look for other signals.
80414782Ssam 			 */
80517153Sbloom 			mask = sigmask(sig);
80640807Smarc 			p->p_sig |= mask;
80740807Smarc 			if (p->p_sigmask & mask)
80814782Ssam 				continue;
8097421Sroot 		}
81040807Smarc 
81140807Smarc 		/*
81240807Smarc 		 * Decide whether the signal should be returned.
81340807Smarc 		 * Return the signal's number, or fall through
81440807Smarc 		 * to clear it from the pending mask.
81540807Smarc 		 */
81647540Skarels 		switch ((int)p->p_sigacts->ps_sigact[sig]) {
8177421Sroot 
8187421Sroot 		case SIG_DFL:
8197421Sroot 			/*
8207421Sroot 			 * Don't take default actions on system processes.
8217421Sroot 			 */
82251019Sralph 			if (p->p_pid <= 1) {
82351019Sralph #ifdef DIAGNOSTIC
82451019Sralph 				/*
82551019Sralph 				 * Are you sure you want to ignore SIGSEGV
82651019Sralph 				 * in init? XXX
82751019Sralph 				 */
82851019Sralph 				printf("Process (pid %d) got signal %d\n",
82951019Sralph 					p->p_pid, sig);
83051019Sralph #endif
83140807Smarc 				break;		/* == ignore */
83251019Sralph 			}
83340807Smarc 			/*
83440807Smarc 			 * If there is a pending stop signal to process
83540807Smarc 			 * with default action, stop here,
83642437Skarels 			 * then clear the signal.  However,
83742437Skarels 			 * if process is member of an orphaned
83842437Skarels 			 * process group, ignore tty stop signals.
83940807Smarc 			 */
84047540Skarels 			if (prop & SA_STOP) {
84142437Skarels 				if (p->p_flag&STRC ||
84242437Skarels 		    		    (p->p_pgrp->pg_jobc == 0 &&
84347540Skarels 				    prop & SA_TTYSTOP))
84440807Smarc 					break;	/* == ignore */
84543895Skarels 				p->p_xstat = sig;
8467421Sroot 				stop(p);
84739513Skarels 				if ((p->p_pptr->p_flag & SNOCLDSTOP) == 0)
84839513Skarels 					psignal(p->p_pptr, SIGCHLD);
8497421Sroot 				swtch();
85040807Smarc 				break;
85147540Skarels 			} else if (prop & SA_IGNORE) {
8527421Sroot 				/*
85339513Skarels 				 * Except for SIGCONT, shouldn't get here.
85439513Skarels 				 * Default action is to ignore; drop it.
8557421Sroot 				 */
85640807Smarc 				break;		/* == ignore */
85739513Skarels 			} else
85840807Smarc 				return (sig);
8597421Sroot 			/*NOTREACHED*/
8607421Sroot 
8617421Sroot 		case SIG_IGN:
8627421Sroot 			/*
86339513Skarels 			 * Masking above should prevent us ever trying
86439513Skarels 			 * to take action on an ignored signal other
86539513Skarels 			 * than SIGCONT, unless process is traced.
8667421Sroot 			 */
86747540Skarels 			if ((prop & SA_CONT) == 0 && (p->p_flag&STRC) == 0)
8687421Sroot 				printf("issig\n");
86940807Smarc 			break;		/* == ignore */
8707421Sroot 
8717421Sroot 		default:
8727421Sroot 			/*
8737421Sroot 			 * This signal has an action, let
8747421Sroot 			 * psig process it.
8757421Sroot 			 */
87640807Smarc 			return (sig);
8777421Sroot 		}
87840807Smarc 		p->p_sig &= ~mask;		/* take the signal! */
8797421Sroot 	}
88040807Smarc 	/* NOTREACHED */
8817421Sroot }
8827421Sroot 
8837421Sroot /*
8847421Sroot  * Put the argument process into the stopped
88518331Skarels  * state and notify the parent via wakeup.
88618331Skarels  * Signals are handled elsewhere.
88740807Smarc  * The process must not be on the run queue.
8887421Sroot  */
8897421Sroot stop(p)
8907421Sroot 	register struct proc *p;
8917421Sroot {
8927421Sroot 
8937421Sroot 	p->p_stat = SSTOP;
8947421Sroot 	p->p_flag &= ~SWTED;
8957421Sroot 	wakeup((caddr_t)p->p_pptr);
8967421Sroot }
8977421Sroot 
8987421Sroot /*
89947540Skarels  * Take the action for the specified signal
90047540Skarels  * from the current set of pending signals.
9017421Sroot  */
90247540Skarels void
90340807Smarc psig(sig)
90440807Smarc 	register int sig;
9057421Sroot {
90647540Skarels 	register struct proc *p = curproc;
90747540Skarels 	register struct sigacts *ps = p->p_sigacts;
90847540Skarels 	register sig_t action;
90939513Skarels 	int mask, returnmask;
9107421Sroot 
91140807Smarc #ifdef DIAGNOSTIC
91247540Skarels 	if (sig == 0)
91347540Skarels 		panic("psig");
91440807Smarc #endif
91547540Skarels 	mask = sigmask(sig);
91647540Skarels 	p->p_sig &= ~mask;
91747540Skarels 	action = ps->ps_sigact[sig];
91840807Smarc #ifdef KTRACE
91947540Skarels 	if (KTRPOINT(p, KTR_PSIG))
92047540Skarels 		ktrpsig(p->p_tracep, sig, action, ps->ps_flags & SA_OLDMASK ?
92147540Skarels 		    ps->ps_oldmask : p->p_sigmask, 0);
92240807Smarc #endif
92347540Skarels 	if (action == SIG_DFL) {
92447540Skarels 		/*
92547540Skarels 		 * Default action, where the default is to kill
92647540Skarels 		 * the process.  (Other cases were ignored above.)
92747540Skarels 		 */
92847650Skarels 		sigexit(p, sig);
92947540Skarels 		/* NOTREACHED */
93047540Skarels 	} else {
93147540Skarels 		/*
93247540Skarels 		 * If we get here, the signal must be caught.
93347540Skarels 		 */
93439513Skarels #ifdef DIAGNOSTIC
93547540Skarels 		if (action == SIG_IGN || (p->p_sigmask & mask))
93647540Skarels 			panic("psig action");
93739513Skarels #endif
93847540Skarels 		/*
93947540Skarels 		 * Set the new mask value and also defer further
94047540Skarels 		 * occurences of this signal.
94147540Skarels 		 *
94247540Skarels 		 * Special case: user has done a sigpause.  Here the
94347540Skarels 		 * current mask is not of interest, but rather the
94447540Skarels 		 * mask from before the sigpause is what we want
94547540Skarels 		 * restored after the signal processing is completed.
94647540Skarels 		 */
94747540Skarels 		(void) splhigh();
94847540Skarels 		if (ps->ps_flags & SA_OLDMASK) {
94947540Skarels 			returnmask = ps->ps_oldmask;
95047540Skarels 			ps->ps_flags &= ~SA_OLDMASK;
95147540Skarels 		} else
95247540Skarels 			returnmask = p->p_sigmask;
95347540Skarels 		p->p_sigmask |= ps->ps_catchmask[sig] | mask;
95447540Skarels 		(void) spl0();
95547540Skarels 		p->p_stats->p_ru.ru_nsignals++;
95647540Skarels 		sendsig(action, sig, returnmask, 0);
95747540Skarels 	}
9587421Sroot }
9597421Sroot 
9607421Sroot /*
96147650Skarels  * Force the current process to exit with the specified
96247650Skarels  * signal, dumping core if appropriate.  We bypass the normal
96347650Skarels  * tests for masked and caught signals, allowing unrecoverable
96447650Skarels  * failures to terminate the process without changing signal state.
96547650Skarels  * Mark the accounting record with the signal termination.
96647650Skarels  * If dumping core, save the signal number for the debugger.
96747650Skarels  * Calls exit and does not return.
96847650Skarels  */
96947650Skarels sigexit(p, sig)
97047650Skarels 	register struct proc *p;
97147650Skarels 	int sig;
97247650Skarels {
97347650Skarels 
97447650Skarels 	p->p_acflag |= AXSIG;
97547650Skarels 	if (sigprop[sig] & SA_CORE) {
97647650Skarels 		p->p_sigacts->ps_sig = sig;
97747650Skarels 		if (coredump(p) == 0)
97847650Skarels 			sig |= WCOREFLAG;
97947650Skarels 	}
98047650Skarels 	exit(p, W_EXITCODE(0, sig));
98147650Skarels 	/* NOTREACHED */
98247650Skarels }
98347650Skarels 
98447650Skarels /*
98547540Skarels  * Create a core dump.
98650244Skarels  * The file name is "core.progname".
98750099Smckusick  * Core dumps are not created if the process is setuid.
9887421Sroot  */
98947540Skarels coredump(p)
99047540Skarels 	register struct proc *p;
9917421Sroot {
99237728Smckusick 	register struct vnode *vp;
99347540Skarels 	register struct pcred *pcred = p->p_cred;
99447540Skarels 	register struct ucred *cred = pcred->pc_ucred;
99547540Skarels 	register struct vmspace *vm = p->p_vmspace;
99637580Smckusick 	struct vattr vattr;
99750105Smckusick 	int error, error1;
99847540Skarels 	struct nameidata nd;
99950244Skarels 	char name[MAXCOMLEN+6];	/* core.progname */
10007421Sroot 
100147540Skarels 	if (pcred->p_svuid != pcred->p_ruid ||
100247540Skarels 	    pcred->p_svgid != pcred->p_rgid)
100337580Smckusick 		return (EFAULT);
100447540Skarels 	if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >=
100547540Skarels 	    p->p_rlimit[RLIMIT_CORE].rlim_cur)
100637580Smckusick 		return (EFAULT);
100750244Skarels 	sprintf(name, "core.%s", p->p_comm);
100850099Smckusick 	nd.ni_dirp = name;
100947540Skarels 	nd.ni_segflg = UIO_SYSSPACE;
101049913Smckusick 	if (error = vn_open(&nd, p, O_CREAT|FWRITE, 0644))
101137580Smckusick 		return (error);
101247540Skarels 	vp = nd.ni_vp;
101348020Smckusick 	if (vp->v_type != VREG || VOP_GETATTR(vp, &vattr, cred, p) ||
101437580Smckusick 	    vattr.va_nlink != 1) {
101550105Smckusick 		error = EFAULT;
101650105Smckusick 		goto out;
10177818Sroot 	}
101841362Smckusick 	VATTR_NULL(&vattr);
101937580Smckusick 	vattr.va_size = 0;
102048020Smckusick 	VOP_SETATTR(vp, &vattr, cred, p);
102147540Skarels 	p->p_acflag |= ACORE;
102249102Skarels 	bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc));
102349102Skarels 	fill_eproc(p, &p->p_addr->u_kproc.kp_eproc);
102442004Smckusick #ifdef HPUXCOMPAT
102542004Smckusick 	/*
102642004Smckusick 	 * BLETCH!  If we loaded from an HPUX format binary file
102742004Smckusick 	 * we have to dump an HPUX style user struct so that the
102842004Smckusick 	 * HPUX debuggers can grok it.
102942004Smckusick 	 */
103049102Skarels 	if (p->p_addr->u_pcb.pcb_flags & PCB_HPUXBIN)
103147540Skarels 		error = hpuxdumpu(vp, cred);
103242004Smckusick 	else
103342004Smckusick #endif
103449102Skarels 	error = vn_rdwr(UIO_WRITE, vp, (caddr_t) p->p_addr, ctob(UPAGES),
103549102Skarels 	    (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) NULL,
103649102Skarels 	    p);
103737580Smckusick 	if (error == 0)
103847540Skarels 		error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr,
103947540Skarels 		    (int)ctob(vm->vm_dsize), (off_t)ctob(UPAGES), UIO_USERSPACE,
104049102Skarels 		    IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p);
104137580Smckusick 	if (error == 0)
104237580Smckusick 		error = vn_rdwr(UIO_WRITE, vp,
104349102Skarels 		    (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)),
104447540Skarels 		    round_page(ctob(vm->vm_ssize)),
104547540Skarels 		    (off_t)ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE,
104649102Skarels 		    IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p);
104750105Smckusick out:
104850105Smckusick 	VOP_UNLOCK(vp);
104950105Smckusick 	error1 = vn_close(vp, FWRITE, cred, p);
105050244Skarels 	if (error == 0)
105150105Smckusick 		error = error1;
105237580Smckusick 	return (error);
10537421Sroot }
105439513Skarels 
105539513Skarels /*
105639513Skarels  * Nonexistent system call-- signal process (may want to handle it).
105739513Skarels  * Flag error in case process won't see signal immediately (blocked or ignored).
105839513Skarels  */
105943364Smckusick /* ARGSUSED */
106043364Smckusick nosys(p, args, retval)
106143364Smckusick 	struct proc *p;
106243364Smckusick 	void *args;
106343364Smckusick 	int *retval;
106439513Skarels {
106539513Skarels 
106643364Smckusick 	psignal(p, SIGSYS);
106744405Skarels 	return (EINVAL);
106839513Skarels }
1069