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

Timestamp:

2014-12-22T17:47:40Z (9 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

8c7d5ad

Parents:

eae91e0 (diff), 759ea0d (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 the CHT pre-integration branch

This branch contains:

• the merge of lp:~adam-hraska+lp/helenos/rcu, which brings:

• a new preemptible kernel RCU variant called A-RCU,
• a preemptible variant of Podzimek's non-preemptible kernel RCU and
• a new variant of usersace RCU,
• a new concurrent hash table (CHT) implementation based on RCU,
• a deployment of CHT in kernel futex handling,
• a deployment of the userspace RCU in the implementation of upgradable futexes,

all described in Adam Hraska's master thesis named Read-Copy-Update
for HelenOS, defended in 2013 at MFF UK; furthemore, the branch
fixes two synchronization bugs in condvars and waitq, respectively:

• revid:adam.hraska+hos@gmail.com-20121116144921-3to9u1tn1sg07rg7
• revid:adam.hraska+hos@gmail.com-20121116173623-km7gwtqixwudpe66

• build fixes required to pass make check
• overhaul of ia64 and sparc64 trap handling, to allow exc_dispatch() to be used now when the kernel is more picky about CPU state accounting
• an important fix of the sparc64/sun4v preemptible trap handler
• various other fixes of issues discovered on non-x86 architectures

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;
+}
+
+
 /** @}
  */