use Rawlist for wait queue

Signed-off-by: guoweikang <[email protected]>

modules/axtask/Cargo.toml

@@ -50,7 +50,8 @@ kernel_guard = { version = "0.1", optional = true }
 crate_interface = { version = "0.1", optional = true }
 cpumask = { version = "0.1", optional = true }
 scheduler = { git = "https://github.com/arceos-org/scheduler.git", tag = "v0.2.0", optional = true }
-linked_list_r4l = { version = "0.2.0" , optional = true }
+linked_list_r4l = { git = "https://github.com/arceos-org/linked_list_r4l.git", branch ="guoweikang/add_push_front", optional = true}
+#linked_list_r4l = { version = "0.2.0" , optional = true }
 
 [dev-dependencies]
 rand = "0.8"

modules/axtask/src/run_queue.rs

@@ -367,11 +367,7 @@ impl<'a, G: BaseGuard> CurrentRunQueueRef<'a, G> {
     ///     2. The caller must ensure that the current task is in the running state.
     ///     3. The caller must ensure that the current task is not the idle task.
     ///     4. The lock of the wait queue will be released explicitly after current task is pushed into it.
-    pub fn blocked_resched(
-        &mut self,
-        mut wq_guard: WaitQueueGuard,
-        curr_waiter: Arc<WaitTaskNode>,
-    ) {
+    pub fn blocked_resched(&mut self, mut wq_guard: WaitQueueGuard, curr_waiter: &WaitTaskNode) {
         let curr = &self.current_task;
         assert!(curr.is_running());
         assert!(!curr.is_idle());
@@ -384,7 +380,11 @@ impl<'a, G: BaseGuard> CurrentRunQueueRef<'a, G> {
         // Mark the task as blocked, this has to be done before adding it to the wait queue
         // while holding the lock of the wait queue.
         curr.set_state(TaskState::Blocked);
-        wq_guard.push_back(curr_waiter);
+        // SAFETY: The waiter was on caller stack, the lifetime ends
+        // only when the task resumes running.
+        unsafe {
+            assert!(wq_guard.push_back(curr_waiter));
+        }
         // Drop the lock of wait queue explictly.
         drop(wq_guard);
 

modules/axtask/src/wait_queue.rs

@@ -2,7 +2,7 @@ use alloc::sync::Arc;
 
 use kernel_guard::{NoOp, NoPreemptIrqSave};
 use kspin::{SpinNoIrq, SpinNoIrqGuard};
-use linked_list_r4l::{def_node, List};
+use linked_list_r4l::{def_node, RawList};
 
 use crate::{current_run_queue, select_run_queue, AxTaskRef};
 
@@ -19,8 +19,6 @@ impl WaitTaskNode {
     }
 }
 
-type Node = Arc<WaitTaskNode>;
-
 /// A queue to store sleeping tasks.
 ///
 /// # Examples
@@ -44,22 +42,22 @@ type Node = Arc<WaitTaskNode>;
 /// assert_eq!(VALUE.load(Ordering::Relaxed), 1);
 /// ```
 pub struct WaitQueue {
-    list: SpinNoIrq<List<Node>>,
+    list: SpinNoIrq<RawList<WaitTaskNode>>,
 }
 
-pub(crate) type WaitQueueGuard<'a> = SpinNoIrqGuard<'a, List<Node>>;
+pub(crate) type WaitQueueGuard<'a> = SpinNoIrqGuard<'a, RawList<WaitTaskNode>>;
 
 impl WaitQueue {
     /// Creates an empty wait queue.
     pub const fn new() -> Self {
         Self {
-            list: SpinNoIrq::new(List::new()),
+            list: SpinNoIrq::new(RawList::new()),
         }
     }
 
     /// Cancel events by removing the task from the wait queue.
     /// If `from_timer_list` is true, try to remove the task from the timer list.
-    fn cancel_events(&self, waiter: Node, _from_timer_list: bool) {
+    fn cancel_events(&self, waiter: WaitTaskNode, _from_timer_list: bool) {
         // SAFETY:
         // Waiter is only  defined in the local function scope,
         // therefore, it is not possible in other List.
@@ -71,10 +69,7 @@ impl WaitQueue {
         // Just mark task's current timer ticket ID as expired.
         #[cfg(feature = "irq")]
         if _from_timer_list {
-            Arc::<WaitTaskNode>::into_inner(waiter)
-                .expect("into_inner")
-                .into_inner()
-                .timer_ticket_expired();
+            waiter.into_inner().timer_ticket_expired();
             // Note:
             //  this task is still not removed from timer list of target CPU,
             //  which may cause some redundant timer events because it still needs to
@@ -86,8 +81,8 @@ impl WaitQueue {
     /// Blocks the current task and put it into the wait queue, until other task
     /// notifies it.
     pub fn wait(&self) {
-        let waiter = Arc::new(WaitTaskNode::from_current());
-        current_run_queue::<NoPreemptIrqSave>().blocked_resched(self.list.lock(), waiter.clone());
+        let waiter = WaitTaskNode::from_current();
+        current_run_queue::<NoPreemptIrqSave>().blocked_resched(self.list.lock(), &waiter);
         self.cancel_events(waiter, false);
     }
 
@@ -100,14 +95,14 @@ impl WaitQueue {
     where
         F: Fn() -> bool,
     {
-        let waiter = Arc::new(WaitTaskNode::from_current());
+        let waiter = WaitTaskNode::from_current();
         loop {
             let mut rq = current_run_queue::<NoPreemptIrqSave>();
             let wq = self.list.lock();
             if condition() {
                 break;
             }
-            rq.blocked_resched(wq, waiter.clone());
+            rq.blocked_resched(wq, &waiter);
             // Preemption may occur here.
         }
 
@@ -118,7 +113,7 @@ impl WaitQueue {
     /// notify it, or the given duration has elapsed.
     #[cfg(feature = "irq")]
     pub fn wait_timeout(&self, dur: core::time::Duration) -> bool {
-        let waiter = Arc::new(WaitTaskNode::from_current());
+        let waiter = WaitTaskNode::from_current();
         let mut rq = current_run_queue::<NoPreemptIrqSave>();
         let curr = crate::current();
         let deadline = axhal::time::wall_time() + dur;
@@ -129,7 +124,7 @@ impl WaitQueue {
         );
         crate::timers::set_alarm_wakeup(deadline, curr.clone());
 
-        rq.blocked_resched(self.list.lock(), waiter.clone());
+        rq.blocked_resched(self.list.lock(), &waiter);
 
         let timeout = axhal::time::wall_time() >= deadline;
 
@@ -148,7 +143,7 @@ impl WaitQueue {
     where
         F: Fn() -> bool,
     {
-        let waiter = Arc::new(WaitTaskNode::from_current());
+        let waiter = WaitTaskNode::from_current();
         let curr = crate::current();
         let deadline = axhal::time::wall_time() + dur;
         debug!(
@@ -169,7 +164,7 @@ impl WaitQueue {
                 timeout = false;
                 break;
             }
-            rq.blocked_resched(wq, waiter.clone());
+            rq.blocked_resched(wq, &waiter);
             // Preemption may occur here.
         }
 
@@ -185,7 +180,9 @@ impl WaitQueue {
     pub fn notify_one(&self, resched: bool) -> bool {
         let mut wq = self.list.lock();
         if let Some(waiter) = wq.pop_front() {
-            unblock_one_task(waiter.inner().clone(), resched);
+            // SAFETY: waiter NonNull<T> is valid created by block
+            let waiter_ref = unsafe { waiter.as_ref() };
+            unblock_one_task(waiter_ref.inner().clone(), resched);
             true
         } else {
             false