update .gitignore, README.md, dev-env-info.md

[Ch3] update user module to 2021autumn version

.dockerignore

@@ -0,0 +1 @@
+*/*

.gitignore

@@ -1,6 +1,16 @@
-.idea/*
+.idea
-os/target/*
+Cargo.lock
-os/.idea/*
+target
 os/src/link_app.S
+os/last-*
+os/Cargo.lock
+user/build
 user/target/*
-user/.idea/*
+user/.idea/*
+user/Cargo.lock
+easy-fs/Cargo.lock
+easy-fs/target/*
+easy-fs-fuse/Cargo.lock
+easy-fs-fuse/target/*
+tools/
+pushall.sh

Dockerfile

@@ -0,0 +1,40 @@
+FROM ubuntu:18.04
+LABEL maintainer="dinghao188" \
+      version="1.1" \
+      description="ubuntu 18.04 with tools for tsinghua's rCore-Tutorial-V3"
+
+#install some deps
+RUN set -x \
+    && apt-get update \
+    && apt-get install -y curl wget autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev \
+              gawk build-essential bison flex texinfo gperf libtool patchutils bc xz-utils \
+              zlib1g-dev libexpat-dev pkg-config  libglib2.0-dev libpixman-1-dev git tmux python3 
+
+#install rust and qemu
+RUN set -x; \
+    RUSTUP='/root/rustup.sh' \
+    && cd $HOME \
+    #install rust
+    && curl https://sh.rustup.rs -sSf > $RUSTUP && chmod +x $RUSTUP \
+    && $RUSTUP -y --default-toolchain nightly --profile minimal \
+
+    #compile qemu
+    && wget https://ftp.osuosl.org/pub/blfs/conglomeration/qemu/qemu-5.0.0.tar.xz \
+    && tar xvJf qemu-5.0.0.tar.xz \
+    && cd qemu-5.0.0 \
+    && ./configure --target-list=riscv64-softmmu,riscv64-linux-user \
+    && make -j$(nproc) install \
+    && cd $HOME && rm -rf qemu-5.0.0 qemu-5.0.0.tar.xz
+
+#for chinese network
+RUN set -x; \
+    APT_CONF='/etc/apt/sources.list'; \
+    CARGO_CONF='/root/.cargo/config'; \
+    BASHRC='/root/.bashrc' \
+    && echo 'export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static' >> $BASHRC \
+    && echo 'export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup' >> $BASHRC \
+    && touch $CARGO_CONF \
+    && echo '[source.crates-io]' > $CARGO_CONF \
+    && echo "replace-with = 'ustc'" >> $CARGO_CONF \
+    && echo '[source.ustc]' >> $CARGO_CONF \
+    && echo 'registry = "git://mirrors.ustc.edu.cn/crates.io-index"' >> $CARGO_CONF

Makefile

@@ -0,0 +1,8 @@
+DOCKER_NAME ?= dinghao188/rcore-tutorial
+.PHONY: docker build_docker
+
+docker:
+	docker run --rm -it --mount type=bind,source=$(shell pwd),destination=/mnt ${DOCKER_NAME}
+
+build_docker: 
+	docker build -t ${DOCKER_NAME} .

README.md

@@ -1,2 +1,67 @@
 # rCore-Tutorial-v3
-rCore-Tutorial version 3.
+rCore-Tutorial version 3.5. See the [Documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/).
+
+## 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)
+
+## Overview
+
+This project aims to show how to write an **Unix-like OS** running on **RISC-V** platforms **from scratch** in **[Rust](https://www.rust-lang.org/)** for **beginners** without any background knowledge about **computer architectures, assembly languages or operating systems**.
+
+## Features
+
+* 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
+  * preemptive scheduling(Round-Robin algorithm)
+  * dynamic memory management in kernel
+  * virtual memory
+  * a simple file system with a block cache
+  * an interactive shell in the userspace
+* **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)
+
+## Run our project
+
+TODO:
+
+## 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.
+
+Overall progress: ch7
+
+### Completed
+
+* [x] automatically clean up and rebuild before running our project on a different platform
+* [x] fix `power` series application in early chapters, now you can find modulus in the output
+* [x] use `UPSafeCell` instead of `RefCell` or `spin::Mutex` in order to access static data structures and adjust its API so that it cannot be borrowed twice at a time(mention `& .exclusive_access().task[0]` in `run_first_task`)
+* [x] move `TaskContext` into `TaskControlBlock` instead of restoring it in place on kernel stack(since ch3), eliminating annoying `task_cx_ptr2`
+* [x] replace `llvm_asm!` with `asm!`
+* [x] expand the fs image size generated by `rcore-fs-fuse` to 128MiB
+* [x] add a new test named `huge_write` which evaluates the fs performance(qemu\~500KiB/s k210\~50KiB/s)
+* [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)
+
+### 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
+* [ ] use old fs image optionally, do not always rebuild the image
+* [ ] add new system calls: getdents64/fstat
+* [ ] shell functionality improvement(to be continued...)
+* [ ] give every non-zero process exit code an unique and clear error type
+* [ ] effective error handling of mm module
+
+### Todo(Low priority)
+
+* [ ] rewrite practice doc and remove some inproper questions
+* [ ] provide smooth debug experience at a Rust source code level
+* [ ] format the code using official tools
+
+
+### Crates
+
+We will add them later.

dev-env-info.md

@@ -0,0 +1,18 @@
+# rCore-Tutorial-v3
+rCore-Tutorial version 3.x
+
+## Dependency
+
+### Binaries
+
+* rustc: 1.57.0-nightly (e1e9319d9 2021-10-14)
+
+* cargo-binutils: 0.3.3
+
+* qemu: 5.0.0
+
+* rustsbi-lib: 0.2.0-alpha.4
+
+  rustsbi-qemu: d4968dd2
+
+  rustsbi-k210: b689314e

os/Cargo.lock

@@ -1,132 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "aho-corasick"
-version = "0.7.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "bare-metal"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
-dependencies = [
- "rustc_version",
-]
-
-[[package]]
-name = "bit_field"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4"
-
-[[package]]
-name = "bitflags"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-dependencies = [
- "spin",
-]
-
-[[package]]
-name = "memchr"
-version = "2.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
-
-[[package]]
-name = "os"
-version = "0.1.0"
-dependencies = [
- "lazy_static",
- "riscv",
-]
-
-[[package]]
-name = "regex"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
- "thread_local",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189"
-
-[[package]]
-name = "riscv"
-version = "0.6.0"
-source = "git+https://github.com/rcore-os/riscv#21e32ee1dc786cc0d5006ceee0040ce4f8398575"
-dependencies = [
- "bare-metal",
- "bit_field",
- "bitflags",
- "riscv-target",
-]
-
-[[package]]
-name = "riscv-target"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88aa938cda42a0cf62a20cfe8d139ff1af20c2e681212b5b34adb5a58333f222"
-dependencies = [
- "lazy_static",
- "regex",
-]
-
-[[package]]
-name = "rustc_version"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-dependencies = [
- "semver",
-]
-
-[[package]]
-name = "semver"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-dependencies = [
- "semver-parser",
-]
-
-[[package]]
-name = "semver-parser"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
-[[package]]
-name = "thread_local"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
-dependencies = [
- "lazy_static",
-]

os/Makefile

@@ -3,17 +3,24 @@ TARGET := riscv64gc-unknown-none-elf
 MODE := release
 KERNEL_ELF := target/$(TARGET)/$(MODE)/os
 KERNEL_BIN := $(KERNEL_ELF).bin
-KERNEL_ENTRY_PA := 0x80020000
 DISASM_TMP := target/$(TARGET)/$(MODE)/asm
 
 # BOARD
-BOARD		?= qemu
+BOARD ?= qemu
-SBI			?= rustsbi
+SBI ?= rustsbi
-BOOTLOADER	:= ../bootloader/$(SBI)-$(BOARD).bin
+BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
+K210_BOOTLOADER_SIZE := 131072
+
+# KERNEL ENTRY
+ifeq ($(BOARD), qemu)
+	KERNEL_ENTRY_PA := 0x80200000
+else ifeq ($(BOARD), k210)
+	KERNEL_ENTRY_PA := 0x80020000
+endif
 
 # Run K210
 K210-SERIALPORT	= /dev/ttyUSB0
-K210-BURNER		= ../tools/kflash.py
+K210-BURNER = ../tools/kflash.py
 
 # Binutils
 OBJDUMP := rust-objdump --arch-name=riscv64
@@ -22,14 +29,32 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
 # Disassembly
 DISASM ?= -x
 
-build: $(KERNEL_BIN)
+TEST ?= 0
+
+build: env switch-check $(KERNEL_BIN)
+
+switch-check:
+ifeq ($(BOARD), qemu)
+	(which last-qemu) || (rm last-k210 -f && touch last-qemu && make clean)
+else ifeq ($(BOARD), k210)
+	(which last-k210) || (rm last-qemu -f && touch last-k210 && make clean)
+endif
+
+env:
+	(rustup target list | grep "riscv64gc-unknown-none-elf (installed)") || rustup target add $(TARGET)
+	cargo install cargo-binutils --vers =0.3.3
+	rustup component add rust-src
+	rustup component add llvm-tools-preview
 
 $(KERNEL_BIN): kernel
 	@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
 
 kernel:
-	@cd ../user && make build
+	@cd ../user && make build TEST=$(TEST)
+	@echo Platform: $(BOARD)
+	@cp src/linker-$(BOARD).ld src/linker.ld
 	@cargo build --release --features "board_$(BOARD)"
+	@rm src/linker.ld
 
 clean:
 	@cargo clean
@@ -44,6 +69,8 @@ disasm-vim: kernel
 
 run: run-inner
 
+	
+
 run-inner: build
 ifeq ($(BOARD),qemu)
 	@qemu-system-riscv64 \
@@ -52,12 +79,13 @@ ifeq ($(BOARD),qemu)
 		-bios $(BOOTLOADER) \
 		-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA)
 else
+	(which $(K210-BURNER)) || (cd .. && git clone https://github.com/sipeed/kflash.py.git && mv kflash.py tools)
 	@cp $(BOOTLOADER) $(BOOTLOADER).copy
-	@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=128K seek=1
+	@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=$(K210_BOOTLOADER_SIZE) seek=1
 	@mv $(BOOTLOADER).copy $(KERNEL_BIN)
 	@sudo chmod 777 $(K210-SERIALPORT)
 	python3 $(K210-BURNER) -p $(K210-SERIALPORT) -b 1500000 $(KERNEL_BIN)
-	miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
+	python3 -m serial.tools.miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
 endif
 
 debug: build
@@ -66,4 +94,4 @@ 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 kernel clean disasm disasm-vim run-inner
+.PHONY: build env kernel clean disasm disasm-vim run-inner switch-check

os/build.rs

@@ -1,16 +1,17 @@
+use std::fs::{read_dir, File};
 use std::io::{Result, Write};
-use std::fs::{File, read_dir};
 
 fn main() {
-    println!("cargo:rerun-if-changed=../user/src/bin/");
+    println!("cargo:rerun-if-changed=../user/src/");
+    println!("cargo:rerun-if-changed={}", TARGET_PATH);
     insert_app_data().unwrap();
 }
 
-static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/debug/";
+static TARGET_PATH: &str = "../user/build/bin/";
 
 fn insert_app_data() -> Result<()> {
     let mut f = File::create("src/link_app.S").unwrap();
-    let mut apps: Vec<_> = read_dir("../user/src/bin")
+    let mut apps: Vec<_> = read_dir("../user/build/bin/")
         .unwrap()
         .into_iter()
         .map(|dir_entry| {
@@ -21,33 +22,35 @@ fn insert_app_data() -> Result<()> {
         .collect();
     apps.sort();
 
-    writeln!(f, r#"
+    writeln!(
-    .align 4
+        f,
+        r#"
+    .align 3
     .section .data
     .global _num_app
 _num_app:
-    .quad {}
+    .quad {}"#,
-    "#, apps.len())?;
+        apps.len()
+    )?;
 
     for i in 0..apps.len() {
-        writeln!(f, r#"
+        writeln!(f, r#"    .quad app_{}_start"#, i)?;
-    .quad app_{}_start
-        "#, i)?;
     }
-    writeln!(f, r#"
+    writeln!(f, r#"    .quad app_{}_end"#, apps.len() - 1)?;
-    .quad app_{}_end
-    "#, apps.len() - 1)?;
 
     for (idx, app) in apps.iter().enumerate() {
         println!("app_{}: {}", idx, app);
-        writeln!(f, r#"
+        writeln!(
+            f,
+            r#"
     .section .data
     .global app_{0}_start
     .global app_{0}_end
 app_{0}_start:
     .incbin "{2}{1}.bin"
-app_{0}_end:
+app_{0}_end:"#,
-        "#, idx, app, TARGET_PATH)?;
+            idx, app, TARGET_PATH
+        )?;
     }
     Ok(())
-}
+}

os/src/config.rs

@@ -1,11 +1,11 @@
 pub const USER_STACK_SIZE: usize = 4096 * 2;
 pub const KERNEL_STACK_SIZE: usize = 4096 * 2;
-pub const MAX_APP_NUM: usize = 4;
+pub const MAX_APP_NUM: usize = 8;
-pub const APP_BASE_ADDRESS: usize = 0x80100000;
+pub const APP_BASE_ADDRESS: usize = 0x80400000;
 pub const APP_SIZE_LIMIT: usize = 0x20000;
 
 #[cfg(feature = "board_k210")]
-pub const CPU_FREQ: usize = 10000000;
+pub const CLOCK_FREQ: usize = 403000000 / 62;
 
 #[cfg(feature = "board_qemu")]
-pub const CPU_FREQ: usize = 12500000;
+pub const CLOCK_FREQ: usize = 12500000;

os/src/linker-k210.ld

@@ -18,6 +18,7 @@ SECTIONS
     srodata = .;
     .rodata : {
         *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
     }
 
     . = ALIGN(4K);
@@ -25,6 +26,7 @@ SECTIONS
     sdata = .;
     .data : {
         *(.data .data.*)
+        *(.sdata .sdata.*)
     }
 
     . = ALIGN(4K);
@@ -33,6 +35,7 @@ SECTIONS
         *(.bss.stack)
         sbss = .;
         *(.bss .bss.*)
+        *(.sbss .sbss.*)
     }
 
     . = ALIGN(4K);

os/src/linker-qemu.ld

@@ -0,0 +1,48 @@
+OUTPUT_ARCH(riscv)
+ENTRY(_start)
+BASE_ADDRESS = 0x80200000;
+
+SECTIONS
+{
+    . = BASE_ADDRESS;
+    skernel = .;
+
+    stext = .;
+    .text : {
+        *(.text.entry)
+        *(.text .text.*)
+    }
+
+    . = ALIGN(4K);
+    etext = .;
+    srodata = .;
+    .rodata : {
+        *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
+    }
+
+    . = ALIGN(4K);
+    erodata = .;
+    sdata = .;
+    .data : {
+        *(.data .data.*)
+        *(.sdata .sdata.*)
+    }
+
+    . = ALIGN(4K);
+    edata = .;
+    .bss : {
+        *(.bss.stack)
+        sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+    }
+
+    . = ALIGN(4K);
+    ebss = .;
+    ekernel = .;
+
+    /DISCARD/ : {
+        *(.eh_frame)
+    }
+}

os/src/loader.rs

@@ -1,13 +1,14 @@
 use crate::trap::TrapContext;
-use crate::task::TaskContext;
 use crate::config::*;
 
 #[repr(align(4096))]
+#[derive(Copy, Clone)]
 struct KernelStack {
     data: [u8; KERNEL_STACK_SIZE],
 }
 
 #[repr(align(4096))]
+#[derive(Copy, Clone)]
 struct UserStack {
     data: [u8; USER_STACK_SIZE],
 }
@@ -26,14 +27,10 @@ impl KernelStack {
     fn get_sp(&self) -> usize {
         self.data.as_ptr() as usize + KERNEL_STACK_SIZE
     }
-    pub fn push_context(&self, trap_cx: TrapContext, task_cx: TaskContext) -> &'static mut TaskContext {
+    pub fn push_context(&self, trap_cx: TrapContext) -> usize {
-        unsafe {
+        let trap_cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
-            let trap_cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
+        unsafe { *trap_cx_ptr = trap_cx; }
-            *trap_cx_ptr = trap_cx;
+        trap_cx_ptr as usize
-            let task_cx_ptr = (trap_cx_ptr as usize - core::mem::size_of::<TaskContext>()) as *mut TaskContext;
-            *task_cx_ptr = task_cx;
-            task_cx_ptr.as_mut().unwrap()
-        }
     }
 }
 
@@ -60,7 +57,7 @@ pub fn load_apps() {
         core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1)
     };
     // clear i-cache first
-    unsafe { llvm_asm!("fence.i" :::: "volatile"); }
+    unsafe { asm!("fence.i"); }
     // load apps
     for i in 0..num_app {
         let base_i = get_base_i(i);
@@ -79,9 +76,8 @@ pub fn load_apps() {
     }
 }
 
-pub fn init_app_cx(app_id: usize) -> &'static TaskContext {
+pub fn init_app_cx(app_id: usize) -> usize {
     KERNEL_STACK[app_id].push_context(
         TrapContext::app_init_context(get_base_i(app_id), USER_STACK[app_id].get_sp()),
-        TaskContext::goto_restore(),
     )
 }

os/src/main.rs

@@ -1,9 +1,8 @@
 #![no_std]
 #![no_main]
 #![feature(global_asm)]
-#![feature(llvm_asm)]
+#![feature(asm)]
 #![feature(panic_info_message)]
-#![feature(const_in_array_repeat_expressions)]
 
 #[macro_use]
 mod console;
@@ -15,6 +14,7 @@ mod loader;
 mod config;
 mod task;
 mod timer;
+mod sync;
 
 global_asm!(include_str!("entry.asm"));
 global_asm!(include_str!("link_app.S"));
@@ -24,9 +24,12 @@ fn clear_bss() {
         fn sbss();
         fn ebss();
     }
-    (sbss as usize..ebss as usize).for_each(|a| {
+    unsafe {
-        unsafe { (a as *mut u8).write_volatile(0) }
+        core::slice::from_raw_parts_mut(
-    });
+            sbss as usize as *mut u8,
+            ebss as usize - sbss as usize,
+        ).fill(0);
+    }
 }
 
 #[no_mangle]
@@ -35,7 +38,6 @@ pub fn rust_main() -> ! {
     println!("[kernel] Hello, world!");
     trap::init();
     loader::load_apps();
-    trap::enable_interrupt();
     trap::enable_timer_interrupt();
     timer::set_next_trigger();
     task::run_first_task();

os/src/sbi.rs

@@ -14,11 +14,12 @@ const SBI_SHUTDOWN: usize = 8;
 fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
     let mut ret;
     unsafe {
-        llvm_asm!("ecall"
+        asm!(
-            : "={x10}" (ret)
+            "ecall",
-            : "{x10}" (arg0), "{x11}" (arg1), "{x12}" (arg2), "{x17}" (which)
+            inlateout("x10") arg0 => ret,
-            : "memory"
+            in("x11") arg1,
-            : "volatile"
+            in("x12") arg2,
+            in("x17") which,
         );
     }
     ret

os/src/sync/mod.rs

@@ -0,0 +1,3 @@
+mod up;
+
+pub use up::UPSafeCell;

os/src/sync/up.rs

@@ -0,0 +1,27 @@
+use core::cell::{RefCell, RefMut};
+
+/// Wrap a static data structure inside it so that we are
+/// able to access it without any `unsafe`.
+///
+/// We should only use it in uniprocessor.
+///
+/// In order to get mutable reference of inner data, call
+/// `exclusive_access`.
+pub struct UPSafeCell<T> {
+    /// inner data
+    inner: RefCell<T>,
+}
+
+unsafe impl<T> Sync for UPSafeCell<T> {}
+
+impl<T> UPSafeCell<T> {
+    /// User is responsible to guarantee that inner struct is only used in
+    /// uniprocessor.
+    pub unsafe fn new(value: T) -> Self {
+        Self { inner: RefCell::new(value) }
+    }
+    /// Panic if the data has been borrowed.
+    pub fn exclusive_access(&self) -> RefMut<'_, T> {
+        self.inner.borrow_mut()
+    }
+}

os/src/syscall/mod.rs

@@ -14,7 +14,7 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
         SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
         SYSCALL_EXIT => sys_exit(args[0] as i32),
         SYSCALL_YIELD => sys_yield(),
-        SYSCALL_GET_TIME => sys_get_time(),
+        SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal, args[1]),
         _ => panic!("Unsupported syscall_id: {}", syscall_id),
     }
 }

os/src/syscall/process.rs

@@ -2,10 +2,17 @@ use crate::task::{
     suspend_current_and_run_next,
     exit_current_and_run_next,
 };
-use crate::timer::get_time;
+use crate::timer::get_time_us;
 
-pub fn sys_exit(xstate: i32) -> ! {
+#[repr(C)]
-    println!("[kernel] Application exited with code {}", xstate);
+#[derive(Debug)]
+pub struct TimeVal {
+    pub sec: usize,
+    pub usec: usize,
+}
+
+pub fn sys_exit(exit_code: i32) -> ! {
+    println!("[kernel] Application exited with code {}", exit_code);
     exit_current_and_run_next();
     panic!("Unreachable in sys_exit!");
 }
@@ -15,6 +22,17 @@ pub fn sys_yield() -> isize {
     0
 }
 
-pub fn sys_get_time() -> isize {
+// pub fn sys_get_time() -> isize {
-    get_time() as isize
+//     get_time_ms() as isize
+// }
+
+pub fn sys_get_time(ts: *mut TimeVal, _tz: usize) -> isize {
+    let us = get_time_us();
+    unsafe {
+        *ts = TimeVal {
+            sec: us / 1_000_000,
+            usec: us % 1_000_000,
+        };
+    }
+    0
 }

os/src/task/context.rs

@@ -1,14 +1,24 @@
+#[derive(Copy, Clone)]
 #[repr(C)]
 pub struct TaskContext {
     ra: usize,
+    sp: usize,
     s: [usize; 12],
 }
 
 impl TaskContext {
-    pub fn goto_restore() -> Self {
+    pub fn zero_init() -> Self {
+        Self {
+            ra: 0,
+            sp: 0,
+            s: [0; 12],
+        }
+    }
+    pub fn goto_restore(kstack_ptr: usize) -> Self {
         extern "C" { fn __restore(); }
         Self {
             ra: __restore as usize,
+            sp: kstack_ptr,
             s: [0; 12],
         }
     }

os/src/task/mod.rs

@@ -4,16 +4,16 @@ mod task;
 
 use crate::config::MAX_APP_NUM;
 use crate::loader::{get_num_app, init_app_cx};
-use core::cell::RefCell;
 use lazy_static::*;
 use switch::__switch;
 use task::{TaskControlBlock, TaskStatus};
+use crate::sync::UPSafeCell;
 
 pub use context::TaskContext;
 
 pub struct TaskManager {
     num_app: usize,
-    inner: RefCell<TaskManagerInner>,
+    inner: UPSafeCell<TaskManagerInner>,
 }
 
 struct TaskManagerInner {
@@ -21,55 +21,62 @@ struct TaskManagerInner {
     current_task: usize,
 }
 
-unsafe impl Sync for TaskManager {}
-
 lazy_static! {
     pub static ref TASK_MANAGER: TaskManager = {
         let num_app = get_num_app();
         let mut tasks = [
-            TaskControlBlock { task_cx_ptr: 0, task_status: TaskStatus::UnInit };
+            TaskControlBlock {
+                task_cx: TaskContext::zero_init(),
+                task_status: TaskStatus::UnInit
+            };
             MAX_APP_NUM
         ];
         for i in 0..num_app {
-            tasks[i].task_cx_ptr = init_app_cx(i) as * const _ as usize;
+            tasks[i].task_cx = TaskContext::goto_restore(init_app_cx(i));
             tasks[i].task_status = TaskStatus::Ready;
         }
         TaskManager {
             num_app,
-            inner: RefCell::new(TaskManagerInner {
+            inner: unsafe { UPSafeCell::new(TaskManagerInner {
                 tasks,
                 current_task: 0,
-            }),
+            })},
         }
     };
 }
 
 impl TaskManager {
-    fn run_first_task(&self) {
+    fn run_first_task(&self) -> ! {
-        self.inner.borrow_mut().tasks[0].task_status = TaskStatus::Running;
+        let mut inner = self.inner.exclusive_access();
-        let next_task_cx = self.inner.borrow().tasks[0].get_task_cx_ptr2();
+        let task0 = &mut inner.tasks[0];
+        task0.task_status = TaskStatus::Running;
+        let next_task_cx_ptr = &task0.task_cx as *const TaskContext;
+        drop(inner);
+        let mut _unused = TaskContext::zero_init();
+        // before this, we should drop local variables that must be dropped manually
         unsafe {
             __switch(
-                &0usize as *const _,
+                &mut _unused as *mut TaskContext,
-                next_task_cx,
+                next_task_cx_ptr,
             );
         }
+        panic!("unreachable in run_first_task!");
     }
 
     fn mark_current_suspended(&self) {
-        let mut inner = self.inner.borrow_mut();
+        let mut inner = self.inner.exclusive_access();
         let current = inner.current_task;
         inner.tasks[current].task_status = TaskStatus::Ready;
     }
 
     fn mark_current_exited(&self) {
-        let mut inner = self.inner.borrow_mut();
+        let mut inner = self.inner.exclusive_access();
         let current = inner.current_task;
         inner.tasks[current].task_status = TaskStatus::Exited;
     }
 
     fn find_next_task(&self) -> Option<usize> {
-        let inner = self.inner.borrow();
+        let inner = self.inner.exclusive_access();
         let current = inner.current_task;
         (current + 1..current + self.num_app + 1)
             .map(|id| id % self.num_app)
@@ -80,19 +87,21 @@ impl TaskManager {
 
     fn run_next_task(&self) {
         if let Some(next) = self.find_next_task() {
-            let mut inner = self.inner.borrow_mut();
+            let mut inner = self.inner.exclusive_access();
             let current = inner.current_task;
             inner.tasks[next].task_status = TaskStatus::Running;
             inner.current_task = next;
-            let current_task_cx = inner.tasks[current].get_task_cx_ptr2();
+            let current_task_cx_ptr = &mut inner.tasks[current].task_cx as *mut TaskContext;
-            let next_task_cx = inner.tasks[next].get_task_cx_ptr2();
+            let next_task_cx_ptr = &inner.tasks[next].task_cx as *const TaskContext;
-            core::mem::drop(inner);
+            drop(inner);
+            // before this, we should drop local variables that must be dropped manually
             unsafe {
                 __switch(
-                    current_task_cx,
+                    current_task_cx_ptr,
-                    next_task_cx,
+                    next_task_cx_ptr,
                 );
             }
+            // go back to user mode
         } else {
             panic!("All applications completed!");
         }

os/src/task/switch.S

@@ -1,34 +1,34 @@
 .altmacro
 .macro SAVE_SN n
-    sd s\n, (\n+1)*8(sp)
+    sd s\n, (\n+2)*8(a0)
 .endm
 .macro LOAD_SN n
-    ld s\n, (\n+1)*8(sp)
+    ld s\n, (\n+2)*8(a1)
 .endm
     .section .text
     .globl __switch
 __switch:
-    # __switch(current_task_cx: &*const TaskContext, next_task_cx: &*const TaskContext)
+    # __switch(
-    # push TaskContext to current sp and save its address to where a0 points to
+    #     current_task_cx_ptr: *mut TaskContext,
-    addi sp, sp, -13*8
+    #     next_task_cx_ptr: *const TaskContext
-    sd sp, 0(a0)
+    # )
-    # fill TaskContext with ra & s0-s11
+    # save kernel stack of current task
-    sd ra, 0(sp)
+    sd sp, 8(a0)
+    # save ra & s0~s11 of current execution
+    sd ra, 0(a0)
     .set n, 0
     .rept 12
         SAVE_SN %n
         .set n, n + 1
     .endr
-    # ready for loading TaskContext a1 points to
+    # restore ra & s0~s11 of next execution
-    ld sp, 0(a1)
+    ld ra, 0(a1)
-    # load registers in the TaskContext
-    ld ra, 0(sp)
     .set n, 0
     .rept 12
         LOAD_SN %n
         .set n, n + 1
     .endr
-    # pop TaskContext
+    # restore kernel stack of next task
-    addi sp, sp, 13*8
+    ld sp, 8(a1)
     ret
 

os/src/task/switch.rs

@@ -1,5 +1,10 @@
 global_asm!(include_str!("switch.S"));
 
+use super::TaskContext;
+
 extern "C" {
-    pub fn __switch(current_task_cx: *const usize, next_task_cx: *const usize);
+    pub fn __switch(
+        current_task_cx_ptr: *mut TaskContext,
+        next_task_cx_ptr: *const TaskContext
+    );
 }

os/src/task/task.rs

@@ -1,12 +1,9 @@
-pub struct TaskControlBlock {
+use super::TaskContext;
-    pub task_cx_ptr: usize,
-    pub task_status: TaskStatus,
-}
 
-impl TaskControlBlock {
+#[derive(Copy, Clone)]
-    pub fn get_task_cx_ptr2(&self) -> *const usize {
+pub struct TaskControlBlock {
-        &self.task_cx_ptr as *const usize
+    pub task_status: TaskStatus,
-    }
+    pub task_cx: TaskContext,
 }
 
 #[derive(Copy, Clone, PartialEq)]

os/src/timer.rs

@@ -1,13 +1,18 @@
-use riscv::register::time;
+use crate::config::CLOCK_FREQ;
 use crate::sbi::set_timer;
-use crate::config::CPU_FREQ;
+use riscv::register::time;
 
 const TICKS_PER_SEC: usize = 100;
+const MICRO_PER_SEC: usize = 1_000_000;
 
 pub fn get_time() -> usize {
     time::read()
 }
 
+pub fn get_time_us() -> usize {
+    time::read() / (CLOCK_FREQ / MICRO_PER_SEC)
+}
+
 pub fn set_next_trigger() {
-    set_timer(get_time() + CPU_FREQ / TICKS_PER_SEC);
+    set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
-}
+}

os/src/trap/mod.rs

@@ -10,7 +10,6 @@ use riscv::register::{
         Interrupt,
     },
     stval,
-    sstatus,
     sie,
 };
 use crate::syscall::syscall;
@@ -29,10 +28,6 @@ pub fn init() {
     }
 }
 
-pub fn enable_interrupt() {
-    unsafe { sstatus::set_sie(); }
-}
-
 pub fn enable_timer_interrupt() {
     unsafe { sie::set_stimer(); }
 }

rust-toolchain

@@ -1 +1 @@
-nightly-2020-11-01
+nightly-2021-10-15

user/Cargo.lock

@@ -1,5 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-[[package]]
-name = "user_lib"
-version = "0.1.0"

user/Cargo.toml

@@ -7,3 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+buddy_system_allocator = "0.6"
+bitflags = "1.2.1"
+spin = "0.9"
+lazy_static = { version = "1.4.0", features = ["spin_no_std"] }

user/Makefile

@@ -1,23 +1,40 @@
 TARGET := riscv64gc-unknown-none-elf
-MODE := debug
+MODE := release
 APP_DIR := src/bin
 TARGET_DIR := target/$(TARGET)/$(MODE)
-APPS := $(wildcard $(APP_DIR)/*.rs)
+BUILD_DIR := build
-ELFS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%, $(APPS))
-BINS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%.bin, $(APPS))
-
 OBJDUMP := rust-objdump --arch-name=riscv64
 OBJCOPY := rust-objcopy --binary-architecture=riscv64
+PY := python3
+
+TEST ?= 0
+ifeq ($(TEST), 0)
+	APPS :=  $(filter-out $(wildcard $(APP_DIR)/test*.rs), $(wildcard $(APP_DIR)/*.rs))
+else
+	APPS :=  $(wildcard $(APP_DIR)/test$(TEST)*.rs)
+endif
+ELFS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%, $(APPS))
 
 elf: $(APPS)
 	@python3 build.py
 
 binary: elf
-	$(foreach elf, $(ELFS), $(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf));)
+	@$(foreach elf, $(ELFS), \
+		$(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf)); \
+		cp $(elf) $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.elf, $(elf));)
 
-build: binary
+pre:
+	@mkdir -p $(BUILD_DIR)/bin/
+	@mkdir -p $(BUILD_DIR)/elf/
+	@mkdir -p $(BUILD_DIR)/app/
+	@$(foreach t, $(APPS), cp $(t) $(BUILD_DIR)/app/;)
+	
+build: clean pre binary 
+	@$(foreach t, $(ELFS), cp $(t).bin $(BUILD_DIR)/bin/;)
+	@$(foreach t, $(ELFS), cp $(t).elf $(BUILD_DIR)/elf/;)
 
 clean:
 	@cargo clean
+	@rm -rf $(BUILD_DIR)
 
 .PHONY: elf binary build clean

user/build.py

@@ -1,11 +1,11 @@
 import os
 
-base_address = 0x80100000
+base_address = 0x80400000
 step = 0x20000
 linker = 'src/linker.ld'
 
 app_id = 0
-apps = os.listdir('src/bin')
+apps = os.listdir('build/app')
 apps.sort()
 for app in apps:
     app = app[:app.find('.')]
@@ -18,7 +18,7 @@ for app in apps:
             lines.append(line)
     with open(linker, 'w+') as f:
         f.writelines(lines)
-    os.system('cargo build --bin %s' % app)
+    os.system('cargo build --bin %s --release' % app)
     print('[build.py] application %s start with address %s' %(app, hex(base_address+step*app_id)))
     with open(linker, 'w+') as f:
         f.writelines(lines_before)

user/src/bin/03sleep.rs

@@ -1,18 +0,0 @@
-#![no_std]
-#![no_main]
-
-#[macro_use]
-extern crate user_lib;
-
-use user_lib::{sys_get_time, sys_yield};
-
-#[no_mangle]
-fn main() -> i32 {
-    let current_timer = sys_get_time();
-    let wait_for = current_timer + 10000000;
-    while sys_get_time() < wait_for {
-        sys_yield();
-    }
-    println!("Test sleep OK!");
-    0
-}

user/src/bin/power_3.rs

@@ -10,7 +10,7 @@ const LEN: usize = 100;
 fn main() -> i32 {
     let p = 3u64;
     let m = 998244353u64;
-    let iter: usize = 100000;
+    let iter: usize = 200000;
     let mut s = [0u64; LEN];
     let mut cur = 0usize;
     s[cur] = 1;
@@ -22,7 +22,7 @@ fn main() -> i32 {
             println!("power_3 [{}/{}]", i, iter);
         }
     }
-    println!("{}^{} = {}", p, iter, s[cur]);
+    println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
     println!("Test power_3 OK!");
     0
 }

user/src/bin/power_5.rs

@@ -10,7 +10,7 @@ const LEN: usize = 100;
 fn main() -> i32 {
     let p = 5u64;
     let m = 998244353u64;
-    let iter: usize = 70000;
+    let iter: usize = 140000;
     let mut s = [0u64; LEN];
     let mut cur = 0usize;
     s[cur] = 1;
@@ -22,7 +22,7 @@ fn main() -> i32 {
             println!("power_5 [{}/{}]", i, iter);
         }
     }
-    println!("{}^{} = {}", p, iter, s[cur]);
+    println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
     println!("Test power_5 OK!");
     0
 }

user/src/bin/power_7.rs

@@ -10,7 +10,7 @@ const LEN: usize = 100;
 fn main() -> i32 {
     let p = 7u64;
     let m = 998244353u64;
-    let iter: usize = 80000;
+    let iter: usize = 160000;
     let mut s = [0u64; LEN];
     let mut cur = 0usize;
     s[cur] = 1;
@@ -22,7 +22,7 @@ fn main() -> i32 {
             println!("power_7 [{}/{}]", i, iter);
         }
     }
-    println!("{}^{} = {}", p, iter, s[cur]);
+    println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
     println!("Test power_7 OK!");
     0
 }

user/src/bin/sleep.rs

@@ -0,0 +1,24 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{get_time, yield_};
+
+/// 正确输出：（无报错信息）
+/// get_time OK! {...}
+/// Test sleep OK!
+
+#[no_mangle]
+fn main() -> i32 {
+    let current_time = get_time();
+    assert!(current_time > 0);
+    println!("get_time OK! {}", current_time);
+    let wait_for = current_time + 3000;
+    while get_time() < wait_for {
+        yield_();
+    }
+    println!("Test sleep OK!");
+    0
+}

user/src/bin/sleep1.rs

@@ -0,0 +1,22 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::{get_time, sleep};
+
+#[no_mangle]
+pub fn main() -> i32 {
+    let start = get_time();
+    println!("current time_msec = {}", start);
+    sleep(100);
+    let end = get_time();
+    println!(
+        "time_msec = {} after sleeping 100 ticks, delta = {}ms!",
+        end,
+        end - start
+    );
+    println!("Test sleep1 passed!");
+    0
+}

user/src/bin/test1_write0.rs

@@ -0,0 +1,53 @@
+#![no_std]
+#![no_main]
+#![feature(asm)]
+
+#[macro_use]
+extern crate user_lib;
+extern crate core;
+use core::slice;
+use user_lib::{write, STDOUT};
+
+/// 正确输出：
+/// Test write0 OK!
+
+const STACK_SIZE: usize = 0x1000;
+
+unsafe fn r_sp() -> usize {
+    let mut sp: usize;
+    asm!("mv {}, sp", out(reg) sp);
+    sp
+}
+
+unsafe fn stack_range() -> (usize, usize) {
+    let sp = r_sp();
+    let top = (sp + STACK_SIZE - 1) & (!(STACK_SIZE - 1));
+    (top - STACK_SIZE, top)
+}
+
+#[no_mangle]
+pub fn main() -> i32 {
+    assert_eq!(
+        write(STDOUT, unsafe {
+            #[allow(clippy::zero_ptr)]
+            slice::from_raw_parts(0x0 as *const _, 10)
+        }),
+        -1
+    );
+    let (bottom, top) = unsafe { stack_range() };
+    assert_eq!(
+        write(STDOUT, unsafe {
+            slice::from_raw_parts((top - 5) as *const _, 10)
+        }),
+        -1
+    );
+    assert_eq!(
+        write(STDOUT, unsafe {
+            slice::from_raw_parts((bottom - 5) as *const _, 10)
+        }),
+        -1
+    );
+    // TODO: test string located in .data section
+    println!("Test write0 OK!");
+    0
+}

user/src/bin/test1_write1.rs

@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{write, STDOUT};
+const DATA_STRING: &str = "string from data section\n";
+
+/// 正确输出：
+/// string from data section
+/// strinstring from stack section
+/// strin
+/// Test write1 OK!
+
+#[no_mangle]
+pub fn main() -> i32 {
+    assert_eq!(write(1234, DATA_STRING.as_bytes()), -1);
+    assert_eq!(
+        write(STDOUT, DATA_STRING.as_bytes()),
+        DATA_STRING.len() as isize
+    );
+    assert_eq!(write(STDOUT, &DATA_STRING.as_bytes()[..5]), 5);
+    let stack_string = "string from stack section\n";
+    assert_eq!(
+        write(STDOUT, stack_string.as_bytes()),
+        stack_string.len() as isize
+    );
+    assert_eq!(write(STDOUT, &stack_string.as_bytes()[..5]), 5);
+    println!("\nTest write1 OK!");
+    0
+}

user/src/bin/test2_setprio.rs

@@ -0,0 +1,20 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::set_priority;
+
+/// 正确输出：（无报错信息）
+/// Test set_priority OK!
+
+#[no_mangle]
+pub fn main() -> i32 {
+    assert_eq!(set_priority(10), 10);
+    assert_eq!(set_priority(isize::MAX), isize::MAX);
+    assert_eq!(set_priority(0), -1);
+    assert_eq!(set_priority(1), -1);
+    assert_eq!(set_priority(-10), -1);
+    println!("Test set_priority OK!");
+    0
+}

user/src/bin/test3_stride0.rs

@@ -0,0 +1,43 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{get_time, set_priority};
+
+/*
+理想结果：6个进程退出时，输出 count 基本正比于 priority
+*/
+
+fn spin_delay() {
+    let mut j = true;
+    for _ in 0..10 {
+        j = !j;
+    }
+}
+
+// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
+const MAX_TIME: isize = 1000;
+pub fn count_during(prio: isize) -> isize {
+    let start_time = get_time();
+    let mut acc = 0;
+    set_priority(prio);
+    loop {
+        spin_delay();
+        acc += 1;
+        if acc % 400 == 0 {
+            let time = get_time() - start_time;
+            if time > MAX_TIME {
+                return acc;
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let prio = 5;
+    let count = count_during(prio);
+    println!("priority = {}, exitcode = {}", prio, count);
+    0
+}

user/src/bin/test3_stride1.rs

@@ -0,0 +1,39 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{get_time, set_priority};
+
+fn spin_delay() {
+    let mut j = true;
+    for _ in 0..10 {
+        j = !j;
+    }
+}
+
+// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
+const MAX_TIME: isize = 1000;
+fn count_during(prio: isize) -> isize {
+    let start_time = get_time();
+    let mut acc = 0;
+    set_priority(prio);
+    loop {
+        spin_delay();
+        acc += 1;
+        if acc % 400 == 0 {
+            let time = get_time() - start_time;
+            if time > MAX_TIME {
+                return acc;
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let prio = 6;
+    let count = count_during(prio);
+    println!("priority = {}, exitcode = {}", prio, count);
+    0
+}

user/src/bin/test3_stride2.rs

@@ -0,0 +1,39 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{get_time, set_priority};
+
+fn spin_delay() {
+    let mut j = true;
+    for _ in 0..10 {
+        j = !j;
+    }
+}
+
+// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
+const MAX_TIME: isize = 1000;
+fn count_during(prio: isize) -> isize {
+    let start_time = get_time();
+    let mut acc = 0;
+    set_priority(prio);
+    loop {
+        spin_delay();
+        acc += 1;
+        if acc % 400 == 0 {
+            let time = get_time() - start_time;
+            if time > MAX_TIME {
+                return acc;
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let prio = 7;
+    let count = count_during(prio);
+    println!("priority = {}, exitcode = {}", prio, count);
+    0
+}

user/src/bin/test3_stride3.rs

@@ -0,0 +1,39 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{get_time, set_priority};
+
+fn spin_delay() {
+    let mut j = true;
+    for _ in 0..10 {
+        j = !j;
+    }
+}
+
+// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
+const MAX_TIME: isize = 1000;
+fn count_during(prio: isize) -> isize {
+    let start_time = get_time();
+    let mut acc = 0;
+    set_priority(prio);
+    loop {
+        spin_delay();
+        acc += 1;
+        if acc % 400 == 0 {
+            let time = get_time() - start_time;
+            if time > MAX_TIME {
+                return acc;
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let prio = 8;
+    let count = count_during(prio);
+    println!("priority = {}, exitcode = {}", prio, count);
+    0
+}

user/src/bin/test3_stride4.rs

@@ -0,0 +1,39 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{get_time, set_priority};
+
+fn spin_delay() {
+    let mut j = true;
+    for _ in 0..10 {
+        j = !j;
+    }
+}
+
+// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
+const MAX_TIME: isize = 1000;
+fn count_during(prio: isize) -> isize {
+    let start_time = get_time();
+    let mut acc = 0;
+    set_priority(prio);
+    loop {
+        spin_delay();
+        acc += 1;
+        if acc % 400 == 0 {
+            let time = get_time() - start_time;
+            if time > MAX_TIME {
+                return acc;
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let prio = 9;
+    let count = count_during(prio);
+    println!("priority = {}, exitcode = {}", prio, count);
+    0
+}

user/src/bin/test3_stride5.rs

@@ -0,0 +1,39 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+use user_lib::{get_time, set_priority};
+
+fn spin_delay() {
+    let mut j = true;
+    for _ in 0..10 {
+        j = !j;
+    }
+}
+
+// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
+const MAX_TIME: isize = 1000;
+fn count_during(prio: isize) -> isize {
+    let start_time = get_time();
+    let mut acc = 0;
+    set_priority(prio);
+    loop {
+        spin_delay();
+        acc += 1;
+        if acc % 400 == 0 {
+            let time = get_time() - start_time;
+            if time > MAX_TIME {
+                return acc;
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub fn main() -> usize {
+    let prio = 10;
+    let count = count_during(prio);
+    println!("priority = {}, exitcode = {}", prio, count);
+    0
+}

user/src/bin/yield0.rs

@@ -0,0 +1,30 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::yield_;
+
+const WIDTH: usize = 10;
+const HEIGHT: usize = 5;
+
+/*
+理想结果：三个程序交替输出 ABC
+*/
+
+#[no_mangle]
+fn main() -> i32 {
+    for i in 0..HEIGHT {
+        let buf = ['A' as u8; WIDTH];
+        println!(
+            "{} [{}/{}]",
+            core::str::from_utf8(&buf).unwrap(),
+            i + 1,
+            HEIGHT
+        );
+        yield_();
+    }
+    println!("Test write A OK!");
+    0
+}

user/src/bin/yield1.rs

@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::yield_;
+
+const WIDTH: usize = 10;
+const HEIGHT: usize = 5;
+
+/*
+理想结果：三个程序交替输出 ABC
+*/
+
+#[no_mangle]
+#[no_mangle]
+fn main() -> i32 {
+    for i in 0..HEIGHT {
+        let buf = ['B' as u8; WIDTH];
+        println!(
+            "{} [{}/{}]",
+            core::str::from_utf8(&buf).unwrap(),
+            i + 1,
+            HEIGHT
+        );
+        yield_();
+    }
+    println!("Test write B OK!");
+    0
+}

user/src/bin/yield2.rs

@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate user_lib;
+
+use user_lib::yield_;
+
+/*
+理想结果：三个程序交替输出 ABC
+*/
+
+const WIDTH: usize = 10;
+const HEIGHT: usize = 5;
+
+#[no_mangle]
+#[no_mangle]
+fn main() -> i32 {
+    for i in 0..HEIGHT {
+        let buf = ['C' as u8; WIDTH];
+        println!(
+            "{} [{}/{}]",
+            core::str::from_utf8(&buf).unwrap(),
+            i + 1,
+            HEIGHT
+        );
+        yield_();
+    }
+    println!("Test write C OK!");
+    0
+}

user/src/console.rs

@@ -1,17 +1,52 @@
+use alloc::collections::vec_deque::VecDeque;
+use alloc::sync::Arc;
 use core::fmt::{self, Write};
-use crate::syscall::{STDOUT, sys_write};
+use spin::mutex::Mutex;
 
-struct Stdout;
+pub const STDIN: usize = 0;
+pub const STDOUT: usize = 1;
 
-impl Write for Stdout {
+const CONSOLE_BUFFER_SIZE: usize = 256 * 10;
+
+use super::{read, write};
+use lazy_static::*;
+
+struct ConsoleBuffer(VecDeque<u8>);
+
+lazy_static! {
+    static ref CONSOLE_BUFFER: Arc<Mutex<ConsoleBuffer>> = {
+        let buffer = VecDeque::<u8>::with_capacity(CONSOLE_BUFFER_SIZE);
+        Arc::new(Mutex::new(ConsoleBuffer(buffer)))
+    };
+}
+
+impl ConsoleBuffer {
+    fn flush(&mut self) -> isize {
+        let s: &[u8] = self.0.make_contiguous();
+        let ret = write(STDOUT, s);
+        self.0.clear();
+        ret
+    }
+}
+
+impl Write for ConsoleBuffer {
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        sys_write(STDOUT, s.as_bytes());
+        for c in s.as_bytes().iter() {
+            self.0.push_back(*c);
+            if (*c == b'\n' || self.0.len() == CONSOLE_BUFFER_SIZE) && -1 == self.flush() {
+                return Err(fmt::Error);
+            }
+        }
         Ok(())
     }
 }
 
+#[allow(unused)]
 pub fn print(args: fmt::Arguments) {
-    Stdout.write_fmt(args).unwrap();
+    let mut buf = CONSOLE_BUFFER.lock();
+    // buf.write_fmt(args).unwrap();
+    // BUG FIX: 关闭 stdout 后，本函数不能触发 panic，否则会造成死锁
+    buf.write_fmt(args);
 }
 
 #[macro_export]
@@ -26,4 +61,15 @@ macro_rules! println {
     ($fmt: literal $(, $($arg: tt)+)?) => {
         $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
     }
-}
+}
+
+pub fn getchar() -> u8 {
+    let mut c = [0u8; 1];
+    read(STDIN, &mut c);
+    c[0]
+}
+
+pub fn flush() {
+    let mut buf = CONSOLE_BUFFER.lock();
+    buf.flush();
+}

user/src/lang_items.rs

@@ -1,10 +1,17 @@
+use crate::exit;
+
 #[panic_handler]
 fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! {
     let err = panic_info.message().unwrap();
     if let Some(location) = panic_info.location() {
-        println!("Panicked at {}:{}, {}", location.file(), location.line(), err);
+        println!(
+            "Panicked at {}:{}, {}",
+            location.file(),
+            location.line(),
+            err
+        );
     } else {
         println!("Panicked: {}", err);
     }
-    loop {}
+    exit(-1);
-}
+}

user/src/lib.rs

@@ -1,19 +1,43 @@
 #![no_std]
-#![feature(llvm_asm)]
+#![feature(asm)]
 #![feature(linkage)]
 #![feature(panic_info_message)]
+#![feature(alloc_error_handler)]
 
 #[macro_use]
 pub mod console;
-mod syscall;
 mod lang_items;
+mod syscall;
+
+extern crate alloc;
+extern crate core;
+#[macro_use]
+extern crate bitflags;
+
+use buddy_system_allocator::LockedHeap;
+pub use console::{flush, STDIN, STDOUT};
+pub use syscall::*;
+
+const USER_HEAP_SIZE: usize = 16384;
+
+static mut HEAP_SPACE: [u8; USER_HEAP_SIZE] = [0; USER_HEAP_SIZE];
+
+#[global_allocator]
+static HEAP: LockedHeap = LockedHeap::empty();
+
+#[alloc_error_handler]
+pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
+    panic!("Heap allocation error, layout = {:?}", layout);
+}
 
 #[no_mangle]
 #[link_section = ".text.entry"]
 pub extern "C" fn _start() -> ! {
-    clear_bss();
+    unsafe {
-    syscall::sys_exit(main());
+        HEAP.lock()
-    panic!("unreachable after sys_exit!");
+            .init(HEAP_SPACE.as_ptr() as usize, USER_HEAP_SIZE);
+    }
+    exit(main());
 }
 
 #[linkage = "weak"]
@@ -22,14 +46,194 @@ fn main() -> i32 {
     panic!("Cannot find main!");
 }
 
-fn clear_bss() {
+bitflags! {
-    extern "C" {
+    pub struct OpenFlags: u32 {
-        fn start_bss();
+        const RDONLY = 0;
-        fn end_bss();
+        const WRONLY = 1 << 0;
+        const RDWR = 1 << 1;
+        const CREATE = 1 << 9;
+        const TRUNC = 1 << 10;
     }
-    (start_bss as usize..end_bss as usize).for_each(|addr| {
-        unsafe { (addr as *mut u8).write_volatile(0); }
-    });
 }
 
-pub use syscall::*;
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct TimeVal {
+    pub sec: usize,
+    pub usec: usize,
+}
+
+impl TimeVal {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct Stat {
+    /// ID of device containing file
+    pub dev: u64,
+    /// inode number
+    pub ino: u64,
+    /// file type and mode
+    pub mode: StatMode,
+    /// number of hard links
+    pub nlink: u32,
+    /// unused pad
+    pad: [u64; 7],
+}
+
+impl Stat {
+    pub fn new() -> Self {
+        Stat {
+            dev: 0,
+            ino: 0,
+            mode: StatMode::NULL,
+            nlink: 0,
+            pad: [0; 7],
+        }
+    }
+}
+
+impl Default for Stat {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+bitflags! {
+    pub struct StatMode: u32 {
+        const NULL  = 0;
+        /// directory
+        const DIR   = 0o040000;
+        /// ordinary regular file
+        const FILE  = 0o100000;
+    }
+}
+
+const AT_FDCWD: isize = -100;
+
+pub fn open(path: &str, flags: OpenFlags) -> isize {
+    sys_openat(AT_FDCWD as usize, path, flags.bits, OpenFlags::RDWR.bits)
+}
+
+pub fn close(fd: usize) -> isize {
+    if fd == STDOUT {
+        console::flush();
+    }
+    sys_close(fd)
+}
+
+pub fn read(fd: usize, buf: &mut [u8]) -> isize {
+    sys_read(fd, buf)
+}
+
+pub fn write(fd: usize, buf: &[u8]) -> isize {
+    sys_write(fd, buf)
+}
+
+pub fn link(old_path: &str, new_path: &str) -> isize {
+    sys_linkat(AT_FDCWD as usize, old_path, AT_FDCWD as usize, new_path, 0)
+}
+
+pub fn unlink(path: &str) -> isize {
+    sys_unlinkat(AT_FDCWD as usize, path, 0)
+}
+
+pub fn fstat(fd: usize, st: &Stat) -> isize {
+    sys_fstat(fd, st)
+}
+
+pub fn mail_read(buf: &mut [u8]) -> isize {
+    sys_mail_read(buf)
+}
+
+pub fn mail_write(pid: usize, buf: &[u8]) -> isize {
+    sys_mail_write(pid, buf)
+}
+
+pub fn exit(exit_code: i32) -> ! {
+    console::flush();
+    sys_exit(exit_code);
+}
+
+pub fn yield_() -> isize {
+    sys_yield()
+}
+
+pub fn get_time() -> isize {
+    let time = TimeVal::new();
+    match sys_get_time(&time, 0) {
+        0 => ((time.sec & 0xffff) * 1000 + time.usec / 1000) as isize,
+        _ => -1,
+    }
+}
+
+pub fn getpid() -> isize {
+    sys_getpid()
+}
+
+pub fn fork() -> isize {
+    sys_fork()
+}
+
+pub fn exec(path: &str) -> isize {
+    sys_exec(path)
+}
+
+pub fn set_priority(prio: isize) -> isize {
+    sys_set_priority(prio)
+}
+
+pub fn wait(exit_code: &mut i32) -> isize {
+    loop {
+        match sys_waitpid(-1, exit_code as *mut _) {
+            -2 => {
+                sys_yield();
+            }
+            n => {
+                return n;
+            }
+        }
+    }
+}
+
+pub fn waitpid(pid: usize, exit_code: &mut i32) -> isize {
+    loop {
+        match sys_waitpid(pid as isize, exit_code as *mut _) {
+            -2 => {
+                sys_yield();
+            }
+            n => {
+                return n;
+            }
+        }
+    }
+}
+
+pub fn sleep(period_ms: usize) {
+    let start = get_time();
+    while get_time() < start + period_ms as isize {
+        sys_yield();
+    }
+}
+
+pub fn mmap(start: usize, len: usize, prot: usize) -> isize {
+    sys_mmap(start, len, prot)
+}
+
+pub fn munmap(start: usize, len: usize) -> isize {
+    sys_munmap(start, len)
+}
+
+pub fn spawn(path: &str) -> isize {
+    sys_spawn(path)
+}
+
+pub fn dup(fd: usize) -> isize {
+    sys_dup(fd)
+}
+pub fn pipe(pipe_fd: &mut [usize]) -> isize {
+    sys_pipe(pipe_fd)
+}

user/src/linker.ld

@@ -2,7 +2,7 @@
 OUTPUT_ARCH(riscv)
 ENTRY(_start)
 
-BASE_ADDRESS = 0x80100000;
+BASE_ADDRESS = 0x80400000;
 
 SECTIONS
 {
@@ -13,13 +13,16 @@ SECTIONS
     }
     .rodata : {
         *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
     }
     .data : {
         *(.data .data.*)
+        *(.sdata .sdata.*)
     }
     .bss : {
         start_bss = .;
         *(.bss .bss.*)
+        *(.sbss .sbss.*)
         end_bss = .;
     }
     /DISCARD/ : {

user/src/syscall.rs

@@ -1,35 +1,179 @@
-pub const STDOUT: usize = 1;
+use super::{Stat, TimeVal};
 
-const SYSCALL_WRITE: usize = 64;
+pub const SYSCALL_OPENAT: usize = 56;
-const SYSCALL_EXIT: usize = 93;
+pub const SYSCALL_CLOSE: usize = 57;
-const SYSCALL_YIELD: usize = 124;
+pub const SYSCALL_READ: usize = 63;
-const SYSCALL_GET_TIME: usize = 169;
+pub const SYSCALL_WRITE: usize = 64;
+pub const SYSCALL_UNLINKAT: usize = 35;
+pub const SYSCALL_LINKAT: usize = 37;
+pub const SYSCALL_FSTAT: usize = 80;
+pub const SYSCALL_EXIT: usize = 93;
+pub const SYSCALL_YIELD: usize = 124;
+pub const SYSCALL_GETTIMEOFDAY: usize = 169;
+pub const SYSCALL_GETPID: usize = 172;
+pub const SYSCALL_FORK: usize = 220;
+pub const SYSCALL_EXEC: usize = 221;
+pub const SYSCALL_WAITPID: usize = 260;
+pub const SYSCALL_SET_PRIORITY: usize = 140;
+pub const SYSCALL_MUNMAP: usize = 215;
+pub const SYSCALL_MMAP: usize = 222;
+pub const SYSCALL_SPAWN: usize = 400;
+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;
 
-fn syscall(id: usize, args: [usize; 3]) -> isize {
+pub fn syscall(id: usize, args: [usize; 3]) -> isize {
     let mut ret: isize;
     unsafe {
-        llvm_asm!("ecall"
+        asm!(
-            : "={x10}" (ret)
+            "ecall",
-            : "{x10}" (args[0]), "{x11}" (args[1]), "{x12}" (args[2]), "{x17}" (id)
+            inlateout("x10") args[0] => ret,
-            : "memory"
+            in("x11") args[1],
-            : "volatile"
+            in("x12") args[2],
+            in("x17") id
         );
     }
     ret
 }
 
+pub fn syscall6(id: usize, args: [usize; 6]) -> isize {
+    let mut ret: isize;
+    unsafe {
+        asm!(
+            "ecall",
+            inlateout("x10") args[0] => ret,
+            in("x11") args[1],
+            in("x12") args[2],
+            in("x13") args[3],
+            in("x14") args[4],
+            in("x15") args[5],
+            in("x17") id
+        );
+    }
+    ret
+}
+
+pub fn sys_openat(dirfd: usize, path: &str, flags: u32, mode: u32) -> isize {
+    syscall6(
+        SYSCALL_OPENAT,
+        [
+            dirfd,
+            path.as_ptr() as usize,
+            flags as usize,
+            mode as usize,
+            0,
+            0,
+        ],
+    )
+}
+
+pub fn sys_close(fd: usize) -> isize {
+    syscall(SYSCALL_CLOSE, [fd, 0, 0])
+}
+
+pub fn sys_read(fd: usize, buffer: &mut [u8]) -> isize {
+    syscall(
+        SYSCALL_READ,
+        [fd, buffer.as_mut_ptr() as usize, buffer.len()],
+    )
+}
+
 pub fn sys_write(fd: usize, buffer: &[u8]) -> isize {
     syscall(SYSCALL_WRITE, [fd, buffer.as_ptr() as usize, buffer.len()])
 }
 
-pub fn sys_exit(xstate: i32) -> isize {
+pub fn sys_linkat(
-    syscall(SYSCALL_EXIT, [xstate as usize, 0, 0])
+    old_dirfd: usize,
+    old_path: &str,
+    new_dirfd: usize,
+    new_path: &str,
+    flags: usize,
+) -> isize {
+    syscall6(
+        SYSCALL_LINKAT,
+        [
+            old_dirfd,
+            old_path.as_ptr() as usize,
+            new_dirfd,
+            new_path.as_ptr() as usize,
+            flags,
+            0,
+        ],
+    )
+}
+
+pub fn sys_unlinkat(dirfd: usize, path: &str, flags: usize) -> isize {
+    syscall(SYSCALL_UNLINKAT, [dirfd, path.as_ptr() as usize, flags])
+}
+
+pub fn sys_fstat(fd: usize, st: &Stat) -> isize {
+    syscall(SYSCALL_FSTAT, [fd, st as *const _ as usize, 0])
+}
+
+pub fn sys_mail_read(buffer: &mut [u8]) -> isize {
+    syscall(
+        SYSCALL_MAIL_READ,
+        [buffer.as_ptr() as usize, buffer.len(), 0],
+    )
+}
+
+pub fn sys_mail_write(pid: usize, buffer: &[u8]) -> isize {
+    syscall(
+        SYSCALL_MAIL_WRITE,
+        [pid, buffer.as_ptr() as usize, buffer.len()],
+    )
+}
+
+pub fn sys_exit(exit_code: i32) -> ! {
+    syscall(SYSCALL_EXIT, [exit_code as usize, 0, 0]);
+    panic!("sys_exit never returns!");
 }
 
 pub fn sys_yield() -> isize {
     syscall(SYSCALL_YIELD, [0, 0, 0])
 }
 
-pub fn sys_get_time() -> isize {
+pub fn sys_get_time(time: &TimeVal, tz: usize) -> isize {
-    syscall(SYSCALL_GET_TIME, [0, 0, 0])
+    syscall(SYSCALL_GETTIMEOFDAY, [time as *const _ as usize, tz, 0])
-}
+}
+
+pub fn sys_getpid() -> isize {
+    syscall(SYSCALL_GETPID, [0, 0, 0])
+}
+
+pub fn sys_fork() -> isize {
+    syscall(SYSCALL_FORK, [0, 0, 0])
+}
+
+pub fn sys_exec(path: &str) -> isize {
+    syscall(SYSCALL_EXEC, [path.as_ptr() as usize, 0, 0])
+}
+
+pub fn sys_waitpid(pid: isize, xstatus: *mut i32) -> isize {
+    syscall(SYSCALL_WAITPID, [pid as usize, xstatus as usize, 0])
+}
+
+pub fn sys_set_priority(prio: isize) -> isize {
+    syscall(SYSCALL_SET_PRIORITY, [prio as usize, 0, 0])
+}
+
+pub fn sys_mmap(start: usize, len: usize, prot: usize) -> isize {
+    syscall(SYSCALL_MMAP, [start, len, prot])
+}
+
+pub fn sys_munmap(start: usize, len: usize) -> isize {
+    syscall(SYSCALL_MUNMAP, [start, len, 0])
+}
+
+pub fn sys_spawn(path: &str) -> isize {
+    syscall(SYSCALL_SPAWN, [path.as_ptr() as usize, 0, 0])
+}
+
+pub fn sys_dup(fd: usize) -> isize {
+    syscall(SYSCALL_DUP, [fd, 0, 0])
+}
+
+pub fn sys_pipe(pipe: &mut [usize]) -> isize {
+    syscall(SYSCALL_PIPE, [pipe.as_mut_ptr() as usize, 0, 0])
+}