Changeset b1c57a8 in mainline for kernel/generic/src/synch/condvar.c

Timestamp:

2014-10-09T15:03:55Z (10 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e367939c

Parents:

21799398 (diff), 207e8880 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from lp:~adam-hraska+lp/helenos/rcu/.

Only merge from the feature branch and resolve all conflicts.

File:

• kernel/generic/src/synch/condvar.c (modified) (3 diffs)

kernel/generic/src/synch/condvar.c

@@ -38 +38 @@
 #include <synch/condvar.h>
 #include <synch/mutex.h>
+#include <synch/spinlock.h>
 #include <synch/waitq.h>
 #include <arch.h>
@@ -90 +91 @@
 
         ipl = waitq_sleep_prepare(&cv->wq);
+        /* Unlock only after the waitq is locked so we don't miss a wakeup. */
         mutex_unlock(mtx);
 
@@ -95 +97 @@
         rc = waitq_sleep_timeout_unsafe(&cv->wq, usec, flags);
 
+        waitq_sleep_finish(&cv->wq, rc, ipl);
+        /* Lock only after releasing the waitq to avoid a possible deadlock. */
         mutex_lock(mtx);
-        waitq_sleep_finish(&cv->wq, rc, ipl);
 
         return rc;
 }
 
+/** Wait for the condition to become true with a locked spinlock.
+ * 
+ * The function is not aware of irq_spinlock. Therefore do not even
+ * try passing irq_spinlock_t to it. Use _condvar_wait_timeout_irq_spinlock()
+ * instead.
+ *
+ * @param cv            Condition variable.
+ * @param lock          Locked spinlock.
+ * @param usec          Timeout value in microseconds.
+ * @param flags         Select mode of operation.
+ *
+ * For exact description of meaning of possible combinations of usec and flags,
+ * see comment for waitq_sleep_timeout().  Note that when
+ * SYNCH_FLAGS_NON_BLOCKING is specified here, ESYNCH_WOULD_BLOCK is always
+ * returned.
+ *
+ * @return See comment for waitq_sleep_timeout().
+ */
+int _condvar_wait_timeout_spinlock_impl(condvar_t *cv, spinlock_t *lock, 
+        uint32_t usec, int flags)
+{
+        int rc;
+        ipl_t ipl;
+        
+        ipl = waitq_sleep_prepare(&cv->wq);
+
+        /* Unlock only after the waitq is locked so we don't miss a wakeup. */
+        spinlock_unlock(lock);
+
+        cv->wq.missed_wakeups = 0;      /* Enforce blocking. */
+        rc = waitq_sleep_timeout_unsafe(&cv->wq, usec, flags);
+
+        waitq_sleep_finish(&cv->wq, rc, ipl);
+        /* Lock only after releasing the waitq to avoid a possible deadlock. */
+        spinlock_lock(lock);
+        
+        return rc;
+}
+
+/** Wait for the condition to become true with a locked irq spinlock.
+ * 
+ * @param cv            Condition variable.
+ * @param lock          Locked irq spinlock.
+ * @param usec          Timeout value in microseconds.
+ * @param flags         Select mode of operation.
+ *
+ * For exact description of meaning of possible combinations of usec and flags,
+ * see comment for waitq_sleep_timeout().  Note that when
+ * SYNCH_FLAGS_NON_BLOCKING is specified here, ESYNCH_WOULD_BLOCK is always
+ * returned.
+ *
+ * @return See comment for waitq_sleep_timeout().
+ */
+int _condvar_wait_timeout_irq_spinlock(condvar_t *cv, irq_spinlock_t *irq_lock, 
+        uint32_t usec, int flags)
+{
+        int rc;
+        /* Save spinlock's state so we can restore it correctly later on. */
+        ipl_t ipl = irq_lock->ipl;
+        bool guard = irq_lock->guard;
+        
+        irq_lock->guard = false;
+        
+        /* 
+         * waitq_prepare() restores interrupts to the current state, 
+         * ie disabled. Therefore, interrupts will remain disabled while 
+         * it spins waiting for a pending timeout handler to complete. 
+         * Although it spins with interrupts disabled there can only
+         * be a pending timeout if we failed to cancel an imminent
+         * timeout (on another cpu) during a wakeup. As a result the 
+         * timeout handler is guaranteed to run (it is most likely already 
+         * running) and there is no danger of a deadlock.
+         */
+        rc = _condvar_wait_timeout_spinlock(cv, &irq_lock->lock, usec, flags);
+        
+        irq_lock->guard = guard;
+        irq_lock->ipl = ipl;
+        
+        return rc;
+}
+
+
 /** @}
  */