Add a mutex to the sleepq wait interface. (#1378)

Author: MichalBlk

include/sys/sleepq.h

@@ -5,6 +5,7 @@
 #include <sys/types.h>
 #include <sys/queue.h>
 
+typedef struct mtx mtx_t;
 typedef struct thread thread_t;
 typedef struct sleepq sleepq_t;
 
@@ -23,11 +24,14 @@ void sleepq_destroy(sleepq_t *sq);
  *
  * \param wchan unique sleep queue identifier
  * \param waitpt caller associated with sleep action
+ * \param mtx mutex to release before falling asleep and reacquire
+ * upon waking up
  */
-void sleepq_wait(void *wchan, const void *waitpt);
+void sleepq_wait(void *wchan, const void *waitpt, mtx_t *mtx);
 
 /*! \brief Same as \a sleepq_wait but allows the sleep to be interrupted. */
-#define sleepq_wait_intr(wchan, waitpt) sleepq_wait_timed((wchan), (waitpt), 0)
+#define sleepq_wait_intr(wchan, waitpt, mtx)                                   \
+  sleepq_wait_timed((wchan), (waitpt), (mtx), 0)
 
 /*! \brief Performs interruptible sleep with timeout.
  *
@@ -37,7 +41,8 @@ void sleepq_wait(void *wchan, const void *waitpt);
  *
  * \param timeout in system ticks, if 0 waits indefinitely
  * \returns how the thread was actually woken up */
-int sleepq_wait_timed(void *wchan, const void *waitpt, systime_t timeout);
+int sleepq_wait_timed(void *wchan, const void *waitpt, mtx_t *mtx,
+                      systime_t timeout);
 
 /*! \brief Wakes up highest priority thread waiting on \a wchan.
  *

sys/drv/rtc.c

@@ -80,7 +80,7 @@ static int rtc_time_read(devnode_t *dev, uio_t *uio) {
   rtc_state_t *rtc = dev->data;
   tm_t t;
 
-  sleepq_wait(rtc, NULL);
+  sleepq_wait(rtc, NULL, NULL);
   rtc_gettime(rtc->regs, &t);
   int count = snprintf(rtc->asctime, RTC_ASCTIME_SIZE, "%d %d %d %d %d %d",
                        t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour,

sys/kern/callout.c

@@ -55,7 +55,7 @@ static void callout_thread(void *arg) {
 
     WITH_INTR_DISABLED {
       while (TAILQ_EMPTY(&delegated)) {
-        sleepq_wait(&delegated, NULL);
+        sleepq_wait(&delegated, NULL, NULL);
       }
 
       elem = TAILQ_FIRST(&delegated);
@@ -211,6 +211,6 @@ bool callout_drain(callout_t *handle) {
   if (!callout_is_pending(handle) && !callout_is_active(handle))
     return false;
   while (callout_is_pending(handle) || callout_is_active(handle))
-    sleepq_wait(handle, NULL);
+    sleepq_wait(handle, NULL, NULL);
   return true;
 }

sys/kern/condvar.c

@@ -15,7 +15,7 @@ void cv_wait(condvar_t *cv, mtx_t *m) {
     /* If we got interrupted here and an interrupt filter called
      * cv_signal, we would have a lost wakeup, so we need interrupts
      * to be disabled. Same goes for cv_wait_timed. */
-    sleepq_wait(cv, __caller(0));
+    sleepq_wait(cv, __caller(0), NULL);
   }
   _mtx_lock(m, __caller(0));
 }
@@ -25,7 +25,7 @@ int cv_wait_timed(condvar_t *cv, mtx_t *m, systime_t timeout) {
   WITH_INTR_DISABLED {
     cv->waiters++;
     mtx_unlock(m);
-    status = sleepq_wait_timed(cv, __caller(0), timeout);
+    status = sleepq_wait_timed(cv, __caller(0), NULL, timeout);
   }
   _mtx_lock(m, __caller(0));
   return status;

sys/kern/interrupt.c

@@ -275,7 +275,7 @@ static void intr_thread(void *arg) {
       if (!TAILQ_EMPTY(&ie->ie_handlers))
         ie_enable(ie);
 
-      sleepq_wait(ie, NULL);
+      sleepq_wait(ie, NULL, NULL);
     }
   }
 }

sys/kern/signal.c

@@ -195,7 +195,7 @@ int do_sigsuspend(proc_t *p, const sigset_t *mask) {
   }
 
   int error;
-  error = sleepq_wait_intr(&td->td_sigmask, "sigsuspend()");
+  error = sleepq_wait_intr(&td->td_sigmask, "sigsuspend()", NULL);
   assert(error == EINTR);
 
   return ERESTARTNOHAND;

sys/kern/sleepq.c

@@ -274,39 +274,49 @@ bool sleepq_abort(thread_t *td) {
   return _sleepq_abort(td, EINTR);
 }
 
-void sleepq_wait(void *wchan, const void *waitpt) {
+void sleepq_wait(void *wchan, const void *waitpt, mtx_t *mtx) {
   thread_t *td = thread_self();
 
   if (waitpt == NULL)
     waitpt = __caller(0);
 
   sleepq_chain_t *sc = sc_acquire(wchan);
+  if (mtx)
+    mtx_unlock(mtx);
   mtx_lock(td->td_lock);
   td->td_state = TDS_SLEEPING;
   sq_enter(td, sc, wchan, waitpt);
 
   /* Panic if we were interrupted by timeout or signal. */
   assert((td->td_flags & (TDF_SLPINTR | TDF_SLPTIMED)) == 0);
+
+  if (mtx)
+    mtx_lock(mtx);
 }
 
 static void sq_timeout(thread_t *td) {
   _sleepq_abort(td, ETIMEDOUT);
 }
 
-int sleepq_wait_timed(void *wchan, const void *waitpt, systime_t timeout) {
+int sleepq_wait_timed(void *wchan, const void *waitpt, mtx_t *mtx,
+                      systime_t timeout) {
   thread_t *td = thread_self();
+  int error = 0;
 
   if (waitpt == NULL)
     waitpt = __caller(0);
 
   sleepq_chain_t *sc = sc_acquire(wchan);
+  if (mtx)
+    mtx_unlock(mtx);
   mtx_lock(td->td_lock);
 
   /* If there are pending signals, interrupt the sleep immediately. */
   if ((td->td_flags & TDF_NEEDSIGCHK) && (timeout == 0)) {
     mtx_unlock(td->td_lock);
     sc_release(sc);
-    return EINTR;
+    error = EINTR;
+    goto end;
   }
 
   if (timeout > 0) {
@@ -320,7 +330,6 @@ int sleepq_wait_timed(void *wchan, const void *waitpt, systime_t timeout) {
   /* After wakeup, only one of the following flags may be set:
    *  - TDF_SLPINTR if sleep was aborted,
    *  - TDF_SLPTIMED if sleep has timed out. */
-  int error = 0;
   WITH_MTX_LOCK (td->td_lock) {
     if (td->td_flags & TDF_SLPINTR) {
       error = EINTR;
@@ -333,5 +342,8 @@ int sleepq_wait_timed(void *wchan, const void *waitpt, systime_t timeout) {
   if (timeout > 0)
     callout_stop(&td->td_slpcallout);
 
+end:
+  if (mtx)
+    mtx_lock(mtx);
   return error;
 }

sys/kern/time.c

@@ -89,7 +89,7 @@ int do_clock_nanosleep(clockid_t clk, int flags, timespec_t *rqtp,
   }
 
   do {
-    error = sleepq_wait_timed((void *)(&rmt_start), __caller(0), timo);
+    error = sleepq_wait_timed((void *)(&rmt_start), __caller(0), NULL, timo);
     if (error == ETIMEDOUT)
       goto timedout;
 

sys/tests/sleepq.c

@@ -12,7 +12,7 @@ static void test_thread(void *expected) {
     WITH_NO_PREEMPTION {
       wakeups++;
     }
-    sleepq_wait(&test_thread, NULL);
+    sleepq_wait(&test_thread, NULL, NULL);
   }
 }
 

sys/tests/sleepq_abort.c

@@ -35,7 +35,7 @@ static volatile int interrupted;
  * when waiters can't.
  * Therefore there should be only one waiter active at once */
 static void waiter_routine(void *_arg) {
-  int rsn = sleepq_wait_intr(&some_val, __caller(0));
+  int rsn = sleepq_wait_intr(&some_val, __caller(0), NULL);
 
   if (rsn == EINTR)
     interrupted++;

sys/tests/sleepq_timed.c

@@ -34,7 +34,7 @@ static thread_t *waker;
 
 static void waiter_routine(void *_arg) {
   systime_t before_sleep = getsystime();
-  int status = sleepq_wait_timed(&wchan, __caller(0), SLEEP_TICKS);
+  int status = sleepq_wait_timed(&wchan, __caller(0), NULL, SLEEP_TICKS);
   systime_t after_sleep = getsystime();
   systime_t diff = after_sleep - before_sleep;
 

sys/tests/thread_stats.c

@@ -53,12 +53,12 @@ static void thread_wake_function(void *arg) {
 }
 
 static void thread_sleep_function(void *arg) {
-  sleepq_wait(arg, "Thread stats test sleepq");
+  sleepq_wait(arg, "Thread stats test sleepq", NULL);
   bintime_t end = *(bintime_t *)arg;
   bintime_add_frac(&end, test_time_frac);
   bintime_t now = binuptime();
   while (bintime_cmp(&now, &end, <)) {
-    sleepq_wait(arg, "Thread stats test sleepq");
+    sleepq_wait(arg, "Thread stats test sleepq", NULL);
     now = binuptime();
   }
 }

sys/tests/turnstile_adjust.c

@@ -83,7 +83,7 @@ static int test_turnstile_adjust(void) {
   for (int i = 0; i < T; i++) {
     WITH_NO_PREEMPTION {
       sched_add(threads[i]);
-      sleepq_wait(threads[i], "thread start");
+      sleepq_wait(threads[i], "thread start", NULL);
     }
   }