update ch03

Author: Leakbox258

os/src/syscall/mod.rs

@@ -11,24 +11,28 @@
 //! submodules, and you should also implement syscalls this way.
 
 /// write syscall
-const SYSCALL_WRITE: usize = 64;
+pub const SYSCALL_WRITE: usize = 64;
 /// exit syscall
-const SYSCALL_EXIT: usize = 93;
+pub const SYSCALL_EXIT: usize = 93;
 /// yield syscall
-const SYSCALL_YIELD: usize = 124;
+pub const SYSCALL_YIELD: usize = 124;
 /// gettime syscall
-const SYSCALL_GET_TIME: usize = 169;
+pub const SYSCALL_GET_TIME: usize = 169;
 /// trace syscall
-const SYSCALL_TRACE: usize = 410;
+pub const SYSCALL_TRACE: usize = 410;
 
 mod fs;
 mod process;
 
+use crate::task::inc_current_syscall_times;
 use fs::*;
 use process::*;
 
 /// handle syscall exception with `syscall_id` and other arguments
 pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
+    // inc the syscall_time of current app (valid only)
+    inc_current_syscall_times(syscall_id);
+
     match syscall_id {
         SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
         SYSCALL_EXIT => sys_exit(args[0] as i32),

os/src/syscall/process.rs

@@ -1,6 +1,6 @@
 //! Process management syscalls
 use crate::{
-    task::{exit_current_and_run_next, suspend_current_and_run_next},
+    task::{exit_current_and_run_next, query_current_syscall_times, suspend_current_and_run_next},
     timer::get_time_us,
 };
 
@@ -39,7 +39,27 @@ pub fn sys_get_time(ts: *mut TimeVal, _tz: usize) -> isize {
 }
 
 // TODO: implement the syscall
-pub fn sys_trace(_trace_request: usize, _id: usize, _data: usize) -> isize {
-    trace!("kernel: sys_trace");
-    -1
+
+const READ_DATA: usize = 0;
+const WRITE_DATA: usize = 1;
+const QUERY_SYSCALL_TIME: usize = 2;
+
+pub fn sys_trace(trace_request: usize, id: usize, data: usize) -> isize {
+    match trace_request {
+        READ_DATA => {
+            let ptr = id as *const u8;
+
+            unsafe { *ptr as isize }
+        }
+        WRITE_DATA => {
+            let ptr = id as *mut u8;
+
+            unsafe { *ptr = data as u8 }
+
+            0
+        }
+        QUERY_SYSCALL_TIME => query_current_syscall_times(id) as isize,
+        _ => -1,
+        // _ => panic!("Unsupport trace_request for sys_trace"),
+    }
 }

os/src/task/mod.rs

@@ -17,6 +17,7 @@ mod task;
 use crate::config::MAX_APP_NUM;
 use crate::loader::{get_num_app, init_app_cx};
 use crate::sync::UPSafeCell;
+use crate::syscall::{SYSCALL_EXIT, SYSCALL_GET_TIME, SYSCALL_TRACE, SYSCALL_WRITE, SYSCALL_YIELD};
 use lazy_static::*;
 use switch::__switch;
 pub use task::{TaskControlBlock, TaskStatus};
@@ -51,10 +52,7 @@ lazy_static! {
     /// Global variable: TASK_MANAGER
     pub static ref TASK_MANAGER: TaskManager = {
         let num_app = get_num_app();
-        let mut tasks = [TaskControlBlock {
-            task_cx: TaskContext::zero_init(),
-            task_status: TaskStatus::UnInit,
-        }; MAX_APP_NUM];
+        let mut tasks = [TaskControlBlock::new(); MAX_APP_NUM];
         for (i, task) in tasks.iter_mut().enumerate() {
             task.task_cx = TaskContext::goto_restore(init_app_cx(i));
             task.task_status = TaskStatus::Ready;
@@ -169,3 +167,37 @@ pub fn exit_current_and_run_next() {
     mark_current_exited();
     run_next_task();
 }
+
+/// Modified: to inc syscall_time in the TCB of current task
+
+pub fn inc_current_syscall_times(syscall_id: usize) {
+    let mut inner = TASK_MANAGER.inner.exclusive_access();
+    let current_app_id = inner.current_task;
+    let current_tcb = inner.tasks.get_mut(current_app_id).unwrap();
+
+    match syscall_id {
+        SYSCALL_WRITE => current_tcb.sys_write_times += 1,
+        SYSCALL_EXIT => current_tcb.sys_exit_times += 1,
+        SYSCALL_YIELD => current_tcb.sys_yield_times += 1,
+        SYSCALL_GET_TIME => current_tcb.sys_get_time_times += 1,
+        SYSCALL_TRACE => current_tcb.sys_trace_times += 1,
+        _ => panic!("Unsupported syscall_id: {}", syscall_id),
+    }
+}
+
+/// Modified: to query syscall_time in the TCB of current task
+
+pub fn query_current_syscall_times(syscall_id: usize) -> usize {
+    let inner = TASK_MANAGER.inner.exclusive_access();
+    let current_app_id = inner.current_task;
+    let current_tcb = inner.tasks.get(current_app_id).unwrap();
+
+    match syscall_id {
+        SYSCALL_WRITE => current_tcb.sys_write_times,
+        SYSCALL_EXIT => current_tcb.sys_exit_times,
+        SYSCALL_YIELD => current_tcb.sys_yield_times,
+        SYSCALL_GET_TIME => current_tcb.sys_get_time_times,
+        SYSCALL_TRACE => current_tcb.sys_trace_times,
+        _ => panic!("Unsupported syscall_id: {}", syscall_id),
+    }
+}

os/src/task/task.rs

@@ -9,6 +9,31 @@ pub struct TaskControlBlock {
     pub task_status: TaskStatus,
     /// The task context
     pub task_cx: TaskContext,
+    /// sys_write times
+    pub sys_write_times: usize,
+    /// sys_exit times
+    pub sys_exit_times: usize,
+    /// sys_yield times
+    pub sys_yield_times: usize,
+    /// sys get_time times
+    pub sys_get_time_times: usize,
+    /// sys trace times
+    pub sys_trace_times: usize,
+}
+
+impl TaskControlBlock {
+    /// quick init of TCB
+    pub fn new() -> TaskControlBlock {
+        TaskControlBlock {
+            task_cx: TaskContext::zero_init(),
+            task_status: TaskStatus::UnInit,
+            sys_write_times: 0,
+            sys_exit_times: 0,
+            sys_yield_times: 0,
+            sys_get_time_times: 0,
+            sys_trace_times: 0,
+        }
+    }
 }
 
 /// The status of a task