6 files changed, 322 insertions, 104 deletions

diff --git a/sys/compat/linux/linux.c b/sys/compat/linux/linux.c
new file mode 100644
index 0000000..d1d7877
--- /dev/null
+++ b/sys/compat/linux/linux.c
@@ -0,0 +1,205 @@
+/*-
+ * Copyright (c) 2015 Dmitry Chagin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/signalvar.h>
+
+#include <compat/linux/linux.h>
+
+
+static int bsd_to_linux_sigtbl[LINUX_SIGTBLSZ] = {
+	LINUX_SIGHUP,	/* SIGHUP */
+	LINUX_SIGINT,	/* SIGINT */
+	LINUX_SIGQUIT,	/* SIGQUIT */
+	LINUX_SIGILL,	/* SIGILL */
+	LINUX_SIGTRAP,	/* SIGTRAP */
+	LINUX_SIGABRT,	/* SIGABRT */
+	0,		/* SIGEMT */
+	LINUX_SIGFPE,	/* SIGFPE */
+	LINUX_SIGKILL,	/* SIGKILL */
+	LINUX_SIGBUS,	/* SIGBUS */
+	LINUX_SIGSEGV,	/* SIGSEGV */
+	LINUX_SIGSYS,	/* SIGSYS */
+	LINUX_SIGPIPE,	/* SIGPIPE */
+	LINUX_SIGALRM,	/* SIGALRM */
+	LINUX_SIGTERM,	/* SIGTERM */
+	LINUX_SIGURG,	/* SIGURG */
+	LINUX_SIGSTOP,	/* SIGSTOP */
+	LINUX_SIGTSTP,	/* SIGTSTP */
+	LINUX_SIGCONT,	/* SIGCONT */
+	LINUX_SIGCHLD,	/* SIGCHLD */
+	LINUX_SIGTTIN,	/* SIGTTIN */
+	LINUX_SIGTTOU,	/* SIGTTOU */
+	LINUX_SIGIO,	/* SIGIO */
+	LINUX_SIGXCPU,	/* SIGXCPU */
+	LINUX_SIGXFSZ,	/* SIGXFSZ */
+	LINUX_SIGVTALRM,/* SIGVTALRM */
+	LINUX_SIGPROF,	/* SIGPROF */
+	LINUX_SIGWINCH,	/* SIGWINCH */
+	0,		/* SIGINFO */
+	LINUX_SIGUSR1,	/* SIGUSR1 */
+	LINUX_SIGUSR2	/* SIGUSR2 */
+};
+
+static int linux_to_bsd_sigtbl[LINUX_SIGTBLSZ] = {
+	SIGHUP,		/* LINUX_SIGHUP */
+	SIGINT,		/* LINUX_SIGINT */
+	SIGQUIT,	/* LINUX_SIGQUIT */
+	SIGILL,		/* LINUX_SIGILL */
+	SIGTRAP,	/* LINUX_SIGTRAP */
+	SIGABRT,	/* LINUX_SIGABRT */
+	SIGBUS,		/* LINUX_SIGBUS */
+	SIGFPE,		/* LINUX_SIGFPE */
+	SIGKILL,	/* LINUX_SIGKILL */
+	SIGUSR1,	/* LINUX_SIGUSR1 */
+	SIGSEGV,	/* LINUX_SIGSEGV */
+	SIGUSR2,	/* LINUX_SIGUSR2 */
+	SIGPIPE,	/* LINUX_SIGPIPE */
+	SIGALRM,	/* LINUX_SIGALRM */
+	SIGTERM,	/* LINUX_SIGTERM */
+	SIGBUS,		/* LINUX_SIGSTKFLT */
+	SIGCHLD,	/* LINUX_SIGCHLD */
+	SIGCONT,	/* LINUX_SIGCONT */
+	SIGSTOP,	/* LINUX_SIGSTOP */
+	SIGTSTP,	/* LINUX_SIGTSTP */
+	SIGTTIN,	/* LINUX_SIGTTIN */
+	SIGTTOU,	/* LINUX_SIGTTOU */
+	SIGURG,		/* LINUX_SIGURG */
+	SIGXCPU,	/* LINUX_SIGXCPU */
+	SIGXFSZ,	/* LINUX_SIGXFSZ */
+	SIGVTALRM,	/* LINUX_SIGVTALARM */
+	SIGPROF,	/* LINUX_SIGPROF */
+	SIGWINCH,	/* LINUX_SIGWINCH */
+	SIGIO,		/* LINUX_SIGIO */
+	/*
+	 * FreeBSD does not have SIGPWR signal, map Linux SIGPWR signal
+	 * to the first unused FreeBSD signal number. Since Linux supports
+	 * signals from 1 to 64 we are ok here as our SIGRTMIN = 65.
+	 */
+	SIGRTMIN,	/* LINUX_SIGPWR */
+	SIGSYS		/* LINUX_SIGSYS */
+};
+
+/*
+ * Map Linux RT signals to the FreeBSD RT signals.
+ */
+static inline int
+linux_to_bsd_rt_signal(int sig)
+{
+
+	return (SIGRTMIN + 1 + sig - LINUX_SIGRTMIN);
+}
+
+static inline int
+bsd_to_linux_rt_signal(int sig)
+{
+
+	return (sig - SIGRTMIN - 1 + LINUX_SIGRTMIN);
+}
+
+int
+linux_to_bsd_signal(int sig)
+{
+
+	KASSERT(sig > 0 && sig <= LINUX_SIGRTMAX, ("Invalid Linux signal\n"));
+
+	if (sig < LINUX_SIGRTMIN)
+		return (linux_to_bsd_sigtbl[_SIG_IDX(sig)]);
+
+	return (linux_to_bsd_rt_signal(sig));
+}
+
+int
+bsd_to_linux_signal(int sig)
+{
+
+	if (sig <= LINUX_SIGTBLSZ)
+		return (bsd_to_linux_sigtbl[_SIG_IDX(sig)]);
+	if (sig == SIGRTMIN)
+		return (LINUX_SIGPWR);
+
+	return (bsd_to_linux_rt_signal(sig));
+}
+
+int
+linux_to_bsd_sigaltstack(int lsa)
+{
+	int bsa = 0;
+
+	if (lsa & LINUX_SS_DISABLE)
+		bsa |= SS_DISABLE;
+	/*
+	 * Linux ignores SS_ONSTACK flag for ss
+	 * parameter while FreeBSD prohibits it.
+	 */
+	return (bsa);
+}
+
+int
+bsd_to_linux_sigaltstack(int bsa)
+{
+	int lsa = 0;
+
+	if (bsa & SS_DISABLE)
+		lsa |= LINUX_SS_DISABLE;
+	if (bsa & SS_ONSTACK)
+		lsa |= LINUX_SS_ONSTACK;
+	return (lsa);
+}
+
+void
+linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss)
+{
+	int b, l;
+
+	SIGEMPTYSET(*bss);
+	for (l = 1; l <= LINUX_SIGRTMAX; l++) {
+		if (LINUX_SIGISMEMBER(*lss, l)) {
+			b = linux_to_bsd_signal(l);
+			if (b)
+				SIGADDSET(*bss, b);
+		}
+	}
+}
+
+void
+bsd_to_linux_sigset(sigset_t *bss, l_sigset_t *lss)
+{
+	int b, l;
+
+	LINUX_SIGEMPTYSET(*lss);
+	for (b = 1; b <= SIGRTMAX; b++) {
+		if (SIGISMEMBER(*bss, b)) {
+			l = bsd_to_linux_signal(b);
+			if (l)
+				LINUX_SIGADDSET(*lss, l);
+		}
+	}
+}
diff --git a/sys/compat/linux/linux.h b/sys/compat/linux/linux.h
new file mode 100644
index 0000000..974440f
--- /dev/null
+++ b/sys/compat/linux/linux.h
@@ -0,0 +1,95 @@
+/*-
+ * Copyright (c) 2015 Dmitry Chagin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _LINUX_MI_H_
+#define _LINUX_MI_H_
+
+/* sigaltstack */
+#define	LINUX_SS_ONSTACK	1
+#define	LINUX_SS_DISABLE	2
+
+int linux_to_bsd_sigaltstack(int lsa);
+int bsd_to_linux_sigaltstack(int bsa);
+
+/* sigset */
+typedef struct {
+	uint64_t	__mask;
+} l_sigset_t;
+
+/* primitives to manipulate sigset_t */
+#define	LINUX_SIGEMPTYSET(set)		(set).__mask = 0
+#define	LINUX_SIGISMEMBER(set, sig)	(1UL & ((set).__mask >> _SIG_IDX(sig)))
+#define	LINUX_SIGADDSET(set, sig)	(set).__mask |= 1UL << _SIG_IDX(sig)
+
+void linux_to_bsd_sigset(l_sigset_t *, sigset_t *);
+void bsd_to_linux_sigset(sigset_t *, l_sigset_t *);
+
+/* signaling */
+#define	LINUX_SIGHUP		1
+#define	LINUX_SIGINT		2
+#define	LINUX_SIGQUIT		3
+#define	LINUX_SIGILL		4
+#define	LINUX_SIGTRAP		5
+#define	LINUX_SIGABRT		6
+#define	LINUX_SIGIOT		LINUX_SIGABRT
+#define	LINUX_SIGBUS		7
+#define	LINUX_SIGFPE		8
+#define	LINUX_SIGKILL		9
+#define	LINUX_SIGUSR1		10
+#define	LINUX_SIGSEGV		11
+#define	LINUX_SIGUSR2		12
+#define	LINUX_SIGPIPE		13
+#define	LINUX_SIGALRM		14
+#define	LINUX_SIGTERM		15
+#define	LINUX_SIGSTKFLT		16
+#define	LINUX_SIGCHLD		17
+#define	LINUX_SIGCONT		18
+#define	LINUX_SIGSTOP		19
+#define	LINUX_SIGTSTP		20
+#define	LINUX_SIGTTIN		21
+#define	LINUX_SIGTTOU		22
+#define	LINUX_SIGURG		23
+#define	LINUX_SIGXCPU		24
+#define	LINUX_SIGXFSZ		25
+#define	LINUX_SIGVTALRM		26
+#define	LINUX_SIGPROF		27
+#define	LINUX_SIGWINCH		28
+#define	LINUX_SIGIO		29
+#define	LINUX_SIGPOLL		LINUX_SIGIO
+#define	LINUX_SIGPWR		30
+#define	LINUX_SIGSYS		31
+#define	LINUX_SIGTBLSZ		31
+#define	LINUX_SIGRTMIN		32
+#define	LINUX_SIGRTMAX		64
+
+#define LINUX_SIG_VALID(sig)	((sig) <= LINUX_SIGRTMAX && (sig) > 0)
+
+int linux_to_bsd_signal(int sig);
+int bsd_to_linux_signal(int sig);
+
+#endif /* _LINUX_MI_H_ */
diff --git a/sys/compat/linux/linux_fork.c b/sys/compat/linux/linux_fork.c
index ce4ddcf..280b406 100644
--- a/sys/compat/linux/linux_fork.c
+++ b/sys/compat/linux/linux_fork.c
@@ -57,7 +57,6 @@ __FBSDID("$FreeBSD$");
 #include <machine/../linux/linux.h>
 #include <machine/../linux/linux_proto.h>
 #endif
-#include <compat/linux/linux_signal.h>
 #include <compat/linux/linux_emul.h>
 #include <compat/linux/linux_futex.h>
 #include <compat/linux/linux_misc.h>
@@ -160,9 +159,7 @@ linux_clone_proc(struct thread *td, struct linux_clone_args *args)
 
 	exit_signal = args->flags & 0x000000ff;
 	if (LINUX_SIG_VALID(exit_signal)) {
-		if (exit_signal <= LINUX_SIGTBLSZ)
-			exit_signal =
-			    linux_to_bsd_signal[_SIG_IDX(exit_signal)];
+		exit_signal = linux_to_bsd_signal(exit_signal);
 	} else if (exit_signal != 0)
 		return (EINVAL);
 
diff --git a/sys/compat/linux/linux_misc.c b/sys/compat/linux/linux_misc.c
index 9806e03..b377f7f 100644
--- a/sys/compat/linux/linux_misc.c
+++ b/sys/compat/linux/linux_misc.c
@@ -870,10 +870,10 @@ linux_common_wait(struct thread *td, int pid, int *status,
 		tmpstat &= 0xffff;
 		if (WIFSIGNALED(tmpstat))
 			tmpstat = (tmpstat & 0xffffff80) |
-			    BSD_TO_LINUX_SIGNAL(WTERMSIG(tmpstat));
+			    bsd_to_linux_signal(WTERMSIG(tmpstat));
 		else if (WIFSTOPPED(tmpstat))
 			tmpstat = (tmpstat & 0xffff00ff) |
-			    (BSD_TO_LINUX_SIGNAL(WSTOPSIG(tmpstat)) << 8);
+			    (bsd_to_linux_signal(WSTOPSIG(tmpstat)) << 8);
 		else if (WIFCONTINUED(tmpstat))
 			tmpstat = 0xffff;
 		error = copyout(&tmpstat, status, sizeof(int));
@@ -986,7 +986,7 @@ linux_waitid(struct thread *td, struct linux_waitid_args *args)
 		if (td->td_retval[0] == 0)
 			bzero(&lsi, sizeof(lsi));
 		else {
-			sig = BSD_TO_LINUX_SIGNAL(siginfo.si_signo);
+			sig = bsd_to_linux_signal(siginfo.si_signo);
 			siginfo_to_lsiginfo(&siginfo, &lsi, sig);
 		}
 		error = copyout(&lsi, args->info, sizeof(lsi));
diff --git a/sys/compat/linux/linux_signal.c b/sys/compat/linux/linux_signal.c
index f60e731..0ecf537 100644
--- a/sys/compat/linux/linux_signal.c
+++ b/sys/compat/linux/linux_signal.c
@@ -60,42 +60,6 @@ static int	linux_do_tkill(struct thread *td, struct thread *tdt,
 static void	sicode_to_lsicode(int si_code, int *lsi_code);
 
 
-#if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
-void
-linux_to_bsd_sigset(l_sigset_t *lss, sigset_t *bss)
-{
-	int b, l;
-
-	SIGEMPTYSET(*bss);
-	bss->__bits[0] = lss->__bits[0] & ~((1U << LINUX_SIGTBLSZ) - 1);
-	bss->__bits[1] = lss->__bits[1];
-	for (l = 1; l <= LINUX_SIGTBLSZ; l++) {
-		if (LINUX_SIGISMEMBER(*lss, l)) {
-			b = linux_to_bsd_signal[_SIG_IDX(l)];
-			if (b)
-				SIGADDSET(*bss, b);
-		}
-	}
-}
-
-void
-bsd_to_linux_sigset(sigset_t *bss, l_sigset_t *lss)
-{
-	int b, l;
-
-	LINUX_SIGEMPTYSET(*lss);
-	lss->__bits[0] = bss->__bits[0] & ~((1U << LINUX_SIGTBLSZ) - 1);
-	lss->__bits[1] = bss->__bits[1];
-	for (b = 1; b <= LINUX_SIGTBLSZ; b++) {
-		if (SIGISMEMBER(*bss, b)) {
-			l = bsd_to_linux_signal[_SIG_IDX(b)];
-			if (l)
-				LINUX_SIGADDSET(*lss, l);
-		}
-	}
-}
-#endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
-
 static void
 linux_to_bsd_sigaction(l_sigaction_t *lsa, struct sigaction *bsa)
 {
@@ -163,11 +127,7 @@ linux_do_sigaction(struct thread *td, int linux_sig, l_sigaction_t *linux_nsa,
 		linux_to_bsd_sigaction(linux_nsa, nsa);
 	} else
 		nsa = NULL;
-
-	if (linux_sig <= LINUX_SIGTBLSZ)
-		sig = linux_to_bsd_signal[_SIG_IDX(linux_sig)];
-	else
-		sig = linux_sig;
+	sig = linux_to_bsd_signal(linux_sig);
 
 	error = kern_sigaction(td, sig, nsa, osa, 0);
 	if (error)
@@ -289,7 +249,7 @@ linux_sigprocmask(struct thread *td, struct linux_sigprocmask_args *args)
 		if (error)
 			return (error);
 		LINUX_SIGEMPTYSET(set);
-		set.__bits[0] = mask;
+		set.__mask = mask;
 	}
 
 	error = linux_do_sigprocmask(td, args->how,
@@ -297,7 +257,7 @@ linux_sigprocmask(struct thread *td, struct linux_sigprocmask_args *args)
 				     args->omask ? &oset : NULL);
 
 	if (args->omask != NULL && !error) {
-		mask = oset.__bits[0];
+		mask = oset.__mask;
 		error = copyout(&mask, args->omask, sizeof(l_osigset_t));
 	}
 
@@ -353,7 +313,7 @@ linux_sgetmask(struct thread *td, struct linux_sgetmask_args *args)
 	PROC_LOCK(p);
 	bsd_to_linux_sigset(&td->td_sigmask, &mask);
 	PROC_UNLOCK(p);
-	td->td_retval[0] = mask.__bits[0];
+	td->td_retval[0] = mask.__mask;
 	return (0);
 }
 
@@ -371,9 +331,9 @@ linux_ssetmask(struct thread *td, struct linux_ssetmask_args *args)
 
 	PROC_LOCK(p);
 	bsd_to_linux_sigset(&td->td_sigmask, &lset);
-	td->td_retval[0] = lset.__bits[0];
+	td->td_retval[0] = lset.__mask;
 	LINUX_SIGEMPTYSET(lset);
-	lset.__bits[0] = args->mask;
+	lset.__mask = args->mask;
 	linux_to_bsd_sigset(&lset, &bset);
 	td->td_sigmask = bset;
 	SIG_CANTMASK(td->td_sigmask);
@@ -401,7 +361,7 @@ linux_sigpending(struct thread *td, struct linux_sigpending_args *args)
 	SIGSETAND(bset, td->td_sigmask);
 	PROC_UNLOCK(p);
 	bsd_to_linux_sigset(&bset, &lset);
-	mask = lset.__bits[0];
+	mask = lset.__mask;
 	return (copyout(&mask, args->mask, sizeof(mask)));
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
@@ -505,7 +465,7 @@ linux_rt_sigtimedwait(struct thread *td,
 	if (error)
 		return (error);
 
-	sig = BSD_TO_LINUX_SIGNAL(info.ksi_signo);
+	sig = bsd_to_linux_signal(info.ksi_signo);
 
 	if (args->ptr) {
 		memset(&linfo, 0, sizeof(linfo));
@@ -537,10 +497,10 @@ linux_kill(struct thread *td, struct linux_kill_args *args)
 	if (!LINUX_SIG_VALID(args->signum) && args->signum != 0)
 		return (EINVAL);
 
-	if (args->signum > 0 && args->signum <= LINUX_SIGTBLSZ)
-		tmp.signum = linux_to_bsd_signal[_SIG_IDX(args->signum)];
+	if (args->signum > 0)
+		tmp.signum = linux_to_bsd_signal(args->signum);
 	else
-		tmp.signum = args->signum;
+		tmp.signum = 0;
 
 	tmp.pid = args->pid;
 	return (sys_kill(td, &tmp));
@@ -590,10 +550,10 @@ linux_tgkill(struct thread *td, struct linux_tgkill_args *args)
 	if (!LINUX_SIG_VALID(args->sig) && args->sig != 0)
 		return (EINVAL);
 
-	if (args->sig > 0 && args->sig <= LINUX_SIGTBLSZ)
-		sig = linux_to_bsd_signal[_SIG_IDX(args->sig)];
+	if (args->sig > 0)
+		sig = linux_to_bsd_signal(args->sig);
 	else
-		sig = args->sig;
+		sig = 0;
 
 	tdt = linux_tdfind(td, args->pid, args->tgid);
 	if (tdt == NULL)
@@ -628,8 +588,7 @@ linux_tkill(struct thread *td, struct linux_tkill_args *args)
 	if (!LINUX_SIG_VALID(args->sig))
 		return (EINVAL);
 
-
-	sig = BSD_TO_LINUX_SIGNAL(args->sig);
+	sig = linux_to_bsd_signal(args->sig);
 
 	tdt = linux_tdfind(td, args->tid, -1);
 	if (tdt == NULL)
@@ -727,9 +686,9 @@ siginfo_to_lsiginfo(const siginfo_t *si, l_siginfo_t *lsi, l_int sig)
 			lsi->lsi_uid = si->si_uid;
 
 			if (si->si_code == CLD_STOPPED)
-				lsi->lsi_status = BSD_TO_LINUX_SIGNAL(si->si_status);
+				lsi->lsi_status = bsd_to_linux_signal(si->si_status);
 			else if (si->si_code == CLD_CONTINUED)
-				lsi->lsi_status = BSD_TO_LINUX_SIGNAL(SIGCONT);
+				lsi->lsi_status = bsd_to_linux_signal(SIGCONT);
 			else
 				lsi->lsi_status = si->si_status;
 			break;
@@ -754,32 +713,6 @@ siginfo_to_lsiginfo(const siginfo_t *si, l_siginfo_t *lsi, l_int sig)
 	}
 }
 
-int
-linux_to_bsd_sigaltstack(int lsa)
-{
-	int bsa = 0;
-
-	if (lsa & LINUX_SS_DISABLE)
-		bsa |= SS_DISABLE;
-	/*
-	 * Linux ignores SS_ONSTACK flag for ss
-	 * parameter while FreeBSD prohibits it.
-	 */
-	return (bsa);
-}
-
-int
-bsd_to_linux_sigaltstack(int bsa)
-{
-	int lsa = 0;
-
-	if (bsa & SS_DISABLE)
-		lsa |= LINUX_SS_DISABLE;
-	if (bsa & SS_ONSTACK)
-		lsa |= LINUX_SS_ONSTACK;
-	return (lsa);
-}
-
 void
 lsiginfo_to_ksiginfo(const l_siginfo_t *lsi, ksiginfo_t *ksi, int sig)
 {
@@ -812,7 +745,7 @@ linux_rt_sigqueueinfo(struct thread *td, struct linux_rt_sigqueueinfo_args *args
 	if (linfo.lsi_code >= 0)
 		return (EPERM);
 
-	sig = BSD_TO_LINUX_SIGNAL(args->sig);
+	sig = linux_to_bsd_signal(args->sig);
 
 	error = ESRCH;
 	if ((p = pfind(args->pid)) != NULL ||
diff --git a/sys/compat/linux/linux_signal.h b/sys/compat/linux/linux_signal.h
index eb06bb0..510bfb3 100644
--- a/sys/compat/linux/linux_signal.h
+++ b/sys/compat/linux/linux_signal.h
@@ -43,21 +43,9 @@
 #define	LINUX_SI_SIGIO		-5	/* sent by queued SIGIO */
 #define	LINUX_SI_TKILL		-6	/* sent by tkill system call */
 
-extern int bsd_to_linux_signal[];
-extern int linux_to_bsd_signal[];
-
-int linux_to_bsd_sigaltstack(int lsa);
-int bsd_to_linux_sigaltstack(int bsa);
-void linux_to_bsd_sigset(l_sigset_t *, sigset_t *);
-void bsd_to_linux_sigset(sigset_t *, l_sigset_t *);
 int linux_do_sigaction(struct thread *, int, l_sigaction_t *, l_sigaction_t *);
 void ksiginfo_to_lsiginfo(const ksiginfo_t *ksi, l_siginfo_t *lsi, l_int sig);
 void siginfo_to_lsiginfo(const siginfo_t *si, l_siginfo_t *lsi, l_int sig);
 void lsiginfo_to_ksiginfo(const l_siginfo_t *lsi, ksiginfo_t *ksi, int sig);
 
-#define LINUX_SIG_VALID(sig)	((sig) <= LINUX_NSIG && (sig) > 0)
-
-#define BSD_TO_LINUX_SIGNAL(sig)				\
-	(((sig) <= LINUX_SIGTBLSZ) ? bsd_to_linux_signal[_SIG_IDX(sig)] : sig)
-
 #endif /* _LINUX_SIGNAL_H_ */