diff --git a/klibc/SYSCALLS.def b/klibc/SYSCALLS.def
index 2814c3b..e8b9a7f 100644
--- a/klibc/SYSCALLS.def
+++ b/klibc/SYSCALLS.def
@@ -146,6 +146,12 @@
 ; Signal operations
 ;
 int kill(pid_t, int)
+; We really should get rid of the non-rt_* of these, but that takes
+; sanitizing <signal.h> for all architectures, sigh...
+<?> int sigaction(int, const struct sigaction *, struct sigaction *)
+<?> int sigsuspend(const sigset_t *)
+<?> int sigpending(sigset_t *)
+<?> int sigprocmask(int, const sigset_t *, sigset_t *)
 int rt_sigaction(int, const struct sigaction *, struct sigaction *, size_t)
 int rt_sigsuspend(const sigset_t *, size_t)
 int rt_sigpending(sigset_t *, size_t)
diff --git a/klibc/sigaction.c b/klibc/sigaction.c
index b96ae62..819ffd4 100644
--- a/klibc/sigaction.c
+++ b/klibc/sigaction.c
@@ -5,7 +5,11 @@
 #include <signal.h>
 #include <sys/syscall.h>
 
+#ifndef __NR_sigaction
+
 int sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
 {
   return rt_sigaction(sig, act, oact, sizeof(sigset_t));
 }
+
+#endif
diff --git a/klibc/sigpending.c b/klibc/sigpending.c
index 491d9ac..76d2b1a 100644
--- a/klibc/sigpending.c
+++ b/klibc/sigpending.c
@@ -5,7 +5,11 @@
 #include <signal.h>
 #include <sys/syscall.h>
 
+#ifndef __NR_sigpending
+
 int sigpending(sigset_t *set)
 {
   return rt_sigpending(set, sizeof(sigset_t));
 }
+
+#endif
diff --git a/klibc/sigprocmask.c b/klibc/sigprocmask.c
index 8dd77d4..b5e58b2 100644
--- a/klibc/sigprocmask.c
+++ b/klibc/sigprocmask.c
@@ -5,7 +5,11 @@
 #include <signal.h>
 #include <sys/syscall.h>
 
+#ifndef __NR_sigprocmask
+
 int sigprocmask(int how, const sigset_t *set, sigset_t *oset)
 {
   return rt_sigprocmask(how, set, oset, sizeof(sigset_t));
 }
+
+#endif
diff --git a/klibc/sigsuspend.c b/klibc/sigsuspend.c
index 905cd00..a927999 100644
--- a/klibc/sigsuspend.c
+++ b/klibc/sigsuspend.c
@@ -5,7 +5,11 @@
 #include <signal.h>
 #include <sys/syscall.h>
 
+#ifndef __NR_sigsuspend
+
 int sigsuspend(const sigset_t *mask)
 {
   return rt_sigsuspend(mask, sizeof *mask);
 }
+
+#endif
