ch3 ok

Author: afox666

os/src/syscall/mod.rs

@@ -11,24 +11,26 @@
 //! 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 fs::*;
 use process::*;
+use crate::task::add_syscall_counter;
 
 /// handle syscall exception with `syscall_id` and other arguments
 pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
+    add_syscall_counter(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, suspend_current_and_run_next, get_syscall_counter},
     timer::get_time_us,
 };
 
@@ -41,5 +41,18 @@ 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
+    // 向claude3.7请教了通过裸指针操作内存的方法
+    match _trace_request {
+        0 => {
+            let ptr : *const u8 = _id as *const u8; 
+            unsafe { (*ptr).into() }
+        },
+        1 => {
+            let ptr : *mut u8 = _id as *mut u8; 
+            unsafe { *ptr = _data as u8 ; };
+            0
+        },
+        2 => get_syscall_counter(_id),
+        _ => -1
+    }
 }

os/src/task/mod.rs

@@ -22,6 +22,7 @@ use switch::__switch;
 pub use task::{TaskControlBlock, TaskStatus};
 
 pub use context::TaskContext;
+use crate::syscall::{SYSCALL_EXIT, SYSCALL_GET_TIME, SYSCALL_TRACE, SYSCALL_WRITE, SYSCALL_YIELD};
 
 /// The task manager, where all the tasks are managed.
 ///
@@ -44,6 +45,11 @@ pub struct TaskManagerInner {
     /// task list
     tasks: [TaskControlBlock; MAX_APP_NUM],
     /// id of current `Running` task
+    syscall_write_counter: [usize; MAX_APP_NUM],
+    syscall_exit_counter: [usize; MAX_APP_NUM],
+    syscall_yield_counter: [usize; MAX_APP_NUM],
+    syscall_get_time_counter: [usize; MAX_APP_NUM],
+    syscall_trace_counter: [usize; MAX_APP_NUM],
     current_task: usize,
 }
 
@@ -64,6 +70,11 @@ lazy_static! {
             inner: unsafe {
                 UPSafeCell::new(TaskManagerInner {
                     tasks,
+                    syscall_write_counter: [0; MAX_APP_NUM],
+                    syscall_exit_counter: [0; MAX_APP_NUM],
+                    syscall_yield_counter: [0; MAX_APP_NUM],
+                    syscall_get_time_counter: [0; MAX_APP_NUM],
+                    syscall_trace_counter: [0; MAX_APP_NUM],
                     current_task: 0,
                 })
             },
@@ -135,6 +146,32 @@ impl TaskManager {
             panic!("All applications completed!");
         }
     }
+
+    fn add_syscall_counter(&self, syscall_id: usize) {
+        let mut inner = self.inner.exclusive_access();
+        let current = inner.current_task;
+        match syscall_id {
+            SYSCALL_WRITE => inner.syscall_write_counter[current] += 1,
+            SYSCALL_EXIT => inner.syscall_exit_counter[current] += 1,
+            SYSCALL_YIELD => inner.syscall_yield_counter[current] += 1,
+            SYSCALL_GET_TIME => inner.syscall_get_time_counter[current] += 1,
+            SYSCALL_TRACE => inner.syscall_trace_counter[current] += 1,
+            _ => panic!("Unsupported syscall_id: {}", syscall_id),
+        }
+    }
+
+    fn get_syscall_counter(&self, syscall_id: usize) -> usize {
+        let inner = self.inner.exclusive_access();
+        let current = inner.current_task;
+        match syscall_id {
+            SYSCALL_WRITE => inner.syscall_write_counter[current],
+            SYSCALL_EXIT => inner.syscall_exit_counter[current],
+            SYSCALL_YIELD => inner.syscall_yield_counter[current],
+            SYSCALL_GET_TIME => inner.syscall_get_time_counter[current],
+            SYSCALL_TRACE => inner.syscall_trace_counter[current],
+            _ => panic!("Unsupported syscall_id: {}", syscall_id),
+        }
+    }
 }
 
 /// Run the first task in task list.
@@ -169,3 +206,13 @@ pub fn exit_current_and_run_next() {
     mark_current_exited();
     run_next_task();
 }
+
+/// Add the current 'Running' task's syscall counter by syscall_id.
+pub fn add_syscall_counter(syscall_id: usize) {
+    TASK_MANAGER.add_syscall_counter(syscall_id);
+}
+
+/// Get the current 'Running' task's syscall counter by syscall_id.
+pub fn get_syscall_counter(syscall_id: usize) -> isize {
+    TASK_MANAGER.get_syscall_counter(syscall_id).try_into().unwrap()
+}

reports/lab1.md

@@ -0,0 +1,65 @@
+### 总结实现的功能
+为`sys_trace`实现了三个功能：
+1. 根据传入的参数(_id)读取对应内存地址的值并返回
+2. 根据传入的参数(_id, _data)向对应地址写入值
+3. 获取传入的参数(_id)对应的系统调用执行的次数
+
+为了实现第3个功能，我修改了`TaskManagerInner`结构体，向里面添加了对应不同系统调用的计数器，用于统计不同系统调用的执行次数。并且，提供了两个函数`add_syscall_counter`和`get_syscall_counter`用于修改和查询系统调用的执行次数。
+
+### 问答题
+#### 1. 正确进入 U 态后，程序的特征还应有：使用 S 态特权指令，访问 S 态寄存器后会报错。 请同学们可以自行测试这些内容（运行 三个 bad 测例 (ch2b_bad_*.rs) ）， 描述程序出错行为，同时注意注明你使用的 sbi 及其版本。
+
+使用RustSBI，版本号：version 0.4.0-alpha.1
+
+- ch2b_bad_address.rs: OS首先输出`PageFault`异常，这表明程序尝试请求非法的内存地址，OS提示该地址`bad addr = 0x0`,且该错误的指令存储在这个位置：`bad instruction = 0x804003a4`。
+
+如果同时运行三个bad测例，则后两个测例的输出为：`IllegalInstruction in application, kernel killed it.`。  
+
+我尝试单独运行后两个测例后，可得到以下输出：
+- ch2b_bad_instructions.rs: OS会输出`InstructionFault`非法指令异常，此时`stval = 0x0`。
+- ch2b_bad_register.rs: 此测例会在进行系统调用时提示不支持的trap异常，`scause`的输出信息为`LoadFault`，`stval = 0x10`，这表明程序在U模式尝试访问了S模式的寄存器，导致程序出错。
+
+#### 2.深入理解 trap.S 中两个函数 __alltraps 和 __restore 的作用，并回答如下问题:
+1. L40：刚进入 __restore 时，sp 代表了什么值。请指出 __restore 的两种使用情景。
+    - sp指向了内核栈的TrapContext结构体的起始位置，也就是内核态的栈指针
+    - 使用场景：
+        - 在任务上下文切换中，__restore会成为__switch返回后继续执行的函数
+        - Trap处理后的返回
+
+2. L43-L48：这几行汇编代码特殊处理了哪些寄存器？这些寄存器的的值对于进入用户态有何意义？请分别解释。
+分别处理了以下寄存器：
+    - sstatus: 记录和控制当前特权级别以及在异常发生前的特权级别，同时还能够恢复用户程序的中断使能状态。
+    - sepc: 将内核TrapContext的pc值保存，在后面执行`sret`指令从S态返回时，pc寄存器将从sepc寄存器中读取该值。
+    - sscratch: 在特权级切换的过程中，sscratch和sp寄存器会互相交换值，从而保存用户态或者内核态的栈指针
+
+3. L50-L56：为何跳过了 x2 和 x4？
+    - x2 寄存器就是 sp寄存器，我们通过 csrrw 指令将sp寄存器和sscratch寄存器的值进行交换保存了
+    - x4 寄存器是 tp寄存器，用于支持线程局部存储，这个寄存器只有在某些特殊用途的情况下会用到。
+
+4. L60：该指令之后，sp 和 sscratch 中的值分别有什么意义？
+    - sp: 存储的是用户态的栈指针
+    - sscratch: 暂存了内核态的栈指针
+
+5. __restore：中发生状态切换在哪一条指令？为何该指令执行之后会进入用户态？
+    - 状态切换发生在`sret`指令
+    - `sret`指令会将特权级别切换到`sstatus.SPP`指定的特权级别。从用户态进入内核态时，硬件会自动将`sstatus.SPP`设置为0，表示之前是用户态。所以执行`sret`后会进入用户态。并且，在执行`sret`之前，我们已经正确设置了sepc和sstatus寄存器，从而使得进入用户态后，程序能够跳转到正确的地址执行。
+
+6. L13：该指令之后，sp 和 sscratch 中的值分别有什么意义？
+    - sp: 指向了内核栈的TrapContext结构体的起始位置，也就是内核态的栈指针
+    - sscratch: 暂存了用户态TrapContext结构体的起始位置，也就是用户态的栈指针
+
+7. 从 U 态进入 S 态是哪一条指令发生的？
+    `ecall`
+
+### 荣誉准则
+1. 在完成本次实验的过程（含此前学习的过程）中，我曾分别与 以下各位 就（与本次实验相关的）以下方面做过交流，还在代码中对应的位置以注释形式记录了具体的交流对象及内容：
+
+    向claude3.7老师请教了许多问题，感谢它的帮助
+
+2. 此外，我也参考了 以下资料 ，还在代码中对应的位置以注释形式记录了具体的参考来源及内容：
+
+    参考了 https://cheats.rs/ 手册的一些语法细节。
+
+3. 我独立完成了本次实验除以上方面之外的所有工作，包括代码与文档。 我清楚地知道，从以上方面获得的信息在一定程度上降低了实验难度，可能会影响起评分。
+
+4. 我从未使用过他人的代码，不管是原封不动地复制，还是经过了某些等价转换。 我未曾也不会向他人（含此后各届同学）复制或公开我的实验代码，我有义务妥善保管好它们。 我提交至本实验的评测系统的代码，均无意于破坏或妨碍任何计算机系统的正常运转。 我清楚地知道，以上情况均为本课程纪律所禁止，若违反，对应的实验成绩将按“-100”分计。