update

Author: Docter-R

os/src/syscall/process.rs

@@ -1,6 +1,7 @@
 //! Process management syscalls
 //!
 use alloc::sync::Arc;
+use crate::task::BIG_STRIDE;
 
 use crate::{
     fs::{open_file, OpenFlags},
@@ -152,10 +153,22 @@ pub fn sys_spawn(_path: *const u8) -> isize {
 }
 
 // YOUR JOB: Set task priority.
-pub fn sys_set_priority(_prio: isize) -> isize {
+pub fn sys_set_priority(prio: isize) -> isize {
     trace!(
         "kernel:pid[{}] sys_set_priority NOT IMPLEMENTED",
         current_task().unwrap().pid.0
     );
-    -1
+        if prio < 2 {
+        return -1; // 优先级必须 >= 2
+    }
+    
+    let prio = prio as usize;
+    let current_task = current_task().unwrap();
+    let mut inner = current_task.inner_exclusive_access();
+    
+    // 更新优先级和步长
+    inner.priority = prio;
+    inner.pass = BIG_STRIDE / prio;
+    
+    prio as isize
 }

os/src/task/manager.rs

@@ -4,6 +4,7 @@ use crate::sync::UPSafeCell;
 use alloc::collections::VecDeque;
 use alloc::sync::Arc;
 use lazy_static::*;
+use crate::task::current_task;
 ///A array of `TaskControlBlock` that is thread-safe
 pub struct TaskManager {
     ready_queue: VecDeque<Arc<TaskControlBlock>>,
@@ -25,6 +26,85 @@ impl TaskManager {
     pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
         self.ready_queue.pop_front()
     }
+    /// 在当前任务的页表中映射一段虚拟地址区域    
+    pub fn sys_mmap_tcb(&mut self, start: usize, len: usize, prot: usize) -> isize {
+        if let Some(task) = current_task() {
+            let mut inner = task.inner_exclusive_access();
+            inner.sys_mmap_tcb(start, len, prot)
+        } else {
+            -1
+        }
+    }
+    /// 在当前任务的页表中取消映射一段虚拟地址区域
+    pub fn sys_munmap_tcb(&mut self, start: usize, len: usize) -> isize {
+        if let Some(task) = current_task() {
+            let mut inner = task.inner_exclusive_access();
+            inner.sys_munmap_tcb(start, len)
+        } else {
+            -1
+        }
+    }
+
+    /// 选择 stride 最小的任务进行调度
+    pub fn fetch_stride(&mut self) -> Option<Arc<TaskControlBlock>> {
+    if self.ready_queue.is_empty() {
+        None
+    } else {
+        // 找到 stride 最小的任务
+        let mut min_stride = usize::MAX;
+        let mut min_index = 0;
+        
+        for (i, task) in self.ready_queue.iter().enumerate() {
+            let inner = task.inner_exclusive_access();
+            if inner.stride < min_stride {
+                min_stride = inner.stride;
+                min_index = i;
+            }
+        }
+        
+        // 移除选中的任务
+        let task = self.ready_queue.remove(min_index).unwrap();
+        
+        // 更新被选中任务的 stride
+        {
+            let pass = {
+                let inner = task.inner_exclusive_access();
+                inner.pass
+            }; // 这里 inner 被释放
+
+            let mut inner = task.inner_exclusive_access();
+            // 检查溢出
+            if let Some(new_stride) = inner.stride.checked_add(pass) {
+                inner.stride = new_stride;
+            } else {
+                // 处理溢出：归一化所有任务的 stride
+                inner.stride = pass;
+                self.normalize_strides();
+                }
+            } // 这里 inner 被释放
+
+        Some(task)
+        }
+    }
+
+    /// 归一化所有任务的 stride 值，避免溢出
+    fn normalize_strides(&mut self) {
+        if self.ready_queue.is_empty() {
+            return;
+        }
+        
+        // 找到最小的 stride
+        let min_stride = self.ready_queue.iter()
+            .map(|task| task.inner_exclusive_access().stride)
+            .min()
+            .unwrap();
+        
+        // 所有任务减去最小 stride
+        for task in self.ready_queue.iter_mut() {
+            let mut inner = task.inner_exclusive_access();
+            inner.stride = inner.stride.saturating_sub(min_stride);
+        }
+    }
 }
 
 lazy_static! {
@@ -44,3 +124,13 @@ pub fn fetch_task() -> Option<Arc<TaskControlBlock>> {
     //trace!("kernel: TaskManager::fetch_task");
     TASK_MANAGER.exclusive_access().fetch()
 }
+
+/// 在当前任务的页表中映射一段虚拟地址区域
+pub fn sys_mmap_tcb(start: usize, len: usize, prot: usize) -> isize {
+    TASK_MANAGER.exclusive_access().sys_mmap_tcb(start, len, prot)
+}
+
+/// 在当前任务的页表中取消映射一段虚拟地址区域
+pub fn sys_munmap_tcb(start: usize, len: usize) -> isize {
+    TASK_MANAGER.exclusive_access().sys_munmap_tcb(start, len)
+}

os/src/task/processor.rs

@@ -12,11 +12,8 @@ use crate::trap::TrapContext;
 use alloc::sync::Arc;
 use lazy_static::*;
 
-<<<<<<< HEAD
 use crate::task::add_task;
 
-=======
->>>>>>> e5b3d74 (Initialize ch6)
 /// Processor management structure
 pub struct Processor {
     ///The task currently executing on the current processor
@@ -109,7 +106,6 @@ pub fn current_trap_cx() -> &'static mut TrapContext {
 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();
-<<<<<<< HEAD
     // 将当前任务放回就绪队列（如果它还是可运行的）
     if let Some(current) = &processor.current {
         let mut inner = current.inner_exclusive_access();
@@ -121,8 +117,6 @@ pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
             add_task(current.clone());
         }
     }
-=======
->>>>>>> e5b3d74 (Initialize ch6)
     drop(processor);
     unsafe {
         __switch(switched_task_cx_ptr, idle_task_cx_ptr);