ch4 ok

Author: afox666

os/src/mm/memory_set.rs

@@ -300,6 +300,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 {

os/src/mm/mod.rs

@@ -16,8 +16,9 @@ use address::{StepByOne, VPNRange};
 pub use frame_allocator::{frame_alloc, FrameTracker};
 pub use memory_set::remap_test;
 pub use memory_set::{MapPermission, MemorySet, KERNEL_SPACE};
-pub use page_table::{translated_byte_buffer, translated_refmut, translated_str, PageTableEntry};
-use page_table::{PTEFlags, PageTable};
+pub use page_table::{translated_byte_buffer, translated_refmut, translated_physaddr, translated_str, PageTableEntry};
+pub use page_table::{PTEFlags, PageTable};
+
 /// initiate heap allocator, frame allocator and kernel space
 pub fn init() {
     heap_allocator::init_heap();

os/src/mm/page_table.rs

@@ -202,6 +202,7 @@ pub fn translated_str(token: usize, ptr: *const u8) -> String {
     }
     string
 }
+
 /// Translate a ptr[u8] array through page table and return a mutable reference of T
 pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
     //trace!("into translated_refmut!");
@@ -213,3 +214,16 @@ pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
         .unwrap()
         .get_mut()
 }
+
+/// 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;
+}

os/src/syscall/mod.rs

@@ -43,6 +43,7 @@ mod process;
 
 use fs::*;
 use process::*;
+
 /// handle syscall exception with `syscall_id` and other arguments
 pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
     match syscall_id {

os/src/syscall/process.rs

@@ -2,12 +2,7 @@
 use alloc::sync::Arc;
 
 use crate::{
-    loader::get_app_data_by_name,
-    mm::{translated_refmut, translated_str},
-    task::{
-        add_task, current_task, current_user_token, exit_current_and_run_next,
-        suspend_current_and_run_next,
-    },
+    loader::get_app_data_by_name, mm::{translated_physaddr, translated_refmut, translated_str, MapPermission, VirtAddr}, task::{add_task, current_task, current_user_token, exit_current_and_run_next, suspend_current_and_run_next}, timer::get_time_us
 };
 
 #[repr(C)]
@@ -106,29 +101,83 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
 /// HINT: You might reimplement it with virtual memory management.
 /// HINT: What if [`TimeVal`] is splitted by two pages ?
 pub fn sys_get_time(_ts: *mut TimeVal, _tz: usize) -> isize {
-    trace!(
-        "kernel:pid[{}] sys_get_time NOT IMPLEMENTED",
-        current_task().unwrap().pid.0
-    );
-    -1
+    trace!("kernel: sys_get_time");
+    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
 }
 
-/// YOUR JOB: Implement mmap.
+#[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:pid[{}] sys_mmap NOT IMPLEMENTED",
-        current_task().unwrap().pid.0
-    );
-    -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 !current_task().unwrap().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:pid[{}] sys_munmap NOT IMPLEMENTED",
-        current_task().unwrap().pid.0
-    );
-    -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 !current_task().unwrap().find_area_remove(start_va, end_va) {
+        return -1;
+    }
+    return 0;
 }
 
 /// change data segment size

os/src/task/task.rs

@@ -1,8 +1,8 @@
 //! Types related to task management & Functions for completely changing TCB
 use super::TaskContext;
 use super::{kstack_alloc, pid_alloc, KernelStack, PidHandle};
+use crate::mm::{MapPermission, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
 use crate::config::TRAP_CONTEXT_BASE;
-use crate::mm::{MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE};
 use crate::sync::UPSafeCell;
 use crate::trap::{trap_handler, TrapContext};
 use alloc::sync::{Arc, Weak};
@@ -236,6 +236,14 @@ impl TaskControlBlock {
             None
         }
     }
+    /// find area of memory set to insert
+    pub fn find_area_insert(&self, start_va: VirtAddr, end_va: VirtAddr, permission: MapPermission) -> bool {
+        self.inner_exclusive_access().memory_set.find_area_insert(start_va, end_va, permission)
+    }
+    /// find area of memory set to remove
+    pub fn find_area_remove(&self, start_va: VirtAddr, end_va: VirtAddr) -> bool {
+        self.inner_exclusive_access().memory_set.find_area_remove(start_va, end_va)
+    }
 }
 
 #[derive(Copy, Clone, PartialEq)]

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”分计。

reports/lab2.md

@@ -85,4 +85,4 @@ SV39页表页表项（PTE），由64位组成，
 
 3. 我独立完成了本次实验除以上方面之外的所有工作，包括代码与文档。 我清楚地知道，从以上方面获得的信息在一定程度上降低了实验难度，可能会影响起评分。
 
-4. 我从未使用过他人的代码，不管是原封不动地复制，还是经过了某些等价转换。 我未曾也不会向他人（含此后各届同学）复制或公开我的实验代码，我有义务妥善保管好它们。 我提交至本实验的评测系统的代码，均无意于破坏或妨碍任何计算机系统的正常运转。 我清楚地知道，以上情况均为本课程纪律所禁止，若违反，对应的实验成绩将按“-100”分计。
+4. 我从未使用过他人的代码，不管是原封不动地复制，还是经过了某些等价转换。 我未曾也不会向他人（含此后各届同学）复制或公开我的实验代码，我有义务妥善保管好它们。 我提交至本实验的评测系统的代码，均无意于破坏或妨碍任何计算机系统的正常运转。 我清楚地知道，以上情况均为本课程纪律所禁止，若违反，对应的实验成绩将按“-100”分计。