Support signal mechanism for ch8(only works on signal-thread apps)

user/src/bin/cat.rs

@@ -15,7 +15,7 @@ pub fn main(argc: usize, argv: &[&str]) -> i32 {
         panic!("Error occured when opening file");
     }
     let fd = fd as usize;
-    let mut buf = [0u8; 16];
+    let mut buf = [0u8; 256];
     loop {
         let size = read(fd, &mut buf) as usize;
         if size == 0 {

user/src/bin/infloop.rs

@@ -0,0 +1,10 @@
+#![no_std]
+#![no_main]
+#![allow(clippy::empty_loop)]
+
+extern crate user_lib;
+
+#[no_mangle]
+pub fn main(_argc: usize, _argv: &[&str]) -> ! {
+    loop {}
+}

user/src/bin/priv_csr.rs

@@ -0,0 +1,17 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use riscv::register::sstatus::{self, SPP};
+
+#[no_mangle]
+fn main() -> i32 {
+    println!("Try to access privileged CSR in U Mode");
+    println!("Kernel should kill this application!");
+    unsafe {
+        sstatus::set_spp(SPP::User);
+    }
+    0
+}

user/src/bin/priv_inst.rs

@@ -0,0 +1,17 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use core::arch::asm;
+
+#[no_mangle]
+fn main() -> i32 {
+    println!("Try to execute privileged instruction in U Mode");
+    println!("Kernel should kill this application!");
+    unsafe {
+        asm!("sret");
+    }
+    0
+}

user/src/bin/store_fault.rs

@@ -0,0 +1,15 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+#[no_mangle]
+fn main() -> i32 {
+    println!("Into Test store_fault, we will insert an invalid store operation...");
+    println!("Kernel should kill this application!");
+    unsafe {
+        core::ptr::null_mut::<u8>().write_volatile(0);
+    }
+    0
+}

user/src/bin/until_timeout.rs

@@ -0,0 +1,46 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{exec, fork, get_time, kill, waitpid, waitpid_nb, SignalFlags};
+
+#[no_mangle]
+pub fn main(argc: usize, argv: &[&str]) -> i32 {
+    assert_eq!(argc, 3, "argc must be 3!");
+    let timeout_ms = argv[2]
+        .parse::<isize>()
+        .expect("Error when parsing timeout!");
+    let pid = fork() as usize;
+    if pid == 0 {
+        if exec(argv[1], &[core::ptr::null::<u8>()]) != 0 {
+            println!("Error when executing '{}'", argv[1]);
+            return -4;
+        }
+    } else {
+        let start_time = get_time();
+        let mut child_exited = false;
+        let mut exit_code: i32 = 0;
+        loop {
+            if get_time() - start_time > timeout_ms {
+                break;
+            }
+            if waitpid_nb(pid, &mut exit_code) as usize == pid {
+                child_exited = true;
+                println!(
+                    "child exited in {}ms, exit_code = {}",
+                    get_time() - start_time,
+                    exit_code,
+                );
+            }
+        }
+        if !child_exited {
+            println!("child has run for {}ms, kill it!", timeout_ms);
+            kill(pid, SignalFlags::SIGINT.bits());
+            assert_eq!(waitpid(pid, &mut exit_code) as usize, pid);
+            println!("exit code of the child is {}", exit_code);
+        }
+    }
+    0
+}