ch5 ok

Author: afox666

.github/workflows/build.yml

@@ -31,6 +31,14 @@ jobs:
     container:
       image: duskmoon/dev-env:rcore-ci
     steps:
+      - name: Remove Cargo proxy config
+        run: |
+          unset RUSTUP_DIST_SERVER
+          unset RUSTUP_UPDATE_ROOT
+          unset CARGO_HTTP_MULTIPLEXING
+          # 删除或重置全局配置
+          rm ${CARGO_HOME}/config.toml || true
+          rm -rf rm ${CARGO_HOME}/registry/* || true
       - uses: actions/checkout@v4
       - name: Run tests
         run: |

os/src/config.rs

@@ -21,3 +21,6 @@ pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
 pub const CLOCK_FREQ: usize = 12500000;
 /// the physical memory end
 pub const MEMORY_END: usize = 0x88000000;
+
+/// BigStride
+pub const BIG_STRIDE: usize = 1000;

os/src/mm/memory_set.rs

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

@@ -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;
     }
 }
@@ -202,6 +210,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 +222,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, TaskControlBlock}, timer::get_time_us
 };
 
 #[repr(C)]
@@ -78,6 +73,7 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
         .iter()
         .any(|p| pid == -1 || pid as usize == p.getpid())
     {
+        debug!("no such pid[{}]", pid);
         return -1;
         // ---- release current PCB
     }
@@ -95,8 +91,10 @@ pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
         let exit_code = child.inner_exclusive_access().exit_code;
         // ++++ release child PCB
         *translated_refmut(inner.memory_set.token(), exit_code_ptr) = exit_code;
+        debug!("found pid[{}]", found_pid);
         found_pid as isize
     } else {
+        // debug!("pid[{}] is running", pid);
         -2
     }
     // ---- release current PCB automatically
@@ -106,29 +104,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
+}
+
+#[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.
+// 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
@@ -148,7 +200,18 @@ pub fn sys_spawn(_path: *const u8) -> isize {
         "kernel:pid[{}] sys_spawn NOT IMPLEMENTED",
         current_task().unwrap().pid.0
     );
-    -1
+    let token = current_user_token();
+    let path = translated_str(token, _path);
+    if let Some(data) = get_app_data_by_name(&path) {
+        let new_task: Arc<TaskControlBlock> = current_task().unwrap().spawn(data);
+        let pid = new_task.getpid() as isize;
+        add_task(new_task);
+        debug!("add task pid[{}]", pid);
+        return pid;
+    } else {
+        debug!("kernel: sys spawn error...");
+        return -1;
+    }
 }
 
 // YOUR JOB: Set task priority.
@@ -157,5 +220,9 @@ pub fn sys_set_priority(_prio: isize) -> isize {
         "kernel:pid[{}] sys_set_priority NOT IMPLEMENTED",
         current_task().unwrap().pid.0
     );
-    -1
+    if _prio < 2 {
+        return -1;
+    }
+    current_task().unwrap().set_priority(_prio as usize);
+    return _prio;
 }

os/src/task/manager.rs

@@ -1,29 +1,41 @@
 //!Implementation of [`TaskManager`]
 use super::TaskControlBlock;
+use crate::config::BIG_STRIDE;
 use crate::sync::UPSafeCell;
-use alloc::collections::VecDeque;
 use alloc::sync::Arc;
+use alloc::vec::Vec;
 use lazy_static::*;
 ///A array of `TaskControlBlock` that is thread-safe
 pub struct TaskManager {
-    ready_queue: VecDeque<Arc<TaskControlBlock>>,
+    ready_queue: Vec<Arc<TaskControlBlock>>,
 }
 
 /// A simple FIFO scheduler.
 impl TaskManager {
     ///Creat an empty TaskManager
     pub fn new() -> Self {
         Self {
-            ready_queue: VecDeque::new(),
+            ready_queue: Vec::new(),
         }
     }
     /// Add process back to ready queue
     pub fn add(&mut self, task: Arc<TaskControlBlock>) {
-        self.ready_queue.push_back(task);
+        self.ready_queue.push(task);
     }
     /// Take a process out of the ready queue
     pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
-        self.ready_queue.pop_front()
+        let mut min_stride_idx = 0;
+        let mut min_stride = BIG_STRIDE;
+        for (idx, task) in self.ready_queue.iter().enumerate() {
+            let stride = task.inner_exclusive_access().stride as usize;
+            if stride < min_stride {
+                min_stride_idx = idx;
+                min_stride = stride;
+            }
+        }
+        let ret = self.ready_queue[min_stride_idx].clone();
+        self.ready_queue.remove(min_stride_idx);
+        return Some(ret);
     }
 }
 

os/src/task/mod.rs

@@ -48,6 +48,7 @@ pub fn suspend_current_and_run_next() {
     drop(task_inner);
     // ---- release current PCB
 
+    task.update_stride();
     // push back to ready queue.
     add_task(task);
     // jump to scheduling cycle