add ch3/ch4 test: ch3_trace, ch4_trace1

Author: scPointer

src/bin/ch3_taskinfo.rs

@@ -0,0 +1,48 @@
+#![no_std]
+#![no_main]
+
+extern crate user_lib;
+
+use user_lib::{
+    count_syscall, get_time, println, sleep, trace_read, trace_write,
+    SYSCALL_EXIT, SYSCALL_GETTIMEOFDAY, SYSCALL_TRACE, SYSCALL_WRITE, SYSCALL_YIELD
+};
+
+pub fn write_const(var: &u8, new_val: u8) {
+    trace_write(var as *const _, new_val);
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let t1 = get_time() as usize;
+    get_time();
+    sleep(500);
+    let t2 = get_time() as usize;
+    let t3 = get_time() as usize;
+    assert!(3 <= count_syscall(SYSCALL_GETTIMEOFDAY));
+    // 注意这次 sys_trace 调用本身也计入
+    assert_eq!(2, count_syscall(SYSCALL_TRACE));
+    assert_eq!(0, count_syscall(SYSCALL_WRITE));
+    assert!(0 < count_syscall(SYSCALL_YIELD));
+    assert_eq!(0, count_syscall(SYSCALL_EXIT));
+
+    // 想想为什么 write 调用是两次
+    println!("string from task trace test\n");
+    let t4 = get_time() as usize;
+    let t5 = get_time() as usize;
+    assert!(5 <= count_syscall(SYSCALL_GETTIMEOFDAY));
+    assert_eq!(7, count_syscall(SYSCALL_TRACE));
+    assert_eq!(2, count_syscall(SYSCALL_WRITE));
+    assert!(0 < count_syscall(SYSCALL_YIELD));
+    assert_eq!(0, count_syscall(SYSCALL_EXIT));
+
+    #[allow(unused_mut)]
+    let mut var = 111u8;
+    assert_eq!(Some(111), trace_read(&var as *const u8));
+    write_const(&var, (t1 ^ t2 ^ t3 ^ t4 ^ t5) as u8);
+    assert_eq!((t1 ^ t2 ^ t3 ^ t4 ^ t5) as u8, unsafe { core::ptr::read_volatile(&var) });
+
+    assert!(None != trace_read(main as *const _));
+    println!("Test trace OK!");
+    0
+}

src/bin/ch3_trace.rs

@@ -0,0 +1,38 @@
+#![no_std]
+#![no_main]
+
+extern crate user_lib;
+
+use user_lib::{println, trace_read, trace_write, mmap, munmap};
+
+#[no_mangle]
+pub fn main() -> usize {
+    #[allow(unused_mut)]
+    let mut var = 111u8;
+    assert_eq!(Some(111), trace_read(&var as *const _));
+    var = 22;
+    assert_eq!(Some(22), trace_read(&var as *const _));
+    assert_eq!(0, trace_write(&var as *const _, 33));
+
+    assert_eq!(None, trace_read(usize::MAX as *const _));
+    assert_eq!(-1, trace_write(usize::MAX as *const _, 0));
+    assert_eq!(None, trace_read(0x80200000 as *const _));
+    assert_eq!(-1, trace_write(0x80200000 as *const _, 0));
+    
+    let start: usize = 0x10000000;
+    let len: usize = 4096;
+    let prot: usize = 1; // READONLY
+
+    assert_eq!(0, mmap(start, len, prot));
+
+    assert!(None != trace_read(start as *const u8));
+    assert_eq!(-1, trace_write(start as *const u8, 0));
+
+    assert_eq!(0, munmap(start, len));
+
+    assert_eq!(None, trace_read(start as *const u8));
+    assert_eq!(-1, trace_write(start as *const u8, 0));
+
+    println!("Test trace_1 OK!");
+    0
+}

src/bin/ch4_trace1.rs

@@ -106,29 +106,11 @@ pub enum TaskStatus {
     Exited,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub struct SyscallInfo {
-    pub id: usize,
-    pub times: usize,
-}
-
-const MAX_SYSCALL_NUM: usize = 500;
-
-#[derive(Debug)]
-pub struct TaskInfo {
-    pub status: TaskStatus,
-    pub syscall_times: [u32; MAX_SYSCALL_NUM],
-    pub time: usize,
-}
-
-impl TaskInfo {
-    pub fn new() -> Self {
-        TaskInfo {
-            status: TaskStatus::UnInit,
-            syscall_times: [0; MAX_SYSCALL_NUM],
-            time: 0,
-        }
-    }
+#[repr(C)]
+pub enum TraceRequest {
+    Read,
+    Write,
+    Syscall,
 }
 
 #[repr(C)]
@@ -307,8 +289,23 @@ pub fn pipe(pipe_fd: &mut [usize]) -> isize {
     sys_pipe(pipe_fd)
 }
 
-pub fn task_info(info: &mut TaskInfo) -> isize {
-    sys_task_info(info)
+pub fn trace(request: TraceRequest, id: usize, data: usize) -> isize {
+    sys_trace(request as usize, id, data)
+}
+
+pub fn trace_read(addr: *const u8) -> Option<u8> {
+    match trace(TraceRequest::Read, addr as usize, 0) {
+        -1 => None,
+        data => Some(data as u8),
+    }
+}
+
+pub fn trace_write(addr: *const u8, data: u8) -> isize {
+    trace(TraceRequest::Write, addr as usize, data as usize)
+}
+
+pub fn count_syscall(id: usize) -> isize {
+    trace(TraceRequest::Syscall, id, 0)
 }
 
 pub fn thread_create(entry: usize, arg: usize) -> isize {
@@ -461,7 +458,7 @@ pub fn sigaction(
     sys_sigaction(
         signum,
         action.map_or(core::ptr::null(), |a| a),
-        old_action.map_or(core::ptr::null_mut(), |a| a)
+        old_action.map_or(core::ptr::null_mut(), |a| a),
     )
 }
 
@@ -471,4 +468,4 @@ pub fn sigprocmask(mask: u32) -> isize {
 
 pub fn sigreturn() -> isize {
     sys_sigreturn()
-}
+}

src/lib.rs

@@ -1,4 +1,4 @@
-use crate::{TaskInfo, SignalAction};
+use crate::SignalAction;
 
 use super::{Stat, TimeVal};
 
@@ -31,7 +31,7 @@ pub const SYSCALL_MAIL_READ: usize = 401;
 pub const SYSCALL_MAIL_WRITE: usize = 402;
 pub const SYSCALL_DUP: usize = 24;
 pub const SYSCALL_PIPE: usize = 59;
-pub const SYSCALL_TASK_INFO: usize = 410;
+pub const SYSCALL_TRACE: usize = 410;
 pub const SYSCALL_THREAD_CREATE: usize = 460;
 pub const SYSCALL_WAITTID: usize = 462;
 pub const SYSCALL_MUTEX_CREATE: usize = 463;
@@ -210,8 +210,8 @@ pub fn sys_pipe(pipe: &mut [usize]) -> isize {
     syscall(SYSCALL_PIPE, [pipe.as_mut_ptr() as usize, 0, 0])
 }
 
-pub fn sys_task_info(info: &mut TaskInfo) -> isize {
-    syscall(SYSCALL_TASK_INFO, [info as *const _ as usize, 0, 0])
+pub fn sys_trace(trace_request: usize, id: usize, data: usize) -> isize {
+    syscall(SYSCALL_TRACE, [trace_request, id, data])
 }
 
 pub fn sys_thread_create(entry: usize, arg: usize) -> isize {
@@ -273,11 +273,7 @@ pub fn sys_sigaction(
 ) -> isize {
     syscall(
         SYSCALL_SIGACTION,
-        [
-            signum as usize,
-            action as usize,
-            old_action as usize,
-        ],
+        [signum as usize, action as usize, old_action as usize],
     )
 }