Implement sigtimedwait for use by suckless init

bin/utest/signal.c

@@ -6,6 +6,7 @@
 #include <stdio.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <errno.h>
 
 /* ======= signal_basic ======= */
 static volatile int sigusr1_handled = 0;
@@ -295,6 +296,93 @@ TEST_ADD(signal_sigsuspend) {
   return 0;
 }
 
+/* ======= signal_sigtimedwait ======= */
+int sigtimedwait_child(void *arg) {
+  pid_t ppid = getppid();
+  sched_yield();
+  syscall_ok(kill(ppid, SIGUSR1));
+  return 0;
+}
+
+TEST_ADD(signal_sigtimedwait) {
+  syscall_ok(signal(SIGCONT, sigcont_handler));
+  sigset_t set, current, waitset;
+  __sigemptyset(&set);
+  __sigaddset(&set, SIGUSR1);
+  __sigaddset(&set, SIGCONT);
+  syscall_ok(sigprocmask(SIG_SETMASK, &set, NULL));
+
+  utest_spawn(sigtimedwait_child, NULL);
+
+  siginfo_t info;
+  __sigemptyset(&waitset);
+  __sigaddset(&waitset, SIGUSR1);
+  assert(sigtimedwait(&waitset, &info, NULL) == SIGUSR1);
+  assert(info.si_signo == SIGUSR1);
+
+  syscall_ok(sigprocmask(SIG_BLOCK, NULL, &current));
+  assert(__sigsetequal(&set, &current));
+
+  utest_child_exited(0);
+  return 0;
+}
+
+/* ======= signal_sigtimedwait_timeout ======= */
+static int sigusr2_handled = 0;
+
+void sigtimedwait_timeout_sigusr2_handler(int signo) {
+  sigusr2_handled = 1;
+}
+
+int sigtimedwait_timeout_child(void *arg) {
+  ppid = getppid();
+  while (!sigusr2_handled) {
+    kill(ppid, SIGCONT);
+  }
+  return 0;
+}
+
+TEST_ADD(signal_sigtimedwait_timeout) {
+  syscall_ok(signal(SIGCONT, sigcont_handler));
+  syscall_ok(signal(SIGUSR2, sigtimedwait_timeout_sigusr2_handler));
+  sigset_t set, waitset;
+  __sigemptyset(&set);
+  __sigaddset(&set, SIGUSR1);
+  syscall_ok(sigprocmask(SIG_SETMASK, &set, NULL));
+
+  pid_t cpid = utest_spawn(sigtimedwait_timeout_child, NULL);
+
+  siginfo_t info;
+  __sigemptyset(&waitset);
+  __sigaddset(&waitset, SIGUSR1);
+  timespec_t timeout = {
+    .tv_nsec = -1,
+    .tv_sec = -1,
+  };
+
+  /* tv_nsec is invalid. */
+  syscall_fail(sigtimedwait(&waitset, &info, &timeout), EINVAL);
+
+  /* tv_nsec is valid, but tv_sec < 0. */
+  timeout.tv_nsec = 10000000;
+  syscall_fail(sigtimedwait(&waitset, &info, &timeout), EAGAIN);
+
+  /* Timeout is valid, should be interrupted. */
+  timeout.tv_sec = 0;
+  syscall_fail(sigtimedwait(&waitset, &info, &timeout), EINTR);
+
+  /* After the signal we should be interrupted only once, so next call to
+   * sigtimedwait will timeout. */
+  syscall_ok(kill(cpid, SIGUSR2));
+
+  /* This may be woken up by a timeout or by an interrupt. */
+  nanosleep(&timeout, NULL);
+  syscall_fail(sigtimedwait(&waitset, &info, &timeout), EAGAIN);
+
+  utest_child_exited(0);
+  return 0;
+}
+
 /* ======= signal_sigsuspend_stop ======= */
 TEST_ADD(signal_sigsuspend_stop) {
   pid_t ppid = getpid();

include/sys/signal.h

@@ -202,6 +202,8 @@ void sig_onexec(proc_t *p);
 int do_sigaction(signo_t sig, const sigaction_t *act, sigaction_t *oldact);
 int do_sigprocmask(int how, const sigset_t *set, sigset_t *oset);
 int do_sigsuspend(proc_t *p, const sigset_t *mask);
+int do_sigtimedwait(proc_t *p, sigset_t waitset, ksiginfo_t *kinfo,
+                    struct timespec *timeout);
 int do_sigpending(proc_t *p, sigset_t *set);
 int do_sigtimedwait(proc_t *p, sigset_t waitset, ksiginfo_t *kinfo,
                     struct timespec *timeout);

include/sys/syscallargs.h

@@ -9,7 +9,6 @@
 #include <sys/ucontext.h>
 #include <sys/sigtypes.h>
 #include <sys/siginfo.h>
-
 #define SCARG(p, x) ((p)->x.arg)
 #define SYSCALLARG(x) union { register_t _pad; x arg; }
 

sys/kern/signal.c

@@ -13,6 +13,9 @@
 #include <sys/mutex.h>
 #include <sys/malloc.h>
 
+#include "sys/siginfo.h"
+#include "sys/sigtypes.h"
+
 static KMALLOC_DEFINE(M_SIGNAL, "signal");
 
 /*!\brief Signal properties. */
@@ -201,6 +204,88 @@ int do_sigsuspend(proc_t *p, const sigset_t *mask) {
   return ERESTARTNOHAND;
 }
 
+int do_sigtimedwait(proc_t *p, sigset_t waitset, ksiginfo_t *kinfo,
+                    timespec_t *tsp) {
+  int timevalid = 0, error = 0, timeout = 0;
+  sigset_t saved_mask;
+  signo_t sig;
+  thread_t *td = p->p_thread;
+
+  if (tsp != NULL) {
+    if (tsp->tv_nsec < 0 || tsp->tv_nsec >= 1000000000) {
+      return EINVAL;
+    }
+    /* This is the same behaviour as in OpenBSD. */
+    if (tsp->tv_sec < 0) {
+      return EAGAIN;
+    }
+
+    timevalid = 1;
+    timeout = ts2hz(tsp);
+    /* Timeout set to 0 means to not block, but for sleepq it means to
+     * wait indefinitely */
+    if (timeout == 0) {
+      if (tsp->tv_nsec == 0 && tsp->tv_sec == 0) {
+        timeout = -1;
+      } else {
+        /* Shortest possible timeout */
+        timeout = 1;
+      }
+    }
+  }
+
+  bzero(kinfo, sizeof(*kinfo));
+
+  /* Silently ignore SIGKILL and SIGSTOP. */
+  __sigminusset(&cantmask, &waitset);
+
+  WITH_PROC_LOCK(p) {
+    /* Unblocking temporarly waited signals so we're woken up upon receiving
+     * such signal. */
+    saved_mask = td->td_sigmask;
+    __sigminusset(&waitset, &td->td_sigmask);
+
+    sigset_t pending = td->td_sigpend.sp_set;
+    __sigandset(&waitset, &pending);
+    if ((sig = __sigfindset(&pending))) {
+      sigpend_get(&td->td_sigpend, sig, kinfo);
+      error = 0;
+      goto out;
+    }
+    if (timeout == -1) {
+      error = EAGAIN;
+      goto out;
+    }
+    if (tsp != NULL && !timevalid) {
+      error = EINVAL;
+      goto out;
+    }
+
+    error =
+      sleepq_wait_timed(&td->td_sigmask, "sigtimedwait()", &p->p_lock, timeout);
+
+    if (error == ETIMEDOUT) {
+      error = EAGAIN;
+      goto out;
+    }
+
+    /* We need to find pending signal that we also wait for manually, as
+     * sig_pending may return a pending signal not from waitset. */
+    pending = td->td_sigpend.sp_set;
+    __sigandset(&waitset, &pending);
+    if ((sig = __sigfindset(&pending))) {
+      sigpend_get(&td->td_sigpend, sig, kinfo);
+      error = 0;
+    } else {
+      error = EINTR;
+    }
+  }
+
+out:
+  td->td_sigmask = saved_mask;
+  return error;
+}
+
 int do_sigpending(proc_t *p, sigset_t *set) {
   SCOPED_MTX_LOCK(&p->p_lock);
   thread_t *td = p->p_thread;

sys/kern/sleepq.c

@@ -324,7 +324,8 @@ int sleepq_wait_timed(void *wchan, const void *waitpt, mtx_t *mtx,
     callout_schedule(&td->td_slpcallout, timeout);
   }
 
-  td->td_flags |= (timeout > 0) ? TDF_SLPTIMED : TDF_SLPINTR;
+  td->td_flags |= TDF_SLPINTR;
+  td->td_flags |= (timeout > 0) ? TDF_SLPTIMED : 0;
   sq_enter(td, sc, wchan, waitpt);
 
   /* After wakeup, only one of the following flags may be set:

sys/kern/syscalls.c

@@ -1,4 +1,3 @@
-#define KL_LOG KL_SYSCALL
 #include <sys/klog.h>
 #include <sys/sysent.h>
 #include <sys/mimiker.h>
@@ -26,6 +25,7 @@
 #include <sys/pty.h>
 #include <sys/event.h>
 
+#include "sys/sigtypes.h"
 #include "sysent.h"
 
 /* Empty syscall handler, for unimplemented and deprecated syscall numbers. */
@@ -1330,5 +1330,34 @@ static int sys_kevent(proc_t *p, kevent_args_t *args, register_t *res) {
 
 static int sys_sigtimedwait(proc_t *p, sigtimedwait_args_t *args,
                             register_t *res) {
-  return ENOTSUP;
+  const sigset_t *u_set = SCARG(args, set);
+  siginfo_t *u_info = SCARG(args, info);
+  const timespec_t *u_timeout = SCARG(args, timeout);
+  sigset_t set;
+  ksiginfo_t kinfo;
+  timespec_t timeout = {};
+  timespec_t *tsp = NULL;
+  int error;
+
+  if (u_timeout) {
+    error = copyin_s(u_timeout, timeout);
+    tsp = &timeout;
+    if (error)
+      return error;
+  }
+
+  error = copyin_s(u_set, set);
+  if (error)
+    return error;
+
+  error = do_sigtimedwait(p, set, &kinfo, tsp);
+  if (error)
+    return error;
+
+  if (u_info) {
+    error = copyout_s(kinfo.ksi_info, u_info);
+  }
+  *res = kinfo.ksi_info.si_signo;
+
+  return error;
 }

sys/tests/utest.c

@@ -103,6 +103,8 @@ UTEST_ADD(signal_stop);
 UTEST_ADD(signal_cont_masked);
 UTEST_ADD(signal_mask);
 UTEST_ADD(signal_mask_nonmaskable);
+UTEST_ADD(signal_sigtimedwait);
+UTEST_ADD(signal_sigtimedwait_timeout);
 UTEST_ADD(signal_sigsuspend);
 UTEST_ADD(signal_sigsuspend_stop);
 UTEST_ADD(signal_handler_mask);