task: add wake_all parameter to WaitQueue::wakeup and name test increment

Per review: wakeup() now takes wake_all so callers must be conscious of
wake-all vs wake-head semantics; task termination wakes the entire queue,
while wake_all=false removes only the head waiter for future turnstile-
type waits. The multi-waiter test's magic 10 becomes a named constant.

Author: mvanhorn

kernel/src/task/schedule.rs

@@ -951,6 +951,7 @@ mod test {
     }
 
     static MULTI_WAITER_COUNTER: AtomicU32 = AtomicU32::new(0);
+    const MULTI_WAITER_TASK_INCREMENT: u32 = 10;
 
     fn multi_waiter_target(_: usize) {
         // Increment the counter and exit; both waiting_task instances below
@@ -964,7 +965,7 @@ mod test {
         if let Some(task) = target {
             wait_for_termination(task);
         }
-        MULTI_WAITER_COUNTER.fetch_add(10, Ordering::Relaxed);
+        MULTI_WAITER_COUNTER.fetch_add(MULTI_WAITER_TASK_INCREMENT, Ordering::Relaxed);
     }
 
     #[test]
@@ -999,8 +1000,11 @@ mod test {
         wait_for_termination(target);
 
         // Both waiter tasks must have run: multi_waiter_target adds 1,
-        // each waiting_task adds 10. Total = 1 + 10 + 10 = 21.
-        assert_eq!(MULTI_WAITER_COUNTER.load(Ordering::Relaxed), 21);
+        // each waiting_task adds MULTI_WAITER_TASK_INCREMENT.
+        assert_eq!(
+            MULTI_WAITER_COUNTER.load(Ordering::Relaxed),
+            1 + (MULTI_WAITER_TASK_INCREMENT * 2)
+        );
     }
 
     #[test]

kernel/src/task/tasks.rs

@@ -598,7 +598,7 @@ impl Task {
         self.sched_state
             .panic_on_idle("Trying to terminate idle task")
             .set_state(TaskState::TERMINATED);
-        self.wait_queue.lock().wakeup()
+        self.wait_queue.lock().wakeup(true)
     }
 
     pub fn set_task_blocked(&self) {

kernel/src/task/waiting.rs

@@ -9,7 +9,7 @@ use intrusive_collections::LinkedList;
 use super::tasks::{TaskPointer, TaskWaitListAdapter};
 
 /// A queue of tasks waiting for a single event. Multiple tasks may wait
-/// simultaneously; all are woken when the event fires.
+/// simultaneously.
 #[derive(Debug)]
 pub struct WaitQueue {
     waiters: LinkedList<TaskWaitListAdapter>,
@@ -29,10 +29,19 @@ impl WaitQueue {
         self.waiters.push_back(current_task);
     }
 
-    /// Wake all waiting tasks. Returns the drained list of waiters so the
-    /// caller can schedule each one.
-    pub fn wakeup(&mut self) -> LinkedList<TaskWaitListAdapter> {
-        self.waiters.take()
+    /// Wake waiting tasks. If `wake_all` is false, only the head waiter is
+    /// removed. Returns the removed waiters so the caller can schedule each
+    /// one.
+    pub fn wakeup(&mut self, wake_all: bool) -> LinkedList<TaskWaitListAdapter> {
+        if wake_all {
+            self.waiters.take()
+        } else {
+            let mut waiters = LinkedList::new(TaskWaitListAdapter::new());
+            if let Some(task) = self.waiters.pop_front() {
+                waiters.push_back(task);
+            }
+            waiters
+        }
     }
 }