Changeset 5c8ba05 in mainline

Timestamp:

2007-05-07T18:52:24Z (18 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

6fa4888b

Parents:

4f42d52

Message:

Cleanup the waitq_wakeup() interface.
Replace numeric constants (i.e. 0)
and boolean constants (i.e. false) with
more readable WAKEUP_FIRST. Also change the
type of the second argument of waitq_wakeup()
to a newly introduced type wakeup_mode_t.

Fix behaviour of waitq_wakeup() in case
that WAKEUP_ALL semantics is required
but no threads are sleeping in the wait
queue. This is a similar fix to that of
Jan Hudecek committed in the RCU branch,
but, IMHO, is more straightforward and
also doesn't eat up previous missed
wakeups.

Location:

kernel/generic

Files:

• include/synch/waitq.h (modified) (2 diffs)
• src/ipc/ipc.c (modified) (2 diffs)
• src/proc/scheduler.c (modified) (1 diff)
• src/synch/waitq.c (modified) (4 diffs)

kernel/generic/include/synch/waitq.h

@@ -41 +41 @@
 #include <adt/list.h>
 
-#define WAKEUP_FIRST    0
-#define WAKEUP_ALL      1
+typedef enum {
+        WAKEUP_FIRST = 0,
+        WAKEUP_ALL
+} wakeup_mode_t;
 
 /** Wait queue structure. */
@@ -71 +73 @@
 extern int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, int flags);
 extern void waitq_sleep_finish(waitq_t *wq, int rc, ipl_t ipl);
-extern void waitq_wakeup(waitq_t *wq, bool all);
-extern void _waitq_wakeup_unsafe(waitq_t *wq, bool all);
+extern void waitq_wakeup(waitq_t *wq, wakeup_mode_t mode);
+extern void _waitq_wakeup_unsafe(waitq_t *wq, wakeup_mode_t mode);
 extern void waitq_interrupt_sleep(struct thread *t);
 

kernel/generic/src/ipc/ipc.c

@@ -164 +164 @@
         list_append(&call->link, &callerbox->answers);
         spinlock_unlock(&callerbox->lock);
-        waitq_wakeup(&callerbox->wq, 0);
+        waitq_wakeup(&callerbox->wq, WAKEUP_FIRST);
 }
 
@@ -206 +206 @@
         list_append(&call->link, &box->calls);
         spinlock_unlock(&box->lock);
-        waitq_wakeup(&box->wq, 0);
+        waitq_wakeup(&box->wq, WAKEUP_FIRST);
 }
 

kernel/generic/src/proc/scheduler.c

@@ -412 +412 @@
                                         goto repeat;
                                 }
-                                _waitq_wakeup_unsafe(&THREAD->join_wq, false);
+                                _waitq_wakeup_unsafe(&THREAD->join_wq,
+                                    WAKEUP_FIRST);
                                 spinlock_unlock(&THREAD->join_wq.lock);
                                 

kernel/generic/src/synch/waitq.c

@@ -384 +384 @@
  * timeout.
  *
- * @param wq Pointer to wait queue.
- * @param all If this is non-zero, all sleeping threads will be woken up and
- *      missed count will be zeroed.
- */
-void waitq_wakeup(waitq_t *wq, bool all)
+ * @param wq    Pointer to wait queue.
+ * @param mode  Wakeup mode.
+ */
+void waitq_wakeup(waitq_t *wq, wakeup_mode_t mode)
 {
         ipl_t ipl;
@@ -395 +394 @@
         spinlock_lock(&wq->lock);
 
-        _waitq_wakeup_unsafe(wq, all);
-
-        spinlock_unlock(&wq->lock);     
-        interrupts_restore(ipl);        
+        _waitq_wakeup_unsafe(wq, mode);
+
+        spinlock_unlock(&wq->lock);
+        interrupts_restore(ipl);
 }
 
@@ -406 +405 @@
  * assumes wq->lock is already locked and interrupts are already disabled.
  *
- * @param wq Pointer to wait queue.
- * @param all If this is non-zero, all sleeping threads will be woken up and
- *      missed count will be zeroed.
- */
-void _waitq_wakeup_unsafe(waitq_t *wq, bool all)
+ * @param wq    Pointer to wait queue.
+ * @param mode  If mode is WAKEUP_FIRST, then the longest waiting thread,
+ *              if any, is woken up. If mode is WAKEUP_ALL, then all
+ *              waiting threads, if any, are woken up. If there are no
+ *              waiting threads to be woken up, the missed wakeup is
+ *              recorded in the wait queue.
+ */
+void _waitq_wakeup_unsafe(waitq_t *wq, wakeup_mode_t mode)
 {
         thread_t *t;
+        count_t count = 0;
 
 loop:   
         if (list_empty(&wq->head)) {
                 wq->missed_wakeups++;
-                if (all)
-                        wq->missed_wakeups = 0;
+                if (count && mode == WAKEUP_ALL)
+                        wq->missed_wakeups--;
                 return;
         }
 
+        count++;
         t = list_get_instance(wq->head.next, thread_t, wq_link);
         
@@ -450 +454 @@
         thread_ready(t);
 
-        if (all)
+        if (mode == WAKEUP_ALL)
                 goto loop;
 }