Implement many process syscalls.

os/src/task/processor.rs

@@ -2,7 +2,7 @@ use super::TaskControlBlock;
 use alloc::sync::Arc;
 use spin::Mutex;
 use lazy_static::*;
-use super::{add_task, fetch_task};
+use super::{fetch_task, TaskStatus};
 use super::__switch;
 use crate::trap::TrapContext;
 
@@ -13,7 +13,7 @@ pub struct Processor {
 unsafe impl Sync for Processor {}
 
 struct ProcessorInner {
-    current: Option<Arc<Mutex<TaskControlBlock>>>,
+    current: Option<Arc<TaskControlBlock>>,
     idle_task_cx_ptr: usize,
 }
 
@@ -31,13 +31,13 @@ impl Processor {
         &inner.idle_task_cx_ptr as *const usize
     }
     pub fn run(&self) {
-        //println!("into Processor::run");
         loop {
             if let Some(task) = fetch_task() {
-                //println!("found task!");
                 let idle_task_cx_ptr = self.get_idle_task_cx_ptr2();
-                let next_task_cx_ptr = task.lock().get_task_cx_ptr2();
-                //println!("next_task_cx_ptr={:p}", next_task_cx_ptr);
+                // acquire
+                let next_task_cx_ptr = task.acquire_inner_lock().get_task_cx_ptr2();
+                task.acquire_inner_lock().task_status = TaskStatus::Running;
+                // release
                 self.inner.lock().current = Some(task);
                 unsafe {
                     __switch(
@@ -48,10 +48,10 @@ impl Processor {
             }
         }
     }
-    pub fn take_current(&self) -> Option<Arc<Mutex<TaskControlBlock>>> {
+    pub fn take_current(&self) -> Option<Arc<TaskControlBlock>> {
         self.inner.lock().current.take()
     }
-    pub fn current(&self) -> Option<Arc<Mutex<TaskControlBlock>>> {
+    pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
         self.inner.lock().current.as_ref().map(|task| task.clone())
     }
 }
@@ -64,25 +64,22 @@ pub fn run_tasks() {
     PROCESSOR.run();
 }
 
-pub fn take_current_task() -> Option<Arc<Mutex<TaskControlBlock>>> {
+pub fn take_current_task() -> Option<Arc<TaskControlBlock>> {
     PROCESSOR.take_current()
 }
 
-pub fn current_task() -> Option<Arc<Mutex<TaskControlBlock>>> {
-    //println!("into current_task!");
+pub fn current_task() -> Option<Arc<TaskControlBlock>> {
     PROCESSOR.current()
 }
 
 pub fn current_user_token() -> usize {
-    //println!("into current_user_token!");
     let task = current_task().unwrap();
-    //println!("Got task in current_user_token!");
-    let token = task.lock().get_user_token();
+    let token = task.acquire_inner_lock().get_user_token();
     token
 }
 
 pub fn current_trap_cx() -> &'static mut TrapContext {
-    current_task().unwrap().as_ref().lock().get_trap_cx()
+    current_task().unwrap().acquire_inner_lock().get_trap_cx()
 }
 
 pub fn schedule(switched_task_cx_ptr2: *const usize) {