fix(task): handle the case where next_running_task == prev_running_task in choose_next_running_task

Fixes the test case `timer_zero_period` failing on `gr_peach`.

The following diagram illustrates a simplified execution flow that
causes this bug:

    wait_until_woken_up:
      [running_task = &task1]
      task1.state = Waiting
      leave_cpu_lock()
                               interrupt_handler:
                                 make_ready(&task1):
                                   task1.state = Ready
                                   queue.push_back(&task1)
                                 yield_cpu()
                                 choose_next_running_task():
                                   next_running_task = queue.pop_front()
                                   [next_running_task = &task1]
                                   next_running_task.state = Running
                                   make_ready(&running_task):
                                     running_task.state = Ready
                                     queue.push_back(&running_task)
                                   running_task = next_running_task
      yield_cpu()
      [task1.state = Ready]
      yield_cpu()
      [task1.state = Ready]
      <loop indefinitely>

    (Conditional branches are omitted. Brackets [] denotes excerpts of
    current internal states that destine the outcomes of conditional
    branches.)

`choose_next_running_task` did not handle the case where
`next_running_task == prev_running_task`. As a result, it transitioned
`next_running_task` into Ready state when it's expected to transition it
into Running state.

The correct execution flow looks like the following:

    wait_until_woken_up:
      [running_task = &task1]
      task1.state = Waiting
      leave_cpu_lock()
                               interrupt_handler:
                                 make_ready(&task1):
                                   task1.state = Ready
                                   queue.push_back(&task1)
                                 yield_cpu()
                                 choose_next_running_task():
                                   next_running_task = queue.pop_front()
                                   [next_running_task = &task1]
                                   next_running_task.state = Running
                                   [next_running_task = running_task]
      yield_cpu()
      [task1.state = Running]
      enter_cpu_lock()

Author: yvt

src/constance/src/kernel/task.rs

@@ -570,7 +570,11 @@ pub(super) fn unlock_cpu_and_check_preemption<System: Kernel>(
 
     let prev_task_priority =
         if let Some(running_task) = System::state().running_task(lock.borrow_mut()) {
-            running_task.priority.read(&*lock).to_usize().unwrap()
+            if *running_task.st.read(&*lock) == TaskSt::Running {
+                running_task.priority.read(&*lock).to_usize().unwrap()
+            } else {
+                usize::MAX
+            }
         } else {
             usize::MAX
         };
@@ -667,12 +671,18 @@ pub(super) fn choose_next_running_task<System: Kernel>(
         // Transition `next_running_task` into the Running state
         task.st.replace(&mut *lock, TaskSt::Running);
 
+        if ptr_from_option_ref(prev_running_task) == task {
+            // Skip the remaining steps if `task == prev_running_task`
+            return;
+        }
+
         Some(task)
     } else {
         None
     };
 
-    // If `prev_running_task` is in the Running state, transition it into Ready
+    // If `prev_running_task` is in the Running state, transition it into Ready.
+    // Assumes `prev_running_task != next_running_task`.
     if let Some(running_task) = prev_running_task {
         match running_task.st.read(&*lock) {
             TaskSt::Running => {
@@ -689,6 +699,15 @@ pub(super) fn choose_next_running_task<System: Kernel>(
         .replace(&mut *lock, next_running_task);
 }
 
+#[inline]
+fn ptr_from_option_ref<T>(x: Option<&T>) -> *const T {
+    if let Some(x) = x {
+        x
+    } else {
+        core::ptr::null()
+    }
+}
+
 /// Transition the currently running task into the Waiting state. Returns when
 /// woken up.
 ///
@@ -723,6 +742,8 @@ pub(super) fn wait_until_woken_up<System: Kernel>(
         if *running_task.st.read(&*lock) == TaskSt::Running {
             break;
         }
+
+        assert_eq!(*running_task.st.read(&*lock), TaskSt::Waiting);
     }
 }
 

src/constance_test_suite/src/kernel_tests/time_misc.rs

@@ -122,5 +122,9 @@ fn task_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
         Err(constance::kernel::SleepError::BadParam)
     );
 
+    // Wait zero microseconds
+    log::trace!("sleep(0)");
+    System::sleep(Duration::ZERO).unwrap();
+
     D::success();
 }