complete answer and test CI

Author: Ivans-11

ch3/src/main.rs

@@ -40,7 +40,7 @@ extern "C" fn rust_main() -> ! {
     for (i, app) in tg_linker::AppMeta::locate().iter().enumerate() {
         let entry = app.as_ptr() as usize;
         log::info!("load app{i} to {entry:#x}");
-        tcbs[i].init(entry);
+        tcbs[i].init(i, entry);
         index_mod += 1;
     }
     println!();
@@ -183,17 +183,28 @@ mod impls {
     }
 
     impl Trace for SyscallContext {
-        // TODO: 实现 trace 系统调用
+        // 实现 trace 系统调用
         #[inline]
-        fn trace(
-            &self,
-            _caller: tg_syscall::Caller,
-            _trace_request: usize,
-            _id: usize,
-            _data: usize,
-        ) -> isize {
-            tg_console::log::info!("trace: not implemented");
-            -1
+        fn trace(&self, _caller: tg_syscall::Caller, trace_request: usize, id: usize, data: usize) -> isize {
+            match trace_request {
+                // 读取 id 地址处一个字节的值
+                0 => {
+                    let ptr = id as *const u8;
+                    unsafe { *ptr as isize }
+                }
+                // 写入 data（作为 u8）到 id 地址处
+                1 => {
+                    let ptr = id as *mut u8;
+                    unsafe { *ptr = data as u8 };
+                    0
+                }
+                // 查询系统调用次数（本次调用已在 handle_syscall 中计入）
+                2 => {
+                    crate::task::get_syscall_count(id)
+                }
+                // 其他情况返回 -1
+                _ => -1,
+            }
         }
     }
 }

ch3/src/task.rs

@@ -1,13 +1,27 @@
 use tg_kernel_context::LocalContext;
 use tg_syscall::{Caller, SyscallId};
 
+/// 系统调用计数器数组大小（覆盖所需系统调用号，SYS_TRACE = 410 + 1）
+const SYSCALL_COUNT_SIZE: usize = 420;
+
+/// 最大任务数量
+const MAX_TASKS: usize = 32;
+
+/// 静态分配的系统调用计数器数组（避免栈溢出）
+static mut SYSCALL_COUNTS: [[usize; SYSCALL_COUNT_SIZE]; MAX_TASKS] = [[0; SYSCALL_COUNT_SIZE]; MAX_TASKS];
+
+/// 当前任务 ID
+static mut CURRENT_TASK_ID: usize = 0;
+
 /// 任务控制块。
 ///
 /// 包含任务的上下文、状态和资源。
 pub struct TaskControlBlock {
     ctx: LocalContext,
     pub finish: bool,
     stack: [usize; 256],
+    /// 任务 ID，用于索引静态系统调用计数器
+    task_id: usize,
 }
 
 /// 调度事件。
@@ -23,12 +37,18 @@ impl TaskControlBlock {
         ctx: LocalContext::empty(),
         finish: false,
         stack: [0; 256],
+        task_id: 0,
     };
 
     /// 初始化一个任务。
-    pub fn init(&mut self, entry: usize) {
+    pub fn init(&mut self, task_id: usize, entry: usize) {
         self.stack.fill(0);
         self.finish = false;
+        self.task_id = task_id;
+        // 清零该任务的系统调用计数器
+        unsafe {
+            SYSCALL_COUNTS[task_id].fill(0);
+        }
         self.ctx = LocalContext::user(entry);
         *self.ctx.sp_mut() = self.stack.as_ptr() as usize + core::mem::size_of_val(&self.stack);
     }
@@ -44,7 +64,7 @@ impl TaskControlBlock {
         use tg_syscall::{SyscallId as Id, SyscallResult as Ret};
         use SchedulingEvent as Event;
 
-        let id = self.ctx.a(7).into();
+        let id: SyscallId = self.ctx.a(7).into();
         let args = [
             self.ctx.a(0),
             self.ctx.a(1),
@@ -53,6 +73,17 @@ impl TaskControlBlock {
             self.ctx.a(4),
             self.ctx.a(5),
         ];
+
+        // 统计系统调用次数（在处理前增加计数，这样 trace 查询时能包含本次调用）
+        let syscall_num = id.0;
+        unsafe {
+            if syscall_num < SYSCALL_COUNT_SIZE && self.task_id < MAX_TASKS {
+                SYSCALL_COUNTS[self.task_id][syscall_num] += 1;
+            }
+            // 设置当前任务 ID，让 trace 系统调用能访问当前任务的计数器
+            CURRENT_TASK_ID = self.task_id;
+        }
+
         match tg_syscall::handle(Caller { entity: 0, flow: 0 }, id, args) {
             Ret::Done(ret) => match id {
                 Id::EXIT => Event::Exit(self.ctx.a(0)),
@@ -71,3 +102,14 @@ impl TaskControlBlock {
         }
     }
 }
+
+/// 获取当前任务指定系统调用的调用次数
+pub fn get_syscall_count(syscall_id: usize) -> isize {
+    unsafe {
+        if syscall_id >= SYSCALL_COUNT_SIZE || CURRENT_TASK_ID >= MAX_TASKS {
+            -1
+        } else {
+            SYSCALL_COUNTS[CURRENT_TASK_ID][syscall_id] as isize
+        }
+    }
+}

ch4/src/main.rs

@@ -365,36 +365,129 @@ mod impls {
     }
 
     impl Trace for SyscallContext {
-        // TODO: 实现 trace 系统调用
+        // 实现 trace 系统调用
         #[inline]
-        fn trace(&self, _caller: Caller, _trace_request: usize, _id: usize, _data: usize) -> isize {
-            tg_console::log::info!("trace: not implemented");
-            -1
+        fn trace(&self, caller: tg_syscall::Caller, trace_request: usize, id: usize, data: usize) -> isize {
+            let process = unsafe { PROCESSES.get_mut().get(caller.entity) }.unwrap();
+            
+            match trace_request {
+                // 读取 id 地址处一个字节的值
+                0 => {
+                    // 检查地址是否用户可见且可读（需要 U、R、V 标志）
+                    const READABLE: VmFlags<Sv39> = VmFlags::build_from_str("U__RV");
+                    if let Some(ptr) = process.address_space.translate::<u8>(VAddr::new(id), READABLE) {
+                        unsafe { *ptr.as_ptr() as isize }
+                    } else {
+                        -1
+                    }
+                }
+                // 写入 data（作为 u8）到 id 地址处
+                1 => {
+                    // 检查地址是否用户可见且可写（需要 U、W、V 标志）
+                    const WRITABLE: VmFlags<Sv39> = VmFlags::build_from_str("U_WRV");
+                    if let Some(mut ptr) = process.address_space.translate::<u8>(VAddr::new(id), WRITABLE) {
+                        unsafe { *ptr.as_mut() = data as u8 };
+                        0
+                    } else {
+                        -1
+                    }
+                }
+                // 其他情况返回 -1
+                _ => -1,
+            }
         }
     }
 
     impl Memory for SyscallContext {
-        // TODO: 实现 mmap 系统调用
-        fn mmap(
-            &self,
-            _caller: Caller,
-            addr: usize,
-            len: usize,
-            prot: i32,
-            _flags: i32,
-            _fd: i32,
-            _offset: usize,
-        ) -> isize {
-            tg_console::log::info!(
-                "mmap: addr = {addr:#x}, len = {len}, prot = {prot}, not implemented"
-            );
-            -1
+        // 实现 mmap 系统调用
+        fn mmap(&self, caller: Caller, addr: usize, len: usize, prot: i32, _flags: i32, _fd: i32, _offset: usize) -> isize {
+            const PAGE_SIZE: usize = 1 << Sv39::PAGE_BITS;
+            
+            // 检查 addr 是否页对齐
+            if addr & (PAGE_SIZE - 1) != 0 {
+                return -1;
+            }
+            
+            // 检查 prot 参数
+            // prot & !0x7 != 0 (prot 其余位必须为 0)
+            if prot & !0x7 != 0 {
+                return -1;
+            }
+            // prot & 0x7 == 0 (这样的内存无意义)
+            if prot & 0x7 == 0 {
+                return -1;
+            }
+            
+            // len 为 0 时直接返回成功
+            if len == 0 {
+                return 0;
+            }
+            
+            // 计算页范围（向上取整）
+            let start_vpn = VPN::<Sv39>::new(addr >> Sv39::PAGE_BITS);
+            let end_addr = addr + len;
+            let end_vpn = VPN::<Sv39>::new((end_addr + PAGE_SIZE - 1) >> Sv39::PAGE_BITS);
+            let range = start_vpn..end_vpn;
+            
+            let process = unsafe { PROCESSES.get_mut().get_mut(caller.entity) }.unwrap();
+            
+            // 检查是否与已有映射重叠
+            if process.address_space.overlaps(&range) {
+                return -1;
+            }
+            
+            // 构建 VmFlags
+            // prot: bit 0 = 可读(R), bit 1 = 可写(W), bit 2 = 可执行(X)
+            // RISC-V PTE: bit 0 = V, bit 1 = R, bit 2 = W, bit 3 = X, bit 4 = U
+            let mut flags_str: [u8; 5] = *b"U___V";
+            if prot & 0x4 != 0 {
+                flags_str[1] = b'X';
+            }
+            if prot & 0x2 != 0 {
+                flags_str[2] = b'W';
+            }
+            if prot & 0x1 != 0 {
+                flags_str[3] = b'R';
+            }
+            let flags = VmFlags::build_from_str(unsafe { core::str::from_utf8_unchecked(&flags_str) });
+            
+            // 分配物理页并建立映射
+            process.address_space.map_alloc(range, flags);
+            
+            0
         }
 
-        // TODO: 实现 munmap 系统调用
-        fn munmap(&self, _caller: Caller, addr: usize, len: usize) -> isize {
-            tg_console::log::info!("munmap: addr = {addr:#x}, len = {len}, not implemented");
-            -1
+        // 实现 munmap 系统调用
+        fn munmap(&self, caller: Caller, addr: usize, len: usize) -> isize {
+            const PAGE_SIZE: usize = 1 << Sv39::PAGE_BITS;
+            
+            // 检查 addr 是否页对齐
+            if addr & (PAGE_SIZE - 1) != 0 {
+                return -1;
+            }
+            
+            // len 为 0 时直接返回成功
+            if len == 0 {
+                return 0;
+            }
+            
+            // 计算页范围（向上取整）
+            let start_vpn = VPN::<Sv39>::new(addr >> Sv39::PAGE_BITS);
+            let end_addr = addr + len;
+            let end_vpn = VPN::<Sv39>::new((end_addr + PAGE_SIZE - 1) >> Sv39::PAGE_BITS);
+            let range = start_vpn..end_vpn;
+            
+            let process = unsafe { PROCESSES.get_mut().get_mut(caller.entity) }.unwrap();
+            
+            // 检查该范围是否完全被映射
+            if !process.address_space.fully_mapped(&range) {
+                return -1;
+            }
+            
+            // 取消映射
+            process.address_space.unmap(range);
+            
+            0
         }
     }
 }