Changeset b3f8fb7 in mainline for kernel/generic/src/proc

Timestamp:

2007-01-28T13:25:49Z (18 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

8e8c1a5

Parents:

1ba41c5

Message:

huge type system cleanup
remove cyclical type dependencies across multiple header files
many minor coding style fixes

Location:

kernel/generic/src/proc

Files:

• scheduler.c (modified) (2 diffs)
• task.c (modified) (1 diff)
• the.c (modified) (1 diff)
• thread.c (modified) (2 diffs)

kernel/generic/src/proc/scheduler.c

@@ -45 +45 @@
 #include <mm/page.h>
 #include <mm/as.h>
+#include <time/timeout.h>
 #include <time/delay.h>
 #include <arch/asm.h>
@@ -53 +54 @@
 #include <config.h>
 #include <context.h>
+#include <fpu_context.h>
 #include <func.h>
 #include <arch.h>
 #include <adt/list.h>
 #include <panic.h>
-#include <typedefs.h>
 #include <cpu.h>
 #include <print.h>

kernel/generic/src/proc/task.c

@@ -364 +364 @@
                 
                 if (sleeping)
-                        waitq_interrupt_sleep(thr);
+                        thread_interrupt_sleep(thr);
         }
         

kernel/generic/src/proc/the.c

@@ -43 +43 @@
 
 #include <arch.h>
-#include <typedefs.h>
 
 

kernel/generic/src/proc/thread.c

@@ -54 +54 @@
 #include <adt/btree.h>
 #include <adt/list.h>
-#include <typedefs.h>
 #include <time/clock.h>
+#include <time/timeout.h>
 #include <config.h>
 #include <arch/interrupt.h>
@@ -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);
+}
+
 /** @}
  */