edit mmap

Author: fnnx1

.gitignore

@@ -20,4 +20,5 @@ ci-user/
 user/
 os/vendor/
 sdcard-riscv64.img
-Linux1.0
+Linux1.0
+testsuits-for-oskernel

os/Makefile

@@ -7,6 +7,11 @@ DISASM_TMP := target/$(TARGET)/$(MODE)/asm
 FS_IMG := ../user/target/$(TARGET)/$(MODE)/fs.img
 APPS := ../user/src/bin/*
 OFFLINE :=
+# Extra test apps to bundle into fs.img (override from CLI if needed)
+# Examples:
+# - make run TEST_APPS=../tests/musl/basic
+# - make run TEST_APPS=../testsuits-for-oskernel/basic
+TEST_APPS ?= ../tests/musl/basic
 
 # BOARD
 BOARD := qemu
@@ -50,6 +55,14 @@ $(KERNEL_BIN): kernel
 
 fs-img: $(APPS)
 	@make -C ../user build TEST=$(TEST) CHAPTER=$(CHAPTER) BASE=$(BASE)
+	@mkdir -p ../user/build/app/
+	@if [ -n "$(TEST_APPS)" ]; then \
+	  if [ -e "$(TEST_APPS)" ]; then \
+	    cp -r "$(TEST_APPS)"/. ../user/build/app/; \
+	  else \
+	    echo "[fs-img] WARN: TEST_APPS '$(TEST_APPS)' not found; skipping"; \
+	  fi; \
+	fi
 	@rm -f $(FS_IMG)
 	@cd ../easy-fs-fuse && cargo run --release -- -s ../user/build/app/ -t ../user/target/riscv64gc-unknown-none-elf/release/
 

os/src/mm/memory_set.rs

@@ -3,7 +3,7 @@ use super::{PTEFlags, PageTable, PageTableEntry};
 use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
 use super::{StepByOne, VPNRange};
 use crate::config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT_BASE, USER_STACK_SIZE};
-use crate::mm::mmap::{self, MMapProt};
+use crate::mm::mmap;
 use crate::sync::UPSafeCell;
 use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
@@ -91,25 +91,23 @@ impl MemorySet {
     /// 检查目标地址段是否与已有的映射冲突(存在交集)
     fn has_conflict(&self, start: usize, len: usize) -> bool {
         for area in self.areas.iter() {
-            let area_start = area.vpn_range.get_start().0 * PAGE_SIZE;
-            let area_end = area.vpn_range.get_end().0 * PAGE_SIZE;
-            let target_start = start;
-            let target_end = start + len;
+            //以下均为页号
+            let area_start = area.vpn_range.get_start().0;
+            let area_end = area.vpn_range.get_end().0;
+            let target_start = start / PAGE_SIZE;
+            let target_end = (start + len) / PAGE_SIZE +1;
             if target_end > area_start && target_start < area_end {
                 return true;
             }
         }
         false
     }
-    /// 实现mmap
+    /// 实现mmap（只分配内存，不加载文件）
     pub fn mmap(
         &mut self,
         addr: usize,
         length: usize,
-        prot: mmap::MMapProt,
-        flags: mmap::MMapFlags,
-        _fd: i32,
-        _offset: usize,
+        prot: mmap::MMapProt
     ) -> Result<usize, i32> {
         // 检查冲突
         if self.has_conflict(addr, length) {
@@ -127,7 +125,7 @@ impl MemorySet {
         if prot.contains(mmap::MMapProt::PROT_EXEC) {
             permission |= MapPermission::X;
         }
-        if prot != MMapProt::PROT_NONE {
+        if prot != mmap::MMapProt::PROT_NONE {
             permission |= MapPermission::U;
         }
 
@@ -138,13 +136,6 @@ impl MemorySet {
             permission,
         );
 
-        // 按类型处理映射内容
-        if flags.contains(mmap::MMapFlags::MAP_ANONYMOUS) {
-            // do nothing
-        } else {
-            // 待完成文件有关部分
-        }
-
         Ok(addr)
     }
     /// Mention that trampoline is not collected by areas.

os/src/mm/mmap.rs

@@ -1,5 +1,6 @@
 #![deny(warnings)]
 #![allow(missing_docs)]
+
 use bitflags::*;
 use crate::task::processor::PROCESSOR;
 
@@ -16,16 +17,19 @@ bitflags! {
 // mmap 映射类型标志
 bitflags! {
     pub struct MMapFlags: i32 {
+        const MAP_FILE      = 0;
         const MAP_SHARED    = 1 << 0;
         const MAP_PRIVATE   = 1 << 1;
         const MAP_ANONYMOUS = 1 << 2;
-        const MAP_FILE      = 1 << 3;
     }
 }
 
-/// 处理mmap系统调用
-pub fn do_mmap(addr: usize, length: usize, prot: MMapProt, flags: MMapFlags, fd: i32, offset: usize) -> Result<usize, i32> {
+/// 处理mmap系统调用的分配部分
+pub fn do_mmap(addr: usize, length: usize, prot: MMapProt) -> Result<usize, i32> {
     let task = PROCESSOR.exclusive_access().current().unwrap();
     let mut task_inner = task.inner_exclusive_access();
-    task_inner.mmap(addr, length, prot, flags, fd, offset)
-}
+    task_inner.mmap(addr, length, prot)
+}
+
+// 尽管文件映射在syscall中实现，但此处设置一个shared区域
+// unimplemented

os/src/syscall/mod.rs

@@ -69,8 +69,9 @@ use process::*;
 
 use crate::{fs::Stat, task::SignalAction};
 
+#[no_mangle]
 /// handle syscall exception with `syscall_id` and other arguments
-pub fn syscall(syscall_id: usize, args: [usize; 4]) -> isize {
+pub fn syscall(syscall_id: usize, args: [usize; 6]) -> isize {
     match syscall_id {
         SYSCALL_DUP => sys_dup(args[0]),
         SYSCALL_OPEN => sys_open(args[1] as *const u8, args[2] as u32),
@@ -96,7 +97,10 @@ pub fn syscall(syscall_id: usize, args: [usize; 4]) -> isize {
         SYSCALL_EXEC => sys_exec(args[0] as *const u8, args[1] as *const usize),
         SYSCALL_WAITPID => sys_waitpid(args[0] as isize, args[1] as *mut i32),
         SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal, args[1]),
-        SYSCALL_MMAP => sys_mmap(args[0], args[1], args[2]),
+        SYSCALL_MMAP => sys_mmap(
+            args[0], args[1], args[2] as i32, 
+            args[3] as i32, args[4] as i32, args[5]
+        ),
         SYSCALL_MUNMAP => sys_munmap(args[0], args[1]),
         SYSCALL_SBRK => sys_sbrk(args[0] as i32),
         SYSCALL_SPAWN => sys_spawn(args[0] as *const u8),

os/src/syscall/process.rs

@@ -1,15 +1,16 @@
 //! Process management syscalls
 
 use crate::{
-    fs::{open_file, OpenFlags},
-    mm::{translated_ref, translated_refmut, translated_str, mmap},
-    task::{
+    fs::{*}, mm::{mmap, translated_ref, translated_refmut, translated_str}, task::{
         add_task, current_task, current_user_token, exit_current_and_run_next, pid2task,
         suspend_current_and_run_next, SignalAction, SignalFlags, MAX_SIG,
     },
+    syscall::sys_read
 };
 use alloc::{string::String, sync::Arc, vec::Vec};
 
+
+
 #[repr(C)]
 #[derive(Debug)]
 pub struct TimeVal {
@@ -142,16 +143,32 @@ pub fn sys_get_time(_ts: *mut TimeVal, _tz: usize) -> isize {
 }
 
 /// YOUR JOB: Implement mmap.
-pub fn sys_mmap(_start: usize, _len: usize, _port: usize) -> isize {
+pub fn sys_mmap(start: usize, len: usize, port: i32, flags: i32, fd: i32, _off: usize) -> isize {
     trace!("kernel:pid[{}] sys_mmap NOT IMPLEMENTED", current_task().unwrap().pid.0);
-    mmap::do_mmap(
-        _start, 
-        _len,
-        mmap::MMapProt::from_bits_truncate(_port as i32),
-        mmap::MMapFlags::from_bits_truncate(_port as i32),
-        -1,
-        0
-    ).unwrap_or(usize::MAX) as isize
+    let mmap_flags = mmap::MMapFlags::from_bits_truncate(flags);
+    let mmap_prot = mmap::MMapProt::from_bits_truncate(port);
+    if let Ok(ret) = mmap::do_mmap(
+        start, 
+        len,
+        mmap_prot
+    ) {
+        match mmap_flags {
+            mmap::MMapFlags::MAP_ANONYMOUS => {},
+            mmap::MMapFlags::MAP_PRIVATE => {
+                // 按目前理解，拷贝文件内容到映射区即可？
+                sys_read(fd as usize, ret as *mut u8, len);
+            },
+            mmap::MMapFlags::MAP_SHARED => {
+                //尚未实现
+                //此此处似乎需要实现文件的同步回写
+            },
+            _ =>  {return -1;},
+        };
+        ret as isize
+    }
+    else {
+        -1
+    }
 }
 
 /// YOUR JOB: Implement munmap.

os/src/task/processor.rs

@@ -1,4 +1,4 @@
-//! Implementation of [`Processor`] and Intersection of control flow
+//!Implementation of [`Processor`] and Intersection of control flow
 //!
 //! Here, the continuous operation of user apps in CPU is maintained,
 //! the current running state of CPU is recorded,
@@ -10,9 +10,12 @@ use super::{TaskContext, TaskControlBlock};
 use crate::sync::UPSafeCell;
 use crate::trap::TrapContext;
 use alloc::sync::Arc;
+use core::cell::RefMut;
 use lazy_static::*;
+use super::task::TaskControlBlockInner;
 
 /// Processor management structure
+/// 只记录当前任务block与空闲状态下的任务上下文
 pub struct Processor {
     ///The task currently executing on the current processor
     current: Option<Arc<TaskControlBlock>>,
@@ -42,24 +45,31 @@ impl Processor {
 
     ///Get current task in cloning semanteme
     pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
+        //map方法传入Option<T>，对T进行处理（闭包），并返回新的Option<T'>
         self.current.as_ref().map(Arc::clone)
     }
+    ///获取当前task的访问权，但不获取其所有权
+    pub fn _current_exclusive_access(&self) -> Option<RefMut<'_, TaskControlBlockInner>> {
+        self.current.as_ref().map(|task| task.inner_exclusive_access())
+    }
 }
 
 lazy_static! {
-    /// Global processor instance.
+    ///The global unique processor instance
     pub static ref PROCESSOR: UPSafeCell<Processor> = unsafe { UPSafeCell::new(Processor::new()) };
 }
 
 ///The main part of process execution and scheduling
 ///Loop `fetch_task` to get the process that needs to run, and switch the process through `__switch`
 pub fn run_tasks() {
+    //注意，这里是一个循环
     loop {
         let mut processor = PROCESSOR.exclusive_access();
         if let Some(task) = fetch_task() {
             let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
             // access coming task TCB exclusively
             let mut task_inner = task.inner_exclusive_access();
+            // 这玩意保存在内核堆区
             let next_task_cx_ptr = &task_inner.task_cx as *const TaskContext;
             task_inner.task_status = TaskStatus::Running;
             // release coming task_inner manually
@@ -69,8 +79,12 @@ pub fn run_tasks() {
             // release processor manually
             drop(processor);
             unsafe {
+                // 调用前，a寄存器和t寄存器已经被保存好（调用者保存）
+                // __switch会保存s寄存器
                 __switch(idle_task_cx_ptr, next_task_cx_ptr);
-            }
+            } 
+            // 一段时间后后可能会返回到这里（切回空闲状态后）
+            // 进入下一个循环
         } else {
             warn!("no tasks available in run_tasks");
         }
@@ -93,15 +107,16 @@ pub fn current_user_token() -> usize {
     task.get_user_token()
 }
 
-/// Get the mutable reference to trap context of current task
+///Get the mutable reference to trap context of current task
 pub fn current_trap_cx() -> &'static mut TrapContext {
     current_task()
         .unwrap()
         .inner_exclusive_access()
         .get_trap_cx()
 }
 
-/// Return to idle control flow for new scheduling
+///Return to idle control flow for new scheduling
+///保存当前任务到传入参数地址（这时还是用户态），切换到空闲状态
 pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
     let mut processor = PROCESSOR.exclusive_access();
     let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();

os/src/task/task.rs

@@ -112,16 +112,13 @@ impl TaskControlBlockInner {
             self.fd_table.len() - 1
         }
     }
-    pub fn mmap(
+    pub fn mmap(//映射内存段
         &mut self,
         addr: usize,
         length: usize,
-        prot: mmap::MMapProt,
-        flags: mmap::MMapFlags,
-        fd: i32,
-        offset: usize,
+        prot: mmap::MMapProt
     ) -> Result<usize, i32> {
-        self.memory_set.mmap(addr, length, prot, flags, fd, offset)
+        self.memory_set.mmap(addr, length, prot)
     }
 }