add cargo fmt in Makefile, and exec make fmt

wait child exit in forktree

.github/workflows/doc-and-test.yml

@@ -0,0 +1,66 @@
+name: Build Rust Doc And Run tests
+
+on: [push]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build-doc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly-2022-04-11
+          components: rust-src, llvm-tools-preview
+          target: riscv64gc-unknown-none-elf
+      - name: Build doc
+        run: cd os && cargo doc --no-deps --verbose
+      - name: Deploy to Github Pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./os/target/riscv64gc-unknown-none-elf/doc
+          destination_dir: ${{ github.ref_name }}
+
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly-2022-04-11
+          components: rust-src, llvm-tools-preview
+          target: riscv64gc-unknown-none-elf
+      - uses: actions-rs/install@v0.1
+        with:
+          crate: cargo-binutils
+          version: latest
+          use-tool-cache: true
+      - name: Cache QEMU
+        uses: actions/cache@v3
+        with:
+          path: qemu-7.0.0
+          key: qemu-7.0.0-x86_64-riscv64
+      - name: Install QEMU
+        run: |
+          sudo apt-get update
+          sudo apt-get install ninja-build -y
+          if [ ! -d qemu-7.0.0 ]; then
+            wget https://download.qemu.org/qemu-7.0.0.tar.xz
+            tar -xf qemu-7.0.0.tar.xz
+            cd qemu-7.0.0
+            ./configure --target-list=riscv64-softmmu
+            make -j
+          else
+            cd qemu-7.0.0
+          fi
+          sudo make install
+          qemu-system-riscv64 --version
+
+      - name: Run usertests
+        run: cd os && make run TEST=1
+        timeout-minutes: 10

.gitignore

@@ -1,16 +1,13 @@
-.idea/*
-os/target/*
-os/.idea/*
+.*/*
+!.github/*
+!.vscode/settings.json
+
+**/target/
+**/Cargo.lock
+
 os/src/link_app.S
 os/src/linker.ld
 os/last-*
-os/Cargo.lock
-user/target/*
-user/.idea/*
-user/Cargo.lock
-easy-fs/Cargo.lock
-easy-fs/target/*
-easy-fs-fuse/Cargo.lock
-easy-fs-fuse/target/*
+os/.gdb_history
 tools/
 pushall.sh

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    // Prevent "can't find crate for `test`" error on no_std
+    // Ref: https://github.com/rust-lang/vscode-rust/issues/729
+    // For vscode-rust plugin users:
+    "rust.target": "riscv64gc-unknown-none-elf",
+    "rust.all_targets": false,
+    // For Rust Analyzer plugin users:
+    "rust-analyzer.cargo.target": "riscv64gc-unknown-none-elf",
+    "rust-analyzer.checkOnSave.allTargets": false
+}

Makefile

@@ -6,3 +6,5 @@ docker:
 
 build_docker: 
 	docker build -t ${DOCKER_NAME} .
+fmt:
+	cd easy-fs; cargo fmt; cd ../easy-fs-fuse cargo fmt; cd ../os ; cargo fmt; cd ../user; cargo fmt; cd ..

README.md

@@ -1,8 +1,14 @@
 # rCore-Tutorial-v3
 rCore-Tutorial version 3.5. See the [Documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/).
 
+rCore-Tutorial API Docs.  See the [API Docs of Ten OSes ](#OS-API-DOCS)
+
+If you don't know  Rust Language and try to learn it, please visit [Rust Learning Resources](https://github.com/rcore-os/rCore/wiki/study-resource-of-system-programming-in-RUST)
+
+Official QQ group number: 735045051
+
 ## news
-- 2021.11.20: Now we are updating our labs. Please checkout chX-dev Branches for our current new labs. (Notice: please see the [Dependency] section in the end of this doc)
+- 25/01/2022: Version 3.6.0 is on the way! Now we directly update the code on chX branches, please periodically check if there are any updates.
 
 ## Overview
 
@@ -12,7 +18,7 @@ This project aims to show how to write an **Unix-like OS** running on **RISC-V**
 
 * Platform supported: `qemu-system-riscv64` simulator or dev boards based on [Kendryte K210 SoC](https://canaan.io/product/kendryteai) such as [Maix Dock](https://www.seeedstudio.com/Sipeed-MAIX-Dock-p-4815.html)
 * OS
-  * concurrency of multiple processes
+  * concurrency of multiple processes each of which contains mutiple native threads
   * preemptive scheduling(Round-Robin algorithm)
   * dynamic memory management in kernel
   * virtual memory
@@ -21,15 +27,237 @@ This project aims to show how to write an **Unix-like OS** running on **RISC-V**
 * **only 4K+ LoC**
 * [A detailed documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/) in spite of the lack of comments in the code(English version is not available at present)
 
+## Prerequisites
+
+### Install Rust
+
+See [official guide](https://www.rust-lang.org/tools/install).
+
+Install some tools:
+
+```sh
+$ rustup target add riscv64gc-unknown-none-elf
+$ cargo install cargo-binutils --vers =0.3.3
+$ rustup component add llvm-tools-preview
+$ rustup component add rust-src
+```
+
+### Install Qemu
+
+Here we manually compile and install Qemu 5.0.0. For example, on Ubuntu 18.04:
+
+```sh
+# install dependency packages
+$ sudo apt install autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev \
+              gawk build-essential bison flex texinfo gperf libtool patchutils bc \
+              zlib1g-dev libexpat-dev pkg-config  libglib2.0-dev libpixman-1-dev git tmux python3 python3-pip
+# download Qemu source code
+$ wget https://download.qemu.org/qemu-5.0.0.tar.xz
+# extract to qemu-5.0.0/
+$ tar xvJf qemu-5.0.0.tar.xz
+$ cd qemu-5.0.0
+# build
+$ ./configure --target-list=riscv64-softmmu,riscv64-linux-user
+$ make -j$(nproc)
+```
+
+Then, add following contents to `~/.bashrc`(please adjust these paths according to your environment):
+
+```
+export PATH=$PATH:/home/shinbokuow/Downloads/built/qemu-5.0.0
+export PATH=$PATH:/home/shinbokuow/Downloads/built/qemu-5.0.0/riscv64-softmmu
+export PATH=$PATH:/home/shinbokuow/Downloads/built/qemu-5.0.0/riscv64-linux-user
+```
+
+Finally, update the current shell:
+
+```sh
+$ source ~/.bashrc
+```
+
+Now we can check the version of Qemu:
+
+```sh
+$ qemu-system-riscv64 --version
+QEMU emulator version 5.0.0
+Copyright (c) 2003-2020 Fabrice Bellard and the QEMU Project developers
+```
+
+### Install RISC-V GNU Embedded Toolchain(including GDB)
+
+Download the compressed file according to your platform From [Sifive website](https://www.sifive.com/software)(Ctrl+F 'toolchain').
+
+Extract it and append the location of the 'bin' directory under its root directory to `$PATH`.
+
+For example, we can check the version of GDB:
+
+```sh
+$ riscv64-unknown-elf-gdb --version
+GNU gdb (SiFive GDB-Metal 10.1.0-2020.12.7) 10.1
+Copyright (C) 2020 Free Software Foundation, Inc.
+License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
+This is free software: you are free to change and redistribute it.
+There is NO WARRANTY, to the extent permitted by law.
+```
+
+### Install serial tools(Optional, if you want to run on K210)
+
+```sh
+$ pip3 install pyserial
+$ sudo apt install python3-serial
+```
+
 ## Run our project
 
-TODO:
+### Qemu
+
+```sh
+$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
+$ cd rCore-Tutorial-v3/os
+$ make run
+```
+
+After outputing some debug messages, the kernel lists all the applications available and enter the user shell:
+
+```
+/**** APPS ****
+mpsc_sem
+usertests
+pipetest
+forktest2
+cat
+initproc
+race_adder_loop
+threads_arg
+race_adder_mutex_spin
+race_adder_mutex_blocking
+forktree
+user_shell
+huge_write
+race_adder
+race_adder_atomic
+threads
+stack_overflow
+filetest_simple
+forktest_simple
+cmdline_args
+run_pipe_test
+forktest
+matrix
+exit
+fantastic_text
+sleep_simple
+yield
+hello_world
+pipe_large_test
+sleep
+phil_din_mutex
+**************/
+Rust user shell
+>> 
+```
+
+You can run any application except for `initproc` and `user_shell` itself. To run an application, just input its filename and hit enter. `usertests` can run a bunch of applications, thus it is recommended.
+
+Type `Ctrl+a` then `x` to exit Qemu.
+
+### K210
+
+Before chapter 6, you do not need a SD card:
+
+```sh
+$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
+$ cd rCore-Tutorial-v3/os
+$ make run BOARD=k210
+```
+
+From chapter 6, before running the kernel, we should insert a SD card into PC and manually write the filesystem image to it:
+
+```sh
+$ cd rCore-Tutorial-v3/os
+$ make sdcard
+```
+
+By default it will overwrite the device `/dev/sdb` which is the SD card, but you can provide another location. For example, `make sdcard SDCARD=/dev/sdc`.
+
+After that, remove the SD card from PC and insert it to the slot of K210. Connect the K210 to PC and then:
+
+```sh
+$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
+$ cd rCore-Tutorial-v3/os
+$ make run BOARD=k210
+```
+
+Type `Ctrl+]` to disconnect from K210.
+
+## Show runtime debug info of OS kernel version
+The branch of ch9-log contains a lot of debug info. You could try to run rcore tutorial 
+for understand the internal behavior of os kernel.
+
+```sh
+$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
+$ cd rCore-Tutorial-v3/os
+$ git checkout ch9-log
+$ make run
+......
+[rustsbi] RustSBI version 0.2.0-alpha.10, adapting to RISC-V SBI v0.3
+.______       __    __      _______.___________.  _______..______   __
+|   _  \     |  |  |  |    /       |           | /       ||   _  \ |  |
+|  |_)  |    |  |  |  |   |   (----`---|  |----`|   (----`|  |_)  ||  |
+|      /     |  |  |  |    \   \       |  |      \   \    |   _  < |  |
+|  |\  \----.|  `--'  |.----)   |      |  |  .----)   |   |  |_)  ||  |
+| _| `._____| \______/ |_______/       |__|  |_______/    |______/ |__|
+
+[rustsbi] Implementation: RustSBI-QEMU Version 0.0.2
+[rustsbi-dtb] Hart count: cluster0 with 1 cores
+[rustsbi] misa: RV64ACDFIMSU
+[rustsbi] mideleg: ssoft, stimer, sext (0x222)
+[rustsbi] medeleg: ima, ia, bkpt, la, sa, uecall, ipage, lpage, spage (0xb1ab)
+[rustsbi] pmp0: 0x10000000 ..= 0x10001fff (rw-)
+[rustsbi] pmp1: 0x2000000 ..= 0x200ffff (rw-)
+[rustsbi] pmp2: 0xc000000 ..= 0xc3fffff (rw-)
+[rustsbi] pmp3: 0x80000000 ..= 0x8fffffff (rwx)
+[rustsbi] enter supervisor 0x80200000
+[KERN] rust_main() begin
+[KERN] clear_bss() begin
+[KERN] clear_bss() end
+[KERN] mm::init() begin
+[KERN] mm::init_heap() begin
+[KERN] mm::init_heap() end
+[KERN] mm::init_frame_allocator() begin
+[KERN] mm::frame_allocator::lazy_static!FRAME_ALLOCATOR begin
+......
+```
+## Rustdoc
+
+Currently it can only help you view the code since only a tiny part of the code has been documented.
+
+You can open a doc html of `os` using `cargo doc --no-deps --open` under `os` directory.
+
+### OS-API-DOCS
+The API Docs for Ten OS
+1. [Lib-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch1/os/index.html)
+1. [Batch-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch2/os/index.html)
+1. [MultiProg-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch3-coop/os/index.html)
+1. [TimeSharing-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch3/os/index.html)
+1. [AddrSpace-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch4/os/index.html)
+1. [Process-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch5/os/index.html)
+1. [FileSystem-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch6/os/index.html)
+1. [IPC-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch7/os/index.html)
+1. [SyncMutex-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch8/os/index.html)
+1. [IODevice-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch9/os/index.html)
 
 ## Working in progress
 
-Now we are still updating our project, you can find latest changes on branches `chX-dev` such as `ch1-dev`. We are intended to publish first release 3.5.0 after completing most of the tasks mentioned below.
+Our first release 3.5.0 (chapter 1-7) has been published.
+
+There will be 9 chapters in our next release 3.6.0, where 2 new chapters will be added:
+* chapter 8: synchronization on a uniprocessor
+* chapter 9: I/O devices
 
-Overall progress: ch7
+Current version is 3.6.0-alpha.1 and we are still working on it.
+
+Here are the updates since 3.5.0:
 
 ### Completed
 
@@ -43,12 +271,18 @@ Overall progress: ch7
 * [x] flush all block cache to disk after a fs transaction which involves write operation
 * [x] replace `spin::Mutex` with `UPSafeCell` before SMP chapter
 * [x] add codes for a new chapter about synchronization & mutual exclusion(uniprocessor only)
+* [x] bug fix: we should call `find_pte` rather than `find_pte_create` in `PageTable::unmap`
+* [x] clarify: "check validity of level-3 pte in `find_pte` instead of checking it outside this function" should not be a bug
+* [x] code of chapter 8: synchronization on a uniprocessor
+* [x] switch the code of chapter 6 and chapter 7
+* [x] support signal mechanism in chapter 7/8(only works for apps with a single thread)
+* [x] Add boards/ directory and support rustdoc, for example you can use `cargo doc --no-deps --open` to view the documentation of a crate
 
 ### Todo(High priority)
 
-* [ ] support Allwinner's RISC-V D1 chip
-* [ ] bug fix: we should call `find_pte` rather than `find_pte_create` in `PageTable::unmap`
-* [ ] bug fix: check validity of level-3 pte in `find_pte` instead of checking it outside this function
+* [ ] review documentation, current progress: 5/9
+* [ ] support user-level sync primitives in chapter 8
+* [ ] code of chapter 9: device drivers based on interrupts, including UART and block devices
 * [ ] use old fs image optionally, do not always rebuild the image
 * [ ] add new system calls: getdents64/fstat
 * [ ] shell functionality improvement(to be continued...)
@@ -61,7 +295,6 @@ Overall progress: ch7
 * [ ] provide smooth debug experience at a Rust source code level
 * [ ] format the code using official tools
 
-
 ### Crates
 
 We will add them later.

easy-fs-fuse/src/main.rs

@@ -23,6 +23,8 @@ impl BlockDevice for BlockFile {
             .expect("Error when seeking!");
         assert_eq!(file.write(buf).unwrap(), BLOCK_SZ, "Not a complete block!");
     }
+
+    fn handle_irq(&self) { unimplemented!(); }
 }
 
 fn main() {

easy-fs/Cargo.toml

@@ -8,4 +8,7 @@ edition = "2018"
 
 [dependencies]
 spin = "0.7.0"
-lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+
+[profile.release]
+debug = true

easy-fs/src/block_dev.rs

@@ -3,4 +3,5 @@ use core::any::Any;
 pub trait BlockDevice: Send + Sync + Any {
     fn read_block(&self, block_id: usize, buf: &mut [u8]);
     fn write_block(&self, block_id: usize, buf: &[u8]);
+    fn handle_irq(&self);
 }

os/Cargo.toml

@@ -12,6 +12,7 @@ lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
 buddy_system_allocator = "0.6"
 bitflags = "1.2.1"
 xmas-elf = "0.7.0"
+volatile = "0.3"
 virtio-drivers = { git = "https://github.com/rcore-os/virtio-drivers" }
 k210-pac = { git = "https://github.com/wyfcyx/k210-pac" }
 k210-hal = { git = "https://github.com/wyfcyx/k210-hal" }
@@ -20,4 +21,7 @@ easy-fs = { path = "../easy-fs" }
 
 [features]
 board_qemu = []
-board_k210 = []
+board_k210 = []
+
+[profile.release]
+debug = true

os/Makefile

@@ -14,6 +14,11 @@ SBI ?= rustsbi
 BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
 K210_BOOTLOADER_SIZE := 131072
 
+# Building mode argument
+ifeq ($(MODE), release)
+	MODE_ARG := --release
+endif
+
 # KERNEL ENTRY
 ifeq ($(BOARD), qemu)
 	KERNEL_ENTRY_PA := 0x80200000
@@ -32,6 +37,9 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
 # Disassembly
 DISASM ?= -x
 
+# Run usertests or usershell
+TEST ?=
+
 build: env switch-check $(KERNEL_BIN) fs-img 
 
 switch-check:
@@ -56,7 +64,7 @@ $(KERNEL_BIN): kernel
 	@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
 
 fs-img: $(APPS)
-	@cd ../user && make build
+	@cd ../user && make build TEST=$(TEST)
 	@rm -f $(FS_IMG)
 	@cd ../easy-fs-fuse && cargo run --release -- -s ../user/src/bin/ -t ../user/target/riscv64gc-unknown-none-elf/release/
 
@@ -76,7 +84,7 @@ disasm: kernel
 
 disasm-vim: kernel
 	@$(OBJDUMP) $(DISASM) $(KERNEL_ELF) > $(DISASM_TMP)
-	@vim $(DISASM_TMP)
+	@nvim $(DISASM_TMP)
 	@rm $(DISASM_TMP)
 
 run: run-inner
@@ -106,4 +114,11 @@ debug: build
 		tmux split-window -h "riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'" && \
 		tmux -2 attach-session -d
 
-.PHONY: build env kernel clean disasm disasm-vim run-inner switch-check fs-img
+
+gdbserver: build
+	@qemu-system-riscv64 -machine virt -nographic -bios $(BOOTLOADER) -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) -s -S
+
+gdbclient:
+	@riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'
+
+.PHONY: build env kernel clean disasm disasm-vim run-inner switch-check fs-img gdbserver gdbclient

os/src/boards/k210.rs

@@ -21,3 +21,10 @@ pub const MMIO: &[(usize, usize)] = &[
 
 pub type BlockDeviceImpl = crate::drivers::block::SDCardWrapper;
 
+pub fn device_init() {
+    unimplemented!();
+}
+
+pub fn irq_handler() {
+    unimplemented!();
+}

os/src/boards/qemu.rs

@@ -1,6 +1,126 @@
 pub const CLOCK_FREQ: usize = 12500000;
 
-pub const MMIO: &[(usize, usize)] = &[(0x10001000, 0x1000)];
+pub const MMIO: &[(usize, usize)] = &[
+    (0x1000_0000, 0x1000),    // VIRT_UART0 in virt machine
+    (0x1000_1000, 0x1000),    // VIRT_VIRTIO in virt machine
+    (0x0C00_0000, 0x40_0000), // VIRT_PLIC in virt machine
+    (0x0010_0000, 0x00_2000), // VIRT_TEST/RTC  in virt machine
+];
 
 pub type BlockDeviceImpl = crate::drivers::block::VirtIOBlock;
+pub type CharDeviceImpl = crate::drivers::chardev::NS16550a<VIRT_UART>;
 
+pub const VIRT_PLIC: usize = 0xC00_0000;
+pub const VIRT_UART: usize = 0x1000_0000;
+
+use crate::drivers::block::BLOCK_DEVICE;
+use crate::drivers::chardev::{CharDevice, UART};
+use crate::drivers::plic::{IntrTargetPriority, PLIC};
+
+pub fn device_init() {
+    use riscv::register::sie;
+    let mut plic = unsafe { PLIC::new(VIRT_PLIC) };
+    let hart_id: usize = 0;
+    let supervisor = IntrTargetPriority::Supervisor;
+    let machine = IntrTargetPriority::Machine;
+    plic.set_threshold(hart_id, supervisor, 0);
+    plic.set_threshold(hart_id, machine, 1);
+    for intr_src_id in [1usize, 10] {
+        plic.enable(hart_id, supervisor, intr_src_id);
+        plic.set_priority(intr_src_id, 1);
+    }
+    unsafe {
+        sie::set_sext();
+    }
+}
+
+pub fn irq_handler() {
+    let mut plic = unsafe { PLIC::new(VIRT_PLIC) };
+    let intr_src_id = plic.claim(0, IntrTargetPriority::Supervisor);
+    match intr_src_id {
+        1 => BLOCK_DEVICE.handle_irq(),
+        10 => UART.handle_irq(),
+        _ => panic!("unsupported IRQ {}", intr_src_id),
+    }
+    plic.complete(0, IntrTargetPriority::Supervisor, intr_src_id);
+}
+
+//ref:: https://github.com/andre-richter/qemu-exit
+use core::arch::asm;
+
+const EXIT_SUCCESS: u32 = 0x5555; // Equals `exit(0)`. qemu successful exit
+
+const EXIT_FAILURE_FLAG: u32 = 0x3333;
+const EXIT_FAILURE: u32 = exit_code_encode(1); // Equals `exit(1)`. qemu failed exit
+const EXIT_RESET: u32 = 0x7777; // qemu reset
+
+pub trait QEMUExit {
+    /// Exit with specified return code.
+    ///
+    /// Note: For `X86`, code is binary-OR'ed with `0x1` inside QEMU.
+    fn exit(&self, code: u32) -> !;
+
+    /// Exit QEMU using `EXIT_SUCCESS`, aka `0`, if possible.
+    ///
+    /// Note: Not possible for `X86`.
+    fn exit_success(&self) -> !;
+
+    /// Exit QEMU using `EXIT_FAILURE`, aka `1`.
+    fn exit_failure(&self) -> !;
+}
+
+/// RISCV64 configuration
+pub struct RISCV64 {
+    /// Address of the sifive_test mapped device.
+    addr: u64,
+}
+
+/// Encode the exit code using EXIT_FAILURE_FLAG.
+const fn exit_code_encode(code: u32) -> u32 {
+    (code << 16) | EXIT_FAILURE_FLAG
+}
+
+impl RISCV64 {
+    /// Create an instance.
+    pub const fn new(addr: u64) -> Self {
+        RISCV64 { addr }
+    }
+}
+
+impl QEMUExit for RISCV64 {
+    /// Exit qemu with specified exit code.
+    fn exit(&self, code: u32) -> ! {
+        // If code is not a special value, we need to encode it with EXIT_FAILURE_FLAG.
+        let code_new = match code {
+            EXIT_SUCCESS | EXIT_FAILURE | EXIT_RESET => code,
+            _ => exit_code_encode(code),
+        };
+
+        unsafe {
+            asm!(
+                "sw {0}, 0({1})",
+                in(reg)code_new, in(reg)self.addr
+            );
+
+            // For the case that the QEMU exit attempt did not work, transition into an infinite
+            // loop. Calling `panic!()` here is unfeasible, since there is a good chance
+            // this function here is the last expression in the `panic!()` handler
+            // itself. This prevents a possible infinite loop.
+            loop {
+                asm!("wfi", options(nomem, nostack));
+            }
+        }
+    }
+
+    fn exit_success(&self) -> ! {
+        self.exit(EXIT_SUCCESS);
+    }
+
+    fn exit_failure(&self) -> ! {
+        self.exit(EXIT_FAILURE);
+    }
+}
+
+const VIRT_TEST: u64 = 0x100000;
+
+pub const QEMU_EXIT_HANDLE: RISCV64 = RISCV64::new(VIRT_TEST);

os/src/config.rs

@@ -11,4 +11,3 @@ pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
 pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
 
 pub use crate::board::{CLOCK_FREQ, MMIO};
-

os/src/console.rs

@@ -1,4 +1,4 @@
-use crate::sbi::console_putchar;
+use crate::drivers::chardev::{CharDevice, UART};
 use core::fmt::{self, Write};
 
 struct Stdout;
@@ -6,7 +6,7 @@ struct Stdout;
 impl Write for Stdout {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         for c in s.chars() {
-            console_putchar(c as usize);
+            UART.write(c as u8);
         }
         Ok(())
     }

os/src/drivers/block/mod.rs

@@ -1,13 +1,13 @@
 mod sdcard;
 mod virtio_blk;
 
-pub use virtio_blk::VirtIOBlock;
 pub use sdcard::SDCardWrapper;
+pub use virtio_blk::VirtIOBlock;
 
+use crate::board::BlockDeviceImpl;
 use alloc::sync::Arc;
 use easy_fs::BlockDevice;
 use lazy_static::*;
-use crate::board::BlockDeviceImpl;
 
 lazy_static! {
     pub static ref BLOCK_DEVICE: Arc<dyn BlockDevice> = Arc::new(BlockDeviceImpl::new());

os/src/drivers/block/sdcard.rs

@@ -3,7 +3,7 @@
 #![allow(unused)]
 
 use super::BlockDevice;
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use core::convert::TryInto;
 use k210_hal::prelude::*;
 use k210_pac::{Peripherals, SPI0};
@@ -321,14 +321,14 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
      * Get SD card data response.
      * @param  None
      * @retval The SD status: Read data response xxx0<status>1
-     *         - status 010: Data accecpted
+     *         - status 010: Data accepted
      *         - status 101: Data rejected due to a crc error
      *         - status 110: Data rejected due to a Write error.
      *         - status 111: Data rejected due to other error.
      */
     fn get_dataresponse(&self) -> u8 {
         let response = &mut [0u8];
-        /* Read resonse */
+        /* Read response */
         self.read_data(response);
         /* Mask unused bits */
         response[0] &= 0x1F;
@@ -423,7 +423,7 @@ impl</*'a,*/ X: SPI> SDCard</*'a,*/ X> {
             /* Byte 15 */
             CSD_CRC: (csd_tab[15] & 0xFE) >> 1,
             Reserved4: 1,
-            /* Return the reponse */
+            /* Return the response */
         })
     }
 
@@ -715,8 +715,8 @@ fn io_init() {
 }
 
 lazy_static! {
-    static ref PERIPHERALS: UPSafeCell<Peripherals> =
-        unsafe { UPSafeCell::new(Peripherals::take().unwrap()) };
+    static ref PERIPHERALS: UPIntrFreeCell<Peripherals> =
+        unsafe { UPIntrFreeCell::new(Peripherals::take().unwrap()) };
 }
 
 fn init_sdcard() -> SDCard<SPIImpl<SPI0>> {
@@ -740,11 +740,11 @@ fn init_sdcard() -> SDCard<SPIImpl<SPI0>> {
     sd
 }
 
-pub struct SDCardWrapper(UPSafeCell<SDCard<SPIImpl<SPI0>>>);
+pub struct SDCardWrapper(UPIntrFreeCell<SDCard<SPIImpl<SPI0>>>);
 
 impl SDCardWrapper {
     pub fn new() -> Self {
-        unsafe { Self(UPSafeCell::new(init_sdcard())) }
+        unsafe { Self(UPIntrFreeCell::new(init_sdcard())) }
     }
 }
 
@@ -761,4 +761,7 @@ impl BlockDevice for SDCardWrapper {
             .write_sector(buf, block_id as u32)
             .unwrap();
     }
+    fn handle_irq(&self) {
+        unimplemented!();
+    }
 }

os/src/drivers/block/virtio_blk.rs

@@ -3,42 +3,93 @@ use crate::mm::{
     frame_alloc, frame_dealloc, kernel_token, FrameTracker, PageTable, PhysAddr, PhysPageNum,
     StepByOne, VirtAddr,
 };
-use crate::sync::UPSafeCell;
+use crate::sync::{Condvar, UPIntrFreeCell};
+use crate::task::schedule;
+use crate::DEV_NON_BLOCKING_ACCESS;
+use alloc::collections::BTreeMap;
 use alloc::vec::Vec;
 use lazy_static::*;
-use virtio_drivers::{VirtIOBlk, VirtIOHeader};
+use virtio_drivers::{BlkResp, RespStatus, VirtIOBlk, VirtIOHeader};
 
 #[allow(unused)]
 const VIRTIO0: usize = 0x10001000;
 
-pub struct VirtIOBlock(UPSafeCell<VirtIOBlk<'static>>);
+pub struct VirtIOBlock {
+    virtio_blk: UPIntrFreeCell<VirtIOBlk<'static>>,
+    condvars: BTreeMap<u16, Condvar>,
+}
 
 lazy_static! {
-    static ref QUEUE_FRAMES: UPSafeCell<Vec<FrameTracker>> = unsafe { UPSafeCell::new(Vec::new()) };
+    static ref QUEUE_FRAMES: UPIntrFreeCell<Vec<FrameTracker>> =
+        unsafe { UPIntrFreeCell::new(Vec::new()) };
 }
 
 impl BlockDevice for VirtIOBlock {
     fn read_block(&self, block_id: usize, buf: &mut [u8]) {
-        self.0
-            .exclusive_access()
-            .read_block(block_id, buf)
-            .expect("Error when reading VirtIOBlk");
+        let nb = *DEV_NON_BLOCKING_ACCESS.exclusive_access();
+        if nb {
+            let mut resp = BlkResp::default();
+            let task_cx_ptr = self.virtio_blk.exclusive_session(|blk| {
+                let token = unsafe { blk.read_block_nb(block_id, buf, &mut resp).unwrap() };
+                self.condvars.get(&token).unwrap().wait_no_sched()
+            });
+            schedule(task_cx_ptr);
+            assert_eq!(
+                resp.status(),
+                RespStatus::Ok,
+                "Error when reading VirtIOBlk"
+            );
+        } else {
+            self.virtio_blk
+                .exclusive_access()
+                .read_block(block_id, buf)
+                .expect("Error when reading VirtIOBlk");
+        }
     }
     fn write_block(&self, block_id: usize, buf: &[u8]) {
-        self.0
-            .exclusive_access()
-            .write_block(block_id, buf)
-            .expect("Error when writing VirtIOBlk");
+        let nb = *DEV_NON_BLOCKING_ACCESS.exclusive_access();
+        if nb {
+            let mut resp = BlkResp::default();
+            let task_cx_ptr = self.virtio_blk.exclusive_session(|blk| {
+                let token = unsafe { blk.write_block_nb(block_id, buf, &mut resp).unwrap() };
+                self.condvars.get(&token).unwrap().wait_no_sched()
+            });
+            schedule(task_cx_ptr);
+            assert_eq!(
+                resp.status(),
+                RespStatus::Ok,
+                "Error when writing VirtIOBlk"
+            );
+        } else {
+            self.virtio_blk
+                .exclusive_access()
+                .write_block(block_id, buf)
+                .expect("Error when writing VirtIOBlk");
+        }
+    }
+    fn handle_irq(&self) {
+        self.virtio_blk.exclusive_session(|blk| {
+            while let Ok(token) = blk.pop_used() {
+                self.condvars.get(&token).unwrap().signal();
+            }
+        });
     }
 }
 
 impl VirtIOBlock {
-    #[allow(unused)]
     pub fn new() -> Self {
-        unsafe {
-            Self(UPSafeCell::new(
-                VirtIOBlk::new(&mut *(VIRTIO0 as *mut VirtIOHeader)).unwrap(),
-            ))
+        let virtio_blk = unsafe {
+            UPIntrFreeCell::new(VirtIOBlk::new(&mut *(VIRTIO0 as *mut VirtIOHeader)).unwrap())
+        };
+        let mut condvars = BTreeMap::new();
+        let channels = virtio_blk.exclusive_access().virt_queue_size();
+        for i in 0..channels {
+            let condvar = Condvar::new();
+            condvars.insert(i, condvar);
+        }
+        Self {
+            virtio_blk,
+            condvars,
         }
     }
 }

os/src/drivers/chardev/mod.rs

@@ -0,0 +1,17 @@
+mod ns16550a;
+
+pub use ns16550a::NS16550a;
+
+use crate::board::CharDeviceImpl;
+use alloc::sync::Arc;
+use lazy_static::*;
+
+pub trait CharDevice {
+    fn read(&self) -> u8;
+    fn write(&self, ch: u8);
+    fn handle_irq(&self);
+}
+
+lazy_static! {
+    pub static ref UART: Arc<CharDeviceImpl> = Arc::new(CharDeviceImpl::new());
+}

os/src/drivers/chardev/ns16550a.rs

@@ -0,0 +1,175 @@
+///! Ref: https://www.lammertbies.nl/comm/info/serial-uart
+///! Ref: ns16550a datasheet: https://datasheetspdf.com/pdf-file/605590/NationalSemiconductor/NS16550A/1
+///! Ref: ns16450 datasheet: https://datasheetspdf.com/pdf-file/1311818/NationalSemiconductor/NS16450/1
+use super::CharDevice;
+use crate::sync::{Condvar, UPIntrFreeCell};
+use crate::task::schedule;
+use alloc::collections::VecDeque;
+use bitflags::*;
+use volatile::{ReadOnly, Volatile, WriteOnly};
+
+bitflags! {
+    /// InterruptEnableRegister
+    pub struct IER: u8 {
+        const RX_AVAILABLE = 1 << 0;
+        const TX_EMPTY = 1 << 1;
+    }
+
+    /// LineStatusRegister
+    pub struct LSR: u8 {
+        const DATA_AVAILABLE = 1 << 0;
+        const THR_EMPTY = 1 << 5;
+    }
+
+    /// Model Control Register
+    pub struct MCR: u8 {
+        const DATA_TERMINAL_READY = 1 << 0;
+        const REQUEST_TO_SEND = 1 << 1;
+        const AUX_OUTPUT1 = 1 << 2;
+        const AUX_OUTPUT2 = 1 << 3;
+    }
+}
+
+#[repr(C)]
+#[allow(dead_code)]
+struct ReadWithoutDLAB {
+    /// receiver buffer register
+    pub rbr: ReadOnly<u8>,
+    /// interrupt enable register
+    pub ier: Volatile<IER>,
+    /// interrupt identification register
+    pub iir: ReadOnly<u8>,
+    /// line control register
+    pub lcr: Volatile<u8>,
+    /// model control register
+    pub mcr: Volatile<MCR>,
+    /// line status register
+    pub lsr: ReadOnly<LSR>,
+    /// ignore MSR
+    _padding1: ReadOnly<u8>,
+    /// ignore SCR
+    _padding2: ReadOnly<u8>,
+}
+
+#[repr(C)]
+#[allow(dead_code)]
+struct WriteWithoutDLAB {
+    /// transmitter holding register
+    pub thr: WriteOnly<u8>,
+    /// interrupt enable register
+    pub ier: Volatile<IER>,
+    /// ignore FCR
+    _padding0: ReadOnly<u8>,
+    /// line control register
+    pub lcr: Volatile<u8>,
+    /// modem control register
+    pub mcr: Volatile<MCR>,
+    /// line status register
+    pub lsr: ReadOnly<LSR>,
+    /// ignore other registers
+    _padding1: ReadOnly<u16>,
+}
+
+pub struct NS16550aRaw {
+    base_addr: usize,
+}
+
+impl NS16550aRaw {
+    fn read_end(&mut self) -> &mut ReadWithoutDLAB {
+        unsafe { &mut *(self.base_addr as *mut ReadWithoutDLAB) }
+    }
+
+    fn write_end(&mut self) -> &mut WriteWithoutDLAB {
+        unsafe { &mut *(self.base_addr as *mut WriteWithoutDLAB) }
+    }
+
+    pub fn new(base_addr: usize) -> Self {
+        Self { base_addr }
+    }
+
+    pub fn init(&mut self) {
+        let read_end = self.read_end();
+        let mut mcr = MCR::empty();
+        mcr |= MCR::DATA_TERMINAL_READY;
+        mcr |= MCR::REQUEST_TO_SEND;
+        mcr |= MCR::AUX_OUTPUT2;
+        read_end.mcr.write(mcr);
+        let ier = IER::RX_AVAILABLE;
+        read_end.ier.write(ier);
+    }
+
+    pub fn read(&mut self) -> Option<u8> {
+        let read_end = self.read_end();
+        let lsr = read_end.lsr.read();
+        if lsr.contains(LSR::DATA_AVAILABLE) {
+            Some(read_end.rbr.read())
+        } else {
+            None
+        }
+    }
+
+    pub fn write(&mut self, ch: u8) {
+        let write_end = self.write_end();
+        loop {
+            if write_end.lsr.read().contains(LSR::THR_EMPTY) {
+                write_end.thr.write(ch);
+                break;
+            }
+        }
+    }
+}
+
+struct NS16550aInner {
+    ns16550a: NS16550aRaw,
+    read_buffer: VecDeque<u8>,
+}
+
+pub struct NS16550a<const BASE_ADDR: usize> {
+    inner: UPIntrFreeCell<NS16550aInner>,
+    condvar: Condvar,
+}
+
+impl<const BASE_ADDR: usize> NS16550a<BASE_ADDR> {
+    pub fn new() -> Self {
+        let mut inner = NS16550aInner {
+            ns16550a: NS16550aRaw::new(BASE_ADDR),
+            read_buffer: VecDeque::new(),
+        };
+        inner.ns16550a.init();
+        Self {
+            inner: unsafe { UPIntrFreeCell::new(inner) },
+            condvar: Condvar::new(),
+        }
+    }
+}
+
+impl<const BASE_ADDR: usize> CharDevice for NS16550a<BASE_ADDR> {
+    fn read(&self) -> u8 {
+        loop {
+            let mut inner = self.inner.exclusive_access();
+            if let Some(ch) = inner.read_buffer.pop_front() {
+                return ch;
+            } else {
+                let task_cx_ptr = self.condvar.wait_no_sched();
+                drop(inner);
+                schedule(task_cx_ptr);
+            }
+        }
+    }
+    fn write(&self, ch: u8) {
+        let mut inner = self.inner.exclusive_access();
+        inner.ns16550a.write(ch);
+    }
+    fn handle_irq(&self) {
+        let mut count = 0;
+        self.inner.exclusive_session(|inner| {
+            while let Some(ch) = inner.ns16550a.read() {
+                count += 1;
+                inner.read_buffer.push_back(ch);
+            }
+        });
+        if count > 0 {
+            self.condvar.signal();
+        }
+    }
+}

os/src/drivers/mod.rs

@@ -1,3 +1,6 @@
 pub mod block;
+pub mod chardev;
+pub mod plic;
 
 pub use block::BLOCK_DEVICE;
+pub use chardev::UART;

os/src/drivers/plic.rs

@@ -0,0 +1,124 @@
+#[allow(clippy::upper_case_acronyms)]
+pub struct PLIC {
+    base_addr: usize,
+}
+
+#[derive(Copy, Clone)]
+pub enum IntrTargetPriority {
+    Machine = 0,
+    Supervisor = 1,
+}
+
+impl IntrTargetPriority {
+    pub fn supported_number() -> usize {
+        2
+    }
+}
+
+impl PLIC {
+    fn priority_ptr(&self, intr_source_id: usize) -> *mut u32 {
+        assert!(intr_source_id > 0 && intr_source_id <= 132);
+        (self.base_addr + intr_source_id * 4) as *mut u32
+    }
+    fn hart_id_with_priority(hart_id: usize, target_priority: IntrTargetPriority) -> usize {
+        let priority_num = IntrTargetPriority::supported_number();
+        hart_id * priority_num + target_priority as usize
+    }
+    fn enable_ptr(
+        &self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+        intr_source_id: usize,
+    ) -> (*mut u32, usize) {
+        let id = Self::hart_id_with_priority(hart_id, target_priority);
+        let (reg_id, reg_shift) = (intr_source_id / 32, intr_source_id % 32);
+        (
+            (self.base_addr + 0x2000 + 0x80 * id + 0x4 * reg_id) as *mut u32,
+            reg_shift,
+        )
+    }
+    fn threshold_ptr_of_hart_with_priority(
+        &self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+    ) -> *mut u32 {
+        let id = Self::hart_id_with_priority(hart_id, target_priority);
+        (self.base_addr + 0x20_0000 + 0x1000 * id) as *mut u32
+    }
+    fn claim_comp_ptr_of_hart_with_priority(
+        &self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+    ) -> *mut u32 {
+        let id = Self::hart_id_with_priority(hart_id, target_priority);
+        (self.base_addr + 0x20_0004 + 0x1000 * id) as *mut u32
+    }
+    pub unsafe fn new(base_addr: usize) -> Self {
+        Self { base_addr }
+    }
+    pub fn set_priority(&mut self, intr_source_id: usize, priority: u32) {
+        assert!(priority < 8);
+        unsafe {
+            self.priority_ptr(intr_source_id).write_volatile(priority);
+        }
+    }
+    #[allow(unused)]
+    pub fn get_priority(&mut self, intr_source_id: usize) -> u32 {
+        unsafe { self.priority_ptr(intr_source_id).read_volatile() & 7 }
+    }
+    pub fn enable(
+        &mut self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+        intr_source_id: usize,
+    ) {
+        let (reg_ptr, shift) = self.enable_ptr(hart_id, target_priority, intr_source_id);
+        unsafe {
+            reg_ptr.write_volatile(reg_ptr.read_volatile() | 1 << shift);
+        }
+    }
+    #[allow(unused)]
+    pub fn disable(
+        &mut self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+        intr_source_id: usize,
+    ) {
+        let (reg_ptr, shift) = self.enable_ptr(hart_id, target_priority, intr_source_id);
+        unsafe {
+            reg_ptr.write_volatile(reg_ptr.read_volatile() & (!(1u32 << shift)));
+        }
+    }
+    pub fn set_threshold(
+        &mut self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+        threshold: u32,
+    ) {
+        assert!(threshold < 8);
+        let threshold_ptr = self.threshold_ptr_of_hart_with_priority(hart_id, target_priority);
+        unsafe {
+            threshold_ptr.write_volatile(threshold);
+        }
+    }
+    #[allow(unused)]
+    pub fn get_threshold(&mut self, hart_id: usize, target_priority: IntrTargetPriority) -> u32 {
+        let threshold_ptr = self.threshold_ptr_of_hart_with_priority(hart_id, target_priority);
+        unsafe { threshold_ptr.read_volatile() & 7 }
+    }
+    pub fn claim(&mut self, hart_id: usize, target_priority: IntrTargetPriority) -> u32 {
+        let claim_comp_ptr = self.claim_comp_ptr_of_hart_with_priority(hart_id, target_priority);
+        unsafe { claim_comp_ptr.read_volatile() }
+    }
+    pub fn complete(
+        &mut self,
+        hart_id: usize,
+        target_priority: IntrTargetPriority,
+        completion: u32,
+    ) {
+        let claim_comp_ptr = self.claim_comp_ptr_of_hart_with_priority(hart_id, target_priority);
+        unsafe {
+            claim_comp_ptr.write_volatile(completion);
+        }
+    }
+}

os/src/fs/inode.rs

@@ -1,7 +1,7 @@
 use super::File;
 use crate::drivers::BLOCK_DEVICE;
 use crate::mm::UserBuffer;
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use bitflags::*;
@@ -11,7 +11,7 @@ use lazy_static::*;
 pub struct OSInode {
     readable: bool,
     writable: bool,
-    inner: UPSafeCell<OSInodeInner>,
+    inner: UPIntrFreeCell<OSInodeInner>,
 }
 
 pub struct OSInodeInner {
@@ -24,7 +24,7 @@ impl OSInode {
         Self {
             readable,
             writable,
-            inner: unsafe { UPSafeCell::new(OSInodeInner { offset: 0, inode }) },
+            inner: unsafe { UPIntrFreeCell::new(OSInodeInner { offset: 0, inode }) },
         }
     }
     pub fn read_all(&self) -> Vec<u8> {

os/src/fs/pipe.rs

@@ -1,6 +1,6 @@
 use super::File;
 use crate::mm::UserBuffer;
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use alloc::sync::{Arc, Weak};
 
 use crate::task::suspend_current_and_run_next;
@@ -8,18 +8,18 @@ use crate::task::suspend_current_and_run_next;
 pub struct Pipe {
     readable: bool,
     writable: bool,
-    buffer: Arc<UPSafeCell<PipeRingBuffer>>,
+    buffer: Arc<UPIntrFreeCell<PipeRingBuffer>>,
 }
 
 impl Pipe {
-    pub fn read_end_with_buffer(buffer: Arc<UPSafeCell<PipeRingBuffer>>) -> Self {
+    pub fn read_end_with_buffer(buffer: Arc<UPIntrFreeCell<PipeRingBuffer>>) -> Self {
         Self {
             readable: true,
             writable: false,
             buffer,
         }
     }
-    pub fn write_end_with_buffer(buffer: Arc<UPSafeCell<PipeRingBuffer>>) -> Self {
+    pub fn write_end_with_buffer(buffer: Arc<UPIntrFreeCell<PipeRingBuffer>>) -> Self {
         Self {
             readable: false,
             writable: true,
@@ -98,7 +98,7 @@ impl PipeRingBuffer {
 
 /// Return (read_end, write_end)
 pub fn make_pipe() -> (Arc<Pipe>, Arc<Pipe>) {
-    let buffer = Arc::new(unsafe { UPSafeCell::new(PipeRingBuffer::new()) });
+    let buffer = Arc::new(unsafe { UPIntrFreeCell::new(PipeRingBuffer::new()) });
     let read_end = Arc::new(Pipe::read_end_with_buffer(buffer.clone()));
     let write_end = Arc::new(Pipe::write_end_with_buffer(buffer.clone()));
     buffer.exclusive_access().set_write_end(&write_end);

os/src/fs/stdio.rs

@@ -1,10 +1,8 @@
 use super::File;
+use crate::drivers::chardev::{CharDevice, UART};
 use crate::mm::UserBuffer;
-use crate::sbi::console_getchar;
-use crate::task::suspend_current_and_run_next;
 
 pub struct Stdin;
-
 pub struct Stdout;
 
 impl File for Stdin {
@@ -16,18 +14,8 @@ impl File for Stdin {
     }
     fn read(&self, mut user_buf: UserBuffer) -> usize {
         assert_eq!(user_buf.len(), 1);
-        // busy loop
-        let mut c: usize;
-        loop {
-            c = console_getchar();
-            if c == 0 {
-                suspend_current_and_run_next();
-                continue;
-            } else {
-                break;
-            }
-        }
-        let ch = c as u8;
+        //println!("before UART.read() in Stdin::read()");
+        let ch = UART.read();
         unsafe {
             user_buf.buffers[0].as_mut_ptr().write_volatile(ch);
         }

os/src/lang_items.rs

@@ -18,7 +18,7 @@ fn panic(info: &PanicInfo) -> ! {
     unsafe {
         backtrace();
     }
-    shutdown()
+    shutdown(255)
 }
 
 unsafe fn backtrace() {

os/src/main.rs

@@ -29,9 +29,7 @@ mod task;
 mod timer;
 mod trap;
 
-use core::arch::global_asm;
-
-global_asm!(include_str!("entry.asm"));
+core::arch::global_asm!(include_str!("entry.asm"));
 
 fn clear_bss() {
     extern "C" {
@@ -44,17 +42,25 @@ fn clear_bss() {
     }
 }
 
+use lazy_static::*;
+use sync::UPIntrFreeCell;
+
+lazy_static! {
+    pub static ref DEV_NON_BLOCKING_ACCESS: UPIntrFreeCell<bool> =
+        unsafe { UPIntrFreeCell::new(false) };
+}
+
 #[no_mangle]
 pub fn rust_main() -> ! {
     clear_bss();
-    println!("[kernel] Hello, world!");
     mm::init();
-    mm::remap_test();
     trap::init();
     trap::enable_timer_interrupt();
     timer::set_next_trigger();
+    board::device_init();
     fs::list_apps();
     task::add_initproc();
+    *DEV_NON_BLOCKING_ACCESS.exclusive_access() = true;
     task::run_tasks();
     panic!("Unreachable in rust_main!");
 }

os/src/mm/address.rs

@@ -83,7 +83,11 @@ impl From<PhysPageNum> for usize {
 }
 impl From<VirtAddr> for usize {
     fn from(v: VirtAddr) -> Self {
-        v.0
+        if v.0 >= (1 << (VA_WIDTH_SV39 - 1)) {
+            v.0 | (!((1 << VA_WIDTH_SV39) - 1))
+        } else {
+            v.0
+        }
     }
 }
 impl From<VirtPageNum> for usize {

os/src/mm/frame_allocator.rs

@@ -1,6 +1,6 @@
 use super::{PhysAddr, PhysPageNum};
 use crate::config::MEMORY_END;
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use alloc::vec::Vec;
 use core::fmt::{self, Debug, Formatter};
 use lazy_static::*;
@@ -83,8 +83,8 @@ impl FrameAllocator for StackFrameAllocator {
 type FrameAllocatorImpl = StackFrameAllocator;
 
 lazy_static! {
-    pub static ref FRAME_ALLOCATOR: UPSafeCell<FrameAllocatorImpl> =
-        unsafe { UPSafeCell::new(FrameAllocatorImpl::new()) };
+    pub static ref FRAME_ALLOCATOR: UPIntrFreeCell<FrameAllocatorImpl> =
+        unsafe { UPIntrFreeCell::new(FrameAllocatorImpl::new()) };
 }
 
 pub fn init_frame_allocator() {

os/src/mm/memory_set.rs

@@ -3,7 +3,7 @@ use super::{PTEFlags, PageTable, PageTableEntry};
 use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
 use super::{StepByOne, VPNRange};
 use crate::config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE};
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
@@ -25,8 +25,8 @@ extern "C" {
 }
 
 lazy_static! {
-    pub static ref KERNEL_SPACE: Arc<UPSafeCell<MemorySet>> =
-        Arc::new(unsafe { UPSafeCell::new(MemorySet::new_kernel()) });
+    pub static ref KERNEL_SPACE: Arc<UPIntrFreeCell<MemorySet>> =
+        Arc::new(unsafe { UPIntrFreeCell::new(MemorySet::new_kernel()) });
 }
 
 pub fn kernel_token() -> usize {
@@ -351,26 +351,20 @@ pub fn remap_test() {
     let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
     let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
     let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
-    assert!(
-        !kernel_space
-            .page_table
-            .translate(mid_text.floor())
-            .unwrap()
-            .writable(),
-    );
-    assert!(
-        !kernel_space
-            .page_table
-            .translate(mid_rodata.floor())
-            .unwrap()
-            .writable(),
-    );
-    assert!(
-        !kernel_space
-            .page_table
-            .translate(mid_data.floor())
-            .unwrap()
-            .executable(),
-    );
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_text.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_rodata.floor())
+        .unwrap()
+        .writable(),);
+    assert!(!kernel_space
+        .page_table
+        .translate(mid_data.floor())
+        .unwrap()
+        .executable(),);
     println!("remap_test passed!");
 }

os/src/sbi.rs

@@ -16,7 +16,7 @@ const SBI_SHUTDOWN: usize = 8;
 fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
     let mut ret;
     unsafe {
-        asm!(
+        core::arch::asm!(
             "ecall",
             inlateout("x10") arg0 => ret,
             in("x11") arg1,
@@ -39,7 +39,9 @@ pub fn console_getchar() -> usize {
     sbi_call(SBI_CONSOLE_GETCHAR, 0, 0, 0)
 }
 
-pub fn shutdown() -> ! {
-    sbi_call(SBI_SHUTDOWN, 0, 0, 0);
+use crate::board::QEMUExit;
+pub fn shutdown(exit_code: usize) -> ! {
+    //sbi_call(SBI_SHUTDOWN, exit_code, 0, 0);
+    crate::board::QEMU_EXIT_HANDLE.exit_failure();
     panic!("It should shutdown!");
 }

os/src/sync/condvar.rs

@@ -1,9 +1,12 @@
-use crate::sync::{Mutex, UPSafeCell};
-use crate::task::{add_task, block_current_and_run_next, current_task, TaskControlBlock};
+use crate::sync::{Mutex, UPIntrFreeCell};
+use crate::task::{
+    add_task, block_current_and_run_next, block_current_task, current_task, TaskContext,
+    TaskControlBlock,
+};
 use alloc::{collections::VecDeque, sync::Arc};
 
 pub struct Condvar {
-    pub inner: UPSafeCell<CondvarInner>,
+    pub inner: UPIntrFreeCell<CondvarInner>,
 }
 
 pub struct CondvarInner {
@@ -14,7 +17,7 @@ impl Condvar {
     pub fn new() -> Self {
         Self {
             inner: unsafe {
-                UPSafeCell::new(CondvarInner {
+                UPIntrFreeCell::new(CondvarInner {
                     wait_queue: VecDeque::new(),
                 })
             },
@@ -28,12 +31,28 @@ impl Condvar {
         }
     }
 
-    pub fn wait(&self, mutex: Arc<dyn Mutex>) {
-        mutex.unlock();
+    /*
+    pub fn wait(&self) {
         let mut inner = self.inner.exclusive_access();
         inner.wait_queue.push_back(current_task().unwrap());
         drop(inner);
         block_current_and_run_next();
+    }
+    */
+
+    pub fn wait_no_sched(&self) -> *mut TaskContext {
+        self.inner.exclusive_session(|inner| {
+            inner.wait_queue.push_back(current_task().unwrap());
+        });
+        block_current_task()
+    }
+
+    pub fn wait_with_mutex(&self, mutex: Arc<dyn Mutex>) {
+        mutex.unlock();
+        self.inner.exclusive_session(|inner| {
+            inner.wait_queue.push_back(current_task().unwrap());
+        });
+        block_current_and_run_next();
         mutex.lock();
     }
 }

os/src/sync/mod.rs

@@ -6,4 +6,4 @@ mod up;
 pub use condvar::Condvar;
 pub use mutex::{Mutex, MutexBlocking, MutexSpin};
 pub use semaphore::Semaphore;
-pub use up::UPSafeCell;
+pub use up::{UPIntrFreeCell, UPIntrRefMut};

os/src/sync/mutex.rs

@@ -1,4 +1,4 @@
-use super::UPSafeCell;
+use super::UPIntrFreeCell;
 use crate::task::TaskControlBlock;
 use crate::task::{add_task, current_task};
 use crate::task::{block_current_and_run_next, suspend_current_and_run_next};
@@ -10,13 +10,13 @@ pub trait Mutex: Sync + Send {
 }
 
 pub struct MutexSpin {
-    locked: UPSafeCell<bool>,
+    locked: UPIntrFreeCell<bool>,
 }
 
 impl MutexSpin {
     pub fn new() -> Self {
         Self {
-            locked: unsafe { UPSafeCell::new(false) },
+            locked: unsafe { UPIntrFreeCell::new(false) },
         }
     }
 }
@@ -43,7 +43,7 @@ impl Mutex for MutexSpin {
 }
 
 pub struct MutexBlocking {
-    inner: UPSafeCell<MutexBlockingInner>,
+    inner: UPIntrFreeCell<MutexBlockingInner>,
 }
 
 pub struct MutexBlockingInner {
@@ -55,7 +55,7 @@ impl MutexBlocking {
     pub fn new() -> Self {
         Self {
             inner: unsafe {
-                UPSafeCell::new(MutexBlockingInner {
+                UPIntrFreeCell::new(MutexBlockingInner {
                     locked: false,
                     wait_queue: VecDeque::new(),
                 })

os/src/sync/semaphore.rs

@@ -1,9 +1,9 @@
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use crate::task::{add_task, block_current_and_run_next, current_task, TaskControlBlock};
 use alloc::{collections::VecDeque, sync::Arc};
 
 pub struct Semaphore {
-    pub inner: UPSafeCell<SemaphoreInner>,
+    pub inner: UPIntrFreeCell<SemaphoreInner>,
 }
 
 pub struct SemaphoreInner {
@@ -15,7 +15,7 @@ impl Semaphore {
     pub fn new(res_count: usize) -> Self {
         Self {
             inner: unsafe {
-                UPSafeCell::new(SemaphoreInner {
+                UPIntrFreeCell::new(SemaphoreInner {
                     count: res_count as isize,
                     wait_queue: VecDeque::new(),
                 })

os/src/sync/up.rs

@@ -1,5 +1,9 @@
-use core::cell::{RefCell, RefMut};
+use core::cell::{RefCell, RefMut, UnsafeCell};
+use core::ops::{Deref, DerefMut};
+use lazy_static::*;
+use riscv::register::sstatus;
 
+/*
 /// Wrap a static data structure inside it so that we are
 /// able to access it without any `unsafe`.
 ///
@@ -27,3 +31,110 @@ impl<T> UPSafeCell<T> {
         self.inner.borrow_mut()
     }
 }
+*/
+
+pub struct UPSafeCellRaw<T> {
+    inner: UnsafeCell<T>,
+}
+
+unsafe impl<T> Sync for UPSafeCellRaw<T> {}
+
+impl<T> UPSafeCellRaw<T> {
+    pub unsafe fn new(value: T) -> Self {
+        Self {
+            inner: UnsafeCell::new(value),
+        }
+    }
+    pub fn get_mut(&self) -> &mut T {
+        unsafe { &mut (*self.inner.get()) }
+    }
+}
+
+pub struct IntrMaskingInfo {
+    nested_level: usize,
+    sie_before_masking: bool,
+}
+
+lazy_static! {
+    static ref INTR_MASKING_INFO: UPSafeCellRaw<IntrMaskingInfo> =
+        unsafe { UPSafeCellRaw::new(IntrMaskingInfo::new()) };
+}
+
+impl IntrMaskingInfo {
+    pub fn new() -> Self {
+        Self {
+            nested_level: 0,
+            sie_before_masking: false,
+        }
+    }
+
+    pub fn enter(&mut self) {
+        let sie = sstatus::read().sie();
+        unsafe {
+            sstatus::clear_sie();
+        }
+        if self.nested_level == 0 {
+            self.sie_before_masking = sie;
+        }
+        self.nested_level += 1;
+    }
+
+    pub fn exit(&mut self) {
+        self.nested_level -= 1;
+        if self.nested_level == 0 && self.sie_before_masking {
+            unsafe {
+                sstatus::set_sie();
+            }
+        }
+    }
+}
+
+pub struct UPIntrFreeCell<T> {
+    /// inner data
+    inner: RefCell<T>,
+}
+
+unsafe impl<T> Sync for UPIntrFreeCell<T> {}
+
+pub struct UPIntrRefMut<'a, T>(Option<RefMut<'a, T>>);
+
+impl<T> UPIntrFreeCell<T> {
+    pub unsafe fn new(value: T) -> Self {
+        Self {
+            inner: RefCell::new(value),
+        }
+    }
+
+    /// Panic if the data has been borrowed.
+    pub fn exclusive_access(&self) -> UPIntrRefMut<'_, T> {
+        INTR_MASKING_INFO.get_mut().enter();
+        UPIntrRefMut(Some(self.inner.borrow_mut()))
+    }
+
+    pub fn exclusive_session<F, V>(&self, f: F) -> V
+    where
+        F: FnOnce(&mut T) -> V,
+    {
+        let mut inner = self.exclusive_access();
+        f(inner.deref_mut())
+    }
+}
+
+impl<'a, T> Drop for UPIntrRefMut<'a, T> {
+    fn drop(&mut self) {
+        self.0 = None;
+        INTR_MASKING_INFO.get_mut().exit();
+    }
+}
+
+impl<'a, T> Deref for UPIntrRefMut<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref().unwrap().deref()
+    }
+}
+impl<'a, T> DerefMut for UPIntrRefMut<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.0.as_mut().unwrap().deref_mut()
+    }
+}

os/src/syscall/sync.rs

@@ -129,6 +129,6 @@ pub fn sys_condvar_wait(condvar_id: usize, mutex_id: usize) -> isize {
     let condvar = Arc::clone(process_inner.condvar_list[condvar_id].as_ref().unwrap());
     let mutex = Arc::clone(process_inner.mutex_list[mutex_id].as_ref().unwrap());
     drop(process_inner);
-    condvar.wait(mutex);
+    condvar.wait_with_mutex(mutex);
     0
 }

os/src/task/id.rs

@@ -1,7 +1,7 @@
 use super::ProcessControlBlock;
 use crate::config::{KERNEL_STACK_SIZE, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT_BASE, USER_STACK_SIZE};
 use crate::mm::{MapPermission, PhysPageNum, VirtAddr, KERNEL_SPACE};
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use alloc::{
     sync::{Arc, Weak},
     vec::Vec,
@@ -40,12 +40,14 @@ impl RecycleAllocator {
 }
 
 lazy_static! {
-    static ref PID_ALLOCATOR: UPSafeCell<RecycleAllocator> =
-        unsafe { UPSafeCell::new(RecycleAllocator::new()) };
-    static ref KSTACK_ALLOCATOR: UPSafeCell<RecycleAllocator> =
-        unsafe { UPSafeCell::new(RecycleAllocator::new()) };
+    static ref PID_ALLOCATOR: UPIntrFreeCell<RecycleAllocator> =
+        unsafe { UPIntrFreeCell::new(RecycleAllocator::new()) };
+    static ref KSTACK_ALLOCATOR: UPIntrFreeCell<RecycleAllocator> =
+        unsafe { UPIntrFreeCell::new(RecycleAllocator::new()) };
 }
 
+pub const IDLE_PID: usize = 0;
+
 pub struct PidHandle(pub usize);
 
 pub fn pid_alloc() -> PidHandle {

os/src/task/manager.rs

@@ -1,5 +1,5 @@
 use super::{ProcessControlBlock, TaskControlBlock};
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use alloc::collections::{BTreeMap, VecDeque};
 use alloc::sync::Arc;
 use lazy_static::*;
@@ -24,10 +24,10 @@ impl TaskManager {
 }
 
 lazy_static! {
-    pub static ref TASK_MANAGER: UPSafeCell<TaskManager> =
-        unsafe { UPSafeCell::new(TaskManager::new()) };
-    pub static ref PID2PCB: UPSafeCell<BTreeMap<usize, Arc<ProcessControlBlock>>> =
-        unsafe { UPSafeCell::new(BTreeMap::new()) };
+    pub static ref TASK_MANAGER: UPIntrFreeCell<TaskManager> =
+        unsafe { UPIntrFreeCell::new(TaskManager::new()) };
+    pub static ref PID2PCB: UPIntrFreeCell<BTreeMap<usize, Arc<ProcessControlBlock>>> =
+        unsafe { UPIntrFreeCell::new(BTreeMap::new()) };
 }
 
 pub fn add_task(task: Arc<TaskControlBlock>) {

os/src/task/mod.rs

@@ -8,15 +8,16 @@ mod switch;
 #[allow(clippy::module_inception)]
 mod task;
 
+use self::id::TaskUserRes;
 use crate::fs::{open_file, OpenFlags};
-use alloc::sync::Arc;
+use alloc::{sync::Arc, vec::Vec};
 use lazy_static::*;
 use manager::fetch_task;
 use process::ProcessControlBlock;
 use switch::__switch;
 
 pub use context::TaskContext;
-pub use id::{kstack_alloc, pid_alloc, KernelStack, PidHandle};
+pub use id::{kstack_alloc, pid_alloc, KernelStack, PidHandle, IDLE_PID};
 pub use manager::{add_task, pid2process, remove_from_pid2process};
 pub use processor::{
     current_kstack_top, current_process, current_task, current_trap_cx, current_trap_cx_user_va,
@@ -43,15 +44,21 @@ pub fn suspend_current_and_run_next() {
     schedule(task_cx_ptr);
 }
 
-pub fn block_current_and_run_next() {
+/// This function must be followed by a schedule
+pub fn block_current_task() -> *mut TaskContext {
     let task = take_current_task().unwrap();
     let mut task_inner = task.inner_exclusive_access();
-    let task_cx_ptr = &mut task_inner.task_cx as *mut TaskContext;
     task_inner.task_status = TaskStatus::Blocking;
-    drop(task_inner);
+    &mut task_inner.task_cx as *mut TaskContext
+}
+
+pub fn block_current_and_run_next() {
+    let task_cx_ptr = block_current_task();
     schedule(task_cx_ptr);
 }
 
+use crate::board::QEMUExit;
+
 pub fn exit_current_and_run_next(exit_code: i32) {
     let task = take_current_task().unwrap();
     let mut task_inner = task.inner_exclusive_access();
@@ -67,7 +74,21 @@ pub fn exit_current_and_run_next(exit_code: i32) {
     // however, if this is the main thread of current process
     // the process should terminate at once
     if tid == 0 {
-        remove_from_pid2process(process.getpid());
+        let pid = process.getpid();
+        if pid == IDLE_PID {
+            println!(
+                "[kernel] Idle process exit with exit_code {} ...",
+                exit_code
+            );
+            if exit_code != 0 {
+                //crate::sbi::shutdown(255); //255 == -1 for err hint
+                crate::board::QEMU_EXIT_HANDLE.exit_failure();
+            } else {
+                //crate::sbi::shutdown(0); //0 for success hint
+                crate::board::QEMU_EXIT_HANDLE.exit_success();
+            }
+        }
+        remove_from_pid2process(pid);
         let mut process_inner = process.inner_exclusive_access();
         // mark this process as a zombie process
         process_inner.is_zombie = true;
@@ -86,12 +107,21 @@ pub fn exit_current_and_run_next(exit_code: i32) {
         // deallocate user res (including tid/trap_cx/ustack) of all threads
         // it has to be done before we dealloc the whole memory_set
         // otherwise they will be deallocated twice
+        let mut recycle_res = Vec::<TaskUserRes>::new();
         for task in process_inner.tasks.iter().filter(|t| t.is_some()) {
             let task = task.as_ref().unwrap();
             let mut task_inner = task.inner_exclusive_access();
-            task_inner.res = None;
+            if let Some(res) = task_inner.res.take() {
+                recycle_res.push(res);
+            }
         }
+        // dealloc_tid and dealloc_user_res require access to PCB inner, so we
+        // need to collect those user res first, then release process_inner
+        // for now to avoid deadlock/double borrow problem.
+        drop(process_inner);
+        recycle_res.clear();
 
+        let mut process_inner = process.inner_exclusive_access();
         process_inner.children.clear();
         // deallocate other data in user space i.e. program code/data section
         process_inner.memory_set.recycle_data_pages();

os/src/task/process.rs

@@ -5,19 +5,18 @@ use super::{add_task, SignalFlags};
 use super::{pid_alloc, PidHandle};
 use crate::fs::{File, Stdin, Stdout};
 use crate::mm::{translated_refmut, MemorySet, KERNEL_SPACE};
-use crate::sync::{Condvar, Mutex, Semaphore, UPSafeCell};
+use crate::sync::{Condvar, Mutex, Semaphore, UPIntrFreeCell, UPIntrRefMut};
 use crate::trap::{trap_handler, TrapContext};
 use alloc::string::String;
 use alloc::sync::{Arc, Weak};
 use alloc::vec;
 use alloc::vec::Vec;
-use core::cell::RefMut;
 
 pub struct ProcessControlBlock {
     // immutable
     pub pid: PidHandle,
     // mutable
-    inner: UPSafeCell<ProcessControlBlockInner>,
+    inner: UPIntrFreeCell<ProcessControlBlockInner>,
 }
 
 pub struct ProcessControlBlockInner {
@@ -68,7 +67,7 @@ impl ProcessControlBlockInner {
 }
 
 impl ProcessControlBlock {
-    pub fn inner_exclusive_access(&self) -> RefMut<'_, ProcessControlBlockInner> {
+    pub fn inner_exclusive_access(&self) -> UPIntrRefMut<'_, ProcessControlBlockInner> {
         self.inner.exclusive_access()
     }
 
@@ -80,7 +79,7 @@ impl ProcessControlBlock {
         let process = Arc::new(Self {
             pid: pid_handle,
             inner: unsafe {
-                UPSafeCell::new(ProcessControlBlockInner {
+                UPIntrFreeCell::new(ProcessControlBlockInner {
                     is_zombie: false,
                     memory_set,
                     parent: None,
@@ -206,7 +205,7 @@ impl ProcessControlBlock {
         let child = Arc::new(Self {
             pid,
             inner: unsafe {
-                UPSafeCell::new(ProcessControlBlockInner {
+                UPIntrFreeCell::new(ProcessControlBlockInner {
                     is_zombie: false,
                     memory_set,
                     parent: Some(Arc::downgrade(self)),

os/src/task/processor.rs

@@ -1,7 +1,7 @@
 use super::__switch;
 use super::{fetch_task, TaskStatus};
 use super::{ProcessControlBlock, TaskContext, TaskControlBlock};
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use crate::trap::TrapContext;
 use alloc::sync::Arc;
 use lazy_static::*;
@@ -30,7 +30,8 @@ impl Processor {
 }
 
 lazy_static! {
-    pub static ref PROCESSOR: UPSafeCell<Processor> = unsafe { UPSafeCell::new(Processor::new()) };
+    pub static ref PROCESSOR: UPIntrFreeCell<Processor> =
+        unsafe { UPIntrFreeCell::new(Processor::new()) };
 }
 
 pub fn run_tasks() {
@@ -39,11 +40,10 @@ pub fn run_tasks() {
         if let Some(task) = fetch_task() {
             let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
             // access coming task TCB exclusively
-            let mut task_inner = task.inner_exclusive_access();
-            let next_task_cx_ptr = &task_inner.task_cx as *const TaskContext;
-            task_inner.task_status = TaskStatus::Running;
-            drop(task_inner);
-            // release coming task TCB manually
+            let next_task_cx_ptr = task.inner.exclusive_session(|task_inner| {
+                task_inner.task_status = TaskStatus::Running;
+                &task_inner.task_cx as *const TaskContext
+            });
             processor.current = Some(task);
             // release processor manually
             drop(processor);
@@ -95,9 +95,8 @@ pub fn current_kstack_top() -> usize {
 }
 
 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();
-    drop(processor);
+    let idle_task_cx_ptr =
+        PROCESSOR.exclusive_session(|processor| processor.get_idle_task_cx_ptr());
     unsafe {
         __switch(switched_task_cx_ptr, idle_task_cx_ptr);
     }

os/src/task/task.rs

@@ -1,20 +1,22 @@
 use super::id::TaskUserRes;
 use super::{kstack_alloc, KernelStack, ProcessControlBlock, TaskContext};
 use crate::trap::TrapContext;
-use crate::{mm::PhysPageNum, sync::UPSafeCell};
+use crate::{
+    mm::PhysPageNum,
+    sync::{UPIntrFreeCell, UPIntrRefMut},
+};
 use alloc::sync::{Arc, Weak};
-use core::cell::RefMut;
 
 pub struct TaskControlBlock {
     // immutable
     pub process: Weak<ProcessControlBlock>,
     pub kstack: KernelStack,
     // mutable
-    inner: UPSafeCell<TaskControlBlockInner>,
+    pub inner: UPIntrFreeCell<TaskControlBlockInner>,
 }
 
 impl TaskControlBlock {
-    pub fn inner_exclusive_access(&self) -> RefMut<'_, TaskControlBlockInner> {
+    pub fn inner_exclusive_access(&self) -> UPIntrRefMut<'_, TaskControlBlockInner> {
         self.inner.exclusive_access()
     }
 
@@ -58,7 +60,7 @@ impl TaskControlBlock {
             process: Arc::downgrade(&process),
             kstack,
             inner: unsafe {
-                UPSafeCell::new(TaskControlBlockInner {
+                UPIntrFreeCell::new(TaskControlBlockInner {
                     res: Some(res),
                     trap_cx_ppn,
                     task_cx: TaskContext::goto_trap_return(kstack_top),

os/src/timer.rs

@@ -2,7 +2,7 @@ use core::cmp::Ordering;
 
 use crate::config::CLOCK_FREQ;
 use crate::sbi::set_timer;
-use crate::sync::UPSafeCell;
+use crate::sync::UPIntrFreeCell;
 use crate::task::{add_task, TaskControlBlock};
 use alloc::collections::BinaryHeap;
 use alloc::sync::Arc;
@@ -50,8 +50,8 @@ impl Ord for TimerCondVar {
 }
 
 lazy_static! {
-    static ref TIMERS: UPSafeCell<BinaryHeap<TimerCondVar>> =
-        unsafe { UPSafeCell::new(BinaryHeap::<TimerCondVar>::new()) };
+    static ref TIMERS: UPIntrFreeCell<BinaryHeap<TimerCondVar>> =
+        unsafe { UPIntrFreeCell::new(BinaryHeap::<TimerCondVar>::new()) };
 }
 
 pub fn add_timer(expire_ms: usize, task: Arc<TaskControlBlock>) {

os/src/trap/mod.rs

@@ -11,7 +11,7 @@ use core::arch::{asm, global_asm};
 use riscv::register::{
     mtvec::TrapMode,
     scause::{self, Exception, Interrupt, Trap},
-    sie, stval, stvec,
+    sie, sscratch, sstatus, stval, stvec,
 };
 
 global_asm!(include_str!("trap.S"));
@@ -21,8 +21,14 @@ pub fn init() {
 }
 
 fn set_kernel_trap_entry() {
+    extern "C" {
+        fn __alltraps();
+        fn __alltraps_k();
+    }
+    let __alltraps_k_va = __alltraps_k as usize - __alltraps as usize + TRAMPOLINE;
     unsafe {
-        stvec::write(trap_from_kernel as usize, TrapMode::Direct);
+        stvec::write(__alltraps_k_va, TrapMode::Direct);
+        sscratch::write(trap_from_kernel as usize);
     }
 }
 
@@ -38,16 +44,32 @@ pub fn enable_timer_interrupt() {
     }
 }
 
+fn enable_supervisor_interrupt() {
+    unsafe {
+        sstatus::set_sie();
+    }
+}
+
+fn disable_supervisor_interrupt() {
+    unsafe {
+        sstatus::clear_sie();
+    }
+}
+
 #[no_mangle]
 pub fn trap_handler() -> ! {
     set_kernel_trap_entry();
     let scause = scause::read();
     let stval = stval::read();
+    //println!("into {:?}", scause.cause());
     match scause.cause() {
         Trap::Exception(Exception::UserEnvCall) => {
             // jump to next instruction anyway
             let mut cx = current_trap_cx();
             cx.sepc += 4;
+
+            enable_supervisor_interrupt();
+
             // get system call return value
             let result = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]);
             // cx is changed during sys_exec, so we have to call it again
@@ -78,6 +100,9 @@ pub fn trap_handler() -> ! {
             check_timer();
             suspend_current_and_run_next();
         }
+        Trap::Interrupt(Interrupt::SupervisorExternal) => {
+            crate::board::irq_handler();
+        }
         _ => {
             panic!(
                 "Unsupported trap {:?}, stval = {:#x}!",
@@ -96,6 +121,7 @@ pub fn trap_handler() -> ! {
 
 #[no_mangle]
 pub fn trap_return() -> ! {
+    disable_supervisor_interrupt();
     set_user_trap_entry();
     let trap_cx_user_va = current_trap_cx_user_va();
     let user_satp = current_user_token();
@@ -104,6 +130,7 @@ pub fn trap_return() -> ! {
         fn __restore();
     }
     let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
+    //println!("before return");
     unsafe {
         asm!(
             "fence.i",
@@ -117,10 +144,26 @@ pub fn trap_return() -> ! {
 }
 
 #[no_mangle]
-pub fn trap_from_kernel() -> ! {
-    use riscv::register::sepc;
-    println!("stval = {:#x}, sepc = {:#x}", stval::read(), sepc::read());
-    panic!("a trap {:?} from kernel!", scause::read().cause());
+pub fn trap_from_kernel(_trap_cx: &TrapContext) {
+    let scause = scause::read();
+    let stval = stval::read();
+    match scause.cause() {
+        Trap::Interrupt(Interrupt::SupervisorExternal) => {
+            crate::board::irq_handler();
+        }
+        Trap::Interrupt(Interrupt::SupervisorTimer) => {
+            set_next_trigger();
+            check_timer();
+            // do not schedule now
+        }
+        _ => {
+            panic!(
+                "Unsupported trap from kernel: {:?}, stval = {:#x}!",
+                scause.cause(),
+                stval
+            );
+        }
+    }
 }
 
 pub use context::TrapContext;

os/src/trap/trap.S

@@ -8,6 +8,8 @@
     .section .text.trampoline
     .globl __alltraps
     .globl __restore
+    .globl __alltraps_k
+    .globl __restore_k
     .align 2
 __alltraps:
     csrrw sp, sscratch, sp
@@ -67,3 +69,36 @@ __restore:
     # back to user stack
     ld sp, 2*8(sp)
     sret
+
+    .align 2
+__alltraps_k:
+    addi sp, sp, -34*8 
+    sd x1, 1*8(sp)
+    sd x3, 3*8(sp)
+    .set n, 5
+    .rept 27
+        SAVE_GP %n
+        .set n, n+1
+    .endr
+    csrr t0, sstatus
+    csrr t1, sepc
+    sd t0, 32*8(sp)
+    sd t1, 33*8(sp)
+    mv a0, sp
+    csrr t2, sscratch
+    jalr t2
+
+__restore_k:
+    ld t0, 32*8(sp)
+    ld t1, 33*8(sp)
+    csrw sstatus, t0
+    csrw sepc, t1
+    ld x1, 1*8(sp)
+    ld x3, 3*8(sp)
+    .set n, 5
+    .rept 27
+        LOAD_GP %n
+        .set n, n+1
+    .endr
+    addi sp, sp, 34*8
+    sret

rust-toolchain

@@ -1 +1 @@
-nightly-2022-01-19
+nightly-2022-04-11

setenv.sh

@@ -0,0 +1,2 @@
+export PATH=$(rustc --print sysroot)/bin:$PATH
+export RUST_SRC_PATH=$(rustc --print sysroot)/lib/rustlib/src/rust/library/

user/Cargo.toml

@@ -10,3 +10,6 @@ edition = "2018"
 buddy_system_allocator = "0.6"
 bitflags = "1.2.1"
 riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
+
+[profile.release]
+debug = true

user/Makefile

@@ -8,9 +8,15 @@ BINS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%.bin, $(APPS))
 
 OBJDUMP := rust-objdump --arch-name=riscv64
 OBJCOPY := rust-objcopy --binary-architecture=riscv64
+CP := cp 
+
+TEST ?= 
 
 elf: $(APPS)
 	@cargo build --release
+ifeq ($(TEST), 1)
+	@$(CP) $(TARGET_DIR)/usertests $(TARGET_DIR)/initproc
+endif
 
 binary: elf
 	$(foreach elf, $(ELFS), $(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf));)

user/src/bin/cat.rs

@@ -9,10 +9,14 @@ use user_lib::{close, open, read, OpenFlags};
 
 #[no_mangle]
 pub fn main(argc: usize, argv: &[&str]) -> i32 {
+    println!("argc = {}", argc);
+    for (i, arg) in argv.iter().enumerate() {
+        println!("argv[{}] = {}", i, arg);
+    }
     assert!(argc == 2);
     let fd = open(argv[1], OpenFlags::RDONLY);
     if fd == -1 {
-        panic!("Error occured when opening file");
+        panic!("Error occurred when opening file");
     }
     let fd = fd as usize;
     let mut buf = [0u8; 256];

user/src/bin/eisenberg.rs

@@ -0,0 +1,138 @@
+#![no_std]
+#![no_main]
+#![feature(core_intrinsics)]
+
+#[macro_use]
+extern crate user_lib;
+extern crate alloc;
+extern crate core;
+
+use alloc::vec::Vec;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use user_lib::{exit, sleep, thread_create, waittid};
+
+const N: usize = 2;
+const THREAD_NUM: usize = 10;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum FlagState {
+    Out,
+    Want,
+    In,
+}
+
+static mut TURN: usize = 0;
+static mut FLAG: [FlagState; THREAD_NUM] = [FlagState::Out; THREAD_NUM];
+
+static GUARD: AtomicUsize = AtomicUsize::new(0);
+
+fn critical_test_enter() {
+    assert_eq!(GUARD.fetch_add(1, Ordering::SeqCst), 0);
+}
+
+fn critical_test_claim() {
+    assert_eq!(GUARD.load(Ordering::SeqCst), 1);
+}
+
+fn critical_test_exit() {
+    assert_eq!(GUARD.fetch_sub(1, Ordering::SeqCst), 1);
+}
+
+fn eisenberg_enter_critical(id: usize) {
+    /* announce that we want to enter */
+    loop {
+        println!("Thread[{}] try enter", id);
+        vstore!(&FLAG[id], FlagState::Want);
+        loop {
+            /* check if any with higher priority is `Want` or `In` */
+            let mut prior_thread: Option<usize> = None;
+            let turn = vload!(&TURN);
+            let ring_id = if id < turn { id + THREAD_NUM } else { id };
+            // FLAG.iter() may lead to some errors, use for-loop instead
+            for i in turn..ring_id {
+                if vload!(&FLAG[i % THREAD_NUM]) != FlagState::Out {
+                    prior_thread = Some(i % THREAD_NUM);
+                    break;
+                }
+            }
+            if prior_thread.is_none() {
+                break;
+            }
+            println!(
+                "Thread[{}]: prior thread {} exist, sleep and retry",
+                id,
+                prior_thread.unwrap()
+            );
+            sleep(1);
+        }
+        /* now tentatively claim the resource */
+        vstore!(&FLAG[id], FlagState::In);
+        /* enforce the order of `claim` and `conflict check`*/
+        memory_fence!();
+        /* check if anthor thread is also `In`, which imply a conflict*/
+        let mut conflict = false;
+        for i in 0..THREAD_NUM {
+            if i != id && vload!(&FLAG[i]) == FlagState::In {
+                conflict = true;
+            }
+        }
+        if !conflict {
+            break;
+        }
+        println!("Thread[{}]: CONFLECT!", id);
+        /* no need to sleep */
+    }
+    /* clain the trun */
+    vstore!(&TURN, id);
+    println!("Thread[{}] enter", id);
+}
+
+fn eisenberg_exit_critical(id: usize) {
+    /* find next one who wants to enter and give the turn to it*/
+    let mut next = id;
+    let ring_id = id + THREAD_NUM;
+    for i in (id + 1)..ring_id {
+        let idx = i % THREAD_NUM;
+        if vload!(&FLAG[idx]) == FlagState::Want {
+            next = idx;
+            break;
+        }
+    }
+    vstore!(&TURN, next);
+    /* All done */
+    vstore!(&FLAG[id], FlagState::Out);
+    println!("Thread[{}] exit, give turn to {}", id, next);
+}
+
+pub fn thread_fn(id: usize) -> ! {
+    println!("Thread[{}] init.", id);
+    for _ in 0..N {
+        eisenberg_enter_critical(id);
+        critical_test_enter();
+        for _ in 0..3 {
+            critical_test_claim();
+            sleep(2);
+        }
+        critical_test_exit();
+        eisenberg_exit_critical(id);
+    }
+    exit(0)
+}
+
+#[no_mangle]
+pub fn main() -> i32 {
+    let mut v = Vec::new();
+    // TODO: really shuffle
+    assert_eq!(THREAD_NUM, 10);
+    let shuffle: [usize; 10] = [0, 7, 4, 6, 2, 9, 8, 1, 3, 5];
+    for i in 0..THREAD_NUM {
+        v.push(thread_create(thread_fn as usize, shuffle[i]));
+    }
+    for tid in v.iter() {
+        let exit_code = waittid(*tid as usize);
+        assert_eq!(exit_code, 0, "thread conflict happened!");
+        println!("thread#{} exited with code {}", tid, exit_code);
+    }
+    println!("main thread exited.");
+    0
+}

user/src/bin/forktree.rs

@@ -4,7 +4,7 @@
 #[macro_use]
 extern crate user_lib;
 
-use user_lib::{exit, fork, getpid, sleep, yield_};
+use user_lib::{exit, fork, getpid, sleep, wait, yield_};
 
 const DEPTH: usize = 4;
 
@@ -27,11 +27,19 @@ fn fork_tree(cur: &str) {
     println!("pid{}: {}", getpid(), cur);
     fork_child(cur, '0');
     fork_child(cur, '1');
+    let mut exit_code: i32 = 0;
+    for _ in 0..2 {
+        wait(&mut exit_code);
+    }
 }
 
 #[no_mangle]
 pub fn main() -> i32 {
     fork_tree("");
+    let mut exit_code: i32 = 0;
+    for _ in 0..2 {
+        wait(&mut exit_code);
+    }
     sleep(3000);
     0
 }

user/src/bin/huge_write.rs

@@ -24,7 +24,7 @@ pub fn main() -> i32 {
     }
     close(f);
     let time_ms = (get_time() - start) as usize;
-    let speed_kbs = size_mb * 1000000 / time_ms;
+    let speed_kbs = (size_mb << 20) / time_ms;
     println!(
         "{}MiB written, time cost = {}ms, write speed = {}KiB/s",
         size_mb, time_ms, speed_kbs

user/src/bin/huge_write_mt.rs

@@ -0,0 +1,56 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+extern crate alloc;
+
+use alloc::{fmt::format, string::String, vec::Vec};
+use user_lib::{close, get_time, gettid, open, write, OpenFlags};
+use user_lib::{exit, thread_create, waittid};
+
+fn worker(size_kib: usize) {
+    let mut buffer = [0u8; 1024]; // 1KiB
+    for (i, ch) in buffer.iter_mut().enumerate() {
+        *ch = i as u8;
+    }
+    let filename = format(format_args!("testf{}\0", gettid()));
+    let f = open(filename.as_str(), OpenFlags::CREATE | OpenFlags::WRONLY);
+    if f < 0 {
+        panic!("Open test file failed!");
+    }
+    let f = f as usize;
+    for _ in 0..size_kib {
+        write(f, &buffer);
+    }
+    close(f);
+    exit(0)
+}
+
+#[no_mangle]
+pub fn main(argc: usize, argv: &[&str]) -> i32 {
+    assert_eq!(argc, 2, "wrong argument");
+    let size_mb = 1usize;
+    let size_kb = size_mb << 10;
+    let workers = argv[1].parse::<usize>().expect("wrong argument");
+    assert!(workers >= 1 && size_kb % workers == 0, "wrong argument");
+
+    let start = get_time();
+
+    let mut v = Vec::new();
+    let size_mb = 1usize;
+    for _ in 0..workers {
+        v.push(thread_create(worker as usize, size_kb / workers));
+    }
+    for tid in v.iter() {
+        assert_eq!(0, waittid(*tid as usize));
+    }
+
+    let time_ms = (get_time() - start) as usize;
+    let speed_kbs = size_kb * 1000 / time_ms;
+    println!(
+        "{}MiB written by {} threads, time cost = {}ms, write speed = {}KiB/s",
+        size_mb, workers, time_ms, speed_kbs
+    );
+    0
+}

user/src/bin/peterson.rs

@@ -0,0 +1,78 @@
+#![no_std]
+#![no_main]
+#![feature(core_intrinsics)]
+#![feature(asm)]
+
+#[macro_use]
+extern crate user_lib;
+extern crate alloc;
+extern crate core;
+
+use alloc::vec::Vec;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use user_lib::{exit, sleep, thread_create, waittid};
+const N: usize = 3;
+
+static mut TURN: usize = 0;
+static mut FLAG: [bool; 2] = [false; 2];
+static GUARD: AtomicUsize = AtomicUsize::new(0);
+
+fn critical_test_enter() {
+    assert_eq!(GUARD.fetch_add(1, Ordering::SeqCst), 0);
+}
+
+fn critical_test_claim() {
+    assert_eq!(GUARD.load(Ordering::SeqCst), 1);
+}
+
+fn critical_test_exit() {
+    assert_eq!(GUARD.fetch_sub(1, Ordering::SeqCst), 1);
+}
+
+fn peterson_enter_critical(id: usize, peer_id: usize) {
+    println!("Thread[{}] try enter", id);
+    vstore!(&FLAG[id], true);
+    vstore!(&TURN, peer_id);
+    memory_fence!();
+    while vload!(&FLAG[peer_id]) && vload!(&TURN) == peer_id {
+        println!("Thread[{}] enter fail", id);
+        sleep(1);
+        println!("Thread[{}] retry enter", id);
+    }
+    println!("Thread[{}] enter", id);
+}
+
+fn peterson_exit_critical(id: usize) {
+    vstore!(&FLAG[id], false);
+    println!("Thread[{}] exit", id);
+}
+
+pub fn thread_fn(id: usize) -> ! {
+    println!("Thread[{}] init.", id);
+    let peer_id: usize = id ^ 1;
+    for _ in 0..N {
+        peterson_enter_critical(id, peer_id);
+        critical_test_enter();
+        for _ in 0..3 {
+            critical_test_claim();
+            sleep(2);
+        }
+        critical_test_exit();
+        peterson_exit_critical(id);
+    }
+    exit(0)
+}
+
+#[no_mangle]
+pub fn main() -> i32 {
+    let mut v = Vec::new();
+    v.push(thread_create(thread_fn as usize, 0));
+    // v.push(thread_create(thread_fn as usize, 1));
+    for tid in v.iter() {
+        let exit_code = waittid(*tid as usize);
+        assert_eq!(exit_code, 0, "thread conflict happened!");
+        println!("thread#{} exited with code {}", tid, exit_code);
+    }
+    println!("main thread exited.");
+    0
+}

user/src/bin/race_adder_arg.rs

@@ -34,7 +34,10 @@ pub fn main(argc: usize, argv: &[&str]) -> i32 {
     } else if argc == 2 {
         count = argv[1].to_string().parse::<usize>().unwrap();
     } else {
-        println!("ERROR in argv");
+        println!(
+            "ERROR in argv, argc is {}, argv[0] {} , argv[1] {} , argv[2] {}",
+            argc, argv[0], argv[1], argv[2]
+        );
         exit(-1);
     }
 

user/src/bin/run_pipe_test.rs

@@ -8,7 +8,7 @@ use user_lib::{exec, fork, wait};
 
 #[no_mangle]
 pub fn main() -> i32 {
-    for i in 0..1000 {
+    for i in 0..50 {
         if fork() == 0 {
             exec("pipe_large_test\0", &[core::ptr::null::<u8>()]);
         } else {

user/src/bin/usertests.rs

@@ -4,40 +4,138 @@
 #[macro_use]
 extern crate user_lib;
 
-static TESTS: &[&str] = &[
-    "exit\0",
-    "fantastic_text\0",
-    "forktest\0",
-    "forktest2\0",
-    "forktest_simple\0",
-    "hello_world\0",
-    "matrix\0",
-    "sleep\0",
-    "sleep_simple\0",
-    "stack_overflow\0",
-    "yield\0",
+// not in SUCC_TESTS & FAIL_TESTS
+// count_lines, infloop, user_shell, usertests
+
+// item of TESTS : app_name(argv_0), argv_1, argv_2, argv_3, exit_code
+static SUCC_TESTS: &[(&str, &str, &str, &str, i32)] = &[
+    ("filetest_simple\0", "\0", "\0", "\0", 0),
+    ("cat\0", "filea\0", "\0", "\0", 0),
+    ("cmdline_args\0", "1\0", "2\0", "3\0", 0),
+    ("eisenberg\0", "\0", "\0", "\0", 0),
+    ("exit\0", "\0", "\0", "\0", 0),
+    ("fantastic_text\0", "\0", "\0", "\0", 0),
+    ("forktest_simple\0", "\0", "\0", "\0", 0),
+    ("forktest\0", "\0", "\0", "\0", 0),
+    ("forktest2\0", "\0", "\0", "\0", 0),
+    ("forktree\0", "\0", "\0", "\0", 0),
+    ("hello_world\0", "\0", "\0", "\0", 0),
+    ("huge_write\0", "\0", "\0", "\0", 0),
+    ("matrix\0", "\0", "\0", "\0", 0),
+    ("mpsc_sem\0", "\0", "\0", "\0", 0),
+    ("peterson\0", "\0", "\0", "\0", 0),
+    ("phil_din_mutex\0", "\0", "\0", "\0", 0),
+    ("pipe_large_test\0", "\0", "\0", "\0", 0),
+    ("pipetest\0", "\0", "\0", "\0", 0),
+    ("race_adder_arg\0", "3\0", "\0", "\0", 0),
+    ("race_adder_atomic\0", "\0", "\0", "\0", 0),
+    ("race_adder_mutex_blocking\0", "\0", "\0", "\0", 0),
+    ("race_adder_mutex_spin\0", "\0", "\0", "\0", 0),
+    ("run_pipe_test\0", "\0", "\0", "\0", 0),
+    ("sleep_simple\0", "\0", "\0", "\0", 0),
+    ("sleep\0", "\0", "\0", "\0", 0),
+    ("sleep_simple\0", "\0", "\0", "\0", 0),
+    ("sync_sem\0", "\0", "\0", "\0", 0),
+    ("test_condvar\0", "\0", "\0", "\0", 0),
+    ("threads_arg\0", "\0", "\0", "\0", 0),
+    ("threads\0", "\0", "\0", "\0", 0),
+    ("yield\0", "\0", "\0", "\0", 0),
+];
+
+static FAIL_TESTS: &[(&str, &str, &str, &str, i32)] = &[
+    ("stack_overflow\0", "\0", "\0", "\0", -11),
+    ("race_adder_loop\0", "\0", "\0", "\0", -6),
+    ("priv_csr\0", "\0", "\0", "\0", -4),
+    ("priv_inst\0", "\0", "\0", "\0", -4),
+    ("store_fault\0", "\0", "\0", "\0", -11),
+    ("until_timeout\0", "\0", "\0", "\0", -6),
+    ("race_adder\0", "\0", "\0", "\0", -6),
+    ("huge_write_mt\0", "\0", "\0", "\0", -6),
 ];
 
 use user_lib::{exec, fork, waitpid};
 
-#[no_mangle]
-pub fn main() -> i32 {
-    for test in TESTS {
-        println!("Usertests: Running {}", test);
+fn run_tests(tests: &[(&str, &str, &str, &str, i32)]) -> i32 {
+    let mut pass_num = 0;
+    let mut arr: [*const u8; 4] = [
+        core::ptr::null::<u8>(),
+        core::ptr::null::<u8>(),
+        core::ptr::null::<u8>(),
+        core::ptr::null::<u8>(),
+    ];
+
+    for test in tests {
+        println!("Usertests: Running {}", test.0);
+        arr[0] = test.0.as_ptr();
+        if test.1 != "\0" {
+            arr[1] = test.1.as_ptr();
+            arr[2] = core::ptr::null::<u8>();
+            arr[3] = core::ptr::null::<u8>();
+            if test.2 != "\0" {
+                arr[2] = test.2.as_ptr();
+                arr[3] = core::ptr::null::<u8>();
+                if test.3 != "\0" {
+                    arr[3] = test.3.as_ptr();
+                } else {
+                    arr[3] = core::ptr::null::<u8>();
+                }
+            } else {
+                arr[2] = core::ptr::null::<u8>();
+                arr[3] = core::ptr::null::<u8>();
+            }
+        } else {
+            arr[1] = core::ptr::null::<u8>();
+            arr[2] = core::ptr::null::<u8>();
+            arr[3] = core::ptr::null::<u8>();
+        }
+
         let pid = fork();
         if pid == 0 {
-            exec(*test, &[core::ptr::null::<u8>()]);
+            exec(test.0, &arr[..]);
             panic!("unreachable!");
         } else {
             let mut exit_code: i32 = Default::default();
             let wait_pid = waitpid(pid as usize, &mut exit_code);
             assert_eq!(pid, wait_pid);
+            if exit_code == test.4 {
+                // summary apps with  exit_code
+                pass_num = pass_num + 1;
+            }
             println!(
                 "\x1b[32mUsertests: Test {} in Process {} exited with code {}\x1b[0m",
-                test, pid, exit_code
+                test.0, pid, exit_code
             );
         }
     }
-    println!("Usertests passed!");
-    0
+    pass_num
+}
+
+#[no_mangle]
+pub fn main() -> i32 {
+    let succ_num = run_tests(SUCC_TESTS);
+    let err_num = run_tests(FAIL_TESTS);
+    if succ_num == SUCC_TESTS.len() as i32 && err_num == FAIL_TESTS.len() as i32 {
+        println!(
+            "{} of sueecssed apps, {} of failed apps run correctly. \nUsertests passed!",
+            SUCC_TESTS.len(),
+            FAIL_TESTS.len()
+        );
+        return 0;
+    }
+    if succ_num != SUCC_TESTS.len() as i32 {
+        println!(
+            "all successed app_num is  {} , but only  passed {}",
+            SUCC_TESTS.len(),
+            succ_num
+        );
+    }
+    if err_num != FAIL_TESTS.len() as i32 {
+        println!(
+            "all failed app_num is  {} , but only  passed {}",
+            FAIL_TESTS.len(),
+            err_num
+        );
+    }
+    println!(" Usertests failed!");
+    return -1;
 }

user/src/lib.rs

@@ -2,6 +2,7 @@
 #![feature(linkage)]
 #![feature(panic_info_message)]
 #![feature(alloc_error_handler)]
+#![feature(core_intrinsics)]
 
 #[macro_use]
 pub mod console;
@@ -197,3 +198,24 @@ pub fn condvar_signal(condvar_id: usize) {
 pub fn condvar_wait(condvar_id: usize, mutex_id: usize) {
     sys_condvar_wait(condvar_id, mutex_id);
 }
+
+#[macro_export]
+macro_rules! vstore {
+    ($var_ref: expr, $value: expr) => {
+        unsafe { core::intrinsics::volatile_store($var_ref as *const _ as _, $value) }
+    };
+}
+
+#[macro_export]
+macro_rules! vload {
+    ($var_ref: expr) => {
+        unsafe { core::intrinsics::volatile_load($var_ref as *const _ as _) }
+    };
+}
+
+#[macro_export]
+macro_rules! memory_fence {
+    () => {
+        core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst)
+    };
+}

user/src/syscall.rs

@@ -1,5 +1,3 @@
-use core::arch::asm;
-
 const SYSCALL_DUP: usize = 24;
 const SYSCALL_OPEN: usize = 56;
 const SYSCALL_CLOSE: usize = 57;
@@ -31,7 +29,7 @@ const SYSCALL_CONDVAR_WAIT: usize = 1032;
 fn syscall(id: usize, args: [usize; 3]) -> isize {
     let mut ret: isize;
     unsafe {
-        asm!(
+        core::arch::asm!(
             "ecall",
             inlateout("x10") args[0] => ret,
             in("x11") args[1],