backport lab4 to ch5

Author: LRL52

os/src/mm/address.rs

@@ -113,6 +113,15 @@ impl VirtAddr {
     pub fn aligned(&self) -> bool {
         self.page_offset() == 0
     }
+
+    /// Check if the virtual address is valid
+    /// 在启用 SV39 分页模式下，只有低 39 位是真正有意义的。SV39 分页模式规定 64 位虚拟地址的 
+    /// 这 25 位必须和第 38 位相同，否则 MMU 会直接认定它是一个 不合法的虚拟地址。也就是说，
+    /// 所有 2^{64} 个虚拟地址中，只有最低的 256GiB（当第 38 位为 0 时）以及最高的（当第 38 
+    /// 位为 1 时）是合法的虚拟地址。
+    pub fn is_valid(addr: usize) -> bool {
+        addr <= 0x3F_FF_FF_FF_FF_usize || addr >= 0xFF_FF_FF_C0_00_00_00_00_usize
+    }
 }
 impl From<VirtAddr> for VirtPageNum {
     fn from(v: VirtAddr) -> Self {
@@ -204,7 +213,7 @@ impl StepByOne for VirtPageNum {
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq)]
 /// a simple range structure for type T
 pub struct SimpleRange<T>
 where
@@ -227,6 +236,9 @@ where
     pub fn get_end(&self) -> T {
         self.r
     }
+    pub fn has_intersection(&self, other: &Self) -> bool {
+        !(self.r <= other.l || self.l >= other.r)
+    }
 }
 impl<T> IntoIterator for SimpleRange<T>
 where

os/src/mm/frame_allocator.rs

@@ -55,6 +55,9 @@ impl StackFrameAllocator {
         self.end = r.0;
         // trace!("last {} Physical Frames.", self.end - self.current);
     }
+    pub fn free_page_count(&self) -> usize {
+        self.recycled.len() + (self.end - self.current)
+    }
 }
 impl FrameAllocator for StackFrameAllocator {
     fn new() -> Self {

os/src/mm/memory_set.rs

@@ -32,8 +32,10 @@ lazy_static! {
 }
 /// address space
 pub struct MemorySet {
-    page_table: PageTable,
-    areas: Vec<MapArea>,
+    /// page table for this address space
+    pub page_table: PageTable,
+    /// collection of contiguous mapped areas
+    pub areas: Vec<MapArea>,
 }
 
 impl MemorySet {
@@ -60,6 +62,28 @@ impl MemorySet {
             None,
         );
     }
+
+    /// Remove a framed area
+    pub fn remove_framed_area(
+        &mut self,
+        start_va: VirtAddr,
+        end_va: VirtAddr,
+    ) -> Option<MapArea> {
+        let start_vpn = start_va.floor();
+        let end_vpn = end_va.ceil();
+        if let Some(index) = self
+            .areas
+            .iter()
+            .position(|area| area.vpn_range.get_start() == start_vpn && area.vpn_range.get_end() == end_vpn)
+        {
+            let mut area = self.areas.remove(index);
+            area.unmap(&mut self.page_table);
+            Some(area)
+        } else {
+            None
+        }
+    }
+
     /// remove a area
     pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
         if let Some((idx, area)) = self
@@ -103,6 +127,7 @@ impl MemorySet {
             ".bss [{:#x}, {:#x})",
             sbss_with_stack as usize, ebss as usize
         );
+        info!("physical memory [{:#x}, {:#x})", ekernel as usize, MEMORY_END);
         info!("mapping .text section");
         memory_set.push(
             MapArea::new(
@@ -303,7 +328,7 @@ impl MemorySet {
 }
 /// map area structure, controls a contiguous piece of virtual memory
 pub struct MapArea {
-    vpn_range: VPNRange,
+    pub vpn_range: VPNRange,
     data_frames: BTreeMap<VirtPageNum, FrameTracker>,
     map_type: MapType,
     map_perm: MapPermission,

os/src/mm/mod.rs

@@ -11,9 +11,9 @@ mod heap_allocator;
 mod memory_set;
 mod page_table;
 
-pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
-use address::{StepByOne, VPNRange};
-pub use frame_allocator::{frame_alloc, FrameTracker};
+pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum, VPNRange};
+use address::{StepByOne};
+pub use frame_allocator::{frame_alloc, FrameTracker, FRAME_ALLOCATOR};
 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};

os/src/mm/page_table.rs

@@ -8,13 +8,21 @@ use bitflags::*;
 bitflags! {
     /// page table entry flags
     pub struct PTEFlags: u8 {
+        /// Valid
         const V = 1 << 0;
+        /// Readable
         const R = 1 << 1;
+        /// Writable
         const W = 1 << 2;
+        /// Executable
         const X = 1 << 3;
+        /// User
         const U = 1 << 4;
+        /// Global
         const G = 1 << 5;
+        /// Accessed
         const A = 1 << 6;
+        /// Dirty
         const D = 1 << 7;
     }
 }

os/src/syscall/process.rs

@@ -3,11 +3,10 @@ use alloc::sync::Arc;
 
 use crate::{
     loader::get_app_data_by_name,
-    mm::{translated_refmut, translated_str},
+    mm::{translated_byte_buffer, translated_refmut, translated_str, MapPermission, VPNRange, VirtAddr, VirtPageNum, FRAME_ALLOCATOR},
     task::{
-        add_task, current_task, current_user_token, exit_current_and_run_next,
-        suspend_current_and_run_next,
-    },
+        add_task, current_task, current_user_token, exit_current_and_run_next, suspend_current_and_run_next
+    }, timer::get_time_us,
 };
 
 #[repr(C)]
@@ -105,30 +104,92 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
 /// YOUR JOB: get time with second and microsecond
 /// 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
+pub fn sys_get_time(ts: *mut TimeVal, _tz: usize) -> isize {
+    trace!("kernel: sys_get_time");
+    // let token = current_user_token();
+    // let page_table = PageTable::from_token(token);
+    // let va = VirtAddr::from(ts as usize);
+    // let vpn = va.floor();
+    // let ppn = page_table.translate(vpn).unwrap().ppn();
+    // let offset = va.page_offset();
+    // let pa: PhysAddr = (Into::<usize>::into(Into::<PhysAddr>::into(ppn)) + offset).into();
+    // let ts: &mut TimeVal = pa.get_mut();
+    // let us = get_time_us();
+    // *ts = TimeVal {
+    //     sec: us / 1_000_000,
+    //     usec: us % 1_000_000,
+    // };
+    // 上面这个实现并不完美，无法处理跨页的情况
+    let token = current_user_token();
+    let buf = translated_byte_buffer(token, ts as *const u8, core::mem::size_of::<TimeVal>());
+    let us = get_time_us();
+    let ts = TimeVal {
+        sec: us / 1_000_000,
+        usec: us % 1_000_000,
+    };
+    let src = unsafe {
+        core::slice::from_raw_parts(&ts as *const TimeVal as *const u8, core::mem::size_of::<TimeVal>())
+    };
+    let mut offset = 0;
+    for dst in buf {
+        let len = dst.len();
+        dst.copy_from_slice(&src[offset..offset + len]);
+        offset += len;
+    }
+    0
 }
 
-/// 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
+// YOUR JOB: Implement mmap.
+pub fn sys_mmap(start: usize, len: usize, prot: usize) -> isize {
+    trace!("kernel: sys_mmap");
+    let start_va = VirtAddr::from(start);
+    if !start_va.aligned() || (prot & !0x7 != 0) || (prot & 0x7 == 0) {
+        trace!("kernel: sys_mmap failed, invalid parameters!");
+        return -1;
+    }
+    let end_va: VirtAddr = VirtAddr::from(start + len).ceil().into();
+    let start_vpn: VirtPageNum = start_va.into();
+    let end_vpn: VirtPageNum = end_va.into();
+
+    // Check if there are enough free pages
+    if end_vpn.0 - start_vpn.0 > FRAME_ALLOCATOR.exclusive_access().free_page_count() {
+        trace!("kernel: sys_mmap failed, not enough free pages!");
+        return -1;
+    }
+
+    // Check if the new memory area overlaps with existing areas
+    let current = current_task().unwrap();
+    let mut inner = current.inner_exclusive_access();
+    let new_vpn_range = VPNRange::new(start_vpn, end_vpn);
+    for area in inner.memory_set.areas.iter() {
+        if area.vpn_range.has_intersection(&new_vpn_range) {
+            trace!("kernel: sys_mmap failed, overlapping memory area!");
+            return -1;
+        }
+    }
+
+    let mut permission = MapPermission::U;
+    permission |= MapPermission::from_bits((prot << 1) as u8).unwrap();
+    inner.memory_set.insert_framed_area(start_va, end_va, permission);
+    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
+// YOUR JOB: Implement munmap.
+pub fn sys_munmap(start: usize, len: usize) -> isize {
+    trace!("kernel: sys_munmap");
+    let start_va = VirtAddr::from(start);
+    if !start_va.aligned() {
+        trace!("kernel: sys_munmap failed, invalid parameters!");
+        return -1;
+    }
+    let end_va: VirtAddr = VirtAddr::from(start + len).ceil().into();
+    
+    let current = current_task().unwrap();
+    let mut inner = current.inner_exclusive_access();
+    match inner.memory_set.remove_framed_area(start_va, end_va) {
+        Some(_) => 0,
+        None => -1
+    }
 }
 
 /// change data segment size