Changeset 203f4c3 in mainline

Timestamp:

2006-04-09T14:14:49Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

016acbe

Parents:

fe04594

Message:

Sleeping in a wait queue can be now interrupted with
waitq_interrupt_sleep().

Location:

generic

Files:

• include/proc/thread.h (modified) (1 diff)
• include/synch/synch.h (modified) (1 diff)
• include/synch/waitq.h (modified) (1 diff)
• src/synch/waitq.c (modified) (7 diffs)

generic/include/proc/thread.h

@@ -81 +81 @@
         void *thread_arg;                       /**< Argument passed to thread_code() function. */
 
-        context_t saved_context;                /**< From here, the stored context is restored when the thread is scheduled. */
-        context_t sleep_timeout_context;        /**< From here, the stored failover context is restored when sleep times out. */
+        /** From here, the stored context is restored when the thread is scheduled. */
+        context_t saved_context;
+        /** From here, the stored timeout context is restored when sleep times out. */
+        context_t sleep_timeout_context;
+        /** From here, the stored interruption context is restored when sleep is interrupted. */
+        context_t sleep_interruption_context;
 
         waitq_t *sleep_queue;                   /**< Wait queue in which this thread sleeps. */

generic/include/synch/synch.h

@@ -36 +36 @@
 #define ESYNCH_WOULD_BLOCK      1       /**< Could not satisfy the request without going to sleep. */
 #define ESYNCH_TIMEOUT          2       /**< Timeout occurred. */
-#define ESYNCH_OK_ATOMIC        4       /**< Operation succeeded without sleeping. */
-#define ESYNCH_OK_BLOCKED       8       /**< Operation succeeded and did sleep. */
+#define ESYNCH_INTERRUPTED      4       /**< Sleep was interrupted. */
+#define ESYNCH_OK_ATOMIC        8       /**< Operation succeeded without sleeping. */
+#define ESYNCH_OK_BLOCKED       16      /**< Operation succeeded and did sleep. */
 
-#define SYNCH_FAILED(rc)        ((rc) & (ESYNCH_WOULD_BLOCK | ESYNCH_TIMEOUT))
+#define SYNCH_FAILED(rc)        ((rc) & (ESYNCH_WOULD_BLOCK | ESYNCH_TIMEOUT | ESYNCH_INTERRUPTED))
 #define SYNCH_OK(rc)            ((rc) & (ESYNCH_OK_ATOMIC | ESYNCH_OK_BLOCKED))
 

generic/include/synch/waitq.h

@@ -55 +55 @@
         waitq_sleep_timeout((wq),SYNCH_NO_TIMEOUT,SYNCH_BLOCKING)
 
-extern void waitq_interrupted_sleep(void *data);
-
 extern void waitq_initialize(waitq_t *wq);
 extern int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int nonblocking);
 extern void waitq_wakeup(waitq_t *wq, bool all);
 extern void _waitq_wakeup_unsafe(waitq_t *wq, bool all);
+extern void waitq_interrupt_sleep(thread_t *t);
 
 #endif

generic/src/synch/waitq.c

@@ -40 +40 @@
 #include <adt/list.h>
 
+static void waitq_timeouted_sleep(void *data);
+
 /** Initialize wait queue
  *
@@ -65 +67 @@
  * @param data Pointer to the thread that called waitq_sleep_timeout().
  */
-void waitq_interrupted_sleep(void *data)
+void waitq_timeouted_sleep(void *data)
 {
         thread_t *t = (thread_t *) data;
@@ -101 +103 @@
 }
 
-/** Sleep until either wakeup or timeout occurs
+/** Interrupt sleeping thread.
+ *
+ * This routine attempts to interrupt a thread from its sleep in a waitqueue.
+ * If the thread is not found sleeping, no action is taken.
+ *
+ * @param t Thread to be interrupted.
+ */
+void waitq_interrupt_sleep(thread_t *t)
+{
+        waitq_t *wq;
+        bool do_wakeup = false;
+        ipl_t ipl;
+
+        ipl = interrupts_disable();
+        spinlock_lock(&threads_lock);
+        if (!list_member(&t->threads_link, &threads_head))
+                goto out;
+
+grab_locks:
+        spinlock_lock(&t->lock);
+        if ((wq = t->sleep_queue)) {            /* assignment */
+                if (!spinlock_trylock(&wq->lock)) {
+                        spinlock_unlock(&t->lock);
+                        goto grab_locks;        /* avoid deadlock */
+                }
+
+                list_remove(&t->wq_link);
+                t->saved_context = t->sleep_interruption_context;
+                do_wakeup = true;
+                
+                spinlock_unlock(&wq->lock);
+                t->sleep_queue = NULL;
+        }
+        spinlock_unlock(&t->lock);
+
+        if (do_wakeup)
+                thread_ready(t);
+
+out:
+        spinlock_unlock(&threads_lock);
+        interrupts_restore(ipl);
+}
+
+
+/** Sleep until either wakeup, timeout or interruption occurs
  *
  * This is a sleep implementation which allows itself to be
@@ -131 +177 @@
  *
  * ESYNCH_TIMEOUT means that the sleep timed out.
+ *
+ * ESYNCH_INTERRUPTED means that somebody interrupted the sleeping thread.
  *
  * ESYNCH_OK_ATOMIC means that the sleep succeeded and that there was
@@ -179 +227 @@
                 }
         }
-
         
         /*
@@ -185 +232 @@
          */
         spinlock_lock(&THREAD->lock);
+
+        /*
+         * Set context that will be restored if the sleep
+         * of this thread is ever interrupted.
+         */
+        if (!context_save(&THREAD->sleep_interruption_context)) {
+                /* Short emulation of scheduler() return code. */
+                spinlock_unlock(&THREAD->lock);
+                interrupts_restore(ipl);
+                return ESYNCH_INTERRUPTED;
+        }
+
         if (usec) {
                 /* We use the timeout variant. */
                 if (!context_save(&THREAD->sleep_timeout_context)) {
-                        /*
-                         * Short emulation of scheduler() return code.
-                         */
+                        /* Short emulation of scheduler() return code. */
                         spinlock_unlock(&THREAD->lock);
                         interrupts_restore(ipl);
@@ -196 +253 @@
                 }
                 THREAD->timeout_pending = true;
-                timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_interrupted_sleep, THREAD);
+                timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_timeouted_sleep, THREAD);
         }