Rm spin::Mutex except for easy-fs & add new test huge_write & flush cache to disk after a write transaction

os/src/task/processor.rs

@@ -1,95 +1,90 @@
-use super::TaskControlBlock;
+use super::{TaskContext, TaskControlBlock};
 use alloc::sync::Arc;
-use core::cell::RefCell;
 use lazy_static::*;
 use super::{fetch_task, TaskStatus};
 use super::__switch;
 use crate::trap::TrapContext;
+use crate::sync::UPSafeCell;
 
 pub struct Processor {
-    inner: RefCell<ProcessorInner>,
-}
-
-unsafe impl Sync for Processor {}
-
-struct ProcessorInner {
     current: Option<Arc<TaskControlBlock>>,
-    idle_task_cx_ptr: usize,
+    idle_task_cx: TaskContext,
 }
 
 impl Processor {
     pub fn new() -> Self {
         Self {
-            inner: RefCell::new(ProcessorInner {
-                current: None,
-                idle_task_cx_ptr: 0,
-            }),
+            current: None,
+            idle_task_cx: TaskContext::zero_init(),
         }
     }
-    fn get_idle_task_cx_ptr2(&self) -> *const usize {
-        let inner = self.inner.borrow();
-        &inner.idle_task_cx_ptr as *const usize
+    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext {
+        &mut self.idle_task_cx as *mut _
     }
-    pub fn run(&self) {
-        loop {
-            if let Some(task) = fetch_task() {
-                let idle_task_cx_ptr2 = self.get_idle_task_cx_ptr2();
-                // acquire
-                let mut task_inner = task.acquire_inner_lock();
-                let next_task_cx_ptr2 = task_inner.get_task_cx_ptr2();
-                task_inner.task_status = TaskStatus::Running;
-                drop(task_inner);
-                // release
-                self.inner.borrow_mut().current = Some(task);
-                unsafe {
-                    __switch(
-                        idle_task_cx_ptr2,
-                        next_task_cx_ptr2,
-                    );
-                }
-            }
-        }
-    }
-    pub fn take_current(&self) -> Option<Arc<TaskControlBlock>> {
-        self.inner.borrow_mut().current.take()
+    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>> {
+        self.current.take()
     }
     pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
-        self.inner.borrow().current.as_ref().map(|task| Arc::clone(task))
+        self.current.as_ref().map(|task| Arc::clone(task))
     }
 }
 
 lazy_static! {
-    pub static ref PROCESSOR: Processor = Processor::new();
+    pub static ref PROCESSOR: UPSafeCell<Processor> = unsafe {
+        UPSafeCell::new(Processor::new())
+    };
 }
 
 pub fn run_tasks() {
-    PROCESSOR.run();
+    loop {
+        let mut processor = PROCESSOR.exclusive_access();
+        if let Some(task) = fetch_task() {
+            let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
+            // access coming task TCB exclusively
+            let mut task_inner = task.inner_exclusive_access();
+            let next_task_cx_ptr = &task_inner.task_cx as *const TaskContext;
+            task_inner.task_status = TaskStatus::Running;
+            drop(task_inner);
+            // release coming task TCB manually
+            processor.current = Some(task);
+            // release processor manually
+            drop(processor);
+            unsafe {
+                __switch(
+                    idle_task_cx_ptr,
+                    next_task_cx_ptr,
+                );
+            }
+        }
+    }
 }
 
 pub fn take_current_task() -> Option<Arc<TaskControlBlock>> {
-    PROCESSOR.take_current()
+    PROCESSOR.exclusive_access().take_current()
 }
 
 pub fn current_task() -> Option<Arc<TaskControlBlock>> {
-    PROCESSOR.current()
+    PROCESSOR.exclusive_access().current()
 }
 
 pub fn current_user_token() -> usize {
     let task = current_task().unwrap();
-    let token = task.acquire_inner_lock().get_user_token();
+    let token = task.inner_exclusive_access().get_user_token();
     token
 }
 
 pub fn current_trap_cx() -> &'static mut TrapContext {
-    current_task().unwrap().acquire_inner_lock().get_trap_cx()
+    current_task().unwrap().inner_exclusive_access().get_trap_cx()
 }
 
-pub fn schedule(switched_task_cx_ptr2: *const usize) {
-    let idle_task_cx_ptr2 = PROCESSOR.get_idle_task_cx_ptr2();
+pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
+    let mut processor = PROCESSOR.exclusive_access();
+    let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
+    drop(processor);
     unsafe {
         __switch(
-            switched_task_cx_ptr2,
-            idle_task_cx_ptr2,
+            switched_task_cx_ptr,
+            idle_task_cx_ptr,
         );
     }
 }