Changes in kernel/generic/src/synch/waitq.c [897fd8f1:63e27ef] in mainline

File:

• kernel/generic/src/synch/waitq.c (modified) (10 diffs)

kernel/generic/src/synch/waitq.c

@@ -45 +45 @@
 
 #include <assert.h>
-#include <errno.h>
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
@@ -239 +238 @@
  * @param flags Specify mode of the sleep.
  *
- * @param[out] blocked  On return, regardless of the return code,
- *                      `*blocked` is set to `true` iff the thread went to
- *                      sleep.
- *
  * The sleep can be interrupted only if the
  * SYNCH_FLAGS_INTERRUPTIBLE bit is specified in flags.
@@ -256 +251 @@
  * call will immediately return, reporting either success or failure.
  *
- * @return EAGAIN, meaning that the sleep failed because it was requested
- *                 as SYNCH_FLAGS_NON_BLOCKING, but there was no pending wakeup.
- * @return ETIMEOUT, meaning that the sleep timed out.
- * @return EINTR, meaning that somebody interrupted the sleeping
- *         thread. Check the value of `*blocked` to see if the thread slept,
- *         or if a pending interrupt forced it to return immediately.
- * @return EOK, meaning that none of the above conditions occured, and the
- *              thread was woken up successfuly by `waitq_wakeup()`. Check
- *              the value of `*blocked` to see if the thread slept or if
- *              the wakeup was already pending.
- *
- */
-int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, unsigned int flags, bool *blocked)
+ * @return ESYNCH_WOULD_BLOCK, meaning that the sleep failed because at the
+ *         time of the call there was no pending wakeup
+ * @return ESYNCH_TIMEOUT, meaning that the sleep timed out.
+ * @return ESYNCH_INTERRUPTED, meaning that somebody interrupted the sleeping
+ *         thread.
+ * @return ESYNCH_OK_ATOMIC, meaning that the sleep succeeded and that there
+ *         was a pending wakeup at the time of the call. The caller was not put
+ *         asleep at all.
+ * @return ESYNCH_OK_BLOCKED, meaning that the sleep succeeded; the full sleep
+ *         was attempted.
+ *
+ */
+int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, unsigned int flags)
 {
         assert((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
         
         ipl_t ipl = waitq_sleep_prepare(wq);
-        bool nblocked;
-        int rc = waitq_sleep_timeout_unsafe(wq, usec, flags, &nblocked);
-        waitq_sleep_finish(wq, nblocked, ipl);
-
-        if (blocked != NULL) {
-                *blocked = nblocked;
-        }
+        int rc = waitq_sleep_timeout_unsafe(wq, usec, flags);
+        waitq_sleep_finish(wq, rc, ipl);
         return rc;
 }
@@ -330 +320 @@
  * lock is released.
  *
- * @param wq       Wait queue.
- * @param blocked  Out parameter of waitq_sleep_timeout_unsafe().
- * @param ipl      Interrupt level returned by waitq_sleep_prepare().
- *
- */
-void waitq_sleep_finish(waitq_t *wq, bool blocked, ipl_t ipl)
-{
-        if (blocked) {
-                /*
+ * @param wq  Wait queue.
+ * @param rc  Return code of waitq_sleep_timeout_unsafe().
+ * @param ipl Interrupt level returned by waitq_sleep_prepare().
+ *
+ */
+void waitq_sleep_finish(waitq_t *wq, int rc, ipl_t ipl)
+{
+        switch (rc) {
+        case ESYNCH_WOULD_BLOCK:
+        case ESYNCH_OK_ATOMIC:
+                irq_spinlock_unlock(&wq->lock, false);
+                break;
+        default:
+                /* 
                  * Wait for a waitq_wakeup() or waitq_unsleep() to complete
                  * before returning from waitq_sleep() to the caller. Otherwise
                  * the caller might expect that the wait queue is no longer used 
                  * and deallocate it (although the wakeup on a another cpu has 
-                 * not yet completed and is using the wait queue).
-                 *
-                 * Note that we have to do this for EOK and EINTR, but not
-                 * necessarily for ETIMEOUT where the timeout handler stops
-                 * using the waitq before waking us up. To be on the safe side,
-                 * ensure the waitq is not in use anymore in this case as well.
+                 * not yet completed and is using the wait queue). 
+                 * 
+                 * Note that we have to do this for ESYNCH_OK_BLOCKED and
+                 * ESYNCH_INTERRUPTED, but not necessarily for ESYNCH_TIMEOUT
+                 * where the timeout handler stops using the waitq before waking 
+                 * us up. To be on the safe side, ensure the waitq is not in use 
+                 * anymore in this case as well.
                  */
                 waitq_complete_wakeup(wq);
-        } else {
-                irq_spinlock_unlock(&wq->lock, false);
+                break;
         }
         
@@ -368 +363 @@
  * @param flags See waitq_sleep_timeout().
  *
- * @param[out] blocked  See waitq_sleep_timeout().
- *
  * @return See waitq_sleep_timeout().
  *
  */
-int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, unsigned int flags, bool *blocked)
-{
-        *blocked = false;
-
+int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, unsigned int flags)
+{
         /* Checks whether to go to sleep at all */
         if (wq->missed_wakeups) {
                 wq->missed_wakeups--;
-                return EOK;
+                return ESYNCH_OK_ATOMIC;
         } else {
                 if (PARAM_NON_BLOCKING(flags, usec)) {
                         /* Return immediately instead of going to sleep */
-                        return EAGAIN;
+                        return ESYNCH_WOULD_BLOCK;
                 }
         }
@@ -401 +392 @@
                 if (THREAD->interrupted) {
                         irq_spinlock_unlock(&THREAD->lock, false);
-                        return EINTR;
+                        irq_spinlock_unlock(&wq->lock, false);
+                        return ESYNCH_INTERRUPTED;
                 }
                 
@@ -413 +405 @@
                         THREAD->last_cycle = get_cycle();
                         irq_spinlock_unlock(&THREAD->lock, false);
-                        return EINTR;
+                        return ESYNCH_INTERRUPTED;
                 }
         } else
@@ -424 +416 @@
                         THREAD->last_cycle = get_cycle();
                         irq_spinlock_unlock(&THREAD->lock, false);
-                        return ETIMEOUT;
+                        return ESYNCH_TIMEOUT;
                 }
                 
@@ -441 +433 @@
         THREAD->sleep_queue = wq;
         
-        /* Must be before entry to scheduler, because there are multiple
-         * return vectors.
-         */
-        *blocked = true;
-        
         irq_spinlock_unlock(&THREAD->lock, false);
         
@@ -451 +438 @@
         scheduler();
         
-        return EOK;
+        return ESYNCH_OK_BLOCKED;
 }