3 files changed, 136 insertions, 296 deletions

diff --git a/sys/compat/freebsd32/freebsd32_misc.c b/sys/compat/freebsd32/freebsd32_misc.c
index c6f26fe7038ea..c1cdd20376643 100644
--- a/sys/compat/freebsd32/freebsd32_misc.c
+++ b/sys/compat/freebsd32/freebsd32_misc.c
@@ -56,6 +56,7 @@
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/stat.h>
+#include <sys/syscallsubr.h>
 #include <sys/sysctl.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
@@ -358,43 +359,26 @@ struct sigaltstack32 {
 int
 ia32_sigaltstack(struct thread *td, struct ia32_sigaltstack_args *uap)
 {
+	struct sigaltstack32 s32;
+	struct sigaltstack ss, oss, *ssp;
 	int error;
-	caddr_t sg;
-	struct sigaltstack32 *p32, *op32, s32;
-	struct sigaltstack *p = NULL, *op = NULL, s;
 
-	p32 = uap->ss;
-	if (p32) {
-		sg = stackgap_init();
-		p = stackgap_alloc(&sg, sizeof(struct sigaltstack));
-		uap->ss = (struct sigaltstack32 *)p;
-		error = copyin(p32, &s32, sizeof(s32));
-		if (error)
-			return (error);
-		PTRIN_CP(s32, s, ss_sp);
-		CP(s32, s, ss_size);
-		CP(s32, s, ss_flags);
-		error = copyout(&s, p, sizeof(s));
-		if (error)
-			return (error);
-	}
-	op32 = uap->oss;
-	if (op32) {
-		sg = stackgap_init();
-		op = stackgap_alloc(&sg, sizeof(struct sigaltstack));
-		uap->oss = (struct sigaltstack32 *)op;
-	}
-	error = sigaltstack(td, (struct sigaltstack_args *) uap);
-	if (error)
-		return (error);
-	if (op32) {
-		error = copyin(op, &s, sizeof(s));
+	if (uap->ss != NULL) {
+		error = copyin(uap->ss, &s32, sizeof(s32));
 		if (error)
 			return (error);
-		PTROUT_CP(s, s32, ss_sp);
-		CP(s, s32, ss_size);
-		CP(s, s32, ss_flags);
-		error = copyout(&s32, op32, sizeof(s32));
+		PTRIN_CP(s32, ss, ss_sp);
+		CP(s32, ss, ss_size);
+		CP(s32, ss, ss_flags);
+		ssp = &ss;
+	} else
+		ssp = NULL;
+	error = kern_sigaltstack(td, ssp, &oss);
+	if (error == 0 && uap->oss != NULL) {
+		PTROUT_CP(oss, s32, ss_sp);
+		CP(oss, s32, ss_size);
+		CP(oss, s32, ss_flags);
+		error = copyout(&s32, uap->oss, sizeof(s32));
 	}
 	return (error);
 }
@@ -1279,43 +1263,26 @@ struct sigaction32 {
 int
 ia32_sigaction(struct thread *td, struct ia32_sigaction_args *uap)
 {
+	struct sigaction32 s32;
+	struct sigaction sa, osa, *sap;
 	int error;
-	caddr_t sg;
-	struct sigaction32 *p32, *op32, s32;
-	struct sigaction *p = NULL, *op = NULL, s;
 
-	p32 = uap->act;
-	if (p32) {
-		sg = stackgap_init();
-		p = stackgap_alloc(&sg, sizeof(struct sigaction));
-		uap->act = (struct sigaction32 *)p;
-		error = copyin(p32, &s32, sizeof(s32));
-		if (error)
-			return (error);
-		s.sa_handler = PTRIN(s32.sa_u);
-		CP(s32, s, sa_flags);
-		CP(s32, s, sa_mask);
-		error = copyout(&s, p, sizeof(s));
-		if (error)
-			return (error);
-	}
-	op32 = uap->oact;
-	if (op32) {
-		sg = stackgap_init();
-		op = stackgap_alloc(&sg, sizeof(struct sigaction));
-		uap->oact = (struct sigaction32 *)op;
-	}
-	error = sigaction(td, (struct sigaction_args *) uap);
-	if (error)
-		return (error);
-	if (op32) {
-		error = copyin(op, &s, sizeof(s));
+	if (uap->act) {
+		error = copyin(uap->act, &s32, sizeof(s32));
 		if (error)
 			return (error);
-		s32.sa_u = PTROUT(s.sa_handler);
-		CP(s, s32, sa_flags);
-		CP(s, s32, sa_mask);
-		error = copyout(&s32, op32, sizeof(s32));
+		sa.sa_handler = PTRIN(s32.sa_u);
+		CP(s32, sa, sa_flags);
+		CP(s32, sa, sa_mask);
+		sap = &sa;
+	} else
+		sap = NULL;
+	error = kern_sigaction(td, uap->sig, sap, &osa, 0);
+	if (error != 0 && uap->oact != NULL) {
+		s32.sa_u = PTROUT(osa.sa_handler);
+		CP(osa, s32, sa_flags);
+		CP(osa, s32, sa_mask);
+		error = copyout(&s32, uap->oact, sizeof(s32));
 	}
 	return (error);
 }
diff --git a/sys/compat/linux/linux_signal.c b/sys/compat/linux/linux_signal.c
index b70e99d93d2d0..a69f27d07c806 100644
--- a/sys/compat/linux/linux_signal.c
+++ b/sys/compat/linux/linux_signal.c
@@ -227,40 +227,22 @@ static int
 linux_do_sigprocmask(struct thread *td, int how, l_sigset_t *new,
 		     l_sigset_t *old)
 {
+	sigset_t omask, nmask;
+	sigset_t *nmaskp;
 	int error;
-	sigset_t mask;
-	struct proc *p = td->td_proc;
 
-	error = 0;
 	td->td_retval[0] = 0;
 
-	PROC_LOCK(p);
-	if (old != NULL)
-		bsd_to_linux_sigset(&td->td_sigmask, old);
-
 	if (new != NULL) {
-		linux_to_bsd_sigset(new, &mask);
+		linux_to_bsd_sigset(new, &nmask);
+		nmaskp = &nmask;
+	} else
+		nmaskp = NULL;
 
-		switch (how) {
-		case LINUX_SIG_BLOCK:
-			SIGSETOR(td->td_sigmask, mask);
-			SIG_CANTMASK(td->td_sigmask);
-			break;
-		case LINUX_SIG_UNBLOCK:
-			SIGSETNAND(td->td_sigmask, mask);
-			signotify(td);
-			break;
-		case LINUX_SIG_SETMASK:
-			td->td_sigmask = mask;
-			SIG_CANTMASK(td->td_sigmask);
-			signotify(td);
-			break;
-		default:
-			error = EINVAL;
-			break;
-		}
-	}
-	PROC_UNLOCK(p);
+	/* Linux sigprocmask flag values are one less than FreeBSD values. */
+	error = kern_sigprocmask(td, how + 1, nmaskp, &omask, 0);
+	if (error != 0 && old != NULL)
+		bsd_to_linux_sigset(&omask, old);
 
 	return (error);
 }
diff --git a/sys/compat/svr4/svr4_signal.c b/sys/compat/svr4/svr4_signal.c
index e05293c3047e3..c02a89cba61e3 100644
--- a/sys/compat/svr4/svr4_signal.c
+++ b/sys/compat/svr4/svr4_signal.c
@@ -36,6 +36,7 @@
 #include <sys/proc.h>
 #include <sys/signal.h>
 #include <sys/signalvar.h>
+#include <sys/syscallsubr.h>
 #include <sys/sysproto.h>
 
 #include <machine/cpu.h>
@@ -262,61 +263,38 @@ svr4_sys_sigaction(td, uap)
 	register struct thread *td;
 	struct svr4_sys_sigaction_args *uap;
 {
-	struct svr4_sigaction *nisa, *oisa, tmpisa;
-	struct sigaction *nbsa, *obsa, tmpbsa;
-	struct sigaction_args sa;
-	caddr_t sg;
+	struct svr4_sigaction isa;
+	struct sigaction nbsa, obsa;
+	struct sigaction *nbsap;
 	int error;
 
 	DPRINTF(("@@@ svr4_sys_sigaction(%d, %d, %d)\n", td->td_proc->p_pid,
 			uap->signum,
 			SVR4_SVR42BSD_SIG(uap->signum)));
 	
-	sg = stackgap_init();
-	nisa = uap->nsa;
-	oisa = uap->osa;
-
-	if (oisa != NULL)
-		obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-	else
-		obsa = NULL;
-
-	if (nisa != NULL) {
-		nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-		if ((error = copyin(nisa, &tmpisa, sizeof(tmpisa))) != 0)
-			return error;
-		svr4_to_bsd_sigaction(&tmpisa, &tmpbsa);
-		if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
-			return error;
+	if (uap->nsa != NULL) {
+		if ((error = copyin(uap->nsa, &isa, sizeof(isa))) != 0)
+			return (error);
+		svr4_to_bsd_sigaction(&isa, &nbsa);
+		nbsap = &nbsa;
 	} else
-		nbsa = NULL;
-
+		nbsap = NULL;
 #if defined(DEBUG_SVR4)
 	{
 		int i;
 		for (i = 0; i < 4; i++) 
 			DPRINTF(("\tssa_mask[%d] = %lx\n", i,
-						nisa->ssa_mask.bits[i]));
-		DPRINTF(("\tssa_handler = %p\n", nisa->ssa_handler));
+						isa.ssa_mask.bits[i]));
+		DPRINTF(("\tssa_handler = %p\n", isa.ssa_handler));
 	}
 #endif
-
-	sa.sig = SVR4_SVR42BSD_SIG(uap->signum);
-	sa.act = nbsa;
-	sa.oact = obsa;
-
-	if ((error = sigaction(td, &sa)) != 0)
-		return error;
-
-	if (oisa != NULL) {
-		if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
-			return error;
-		bsd_to_svr4_sigaction(&tmpbsa, &tmpisa);
-		if ((error = copyout(&tmpisa, oisa, sizeof(tmpisa))) != 0)
-			return error;
+	error = kern_sigaction(td, SVR4_SVR42BSD_SIG(uap->signum), nbsap, &obsa,
+	    0);
+	if (error == 0 && uap->osa != NULL) {
+		bsd_to_svr4_sigaction(&obsa, &isa);
+		error = copyout(&isa, uap->osa, sizeof(isa));
 	}
-
-	return 0;
+	return (error);
 }
 
 int 
@@ -324,47 +302,23 @@ svr4_sys_sigaltstack(td, uap)
 	register struct thread *td;
 	struct svr4_sys_sigaltstack_args *uap;
 {
-	struct svr4_sigaltstack *nsss, *osss, tmpsss;
-	struct sigaltstack *nbss, *obss, tmpbss;
-	struct sigaltstack_args sa;
-	caddr_t sg;
-	int error, *retval;
-
-	retval = td->td_retval;
-	sg = stackgap_init();
-	nsss = uap->nss;
-	osss = uap->oss;
-
-	if (osss != NULL)
-		obss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
-	else
-		obss = NULL;
+	struct svr4_sigaltstack sss;
+	struct sigaltstack nbss, obss, *nbssp;
+	int error;
 
-	if (nsss != NULL) {
-		nbss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
-		if ((error = copyin(nsss, &tmpsss, sizeof(tmpsss))) != 0)
-			return error;
-		svr4_to_bsd_sigaltstack(&tmpsss, &tmpbss);
-		if ((error = copyout(&tmpbss, nbss, sizeof(tmpbss))) != 0)
-			return error;
+	if (uap->nss != NULL) {
+		if ((error = copyin(uap->nss, &sss, sizeof(sss))) != 0)
+			return (error);
+		svr4_to_bsd_sigaltstack(&sss, &nbss);
+		nbssp = &nbss;
 	} else
-		nbss = NULL;
-
-	sa.ss = nbss;
-	sa.oss = obss;
-
-	if ((error = sigaltstack(td, &sa)) != 0)
-		return error;
-
-	if (obss != NULL) {
-		if ((error = copyin(obss, &tmpbss, sizeof(tmpbss))) != 0)
-			return error;
-		bsd_to_svr4_sigaltstack(&tmpbss, &tmpsss);
-		if ((error = copyout(&tmpsss, osss, sizeof(tmpsss))) != 0)
-			return error;
+		nbssp = NULL;
+	error = kern_sigaltstack(td, nbssp, &obss);
+	if (error == 0 && uap->oss != NULL) {
+		bsd_to_svr4_sigaltstack(&obss, &sss);
+		error = copyout(&sss, uap->oss, sizeof(sss));
 	}
-
-	return 0;
+	return (error);
 }
 
 /*
@@ -375,11 +329,12 @@ svr4_sys_signal(td, uap)
 	register struct thread *td;
 	struct svr4_sys_signal_args *uap;
 {
+	struct proc *p;
 	int signum;
-	int error, *retval = td->td_retval;
-	caddr_t sg = stackgap_init();
+	int error;
 
-	DPRINTF(("@@@ svr4_sys_signal(%d)\n", td->td_proc->p_pid));
+	p = td->td_proc;
+	DPRINTF(("@@@ svr4_sys_signal(%d)\n", p->p_pid));
 
 	signum = SVR4_SVR42BSD_SIG(SVR4_SIGNO(uap->signum));
 	if (signum <= 0 || signum > SVR4_NSIG)
@@ -393,99 +348,66 @@ svr4_sys_signal(td, uap)
 
 	case SVR4_SIGNAL_MASK:
 		{
-			struct sigaction_args sa_args;
-			struct sigaction *nbsa, *obsa, sa;
-
-			nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			sa_args.sig = signum;
-			sa_args.act = nbsa;
-			sa_args.oact = obsa;
-
-			sa.sa_handler = (sig_t) uap->handler;
-			SIGEMPTYSET(sa.sa_mask);
-			sa.sa_flags = 0;
+			struct sigaction nbsa, obsa;
 
+			nbsa.sa_handler = (sig_t) uap->handler;
+			SIGEMPTYSET(nbsa.sa_mask);
+			nbsa.sa_flags = 0;
 			if (signum != SIGALRM)
-				sa.sa_flags = SA_RESTART;
-
-			if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
-				return error;
-			if ((error = sigaction(td, &sa_args)) != 0) {
+				nbsa.sa_flags = SA_RESTART;
+			error = kern_sigaction(td, signum, &nbsa, &obsa, 0);
+			if (error != 0) {
 				DPRINTF(("signal: sigaction failed: %d\n",
 					 error));
-				*retval = (int)SVR4_SIG_ERR;
-				return error;
+				td->td_retval[0] = (int)SVR4_SIG_ERR;
+				return (error);
 			}
-			if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
-				return error;
-			*retval = (int)sa.sa_handler;
-			return 0;
+			td->td_retval[0] = (int)obsa.sa_handler;
+			return (0);
 		}
 
 	case SVR4_SIGHOLD_MASK:
 sighold:
 		{
-			struct sigprocmask_args sa;
-			sigset_t *set;
+			sigset_t set;
 
-			set = stackgap_alloc(&sg, sizeof(sigset_t));
-			SIGEMPTYSET(*set);
-			SIGADDSET(*set, signum);
-			sa.how = SIG_BLOCK;
-			sa.set = set;
-			sa.oset = NULL;
-			return sigprocmask(td, &sa);
+			SIGEMPTYSET(set);
+			SIGADDSET(set, signum);
+			return (kern_sigprocmask(td, SIG_BLOCK, &set, NULL, 0));
 		}
 
 	case SVR4_SIGRELSE_MASK:
 		{
-			struct sigprocmask_args sa;
-			sigset_t *set;
+			sigset_t set;
 
-			set = stackgap_alloc(&sg, sizeof(sigset_t));
-			SIGEMPTYSET(*set);
-			SIGADDSET(*set, signum);
-			sa.how = SIG_UNBLOCK;
-			sa.set = set;
-			sa.oset = NULL;
-			return sigprocmask(td, &sa);
+			SIGEMPTYSET(set);
+			SIGADDSET(set, signum);
+			return (kern_sigprocmask(td, SIG_UNBLOCK, &set, NULL,
+				    0));
 		}
 
 	case SVR4_SIGIGNORE_MASK:
 		{
-			struct sigaction_args sa_args;
-			struct sigaction *bsa, sa;
-
-			bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
-			sa_args.sig = signum;
-			sa_args.act = bsa;
-			sa_args.oact = NULL;
+			struct sigaction sa;
 
 			sa.sa_handler = SIG_IGN;
 			SIGEMPTYSET(sa.sa_mask);
 			sa.sa_flags = 0;
-			if ((error = copyout(&sa, bsa, sizeof(sa))) != 0)
-				return error;
-			if ((error = sigaction(td, &sa_args)) != 0) {
+			error = kern_sigaction(td, signum, &sa, NULL, 0);
+			if (error != 0)
 				DPRINTF(("sigignore: sigaction failed\n"));
-				return error;
-			}
-			return 0;
+			return (error);
 		}
 
 	case SVR4_SIGPAUSE_MASK:
 		{
-			struct sigsuspend_args sa;
-			sigset_t *set;
+			sigset_t mask;
 
-			set = stackgap_alloc(&sg, sizeof(sigset_t));
-			PROC_LOCK(td->td_proc);
-			*set = td->td_sigmask;
-			PROC_UNLOCK(td->td_proc);
-			SIGDELSET(*set, signum);
-			sa.sigmask = set;
-			return sigsuspend(td, &sa);
+			PROC_LOCK(p);
+			mask = td->td_sigmask;
+			PROC_UNLOCK(p);
+			SIGDELSET(mask, signum);
+			return kern_sigsuspend(td, mask);
 		}
 
 	default:
@@ -500,53 +422,25 @@ svr4_sys_sigprocmask(td, uap)
 	struct svr4_sys_sigprocmask_args *uap;
 {
 	svr4_sigset_t sss;
-	sigset_t bss;
-	int error = 0, *retval;
+	sigset_t oss, nss;
+	sigset_t *nssp;
+	int error;
 
-	retval = td->td_retval;
-	if (uap->oset != NULL) {
-		/* Fix the return value first if needed */
-		PROC_LOCK(td->td_proc);
-		bsd_to_svr4_sigset(&td->td_sigmask, &sss);
-		PROC_UNLOCK(td->td_proc);
-		if ((error = copyout(&sss, uap->oset, sizeof(sss))) != 0)
+	if (uap->set != NULL) {
+		if ((error = copyin(uap->set, &sss, sizeof(sss))) != 0)
 			return error;
-	}
-
-	if (uap->set == NULL)
-		/* Just examine */
-		return 0;
-
-	if ((error = copyin(uap->set, &sss, sizeof(sss))) != 0)
-		return error;
-
-	svr4_to_bsd_sigset(&sss, &bss);
-
-	PROC_LOCK(td->td_proc);
-	switch (uap->how) {
-	case SVR4_SIG_BLOCK:
-		SIGSETOR(td->td_sigmask, bss);
-		SIG_CANTMASK(td->td_sigmask);
-		break;
-
-	case SVR4_SIG_UNBLOCK:
-		SIGSETNAND(td->td_sigmask, bss);
-		signotify(td);
-		break;
-
-	case SVR4_SIG_SETMASK:
-		td->td_sigmask = bss;
-		SIG_CANTMASK(td->td_sigmask);
-		signotify(td);
-		break;
+		svr4_to_bsd_sigset(&sss, &nss);
+		nssp = &nss;
+	} else
+		nssp = NULL;
 
-	default:
-		error = EINVAL;
-		break;
+	/* SVR/4 sigprocmask flag values are the same as the FreeBSD values. */
+	error = kern_sigprocmask(td, uap->how, nssp, &oss, 0);
+	if (error == 0 && uap->oset != NULL) {
+		bsd_to_svr4_sigset(&oss, &sss);
+		error = copyout(&sss, uap->oset, sizeof(sss));
 	}
-	PROC_UNLOCK(td->td_proc);
-
-	return error;
+	return (error);
 }
 
 int
@@ -596,19 +490,14 @@ svr4_sys_sigsuspend(td, uap)
 	struct svr4_sys_sigsuspend_args *uap;
 {
 	svr4_sigset_t sss;
-	sigset_t *bss;
-	struct sigsuspend_args sa;
+	sigset_t bss;
 	int error;
-	caddr_t sg = stackgap_init();
 
 	if ((error = copyin(uap->ss, &sss, sizeof(sss))) != 0)
 		return error;
 
-	bss = stackgap_alloc(&sg, sizeof(sigset_t));
-	svr4_to_bsd_sigset(&sss, bss);
-
-	sa.sigmask = bss;
-	return sigsuspend(td, &sa);
+	svr4_to_bsd_sigset(&sss, &bss);
+	return kern_sigsuspend(td, bss);
 }
 
 
@@ -631,15 +520,15 @@ svr4_sys_context(td, uap)
 	struct svr4_sys_context_args *uap;
 {
 	struct svr4_ucontext uc;
-	int error;
+	int error, onstack;
 
 	switch (uap->func) {
 	case 0:
-		PROC_LOCK(td->td_proc);
 		DPRINTF(("getcontext(%p)\n", uap->uc));
-		svr4_getcontext(td, &uc, &td->td_sigmask,
-		    sigonstack(cpu_getstack(td)));
+		PROC_LOCK(td->td_proc);
+		onstack = sigonstack(cpu_getstack(td));
 		PROC_UNLOCK(td->td_proc);
+		svr4_getcontext(td, &uc, &td->td_sigmask, onstack);
 		return copyout(&uc, uap->uc, sizeof(uc));
 
 	case 1: 
@@ -670,8 +559,10 @@ svr4_sys_pause(td, uap)
 	register struct thread *td;
 	struct svr4_sys_pause_args *uap;
 {
-	struct sigsuspend_args bsa;
+	sigset_t mask;
 
-	bsa.sigmask = &td->td_sigmask;
-	return sigsuspend(td, &bsa);
+	PROC_LOCK(td->td_proc);
+	mask = td->td_sigmask;
+	PROC_UNLOCK(td->td_proc);
+	return kern_sigsuspend(td, mask);
 }