Changeset 5573942 in mainline

Timestamp:

2007-02-04T11:46:18Z (17 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

15819e37

Parents:

cf5ddf6

Message:

Revert thread_interrupt_sleep() to waitq_interrupt_sleep().
I'd prefer that this, IMO, waitq related stuff stays together.

Location:

kernel/generic

Files:

• include/ddi/irq.h (modified) (1 diff)
• include/proc/thread.h (modified) (1 diff)
• include/synch/waitq.h (modified) (2 diffs)
• src/proc/task.c (modified) (2 diffs)
• src/proc/thread.c (modified) (1 diff)
• src/synch/waitq.c (modified) (1 diff)

kernel/generic/include/ddi/irq.h

@@ -84 +84 @@
 typedef void (* irq_handler_t)(struct irq *irq, void *arg, ...);
 
-
-
 /** IPC notification config structure.
  *

kernel/generic/include/proc/thread.h

@@ -244 +244 @@
 extern void thread_update_accounting(void);
 extern bool thread_exists(thread_t *t);
-extern void thread_interrupt_sleep(thread_t *t);
 
 /** Fpu context slab cache. */

kernel/generic/include/synch/waitq.h

@@ -64 +64 @@
         waitq_sleep_timeout((wq), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
 
+struct thread;
+
 extern void waitq_initialize(waitq_t *wq);
 extern int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, int flags);
@@ -71 +73 @@
 extern void waitq_wakeup(waitq_t *wq, bool all);
 extern void _waitq_wakeup_unsafe(waitq_t *wq, bool all);
+extern void waitq_interrupt_sleep(struct thread *t);
 
 #endif

kernel/generic/src/proc/task.c

@@ -43 +43 @@
 #include <mm/slab.h>
 #include <synch/spinlock.h>
+#include <synch/waitq.h>
 #include <arch.h>
 #include <panic.h>
@@ -364 +365 @@
                 
                 if (sleeping)
-                        thread_interrupt_sleep(thr);
+                        waitq_interrupt_sleep(thr);
         }
         

kernel/generic/src/proc/thread.c

@@ -679 +679 @@
 }
 
-/** 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 thread_interrupt_sleep(thread_t *t)
-{
-        waitq_t *wq;
-        bool do_wakeup = false;
-        ipl_t ipl;
-
-        ipl = interrupts_disable();
-        spinlock_lock(&threads_lock);
-        if (!thread_exists(t))
-                goto out;
-
-grab_locks:
-        spinlock_lock(&t->lock);
-        if ((wq = t->sleep_queue)) {            /* assignment */
-                if (!(t->sleep_interruptible)) {
-                        /*
-                         * The sleep cannot be interrupted.
-                         */
-                        spinlock_unlock(&t->lock);
-                        goto out;
-                }
-                        
-                if (!spinlock_trylock(&wq->lock)) {
-                        spinlock_unlock(&t->lock);
-                        goto grab_locks;        /* avoid deadlock */
-                }
-
-                if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
-                        t->timeout_pending = false;
-
-                list_remove(&t->wq_link);
-                t->saved_context = t->sleep_interruption_context;
-                do_wakeup = true;
-                t->sleep_queue = NULL;
-                spinlock_unlock(&wq->lock);
-        }
-        spinlock_unlock(&t->lock);
-
-        if (do_wakeup)
-                thread_ready(t);
-
-out:
-        spinlock_unlock(&threads_lock);
-        interrupts_restore(ipl);
-}
-
 /** @}
  */

kernel/generic/src/synch/waitq.c

@@ -117 +117 @@
 }
 
+/** 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 (!thread_exists(t))
+                goto out;
+
+grab_locks:
+        spinlock_lock(&t->lock);
+        if ((wq = t->sleep_queue)) {            /* assignment */
+                if (!(t->sleep_interruptible)) {
+                        /*
+                         * The sleep cannot be interrupted.
+                         */
+                        spinlock_unlock(&t->lock);
+                        goto out;
+                }
+                        
+                if (!spinlock_trylock(&wq->lock)) {
+                        spinlock_unlock(&t->lock);
+                        goto grab_locks;        /* avoid deadlock */
+                }
+
+                if (t->timeout_pending && timeout_unregister(&t->sleep_timeout))
+                        t->timeout_pending = false;
+
+                list_remove(&t->wq_link);
+                t->saved_context = t->sleep_interruption_context;
+                do_wakeup = true;
+                t->sleep_queue = NULL;
+                spinlock_unlock(&wq->lock);
+        }
+        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