lab 03

feat: support devcontainer

.devcontainer/devcontainer.json

@@ -0,0 +1,21 @@
+{
+  "name": "rcore-tutorial-v3",
+  "build": {
+    "dockerfile": "../Dockerfile",
+    "args": {
+      "QEMU_VERSION": "7.0.0",
+      "DEBIAN_FRONTEND": "noninteractive",
+      "GDB_VERSION": "14.1"
+    }
+  },
+  "postCreateCommand": "rustup show",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "rust-lang.rust-analyzer",
+        "ms-vscode.cpptools",
+        "tamasfe.even-better-toml"
+      ]
+    }
+  }
+}

.dockerignore

@@ -0,0 +1,2 @@
+*/*
+!rust-toolchain.toml

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

@@ -0,0 +1,68 @@
+name: Build Rust Doc And Run tests
+
+on: [push]
+
+env:
+  CARGO_TERM_COLOR: always
+  rust_toolchain: nightly-2024-01-18
+
+jobs:
+  build-doc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ env.rust_toolchain }}
+          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: ${{ env.rust_toolchain }}
+          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,6 +1,25 @@
-.idea/*
+.*/*
-os/target/*
+!.github/*
-os/.idea/*
+!.vscode/settings.json
+!.devcontainer/devcontainer.json
+
+.idea
+**/Cargo.lock
+**/target/
+
 os/src/link_app.S
+os/src/linker.ld
+os/last-*
+os/Cargo.lock
+os/.gdb_history
+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
+*.bak

.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+    // 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,
+    // "rust-analyzer.cargo.features": [
+    //     "board_qemu"
+    // ]
+}

Dockerfile

@@ -0,0 +1,72 @@
+# syntax=docker/dockerfile:1
+
+# Stage 1 Build QEMU
+# - https://www.qemu.org/download/
+# - https://wiki.qemu.org/Hosts/Linux#Building_QEMU_for_Linux
+# - https://wiki.qemu.org/Documentation/Platforms/RISCV
+
+FROM ubuntu:20.04 as build_qemu
+
+ARG QEMU_VERSION=7.0.0
+
+RUN sed -i 's/archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \ 
+    sed -i 's/security.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \ 
+    apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y wget build-essential libglib2.0-dev libfdt-dev libpixman-1-dev zlib1g-dev ninja-build
+
+RUN wget https://download.qemu.org/qemu-${QEMU_VERSION}.tar.xz && \
+    tar xf qemu-${QEMU_VERSION}.tar.xz && \
+    cd qemu-${QEMU_VERSION} && \ 
+    ./configure --target-list=riscv64-softmmu,riscv64-linux-user && \
+    make -j$(nproc) && \
+    make install
+
+# Stage 2 Set Lab Environment
+FROM ubuntu:20.04 as build
+
+WORKDIR /tmp
+
+# 2.0. Install general tools
+RUN sed -i 's/archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \ 
+    apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y jq curl git python3 wget build-essential \
+    # qemu dependency
+    libglib2.0-0 libfdt1 libpixman-1-0 zlib1g \
+    # gdb
+    gdb-multiarch
+
+# 2.1. Copy qemu
+COPY --from=build_qemu /usr/local/bin/* /usr/local/bin
+
+# 2.2. Install Rust
+# - https://www.rust-lang.org/tools/install
+ENV RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    PATH=/usr/local/cargo/bin:$PATH \
+    RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static \
+    RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup 
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
+    sh -s -- -y --no-modify-path --profile minimal --default-toolchain nightly
+
+# 2.3. Build env for labs
+# See os/Makefile `env:` for example.
+# This avoids having to wait for these steps each time using a new container.
+COPY rust-toolchain.toml rust-toolchain.toml
+RUN rustup target add riscv64gc-unknown-none-elf && \
+    cargo install toml-cli cargo-binutils && \
+    RUST_VERSION=$(toml get -r rust-toolchain.toml toolchain.channel) && \
+    Components=$(toml get -r rust-toolchain.toml toolchain.components | jq -r 'join(" ")') && \
+    rustup install $RUST_VERSION && \
+    rustup component add --toolchain $RUST_VERSION $Components
+
+# 2.4. Set GDB
+RUN ln -s /usr/bin/gdb-multiarch /usr/bin/riscv64-unknown-elf-gdb
+
+# Stage 3 Sanity checking
+FROM build as test
+RUN qemu-system-riscv64 --version && \
+    qemu-riscv64 --version && \
+    rustup --version && \
+    cargo --version && \
+    rustc --version && \
+    riscv64-unknown-elf-gdb --version

Makefile

@@ -0,0 +1,12 @@
+DOCKER_TAG ?= rcore-tutorial-v3:latest
+.PHONY: docker build_docker
+	
+docker:
+	docker run --rm -it -v ${PWD}:/mnt -w /mnt --name rcore-tutorial-v3 ${DOCKER_TAG} bash
+
+build_docker: 
+	docker build -t ${DOCKER_TAG} --target build .
+
+fmt:
+	cd os ; cargo fmt;  cd ..
+

README.md

@@ -1,2 +1,296 @@
 # rCore-Tutorial-v3
-rCore-Tutorial version 3.
+rCore-Tutorial version 3.6. 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
+- 23/06/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
+
+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 each of which contains mutiple native threads
+  * 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)
+
+## 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 7.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-7.0.0.tar.xz
+# extract to qemu-7.0.0/
+$ tar xvJf qemu-7.0.0.tar.xz
+$ cd qemu-7.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-7.0.0
+export PATH=$PATH:/home/shinbokuow/Downloads/built/qemu-7.0.0/riscv64-softmmu
+export PATH=$PATH:/home/shinbokuow/Downloads/built/qemu-7.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 7.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
+
+### 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
+
+Our first release 3.6.0 (chapter 1-9) has been published, and we are still working on it.
+
+* chapter 9: need more descripts about different I/O devices
+
+Here are the updates since 3.5.0:
+
+### 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)
+* [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
+* [x] code of chapter 9: device drivers based on interrupts, including UART, block, keyboard, mouse, gpu devices
+* [x] add CI autotest and doc in github 
+### Todo(High priority)
+
+* [ ] review documentation, current progress: 8/9
+* [ ] use old fs image optionally, do not always rebuild the image
+* [ ] 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
+* [ ] add more os functions for understanding os conecpts and principles
+### 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/Cargo.toml

@@ -2,14 +2,15 @@
 name = "os"
 version = "0.1.0"
 authors = ["Yifan Wu <shinbokuow@163.com>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
 lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
+log = "0.4"
+sbi-rt = { version = "0.0.2", features = ["legacy"] }
 
-[features]
+[profile.release]
-board_qemu = []
+debug = true
-board_k210 = []

os/Makefile

@@ -3,17 +3,20 @@ 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
 
-# Run K210
+# Building mode argument
-K210-SERIALPORT	= /dev/ttyUSB0
+ifeq ($(MODE), release)
-K210-BURNER		= ../tools/kflash.py
+	MODE_ARG := --release
+endif
+
+# KERNEL ENTRY
+KERNEL_ENTRY_PA := 0x80200000
 
 # Binutils
 OBJDUMP := rust-objdump --arch-name=riscv64
@@ -22,14 +25,23 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
 # Disassembly
 DISASM ?= -x
 
-build: $(KERNEL_BIN)
+build: env $(KERNEL_BIN)
+
+env:
+	(rustup target list | grep "riscv64gc-unknown-none-elf (installed)") || rustup target add $(TARGET)
+	cargo install cargo-binutils
+	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
-	@cargo build --release --features "board_$(BOARD)"
+	@echo Platform: $(BOARD)
+	@cp src/linker-$(BOARD).ld src/linker.ld
+	@cargo build $(MODE_ARG)
+	@rm src/linker.ld
 
 clean:
 	@cargo clean
@@ -44,26 +56,28 @@ disasm-vim: kernel
 
 run: run-inner
 
-run-inner: build
+QEMU_ARGS := -machine virt \
-ifeq ($(BOARD),qemu)
+			 -nographic \
-	@qemu-system-riscv64 \
+			 -bios $(BOOTLOADER) \
-		-machine virt \
+			 -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA)
-		-nographic \
-		-bios $(BOOTLOADER) \
-		-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA)
-else
-	@cp $(BOOTLOADER) $(BOOTLOADER).copy
-	@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=128K 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
-endif
 
-debug: build
+QEMU_NAME := qemu-system-riscv64
+qemu-version-check:
+	@sh scripts/qemu-ver-check.sh $(QEMU_NAME)
+
+run-inner: qemu-version-check build
+	@qemu-system-riscv64 $(QEMU_ARGS)
+
+debug: qemu-version-check build
 	@tmux new-session -d \
-		"qemu-system-riscv64 -machine virt -nographic -bios $(BOOTLOADER) -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) -s -S" && \
+		"qemu-system-riscv64 $(QEMU_ARGS) -s -S" && \
 		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
+gdbserver: qemu-version-check build
+	@qemu-system-riscv64 $(QEMU_ARGS) -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 gdbserver gdbclient qemu-version-check

os/build.rs

@@ -1,12 +1,13 @@
+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/target/riscv64gc-unknown-none-elf/release/";
 
 fn insert_app_data() -> Result<()> {
     let mut f = File::create("src/link_app.S").unwrap();
@@ -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/scripts/qemu-ver-check.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# Argument1: The filename of qemu executable, e.g. qemu-system-riscv64
+QEMU_PATH=$(which $1)
+RET=$?
+MINIMUM_MAJOR_VERSION=7
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+NC='\033[0m'
+if [ $RET != 0 ]
+then
+    echo "$1 not found"
+    exit 1
+else
+    QEMU_VERSION=$($1 --version|head -n 1|awk '{print $4}')
+    MAJOR_VERSION=$(echo $QEMU_VERSION|cut -c1-1)
+    if [ $MAJOR_VERSION -lt $MINIMUM_MAJOR_VERSION ]
+    then
+        echo "${RED}Error: Required major version of QEMU is ${MINIMUM_MAJOR_VERSION}, " \
+             "but current is ${QEMU_VERSION}.${NC}"
+        exit 1
+    else
+        echo "${GREEN}QEMU version is ${QEMU_VERSION}(>=${MINIMUM_MAJOR_VERSION}), OK!${NC}"
+        exit 0
+    fi
+fi

os/src/boards/qemu.rs

@@ -0,0 +1,3 @@
+//! Constants used in rCore for qemu
+
+pub const CLOCK_FREQ: usize = 12500000;

os/src/config.rs

@@ -1,11 +1,17 @@
-pub const USER_STACK_SIZE: usize = 4096 * 2;
+//! Constants used in rCore
+
+pub const USER_STACK_SIZE: usize = 4096;
 pub const KERNEL_STACK_SIZE: usize = 4096 * 2;
 pub const MAX_APP_NUM: usize = 4;
-pub const APP_BASE_ADDRESS: usize = 0x80100000;
+pub const APP_BASE_ADDRESS: usize = 0x80400000;
 pub const APP_SIZE_LIMIT: usize = 0x20000;
+pub const MAX_SYSCALL_NUM: usize = 500;
 
+/*
 #[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;
+*/
+pub use crate::board::CLOCK_FREQ;

os/src/console.rs

@@ -1,5 +1,7 @@
-use core::fmt::{self, Write};
+//! SBI console driver, for text output
+
 use crate::sbi::console_putchar;
+use core::fmt::{self, Write};
 
 struct Stdout;
 
@@ -16,6 +18,7 @@ pub fn print(args: fmt::Arguments) {
     Stdout.write_fmt(args).unwrap();
 }
 
+/// print string macro
 #[macro_export]
 macro_rules! print {
     ($fmt: literal $(, $($arg: tt)+)?) => {
@@ -23,11 +26,10 @@ macro_rules! print {
     }
 }
 
+/// println string macro
 #[macro_export]
 macro_rules! println {
     ($fmt: literal $(, $($arg: tt)+)?) => {
         $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
     }
 }
-
-

os/src/entry.asm

@@ -5,8 +5,8 @@ _start:
     call rust_main
 
     .section .bss.stack
-    .globl boot_stack
+    .globl boot_stack_lower_bound
-boot_stack:
+boot_stack_lower_bound:
     .space 4096 * 16
     .globl boot_stack_top
 boot_stack_top:

os/src/lang_items.rs

@@ -1,12 +1,20 @@
-use core::panic::PanicInfo;
+//! The panic handler
+
 use crate::sbi::shutdown;
+use core::panic::PanicInfo;
+use log::*;
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
     if let Some(location) = info.location() {
-        println!("[kernel] Panicked at {}:{} {}", location.file(), location.line(), info.message().unwrap());
+        error!(
+            "[kernel] Panicked at {}:{} {}",
+            location.file(),
+            location.line(),
+            info.message().unwrap()
+        );
     } else {
-        println!("[kernel] Panicked: {}", info.message().unwrap());
+        error!("[kernel] Panicked: {}", info.message().unwrap());
     }
-    shutdown()
+    shutdown(true)
 }

os/src/linker-qemu.ld

@@ -1,6 +1,6 @@
 OUTPUT_ARCH(riscv)
 ENTRY(_start)
-BASE_ADDRESS = 0x80020000;
+BASE_ADDRESS = 0x80200000;
 
 SECTIONS
 {
@@ -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/loader.rs

@@ -1,39 +1,44 @@
-use crate::trap::TrapContext;
+//! Loading user applications into memory
-use crate::task::TaskContext;
+//!
+//! For chapter 3, user applications are simply part of the data included in the
+//! kernel binary, so we only need to copy them to the space allocated for each
+//! app to load them. We also allocate fixed spaces for each task's
+//! [`KernelStack`] and [`UserStack`].
+
 use crate::config::*;
+use crate::trap::TrapContext;
+use core::arch::asm;
 
 #[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],
 }
 
-static KERNEL_STACK: [KernelStack; MAX_APP_NUM] = [
+static KERNEL_STACK: [KernelStack; MAX_APP_NUM] = [KernelStack {
-    KernelStack { data: [0; KERNEL_STACK_SIZE], };
+    data: [0; KERNEL_STACK_SIZE],
-    MAX_APP_NUM
+}; MAX_APP_NUM];
-];
 
-static USER_STACK: [UserStack; MAX_APP_NUM] = [
+static USER_STACK: [UserStack; MAX_APP_NUM] = [UserStack {
-    UserStack { data: [0; USER_STACK_SIZE], };
+    data: [0; USER_STACK_SIZE],
-    MAX_APP_NUM
+}; MAX_APP_NUM];
-];
 
 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 {
+        let trap_cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
         unsafe {
-            let trap_cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
             *trap_cx_ptr = trap_cx;
-            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()
         }
+        trap_cx_ptr as usize
     }
 }
 
@@ -43,45 +48,56 @@ impl UserStack {
     }
 }
 
+/// Get base address of app i.
 fn get_base_i(app_id: usize) -> usize {
     APP_BASE_ADDRESS + app_id * APP_SIZE_LIMIT
 }
 
+/// Get the total number of applications.
 pub fn get_num_app() -> usize {
-    extern "C" { fn _num_app(); }
+    extern "C" {
+        fn _num_app();
+    }
     unsafe { (_num_app as usize as *const usize).read_volatile() }
 }
 
+/// Load nth user app at
+/// [APP_BASE_ADDRESS + n * APP_SIZE_LIMIT, APP_BASE_ADDRESS + (n+1) * APP_SIZE_LIMIT).
 pub fn load_apps() {
-    extern "C" { fn _num_app(); }
+    extern "C" {
+        fn _num_app();
+    }
     let num_app_ptr = _num_app as usize as *const usize;
     let num_app = get_num_app();
-    let app_start = unsafe {
+    let app_start = unsafe { core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1) };
-        core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1)
-    };
-    // clear i-cache first
-    unsafe { llvm_asm!("fence.i" :::: "volatile"); }
     // load apps
     for i in 0..num_app {
         let base_i = get_base_i(i);
         // clear region
-        (base_i..base_i + APP_SIZE_LIMIT).for_each(|addr| unsafe {
+        (base_i..base_i + APP_SIZE_LIMIT)
-            (addr as *mut u8).write_volatile(0)
+            .for_each(|addr| unsafe { (addr as *mut u8).write_volatile(0) });
-        });
         // load app from data section to memory
         let src = unsafe {
             core::slice::from_raw_parts(app_start[i] as *const u8, app_start[i + 1] - app_start[i])
         };
-        let dst = unsafe {
+        let dst = unsafe { core::slice::from_raw_parts_mut(base_i as *mut u8, src.len()) };
-            core::slice::from_raw_parts_mut(base_i as *mut u8, src.len())
-        };
         dst.copy_from_slice(src);
     }
+    // Memory fence about fetching the instruction memory
+    // It is guaranteed that a subsequent instruction fetch must
+    // observes all previous writes to the instruction memory.
+    // Therefore, fence.i must be executed after we have loaded
+    // the code of the next app into the instruction memory.
+    // See also: riscv non-priv spec chapter 3, 'Zifencei' extension.
+    unsafe {
+        asm!("fence.i");
+    }
 }
 
-pub fn init_app_cx(app_id: usize) -> &'static TaskContext {
+/// get app info with entry and sp and save `TrapContext` in kernel stack
-    KERNEL_STACK[app_id].push_context(
+pub fn init_app_cx(app_id: usize) -> usize {
-        TrapContext::app_init_context(get_base_i(app_id), USER_STACK[app_id].get_sp()),
+    KERNEL_STACK[app_id].push_context(TrapContext::app_init_context(
-        TaskContext::goto_restore(),
+        get_base_i(app_id),
-    )
+        USER_STACK[app_id].get_sp(),
+    ))
 }

os/src/main.rs

@@ -1,43 +1,67 @@
+//! The main module and entrypoint
+//!
+//! Various facilities of the kernels are implemented as submodules. The most
+//! important ones are:
+//!
+//! - [`trap`]: Handles all cases of switching from userspace to the kernel
+//! - [`task`]: Task management
+//! - [`syscall`]: System call handling and implementation
+//!
+//! The operating system also starts in this module. Kernel code starts
+//! executing from `entry.asm`, after which [`rust_main()`] is called to
+//! initialize various pieces of functionality. (See its source code for
+//! details.)
+//!
+//! We then call [`task::run_first_task()`] and for the first time go to
+//! userspace.
+
+#![deny(missing_docs)]
+#![deny(warnings)]
 #![no_std]
 #![no_main]
-#![feature(global_asm)]
-#![feature(llvm_asm)]
 #![feature(panic_info_message)]
-#![feature(const_in_array_repeat_expressions)]
+
+use core::arch::global_asm;
+
+#[path = "boards/qemu.rs"]
+mod board;
 
 #[macro_use]
 mod console;
-mod lang_items;
-mod sbi;
-mod syscall;
-mod trap;
-mod loader;
 mod config;
-mod task;
+mod lang_items;
+mod loader;
+mod sbi;
+mod sync;
+pub mod syscall;
+pub mod task;
 mod timer;
+pub mod trap;
 
 global_asm!(include_str!("entry.asm"));
 global_asm!(include_str!("link_app.S"));
 
+/// clear BSS segment
 fn clear_bss() {
     extern "C" {
         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);
+    }
 }
 
+/// the rust entry-point of os
 #[no_mangle]
 pub fn rust_main() -> ! {
     clear_bss();
     println!("[kernel] Hello, world!");
     trap::init();
     loader::load_apps();
-    trap::enable_interrupt();
     trap::enable_timer_interrupt();
     timer::set_next_trigger();
     task::run_first_task();
     panic!("Unreachable in rust_main!");
-}
+}

os/src/sbi.rs

@@ -1,43 +1,23 @@
-#![allow(unused)]
+//! SBI call wrappers
-
-const SBI_SET_TIMER: usize = 0;
-const SBI_CONSOLE_PUTCHAR: usize = 1;
-const SBI_CONSOLE_GETCHAR: usize = 2;
-const SBI_CLEAR_IPI: usize = 3;
-const SBI_SEND_IPI: usize = 4;
-const SBI_REMOTE_FENCE_I: usize = 5;
-const SBI_REMOTE_SFENCE_VMA: usize = 6;
-const SBI_REMOTE_SFENCE_VMA_ASID: usize = 7;
-const SBI_SHUTDOWN: usize = 8;
-
-#[inline(always)]
-fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
-    let mut ret;
-    unsafe {
-        llvm_asm!("ecall"
-            : "={x10}" (ret)
-            : "{x10}" (arg0), "{x11}" (arg1), "{x12}" (arg2), "{x17}" (which)
-            : "memory"
-            : "volatile"
-        );
-    }
-    ret
-}
-
-pub fn set_timer(timer: usize) {
-    sbi_call(SBI_SET_TIMER, timer, 0, 0);
-}
 
+/// use sbi call to putchar in console (qemu uart handler)
 pub fn console_putchar(c: usize) {
-    sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0);
+    #[allow(deprecated)]
+    sbi_rt::legacy::console_putchar(c);
 }
 
-pub fn console_getchar() -> usize {
+/// use sbi call to set timer
-    sbi_call(SBI_CONSOLE_GETCHAR, 0, 0, 0)
+pub fn set_timer(timer: usize) {
+    sbi_rt::set_timer(timer as _);
 }
 
-pub fn shutdown() -> ! {
+/// use sbi call to shutdown the kernel
-    sbi_call(SBI_SHUTDOWN, 0, 0, 0);
+pub fn shutdown(failure: bool) -> ! {
-    panic!("It should shutdown!");
+    use sbi_rt::{system_reset, NoReason, Shutdown, SystemFailure};
+    if !failure {
+        system_reset(Shutdown, NoReason);
+    } else {
+        system_reset(Shutdown, SystemFailure);
+    }
+    unreachable!()
 }
-

os/src/sync/mod.rs

@@ -0,0 +1,5 @@
+//! Synchronization and interior mutability primitives
+
+mod up;
+
+pub use up::UPSafeCell;

os/src/sync/up.rs

@@ -0,0 +1,31 @@
+//! Uniprocessor interior mutability primitives
+
+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),
+        }
+    }
+    /// Exclusive access inner data in UPSafeCell. Panic if the data has been borrowed.
+    pub fn exclusive_access(&self) -> RefMut<'_, T> {
+        self.inner.borrow_mut()
+    }
+}

os/src/syscall/fs.rs

@@ -1,5 +1,8 @@
+//! File and filesystem-related syscalls
+
 const FD_STDOUT: usize = 1;
 
+/// write buf of length `len`  to a file with `fd`
 pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
     match fd {
         FD_STDOUT => {
@@ -7,9 +10,9 @@ pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
             let str = core::str::from_utf8(slice).unwrap();
             print!("{}", str);
             len as isize
-        },
+        }
         _ => {
             panic!("Unsupported fd in sys_write!");
         }
     }
-}
+}

os/src/syscall/mod.rs

@@ -1,7 +1,20 @@
+//! Implementation of syscalls
+//!
+//! The single entry point to all system calls, [`syscall()`], is called
+//! whenever userspace wishes to perform a system call using the `ecall`
+//! instruction. In this case, the processor raises an 'Environment call from
+//! U-mode' exception, which is handled as one of the cases in
+//! [`crate::trap::trap_handler`].
+//!
+//! For clarity, each single syscall is implemented as its own function, named
+//! `sys_` then the name of the syscall. You can find functions like this in
+//! submodules, and you should also implement syscalls this way.
+
 const SYSCALL_WRITE: usize = 64;
 const SYSCALL_EXIT: usize = 93;
 const SYSCALL_YIELD: usize = 124;
 const SYSCALL_GET_TIME: usize = 169;
+const SYSCALL_TASK_INFO: usize = 410;
 
 mod fs;
 mod process;
@@ -9,13 +22,17 @@ mod process;
 use fs::*;
 use process::*;
 
+use crate::task::TASK_MANAGER;
+
+/// handle syscall exception with `syscall_id` and other arguments
 pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
+    TASK_MANAGER.mark_syscall(syscall_id);
     match syscall_id {
         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_TASK_INFO => sys_task_info(args[0] as *mut TaskInfo),
         _ => panic!("Unsupported syscall_id: {}", syscall_id),
     }
 }
-

os/src/syscall/process.rs

@@ -1,20 +1,46 @@
-use crate::task::{
+//! Process management syscalls
-    suspend_current_and_run_next,
+use log::trace;
-    exit_current_and_run_next,
-};
-use crate::timer::get_time;
 
-pub fn sys_exit(xstate: i32) -> ! {
+use crate::task::{exit_current_and_run_next, suspend_current_and_run_next, TaskStatus, TASK_MANAGER};
-    println!("[kernel] Application exited with code {}", xstate);
+use crate::timer::{get_time, get_time_ms};
+use crate::config::MAX_SYSCALL_NUM;
+
+/// Task information
+#[allow(dead_code)]
+pub struct TaskInfo {
+    /// Task status in it's life cycle
+    status: TaskStatus,
+    /// The numbers of syscall called by task
+    syscall_times: [u32; MAX_SYSCALL_NUM],
+    /// Total running time of task
+    time: usize,
+}
+
+/// task exits and submit an exit code
+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!");
 }
 
+/// current task gives up resources for other tasks
 pub fn sys_yield() -> isize {
     suspend_current_and_run_next();
     0
 }
 
+/// get time in milliseconds
 pub fn sys_get_time() -> isize {
-    get_time() as isize
+    get_time_ms() as isize
-}
+}
+
+/// YOUR JOB: Finish sys_task_info to pass testcases
+pub fn sys_task_info(ti: *mut TaskInfo) -> isize {
+    unsafe {
+        (*ti).status = TASK_MANAGER.get_current_status();
+        (*ti).time = get_time();
+        (*ti).syscall_times = TASK_MANAGER.get_current_syscall_times()
+    }
+    trace!("kernel: sys_task_info");
+    0
+}

os/src/task/context.rs

@@ -1,16 +1,36 @@
+//! Implementation of [`TaskContext`]
+
+/// Task Context
+#[derive(Copy, Clone)]
 #[repr(C)]
 pub struct TaskContext {
+    /// return address ( e.g. __restore ) of __switch ASM function
     ra: usize,
+    /// kernel stack pointer of app
+    sp: usize,
+    /// callee saved registers:  s 0..11
     s: [usize; 12],
 }
 
 impl TaskContext {
-    pub fn goto_restore() -> Self {
+    /// init task context
-        extern "C" { fn __restore(); }
+    pub fn zero_init() -> Self {
+        Self {
+            ra: 0,
+            sp: 0,
+            s: [0; 12],
+        }
+    }
+
+    /// set task context {__restore ASM funciton, kernel stack, 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

@@ -1,126 +1,204 @@
+//! Task management implementation
+//!
+//! Everything about task management, like starting and switching tasks is
+//! implemented here.
+//!
+//! A single global instance of [`TaskManager`] called `TASK_MANAGER` controls
+//! all the tasks in the operating system.
+//!
+//! Be careful when you see `__switch` ASM function in `switch.S`. Control flow around this function
+//! might not be what you expect.
+
 mod context;
 mod switch;
+
+#[allow(clippy::module_inception)]
 mod task;
 
-use crate::config::MAX_APP_NUM;
+use crate::config::{MAX_APP_NUM, MAX_SYSCALL_NUM};
 use crate::loader::{get_num_app, init_app_cx};
-use core::cell::RefCell;
+use crate::sbi::shutdown;
+use crate::sync::UPSafeCell;
 use lazy_static::*;
 use switch::__switch;
-use task::{TaskControlBlock, TaskStatus};
+pub use task::{TaskControlBlock, TaskStatus};
 
 pub use context::TaskContext;
 
+/// The task manager, where all the tasks are managed.
+///
+/// Functions implemented on `TaskManager` deals with all task state transitions
+/// and task context switching. For convenience, you can find wrappers around it
+/// in the module level.
+///
+/// Most of `TaskManager` are hidden behind the field `inner`, to defer
+/// borrowing checks to runtime. You can see examples on how to use `inner` in
+/// existing functions on `TaskManager`.
 pub struct TaskManager {
+    /// total number of tasks
     num_app: usize,
-    inner: RefCell<TaskManagerInner>,
+    /// use inner value to get mutable access
+    inner: UPSafeCell<TaskManagerInner>,
 }
 
-struct TaskManagerInner {
+/// Inner of Task Manager
+pub struct TaskManagerInner {
+    /// task list
     tasks: [TaskControlBlock; MAX_APP_NUM],
+    /// id of current `Running` task
     current_task: usize,
 }
 
-unsafe impl Sync for TaskManager {}
-
 lazy_static! {
+    /// Global variable: TASK_MANAGER
     pub static ref TASK_MANAGER: TaskManager = {
         let num_app = get_num_app();
-        let mut tasks = [
+        let mut tasks = [TaskControlBlock {
-            TaskControlBlock { task_cx_ptr: 0, task_status: TaskStatus::UnInit };
+            task_cx: TaskContext::zero_init(),
-            MAX_APP_NUM
+            task_status: TaskStatus::UnInit,
-        ];
+            syscall_times: [0; MAX_SYSCALL_NUM]
-        for i in 0..num_app {
+        }; MAX_APP_NUM];
-            tasks[i].task_cx_ptr = init_app_cx(i) as * const _ as usize;
+        for (i, task) in tasks.iter_mut().enumerate() {
-            tasks[i].task_status = TaskStatus::Ready;
+            task.task_cx = TaskContext::goto_restore(init_app_cx(i));
+            task.task_status = TaskStatus::Ready;
         }
         TaskManager {
             num_app,
-            inner: RefCell::new(TaskManagerInner {
+            inner: unsafe {
-                tasks,
+                UPSafeCell::new(TaskManagerInner {
-                current_task: 0,
+                    tasks,
-            }),
+                    current_task: 0,
+                })
+            },
         }
     };
 }
 
 impl TaskManager {
-    fn run_first_task(&self) {
+    /// Run the first task in task list.
-        self.inner.borrow_mut().tasks[0].task_status = TaskStatus::Running;
+    ///
-        let next_task_cx = self.inner.borrow().tasks[0].get_task_cx_ptr2();
+    /// Generally, the first task in task list is an idle task (we call it zero process later).
+    /// But in ch3, we load apps statically, so the first task is a real app.
+    fn run_first_task(&self) -> ! {
+        let mut inner = self.inner.exclusive_access();
+        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(
+            __switch(&mut _unused as *mut TaskContext, next_task_cx_ptr);
-                &0usize as *const _,
-                next_task_cx,
-            );
         }
+        panic!("unreachable in run_first_task!");
     }
 
+    /// Change the status of current `Running` task into `Ready`.
     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;
     }
 
+    /// Change the status of current `Running` task into `Exited`.
     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;
     }
 
+    /// Find next task to run and return task id.
+    ///
+    /// In this case, we only return the first `Ready` task in task list.
     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)
-            .find(|id| {
+            .find(|id| inner.tasks[*id].task_status == TaskStatus::Ready)
-                inner.tasks[*id].task_status == TaskStatus::Ready
-            })
     }
 
+    /// Switch current `Running` task to the task we have found,
+    /// or there is no `Ready` task and we can exit with all applications completed
     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(
+                __switch(current_task_cx_ptr, next_task_cx_ptr);
-                    current_task_cx,
-                    next_task_cx,
-                );
             }
+            // go back to user mode
         } else {
-            panic!("All applications completed!");
+            println!("All applications completed!");
+            shutdown(false);
         }
     }
+
+    /// get current task id
+    pub fn get_current_id(&self) -> usize {
+        let inner = self.inner.exclusive_access();
+        inner.current_task
+    }
+
+    /// get current task status
+    pub fn get_current_status(&self) -> TaskStatus {
+        let inner = self.inner.exclusive_access();
+        let current = inner.current_task;
+        inner.tasks[current].task_status
+    }
+
+    /// get current task syscall times
+    pub fn get_current_syscall_times(&self) -> [u32; MAX_SYSCALL_NUM] {
+        let inner = self.inner.exclusive_access();
+        let current = inner.current_task;
+        return inner.tasks[current].syscall_times.clone();
+    }
+
+    /// record syscall
+    pub fn mark_syscall(&self, syscall_id: usize) {
+        if syscall_id >= MAX_SYSCALL_NUM {
+            return;
+        }
+        let mut inner = self.inner.exclusive_access();
+        let current = inner.current_task;
+        inner.tasks[current].syscall_times[syscall_id] += 1;
+    }
 }
 
+/// run first task
 pub fn run_first_task() {
     TASK_MANAGER.run_first_task();
 }
 
+/// rust next task
 fn run_next_task() {
     TASK_MANAGER.run_next_task();
 }
 
+/// suspend current task
 fn mark_current_suspended() {
     TASK_MANAGER.mark_current_suspended();
 }
 
+/// exit current task
 fn mark_current_exited() {
     TASK_MANAGER.mark_current_exited();
 }
 
+/// suspend current task, then run next task
 pub fn suspend_current_and_run_next() {
     mark_current_suspended();
     run_next_task();
 }
 
+/// exit current task,  then run next task
 pub fn exit_current_and_run_next() {
     mark_current_exited();
     run_next_task();
-}
+}

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,17 @@
+//! Rust wrapper around `__switch`.
+//!
+//! Switching to a different task's context happens here. The actual
+//! implementation must not be in Rust and (essentially) has to be in assembly
+//! language (Do you know why?), so this module really is just a wrapper around
+//! `switch.S`.
+
+use super::TaskContext;
+use core::arch::global_asm;
+
 global_asm!(include_str!("switch.S"));
 
 extern "C" {
-    pub fn __switch(current_task_cx: *const usize, next_task_cx: *const usize);
+    /// Switch to the context of `next_task_cx_ptr`, saving the current context
+    /// in `current_task_cx_ptr`.
+    pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext);
 }

os/src/task/task.rs

@@ -1,18 +1,29 @@
+//! Types related to task management
+
+use crate::config::MAX_SYSCALL_NUM;
+
+use super::TaskContext;
+
+/// The task control block (TCB) of a task.
+#[derive(Copy, Clone)]
 pub struct TaskControlBlock {
-    pub task_cx_ptr: usize,
+    /// The task status in it's lifecycle
     pub task_status: TaskStatus,
+    /// The task context
+    pub task_cx: TaskContext,
+    /// The numbers of syscall called by task
+    pub syscall_times: [u32; MAX_SYSCALL_NUM],
 }
 
-impl TaskControlBlock {
+/// The status of a task
-    pub fn get_task_cx_ptr2(&self) -> *const usize {
-        &self.task_cx_ptr as *const usize
-    }
-}
-
 #[derive(Copy, Clone, PartialEq)]
 pub enum TaskStatus {
+    /// uninitialized
     UnInit,
+    /// ready to run
     Ready,
+    /// running
     Running,
+    /// exited
     Exited,
-}
+}

os/src/timer.rs

@@ -1,13 +1,23 @@
-use riscv::register::time;
+//! RISC-V timer-related functionality
+
+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 MSEC_PER_SEC: usize = 1000;
 
+/// read the `mtime` register
 pub fn get_time() -> usize {
     time::read()
 }
 
+/// get current time in milliseconds
+pub fn get_time_ms() -> usize {
+    time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
+}
+
+/// set the next timer interrupt
 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/context.rs

@@ -1,23 +1,30 @@
-use riscv::register::sstatus::{Sstatus, self, SPP};
+use riscv::register::sstatus::{self, Sstatus, SPP};
-
+/// Trap Context
 #[repr(C)]
 pub struct TrapContext {
+    /// general regs[0..31]
     pub x: [usize; 32],
+    /// CSR sstatus      
     pub sstatus: Sstatus,
+    /// CSR sepc
     pub sepc: usize,
 }
 
 impl TrapContext {
-    pub fn set_sp(&mut self, sp: usize) { self.x[2] = sp; }
+    /// set stack pointer to x_2 reg (sp)
+    pub fn set_sp(&mut self, sp: usize) {
+        self.x[2] = sp;
+    }
+    /// init app context
     pub fn app_init_context(entry: usize, sp: usize) -> Self {
-        let mut sstatus = sstatus::read();
+        let mut sstatus = sstatus::read(); // CSR sstatus
-        sstatus.set_spp(SPP::User);
+        sstatus.set_spp(SPP::User); //previous privilege mode: user mode
         let mut cx = Self {
             x: [0; 32],
             sstatus,
-            sepc: entry,
+            sepc: entry, // entry point of app
         };
-        cx.set_sp(sp);
+        cx.set_sp(sp); // app's user stack pointer
-        cx
+        cx // return initial Trap Context of app
     }
 }

os/src/trap/mod.rs

@@ -1,58 +1,64 @@
+//! Trap handling functionality
+//!
+//! For rCore, we have a single trap entry point, namely `__alltraps`. At
+//! initialization in [`init()`], we set the `stvec` CSR to point to it.
+//!
+//! All traps go through `__alltraps`, which is defined in `trap.S`. The
+//! assembly language code does just enough work restore the kernel space
+//! context, ensuring that Rust code safely runs, and transfers control to
+//! [`trap_handler()`].
+//!
+//! It then calls different functionality based on what exactly the exception
+//! was. For example, timer interrupts trigger task preemption, and syscalls go
+//! to [`syscall()`].
+
 mod context;
 
+use crate::syscall::syscall;
+use crate::task::{exit_current_and_run_next, suspend_current_and_run_next};
+use crate::timer::set_next_trigger;
+use core::arch::global_asm;
 use riscv::register::{
     mtvec::TrapMode,
-    stvec,
+    scause::{self, Exception, Interrupt, Trap},
-    scause::{
+    sie, stval, stvec,
-        self,
-        Trap,
-        Exception,
-        Interrupt,
-    },
-    stval,
-    sstatus,
-    sie,
 };
-use crate::syscall::syscall;
-use crate::task::{
-    exit_current_and_run_next,
-    suspend_current_and_run_next,
-};
-use crate::timer::set_next_trigger;
 
 global_asm!(include_str!("trap.S"));
 
+/// initialize CSR `stvec` as the entry of `__alltraps`
 pub fn init() {
-    extern "C" { fn __alltraps(); }
+    extern "C" {
+        fn __alltraps();
+    }
     unsafe {
         stvec::write(__alltraps as usize, TrapMode::Direct);
     }
 }
 
-pub fn enable_interrupt() {
+/// timer interrupt enabled
-    unsafe { sstatus::set_sie(); }
-}
-
 pub fn enable_timer_interrupt() {
-    unsafe { sie::set_stimer(); }
+    unsafe {
+        sie::set_stimer();
+    }
 }
 
 #[no_mangle]
+/// handle an interrupt, exception, or system call from user space
 pub fn trap_handler(cx: &mut TrapContext) -> &mut TrapContext {
-    let scause = scause::read();
+    let scause = scause::read(); // get trap cause
-    let stval = stval::read();
+    let stval = stval::read(); // get extra value
     match scause.cause() {
         Trap::Exception(Exception::UserEnvCall) => {
             cx.sepc += 4;
             cx.x[10] = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]) as usize;
         }
-        Trap::Exception(Exception::StoreFault) |
+        Trap::Exception(Exception::StoreFault) | Trap::Exception(Exception::StorePageFault) => {
-        Trap::Exception(Exception::StorePageFault) => {
+            println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.", stval, cx.sepc);
-            println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, core dumped.", stval, cx.sepc);
             exit_current_and_run_next();
         }
         Trap::Exception(Exception::IllegalInstruction) => {
-            println!("[kernel] IllegalInstruction in application, core dumped.");
+            println!("[kernel] IllegalInstruction in application, kernel killed it.");
             exit_current_and_run_next();
         }
         Trap::Interrupt(Interrupt::SupervisorTimer) => {
@@ -60,10 +66,14 @@ pub fn trap_handler(cx: &mut TrapContext) -> &mut TrapContext {
             suspend_current_and_run_next();
         }
         _ => {
-            panic!("Unsupported trap {:?}, stval = {:#x}!", scause.cause(), stval);
+            panic!(
+                "Unsupported trap {:?}, stval = {:#x}!",
+                scause.cause(),
+                stval
+            );
         }
     }
     cx
 }
 
-pub use context::TrapContext;
+pub use context::TrapContext;

rust-toolchain

@@ -1 +0,0 @@
-nightly-2020-11-01

rust-toolchain.toml

@@ -0,0 +1,6 @@
+[toolchain]
+profile = "minimal"
+# use the nightly version of the last stable toolchain, see <https://forge.rust-lang.org/>
+channel = "nightly-2024-05-01"
+components = ["rust-src", "llvm-tools", "rustfmt", "clippy"]
+targets = ["riscv64gc-unknown-none-elf"]

user/.cargo/config.toml

@@ -3,5 +3,5 @@ target = "riscv64gc-unknown-none-elf"
 
 [target.riscv64gc-unknown-none-elf]
 rustflags = [
-    "-Clink-args=-Tsrc/linker.ld",
+    "-Clink-args=-Tsrc/linker.ld", "-Cforce-frame-pointers=yes"
 ]

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,10 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+
+[profile.release]
+debug = true
+
+# [features]
+# board_qemu = []
+# board_k210 = []

user/Makefile

@@ -1,5 +1,5 @@
 TARGET := riscv64gc-unknown-none-elf
-MODE := debug
+MODE := release
 APP_DIR := src/bin
 TARGET_DIR := target/$(TARGET)/$(MODE)
 APPS := $(wildcard $(APP_DIR)/*.rs)
@@ -13,7 +13,7 @@ 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));)
 
 build: binary
 

user/build.py

@@ -1,6 +1,6 @@
 import os
 
-base_address = 0x80100000
+base_address = 0x80400000
 step = 0x20000
 linker = 'src/linker.ld'
 
@@ -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/00power_3.rs

@@ -1,28 +1,16 @@
 #![no_std]
 #![no_main]
 
-#[macro_use]
 extern crate user_lib;
 
-const LEN: usize = 100;
+use user_lib::{
+    println, task_info, TaskInfo,
+};
 
 #[no_mangle]
-fn main() -> i32 {
+pub fn main() -> usize {
-    let p = 3u64;
+    let info = TaskInfo::new();
-    let m = 998244353u64;
+    assert_eq!(0, task_info(&info));
-    let iter: usize = 100000;
+    println!("task_info {:?}", info);
-    let mut s = [0u64; LEN];
-    let mut cur = 0usize;
-    s[cur] = 1;
-    for i in 1..=iter {
-        let next = if cur + 1 == LEN { 0 } else { cur + 1 };
-        s[next] = s[cur] * p % m;
-        cur = next;
-        if i % 10000 == 0 {
-            println!("power_3 [{}/{}]", i, iter);
-        }
-    }
-    println!("{}^{} = {}", p, iter, s[cur]);
-    println!("Test power_3 OK!");
     0
-}
+}

user/src/bin/01power_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/02power_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/03sleep.rs

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

user/src/bin/04taskinfo.rs

@@ -0,0 +1,16 @@
+#![no_std]
+#![no_main]
+
+extern crate user_lib;
+
+use user_lib::{
+    println, task_info, TaskInfo,
+};
+
+#[no_mangle]
+pub fn main() -> usize {
+    let info = TaskInfo::new();
+    assert_eq!(0, task_info(&info));
+    println!("task_info {:?}", info);
+    0
+}

user/src/console.rs

@@ -1,11 +1,13 @@
+use super::write;
 use core::fmt::{self, Write};
-use crate::syscall::{STDOUT, sys_write};
 
 struct Stdout;
 
+const STDOUT: usize = 1;
+
 impl Write for Stdout {
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        sys_write(STDOUT, s.as_bytes());
+        write(STDOUT, s.as_bytes());
         Ok(())
     }
 }
@@ -26,4 +28,4 @@ macro_rules! println {
     ($fmt: literal $(, $($arg: tt)+)?) => {
         $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
     }
-}
+}

user/src/lang_items.rs

@@ -2,9 +2,14 @@
 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 {}
-}
+}

user/src/lib.rs

@@ -1,18 +1,17 @@
 #![no_std]
-#![feature(llvm_asm)]
 #![feature(linkage)]
 #![feature(panic_info_message)]
 
 #[macro_use]
 pub mod console;
-mod syscall;
 mod lang_items;
+mod syscall;
 
 #[no_mangle]
 #[link_section = ".text.entry"]
 pub extern "C" fn _start() -> ! {
     clear_bss();
-    syscall::sys_exit(main());
+    exit(main());
     panic!("unreachable after sys_exit!");
 }
 
@@ -27,9 +26,54 @@ fn clear_bss() {
         fn start_bss();
         fn end_bss();
     }
-    (start_bss as usize..end_bss as usize).for_each(|addr| {
+    (start_bss as usize..end_bss as usize).for_each(|addr| unsafe {
-        unsafe { (addr as *mut u8).write_volatile(0); }
+        (addr as *mut u8).write_volatile(0);
     });
 }
 
-pub use syscall::*;
+use syscall::*;
+
+pub fn write(fd: usize, buf: &[u8]) -> isize {
+    sys_write(fd, buf)
+}
+pub fn exit(exit_code: i32) -> isize {
+    sys_exit(exit_code)
+}
+pub fn yield_() -> isize {
+    sys_yield()
+}
+pub fn get_time() -> isize {
+    sys_get_time()
+}
+
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum TaskStatus {
+    UnInit,
+    Ready,
+    Running,
+    Exited,
+}
+
+const MAX_SYSCALL_NUM: usize = 500;
+
+#[derive(Debug)]
+pub struct TaskInfo {
+    pub status: TaskStatus,
+    pub syscall_times: [u32; MAX_SYSCALL_NUM],
+    pub time: usize,
+}
+
+impl TaskInfo {
+    pub fn new() -> Self {
+        TaskInfo {
+            status: TaskStatus::UnInit,
+            syscall_times: [0; MAX_SYSCALL_NUM],
+            time: 0,
+        }
+    }
+}
+
+pub fn task_info(info: &TaskInfo) -> isize {
+    sys_task_info(info)
+}

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,18 +1,22 @@
-pub const STDOUT: usize = 1;
+use core::arch::asm;
+
+use crate::TaskInfo;
 
 const SYSCALL_WRITE: usize = 64;
 const SYSCALL_EXIT: usize = 93;
 const SYSCALL_YIELD: usize = 124;
 const SYSCALL_GET_TIME: usize = 169;
+pub const SYSCALL_TASK_INFO: usize = 410;
 
 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
@@ -22,8 +26,8 @@ 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_exit(exit_code: i32) -> isize {
-    syscall(SYSCALL_EXIT, [xstate as usize, 0, 0])
+    syscall(SYSCALL_EXIT, [exit_code as usize, 0, 0])
 }
 
 pub fn sys_yield() -> isize {
@@ -32,4 +36,8 @@ pub fn sys_yield() -> isize {
 
 pub fn sys_get_time() -> isize {
     syscall(SYSCALL_GET_TIME, [0, 0, 0])
+}
+
+pub fn sys_task_info(info: &TaskInfo) -> isize {
+    syscall(SYSCALL_TASK_INFO, [info as *const _ as usize, 0, 0])
 }