fix(wait): call unlock_cpu_and_check_preemption after timeout expiration

It's necessary to call `unlock_cpu_and_check_preemption` after waking up
a task. For timed wake-ups, there are two possible places to do this:

 1. The timeout callback function `interrupt_task_by_timeout` (defined
    in `wait.rs`). However, `unlock_cpu_and_check_preemption` takes the
    ownership of CPU Lock and the convention of timeout callback
    functions requires that they enter and leave with CPU Lock active,
    so this function would have to re-acquire CPU Lock before returning.

 2. The tick handler, `handle_tick` (defined in `timeout.rs`). It
    already releases CPU Lock, so this option doesn't have the CPU Lock
    issue. This option may cause redundant calls to
    `unlock_cpu_and_check_preemption`, but those won't happen too often
    because timeout objects are expected to be used to wake up tasks for
    most of the times.

This commit implements the second option.

Author: yvt

src/constance/src/kernel/timeout.rs

@@ -135,6 +135,7 @@ use core::{
 };
 
 use super::{
+    task,
     utils::{lock_cpu, CpuLockCell, CpuLockGuard, CpuLockGuardBorrowMut},
     AdjustTimeError, BadParamError, Kernel, TimeError, UTicks,
 };
@@ -339,6 +340,14 @@ pub(super) struct Timeout<System: Kernel> {
     _phantom: core::marker::PhantomData<System>,
 }
 
+/// Tiemout callback function.
+///
+/// The callback function is called with CPU Lock active and an interrupt
+/// context when the associated [`Timeout`] expires.
+///
+/// The callback function may wake up tasks. When it does that, it doesn't have
+/// to call `unlock_cpu_and_check_preemption` or `yield_cpu` - it's
+/// automatically taken care of.
 pub(super) type TimeoutFn<System> = fn(usize, CpuLockGuard<System>) -> CpuLockGuard<System>;
 
 /// Value of [`Timeout::heap_pos`] indicating the timeout is not included in the
@@ -716,6 +725,10 @@ pub(super) fn handle_tick<System: Kernel>() {
 
     // Schedule the next tick
     pend_next_tick(lock.borrow_mut(), current_time);
+
+    // Callback functions might have woken up some tasks. Check for dispatch and
+    // release CPU Lock.
+    task::unlock_cpu_and_check_preemption(lock);
 }
 
 /// Get the current event time.