ch4 ok

afox666 · afox666 · commit 1380c098a04d · 2025-04-27T19:34:46.000+08:00
diff --git a/os/src/mm/memory_set.rs b/os/src/mm/memory_set.rs
@@ -262,6 +262,40 @@ impl MemorySet {
             false
         }
     }
+
+    /// find target area by start_va, then insert it to areas
+    pub fn find_area_insert(&mut self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) -> bool {
+        if let Some(_area) = self.areas.iter().find(|area| {
+            debug!("=============== insert ===============");
+            debug!("area start: {}, end: {}", area.vpn_range.get_start().0, area.vpn_range.get_end().0);
+            debug!("target area start: {}, end: {}", start_va.floor().0, end_va.ceil().0);
+            debug!("======================================");
+            area.vpn_range.get_start() < end_va.ceil() && area.vpn_range.get_end() > start_va.floor()
+        }) {
+            debug!("!!! find area has been used !!!");
+            false
+        } else {
+            debug!("!!! area not be used, insert it!!!");
+            self.insert_framed_area(start_va, end_va, permission);
+            true
+        }
+    }
+    /// find target area by start_va, then remove it from areas
+    pub fn find_area_remove(&mut self, start_va: VirtAddr, end_va: VirtAddr) -> bool {
+        if let Some(index) = self.areas.iter().position(|area| {
+            debug!("=============== remove ===============");
+            debug!("area start: {}, end: {}", area.vpn_range.get_start().0, area.vpn_range.get_end().0);
+            debug!("target area start: {}, end: {}", start_va.floor().0, end_va.ceil().0);
+            debug!("======================================");
+            area.vpn_range.get_start() == start_va.floor() && area.vpn_range.get_end() == end_va.ceil()
+        }) {
+            self.areas[index].unmap(&mut self.page_table);
+            self.areas.remove(index);
+            true
+        } else {
+            false
+        }
+    }
 }
 /// map area structure, controls a contiguous piece of virtual memory
 pub struct MapArea {
diff --git a/os/src/mm/mod.rs b/os/src/mm/mod.rs
@@ -17,7 +17,7 @@ use address::{StepByOne, VPNRange};
 pub use frame_allocator::{frame_alloc, FrameTracker};
 pub use memory_set::remap_test;
 pub use memory_set::{kernel_stack_position, MapPermission, MemorySet, KERNEL_SPACE};
-pub use page_table::{translated_byte_buffer, PageTableEntry};
+pub use page_table::{translated_byte_buffer, translated_physaddr, PageTableEntry};
 pub use page_table::{PTEFlags, PageTable};
 
 /// initiate heap allocator, frame allocator and kernel space
diff --git a/os/src/mm/page_table.rs b/os/src/mm/page_table.rs
@@ -1,6 +1,6 @@
 //! Implementation of [`PageTableEntry`] and [`PageTable`].
 
-use super::{frame_alloc, FrameTracker, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
+use super::{frame_alloc, FrameTracker, PhysAddr, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
 use alloc::vec;
 use alloc::vec::Vec;
 use bitflags::*;
@@ -179,3 +179,16 @@ pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&
     }
     v
 }
+
+/// translate a ptr and return its mut
+pub fn translated_physaddr(token: usize, ptr: *const u8) -> PhysAddr {
+    let page_table = PageTable::from_token(token);
+    let va = VirtAddr::from(ptr as usize);
+    let vpn = va.floor();
+    let ppn: PhysPageNum = page_table.translate(vpn).unwrap().ppn();
+    let pa: PhysAddr = ppn.into();
+
+    let offset = va.page_offset();
+    let pa_offset = (pa.0 + offset).into();
+    return pa_offset;
+}
diff --git a/os/src/syscall/mod.rs b/os/src/syscall/mod.rs
@@ -31,8 +31,11 @@ mod process;
 use fs::*;
 use process::*;
 
+use crate::task::TASK_MANAGER;
+
 /// handle syscall exception with `syscall_id` and other arguments
 pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
+    TASK_MANAGER.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),
diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs
@@ -1,5 +1,5 @@
 //! Process management syscalls
-use crate::task::{change_program_brk, exit_current_and_run_next, suspend_current_and_run_next};
+use crate::{mm::{translated_physaddr, MapPermission, PTEFlags, PageTable, VirtAddr}, task::{change_program_brk, current_user_token, exit_current_and_run_next, suspend_current_and_run_next, TASK_MANAGER}, timer::get_time_us};
 
 #[repr(C)]
 #[derive(Debug)]
@@ -27,26 +27,126 @@ pub fn sys_yield() -> isize {
 /// HINT: What if [`TimeVal`] is splitted by two pages ?
 pub fn sys_get_time(_ts: *mut TimeVal, _tz: usize) -> isize {
     trace!("kernel: sys_get_time");
-    -1
+    let pa = translated_physaddr(current_user_token(), _ts as *const u8);
+    let phy_ts = pa.0 as *mut TimeVal;
+
+    let us = get_time_us();
+    let time_val = TimeVal {
+        sec : us / 1_000_000,
+        usec: us % 1_000_000,
+    };
+
+    unsafe { *phy_ts = time_val };
+    0
+}
+
+fn is_readable(va: usize) -> bool {
+    let vpn = VirtAddr::from(va).floor();
+    if let Some(pte) = PageTable::from_token(current_user_token()).translate(vpn) {
+        pte.flags().contains(PTEFlags::U | PTEFlags::R)
+    } else {
+        false
+    }
+}
+
+fn is_writeable(va: usize) -> bool {
+    let vpn = VirtAddr::from(va).floor();
+    if let Some(pte) = PageTable::from_token(current_user_token()).translate(vpn) {
+        pte.flags().contains(PTEFlags::U | PTEFlags::W)
+    } else {
+        false
+    }
 }
 
 /// TODO: Finish sys_trace to pass testcases
 /// HINT: You might reimplement it with virtual memory management.
 pub fn sys_trace(_trace_request: usize, _id: usize, _data: usize) -> isize {
     trace!("kernel: sys_trace");
-    -1
+    match _trace_request {
+        0 => {
+            if !is_readable(_id) {
+                return -1;
+            }
+            let pa = translated_physaddr(current_user_token(), _id as *const u8);
+            let phy_data = pa.0 as *mut u8;
+            unsafe { (*phy_data).into() }
+        },
+        1 => {
+            if !is_writeable(_id) {
+                return -1;
+            }
+            let pa = translated_physaddr(current_user_token(), _id as *const u8);
+            let phy_data = pa.0 as *mut u8; 
+            unsafe { *phy_data = _data as u8 ; };
+            return 0;
+        },
+        2 => TASK_MANAGER.get_syscall_counter(_id).try_into().unwrap(),
+        _ => -1
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct Flag(pub usize);
+
+impl Flag {
+    pub fn is_readable(&self) -> bool {
+        self.0 & 0x1 == 0x1
+    }
+
+    pub fn is_writeable(&self) -> bool {
+        self.0 & 0x2 == 0x2
+    }
+
+    pub fn is_execute(&self) -> bool {
+        self.0 & 0x4 == 0x4
+    }
 }
 
 // YOUR JOB: Implement mmap.
 pub fn sys_mmap(_start: usize, _len: usize, _port: usize) -> isize {
-    trace!("kernel: sys_mmap NOT IMPLEMENTED YET!");
-    -1
+    trace!("kernel: sys_mmap ");
+
+    debug!("mmap start: {}, len: {}, port: {}", _start, _len, _port);
+
+    let start_va = VirtAddr::from(_start);
+    if !start_va.aligned() {
+        return -1;
+    }
+    let end_va: VirtAddr = (_start + _len).into();
+    if _port & !0x7 != 0 || _port & 0x7 == 0 {
+        return -1;
+    }
+
+    let mut map_perm: MapPermission = MapPermission::U;
+    let pte_flag = Flag(_port);
+    if pte_flag.is_readable() {
+        map_perm |= MapPermission::R;
+    }
+    if pte_flag.is_writeable() {
+        map_perm |= MapPermission::W;
+    }
+    if pte_flag.is_execute() {
+        map_perm |= MapPermission::X;
+    }
+
+    if !TASK_MANAGER.find_area_insert(start_va, end_va, map_perm) {
+        return -1;
+    }
+    return 0;
 }
 
 // YOUR JOB: Implement munmap.
 pub fn sys_munmap(_start: usize, _len: usize) -> isize {
-    trace!("kernel: sys_munmap NOT IMPLEMENTED YET!");
-    -1
+    trace!("kernel: sys_munmap ");
+    let start_va = VirtAddr::from(_start);
+    if !start_va.aligned() {
+        return -1;
+    }
+    let end_va: VirtAddr = (_start + _len).into();
+    if !TASK_MANAGER.find_area_remove(start_va, end_va) {
+        return -1;
+    }
+    return 0;
 }
 /// change data segment size
 pub fn sys_sbrk(size: i32) -> isize {
diff --git a/os/src/task/mod.rs b/os/src/task/mod.rs
@@ -15,6 +15,7 @@ mod switch;
 mod task;
 
 use crate::loader::{get_app_data, get_num_app};
+use crate::mm::{VirtAddr, MapPermission};
 use crate::sync::UPSafeCell;
 use crate::trap::TrapContext;
 use alloc::vec::Vec;
@@ -133,6 +134,32 @@ impl TaskManager {
         inner.tasks[cur].change_program_brk(size)
     }
 
+    /// add syscall counter by syscall_id
+    pub fn add_syscall_counter(&self, syscall_id: usize) {
+        let mut inner = self.inner.exclusive_access();
+        let cur = inner.current_task;
+        inner.tasks[cur].add_syscall_counter(syscall_id);
+    }
+
+    /// get syscall counter by syscall_id
+    pub fn get_syscall_counter(&self, syscall_id: usize) -> usize {
+        let inner = self.inner.exclusive_access();
+        inner.tasks[inner.current_task].get_syscall_counter(syscall_id)
+    }
+
+    /// find area of memory to insert, return false if not found
+    pub fn find_area_insert(&self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) -> bool {
+        let mut inner = self.inner.exclusive_access();
+        let cur = inner.current_task;
+        inner.tasks[cur].find_area_insert(start_va, end_va, permission)
+    }
+    /// find area of memory to remove, return false if not found
+    pub fn find_area_remove(&self, start_va: VirtAddr, end_va: VirtAddr) -> bool {
+        let mut inner = self.inner.exclusive_access();
+        let cur = inner.current_task;
+        inner.tasks[cur].find_area_remove(start_va, end_va)
+    }
+
     /// Switch current `Running` task to the task we have found,
     /// or there is no `Ready` task and we can exit with all applications completed
     fn run_next_task(&self) {
diff --git a/os/src/task/task.rs b/os/src/task/task.rs
@@ -1,8 +1,8 @@
 //! Types related to task management
 use super::TaskContext;
-use crate::config::TRAP_CONTEXT_BASE;
+use crate::config::{MAX_SYSCALL_NUM, TRAP_CONTEXT_BASE};
 use crate::mm::{
-    kernel_stack_position, MapPermission, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE,
+    kernel_stack_position, MemorySet, MapPermission, PhysPageNum, VirtAddr, KERNEL_SPACE,
 };
 use crate::trap::{trap_handler, TrapContext};
 
@@ -28,6 +28,9 @@ pub struct TaskControlBlock {
 
     /// Program break
     pub program_brk: usize,
+
+    /// Syscall counter
+    pub syscall_counter: [usize; MAX_SYSCALL_NUM]
 }
 
 impl TaskControlBlock {
@@ -63,6 +66,7 @@ impl TaskControlBlock {
             base_size: user_sp,
             heap_bottom: user_sp,
             program_brk: user_sp,
+            syscall_counter: [0; MAX_SYSCALL_NUM]
         };
         // prepare TrapContext in user space
         let trap_cx = task_control_block.get_trap_cx();
@@ -96,6 +100,22 @@ impl TaskControlBlock {
             None
         }
     }
+    /// add syscall counter by syscall_id
+    pub fn add_syscall_counter(&mut self, syscall_id: usize) {
+        self.syscall_counter[syscall_id] += 1;
+    }
+    /// get syscall counter by syscall_id
+    pub fn get_syscall_counter(&self, syscall_id: usize) -> usize {
+        self.syscall_counter[syscall_id]
+    }
+    /// find area of memory set to insert
+    pub fn find_area_insert(&mut self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) -> bool {
+        self.memory_set.find_area_insert(start_va, end_va, permission)
+    }
+    /// find area of memory set to remove
+    pub fn find_area_remove(&mut self, start_va: VirtAddr, end_va: VirtAddr) -> bool {
+        self.memory_set.find_area_remove(start_va, end_va)
+    }
 }
 
 #[derive(Copy, Clone, PartialEq)]
diff --git a/reports/lab1.md b/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”分计。
diff --git a/reports/lab2.md b/reports/lab2.md
