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

[Ch3] update user module to 2021autumn version

.devcontainer/devcontainer.json

@@ -1,21 +0,0 @@
-{
-  "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

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

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

@@ -1,68 +0,0 @@
-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,16 +1,16 @@
-.*/*
+.idea
-!.github/*
+Cargo.lock
-!.vscode/settings.json
+target
-!.devcontainer/devcontainer.json
-
-**/target/
-**/Cargo.lock
-
 os/src/link_app.S
-os/src/linker.ld
 os/last-*
-os/.gdb_history
+os/Cargo.lock
-os/virt.out
+user/build
+user/target/*
+user/.idea/*
+user/Cargo.lock
+easy-fs/Cargo.lock
+easy-fs/target/*
+easy-fs-fuse/Cargo.lock
+easy-fs-fuse/target/*
 tools/
-pushall.sh
+pushall.sh
-.vscode/*.log

.vscode/settings.json

@@ -1,13 +0,0 @@
-{
-    // 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

@@ -1,72 +1,40 @@
-# syntax=docker/dockerfile:1
+FROM ubuntu:18.04
+LABEL maintainer="dinghao188" \
+      version="1.1" \
+      description="ubuntu 18.04 with tools for tsinghua's rCore-Tutorial-V3"
 
-# Stage 1 Build QEMU
+#install some deps
-# - https://www.qemu.org/download/
+RUN set -x \
-# - https://wiki.qemu.org/Hosts/Linux#Building_QEMU_for_Linux
+    && apt-get update \
-# - https://wiki.qemu.org/Documentation/Platforms/RISCV
+    && 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 
 
-FROM ubuntu:20.04 as build_qemu
+#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 \
 
-ARG QEMU_VERSION=7.0.0
+    #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
 
-RUN sed -i 's/archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \ 
+#for chinese network
-    sed -i 's/security.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \ 
+RUN set -x; \
-    apt-get update && \
+    APT_CONF='/etc/apt/sources.list'; \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y wget build-essential libglib2.0-dev libfdt-dev libpixman-1-dev zlib1g-dev ninja-build
+    CARGO_CONF='/root/.cargo/config'; \
-
+    BASHRC='/root/.bashrc' \
-RUN wget https://download.qemu.org/qemu-${QEMU_VERSION}.tar.xz && \
+    && echo 'export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static' >> $BASHRC \
-    tar xf qemu-${QEMU_VERSION}.tar.xz && \
+    && echo 'export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup' >> $BASHRC \
-    cd qemu-${QEMU_VERSION} && \ 
+    && touch $CARGO_CONF \
-    ./configure --target-list=riscv64-softmmu,riscv64-linux-user && \
+    && echo '[source.crates-io]' > $CARGO_CONF \
-    make -j$(nproc) && \
+    && echo "replace-with = 'ustc'" >> $CARGO_CONF \
-    make install
+    && echo '[source.ustc]' >> $CARGO_CONF \
-
+    && echo 'registry = "git://mirrors.ustc.edu.cn/crates.io-index"' >> $CARGO_CONF
-# 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

@@ -1,12 +1,8 @@
-DOCKER_TAG ?= rcore-tutorial-v3:latest
+DOCKER_NAME ?= dinghao188/rcore-tutorial
 .PHONY: docker build_docker
-	
+
 docker:
-	docker run --rm -it -v ${PWD}:/mnt -w /mnt --name rcore-tutorial-v3 ${DOCKER_TAG} bash
+	docker run --rm -it --mount type=bind,source=$(shell pwd),destination=/mnt ${DOCKER_NAME}
 
 build_docker: 
-	docker build -t ${DOCKER_TAG} --target build .
+	docker build -t ${DOCKER_NAME} .
-
-fmt:
-	cd easy-fs; cargo fmt; cd ../easy-fs-fuse cargo fmt; cd ../os ; cargo fmt; cd ../user; cargo fmt; cd ..
-

README.md

@@ -1,14 +1,8 @@
 # rCore-Tutorial-v3
-rCore-Tutorial version 3.6. See the [Documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/).
+rCore-Tutorial version 3.5. See the [Documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/).
-
-rCore-Tutorial API Docs.  See the [API Docs of Ten OSes ](#OS-API-DOCS)
-
-If you don't know  Rust Language and try to learn it, please visit [Rust Learning Resources](https://github.com/rcore-os/rCore/wiki/study-resource-of-system-programming-in-RUST)
-
-Official QQ group number: 735045051
 
 ## news
-- 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.
+- 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
 
@@ -18,7 +12,7 @@ This project aims to show how to write an **Unix-like OS** running on **RISC-V**
 
 * Platform supported: `qemu-system-riscv64` simulator or dev boards based on [Kendryte K210 SoC](https://canaan.io/product/kendryteai) such as [Maix Dock](https://www.seeedstudio.com/Sipeed-MAIX-Dock-p-4815.html)
 * OS
-  * concurrency of multiple processes each of which contains mutiple native threads
+  * concurrency of multiple processes
   * preemptive scheduling(Round-Robin algorithm)
   * dynamic memory management in kernel
   * virtual memory
@@ -27,233 +21,15 @@ This project aims to show how to write an **Unix-like OS** running on **RISC-V**
 * **only 4K+ LoC**
 * [A detailed documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/) in spite of the lack of comments in the code(English version is not available at present)
 
-## Prerequisites
-
-### Install Rust
-
-See [official guide](https://www.rust-lang.org/tools/install).
-
-Install some tools:
-
-```sh
-$ rustup target add riscv64gc-unknown-none-elf
-$ cargo install cargo-binutils --vers =0.3.3
-$ rustup component add llvm-tools-preview
-$ rustup component add rust-src
-```
-
-### Install Qemu
-
-Here we manually compile and install Qemu 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 ninja-build
-# 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:/path/to/qemu-7.0.0/build
-```
-
-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
+TODO:
-
-```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.
+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.
 
-* chapter 9: need more descripts about different I/O devices
+Overall progress: ch7
-
-Here are the updates since 3.5.0:
 
 ### Completed
 
@@ -267,28 +43,25 @@ Here are the updates since 3.5.0:
 * [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
+* [ ] 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
-* [ ] 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.

easy-fs-fuse/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "easy-fs-fuse"
-version = "0.1.0"
-authors = ["Yifan Wu <shinbokuow@163.com>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-clap = "2.33.3"
-easy-fs = { path = "../easy-fs" }
-rand = "0.8.0"
-
-# [features]
-# board_qemu = []
-# board_k210 = []

easy-fs-fuse/src/main.rs

@@ -1,155 +0,0 @@
-use clap::{App, Arg};
-use easy_fs::{BlockDevice, EasyFileSystem};
-use std::fs::{read_dir, File, OpenOptions};
-use std::io::{Read, Seek, SeekFrom, Write};
-use std::sync::Arc;
-use std::sync::Mutex;
-
-const BLOCK_SZ: usize = 512;
-
-struct BlockFile(Mutex<File>);
-
-impl BlockDevice for BlockFile {
-    fn read_block(&self, block_id: usize, buf: &mut [u8]) {
-        let mut file = self.0.lock().unwrap();
-        file.seek(SeekFrom::Start((block_id * BLOCK_SZ) as u64))
-            .expect("Error when seeking!");
-        assert_eq!(file.read(buf).unwrap(), BLOCK_SZ, "Not a complete block!");
-    }
-
-    fn write_block(&self, block_id: usize, buf: &[u8]) {
-        let mut file = self.0.lock().unwrap();
-        file.seek(SeekFrom::Start((block_id * BLOCK_SZ) as u64))
-            .expect("Error when seeking!");
-        assert_eq!(file.write(buf).unwrap(), BLOCK_SZ, "Not a complete block!");
-    }
-
-    fn handle_irq(&self) {
-        unimplemented!();
-    }
-}
-
-fn main() {
-    easy_fs_pack().expect("Error when packing easy-fs!");
-}
-
-fn easy_fs_pack() -> std::io::Result<()> {
-    let matches = App::new("EasyFileSystem packer")
-        .arg(
-            Arg::with_name("source")
-                .short("s")
-                .long("source")
-                .takes_value(true)
-                .help("Executable source dir(with backslash)"),
-        )
-        .arg(
-            Arg::with_name("target")
-                .short("t")
-                .long("target")
-                .takes_value(true)
-                .help("Executable target dir(with backslash)"),
-        )
-        .get_matches();
-    let src_path = matches.value_of("source").unwrap();
-    let target_path = matches.value_of("target").unwrap();
-    println!("src_path = {}\ntarget_path = {}", src_path, target_path);
-    let block_file = Arc::new(BlockFile(Mutex::new({
-        let f = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(format!("{}{}", target_path, "fs.img"))?;
-        f.set_len(32 * 2048 * 512).unwrap();
-        f
-    })));
-    // 32MiB, at most 4095 files
-    let efs = EasyFileSystem::create(block_file, 32 * 2048, 1);
-    let root_inode = Arc::new(EasyFileSystem::root_inode(&efs));
-    let apps: Vec<_> = read_dir(src_path)
-        .unwrap()
-        .into_iter()
-        .map(|dir_entry| {
-            let mut name_with_ext = dir_entry.unwrap().file_name().into_string().unwrap();
-            name_with_ext.drain(name_with_ext.find('.').unwrap()..name_with_ext.len());
-            name_with_ext
-        })
-        .collect();
-    for app in apps {
-        // load app data from host file system
-        let mut host_file = File::open(format!("{}{}", target_path, app)).unwrap();
-        let mut all_data: Vec<u8> = Vec::new();
-        host_file.read_to_end(&mut all_data).unwrap();
-        // create a file in easy-fs
-        let inode = root_inode.create(app.as_str()).unwrap();
-        // write data to easy-fs
-        inode.write_at(0, all_data.as_slice());
-    }
-    // list apps
-    // for app in root_inode.ls() {
-    //     println!("{}", app);
-    // }
-    Ok(())
-}
-
-#[test]
-fn efs_test() -> std::io::Result<()> {
-    let block_file = Arc::new(BlockFile(Mutex::new({
-        let f = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open("target/fs.img")?;
-        f.set_len(8192 * 512).unwrap();
-        f
-    })));
-    EasyFileSystem::create(block_file.clone(), 4096, 1);
-    let efs = EasyFileSystem::open(block_file.clone());
-    let root_inode = EasyFileSystem::root_inode(&efs);
-    root_inode.create("filea");
-    root_inode.create("fileb");
-    for name in root_inode.ls() {
-        println!("{}", name);
-    }
-    let filea = root_inode.find("filea").unwrap();
-    let greet_str = "Hello, world!";
-    filea.write_at(0, greet_str.as_bytes());
-    //let mut buffer = [0u8; 512];
-    let mut buffer = [0u8; 233];
-    let len = filea.read_at(0, &mut buffer);
-    assert_eq!(greet_str, core::str::from_utf8(&buffer[..len]).unwrap(),);
-
-    let mut random_str_test = |len: usize| {
-        filea.clear();
-        assert_eq!(filea.read_at(0, &mut buffer), 0,);
-        let mut str = String::new();
-        use rand;
-        // random digit
-        for _ in 0..len {
-            str.push(char::from('0' as u8 + rand::random::<u8>() % 10));
-        }
-        filea.write_at(0, str.as_bytes());
-        let mut read_buffer = [0u8; 127];
-        let mut offset = 0usize;
-        let mut read_str = String::new();
-        loop {
-            let len = filea.read_at(offset, &mut read_buffer);
-            if len == 0 {
-                break;
-            }
-            offset += len;
-            read_str.push_str(core::str::from_utf8(&read_buffer[..len]).unwrap());
-        }
-        assert_eq!(str, read_str);
-    };
-
-    random_str_test(4 * BLOCK_SZ);
-    random_str_test(8 * BLOCK_SZ + BLOCK_SZ / 2);
-    random_str_test(100 * BLOCK_SZ);
-    random_str_test(70 * BLOCK_SZ + BLOCK_SZ / 7);
-    random_str_test((12 + 128) * BLOCK_SZ);
-    random_str_test(400 * BLOCK_SZ);
-    random_str_test(1000 * BLOCK_SZ);
-    random_str_test(2000 * BLOCK_SZ);
-
-    Ok(())
-}

easy-fs/.gitignore

@@ -1,3 +0,0 @@
-.idea/
-target/
-Cargo.lock

easy-fs/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "easy-fs"
-version = "0.1.0"
-authors = ["Yifan Wu <shinbokuow@163.com>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-spin = "0.7.0"
-lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
-
-[profile.release]
-debug = true
-
-[features]
-board_qemu = []
-board_k210 = []

easy-fs/src/bitmap.rs

@@ -1,69 +0,0 @@
-use super::{get_block_cache, BlockDevice, BLOCK_SZ};
-use alloc::sync::Arc;
-
-type BitmapBlock = [u64; 64];
-
-const BLOCK_BITS: usize = BLOCK_SZ * 8;
-
-pub struct Bitmap {
-    start_block_id: usize,
-    blocks: usize,
-}
-
-/// Return (block_pos, bits64_pos, inner_pos)
-fn decomposition(mut bit: usize) -> (usize, usize, usize) {
-    let block_pos = bit / BLOCK_BITS;
-    bit %= BLOCK_BITS;
-    (block_pos, bit / 64, bit % 64)
-}
-
-impl Bitmap {
-    pub fn new(start_block_id: usize, blocks: usize) -> Self {
-        Self {
-            start_block_id,
-            blocks,
-        }
-    }
-
-    pub fn alloc(&self, block_device: &Arc<dyn BlockDevice>) -> Option<usize> {
-        for block_id in 0..self.blocks {
-            let pos = get_block_cache(
-                block_id + self.start_block_id as usize,
-                Arc::clone(block_device),
-            )
-            .lock()
-            .modify(0, |bitmap_block: &mut BitmapBlock| {
-                if let Some((bits64_pos, inner_pos)) = bitmap_block
-                    .iter()
-                    .enumerate()
-                    .find(|(_, bits64)| **bits64 != u64::MAX)
-                    .map(|(bits64_pos, bits64)| (bits64_pos, bits64.trailing_ones() as usize))
-                {
-                    // modify cache
-                    bitmap_block[bits64_pos] |= 1u64 << inner_pos;
-                    Some(block_id * BLOCK_BITS + bits64_pos * 64 + inner_pos as usize)
-                } else {
-                    None
-                }
-            });
-            if pos.is_some() {
-                return pos;
-            }
-        }
-        None
-    }
-
-    pub fn dealloc(&self, block_device: &Arc<dyn BlockDevice>, bit: usize) {
-        let (block_pos, bits64_pos, inner_pos) = decomposition(bit);
-        get_block_cache(block_pos + self.start_block_id, Arc::clone(block_device))
-            .lock()
-            .modify(0, |bitmap_block: &mut BitmapBlock| {
-                assert!(bitmap_block[bits64_pos] & (1u64 << inner_pos) > 0);
-                bitmap_block[bits64_pos] -= 1u64 << inner_pos;
-            });
-    }
-
-    pub fn maximum(&self) -> usize {
-        self.blocks * BLOCK_BITS
-    }
-}

easy-fs/src/block_cache.rs

@@ -1,142 +0,0 @@
-use super::{BlockDevice, BLOCK_SZ};
-use alloc::collections::VecDeque;
-use alloc::sync::Arc;
-use alloc::vec;
-use alloc::vec::Vec;
-use lazy_static::*;
-use spin::Mutex;
-
-pub struct BlockCache {
-    cache: Vec<u8>,
-    block_id: usize,
-    block_device: Arc<dyn BlockDevice>,
-    modified: bool,
-}
-
-impl BlockCache {
-    /// Load a new BlockCache from disk.
-    pub fn new(block_id: usize, block_device: Arc<dyn BlockDevice>) -> Self {
-        // for alignment and move effciency
-        let mut cache = vec![0u8; BLOCK_SZ];
-        block_device.read_block(block_id, &mut cache);
-        Self {
-            cache,
-            block_id,
-            block_device,
-            modified: false,
-        }
-    }
-
-    fn addr_of_offset(&self, offset: usize) -> usize {
-        &self.cache[offset] as *const _ as usize
-    }
-
-    pub fn get_ref<T>(&self, offset: usize) -> &T
-    where
-        T: Sized,
-    {
-        let type_size = core::mem::size_of::<T>();
-        assert!(offset + type_size <= BLOCK_SZ);
-        let addr = self.addr_of_offset(offset);
-        unsafe { &*(addr as *const T) }
-    }
-
-    pub fn get_mut<T>(&mut self, offset: usize) -> &mut T
-    where
-        T: Sized,
-    {
-        let type_size = core::mem::size_of::<T>();
-        assert!(offset + type_size <= BLOCK_SZ);
-        self.modified = true;
-        let addr = self.addr_of_offset(offset);
-        unsafe { &mut *(addr as *mut T) }
-    }
-
-    pub fn read<T, V>(&self, offset: usize, f: impl FnOnce(&T) -> V) -> V {
-        f(self.get_ref(offset))
-    }
-
-    pub fn modify<T, V>(&mut self, offset: usize, f: impl FnOnce(&mut T) -> V) -> V {
-        f(self.get_mut(offset))
-    }
-
-    pub fn sync(&mut self) {
-        if self.modified {
-            self.modified = false;
-            self.block_device.write_block(self.block_id, &self.cache);
-        }
-    }
-}
-
-impl Drop for BlockCache {
-    fn drop(&mut self) {
-        self.sync()
-    }
-}
-
-const BLOCK_CACHE_SIZE: usize = 16;
-
-pub struct BlockCacheManager {
-    queue: VecDeque<(usize, Arc<Mutex<BlockCache>>)>,
-}
-
-impl BlockCacheManager {
-    pub fn new() -> Self {
-        Self {
-            queue: VecDeque::new(),
-        }
-    }
-
-    pub fn get_block_cache(
-        &mut self,
-        block_id: usize,
-        block_device: Arc<dyn BlockDevice>,
-    ) -> Arc<Mutex<BlockCache>> {
-        if let Some(pair) = self.queue.iter().find(|pair| pair.0 == block_id) {
-            Arc::clone(&pair.1)
-        } else {
-            // substitute
-            if self.queue.len() == BLOCK_CACHE_SIZE {
-                // from front to tail
-                if let Some((idx, _)) = self
-                    .queue
-                    .iter()
-                    .enumerate()
-                    .find(|(_, pair)| Arc::strong_count(&pair.1) == 1)
-                {
-                    self.queue.drain(idx..=idx);
-                } else {
-                    panic!("Run out of BlockCache!");
-                }
-            }
-            // load block into mem and push back
-            let block_cache = Arc::new(Mutex::new(BlockCache::new(
-                block_id,
-                Arc::clone(&block_device),
-            )));
-            self.queue.push_back((block_id, Arc::clone(&block_cache)));
-            block_cache
-        }
-    }
-}
-
-lazy_static! {
-    pub static ref BLOCK_CACHE_MANAGER: Mutex<BlockCacheManager> =
-        Mutex::new(BlockCacheManager::new());
-}
-
-pub fn get_block_cache(
-    block_id: usize,
-    block_device: Arc<dyn BlockDevice>,
-) -> Arc<Mutex<BlockCache>> {
-    BLOCK_CACHE_MANAGER
-        .lock()
-        .get_block_cache(block_id, block_device)
-}
-
-pub fn block_cache_sync_all() {
-    let manager = BLOCK_CACHE_MANAGER.lock();
-    for (_, cache) in manager.queue.iter() {
-        cache.lock().sync();
-    }
-}

easy-fs/src/block_dev.rs

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

easy-fs/src/efs.rs

@@ -1,147 +0,0 @@
-use super::{
-    block_cache_sync_all, get_block_cache, Bitmap, BlockDevice, DiskInode, DiskInodeType, Inode,
-    SuperBlock,
-};
-use crate::BLOCK_SZ;
-use alloc::sync::Arc;
-use spin::Mutex;
-
-pub struct EasyFileSystem {
-    pub block_device: Arc<dyn BlockDevice>,
-    pub inode_bitmap: Bitmap,
-    pub data_bitmap: Bitmap,
-    inode_area_start_block: u32,
-    data_area_start_block: u32,
-}
-
-type DataBlock = [u8; BLOCK_SZ];
-
-impl EasyFileSystem {
-    pub fn create(
-        block_device: Arc<dyn BlockDevice>,
-        total_blocks: u32,
-        inode_bitmap_blocks: u32,
-    ) -> Arc<Mutex<Self>> {
-        // calculate block size of areas & create bitmaps
-        let inode_bitmap = Bitmap::new(1, inode_bitmap_blocks as usize);
-        let inode_num = inode_bitmap.maximum();
-        let inode_area_blocks =
-            ((inode_num * core::mem::size_of::<DiskInode>() + BLOCK_SZ - 1) / BLOCK_SZ) as u32;
-        let inode_total_blocks = inode_bitmap_blocks + inode_area_blocks;
-        let data_total_blocks = total_blocks - 1 - inode_total_blocks;
-        let data_bitmap_blocks = (data_total_blocks + 4096) / 4097;
-        let data_area_blocks = data_total_blocks - data_bitmap_blocks;
-        let data_bitmap = Bitmap::new(
-            (1 + inode_bitmap_blocks + inode_area_blocks) as usize,
-            data_bitmap_blocks as usize,
-        );
-        let mut efs = Self {
-            block_device: Arc::clone(&block_device),
-            inode_bitmap,
-            data_bitmap,
-            inode_area_start_block: 1 + inode_bitmap_blocks,
-            data_area_start_block: 1 + inode_total_blocks + data_bitmap_blocks,
-        };
-        // clear all blocks
-        for i in 0..total_blocks {
-            get_block_cache(i as usize, Arc::clone(&block_device))
-                .lock()
-                .modify(0, |data_block: &mut DataBlock| {
-                    for byte in data_block.iter_mut() {
-                        *byte = 0;
-                    }
-                });
-        }
-        // initialize SuperBlock
-        get_block_cache(0, Arc::clone(&block_device)).lock().modify(
-            0,
-            |super_block: &mut SuperBlock| {
-                super_block.initialize(
-                    total_blocks,
-                    inode_bitmap_blocks,
-                    inode_area_blocks,
-                    data_bitmap_blocks,
-                    data_area_blocks,
-                );
-            },
-        );
-        // write back immediately
-        // create a inode for root node "/"
-        assert_eq!(efs.alloc_inode(), 0);
-        let (root_inode_block_id, root_inode_offset) = efs.get_disk_inode_pos(0);
-        get_block_cache(root_inode_block_id as usize, Arc::clone(&block_device))
-            .lock()
-            .modify(root_inode_offset, |disk_inode: &mut DiskInode| {
-                disk_inode.initialize(DiskInodeType::Directory);
-            });
-        block_cache_sync_all();
-        Arc::new(Mutex::new(efs))
-    }
-
-    pub fn open(block_device: Arc<dyn BlockDevice>) -> Arc<Mutex<Self>> {
-        // read SuperBlock
-        get_block_cache(0, Arc::clone(&block_device))
-            .lock()
-            .read(0, |super_block: &SuperBlock| {
-                assert!(super_block.is_valid(), "Error loading EFS!");
-                let inode_total_blocks =
-                    super_block.inode_bitmap_blocks + super_block.inode_area_blocks;
-                let efs = Self {
-                    block_device,
-                    inode_bitmap: Bitmap::new(1, super_block.inode_bitmap_blocks as usize),
-                    data_bitmap: Bitmap::new(
-                        (1 + inode_total_blocks) as usize,
-                        super_block.data_bitmap_blocks as usize,
-                    ),
-                    inode_area_start_block: 1 + super_block.inode_bitmap_blocks,
-                    data_area_start_block: 1 + inode_total_blocks + super_block.data_bitmap_blocks,
-                };
-                Arc::new(Mutex::new(efs))
-            })
-    }
-
-    pub fn root_inode(efs: &Arc<Mutex<Self>>) -> Inode {
-        let block_device = Arc::clone(&efs.lock().block_device);
-        // acquire efs lock temporarily
-        let (block_id, block_offset) = efs.lock().get_disk_inode_pos(0);
-        // release efs lock
-        Inode::new(block_id, block_offset, Arc::clone(efs), block_device)
-    }
-
-    pub fn get_disk_inode_pos(&self, inode_id: u32) -> (u32, usize) {
-        let inode_size = core::mem::size_of::<DiskInode>();
-        let inodes_per_block = (BLOCK_SZ / inode_size) as u32;
-        let block_id = self.inode_area_start_block + inode_id / inodes_per_block;
-        (
-            block_id,
-            (inode_id % inodes_per_block) as usize * inode_size,
-        )
-    }
-
-    pub fn get_data_block_id(&self, data_block_id: u32) -> u32 {
-        self.data_area_start_block + data_block_id
-    }
-
-    pub fn alloc_inode(&mut self) -> u32 {
-        self.inode_bitmap.alloc(&self.block_device).unwrap() as u32
-    }
-
-    /// Return a block ID not ID in the data area.
-    pub fn alloc_data(&mut self) -> u32 {
-        self.data_bitmap.alloc(&self.block_device).unwrap() as u32 + self.data_area_start_block
-    }
-
-    pub fn dealloc_data(&mut self, block_id: u32) {
-        get_block_cache(block_id as usize, Arc::clone(&self.block_device))
-            .lock()
-            .modify(0, |data_block: &mut DataBlock| {
-                data_block.iter_mut().for_each(|p| {
-                    *p = 0;
-                })
-            });
-        self.data_bitmap.dealloc(
-            &self.block_device,
-            (block_id - self.data_area_start_block) as usize,
-        )
-    }
-}

easy-fs/src/layout.rs

@@ -1,409 +0,0 @@
-use super::{get_block_cache, BlockDevice, BLOCK_SZ};
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use core::fmt::{Debug, Formatter, Result};
-
-const EFS_MAGIC: u32 = 0x3b800001;
-const INODE_DIRECT_COUNT: usize = 28;
-const NAME_LENGTH_LIMIT: usize = 27;
-const INODE_INDIRECT1_COUNT: usize = BLOCK_SZ / 4;
-const INODE_INDIRECT2_COUNT: usize = INODE_INDIRECT1_COUNT * INODE_INDIRECT1_COUNT;
-const DIRECT_BOUND: usize = INODE_DIRECT_COUNT;
-const INDIRECT1_BOUND: usize = DIRECT_BOUND + INODE_INDIRECT1_COUNT;
-#[allow(unused)]
-const INDIRECT2_BOUND: usize = INDIRECT1_BOUND + INODE_INDIRECT2_COUNT;
-
-#[repr(C)]
-pub struct SuperBlock {
-    magic: u32,
-    pub total_blocks: u32,
-    pub inode_bitmap_blocks: u32,
-    pub inode_area_blocks: u32,
-    pub data_bitmap_blocks: u32,
-    pub data_area_blocks: u32,
-}
-
-impl Debug for SuperBlock {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        f.debug_struct("SuperBlock")
-            .field("total_blocks", &self.total_blocks)
-            .field("inode_bitmap_blocks", &self.inode_bitmap_blocks)
-            .field("inode_area_blocks", &self.inode_area_blocks)
-            .field("data_bitmap_blocks", &self.data_bitmap_blocks)
-            .field("data_area_blocks", &self.data_area_blocks)
-            .finish()
-    }
-}
-
-impl SuperBlock {
-    pub fn initialize(
-        &mut self,
-        total_blocks: u32,
-        inode_bitmap_blocks: u32,
-        inode_area_blocks: u32,
-        data_bitmap_blocks: u32,
-        data_area_blocks: u32,
-    ) {
-        *self = Self {
-            magic: EFS_MAGIC,
-            total_blocks,
-            inode_bitmap_blocks,
-            inode_area_blocks,
-            data_bitmap_blocks,
-            data_area_blocks,
-        }
-    }
-    pub fn is_valid(&self) -> bool {
-        self.magic == EFS_MAGIC
-    }
-}
-
-#[derive(PartialEq)]
-pub enum DiskInodeType {
-    File,
-    Directory,
-}
-
-type IndirectBlock = [u32; BLOCK_SZ / 4];
-type DataBlock = [u8; BLOCK_SZ];
-
-#[repr(C)]
-pub struct DiskInode {
-    pub size: u32,
-    pub direct: [u32; INODE_DIRECT_COUNT],
-    pub indirect1: u32,
-    pub indirect2: u32,
-    type_: DiskInodeType,
-}
-
-impl DiskInode {
-    /// indirect1 and indirect2 block are allocated only when they are needed.
-    pub fn initialize(&mut self, type_: DiskInodeType) {
-        self.size = 0;
-        self.direct.iter_mut().for_each(|v| *v = 0);
-        self.indirect1 = 0;
-        self.indirect2 = 0;
-        self.type_ = type_;
-    }
-    pub fn is_dir(&self) -> bool {
-        self.type_ == DiskInodeType::Directory
-    }
-    #[allow(unused)]
-    pub fn is_file(&self) -> bool {
-        self.type_ == DiskInodeType::File
-    }
-    /// Return block number correspond to size.
-    pub fn data_blocks(&self) -> u32 {
-        Self::_data_blocks(self.size)
-    }
-    fn _data_blocks(size: u32) -> u32 {
-        (size + BLOCK_SZ as u32 - 1) / BLOCK_SZ as u32
-    }
-    /// Return number of blocks needed include indirect1/2.
-    pub fn total_blocks(size: u32) -> u32 {
-        let data_blocks = Self::_data_blocks(size) as usize;
-        let mut total = data_blocks as usize;
-        // indirect1
-        if data_blocks > INODE_DIRECT_COUNT {
-            total += 1;
-        }
-        // indirect2
-        if data_blocks > INDIRECT1_BOUND {
-            total += 1;
-            // sub indirect1
-            total +=
-                (data_blocks - INDIRECT1_BOUND + INODE_INDIRECT1_COUNT - 1) / INODE_INDIRECT1_COUNT;
-        }
-        total as u32
-    }
-    pub fn blocks_num_needed(&self, new_size: u32) -> u32 {
-        assert!(new_size >= self.size);
-        Self::total_blocks(new_size) - Self::total_blocks(self.size)
-    }
-    pub fn get_block_id(&self, inner_id: u32, block_device: &Arc<dyn BlockDevice>) -> u32 {
-        let inner_id = inner_id as usize;
-        if inner_id < INODE_DIRECT_COUNT {
-            self.direct[inner_id]
-        } else if inner_id < INDIRECT1_BOUND {
-            get_block_cache(self.indirect1 as usize, Arc::clone(block_device))
-                .lock()
-                .read(0, |indirect_block: &IndirectBlock| {
-                    indirect_block[inner_id - INODE_DIRECT_COUNT]
-                })
-        } else {
-            let last = inner_id - INDIRECT1_BOUND;
-            let indirect1 = get_block_cache(self.indirect2 as usize, Arc::clone(block_device))
-                .lock()
-                .read(0, |indirect2: &IndirectBlock| {
-                    indirect2[last / INODE_INDIRECT1_COUNT]
-                });
-            get_block_cache(indirect1 as usize, Arc::clone(block_device))
-                .lock()
-                .read(0, |indirect1: &IndirectBlock| {
-                    indirect1[last % INODE_INDIRECT1_COUNT]
-                })
-        }
-    }
-    pub fn increase_size(
-        &mut self,
-        new_size: u32,
-        new_blocks: Vec<u32>,
-        block_device: &Arc<dyn BlockDevice>,
-    ) {
-        let mut current_blocks = self.data_blocks();
-        self.size = new_size;
-        let mut total_blocks = self.data_blocks();
-        let mut new_blocks = new_blocks.into_iter();
-        // fill direct
-        while current_blocks < total_blocks.min(INODE_DIRECT_COUNT as u32) {
-            self.direct[current_blocks as usize] = new_blocks.next().unwrap();
-            current_blocks += 1;
-        }
-        // alloc indirect1
-        if total_blocks > INODE_DIRECT_COUNT as u32 {
-            if current_blocks == INODE_DIRECT_COUNT as u32 {
-                self.indirect1 = new_blocks.next().unwrap();
-            }
-            current_blocks -= INODE_DIRECT_COUNT as u32;
-            total_blocks -= INODE_DIRECT_COUNT as u32;
-        } else {
-            return;
-        }
-        // fill indirect1
-        get_block_cache(self.indirect1 as usize, Arc::clone(block_device))
-            .lock()
-            .modify(0, |indirect1: &mut IndirectBlock| {
-                while current_blocks < total_blocks.min(INODE_INDIRECT1_COUNT as u32) {
-                    indirect1[current_blocks as usize] = new_blocks.next().unwrap();
-                    current_blocks += 1;
-                }
-            });
-        // alloc indirect2
-        if total_blocks > INODE_INDIRECT1_COUNT as u32 {
-            if current_blocks == INODE_INDIRECT1_COUNT as u32 {
-                self.indirect2 = new_blocks.next().unwrap();
-            }
-            current_blocks -= INODE_INDIRECT1_COUNT as u32;
-            total_blocks -= INODE_INDIRECT1_COUNT as u32;
-        } else {
-            return;
-        }
-        // fill indirect2 from (a0, b0) -> (a1, b1)
-        let mut a0 = current_blocks as usize / INODE_INDIRECT1_COUNT;
-        let mut b0 = current_blocks as usize % INODE_INDIRECT1_COUNT;
-        let a1 = total_blocks as usize / INODE_INDIRECT1_COUNT;
-        let b1 = total_blocks as usize % INODE_INDIRECT1_COUNT;
-        // alloc low-level indirect1
-        get_block_cache(self.indirect2 as usize, Arc::clone(block_device))
-            .lock()
-            .modify(0, |indirect2: &mut IndirectBlock| {
-                while (a0 < a1) || (a0 == a1 && b0 < b1) {
-                    if b0 == 0 {
-                        indirect2[a0] = new_blocks.next().unwrap();
-                    }
-                    // fill current
-                    get_block_cache(indirect2[a0] as usize, Arc::clone(block_device))
-                        .lock()
-                        .modify(0, |indirect1: &mut IndirectBlock| {
-                            indirect1[b0] = new_blocks.next().unwrap();
-                        });
-                    // move to next
-                    b0 += 1;
-                    if b0 == INODE_INDIRECT1_COUNT {
-                        b0 = 0;
-                        a0 += 1;
-                    }
-                }
-            });
-    }
-
-    /// Clear size to zero and return blocks that should be deallocated.
-    ///
-    /// We will clear the block contents to zero later.
-    pub fn clear_size(&mut self, block_device: &Arc<dyn BlockDevice>) -> Vec<u32> {
-        let mut v: Vec<u32> = Vec::new();
-        let mut data_blocks = self.data_blocks() as usize;
-        self.size = 0;
-        let mut current_blocks = 0usize;
-        // direct
-        while current_blocks < data_blocks.min(INODE_DIRECT_COUNT) {
-            v.push(self.direct[current_blocks]);
-            self.direct[current_blocks] = 0;
-            current_blocks += 1;
-        }
-        // indirect1 block
-        if data_blocks > INODE_DIRECT_COUNT {
-            v.push(self.indirect1);
-            data_blocks -= INODE_DIRECT_COUNT;
-            current_blocks = 0;
-        } else {
-            return v;
-        }
-        // indirect1
-        get_block_cache(self.indirect1 as usize, Arc::clone(block_device))
-            .lock()
-            .modify(0, |indirect1: &mut IndirectBlock| {
-                while current_blocks < data_blocks.min(INODE_INDIRECT1_COUNT) {
-                    v.push(indirect1[current_blocks]);
-                    //indirect1[current_blocks] = 0;
-                    current_blocks += 1;
-                }
-            });
-        self.indirect1 = 0;
-        // indirect2 block
-        if data_blocks > INODE_INDIRECT1_COUNT {
-            v.push(self.indirect2);
-            data_blocks -= INODE_INDIRECT1_COUNT;
-        } else {
-            return v;
-        }
-        // indirect2
-        assert!(data_blocks <= INODE_INDIRECT2_COUNT);
-        let a1 = data_blocks / INODE_INDIRECT1_COUNT;
-        let b1 = data_blocks % INODE_INDIRECT1_COUNT;
-        get_block_cache(self.indirect2 as usize, Arc::clone(block_device))
-            .lock()
-            .modify(0, |indirect2: &mut IndirectBlock| {
-                // full indirect1 blocks
-                for entry in indirect2.iter_mut().take(a1) {
-                    v.push(*entry);
-                    get_block_cache(*entry as usize, Arc::clone(block_device))
-                        .lock()
-                        .modify(0, |indirect1: &mut IndirectBlock| {
-                            for entry in indirect1.iter() {
-                                v.push(*entry);
-                            }
-                        });
-                }
-                // last indirect1 block
-                if b1 > 0 {
-                    v.push(indirect2[a1]);
-                    get_block_cache(indirect2[a1] as usize, Arc::clone(block_device))
-                        .lock()
-                        .modify(0, |indirect1: &mut IndirectBlock| {
-                            for entry in indirect1.iter().take(b1) {
-                                v.push(*entry);
-                            }
-                        });
-                    //indirect2[a1] = 0;
-                }
-            });
-        self.indirect2 = 0;
-        v
-    }
-    pub fn read_at(
-        &self,
-        offset: usize,
-        buf: &mut [u8],
-        block_device: &Arc<dyn BlockDevice>,
-    ) -> usize {
-        let mut start = offset;
-        let end = (offset + buf.len()).min(self.size as usize);
-        if start >= end {
-            return 0;
-        }
-        let mut start_block = start / BLOCK_SZ;
-        let mut read_size = 0usize;
-        loop {
-            // calculate end of current block
-            let mut end_current_block = (start / BLOCK_SZ + 1) * BLOCK_SZ;
-            end_current_block = end_current_block.min(end);
-            // read and update read size
-            let block_read_size = end_current_block - start;
-            let dst = &mut buf[read_size..read_size + block_read_size];
-            get_block_cache(
-                self.get_block_id(start_block as u32, block_device) as usize,
-                Arc::clone(block_device),
-            )
-            .lock()
-            .read(0, |data_block: &DataBlock| {
-                let src = &data_block[start % BLOCK_SZ..start % BLOCK_SZ + block_read_size];
-                dst.copy_from_slice(src);
-            });
-            read_size += block_read_size;
-            // move to next block
-            if end_current_block == end {
-                break;
-            }
-            start_block += 1;
-            start = end_current_block;
-        }
-        read_size
-    }
-    /// File size must be adjusted before.
-    pub fn write_at(
-        &mut self,
-        offset: usize,
-        buf: &[u8],
-        block_device: &Arc<dyn BlockDevice>,
-    ) -> usize {
-        let mut start = offset;
-        let end = (offset + buf.len()).min(self.size as usize);
-        assert!(start <= end);
-        let mut start_block = start / BLOCK_SZ;
-        let mut write_size = 0usize;
-        loop {
-            // calculate end of current block
-            let mut end_current_block = (start / BLOCK_SZ + 1) * BLOCK_SZ;
-            end_current_block = end_current_block.min(end);
-            // write and update write size
-            let block_write_size = end_current_block - start;
-            get_block_cache(
-                self.get_block_id(start_block as u32, block_device) as usize,
-                Arc::clone(block_device),
-            )
-            .lock()
-            .modify(0, |data_block: &mut DataBlock| {
-                let src = &buf[write_size..write_size + block_write_size];
-                let dst = &mut data_block[start % BLOCK_SZ..start % BLOCK_SZ + block_write_size];
-                dst.copy_from_slice(src);
-            });
-            write_size += block_write_size;
-            // move to next block
-            if end_current_block == end {
-                break;
-            }
-            start_block += 1;
-            start = end_current_block;
-        }
-        write_size
-    }
-}
-
-#[repr(C)]
-pub struct DirEntry {
-    name: [u8; NAME_LENGTH_LIMIT + 1],
-    inode_number: u32,
-}
-
-pub const DIRENT_SZ: usize = 32;
-
-impl DirEntry {
-    pub fn empty() -> Self {
-        Self {
-            name: [0u8; NAME_LENGTH_LIMIT + 1],
-            inode_number: 0,
-        }
-    }
-    pub fn new(name: &str, inode_number: u32) -> Self {
-        let mut bytes = [0u8; NAME_LENGTH_LIMIT + 1];
-        bytes[..name.len()].copy_from_slice(name.as_bytes());
-        Self {
-            name: bytes,
-            inode_number,
-        }
-    }
-    pub fn as_bytes(&self) -> &[u8] {
-        unsafe { core::slice::from_raw_parts(self as *const _ as usize as *const u8, DIRENT_SZ) }
-    }
-    pub fn as_bytes_mut(&mut self) -> &mut [u8] {
-        unsafe { core::slice::from_raw_parts_mut(self as *mut _ as usize as *mut u8, DIRENT_SZ) }
-    }
-    pub fn name(&self) -> &str {
-        let len = (0usize..).find(|i| self.name[*i] == 0).unwrap();
-        core::str::from_utf8(&self.name[..len]).unwrap()
-    }
-    pub fn inode_number(&self) -> u32 {
-        self.inode_number
-    }
-}

easy-fs/src/lib.rs

@@ -1,18 +0,0 @@
-#![no_std]
-
-extern crate alloc;
-
-mod bitmap;
-mod block_cache;
-mod block_dev;
-mod efs;
-mod layout;
-mod vfs;
-
-pub const BLOCK_SZ: usize = 512;
-use bitmap::Bitmap;
-use block_cache::{block_cache_sync_all, get_block_cache};
-pub use block_dev::BlockDevice;
-pub use efs::EasyFileSystem;
-use layout::*;
-pub use vfs::Inode;

easy-fs/src/vfs.rs

@@ -1,186 +0,0 @@
-use super::{
-    block_cache_sync_all, get_block_cache, BlockDevice, DirEntry, DiskInode, DiskInodeType,
-    EasyFileSystem, DIRENT_SZ,
-};
-use alloc::string::String;
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use spin::{Mutex, MutexGuard};
-
-pub struct Inode {
-    block_id: usize,
-    block_offset: usize,
-    fs: Arc<Mutex<EasyFileSystem>>,
-    block_device: Arc<dyn BlockDevice>,
-}
-
-impl Inode {
-    /// We should not acquire efs lock here.
-    pub fn new(
-        block_id: u32,
-        block_offset: usize,
-        fs: Arc<Mutex<EasyFileSystem>>,
-        block_device: Arc<dyn BlockDevice>,
-    ) -> Self {
-        Self {
-            block_id: block_id as usize,
-            block_offset,
-            fs,
-            block_device,
-        }
-    }
-
-    fn read_disk_inode<V>(&self, f: impl FnOnce(&DiskInode) -> V) -> V {
-        get_block_cache(self.block_id, Arc::clone(&self.block_device))
-            .lock()
-            .read(self.block_offset, f)
-    }
-
-    fn modify_disk_inode<V>(&self, f: impl FnOnce(&mut DiskInode) -> V) -> V {
-        get_block_cache(self.block_id, Arc::clone(&self.block_device))
-            .lock()
-            .modify(self.block_offset, f)
-    }
-
-    fn find_inode_id(&self, name: &str, disk_inode: &DiskInode) -> Option<u32> {
-        // assert it is a directory
-        assert!(disk_inode.is_dir());
-        let file_count = (disk_inode.size as usize) / DIRENT_SZ;
-        let mut dirent = DirEntry::empty();
-        for i in 0..file_count {
-            assert_eq!(
-                disk_inode.read_at(DIRENT_SZ * i, dirent.as_bytes_mut(), &self.block_device,),
-                DIRENT_SZ,
-            );
-            if dirent.name() == name {
-                return Some(dirent.inode_number() as u32);
-            }
-        }
-        None
-    }
-
-    pub fn find(&self, name: &str) -> Option<Arc<Inode>> {
-        let fs = self.fs.lock();
-        self.read_disk_inode(|disk_inode| {
-            self.find_inode_id(name, disk_inode).map(|inode_id| {
-                let (block_id, block_offset) = fs.get_disk_inode_pos(inode_id);
-                Arc::new(Self::new(
-                    block_id,
-                    block_offset,
-                    self.fs.clone(),
-                    self.block_device.clone(),
-                ))
-            })
-        })
-    }
-
-    fn increase_size(
-        &self,
-        new_size: u32,
-        disk_inode: &mut DiskInode,
-        fs: &mut MutexGuard<EasyFileSystem>,
-    ) {
-        if new_size < disk_inode.size {
-            return;
-        }
-        let blocks_needed = disk_inode.blocks_num_needed(new_size);
-        let mut v: Vec<u32> = Vec::new();
-        for _ in 0..blocks_needed {
-            v.push(fs.alloc_data());
-        }
-        disk_inode.increase_size(new_size, v, &self.block_device);
-    }
-
-    pub fn create(&self, name: &str) -> Option<Arc<Inode>> {
-        let mut fs = self.fs.lock();
-        let op = |root_inode: &mut DiskInode| {
-            // assert it is a directory
-            assert!(root_inode.is_dir());
-            // has the file been created?
-            self.find_inode_id(name, root_inode)
-        };
-        if self.modify_disk_inode(op).is_some() {
-            return None;
-        }
-        // create a new file
-        // alloc a inode with an indirect block
-        let new_inode_id = fs.alloc_inode();
-        // initialize inode
-        let (new_inode_block_id, new_inode_block_offset) = fs.get_disk_inode_pos(new_inode_id);
-        get_block_cache(new_inode_block_id as usize, Arc::clone(&self.block_device))
-            .lock()
-            .modify(new_inode_block_offset, |new_inode: &mut DiskInode| {
-                new_inode.initialize(DiskInodeType::File);
-            });
-        self.modify_disk_inode(|root_inode| {
-            // append file in the dirent
-            let file_count = (root_inode.size as usize) / DIRENT_SZ;
-            let new_size = (file_count + 1) * DIRENT_SZ;
-            // increase size
-            self.increase_size(new_size as u32, root_inode, &mut fs);
-            // write dirent
-            let dirent = DirEntry::new(name, new_inode_id);
-            root_inode.write_at(
-                file_count * DIRENT_SZ,
-                dirent.as_bytes(),
-                &self.block_device,
-            );
-        });
-
-        let (block_id, block_offset) = fs.get_disk_inode_pos(new_inode_id);
-        block_cache_sync_all();
-        // return inode
-        Some(Arc::new(Self::new(
-            block_id,
-            block_offset,
-            self.fs.clone(),
-            self.block_device.clone(),
-        )))
-        // release efs lock automatically by compiler
-    }
-
-    pub fn ls(&self) -> Vec<String> {
-        let _fs = self.fs.lock();
-        self.read_disk_inode(|disk_inode| {
-            let file_count = (disk_inode.size as usize) / DIRENT_SZ;
-            let mut v: Vec<String> = Vec::new();
-            for i in 0..file_count {
-                let mut dirent = DirEntry::empty();
-                assert_eq!(
-                    disk_inode.read_at(i * DIRENT_SZ, dirent.as_bytes_mut(), &self.block_device,),
-                    DIRENT_SZ,
-                );
-                v.push(String::from(dirent.name()));
-            }
-            v
-        })
-    }
-
-    pub fn read_at(&self, offset: usize, buf: &mut [u8]) -> usize {
-        let _fs = self.fs.lock();
-        self.read_disk_inode(|disk_inode| disk_inode.read_at(offset, buf, &self.block_device))
-    }
-
-    pub fn write_at(&self, offset: usize, buf: &[u8]) -> usize {
-        let mut fs = self.fs.lock();
-        let size = self.modify_disk_inode(|disk_inode| {
-            self.increase_size((offset + buf.len()) as u32, disk_inode, &mut fs);
-            disk_inode.write_at(offset, buf, &self.block_device)
-        });
-        block_cache_sync_all();
-        size
-    }
-
-    pub fn clear(&self) {
-        let mut fs = self.fs.lock();
-        self.modify_disk_inode(|disk_inode| {
-            let size = disk_inode.size;
-            let data_blocks_dealloc = disk_inode.clear_size(&self.block_device);
-            assert!(data_blocks_dealloc.len() == DiskInode::total_blocks(size) as usize);
-            for data_block in data_blocks_dealloc.into_iter() {
-                fs.dealloc_data(data_block);
-            }
-        });
-        block_cache_sync_all();
-    }
-}

os/Cargo.toml

@@ -2,24 +2,14 @@
 name = "os"
 version = "0.1.0"
 authors = ["Yifan Wu <shinbokuow@163.com>"]
-edition = "2021"
+edition = "2018"
 
 # 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"] }
-buddy_system_allocator = "0.6"
-bitflags = "1.2.1"
-xmas-elf = "0.7.0"
-volatile = "0.3"
-virtio-drivers = { git = "https://github.com/rcore-os/virtio-drivers", rev = "4ee80e5" }
-lose-net-stack = { git = "https://github.com/yfblock/lose-net-stack", rev = "db42380" }
-easy-fs = { path = "../easy-fs" }
-embedded-graphics = "0.7.1"
-tinybmp = "0.3.1"
-log = "0.4"
-sbi-rt = { version = "0.0.2", features = ["legacy"] }
 
-[profile.release]
+[features]
-debug = true
+board_qemu = []
+board_k210 = []

os/Makefile

@@ -4,27 +4,23 @@ MODE := release
 KERNEL_ELF := target/$(TARGET)/$(MODE)/os
 KERNEL_BIN := $(KERNEL_ELF).bin
 DISASM_TMP := target/$(TARGET)/$(MODE)/asm
-FS_IMG := ../user/target/$(TARGET)/$(MODE)/fs.img
-APPS := ../user/src/bin/*
 
 # BOARD
-BOARD := qemu
+BOARD ?= qemu
 SBI ?= rustsbi
 BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
-
+K210_BOOTLOADER_SIZE := 131072
-# GUI
-GUI ?= off
-ifeq ($(GUI), off)
-	GUI_OPTION := -display none
-endif
-
-# Building mode argument
-ifeq ($(MODE), release)
-	MODE_ARG := --release
-endif
 
 # KERNEL ENTRY
-KERNEL_ENTRY_PA := 0x80200000
+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
 
 # Binutils
 OBJDUMP := rust-objdump --arch-name=riscv64
@@ -33,31 +29,31 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
 # Disassembly
 DISASM ?= -x
 
-# Run usertests or usershell
+TEST ?= 0
-TEST ?=
 
-build: env $(KERNEL_BIN) fs-img 
+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
+	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 $@
 
-fs-img: $(APPS)
-	@cd ../user && make build TEST=$(TEST)
-	@rm -f $(FS_IMG)
-	@cd ../easy-fs-fuse && cargo run --release -- -s ../user/src/bin/ -t ../user/target/riscv64gc-unknown-none-elf/release/
-
-$(APPS):
-
 kernel:
+	@cd ../user && make build TEST=$(TEST)
 	@echo Platform: $(BOARD)
 	@cp src/linker-$(BOARD).ld src/linker.ld
-	@cargo build --release
+	@cargo build --release --features "board_$(BOARD)"
 	@rm src/linker.ld
 
 clean:
@@ -68,45 +64,34 @@ disasm: kernel
 
 disasm-vim: kernel
 	@$(OBJDUMP) $(DISASM) $(KERNEL_ELF) > $(DISASM_TMP)
-	@nvim $(DISASM_TMP)
+	@vim $(DISASM_TMP)
 	@rm $(DISASM_TMP)
 
 run: run-inner
 
-QEMU_ARGS := -machine virt \
+	
-			 -bios $(BOOTLOADER) \
-			 -serial stdio \
-			 $(GUI_OPTION) \
-			 -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) \
-			 -drive file=$(FS_IMG),if=none,format=raw,id=x0 \
-			 -device virtio-blk-device,drive=x0 \
-			 -device virtio-gpu-device \
-			 -device virtio-keyboard-device \
-			 -device virtio-mouse-device \
-			 -device virtio-net-device,netdev=net0 \
-			 -netdev user,id=net0,hostfwd=udp::6200-:2000,hostfwd=tcp::6201-:80
 
-fdt:
+run-inner: build
-	@qemu-system-riscv64 -M 128m -machine virt,dumpdtb=virt.out
+ifeq ($(BOARD),qemu)
-	fdtdump virt.out
+	@qemu-system-riscv64 \
+		-machine virt \
+		-nographic \
+		-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=$(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)
+	python3 -m serial.tools.miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
+endif
 
-QEMU_NAME := qemu-system-riscv64
+debug: build
-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 $(QEMU_ARGS) -s -S" && \
+		"qemu-system-riscv64 -machine virt -nographic -bios $(BOOTLOADER) -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) -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
 
-gdbserver: qemu-version-check build
+.PHONY: build env kernel clean disasm disasm-vim run-inner switch-check
-	@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 fs-img gdbserver gdbclient fdt qemu-version-check

os/build.rs

@@ -1,6 +1,56 @@
-static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/release/";
+use std::fs::{read_dir, File};
+use std::io::{Result, Write};
 
 fn main() {
     println!("cargo:rerun-if-changed=../user/src/");
     println!("cargo:rerun-if-changed={}", TARGET_PATH);
+    insert_app_data().unwrap();
+}
+
+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/build/bin/")
+        .unwrap()
+        .into_iter()
+        .map(|dir_entry| {
+            let mut name_with_ext = dir_entry.unwrap().file_name().into_string().unwrap();
+            name_with_ext.drain(name_with_ext.find('.').unwrap()..name_with_ext.len());
+            name_with_ext
+        })
+        .collect();
+    apps.sort();
+
+    writeln!(
+        f,
+        r#"
+    .align 3
+    .section .data
+    .global _num_app
+_num_app:
+    .quad {}"#,
+        apps.len()
+    )?;
+
+    for i in 0..apps.len() {
+        writeln!(f, r#"    .quad app_{}_start"#, i)?;
+    }
+    writeln!(f, r#"    .quad app_{}_end"#, apps.len() - 1)?;
+
+    for (idx, app) in apps.iter().enumerate() {
+        println!("app_{}: {}", idx, app);
+        writeln!(
+            f,
+            r#"
+    .section .data
+    .global app_{0}_start
+    .global app_{0}_end
+app_{0}_start:
+    .incbin "{2}{1}.bin"
+app_{0}_end:"#,
+            idx, app, TARGET_PATH
+        )?;
+    }
+    Ok(())
 }

os/scripts/qemu-ver-check.sh

@@ -1,26 +0,0 @@
-#!/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

@@ -1,55 +0,0 @@
-pub const CLOCK_FREQ: usize = 12500000;
-pub const MEMORY_END: usize = 0x8800_0000;
-
-pub const MMIO: &[(usize, usize)] = &[
-    (0x0010_0000, 0x00_2000), // VIRT_TEST/RTC  in virt machine
-    (0x2000000, 0x10000),     // core local interrupter (CLINT)
-    (0xc000000, 0x210000),    // VIRT_PLIC in virt machine
-    (0x10000000, 0x9000),     // VIRT_UART0 with GPU  in virt machine
-];
-
-pub type BlockDeviceImpl = crate::drivers::block::VirtIOBlock;
-pub type CharDeviceImpl = crate::drivers::chardev::NS16550a<VIRT_UART>;
-
-pub const VIRT_PLIC: usize = 0xC00_0000;
-pub const VIRT_UART: usize = 0x1000_0000;
-#[allow(unused)]
-pub const VIRTGPU_XRES: u32 = 1280;
-#[allow(unused)]
-pub const VIRTGPU_YRES: u32 = 800;
-
-use crate::drivers::block::BLOCK_DEVICE;
-use crate::drivers::chardev::{CharDevice, UART};
-use crate::drivers::plic::{IntrTargetPriority, PLIC};
-use crate::drivers::{KEYBOARD_DEVICE, MOUSE_DEVICE};
-
-pub fn device_init() {
-    use riscv::register::sie;
-    let mut plic = unsafe { PLIC::new(VIRT_PLIC) };
-    let hart_id: usize = 0;
-    let supervisor = IntrTargetPriority::Supervisor;
-    let machine = IntrTargetPriority::Machine;
-    plic.set_threshold(hart_id, supervisor, 0);
-    plic.set_threshold(hart_id, machine, 1);
-    //irq nums: 5 keyboard, 6 mouse, 8 block, 10 uart
-    for intr_src_id in [5usize, 6, 8, 10] {
-        plic.enable(hart_id, supervisor, intr_src_id);
-        plic.set_priority(intr_src_id, 1);
-    }
-    unsafe {
-        sie::set_sext();
-    }
-}
-
-pub fn irq_handler() {
-    let mut plic = unsafe { PLIC::new(VIRT_PLIC) };
-    let intr_src_id = plic.claim(0, IntrTargetPriority::Supervisor);
-    match intr_src_id {
-        5 => KEYBOARD_DEVICE.handle_irq(),
-        6 => MOUSE_DEVICE.handle_irq(),
-        8 => BLOCK_DEVICE.handle_irq(),
-        10 => UART.handle_irq(),
-        _ => panic!("unsupported IRQ {}", intr_src_id),
-    }
-    plic.complete(0, IntrTargetPriority::Supervisor, intr_src_id);
-}

os/src/config.rs

@@ -1,12 +1,11 @@
-#[allow(unused)]
-
 pub const USER_STACK_SIZE: usize = 4096 * 2;
 pub const KERNEL_STACK_SIZE: usize = 4096 * 2;
-pub const KERNEL_HEAP_SIZE: usize = 0x100_0000;
+pub const MAX_APP_NUM: usize = 8;
-pub const PAGE_SIZE: usize = 0x1000;
+pub const APP_BASE_ADDRESS: usize = 0x80400000;
-pub const PAGE_SIZE_BITS: usize = 0xc;
+pub const APP_SIZE_LIMIT: usize = 0x20000;
 
-pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
+#[cfg(feature = "board_k210")]
-pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
+pub const CLOCK_FREQ: usize = 403000000 / 62;
 
-pub use crate::board::{CLOCK_FREQ, MEMORY_END, MMIO};
+#[cfg(feature = "board_qemu")]
+pub const CLOCK_FREQ: usize = 12500000;

os/src/console.rs

@@ -1,13 +1,12 @@
-use crate::drivers::chardev::CharDevice;
-use crate::drivers::chardev::UART;
 use core::fmt::{self, Write};
+use crate::sbi::console_putchar;
 
 struct Stdout;
 
 impl Write for Stdout {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         for c in s.chars() {
-            UART.write(c as u8);
+            console_putchar(c as usize);
         }
         Ok(())
     }
@@ -20,13 +19,15 @@ pub fn print(args: fmt::Arguments) {
 #[macro_export]
 macro_rules! print {
     ($fmt: literal $(, $($arg: tt)+)?) => {
-        $crate::console::print(format_args!($fmt $(, $($arg)+)?))
+        $crate::console::print(format_args!($fmt $(, $($arg)+)?));
     }
 }
 
 #[macro_export]
 macro_rules! println {
     ($fmt: literal $(, $($arg: tt)+)?) => {
-        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?))
+        $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
     }
 }
+
+

os/src/drivers/block/mod.rs

@@ -1,28 +0,0 @@
-mod virtio_blk;
-
-pub use virtio_blk::VirtIOBlock;
-
-use crate::board::BlockDeviceImpl;
-use alloc::sync::Arc;
-use easy_fs::BlockDevice;
-use lazy_static::*;
-
-lazy_static! {
-    pub static ref BLOCK_DEVICE: Arc<dyn BlockDevice> = Arc::new(BlockDeviceImpl::new());
-}
-
-#[allow(unused)]
-pub fn block_device_test() {
-    let block_device = BLOCK_DEVICE.clone();
-    let mut write_buffer = [0u8; 512];
-    let mut read_buffer = [0u8; 512];
-    for i in 0..512 {
-        for byte in write_buffer.iter_mut() {
-            *byte = i as u8;
-        }
-        block_device.write_block(i as usize, &write_buffer);
-        block_device.read_block(i as usize, &mut read_buffer);
-        assert_eq!(write_buffer, read_buffer);
-    }
-    println!("block device test passed!");
-}

os/src/drivers/block/virtio_blk.rs

@@ -1,87 +0,0 @@
-use super::BlockDevice;
-use crate::drivers::bus::virtio::VirtioHal;
-use crate::sync::{Condvar, UPIntrFreeCell};
-use crate::task::schedule;
-use crate::DEV_NON_BLOCKING_ACCESS;
-use alloc::collections::BTreeMap;
-use virtio_drivers::{BlkResp, RespStatus, VirtIOBlk, VirtIOHeader};
-
-#[allow(unused)]
-const VIRTIO0: usize = 0x10008000;
-
-pub struct VirtIOBlock {
-    virtio_blk: UPIntrFreeCell<VirtIOBlk<'static, VirtioHal>>,
-    condvars: BTreeMap<u16, Condvar>,
-}
-
-impl BlockDevice for VirtIOBlock {
-    fn read_block(&self, block_id: usize, buf: &mut [u8]) {
-        let nb = *DEV_NON_BLOCKING_ACCESS.exclusive_access();
-        if nb {
-            let mut resp = BlkResp::default();
-            let task_cx_ptr = self.virtio_blk.exclusive_session(|blk| {
-                let token = unsafe { blk.read_block_nb(block_id, buf, &mut resp).unwrap() };
-                self.condvars.get(&token).unwrap().wait_no_sched()
-            });
-            schedule(task_cx_ptr);
-            assert_eq!(
-                resp.status(),
-                RespStatus::Ok,
-                "Error when reading VirtIOBlk"
-            );
-        } else {
-            self.virtio_blk
-                .exclusive_access()
-                .read_block(block_id, buf)
-                .expect("Error when reading VirtIOBlk");
-        }
-    }
-    fn write_block(&self, block_id: usize, buf: &[u8]) {
-        let nb = *DEV_NON_BLOCKING_ACCESS.exclusive_access();
-        if nb {
-            let mut resp = BlkResp::default();
-            let task_cx_ptr = self.virtio_blk.exclusive_session(|blk| {
-                let token = unsafe { blk.write_block_nb(block_id, buf, &mut resp).unwrap() };
-                self.condvars.get(&token).unwrap().wait_no_sched()
-            });
-            schedule(task_cx_ptr);
-            assert_eq!(
-                resp.status(),
-                RespStatus::Ok,
-                "Error when writing VirtIOBlk"
-            );
-        } else {
-            self.virtio_blk
-                .exclusive_access()
-                .write_block(block_id, buf)
-                .expect("Error when writing VirtIOBlk");
-        }
-    }
-    fn handle_irq(&self) {
-        self.virtio_blk.exclusive_session(|blk| {
-            while let Ok(token) = blk.pop_used() {
-                self.condvars.get(&token).unwrap().signal();
-            }
-        });
-    }
-}
-
-impl VirtIOBlock {
-    pub fn new() -> Self {
-        let virtio_blk = unsafe {
-            UPIntrFreeCell::new(
-                VirtIOBlk::<VirtioHal>::new(&mut *(VIRTIO0 as *mut VirtIOHeader)).unwrap(),
-            )
-        };
-        let mut condvars = BTreeMap::new();
-        let channels = virtio_blk.exclusive_access().virt_queue_size();
-        for i in 0..channels {
-            let condvar = Condvar::new();
-            condvars.insert(i, condvar);
-        }
-        Self {
-            virtio_blk,
-            condvars,
-        }
-    }
-}

os/src/drivers/bus/mod.rs

@@ -1 +0,0 @@
-pub mod virtio;

os/src/drivers/bus/virtio.rs

@@ -1,48 +0,0 @@
-use crate::mm::{
-    frame_alloc_more, frame_dealloc, kernel_token, FrameTracker, PageTable, PhysAddr, PhysPageNum,
-    StepByOne, VirtAddr,
-};
-use crate::sync::UPIntrFreeCell;
-use alloc::vec::Vec;
-use lazy_static::*;
-use virtio_drivers::Hal;
-
-lazy_static! {
-    static ref QUEUE_FRAMES: UPIntrFreeCell<Vec<FrameTracker>> =
-        unsafe { UPIntrFreeCell::new(Vec::new()) };
-}
-
-pub struct VirtioHal;
-
-impl Hal for VirtioHal {
-    fn dma_alloc(pages: usize) -> usize {
-        let trakcers = frame_alloc_more(pages);
-        let ppn_base = trakcers.as_ref().unwrap().last().unwrap().ppn;
-        QUEUE_FRAMES
-            .exclusive_access()
-            .append(&mut trakcers.unwrap());
-        let pa: PhysAddr = ppn_base.into();
-        pa.0
-    }
-
-    fn dma_dealloc(pa: usize, pages: usize) -> i32 {
-        let pa = PhysAddr::from(pa);
-        let mut ppn_base: PhysPageNum = pa.into();
-        for _ in 0..pages {
-            frame_dealloc(ppn_base);
-            ppn_base.step();
-        }
-        0
-    }
-
-    fn phys_to_virt(addr: usize) -> usize {
-        addr
-    }
-
-    fn virt_to_phys(vaddr: usize) -> usize {
-        PageTable::from_token(kernel_token())
-            .translate_va(VirtAddr::from(vaddr))
-            .unwrap()
-            .0
-    }
-}

os/src/drivers/chardev/mod.rs

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

os/src/drivers/chardev/ns16550a.rs

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

os/src/drivers/gpu/mod.rs

@@ -1,68 +0,0 @@
-use crate::drivers::bus::virtio::VirtioHal;
-use crate::sync::UPIntrFreeCell;
-use alloc::{sync::Arc, vec::Vec};
-use core::any::Any;
-use embedded_graphics::pixelcolor::Rgb888;
-use tinybmp::Bmp;
-use virtio_drivers::{VirtIOGpu, VirtIOHeader};
-const VIRTIO7: usize = 0x10007000;
-pub trait GpuDevice: Send + Sync + Any {
-    fn update_cursor(&self);
-    fn get_framebuffer(&self) -> &mut [u8];
-    fn flush(&self);
-}
-
-lazy_static::lazy_static!(
-    pub static ref GPU_DEVICE: Arc<dyn GpuDevice> = Arc::new(VirtIOGpuWrapper::new());
-);
-
-pub struct VirtIOGpuWrapper {
-    gpu: UPIntrFreeCell<VirtIOGpu<'static, VirtioHal>>,
-    fb: &'static [u8],
-}
-static BMP_DATA: &[u8] = include_bytes!("../../assert/mouse.bmp");
-impl VirtIOGpuWrapper {
-    pub fn new() -> Self {
-        unsafe {
-            let mut virtio =
-                VirtIOGpu::<VirtioHal>::new(&mut *(VIRTIO7 as *mut VirtIOHeader)).unwrap();
-
-            let fbuffer = virtio.setup_framebuffer().unwrap();
-            let len = fbuffer.len();
-            let ptr = fbuffer.as_mut_ptr();
-            let fb = core::slice::from_raw_parts_mut(ptr, len);
-
-            let bmp = Bmp::<Rgb888>::from_slice(BMP_DATA).unwrap();
-            let raw = bmp.as_raw();
-            let mut b = Vec::new();
-            for i in raw.image_data().chunks(3) {
-                let mut v = i.to_vec();
-                b.append(&mut v);
-                if i == [255, 255, 255] {
-                    b.push(0x0)
-                } else {
-                    b.push(0xff)
-                }
-            }
-            virtio.setup_cursor(b.as_slice(), 50, 50, 50, 50).unwrap();
-
-            Self {
-                gpu: UPIntrFreeCell::new(virtio),
-                fb,
-            }
-        }
-    }
-}
-
-impl GpuDevice for VirtIOGpuWrapper {
-    fn flush(&self) {
-        self.gpu.exclusive_access().flush().unwrap();
-    }
-    fn get_framebuffer(&self) -> &mut [u8] {
-        unsafe {
-            let ptr = self.fb.as_ptr() as *const _ as *mut u8;
-            core::slice::from_raw_parts_mut(ptr, self.fb.len())
-        }
-    }
-    fn update_cursor(&self) {}
-}

os/src/drivers/input/mod.rs

@@ -1,83 +0,0 @@
-use crate::drivers::bus::virtio::VirtioHal;
-use crate::sync::{Condvar, UPIntrFreeCell};
-use crate::task::schedule;
-use alloc::collections::VecDeque;
-use alloc::sync::Arc;
-use core::any::Any;
-use virtio_drivers::{VirtIOHeader, VirtIOInput};
-
-const VIRTIO5: usize = 0x10005000;
-const VIRTIO6: usize = 0x10006000;
-
-struct VirtIOInputInner {
-    virtio_input: VirtIOInput<'static, VirtioHal>,
-    events: VecDeque<u64>,
-}
-
-struct VirtIOInputWrapper {
-    inner: UPIntrFreeCell<VirtIOInputInner>,
-    condvar: Condvar,
-}
-
-pub trait InputDevice: Send + Sync + Any {
-    fn read_event(&self) -> u64;
-    fn handle_irq(&self);
-    fn is_empty(&self) -> bool;
-}
-
-lazy_static::lazy_static!(
-    pub static ref KEYBOARD_DEVICE: Arc<dyn InputDevice> = Arc::new(VirtIOInputWrapper::new(VIRTIO5));
-    pub static ref MOUSE_DEVICE: Arc<dyn InputDevice> = Arc::new(VirtIOInputWrapper::new(VIRTIO6));
-);
-
-impl VirtIOInputWrapper {
-    pub fn new(addr: usize) -> Self {
-        let inner = VirtIOInputInner {
-            virtio_input: unsafe {
-                VirtIOInput::<VirtioHal>::new(&mut *(addr as *mut VirtIOHeader)).unwrap()
-            },
-            events: VecDeque::new(),
-        };
-        Self {
-            inner: unsafe { UPIntrFreeCell::new(inner) },
-            condvar: Condvar::new(),
-        }
-    }
-}
-
-impl InputDevice for VirtIOInputWrapper {
-    fn is_empty(&self) -> bool {
-        self.inner.exclusive_access().events.is_empty()
-    }
-
-    fn read_event(&self) -> u64 {
-        loop {
-            let mut inner = self.inner.exclusive_access();
-            if let Some(event) = inner.events.pop_front() {
-                return event;
-            } else {
-                let task_cx_ptr = self.condvar.wait_no_sched();
-                drop(inner);
-                schedule(task_cx_ptr);
-            }
-        }
-    }
-
-    fn handle_irq(&self) {
-        let mut count = 0;
-        let mut result = 0;
-        self.inner.exclusive_session(|inner| {
-            inner.virtio_input.ack_interrupt();
-            while let Some(event) = inner.virtio_input.pop_pending_event() {
-                count += 1;
-                result = (event.event_type as u64) << 48
-                    | (event.code as u64) << 32
-                    | (event.value) as u64;
-                inner.events.push_back(result);
-            }
-        });
-        if count > 0 {
-            self.condvar.signal();
-        };
-    }
-}

os/src/drivers/mod.rs

@@ -1,13 +0,0 @@
-pub mod block;
-pub mod bus;
-pub mod chardev;
-pub mod gpu;
-pub mod input;
-pub mod net;
-pub mod plic;
-
-pub use block::BLOCK_DEVICE;
-pub use bus::*;
-pub use gpu::*;
-pub use input::*;
-pub use net::*;

os/src/drivers/net/mod.rs

@@ -1,46 +0,0 @@
-use core::any::Any;
-
-use crate::drivers::virtio::VirtioHal;
-use crate::sync::UPIntrFreeCell;
-use alloc::sync::Arc;
-use lazy_static::*;
-use virtio_drivers::{VirtIOHeader, VirtIONet};
-
-const VIRTIO8: usize = 0x10004000;
-
-lazy_static! {
-    pub static ref NET_DEVICE: Arc<dyn NetDevice> = Arc::new(VirtIONetWrapper::new());
-}
-
-pub trait NetDevice: Send + Sync + Any {
-    fn transmit(&self, data: &[u8]);
-    fn receive(&self, data: &mut [u8]) -> usize;
-}
-
-pub struct VirtIONetWrapper(UPIntrFreeCell<VirtIONet<'static, VirtioHal>>);
-
-impl NetDevice for VirtIONetWrapper {
-    fn transmit(&self, data: &[u8]) {
-        self.0
-            .exclusive_access()
-            .send(data)
-            .expect("can't send data")
-    }
-
-    fn receive(&self, data: &mut [u8]) -> usize {
-        self.0
-            .exclusive_access()
-            .recv(data)
-            .expect("can't receive data")
-    }
-}
-
-impl VirtIONetWrapper {
-    pub fn new() -> Self {
-        unsafe {
-            let virtio = VirtIONet::<VirtioHal>::new(&mut *(VIRTIO8 as *mut VirtIOHeader))
-                .expect("can't create net device by virtio");
-            VirtIONetWrapper(UPIntrFreeCell::new(virtio))
-        }
-    }
-}

os/src/drivers/plic.rs

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

os/src/entry.asm

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

os/src/fs/inode.rs

@@ -1,139 +0,0 @@
-use super::File;
-use crate::drivers::BLOCK_DEVICE;
-use crate::mm::UserBuffer;
-use crate::sync::UPIntrFreeCell;
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use bitflags::*;
-use easy_fs::{EasyFileSystem, Inode};
-use lazy_static::*;
-
-pub struct OSInode {
-    readable: bool,
-    writable: bool,
-    inner: UPIntrFreeCell<OSInodeInner>,
-}
-
-pub struct OSInodeInner {
-    offset: usize,
-    inode: Arc<Inode>,
-}
-
-impl OSInode {
-    pub fn new(readable: bool, writable: bool, inode: Arc<Inode>) -> Self {
-        Self {
-            readable,
-            writable,
-            inner: unsafe { UPIntrFreeCell::new(OSInodeInner { offset: 0, inode }) },
-        }
-    }
-    pub fn read_all(&self) -> Vec<u8> {
-        let mut inner = self.inner.exclusive_access();
-        let mut buffer = [0u8; 512];
-        let mut v: Vec<u8> = Vec::new();
-        loop {
-            let len = inner.inode.read_at(inner.offset, &mut buffer);
-            if len == 0 {
-                break;
-            }
-            inner.offset += len;
-            v.extend_from_slice(&buffer[..len]);
-        }
-        v
-    }
-}
-
-lazy_static! {
-    pub static ref ROOT_INODE: Arc<Inode> = {
-        let efs = EasyFileSystem::open(BLOCK_DEVICE.clone());
-        Arc::new(EasyFileSystem::root_inode(&efs))
-    };
-}
-
-pub fn list_apps() {
-    println!("/**** APPS ****");
-    for app in ROOT_INODE.ls() {
-        println!("{}", app);
-    }
-    println!("**************/")
-}
-
-bitflags! {
-    pub struct OpenFlags: u32 {
-        const RDONLY = 0;
-        const WRONLY = 1 << 0;
-        const RDWR = 1 << 1;
-        const CREATE = 1 << 9;
-        const TRUNC = 1 << 10;
-    }
-}
-
-impl OpenFlags {
-    /// Do not check validity for simplicity
-    /// Return (readable, writable)
-    pub fn read_write(&self) -> (bool, bool) {
-        if self.is_empty() {
-            (true, false)
-        } else if self.contains(Self::WRONLY) {
-            (false, true)
-        } else {
-            (true, true)
-        }
-    }
-}
-
-pub fn open_file(name: &str, flags: OpenFlags) -> Option<Arc<OSInode>> {
-    let (readable, writable) = flags.read_write();
-    if flags.contains(OpenFlags::CREATE) {
-        if let Some(inode) = ROOT_INODE.find(name) {
-            // clear size
-            inode.clear();
-            Some(Arc::new(OSInode::new(readable, writable, inode)))
-        } else {
-            // create file
-            ROOT_INODE
-                .create(name)
-                .map(|inode| Arc::new(OSInode::new(readable, writable, inode)))
-        }
-    } else {
-        ROOT_INODE.find(name).map(|inode| {
-            if flags.contains(OpenFlags::TRUNC) {
-                inode.clear();
-            }
-            Arc::new(OSInode::new(readable, writable, inode))
-        })
-    }
-}
-
-impl File for OSInode {
-    fn readable(&self) -> bool {
-        self.readable
-    }
-    fn writable(&self) -> bool {
-        self.writable
-    }
-    fn read(&self, mut buf: UserBuffer) -> usize {
-        let mut inner = self.inner.exclusive_access();
-        let mut total_read_size = 0usize;
-        for slice in buf.buffers.iter_mut() {
-            let read_size = inner.inode.read_at(inner.offset, *slice);
-            if read_size == 0 {
-                break;
-            }
-            inner.offset += read_size;
-            total_read_size += read_size;
-        }
-        total_read_size
-    }
-    fn write(&self, buf: UserBuffer) -> usize {
-        let mut inner = self.inner.exclusive_access();
-        let mut total_write_size = 0usize;
-        for slice in buf.buffers.iter() {
-            let write_size = inner.inode.write_at(inner.offset, *slice);
-            assert_eq!(write_size, slice.len());
-            inner.offset += write_size;
-            total_write_size += write_size;
-        }
-        total_write_size
-    }
-}

os/src/fs/mod.rs

@@ -1,16 +0,0 @@
-mod inode;
-mod pipe;
-mod stdio;
-
-use crate::mm::UserBuffer;
-
-pub trait File: Send + Sync {
-    fn readable(&self) -> bool;
-    fn writable(&self) -> bool;
-    fn read(&self, buf: UserBuffer) -> usize;
-    fn write(&self, buf: UserBuffer) -> usize;
-}
-
-pub use inode::{list_apps, open_file, OpenFlags};
-pub use pipe::make_pipe;
-pub use stdio::{Stdin, Stdout};

os/src/fs/pipe.rs

@@ -1,173 +0,0 @@
-use super::File;
-use crate::mm::UserBuffer;
-use crate::sync::UPIntrFreeCell;
-use alloc::sync::{Arc, Weak};
-
-use crate::task::suspend_current_and_run_next;
-
-pub struct Pipe {
-    readable: bool,
-    writable: bool,
-    buffer: Arc<UPIntrFreeCell<PipeRingBuffer>>,
-}
-
-impl Pipe {
-    pub fn read_end_with_buffer(buffer: Arc<UPIntrFreeCell<PipeRingBuffer>>) -> Self {
-        Self {
-            readable: true,
-            writable: false,
-            buffer,
-        }
-    }
-    pub fn write_end_with_buffer(buffer: Arc<UPIntrFreeCell<PipeRingBuffer>>) -> Self {
-        Self {
-            readable: false,
-            writable: true,
-            buffer,
-        }
-    }
-}
-
-const RING_BUFFER_SIZE: usize = 32;
-
-#[derive(Copy, Clone, PartialEq)]
-enum RingBufferStatus {
-    Full,
-    Empty,
-    Normal,
-}
-
-pub struct PipeRingBuffer {
-    arr: [u8; RING_BUFFER_SIZE],
-    head: usize,
-    tail: usize,
-    status: RingBufferStatus,
-    write_end: Option<Weak<Pipe>>,
-}
-
-impl PipeRingBuffer {
-    pub fn new() -> Self {
-        Self {
-            arr: [0; RING_BUFFER_SIZE],
-            head: 0,
-            tail: 0,
-            status: RingBufferStatus::Empty,
-            write_end: None,
-        }
-    }
-    pub fn set_write_end(&mut self, write_end: &Arc<Pipe>) {
-        self.write_end = Some(Arc::downgrade(write_end));
-    }
-    pub fn write_byte(&mut self, byte: u8) {
-        self.status = RingBufferStatus::Normal;
-        self.arr[self.tail] = byte;
-        self.tail = (self.tail + 1) % RING_BUFFER_SIZE;
-        if self.tail == self.head {
-            self.status = RingBufferStatus::Full;
-        }
-    }
-    pub fn read_byte(&mut self) -> u8 {
-        self.status = RingBufferStatus::Normal;
-        let c = self.arr[self.head];
-        self.head = (self.head + 1) % RING_BUFFER_SIZE;
-        if self.head == self.tail {
-            self.status = RingBufferStatus::Empty;
-        }
-        c
-    }
-    pub fn available_read(&self) -> usize {
-        if self.status == RingBufferStatus::Empty {
-            0
-        } else if self.tail > self.head {
-            self.tail - self.head
-        } else {
-            self.tail + RING_BUFFER_SIZE - self.head
-        }
-    }
-    pub fn available_write(&self) -> usize {
-        if self.status == RingBufferStatus::Full {
-            0
-        } else {
-            RING_BUFFER_SIZE - self.available_read()
-        }
-    }
-    pub fn all_write_ends_closed(&self) -> bool {
-        self.write_end.as_ref().unwrap().upgrade().is_none()
-    }
-}
-
-/// Return (read_end, write_end)
-pub fn make_pipe() -> (Arc<Pipe>, Arc<Pipe>) {
-    let buffer = Arc::new(unsafe { UPIntrFreeCell::new(PipeRingBuffer::new()) });
-    let read_end = Arc::new(Pipe::read_end_with_buffer(buffer.clone()));
-    let write_end = Arc::new(Pipe::write_end_with_buffer(buffer.clone()));
-    buffer.exclusive_access().set_write_end(&write_end);
-    (read_end, write_end)
-}
-
-impl File for Pipe {
-    fn readable(&self) -> bool {
-        self.readable
-    }
-    fn writable(&self) -> bool {
-        self.writable
-    }
-    fn read(&self, buf: UserBuffer) -> usize {
-        assert!(self.readable());
-        let want_to_read = buf.len();
-        let mut buf_iter = buf.into_iter();
-        let mut already_read = 0usize;
-        loop {
-            let mut ring_buffer = self.buffer.exclusive_access();
-            let loop_read = ring_buffer.available_read();
-            if loop_read == 0 {
-                if ring_buffer.all_write_ends_closed() {
-                    return already_read;
-                }
-                drop(ring_buffer);
-                suspend_current_and_run_next();
-                continue;
-            }
-            for _ in 0..loop_read {
-                if let Some(byte_ref) = buf_iter.next() {
-                    unsafe {
-                        *byte_ref = ring_buffer.read_byte();
-                    }
-                    already_read += 1;
-                    if already_read == want_to_read {
-                        return want_to_read;
-                    }
-                } else {
-                    return already_read;
-                }
-            }
-        }
-    }
-    fn write(&self, buf: UserBuffer) -> usize {
-        assert!(self.writable());
-        let want_to_write = buf.len();
-        let mut buf_iter = buf.into_iter();
-        let mut already_write = 0usize;
-        loop {
-            let mut ring_buffer = self.buffer.exclusive_access();
-            let loop_write = ring_buffer.available_write();
-            if loop_write == 0 {
-                drop(ring_buffer);
-                suspend_current_and_run_next();
-                continue;
-            }
-            // write at most loop_write bytes
-            for _ in 0..loop_write {
-                if let Some(byte_ref) = buf_iter.next() {
-                    ring_buffer.write_byte(unsafe { *byte_ref });
-                    already_write += 1;
-                    if already_write == want_to_write {
-                        return want_to_write;
-                    }
-                } else {
-                    return already_write;
-                }
-            }
-        }
-    }
-}

os/src/fs/stdio.rs

@@ -1,46 +0,0 @@
-use super::File;
-use crate::drivers::chardev::CharDevice;
-use crate::drivers::chardev::UART;
-use crate::mm::UserBuffer;
-
-pub struct Stdin;
-pub struct Stdout;
-
-impl File for Stdin {
-    fn readable(&self) -> bool {
-        true
-    }
-    fn writable(&self) -> bool {
-        false
-    }
-    fn read(&self, mut user_buf: UserBuffer) -> usize {
-        assert_eq!(user_buf.len(), 1);
-        //println!("before UART.read() in Stdin::read()");
-        let ch = UART.read();
-        unsafe {
-            user_buf.buffers[0].as_mut_ptr().write_volatile(ch);
-        }
-        1
-    }
-    fn write(&self, _user_buf: UserBuffer) -> usize {
-        panic!("Cannot write to stdin!");
-    }
-}
-
-impl File for Stdout {
-    fn readable(&self) -> bool {
-        false
-    }
-    fn writable(&self) -> bool {
-        true
-    }
-    fn read(&self, _user_buf: UserBuffer) -> usize {
-        panic!("Cannot read from stdout!");
-    }
-    fn write(&self, user_buf: UserBuffer) -> usize {
-        for buffer in user_buf.buffers.iter() {
-            print!("{}", core::str::from_utf8(*buffer).unwrap());
-        }
-        user_buf.len()
-    }
-}

os/src/lang_items.rs

@@ -1,38 +1,12 @@
-use crate::sbi::shutdown;
-use crate::task::current_kstack_top;
-use core::arch::asm;
 use core::panic::PanicInfo;
-use log::*;
+use crate::sbi::shutdown;
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
     if let Some(location) = info.location() {
-        error!(
+        println!("[kernel] Panicked at {}:{} {}", location.file(), location.line(), info.message().unwrap());
-            "[kernel] Panicked at {}:{} {}",
-            location.file(),
-            location.line(),
-            info.message().unwrap()
-        );
     } else {
-        error!("[kernel] Panicked: {}", info.message().unwrap());
+        println!("[kernel] Panicked: {}", info.message().unwrap());
     }
-    unsafe {
+    shutdown()
-        backtrace();
-    }
-    shutdown(true)
-}
-
-unsafe fn backtrace() {
-    let mut fp: usize;
-    let stop = current_kstack_top();
-    asm!("mv {}, s0", out(reg) fp);
-    println!("---START BACKTRACE---");
-    for i in 0..10 {
-        if fp == stop {
-            break;
-        }
-        println!("#{}:ra={:#x}", i, *((fp - 8) as *const usize));
-        fp = *((fp - 16) as *const usize);
-    }
-    println!("---END   BACKTRACE---");
 }

os/src/linker-k210.ld

@@ -0,0 +1,48 @@
+OUTPUT_ARCH(riscv)
+ENTRY(_start)
+BASE_ADDRESS = 0x80020000;
+
+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/linker-qemu.ld

@@ -10,10 +10,6 @@ SECTIONS
     stext = .;
     .text : {
         *(.text.entry)
-        . = ALIGN(4K);
-        strampoline = .;
-        *(.text.trampoline);
-        . = ALIGN(4K);
         *(.text .text.*)
     }
 
@@ -35,7 +31,6 @@ SECTIONS
 
     . = ALIGN(4K);
     edata = .;
-    sbss_with_stack = .;
     .bss : {
         *(.bss.stack)
         sbss = .;

os/src/loader.rs

@@ -0,0 +1,83 @@
+use crate::trap::TrapContext;
+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],
+}
+
+static KERNEL_STACK: [KernelStack; MAX_APP_NUM] = [
+    KernelStack { data: [0; KERNEL_STACK_SIZE], };
+    MAX_APP_NUM
+];
+
+static USER_STACK: [UserStack; MAX_APP_NUM] = [
+    UserStack { data: [0; USER_STACK_SIZE], };
+    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) -> usize {
+        let trap_cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
+        unsafe { *trap_cx_ptr = trap_cx; }
+        trap_cx_ptr as usize
+    }
+}
+
+impl UserStack {
+    fn get_sp(&self) -> usize {
+        self.data.as_ptr() as usize + USER_STACK_SIZE
+    }
+}
+
+fn get_base_i(app_id: usize) -> usize {
+    APP_BASE_ADDRESS + app_id * APP_SIZE_LIMIT
+}
+
+pub fn get_num_app() -> usize {
+    extern "C" { fn _num_app(); }
+    unsafe { (_num_app as usize as *const usize).read_volatile() }
+}
+
+pub fn load_apps() {
+    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 {
+        core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1)
+    };
+    // clear i-cache first
+    unsafe { asm!("fence.i"); }
+    // 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 {
+            (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 {
+            core::slice::from_raw_parts_mut(base_i as *mut u8, src.len())
+        };
+        dst.copy_from_slice(src);
+    }
+}
+
+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()),
+    )
+}

os/src/main.rs

@@ -1,37 +1,23 @@
 #![no_std]
 #![no_main]
+#![feature(global_asm)]
+#![feature(asm)]
 #![feature(panic_info_message)]
-#![feature(alloc_error_handler)]
-
-//use crate::drivers::{GPU_DEVICE, KEYBOARD_DEVICE, MOUSE_DEVICE, INPUT_CONDVAR};
-use crate::drivers::{GPU_DEVICE, KEYBOARD_DEVICE, MOUSE_DEVICE};
-extern crate alloc;
-
-#[macro_use]
-extern crate bitflags;
-
-#[path = "boards/qemu.rs"]
-mod board;
 
 #[macro_use]
 mod console;
-mod config;
-mod drivers;
-mod fs;
 mod lang_items;
-mod mm;
-mod net;
 mod sbi;
-mod sync;
 mod syscall;
+mod trap;
+mod loader;
+mod config;
 mod task;
 mod timer;
-mod trap;
+mod sync;
 
-use crate::drivers::chardev::CharDevice;
+global_asm!(include_str!("entry.asm"));
-use crate::drivers::chardev::UART;
+global_asm!(include_str!("link_app.S"));
-
-core::arch::global_asm!(include_str!("entry.asm"));
 
 fn clear_bss() {
     extern "C" {
@@ -39,38 +25,21 @@ fn clear_bss() {
         fn ebss();
     }
     unsafe {
-        core::slice::from_raw_parts_mut(sbss as usize as *mut u8, ebss as usize - sbss as usize)
+        core::slice::from_raw_parts_mut(
-            .fill(0);
+            sbss as usize as *mut u8,
+            ebss as usize - sbss as usize,
+        ).fill(0);
     }
 }
 
-use lazy_static::*;
-use sync::UPIntrFreeCell;
-
-lazy_static! {
-    pub static ref DEV_NON_BLOCKING_ACCESS: UPIntrFreeCell<bool> =
-        unsafe { UPIntrFreeCell::new(false) };
-}
-
 #[no_mangle]
 pub fn rust_main() -> ! {
     clear_bss();
-    mm::init();
+    println!("[kernel] Hello, world!");
-    UART.init();
-    println!("KERN: init gpu");
-    let _gpu = GPU_DEVICE.clone();
-    println!("KERN: init keyboard");
-    let _keyboard = KEYBOARD_DEVICE.clone();
-    println!("KERN: init mouse");
-    let _mouse = MOUSE_DEVICE.clone();
-    println!("KERN: init trap");
     trap::init();
+    loader::load_apps();
     trap::enable_timer_interrupt();
     timer::set_next_trigger();
-    board::device_init();
+    task::run_first_task();
-    fs::list_apps();
-    task::add_initproc();
-    *DEV_NON_BLOCKING_ACCESS.exclusive_access() = true;
-    task::run_tasks();
     panic!("Unreachable in rust_main!");
-}
+}

os/src/mm/address.rs

@@ -1,270 +0,0 @@
-use super::PageTableEntry;
-use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS};
-use core::fmt::{self, Debug, Formatter};
-
-const PA_WIDTH_SV39: usize = 56;
-const VA_WIDTH_SV39: usize = 39;
-const PPN_WIDTH_SV39: usize = PA_WIDTH_SV39 - PAGE_SIZE_BITS;
-const VPN_WIDTH_SV39: usize = VA_WIDTH_SV39 - PAGE_SIZE_BITS;
-
-/// Definitions
-#[repr(C)]
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct PhysAddr(pub usize);
-
-#[repr(C)]
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct VirtAddr(pub usize);
-
-#[repr(C)]
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct PhysPageNum(pub usize);
-
-#[repr(C)]
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct VirtPageNum(pub usize);
-
-/// Debugging
-
-impl Debug for VirtAddr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("VA:{:#x}", self.0))
-    }
-}
-impl Debug for VirtPageNum {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("VPN:{:#x}", self.0))
-    }
-}
-impl Debug for PhysAddr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("PA:{:#x}", self.0))
-    }
-}
-impl Debug for PhysPageNum {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("PPN:{:#x}", self.0))
-    }
-}
-
-/// T: {PhysAddr, VirtAddr, PhysPageNum, VirtPageNum}
-/// T -> usize: T.0
-/// usize -> T: usize.into()
-
-impl From<usize> for PhysAddr {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << PA_WIDTH_SV39) - 1))
-    }
-}
-impl From<usize> for PhysPageNum {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << PPN_WIDTH_SV39) - 1))
-    }
-}
-impl From<usize> for VirtAddr {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << VA_WIDTH_SV39) - 1))
-    }
-}
-impl From<usize> for VirtPageNum {
-    fn from(v: usize) -> Self {
-        Self(v & ((1 << VPN_WIDTH_SV39) - 1))
-    }
-}
-impl From<PhysAddr> for usize {
-    fn from(v: PhysAddr) -> Self {
-        v.0
-    }
-}
-impl From<PhysPageNum> for usize {
-    fn from(v: PhysPageNum) -> Self {
-        v.0
-    }
-}
-impl From<VirtAddr> for usize {
-    fn from(v: VirtAddr) -> Self {
-        if v.0 >= (1 << (VA_WIDTH_SV39 - 1)) {
-            v.0 | (!((1 << VA_WIDTH_SV39) - 1))
-        } else {
-            v.0
-        }
-    }
-}
-impl From<VirtPageNum> for usize {
-    fn from(v: VirtPageNum) -> Self {
-        v.0
-    }
-}
-
-impl VirtAddr {
-    pub fn floor(&self) -> VirtPageNum {
-        VirtPageNum(self.0 / PAGE_SIZE)
-    }
-    pub fn ceil(&self) -> VirtPageNum {
-        if self.0 == 0 {
-            VirtPageNum(0)
-        } else {
-            VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
-        }
-    }
-    pub fn page_offset(&self) -> usize {
-        self.0 & (PAGE_SIZE - 1)
-    }
-    pub fn aligned(&self) -> bool {
-        self.page_offset() == 0
-    }
-}
-impl From<VirtAddr> for VirtPageNum {
-    fn from(v: VirtAddr) -> Self {
-        assert_eq!(v.page_offset(), 0);
-        v.floor()
-    }
-}
-impl From<VirtPageNum> for VirtAddr {
-    fn from(v: VirtPageNum) -> Self {
-        Self(v.0 << PAGE_SIZE_BITS)
-    }
-}
-impl PhysAddr {
-    pub fn floor(&self) -> PhysPageNum {
-        PhysPageNum(self.0 / PAGE_SIZE)
-    }
-    pub fn ceil(&self) -> PhysPageNum {
-        if self.0 == 0 {
-            PhysPageNum(0)
-        } else {
-            PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE)
-        }
-    }
-    pub fn page_offset(&self) -> usize {
-        self.0 & (PAGE_SIZE - 1)
-    }
-    pub fn aligned(&self) -> bool {
-        self.page_offset() == 0
-    }
-}
-impl From<PhysAddr> for PhysPageNum {
-    fn from(v: PhysAddr) -> Self {
-        assert_eq!(v.page_offset(), 0);
-        v.floor()
-    }
-}
-impl From<PhysPageNum> for PhysAddr {
-    fn from(v: PhysPageNum) -> Self {
-        Self(v.0 << PAGE_SIZE_BITS)
-    }
-}
-
-impl VirtPageNum {
-    pub fn indexes(&self) -> [usize; 3] {
-        let mut vpn = self.0;
-        let mut idx = [0usize; 3];
-        for i in (0..3).rev() {
-            idx[i] = vpn & 511;
-            vpn >>= 9;
-        }
-        idx
-    }
-}
-
-impl PhysAddr {
-    pub fn get_ref<T>(&self) -> &'static T {
-        unsafe { (self.0 as *const T).as_ref().unwrap() }
-    }
-    pub fn get_mut<T>(&self) -> &'static mut T {
-        unsafe { (self.0 as *mut T).as_mut().unwrap() }
-    }
-}
-impl PhysPageNum {
-    pub fn get_pte_array(&self) -> &'static mut [PageTableEntry] {
-        let pa: PhysAddr = (*self).into();
-        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut PageTableEntry, 512) }
-    }
-    pub fn get_bytes_array(&self) -> &'static mut [u8] {
-        let pa: PhysAddr = (*self).into();
-        unsafe { core::slice::from_raw_parts_mut(pa.0 as *mut u8, 4096) }
-    }
-    pub fn get_mut<T>(&self) -> &'static mut T {
-        let pa: PhysAddr = (*self).into();
-        pa.get_mut()
-    }
-}
-
-pub trait StepByOne {
-    fn step(&mut self);
-}
-impl StepByOne for VirtPageNum {
-    fn step(&mut self) {
-        self.0 += 1;
-    }
-}
-impl StepByOne for PhysPageNum {
-    fn step(&mut self) {
-        self.0 += 1;
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct SimpleRange<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    l: T,
-    r: T,
-}
-impl<T> SimpleRange<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    pub fn new(start: T, end: T) -> Self {
-        assert!(start <= end, "start {:?} > end {:?}!", start, end);
-        Self { l: start, r: end }
-    }
-    pub fn get_start(&self) -> T {
-        self.l
-    }
-    pub fn get_end(&self) -> T {
-        self.r
-    }
-}
-impl<T> IntoIterator for SimpleRange<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    type Item = T;
-    type IntoIter = SimpleRangeIterator<T>;
-    fn into_iter(self) -> Self::IntoIter {
-        SimpleRangeIterator::new(self.l, self.r)
-    }
-}
-pub struct SimpleRangeIterator<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    current: T,
-    end: T,
-}
-impl<T> SimpleRangeIterator<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    pub fn new(l: T, r: T) -> Self {
-        Self { current: l, end: r }
-    }
-}
-impl<T> Iterator for SimpleRangeIterator<T>
-where
-    T: StepByOne + Copy + PartialEq + PartialOrd + Debug,
-{
-    type Item = T;
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current == self.end {
-            None
-        } else {
-            let t = self.current;
-            self.current.step();
-            Some(t)
-        }
-    }
-}
-pub type VPNRange = SimpleRange<VirtPageNum>;

os/src/mm/frame_allocator.rs

@@ -1,162 +0,0 @@
-use super::{PhysAddr, PhysPageNum};
-use crate::config::MEMORY_END;
-use crate::sync::UPIntrFreeCell;
-use alloc::vec::Vec;
-use core::fmt::{self, Debug, Formatter};
-use lazy_static::*;
-
-pub struct FrameTracker {
-    pub ppn: PhysPageNum,
-}
-
-impl FrameTracker {
-    pub fn new(ppn: PhysPageNum) -> Self {
-        // page cleaning
-        let bytes_array = ppn.get_bytes_array();
-        for i in bytes_array {
-            *i = 0;
-        }
-        Self { ppn }
-    }
-}
-
-impl Debug for FrameTracker {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_fmt(format_args!("FrameTracker:PPN={:#x}", self.ppn.0))
-    }
-}
-
-impl Drop for FrameTracker {
-    fn drop(&mut self) {
-        frame_dealloc(self.ppn);
-    }
-}
-
-trait FrameAllocator {
-    fn new() -> Self;
-    fn alloc(&mut self) -> Option<PhysPageNum>;
-    fn alloc_more(&mut self, pages: usize) -> Option<Vec<PhysPageNum>>;
-    fn dealloc(&mut self, ppn: PhysPageNum);
-}
-
-pub struct StackFrameAllocator {
-    current: usize,
-    end: usize,
-    recycled: Vec<usize>,
-}
-
-impl StackFrameAllocator {
-    pub fn init(&mut self, l: PhysPageNum, r: PhysPageNum) {
-        self.current = l.0;
-        self.end = r.0;
-        // println!("last {} Physical Frames.", self.end - self.current);
-    }
-}
-impl FrameAllocator for StackFrameAllocator {
-    fn new() -> Self {
-        Self {
-            current: 0,
-            end: 0,
-            recycled: Vec::new(),
-        }
-    }
-    fn alloc(&mut self) -> Option<PhysPageNum> {
-        if let Some(ppn) = self.recycled.pop() {
-            Some(ppn.into())
-        } else if self.current == self.end {
-            None
-        } else {
-            self.current += 1;
-            Some((self.current - 1).into())
-        }
-    }
-    fn alloc_more(&mut self, pages: usize) -> Option<Vec<PhysPageNum>> {
-        if self.current + pages >= self.end {
-            None
-        } else {
-            self.current += pages;
-            let arr: Vec<usize> = (1..pages + 1).collect();
-            let v = arr.iter().map(|x| (self.current - x).into()).collect();
-            Some(v)
-        }
-    }
-    fn dealloc(&mut self, ppn: PhysPageNum) {
-        let ppn = ppn.0;
-        // validity check
-        if ppn >= self.current || self.recycled.iter().any(|&v| v == ppn) {
-            panic!("Frame ppn={:#x} has not been allocated!", ppn);
-        }
-        // recycle
-        self.recycled.push(ppn);
-    }
-}
-
-type FrameAllocatorImpl = StackFrameAllocator;
-
-lazy_static! {
-    pub static ref FRAME_ALLOCATOR: UPIntrFreeCell<FrameAllocatorImpl> =
-        unsafe { UPIntrFreeCell::new(FrameAllocatorImpl::new()) };
-}
-
-pub fn init_frame_allocator() {
-    extern "C" {
-        fn ekernel();
-    }
-    FRAME_ALLOCATOR.exclusive_access().init(
-        PhysAddr::from(ekernel as usize).ceil(),
-        PhysAddr::from(MEMORY_END).floor(),
-    );
-}
-
-pub fn frame_alloc() -> Option<FrameTracker> {
-    FRAME_ALLOCATOR
-        .exclusive_access()
-        .alloc()
-        .map(FrameTracker::new)
-}
-
-pub fn frame_alloc_more(num: usize) -> Option<Vec<FrameTracker>> {
-    FRAME_ALLOCATOR
-        .exclusive_access()
-        .alloc_more(num)
-        .map(|x| x.iter().map(|&t| FrameTracker::new(t)).collect())
-}
-
-pub fn frame_dealloc(ppn: PhysPageNum) {
-    FRAME_ALLOCATOR.exclusive_access().dealloc(ppn);
-}
-
-#[allow(unused)]
-pub fn frame_allocator_test() {
-    let mut v: Vec<FrameTracker> = Vec::new();
-    for i in 0..5 {
-        let frame = frame_alloc().unwrap();
-        println!("{:?}", frame);
-        v.push(frame);
-    }
-    v.clear();
-    for i in 0..5 {
-        let frame = frame_alloc().unwrap();
-        println!("{:?}", frame);
-        v.push(frame);
-    }
-    drop(v);
-    println!("frame_allocator_test passed!");
-}
-
-#[allow(unused)]
-pub fn frame_allocator_alloc_more_test() {
-    let mut v: Vec<FrameTracker> = Vec::new();
-    let frames = frame_alloc_more(5).unwrap();
-    for frame in &frames {
-        println!("{:?}", frame);
-    }
-    v.extend(frames);
-    v.clear();
-    let frames = frame_alloc_more(5).unwrap();
-    for frame in &frames {
-        println!("{:?}", frame);
-    }
-    drop(v);
-    println!("frame_allocator_test passed!");
-}

os/src/mm/heap_allocator.rs

@@ -1,45 +0,0 @@
-use crate::config::KERNEL_HEAP_SIZE;
-use buddy_system_allocator::LockedHeap;
-
-#[global_allocator]
-static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty();
-
-#[alloc_error_handler]
-pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
-    panic!("Heap allocation error, layout = {:?}", layout);
-}
-
-static mut HEAP_SPACE: [u8; KERNEL_HEAP_SIZE] = [0; KERNEL_HEAP_SIZE];
-
-pub fn init_heap() {
-    unsafe {
-        HEAP_ALLOCATOR
-            .lock()
-            .init(HEAP_SPACE.as_ptr() as usize, KERNEL_HEAP_SIZE);
-    }
-}
-
-#[allow(unused)]
-pub fn heap_test() {
-    use alloc::boxed::Box;
-    use alloc::vec::Vec;
-    extern "C" {
-        fn sbss();
-        fn ebss();
-    }
-    let bss_range = sbss as usize..ebss as usize;
-    let a = Box::new(5);
-    assert_eq!(*a, 5);
-    assert!(bss_range.contains(&(a.as_ref() as *const _ as usize)));
-    drop(a);
-    let mut v: Vec<usize> = Vec::new();
-    for i in 0..500 {
-        v.push(i);
-    }
-    for (i, val) in v.iter().take(500).enumerate() {
-        assert_eq!(*val, i);
-    }
-    assert!(bss_range.contains(&(v.as_ptr() as usize)));
-    drop(v);
-    println!("heap_test passed!");
-}

os/src/mm/memory_set.rs

@@ -1,380 +0,0 @@
-use super::{frame_alloc, FrameTracker};
-use super::{PTEFlags, PageTable, PageTableEntry};
-use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum};
-use super::{StepByOne, VPNRange};
-use crate::config::{MEMORY_END, MMIO, PAGE_SIZE, TRAMPOLINE};
-use crate::sync::UPIntrFreeCell;
-use alloc::collections::BTreeMap;
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use core::arch::asm;
-use lazy_static::*;
-use riscv::register::satp;
-
-extern "C" {
-    fn stext();
-    fn etext();
-    fn srodata();
-    fn erodata();
-    fn sdata();
-    fn edata();
-    fn sbss_with_stack();
-    fn ebss();
-    fn ekernel();
-    fn strampoline();
-}
-
-lazy_static! {
-    pub static ref KERNEL_SPACE: Arc<UPIntrFreeCell<MemorySet>> =
-        Arc::new(unsafe { UPIntrFreeCell::new(MemorySet::new_kernel()) });
-}
-
-pub fn kernel_token() -> usize {
-    KERNEL_SPACE.exclusive_access().token()
-}
-
-pub struct MemorySet {
-    page_table: PageTable,
-    areas: Vec<MapArea>,
-}
-
-impl MemorySet {
-    pub fn new_bare() -> Self {
-        Self {
-            page_table: PageTable::new(),
-            areas: Vec::new(),
-        }
-    }
-    pub fn token(&self) -> usize {
-        self.page_table.token()
-    }
-    /// Assume that no conflicts.
-    pub fn insert_framed_area(
-        &mut self,
-        start_va: VirtAddr,
-        end_va: VirtAddr,
-        permission: MapPermission,
-    ) {
-        self.push(
-            MapArea::new(start_va, end_va, MapType::Framed, permission),
-            None,
-        );
-    }
-    pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
-        if let Some((idx, area)) = self
-            .areas
-            .iter_mut()
-            .enumerate()
-            .find(|(_, area)| area.vpn_range.get_start() == start_vpn)
-        {
-            area.unmap(&mut self.page_table);
-            self.areas.remove(idx);
-        }
-    }
-    /// Add a new MapArea into this MemorySet.
-    /// Assuming that there are no conflicts in the virtual address
-    /// space.
-    pub fn push(&mut self, mut map_area: MapArea, data: Option<&[u8]>) {
-        map_area.map(&mut self.page_table);
-        if let Some(data) = data {
-            map_area.copy_data(&self.page_table, data);
-        }
-        self.areas.push(map_area);
-    }
-    /// Mention that trampoline is not collected by areas.
-    fn map_trampoline(&mut self) {
-        self.page_table.map(
-            VirtAddr::from(TRAMPOLINE).into(),
-            PhysAddr::from(strampoline as usize).into(),
-            PTEFlags::R | PTEFlags::X,
-        );
-    }
-    /// Without kernel stacks.
-    pub fn new_kernel() -> Self {
-        let mut memory_set = Self::new_bare();
-        // map trampoline
-        memory_set.map_trampoline();
-        // map kernel sections
-        // println!(".text [{:#x}, {:#x})", stext as usize, etext as usize);
-        // println!(".rodata [{:#x}, {:#x})", srodata as usize, erodata as usize);
-        // println!(".data [{:#x}, {:#x})", sdata as usize, edata as usize);
-        // println!(
-        //     ".bss [{:#x}, {:#x})",
-        //     sbss_with_stack as usize, ebss as usize
-        // );
-        // println!("mapping .text section");
-        memory_set.push(
-            MapArea::new(
-                (stext as usize).into(),
-                (etext as usize).into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::X,
-            ),
-            None,
-        );
-        // println!("mapping .rodata section");
-        memory_set.push(
-            MapArea::new(
-                (srodata as usize).into(),
-                (erodata as usize).into(),
-                MapType::Identical,
-                MapPermission::R,
-            ),
-            None,
-        );
-        // println!("mapping .data section");
-        memory_set.push(
-            MapArea::new(
-                (sdata as usize).into(),
-                (edata as usize).into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::W,
-            ),
-            None,
-        );
-        // println!("mapping .bss section");
-        memory_set.push(
-            MapArea::new(
-                (sbss_with_stack as usize).into(),
-                (ebss as usize).into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::W,
-            ),
-            None,
-        );
-        // println!("mapping physical memory");
-        memory_set.push(
-            MapArea::new(
-                (ekernel as usize).into(),
-                MEMORY_END.into(),
-                MapType::Identical,
-                MapPermission::R | MapPermission::W,
-            ),
-            None,
-        );
-        //println!("mapping memory-mapped registers");
-        for pair in MMIO {
-            memory_set.push(
-                MapArea::new(
-                    (*pair).0.into(),
-                    ((*pair).0 + (*pair).1).into(),
-                    MapType::Identical,
-                    MapPermission::R | MapPermission::W,
-                ),
-                None,
-            );
-        }
-        memory_set
-    }
-    /// Include sections in elf and trampoline,
-    /// also returns user_sp_base and entry point.
-    pub fn from_elf(elf_data: &[u8]) -> (Self, usize, usize) {
-        let mut memory_set = Self::new_bare();
-        // map trampoline
-        memory_set.map_trampoline();
-        // map program headers of elf, with U flag
-        let elf = xmas_elf::ElfFile::new(elf_data).unwrap();
-        let elf_header = elf.header;
-        let magic = elf_header.pt1.magic;
-        assert_eq!(magic, [0x7f, 0x45, 0x4c, 0x46], "invalid elf!");
-        let ph_count = elf_header.pt2.ph_count();
-        let mut max_end_vpn = VirtPageNum(0);
-        for i in 0..ph_count {
-            let ph = elf.program_header(i).unwrap();
-            if ph.get_type().unwrap() == xmas_elf::program::Type::Load {
-                let start_va: VirtAddr = (ph.virtual_addr() as usize).into();
-                let end_va: VirtAddr = ((ph.virtual_addr() + ph.mem_size()) as usize).into();
-                let mut map_perm = MapPermission::U;
-                let ph_flags = ph.flags();
-                if ph_flags.is_read() {
-                    map_perm |= MapPermission::R;
-                }
-                if ph_flags.is_write() {
-                    map_perm |= MapPermission::W;
-                }
-                if ph_flags.is_execute() {
-                    map_perm |= MapPermission::X;
-                }
-                let map_area = MapArea::new(start_va, end_va, MapType::Framed, map_perm);
-                max_end_vpn = map_area.vpn_range.get_end();
-                memory_set.push(
-                    map_area,
-                    Some(&elf.input[ph.offset() as usize..(ph.offset() + ph.file_size()) as usize]),
-                );
-            }
-        }
-        let max_end_va: VirtAddr = max_end_vpn.into();
-        let mut user_stack_base: usize = max_end_va.into();
-        user_stack_base += PAGE_SIZE;
-        (
-            memory_set,
-            user_stack_base,
-            elf.header.pt2.entry_point() as usize,
-        )
-    }
-    pub fn from_existed_user(user_space: &MemorySet) -> MemorySet {
-        let mut memory_set = Self::new_bare();
-        // map trampoline
-        memory_set.map_trampoline();
-        // copy data sections/trap_context/user_stack
-        for area in user_space.areas.iter() {
-            let new_area = MapArea::from_another(area);
-            memory_set.push(new_area, None);
-            // copy data from another space
-            for vpn in area.vpn_range {
-                let src_ppn = user_space.translate(vpn).unwrap().ppn();
-                let dst_ppn = memory_set.translate(vpn).unwrap().ppn();
-                dst_ppn
-                    .get_bytes_array()
-                    .copy_from_slice(src_ppn.get_bytes_array());
-            }
-        }
-        memory_set
-    }
-    pub fn activate(&self) {
-        let satp = self.page_table.token();
-        unsafe {
-            satp::write(satp);
-            asm!("sfence.vma");
-        }
-    }
-    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
-        self.page_table.translate(vpn)
-    }
-    pub fn recycle_data_pages(&mut self) {
-        //*self = Self::new_bare();
-        self.areas.clear();
-    }
-}
-
-pub struct MapArea {
-    vpn_range: VPNRange,
-    data_frames: BTreeMap<VirtPageNum, FrameTracker>,
-    map_type: MapType,
-    map_perm: MapPermission,
-}
-
-impl MapArea {
-    pub fn new(
-        start_va: VirtAddr,
-        end_va: VirtAddr,
-        map_type: MapType,
-        map_perm: MapPermission,
-    ) -> Self {
-        let start_vpn: VirtPageNum = start_va.floor();
-        let end_vpn: VirtPageNum = end_va.ceil();
-        Self {
-            vpn_range: VPNRange::new(start_vpn, end_vpn),
-            data_frames: BTreeMap::new(),
-            map_type,
-            map_perm,
-        }
-    }
-    pub fn from_another(another: &MapArea) -> Self {
-        Self {
-            vpn_range: VPNRange::new(another.vpn_range.get_start(), another.vpn_range.get_end()),
-            data_frames: BTreeMap::new(),
-            map_type: another.map_type,
-            map_perm: another.map_perm,
-        }
-    }
-    pub fn map_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
-        let ppn: PhysPageNum;
-        match self.map_type {
-            MapType::Identical => {
-                ppn = PhysPageNum(vpn.0);
-            }
-            MapType::Framed => {
-                let frame = frame_alloc().unwrap();
-                ppn = frame.ppn;
-                self.data_frames.insert(vpn, frame);
-            }
-            MapType::Linear(pn_offset) => {
-                // check for sv39
-                assert!(vpn.0 < (1usize << 27));
-                ppn = PhysPageNum((vpn.0 as isize + pn_offset) as usize);
-            }
-        }
-        let pte_flags = PTEFlags::from_bits(self.map_perm.bits).unwrap();
-        page_table.map(vpn, ppn, pte_flags);
-    }
-    pub fn unmap_one(&mut self, page_table: &mut PageTable, vpn: VirtPageNum) {
-        if self.map_type == MapType::Framed {
-            self.data_frames.remove(&vpn);
-        }
-        page_table.unmap(vpn);
-    }
-    pub fn map(&mut self, page_table: &mut PageTable) {
-        for vpn in self.vpn_range {
-            self.map_one(page_table, vpn);
-        }
-    }
-    pub fn unmap(&mut self, page_table: &mut PageTable) {
-        for vpn in self.vpn_range {
-            self.unmap_one(page_table, vpn);
-        }
-    }
-    /// data: start-aligned but maybe with shorter length
-    /// assume that all frames were cleared before
-    pub fn copy_data(&mut self, page_table: &PageTable, data: &[u8]) {
-        assert_eq!(self.map_type, MapType::Framed);
-        let mut start: usize = 0;
-        let mut current_vpn = self.vpn_range.get_start();
-        let len = data.len();
-        loop {
-            let src = &data[start..len.min(start + PAGE_SIZE)];
-            let dst = &mut page_table
-                .translate(current_vpn)
-                .unwrap()
-                .ppn()
-                .get_bytes_array()[..src.len()];
-            dst.copy_from_slice(src);
-            start += PAGE_SIZE;
-            if start >= len {
-                break;
-            }
-            current_vpn.step();
-        }
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum MapType {
-    Identical,
-    Framed,
-    /// offset of page num
-    Linear(isize),
-}
-
-bitflags! {
-    pub struct MapPermission: u8 {
-        const R = 1 << 1;
-        const W = 1 << 2;
-        const X = 1 << 3;
-        const U = 1 << 4;
-    }
-}
-
-#[allow(unused)]
-pub fn remap_test() {
-    let mut kernel_space = KERNEL_SPACE.exclusive_access();
-    let mid_text: VirtAddr = ((stext as usize + etext as usize) / 2).into();
-    let mid_rodata: VirtAddr = ((srodata as usize + erodata as usize) / 2).into();
-    let mid_data: VirtAddr = ((sdata as usize + edata as usize) / 2).into();
-    assert!(!kernel_space
-        .page_table
-        .translate(mid_text.floor())
-        .unwrap()
-        .writable(),);
-    assert!(!kernel_space
-        .page_table
-        .translate(mid_rodata.floor())
-        .unwrap()
-        .writable(),);
-    assert!(!kernel_space
-        .page_table
-        .translate(mid_data.floor())
-        .unwrap()
-        .executable(),);
-    println!("remap_test passed!");
-}

os/src/mm/mod.rs

@@ -1,21 +0,0 @@
-mod address;
-mod frame_allocator;
-mod heap_allocator;
-mod memory_set;
-mod page_table;
-
-pub use address::VPNRange;
-pub use address::{PhysAddr, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
-pub use frame_allocator::{frame_alloc, frame_alloc_more, frame_dealloc, FrameTracker};
-pub use memory_set::{kernel_token, MapArea, MapPermission, MapType, MemorySet, KERNEL_SPACE};
-use page_table::PTEFlags;
-pub use page_table::{
-    translated_byte_buffer, translated_ref, translated_refmut, translated_str, PageTable,
-    PageTableEntry, UserBuffer,
-};
-
-pub fn init() {
-    heap_allocator::init_heap();
-    frame_allocator::init_frame_allocator();
-    KERNEL_SPACE.exclusive_access().activate();
-}

os/src/mm/page_table.rs

@@ -1,249 +0,0 @@
-use super::{frame_alloc, FrameTracker, PhysAddr, PhysPageNum, StepByOne, VirtAddr, VirtPageNum};
-use alloc::string::String;
-use alloc::vec;
-use alloc::vec::Vec;
-use bitflags::*;
-
-bitflags! {
-    pub struct PTEFlags: u8 {
-        const V = 1 << 0;
-        const R = 1 << 1;
-        const W = 1 << 2;
-        const X = 1 << 3;
-        const U = 1 << 4;
-        const G = 1 << 5;
-        const A = 1 << 6;
-        const D = 1 << 7;
-    }
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct PageTableEntry {
-    pub bits: usize,
-}
-
-impl PageTableEntry {
-    pub fn new(ppn: PhysPageNum, flags: PTEFlags) -> Self {
-        PageTableEntry {
-            bits: ppn.0 << 10 | flags.bits as usize,
-        }
-    }
-    pub fn empty() -> Self {
-        PageTableEntry { bits: 0 }
-    }
-    pub fn ppn(&self) -> PhysPageNum {
-        (self.bits >> 10 & ((1usize << 44) - 1)).into()
-    }
-    pub fn flags(&self) -> PTEFlags {
-        PTEFlags::from_bits(self.bits as u8).unwrap()
-    }
-    pub fn is_valid(&self) -> bool {
-        (self.flags() & PTEFlags::V) != PTEFlags::empty()
-    }
-    pub fn readable(&self) -> bool {
-        (self.flags() & PTEFlags::R) != PTEFlags::empty()
-    }
-    pub fn writable(&self) -> bool {
-        (self.flags() & PTEFlags::W) != PTEFlags::empty()
-    }
-    pub fn executable(&self) -> bool {
-        (self.flags() & PTEFlags::X) != PTEFlags::empty()
-    }
-}
-
-pub struct PageTable {
-    root_ppn: PhysPageNum,
-    frames: Vec<FrameTracker>,
-}
-
-/// Assume that it won't oom when creating/mapping.
-impl PageTable {
-    pub fn new() -> Self {
-        let frame = frame_alloc().unwrap();
-        PageTable {
-            root_ppn: frame.ppn,
-            frames: vec![frame],
-        }
-    }
-    /// Temporarily used to get arguments from user space.
-    pub fn from_token(satp: usize) -> Self {
-        Self {
-            root_ppn: PhysPageNum::from(satp & ((1usize << 44) - 1)),
-            frames: Vec::new(),
-        }
-    }
-    fn find_pte_create(&mut self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
-        let idxs = vpn.indexes();
-        let mut ppn = self.root_ppn;
-        let mut result: Option<&mut PageTableEntry> = None;
-        for (i, idx) in idxs.iter().enumerate() {
-            let pte = &mut ppn.get_pte_array()[*idx];
-            if i == 2 {
-                result = Some(pte);
-                break;
-            }
-            if !pte.is_valid() {
-                let frame = frame_alloc().unwrap();
-                *pte = PageTableEntry::new(frame.ppn, PTEFlags::V);
-                self.frames.push(frame);
-            }
-            ppn = pte.ppn();
-        }
-        result
-    }
-    fn find_pte(&self, vpn: VirtPageNum) -> Option<&mut PageTableEntry> {
-        let idxs = vpn.indexes();
-        let mut ppn = self.root_ppn;
-        let mut result: Option<&mut PageTableEntry> = None;
-        for (i, idx) in idxs.iter().enumerate() {
-            let pte = &mut ppn.get_pte_array()[*idx];
-            if i == 2 {
-                result = Some(pte);
-                break;
-            }
-            if !pte.is_valid() {
-                return None;
-            }
-            ppn = pte.ppn();
-        }
-        result
-    }
-    #[allow(unused)]
-    pub fn map(&mut self, vpn: VirtPageNum, ppn: PhysPageNum, flags: PTEFlags) {
-        let pte = self.find_pte_create(vpn).unwrap();
-        assert!(!pte.is_valid(), "vpn {:?} is mapped before mapping", vpn);
-        *pte = PageTableEntry::new(ppn, flags | PTEFlags::V);
-    }
-    #[allow(unused)]
-    pub fn unmap(&mut self, vpn: VirtPageNum) {
-        let pte = self.find_pte(vpn).unwrap();
-        assert!(pte.is_valid(), "vpn {:?} is invalid before unmapping", vpn);
-        *pte = PageTableEntry::empty();
-    }
-    pub fn translate(&self, vpn: VirtPageNum) -> Option<PageTableEntry> {
-        self.find_pte(vpn).map(|pte| *pte)
-    }
-    pub fn translate_va(&self, va: VirtAddr) -> Option<PhysAddr> {
-        self.find_pte(va.clone().floor()).map(|pte| {
-            let aligned_pa: PhysAddr = pte.ppn().into();
-            let offset = va.page_offset();
-            let aligned_pa_usize: usize = aligned_pa.into();
-            (aligned_pa_usize + offset).into()
-        })
-    }
-    pub fn token(&self) -> usize {
-        8usize << 60 | self.root_ppn.0
-    }
-}
-
-pub fn translated_byte_buffer(token: usize, ptr: *const u8, len: usize) -> Vec<&'static mut [u8]> {
-    let page_table = PageTable::from_token(token);
-    let mut start = ptr as usize;
-    let end = start + len;
-    let mut v = Vec::new();
-    while start < end {
-        let start_va = VirtAddr::from(start);
-        let mut vpn = start_va.floor();
-        let ppn = page_table.translate(vpn).unwrap().ppn();
-        vpn.step();
-        let mut end_va: VirtAddr = vpn.into();
-        end_va = end_va.min(VirtAddr::from(end));
-        if end_va.page_offset() == 0 {
-            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..]);
-        } else {
-            v.push(&mut ppn.get_bytes_array()[start_va.page_offset()..end_va.page_offset()]);
-        }
-        start = end_va.into();
-    }
-    v
-}
-
-/// Load a string from other address spaces into kernel space without an end `\0`.
-pub fn translated_str(token: usize, ptr: *const u8) -> String {
-    let page_table = PageTable::from_token(token);
-    let mut string = String::new();
-    let mut va = ptr as usize;
-    loop {
-        let ch: u8 = *(page_table
-            .translate_va(VirtAddr::from(va))
-            .unwrap()
-            .get_mut());
-        if ch == 0 {
-            break;
-        }
-        string.push(ch as char);
-        va += 1;
-    }
-    string
-}
-
-pub fn translated_ref<T>(token: usize, ptr: *const T) -> &'static T {
-    let page_table = PageTable::from_token(token);
-    page_table
-        .translate_va(VirtAddr::from(ptr as usize))
-        .unwrap()
-        .get_ref()
-}
-
-pub fn translated_refmut<T>(token: usize, ptr: *mut T) -> &'static mut T {
-    let page_table = PageTable::from_token(token);
-    let va = ptr as usize;
-    page_table
-        .translate_va(VirtAddr::from(va))
-        .unwrap()
-        .get_mut()
-}
-
-pub struct UserBuffer {
-    pub buffers: Vec<&'static mut [u8]>,
-}
-
-impl UserBuffer {
-    pub fn new(buffers: Vec<&'static mut [u8]>) -> Self {
-        Self { buffers }
-    }
-    pub fn len(&self) -> usize {
-        let mut total: usize = 0;
-        for b in self.buffers.iter() {
-            total += b.len();
-        }
-        total
-    }
-}
-
-impl IntoIterator for UserBuffer {
-    type Item = *mut u8;
-    type IntoIter = UserBufferIterator;
-    fn into_iter(self) -> Self::IntoIter {
-        UserBufferIterator {
-            buffers: self.buffers,
-            current_buffer: 0,
-            current_idx: 0,
-        }
-    }
-}
-
-pub struct UserBufferIterator {
-    buffers: Vec<&'static mut [u8]>,
-    current_buffer: usize,
-    current_idx: usize,
-}
-
-impl Iterator for UserBufferIterator {
-    type Item = *mut u8;
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current_buffer >= self.buffers.len() {
-            None
-        } else {
-            let r = &mut self.buffers[self.current_buffer][self.current_idx] as *mut _;
-            if self.current_idx + 1 == self.buffers[self.current_buffer].len() {
-                self.current_idx = 0;
-                self.current_buffer += 1;
-            } else {
-                self.current_idx += 1;
-            }
-            Some(r)
-        }
-    }
-}

os/src/net/mod.rs

@@ -1,136 +0,0 @@
-pub mod port_table;
-pub mod socket;
-pub mod tcp;
-pub mod udp;
-
-pub use lose_net_stack::IPv4;
-
-use alloc::{sync::Arc, vec};
-use lose_net_stack::{results::Packet, LoseStack, MacAddress, TcpFlags};
-
-use crate::{
-    drivers::NET_DEVICE,
-    net::socket::{get_socket, push_data},
-    sync::UPIntrFreeCell,
-};
-
-use self::{port_table::check_accept, socket::set_s_a_by_index};
-
-pub struct NetStack(UPIntrFreeCell<LoseStack>);
-
-impl NetStack {
-    pub fn new() -> Self {
-        unsafe {
-            NetStack(UPIntrFreeCell::new(LoseStack::new(
-                IPv4::new(10, 0, 2, 15),
-                MacAddress::new([0x52, 0x54, 0x00, 0x12, 0x34, 0x56]),
-            )))
-        }
-    }
-}
-
-lazy_static::lazy_static! {
-    static ref LOSE_NET_STACK: Arc<NetStack> = Arc::new(NetStack::new());
-}
-
-pub fn net_interrupt_handler() {
-    let mut recv_buf = vec![0u8; 1024];
-
-    let len = NET_DEVICE.receive(&mut recv_buf);
-
-    let packet = LOSE_NET_STACK
-        .0
-        .exclusive_access()
-        .analysis(&recv_buf[..len]);
-
-    // println!("[kernel] receive a packet");
-    // hexdump(&recv_buf[..len]);
-
-    match packet {
-        Packet::ARP(arp_packet) => {
-            let lose_stack = LOSE_NET_STACK.0.exclusive_access();
-            let reply_packet = arp_packet
-                .reply_packet(lose_stack.ip, lose_stack.mac)
-                .expect("can't build reply");
-            let reply_data = reply_packet.build_data();
-            NET_DEVICE.transmit(&reply_data)
-        }
-
-        Packet::UDP(udp_packet) => {
-            let target = udp_packet.source_ip;
-            let lport = udp_packet.dest_port;
-            let rport = udp_packet.source_port;
-
-            if let Some(socket_index) = get_socket(target, lport, rport) {
-                push_data(socket_index, udp_packet.data.to_vec());
-            }
-        }
-
-        Packet::TCP(tcp_packet) => {
-            let target = tcp_packet.source_ip;
-            let lport = tcp_packet.dest_port;
-            let rport = tcp_packet.source_port;
-            let flags = tcp_packet.flags;
-
-            if flags.contains(TcpFlags::S) {
-                // if it has a port to accept, then response the request
-                if check_accept(lport, &tcp_packet).is_some() {
-                    let mut reply_packet = tcp_packet.ack();
-                    reply_packet.flags = TcpFlags::S | TcpFlags::A;
-                    NET_DEVICE.transmit(&reply_packet.build_data());
-                }
-                return;
-            } else if tcp_packet.flags.contains(TcpFlags::F) {
-                // tcp disconnected
-                let reply_packet = tcp_packet.ack();
-                NET_DEVICE.transmit(&reply_packet.build_data());
-
-                let mut end_packet = reply_packet.ack();
-                end_packet.flags |= TcpFlags::F;
-                NET_DEVICE.transmit(&end_packet.build_data());
-            } else if tcp_packet.flags.contains(TcpFlags::A) && tcp_packet.data_len == 0 {
-                return;
-            }
-
-            if let Some(socket_index) = get_socket(target, lport, rport) {
-                push_data(socket_index, tcp_packet.data.to_vec());
-                set_s_a_by_index(socket_index, tcp_packet.seq, tcp_packet.ack);
-            }
-        }
-        _ => {}
-    }
-}
-
-#[allow(unused)]
-pub fn hexdump(data: &[u8]) {
-    const PRELAND_WIDTH: usize = 70;
-    println!("[kernel] {:-^1$}", " hexdump ", PRELAND_WIDTH);
-    for offset in (0..data.len()).step_by(16) {
-        print!("[kernel] ");
-        for i in 0..16 {
-            if offset + i < data.len() {
-                print!("{:02x} ", data[offset + i]);
-            } else {
-                print!("{:02} ", "");
-            }
-        }
-
-        print!("{:>6}", ' ');
-
-        for i in 0..16 {
-            if offset + i < data.len() {
-                let c = data[offset + i];
-                if c >= 0x20 && c <= 0x7e {
-                    print!("{}", c as char);
-                } else {
-                    print!(".");
-                }
-            } else {
-                print!("{:02} ", "");
-            }
-        }
-
-        println!("");
-    }
-    println!("[kernel] {:-^1$}", " hexdump end ", PRELAND_WIDTH);
-}

os/src/net/port_table.rs

@@ -1,141 +0,0 @@
-use alloc::{sync::Arc, vec::Vec};
-use lazy_static::lazy_static;
-use lose_net_stack::packets::tcp::TCPPacket;
-
-use crate::fs::File;
-use crate::sync::UPIntrFreeCell;
-use crate::task::TaskControlBlock;
-
-use super::tcp::TCP;
-
-pub struct Port {
-    pub port: u16,
-    pub receivable: bool,
-    pub schedule: Option<Arc<TaskControlBlock>>,
-}
-
-lazy_static! {
-    static ref LISTEN_TABLE: UPIntrFreeCell<Vec<Option<Port>>> =
-        unsafe { UPIntrFreeCell::new(Vec::new()) };
-}
-
-pub fn listen(port: u16) -> Option<usize> {
-    let mut listen_table = LISTEN_TABLE.exclusive_access();
-    let mut index = usize::MAX;
-    for i in 0..listen_table.len() {
-        if listen_table[i].is_none() {
-            index = i;
-            break;
-        }
-    }
-
-    let listen_port = Port {
-        port,
-        receivable: false,
-        schedule: None,
-    };
-
-    if index == usize::MAX {
-        listen_table.push(Some(listen_port));
-        Some(listen_table.len() - 1)
-    } else {
-        listen_table[index] = Some(listen_port);
-        Some(index)
-    }
-}
-
-// can accept request
-pub fn accept(listen_index: usize, task: Arc<TaskControlBlock>) {
-    let mut listen_table = LISTEN_TABLE.exclusive_access();
-    assert!(listen_index < listen_table.len());
-    let listen_port = listen_table[listen_index].as_mut();
-    assert!(listen_port.is_some());
-    let listen_port = listen_port.unwrap();
-    listen_port.receivable = true;
-    listen_port.schedule = Some(task);
-}
-
-pub fn port_acceptable(listen_index: usize) -> bool {
-    let mut listen_table = LISTEN_TABLE.exclusive_access();
-    assert!(listen_index < listen_table.len());
-
-    let listen_port = listen_table[listen_index].as_mut();
-    listen_port.map_or(false, |x| x.receivable)
-}
-
-// check whether it can accept request
-pub fn check_accept(port: u16, tcp_packet: &TCPPacket) -> Option<()> {
-    LISTEN_TABLE.exclusive_session(|listen_table| {
-        let mut listen_ports: Vec<&mut Option<Port>> = listen_table
-            .iter_mut()
-            .filter(|x| match x {
-                Some(t) => t.port == port && t.receivable == true,
-                None => false,
-            })
-            .collect();
-        if listen_ports.len() == 0 {
-            None
-        } else {
-            let listen_port = listen_ports[0].as_mut().unwrap();
-            let task = listen_port.schedule.clone().unwrap();
-            // wakeup_task(Arc::clone(&listen_port.schedule.clone().unwrap()));
-            listen_port.schedule = None;
-            listen_port.receivable = false;
-
-            accept_connection(port, tcp_packet, task);
-            Some(())
-        }
-    })
-}
-
-pub fn accept_connection(_port: u16, tcp_packet: &TCPPacket, task: Arc<TaskControlBlock>) {
-    let process = task.process.upgrade().unwrap();
-    let mut inner = process.inner_exclusive_access();
-    let fd = inner.alloc_fd();
-
-    let tcp_socket = TCP::new(
-        tcp_packet.source_ip,
-        tcp_packet.dest_port,
-        tcp_packet.source_port,
-        tcp_packet.seq,
-        tcp_packet.ack,
-    );
-
-    inner.fd_table[fd] = Some(Arc::new(tcp_socket));
-
-    let cx = task.inner_exclusive_access().get_trap_cx();
-    cx.x[10] = fd;
-}
-
-// store in the fd_table, delete the listen table when close the application.
-pub struct PortFd(usize);
-
-impl PortFd {
-    pub fn new(port_index: usize) -> Self {
-        PortFd(port_index)
-    }
-}
-
-impl Drop for PortFd {
-    fn drop(&mut self) {
-        LISTEN_TABLE.exclusive_access()[self.0] = None
-    }
-}
-
-impl File for PortFd {
-    fn readable(&self) -> bool {
-        false
-    }
-
-    fn writable(&self) -> bool {
-        false
-    }
-
-    fn read(&self, _buf: crate::mm::UserBuffer) -> usize {
-        0
-    }
-
-    fn write(&self, _buf: crate::mm::UserBuffer) -> usize {
-        0
-    }
-}

os/src/net/socket.rs

@@ -1,123 +0,0 @@
-use alloc::collections::VecDeque;
-use alloc::vec::Vec;
-use lazy_static::lazy_static;
-use lose_net_stack::IPv4;
-
-use crate::sync::UPIntrFreeCell;
-
-// TODO: specify the protocol, TCP or UDP
-pub struct Socket {
-    pub raddr: IPv4,                // remote address
-    pub lport: u16,                 // local port
-    pub rport: u16,                 // rempote port
-    pub buffers: VecDeque<Vec<u8>>, // datas
-    pub seq: u32,
-    pub ack: u32,
-}
-
-lazy_static! {
-    static ref SOCKET_TABLE: UPIntrFreeCell<Vec<Option<Socket>>> =
-        unsafe { UPIntrFreeCell::new(Vec::new()) };
-}
-
-/// get the seq and ack by socket index
-pub fn get_s_a_by_index(index: usize) -> Option<(u32, u32)> {
-    let socket_table = SOCKET_TABLE.exclusive_access();
-
-    assert!(index < socket_table.len());
-
-    socket_table.get(index).map_or(None, |x| match x {
-        Some(x) => Some((x.seq, x.ack)),
-        None => None,
-    })
-}
-
-pub fn set_s_a_by_index(index: usize, seq: u32, ack: u32) {
-    let mut socket_table = SOCKET_TABLE.exclusive_access();
-
-    assert!(socket_table.len() > index);
-    assert!(socket_table[index].is_some());
-
-    let sock = socket_table[index].as_mut().unwrap();
-
-    sock.ack = ack;
-    sock.seq = seq;
-}
-
-pub fn get_socket(raddr: IPv4, lport: u16, rport: u16) -> Option<usize> {
-    let socket_table = SOCKET_TABLE.exclusive_access();
-    for i in 0..socket_table.len() {
-        let sock = &socket_table[i];
-        if sock.is_none() {
-            continue;
-        }
-
-        let sock = sock.as_ref().unwrap();
-        if sock.raddr == raddr && sock.lport == lport && sock.rport == rport {
-            return Some(i);
-        }
-    }
-    None
-}
-
-pub fn add_socket(raddr: IPv4, lport: u16, rport: u16) -> Option<usize> {
-    if get_socket(raddr, lport, rport).is_some() {
-        return None;
-    }
-
-    let mut socket_table = SOCKET_TABLE.exclusive_access();
-    let mut index = usize::MAX;
-    for i in 0..socket_table.len() {
-        if socket_table[i].is_none() {
-            index = i;
-            break;
-        }
-    }
-
-    let socket = Socket {
-        raddr,
-        lport,
-        rport,
-        buffers: VecDeque::new(),
-        seq: 0,
-        ack: 0,
-    };
-
-    if index == usize::MAX {
-        socket_table.push(Some(socket));
-        Some(socket_table.len() - 1)
-    } else {
-        socket_table[index] = Some(socket);
-        Some(index)
-    }
-}
-
-pub fn remove_socket(index: usize) {
-    let mut socket_table = SOCKET_TABLE.exclusive_access();
-
-    assert!(socket_table.len() > index);
-
-    socket_table[index] = None;
-}
-
-pub fn push_data(index: usize, data: Vec<u8>) {
-    let mut socket_table = SOCKET_TABLE.exclusive_access();
-
-    assert!(socket_table.len() > index);
-    assert!(socket_table[index].is_some());
-
-    socket_table[index]
-        .as_mut()
-        .unwrap()
-        .buffers
-        .push_back(data);
-}
-
-pub fn pop_data(index: usize) -> Option<Vec<u8>> {
-    let mut socket_table = SOCKET_TABLE.exclusive_access();
-
-    assert!(socket_table.len() > index);
-    assert!(socket_table[index].is_some());
-
-    socket_table[index].as_mut().unwrap().buffers.pop_front()
-}

os/src/net/tcp.rs

@@ -1,113 +0,0 @@
-use alloc::vec;
-use lose_net_stack::packets::tcp::TCPPacket;
-use lose_net_stack::IPv4;
-use lose_net_stack::MacAddress;
-use lose_net_stack::TcpFlags;
-
-use crate::{drivers::NET_DEVICE, fs::File};
-
-use super::socket::get_s_a_by_index;
-use super::{
-    net_interrupt_handler,
-    socket::{add_socket, pop_data, remove_socket},
-    LOSE_NET_STACK,
-};
-
-// add tcp packet info to this structure
-pub struct TCP {
-    pub target: IPv4,
-    pub sport: u16,
-    pub dport: u16,
-    pub seq: u32,
-    pub ack: u32,
-    pub socket_index: usize,
-}
-
-impl TCP {
-    pub fn new(target: IPv4, sport: u16, dport: u16, seq: u32, ack: u32) -> Self {
-        let index = add_socket(target, sport, dport).expect("can't add socket");
-
-        Self {
-            target,
-            sport,
-            dport,
-            seq,
-            ack,
-            socket_index: index,
-        }
-    }
-}
-
-impl File for TCP {
-    fn readable(&self) -> bool {
-        true
-    }
-
-    fn writable(&self) -> bool {
-        true
-    }
-
-    fn read(&self, mut buf: crate::mm::UserBuffer) -> usize {
-        loop {
-            if let Some(data) = pop_data(self.socket_index) {
-                let data_len = data.len();
-                let mut left = 0;
-                for i in 0..buf.buffers.len() {
-                    let buffer_i_len = buf.buffers[i].len().min(data_len - left);
-
-                    buf.buffers[i][..buffer_i_len]
-                        .copy_from_slice(&data[left..(left + buffer_i_len)]);
-
-                    left += buffer_i_len;
-                    if left == data_len {
-                        break;
-                    }
-                }
-                return left;
-            } else {
-                net_interrupt_handler();
-            }
-        }
-    }
-
-    fn write(&self, buf: crate::mm::UserBuffer) -> usize {
-        let lose_net_stack = LOSE_NET_STACK.0.exclusive_access();
-
-        let mut data = vec![0u8; buf.len()];
-
-        let mut left = 0;
-        for i in 0..buf.buffers.len() {
-            data[left..(left + buf.buffers[i].len())].copy_from_slice(buf.buffers[i]);
-            left += buf.buffers[i].len();
-        }
-
-        let len = data.len();
-
-        // get sock and sequence
-        let (ack, seq) = get_s_a_by_index(self.socket_index).map_or((0, 0), |x| x);
-
-        let tcp_packet = TCPPacket {
-            source_ip: lose_net_stack.ip,
-            source_mac: lose_net_stack.mac,
-            source_port: self.sport,
-            dest_ip: self.target,
-            dest_mac: MacAddress::new([0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
-            dest_port: self.dport,
-            data_len: len,
-            seq,
-            ack,
-            flags: TcpFlags::A,
-            win: 65535,
-            urg: 0,
-            data: data.as_ref(),
-        };
-        NET_DEVICE.transmit(&tcp_packet.build_data());
-        len
-    }
-}
-
-impl Drop for TCP {
-    fn drop(&mut self) {
-        remove_socket(self.socket_index)
-    }
-}

os/src/net/udp.rs

@@ -1,95 +0,0 @@
-use super::net_interrupt_handler;
-use super::socket::{add_socket, pop_data, remove_socket};
-use super::LOSE_NET_STACK;
-use super::NET_DEVICE;
-use crate::fs::File;
-use alloc::vec;
-use lose_net_stack::packets::udp::UDPPacket;
-use lose_net_stack::IPv4;
-use lose_net_stack::MacAddress;
-
-pub struct UDP {
-    pub target: IPv4,
-    pub sport: u16,
-    pub dport: u16,
-    pub socket_index: usize,
-}
-
-impl UDP {
-    pub fn new(target: IPv4, sport: u16, dport: u16) -> Self {
-        let index = add_socket(target, sport, dport).expect("can't add socket");
-
-        Self {
-            target,
-            sport,
-            dport,
-            socket_index: index,
-        }
-    }
-}
-
-impl File for UDP {
-    fn readable(&self) -> bool {
-        true
-    }
-
-    fn writable(&self) -> bool {
-        true
-    }
-
-    fn read(&self, mut buf: crate::mm::UserBuffer) -> usize {
-        loop {
-            if let Some(data) = pop_data(self.socket_index) {
-                let data_len = data.len();
-                let mut left = 0;
-                for i in 0..buf.buffers.len() {
-                    let buffer_i_len = buf.buffers[i].len().min(data_len - left);
-
-                    buf.buffers[i][..buffer_i_len]
-                        .copy_from_slice(&data[left..(left + buffer_i_len)]);
-
-                    left += buffer_i_len;
-                    if left == data_len {
-                        break;
-                    }
-                }
-                return left;
-            } else {
-                net_interrupt_handler();
-            }
-        }
-    }
-
-    fn write(&self, buf: crate::mm::UserBuffer) -> usize {
-        let lose_net_stack = LOSE_NET_STACK.0.exclusive_access();
-
-        let mut data = vec![0u8; buf.len()];
-
-        let mut left = 0;
-        for i in 0..buf.buffers.len() {
-            data[left..(left + buf.buffers[i].len())].copy_from_slice(buf.buffers[i]);
-            left += buf.buffers[i].len();
-        }
-
-        let len = data.len();
-
-        let udp_packet = UDPPacket::new(
-            lose_net_stack.ip,
-            lose_net_stack.mac,
-            self.sport,
-            self.target,
-            MacAddress::new([0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
-            self.dport,
-            len,
-            data.as_ref(),
-        );
-        NET_DEVICE.transmit(&udp_packet.build_data());
-        len
-    }
-}
-
-impl Drop for UDP {
-    fn drop(&mut self) {
-        remove_socket(self.socket_index)
-    }
-}

os/src/sbi.rs

@@ -1,15 +1,44 @@
-/// use sbi call to set timer
+#![allow(unused)]
-pub fn set_timer(timer: usize) {
+
-    sbi_rt::set_timer(timer as _);
+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 {
+        asm!(
+            "ecall",
+            inlateout("x10") arg0 => ret,
+            in("x11") arg1,
+            in("x12") arg2,
+            in("x17") which,
+        );
+    }
+    ret
 }
 
-/// use sbi call to shutdown the kernel
+pub fn set_timer(timer: usize) {
-pub fn shutdown(failure: bool) -> ! {
+    sbi_call(SBI_SET_TIMER, timer, 0, 0);
-    use sbi_rt::{system_reset, NoReason, Shutdown, SystemFailure};
-    if !failure {
-        system_reset(Shutdown, NoReason);
-    } else {
-        system_reset(Shutdown, SystemFailure);
-    }
-    unreachable!()
 }
+
+pub fn console_putchar(c: usize) {
+    sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0);
+}
+
+pub fn console_getchar() -> usize {
+    sbi_call(SBI_CONSOLE_GETCHAR, 0, 0, 0)
+}
+
+pub fn shutdown() -> ! {
+    sbi_call(SBI_SHUTDOWN, 0, 0, 0);
+    panic!("It should shutdown!");
+}
+

os/src/sync/condvar.rs

@@ -1,58 +0,0 @@
-use crate::sync::{Mutex, UPIntrFreeCell};
-use crate::task::{
-    block_current_and_run_next, block_current_task, current_task, wakeup_task, TaskContext,
-    TaskControlBlock,
-};
-use alloc::{collections::VecDeque, sync::Arc};
-
-pub struct Condvar {
-    pub inner: UPIntrFreeCell<CondvarInner>,
-}
-
-pub struct CondvarInner {
-    pub wait_queue: VecDeque<Arc<TaskControlBlock>>,
-}
-
-impl Condvar {
-    pub fn new() -> Self {
-        Self {
-            inner: unsafe {
-                UPIntrFreeCell::new(CondvarInner {
-                    wait_queue: VecDeque::new(),
-                })
-            },
-        }
-    }
-
-    pub fn signal(&self) {
-        let mut inner = self.inner.exclusive_access();
-        if let Some(task) = inner.wait_queue.pop_front() {
-            wakeup_task(task);
-        }
-    }
-
-    /*
-    pub fn wait(&self) {
-        let mut inner = self.inner.exclusive_access();
-        inner.wait_queue.push_back(current_task().unwrap());
-        drop(inner);
-        block_current_and_run_next();
-    }
-    */
-
-    pub fn wait_no_sched(&self) -> *mut TaskContext {
-        self.inner.exclusive_session(|inner| {
-            inner.wait_queue.push_back(current_task().unwrap());
-        });
-        block_current_task()
-    }
-
-    pub fn wait_with_mutex(&self, mutex: Arc<dyn Mutex>) {
-        mutex.unlock();
-        self.inner.exclusive_session(|inner| {
-            inner.wait_queue.push_back(current_task().unwrap());
-        });
-        block_current_and_run_next();
-        mutex.lock();
-    }
-}

os/src/sync/mod.rs

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

os/src/sync/mutex.rs

@@ -1,88 +0,0 @@
-use super::UPIntrFreeCell;
-use crate::task::TaskControlBlock;
-use crate::task::{block_current_and_run_next, suspend_current_and_run_next};
-use crate::task::{current_task, wakeup_task};
-use alloc::{collections::VecDeque, sync::Arc};
-
-pub trait Mutex: Sync + Send {
-    fn lock(&self);
-    fn unlock(&self);
-}
-
-pub struct MutexSpin {
-    locked: UPIntrFreeCell<bool>,
-}
-
-impl MutexSpin {
-    pub fn new() -> Self {
-        Self {
-            locked: unsafe { UPIntrFreeCell::new(false) },
-        }
-    }
-}
-
-impl Mutex for MutexSpin {
-    fn lock(&self) {
-        loop {
-            let mut locked = self.locked.exclusive_access();
-            if *locked {
-                drop(locked);
-                suspend_current_and_run_next();
-                continue;
-            } else {
-                *locked = true;
-                return;
-            }
-        }
-    }
-
-    fn unlock(&self) {
-        let mut locked = self.locked.exclusive_access();
-        *locked = false;
-    }
-}
-
-pub struct MutexBlocking {
-    inner: UPIntrFreeCell<MutexBlockingInner>,
-}
-
-pub struct MutexBlockingInner {
-    locked: bool,
-    wait_queue: VecDeque<Arc<TaskControlBlock>>,
-}
-
-impl MutexBlocking {
-    pub fn new() -> Self {
-        Self {
-            inner: unsafe {
-                UPIntrFreeCell::new(MutexBlockingInner {
-                    locked: false,
-                    wait_queue: VecDeque::new(),
-                })
-            },
-        }
-    }
-}
-
-impl Mutex for MutexBlocking {
-    fn lock(&self) {
-        let mut mutex_inner = self.inner.exclusive_access();
-        if mutex_inner.locked {
-            mutex_inner.wait_queue.push_back(current_task().unwrap());
-            drop(mutex_inner);
-            block_current_and_run_next();
-        } else {
-            mutex_inner.locked = true;
-        }
-    }
-
-    fn unlock(&self) {
-        let mut mutex_inner = self.inner.exclusive_access();
-        assert!(mutex_inner.locked);
-        if let Some(waking_task) = mutex_inner.wait_queue.pop_front() {
-            wakeup_task(waking_task);
-        } else {
-            mutex_inner.locked = false;
-        }
-    }
-}

os/src/sync/semaphore.rs

@@ -1,45 +0,0 @@
-use crate::sync::UPIntrFreeCell;
-use crate::task::{block_current_and_run_next, current_task, wakeup_task, TaskControlBlock};
-use alloc::{collections::VecDeque, sync::Arc};
-
-pub struct Semaphore {
-    pub inner: UPIntrFreeCell<SemaphoreInner>,
-}
-
-pub struct SemaphoreInner {
-    pub count: isize,
-    pub wait_queue: VecDeque<Arc<TaskControlBlock>>,
-}
-
-impl Semaphore {
-    pub fn new(res_count: usize) -> Self {
-        Self {
-            inner: unsafe {
-                UPIntrFreeCell::new(SemaphoreInner {
-                    count: res_count as isize,
-                    wait_queue: VecDeque::new(),
-                })
-            },
-        }
-    }
-
-    pub fn up(&self) {
-        let mut inner = self.inner.exclusive_access();
-        inner.count += 1;
-        if inner.count <= 0 {
-            if let Some(task) = inner.wait_queue.pop_front() {
-                wakeup_task(task);
-            }
-        }
-    }
-
-    pub fn down(&self) {
-        let mut inner = self.inner.exclusive_access();
-        inner.count -= 1;
-        if inner.count < 0 {
-            inner.wait_queue.push_back(current_task().unwrap());
-            drop(inner);
-            block_current_and_run_next();
-        }
-    }
-}

os/src/sync/up.rs

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

os/src/syscall/fs.rs

@@ -1,99 +1,15 @@
-use crate::fs::{make_pipe, open_file, OpenFlags};
+const FD_STDOUT: usize = 1;
-use crate::mm::{translated_byte_buffer, translated_refmut, translated_str, UserBuffer};
-use crate::task::{current_process, current_user_token};
-use alloc::sync::Arc;
 
 pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize {
-    let token = current_user_token();
+    match fd {
-    let process = current_process();
+        FD_STDOUT => {
-    let inner = process.inner_exclusive_access();
+            let slice = unsafe { core::slice::from_raw_parts(buf, len) };
-    if fd >= inner.fd_table.len() {
+            let str = core::str::from_utf8(slice).unwrap();
-        return -1;
+            print!("{}", str);
-    }
+            len as isize
-    if let Some(file) = &inner.fd_table[fd] {
+        },
-        if !file.writable() {
+        _ => {
-            return -1;
+            panic!("Unsupported fd in sys_write!");
         }
-        let file = file.clone();
-        // release current task TCB manually to avoid multi-borrow
-        drop(inner);
-        file.write(UserBuffer::new(translated_byte_buffer(token, buf, len))) as isize
-    } else {
-        -1
     }
-}
+}
-
-pub fn sys_read(fd: usize, buf: *const u8, len: usize) -> isize {
-    let token = current_user_token();
-    let process = current_process();
-    let inner = process.inner_exclusive_access();
-    if fd >= inner.fd_table.len() {
-        return -1;
-    }
-    if let Some(file) = &inner.fd_table[fd] {
-        let file = file.clone();
-        if !file.readable() {
-            return -1;
-        }
-        // release current task TCB manually to avoid multi-borrow
-        drop(inner);
-        file.read(UserBuffer::new(translated_byte_buffer(token, buf, len))) as isize
-    } else {
-        -1
-    }
-}
-
-pub fn sys_open(path: *const u8, flags: u32) -> isize {
-    let process = current_process();
-    let token = current_user_token();
-    let path = translated_str(token, path);
-    if let Some(inode) = open_file(path.as_str(), OpenFlags::from_bits(flags).unwrap()) {
-        let mut inner = process.inner_exclusive_access();
-        let fd = inner.alloc_fd();
-        inner.fd_table[fd] = Some(inode);
-        fd as isize
-    } else {
-        -1
-    }
-}
-
-pub fn sys_close(fd: usize) -> isize {
-    let process = current_process();
-    let mut inner = process.inner_exclusive_access();
-    if fd >= inner.fd_table.len() {
-        return -1;
-    }
-    if inner.fd_table[fd].is_none() {
-        return -1;
-    }
-    inner.fd_table[fd].take();
-    0
-}
-
-pub fn sys_pipe(pipe: *mut usize) -> isize {
-    let process = current_process();
-    let token = current_user_token();
-    let mut inner = process.inner_exclusive_access();
-    let (pipe_read, pipe_write) = make_pipe();
-    let read_fd = inner.alloc_fd();
-    inner.fd_table[read_fd] = Some(pipe_read);
-    let write_fd = inner.alloc_fd();
-    inner.fd_table[write_fd] = Some(pipe_write);
-    *translated_refmut(token, pipe) = read_fd;
-    *translated_refmut(token, unsafe { pipe.add(1) }) = write_fd;
-    0
-}
-
-pub fn sys_dup(fd: usize) -> isize {
-    let process = current_process();
-    let mut inner = process.inner_exclusive_access();
-    if fd >= inner.fd_table.len() {
-        return -1;
-    }
-    if inner.fd_table[fd].is_none() {
-        return -1;
-    }
-    let new_fd = inner.alloc_fd();
-    inner.fd_table[new_fd] = Some(Arc::clone(inner.fd_table[fd].as_ref().unwrap()));
-    new_fd as isize
-}

os/src/syscall/gui.rs

@@ -1,34 +0,0 @@
-use crate::drivers::GPU_DEVICE;
-use crate::mm::{MapArea, MapPermission, MapType, PhysAddr, VirtAddr};
-use crate::task::current_process;
-
-const FB_VADDR: usize = 0x10000000;
-
-pub fn sys_framebuffer() -> isize {
-    let fb = GPU_DEVICE.get_framebuffer();
-    let len = fb.len();
-    // println!("[kernel] FrameBuffer: addr 0x{:X}, len {}", fb.as_ptr() as usize , len);
-    let fb_start_pa = PhysAddr::from(fb.as_ptr() as usize);
-    assert!(fb_start_pa.aligned());
-    let fb_start_ppn = fb_start_pa.floor();
-    let fb_start_vpn = VirtAddr::from(FB_VADDR).floor();
-    let pn_offset = fb_start_ppn.0 as isize - fb_start_vpn.0 as isize;
-
-    let current_process = current_process();
-    let mut inner = current_process.inner_exclusive_access();
-    inner.memory_set.push(
-        MapArea::new(
-            (FB_VADDR as usize).into(),
-            (FB_VADDR + len as usize).into(),
-            MapType::Linear(pn_offset),
-            MapPermission::R | MapPermission::W | MapPermission::U,
-        ),
-        None,
-    );
-    FB_VADDR as isize
-}
-
-pub fn sys_framebuffer_flush() -> isize {
-    GPU_DEVICE.flush();
-    0
-}

os/src/syscall/input.rs

@@ -1,28 +0,0 @@
-//use crate::drivers::{KEYBOARD_DEVICE,MOUSE_DEVICE,INPUT_CONDVAR,read_input_event};
-use crate::drivers::{KEYBOARD_DEVICE, MOUSE_DEVICE};
-
-pub fn sys_event_get() -> isize {
-    let kb = KEYBOARD_DEVICE.clone();
-    let mouse = MOUSE_DEVICE.clone();
-    //let input=INPUT_CONDVAR.clone();
-    //read_input_event() as isize
-    if !kb.is_empty() {
-        kb.read_event() as isize
-    } else if !mouse.is_empty() {
-        mouse.read_event() as isize
-    } else {
-        0
-    }
-}
-
-use crate::drivers::chardev::UART;
-
-/// check UART's read-buffer is empty or not
-pub fn sys_key_pressed() -> isize {
-    let res = !UART.read_buffer_is_empty();
-    if res {
-        1
-    } else {
-        0
-    }
-}

os/src/syscall/mod.rs

@@ -1,90 +1,21 @@
-const SYSCALL_DUP: usize = 24;
-const SYSCALL_CONNECT: usize = 29;
-const SYSCALL_LISTEN: usize = 30;
-const SYSCALL_ACCEPT: usize = 31;
-const SYSCALL_OPEN: usize = 56;
-const SYSCALL_CLOSE: usize = 57;
-const SYSCALL_PIPE: usize = 59;
-const SYSCALL_READ: usize = 63;
 const SYSCALL_WRITE: usize = 64;
 const SYSCALL_EXIT: usize = 93;
-const SYSCALL_SLEEP: usize = 101;
 const SYSCALL_YIELD: usize = 124;
-const SYSCALL_KILL: usize = 129;
 const SYSCALL_GET_TIME: usize = 169;
-const SYSCALL_GETPID: usize = 172;
-const SYSCALL_FORK: usize = 220;
-const SYSCALL_EXEC: usize = 221;
-const SYSCALL_WAITPID: usize = 260;
-const SYSCALL_THREAD_CREATE: usize = 1000;
-const SYSCALL_GETTID: usize = 1001;
-const SYSCALL_WAITTID: usize = 1002;
-const SYSCALL_MUTEX_CREATE: usize = 1010;
-const SYSCALL_MUTEX_LOCK: usize = 1011;
-const SYSCALL_MUTEX_UNLOCK: usize = 1012;
-const SYSCALL_SEMAPHORE_CREATE: usize = 1020;
-const SYSCALL_SEMAPHORE_UP: usize = 1021;
-const SYSCALL_SEMAPHORE_DOWN: usize = 1022;
-const SYSCALL_CONDVAR_CREATE: usize = 1030;
-const SYSCALL_CONDVAR_SIGNAL: usize = 1031;
-const SYSCALL_CONDVAR_WAIT: usize = 1032;
-const SYSCALL_FRAMEBUFFER: usize = 2000;
-const SYSCALL_FRAMEBUFFER_FLUSH: usize = 2001;
-const SYSCALL_EVENT_GET: usize = 3000;
-const SYSCALL_KEY_PRESSED: usize = 3001;
 
 mod fs;
-mod gui;
-mod input;
-mod net;
 mod process;
-mod sync;
-mod thread;
 
 use fs::*;
-use gui::*;
-use input::*;
-use net::*;
 use process::*;
-use sync::*;
-use thread::*;
 
 pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
     match syscall_id {
-        SYSCALL_DUP => sys_dup(args[0]),
-        SYSCALL_CONNECT => sys_connect(args[0] as _, args[1] as _, args[2] as _),
-        SYSCALL_LISTEN => sys_listen(args[0] as _),
-        SYSCALL_ACCEPT => sys_accept(args[0] as _),
-        SYSCALL_OPEN => sys_open(args[0] as *const u8, args[1] as u32),
-        SYSCALL_CLOSE => sys_close(args[0]),
-        SYSCALL_PIPE => sys_pipe(args[0] as *mut usize),
-        SYSCALL_READ => sys_read(args[0], args[1] as *const u8, args[2]),
         SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
         SYSCALL_EXIT => sys_exit(args[0] as i32),
-        SYSCALL_SLEEP => sys_sleep(args[0]),
         SYSCALL_YIELD => sys_yield(),
-        SYSCALL_KILL => sys_kill(args[0], args[1] as u32),
+        SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal, args[1]),
-        SYSCALL_GET_TIME => sys_get_time(),
-        SYSCALL_GETPID => sys_getpid(),
-        SYSCALL_FORK => sys_fork(),
-        SYSCALL_EXEC => sys_exec(args[0] as *const u8, args[1] as *const usize),
-        SYSCALL_WAITPID => sys_waitpid(args[0] as isize, args[1] as *mut i32),
-        SYSCALL_THREAD_CREATE => sys_thread_create(args[0], args[1]),
-        SYSCALL_GETTID => sys_gettid(),
-        SYSCALL_WAITTID => sys_waittid(args[0]) as isize,
-        SYSCALL_MUTEX_CREATE => sys_mutex_create(args[0] == 1),
-        SYSCALL_MUTEX_LOCK => sys_mutex_lock(args[0]),
-        SYSCALL_MUTEX_UNLOCK => sys_mutex_unlock(args[0]),
-        SYSCALL_SEMAPHORE_CREATE => sys_semaphore_create(args[0]),
-        SYSCALL_SEMAPHORE_UP => sys_semaphore_up(args[0]),
-        SYSCALL_SEMAPHORE_DOWN => sys_semaphore_down(args[0]),
-        SYSCALL_CONDVAR_CREATE => sys_condvar_create(),
-        SYSCALL_CONDVAR_SIGNAL => sys_condvar_signal(args[0]),
-        SYSCALL_CONDVAR_WAIT => sys_condvar_wait(args[0], args[1]),
-        SYSCALL_FRAMEBUFFER => sys_framebuffer(),
-        SYSCALL_FRAMEBUFFER_FLUSH => sys_framebuffer_flush(),
-        SYSCALL_EVENT_GET => sys_event_get(),
-        SYSCALL_KEY_PRESSED => sys_key_pressed(),
         _ => panic!("Unsupported syscall_id: {}", syscall_id),
     }
 }
+

os/src/syscall/net.rs

@@ -1,53 +0,0 @@
-use crate::net::port_table::{accept, listen, port_acceptable, PortFd};
-use crate::net::udp::UDP;
-use crate::net::{net_interrupt_handler, IPv4};
-use crate::task::{current_process, current_task, current_trap_cx};
-use alloc::sync::Arc;
-
-// just support udp
-pub fn sys_connect(raddr: u32, lport: u16, rport: u16) -> isize {
-    let process = current_process();
-    let mut inner = process.inner_exclusive_access();
-    let fd = inner.alloc_fd();
-    let udp_node = UDP::new(IPv4::from_u32(raddr), lport, rport);
-    inner.fd_table[fd] = Some(Arc::new(udp_node));
-    fd as isize
-}
-
-// listen a port
-pub fn sys_listen(port: u16) -> isize {
-    match listen(port) {
-        Some(port_index) => {
-            let process = current_process();
-            let mut inner = process.inner_exclusive_access();
-            let fd = inner.alloc_fd();
-            let port_fd = PortFd::new(port_index);
-            inner.fd_table[fd] = Some(Arc::new(port_fd));
-
-            // NOTICE: this return the port index, not the fd
-            port_index as isize
-        }
-        None => -1,
-    }
-}
-
-// accept a tcp connection
-pub fn sys_accept(port_index: usize) -> isize {
-    println!("accepting port {}", port_index);
-
-    let task = current_task().unwrap();
-    accept(port_index, task);
-    // block_current_and_run_next();
-
-    // NOTICE: There does not have interrupt handler, just call it munually.
-    loop {
-        net_interrupt_handler();
-
-        if !port_acceptable(port_index) {
-            break;
-        }
-    }
-
-    let cx = current_trap_cx();
-    cx.x[10] as isize
-}

os/src/syscall/process.rs

@@ -1,16 +1,19 @@
-use crate::fs::{open_file, OpenFlags};
-use crate::mm::{translated_ref, translated_refmut, translated_str};
 use crate::task::{
-    current_process, current_task, current_user_token, exit_current_and_run_next, pid2process,
+    suspend_current_and_run_next,
-    suspend_current_and_run_next, SignalFlags,
+    exit_current_and_run_next,
 };
-use crate::timer::get_time_ms;
+use crate::timer::get_time_us;
-use alloc::string::String;
+
-use alloc::sync::Arc;
+#[repr(C)]
-use alloc::vec::Vec;
+#[derive(Debug)]
+pub struct TimeVal {
+    pub sec: usize,
+    pub usec: usize,
+}
 
 pub fn sys_exit(exit_code: i32) -> ! {
-    exit_current_and_run_next(exit_code);
+    println!("[kernel] Application exited with code {}", exit_code);
+    exit_current_and_run_next();
     panic!("Unreachable in sys_exit!");
 }
 
@@ -19,99 +22,17 @@ pub fn sys_yield() -> isize {
     0
 }
 
-pub fn sys_get_time() -> isize {
+// pub fn sys_get_time() -> isize {
-    get_time_ms() as isize
+//     get_time_ms() as isize
-}
+// }
 
-pub fn sys_getpid() -> isize {
+pub fn sys_get_time(ts: *mut TimeVal, _tz: usize) -> isize {
-    current_task().unwrap().process.upgrade().unwrap().getpid() as isize
+    let us = get_time_us();
-}
+    unsafe {
-
+        *ts = TimeVal {
-pub fn sys_fork() -> isize {
+            sec: us / 1_000_000,
-    let current_process = current_process();
+            usec: us % 1_000_000,
-    let new_process = current_process.fork();
+        };
-    let new_pid = new_process.getpid();
-    // modify trap context of new_task, because it returns immediately after switching
-    let new_process_inner = new_process.inner_exclusive_access();
-    let task = new_process_inner.tasks[0].as_ref().unwrap();
-    let trap_cx = task.inner_exclusive_access().get_trap_cx();
-    // we do not have to move to next instruction since we have done it before
-    // for child process, fork returns 0
-    trap_cx.x[10] = 0;
-    new_pid as isize
-}
-
-pub fn sys_exec(path: *const u8, mut args: *const usize) -> isize {
-    let token = current_user_token();
-    let path = translated_str(token, path);
-    let mut args_vec: Vec<String> = Vec::new();
-    loop {
-        let arg_str_ptr = *translated_ref(token, args);
-        if arg_str_ptr == 0 {
-            break;
-        }
-        args_vec.push(translated_str(token, arg_str_ptr as *const u8));
-        unsafe {
-            args = args.add(1);
-        }
     }
-    if let Some(app_inode) = open_file(path.as_str(), OpenFlags::RDONLY) {
+    0
-        let all_data = app_inode.read_all();
+}
-        let process = current_process();
-        let argc = args_vec.len();
-        process.exec(all_data.as_slice(), args_vec);
-        // return argc because cx.x[10] will be covered with it later
-        argc as isize
-    } else {
-        -1
-    }
-}
-
-/// If there is not a child process whose pid is same as given, return -1.
-/// Else if there is a child process but it is still running, return -2.
-pub fn sys_waitpid(pid: isize, exit_code_ptr: *mut i32) -> isize {
-    let process = current_process();
-    // find a child process
-
-    let mut inner = process.inner_exclusive_access();
-    if !inner
-        .children
-        .iter()
-        .any(|p| pid == -1 || pid as usize == p.getpid())
-    {
-        return -1;
-        // ---- release current PCB
-    }
-    let pair = inner.children.iter().enumerate().find(|(_, p)| {
-        // ++++ temporarily access child PCB exclusively
-        p.inner_exclusive_access().is_zombie && (pid == -1 || pid as usize == p.getpid())
-        // ++++ release child PCB
-    });
-    if let Some((idx, _)) = pair {
-        let child = inner.children.remove(idx);
-        // confirm that child will be deallocated after being removed from children list
-        assert_eq!(Arc::strong_count(&child), 1);
-        let found_pid = child.getpid();
-        // ++++ temporarily access child PCB exclusively
-        let exit_code = child.inner_exclusive_access().exit_code;
-        // ++++ release child PCB
-        *translated_refmut(inner.memory_set.token(), exit_code_ptr) = exit_code;
-        found_pid as isize
-    } else {
-        -2
-    }
-    // ---- release current PCB automatically
-}
-
-pub fn sys_kill(pid: usize, signal: u32) -> isize {
-    if let Some(process) = pid2process(pid) {
-        if let Some(flag) = SignalFlags::from_bits(signal) {
-            process.inner_exclusive_access().signals |= flag;
-            0
-        } else {
-            -1
-        }
-    } else {
-        -1
-    }
-}

os/src/syscall/sync.rs

@@ -1,134 +0,0 @@
-use crate::sync::{Condvar, Mutex, MutexBlocking, MutexSpin, Semaphore};
-use crate::task::{block_current_and_run_next, current_process, current_task};
-use crate::timer::{add_timer, get_time_ms};
-use alloc::sync::Arc;
-
-pub fn sys_sleep(ms: usize) -> isize {
-    let expire_ms = get_time_ms() + ms;
-    let task = current_task().unwrap();
-    add_timer(expire_ms, task);
-    block_current_and_run_next();
-    0
-}
-
-pub fn sys_mutex_create(blocking: bool) -> isize {
-    let process = current_process();
-    let mutex: Option<Arc<dyn Mutex>> = if !blocking {
-        Some(Arc::new(MutexSpin::new()))
-    } else {
-        Some(Arc::new(MutexBlocking::new()))
-    };
-    let mut process_inner = process.inner_exclusive_access();
-    if let Some(id) = process_inner
-        .mutex_list
-        .iter()
-        .enumerate()
-        .find(|(_, item)| item.is_none())
-        .map(|(id, _)| id)
-    {
-        process_inner.mutex_list[id] = mutex;
-        id as isize
-    } else {
-        process_inner.mutex_list.push(mutex);
-        process_inner.mutex_list.len() as isize - 1
-    }
-}
-
-pub fn sys_mutex_lock(mutex_id: usize) -> isize {
-    let process = current_process();
-    let process_inner = process.inner_exclusive_access();
-    let mutex = Arc::clone(process_inner.mutex_list[mutex_id].as_ref().unwrap());
-    drop(process_inner);
-    drop(process);
-    mutex.lock();
-    0
-}
-
-pub fn sys_mutex_unlock(mutex_id: usize) -> isize {
-    let process = current_process();
-    let process_inner = process.inner_exclusive_access();
-    let mutex = Arc::clone(process_inner.mutex_list[mutex_id].as_ref().unwrap());
-    drop(process_inner);
-    drop(process);
-    mutex.unlock();
-    0
-}
-
-pub fn sys_semaphore_create(res_count: usize) -> isize {
-    let process = current_process();
-    let mut process_inner = process.inner_exclusive_access();
-    let id = if let Some(id) = process_inner
-        .semaphore_list
-        .iter()
-        .enumerate()
-        .find(|(_, item)| item.is_none())
-        .map(|(id, _)| id)
-    {
-        process_inner.semaphore_list[id] = Some(Arc::new(Semaphore::new(res_count)));
-        id
-    } else {
-        process_inner
-            .semaphore_list
-            .push(Some(Arc::new(Semaphore::new(res_count))));
-        process_inner.semaphore_list.len() - 1
-    };
-    id as isize
-}
-
-pub fn sys_semaphore_up(sem_id: usize) -> isize {
-    let process = current_process();
-    let process_inner = process.inner_exclusive_access();
-    let sem = Arc::clone(process_inner.semaphore_list[sem_id].as_ref().unwrap());
-    drop(process_inner);
-    sem.up();
-    0
-}
-
-pub fn sys_semaphore_down(sem_id: usize) -> isize {
-    let process = current_process();
-    let process_inner = process.inner_exclusive_access();
-    let sem = Arc::clone(process_inner.semaphore_list[sem_id].as_ref().unwrap());
-    drop(process_inner);
-    sem.down();
-    0
-}
-
-pub fn sys_condvar_create() -> isize {
-    let process = current_process();
-    let mut process_inner = process.inner_exclusive_access();
-    let id = if let Some(id) = process_inner
-        .condvar_list
-        .iter()
-        .enumerate()
-        .find(|(_, item)| item.is_none())
-        .map(|(id, _)| id)
-    {
-        process_inner.condvar_list[id] = Some(Arc::new(Condvar::new()));
-        id
-    } else {
-        process_inner
-            .condvar_list
-            .push(Some(Arc::new(Condvar::new())));
-        process_inner.condvar_list.len() - 1
-    };
-    id as isize
-}
-
-pub fn sys_condvar_signal(condvar_id: usize) -> isize {
-    let process = current_process();
-    let process_inner = process.inner_exclusive_access();
-    let condvar = Arc::clone(process_inner.condvar_list[condvar_id].as_ref().unwrap());
-    drop(process_inner);
-    condvar.signal();
-    0
-}
-
-pub fn sys_condvar_wait(condvar_id: usize, mutex_id: usize) -> isize {
-    let process = current_process();
-    let process_inner = process.inner_exclusive_access();
-    let condvar = Arc::clone(process_inner.condvar_list[condvar_id].as_ref().unwrap());
-    let mutex = Arc::clone(process_inner.mutex_list[mutex_id].as_ref().unwrap());
-    drop(process_inner);
-    condvar.wait_with_mutex(mutex);
-    0
-}

os/src/syscall/thread.rs

@@ -1,85 +0,0 @@
-use crate::{
-    mm::kernel_token,
-    task::{add_task, current_task, TaskControlBlock},
-    trap::{trap_handler, TrapContext},
-};
-use alloc::sync::Arc;
-
-pub fn sys_thread_create(entry: usize, arg: usize) -> isize {
-    let task = current_task().unwrap();
-    let process = task.process.upgrade().unwrap();
-    // create a new thread
-    let new_task = Arc::new(TaskControlBlock::new(
-        Arc::clone(&process),
-        task.inner_exclusive_access()
-            .res
-            .as_ref()
-            .unwrap()
-            .ustack_base,
-        true,
-    ));
-    // add new task to scheduler
-    add_task(Arc::clone(&new_task));
-    let new_task_inner = new_task.inner_exclusive_access();
-    let new_task_res = new_task_inner.res.as_ref().unwrap();
-    let new_task_tid = new_task_res.tid;
-    let mut process_inner = process.inner_exclusive_access();
-    // add new thread to current process
-    let tasks = &mut process_inner.tasks;
-    while tasks.len() < new_task_tid + 1 {
-        tasks.push(None);
-    }
-    tasks[new_task_tid] = Some(Arc::clone(&new_task));
-    let new_task_trap_cx = new_task_inner.get_trap_cx();
-    *new_task_trap_cx = TrapContext::app_init_context(
-        entry,
-        new_task_res.ustack_top(),
-        kernel_token(),
-        new_task.kstack.get_top(),
-        trap_handler as usize,
-    );
-    (*new_task_trap_cx).x[10] = arg;
-    new_task_tid as isize
-}
-
-pub fn sys_gettid() -> isize {
-    current_task()
-        .unwrap()
-        .inner_exclusive_access()
-        .res
-        .as_ref()
-        .unwrap()
-        .tid as isize
-}
-
-/// thread does not exist, return -1
-/// thread has not exited yet, return -2
-/// otherwise, return thread's exit code
-pub fn sys_waittid(tid: usize) -> i32 {
-    let task = current_task().unwrap();
-    let process = task.process.upgrade().unwrap();
-    let task_inner = task.inner_exclusive_access();
-    let mut process_inner = process.inner_exclusive_access();
-    // a thread cannot wait for itself
-    if task_inner.res.as_ref().unwrap().tid == tid {
-        return -1;
-    }
-    let mut exit_code: Option<i32> = None;
-    let waited_task = process_inner.tasks[tid].as_ref();
-    if let Some(waited_task) = waited_task {
-        if let Some(waited_exit_code) = waited_task.inner_exclusive_access().exit_code {
-            exit_code = Some(waited_exit_code);
-        }
-    } else {
-        // waited thread does not exist
-        return -1;
-    }
-    if let Some(exit_code) = exit_code {
-        // dealloc the exited thread
-        process_inner.tasks[tid] = None;
-        exit_code
-    } else {
-        // waited thread has not exited
-        -2
-    }
-}

os/src/task/context.rs

@@ -1,5 +1,4 @@
-use crate::trap::trap_return;
+#[derive(Copy, Clone)]
-
 #[repr(C)]
 pub struct TaskContext {
     ra: usize,
@@ -15,11 +14,13 @@ impl TaskContext {
             s: [0; 12],
         }
     }
-    pub fn goto_trap_return(kstack_ptr: usize) -> Self {
+    pub fn goto_restore(kstack_ptr: usize) -> Self {
+        extern "C" { fn __restore(); }
         Self {
-            ra: trap_return as usize,
+            ra: __restore as usize,
             sp: kstack_ptr,
             s: [0; 12],
         }
     }
 }
+

os/src/task/id.rs

@@ -1,226 +0,0 @@
-use super::ProcessControlBlock;
-use crate::config::{KERNEL_STACK_SIZE, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT_BASE, USER_STACK_SIZE};
-use crate::mm::{MapPermission, PhysPageNum, VirtAddr, KERNEL_SPACE};
-use crate::sync::UPIntrFreeCell;
-use alloc::{
-    sync::{Arc, Weak},
-    vec::Vec,
-};
-use lazy_static::*;
-
-pub struct RecycleAllocator {
-    current: usize,
-    recycled: Vec<usize>,
-}
-
-impl RecycleAllocator {
-    pub fn new() -> Self {
-        RecycleAllocator {
-            current: 0,
-            recycled: Vec::new(),
-        }
-    }
-    pub fn alloc(&mut self) -> usize {
-        if let Some(id) = self.recycled.pop() {
-            id
-        } else {
-            self.current += 1;
-            self.current - 1
-        }
-    }
-    pub fn dealloc(&mut self, id: usize) {
-        assert!(id < self.current);
-        assert!(
-            !self.recycled.iter().any(|i| *i == id),
-            "id {} has been deallocated!",
-            id
-        );
-        self.recycled.push(id);
-    }
-}
-
-lazy_static! {
-    static ref PID_ALLOCATOR: UPIntrFreeCell<RecycleAllocator> =
-        unsafe { UPIntrFreeCell::new(RecycleAllocator::new()) };
-    static ref KSTACK_ALLOCATOR: UPIntrFreeCell<RecycleAllocator> =
-        unsafe { UPIntrFreeCell::new(RecycleAllocator::new()) };
-}
-
-pub const IDLE_PID: usize = 0;
-
-pub struct PidHandle(pub usize);
-
-pub fn pid_alloc() -> PidHandle {
-    PidHandle(PID_ALLOCATOR.exclusive_access().alloc())
-}
-
-impl Drop for PidHandle {
-    fn drop(&mut self) {
-        PID_ALLOCATOR.exclusive_access().dealloc(self.0);
-    }
-}
-
-/// Return (bottom, top) of a kernel stack in kernel space.
-pub fn kernel_stack_position(kstack_id: usize) -> (usize, usize) {
-    let top = TRAMPOLINE - kstack_id * (KERNEL_STACK_SIZE + PAGE_SIZE);
-    let bottom = top - KERNEL_STACK_SIZE;
-    (bottom, top)
-}
-
-pub struct KernelStack(pub usize);
-
-pub fn kstack_alloc() -> KernelStack {
-    let kstack_id = KSTACK_ALLOCATOR.exclusive_access().alloc();
-    let (kstack_bottom, kstack_top) = kernel_stack_position(kstack_id);
-    KERNEL_SPACE.exclusive_access().insert_framed_area(
-        kstack_bottom.into(),
-        kstack_top.into(),
-        MapPermission::R | MapPermission::W,
-    );
-    KernelStack(kstack_id)
-}
-
-impl Drop for KernelStack {
-    fn drop(&mut self) {
-        let (kernel_stack_bottom, _) = kernel_stack_position(self.0);
-        let kernel_stack_bottom_va: VirtAddr = kernel_stack_bottom.into();
-        KERNEL_SPACE
-            .exclusive_access()
-            .remove_area_with_start_vpn(kernel_stack_bottom_va.into());
-        KSTACK_ALLOCATOR.exclusive_access().dealloc(self.0);
-    }
-}
-
-impl KernelStack {
-    #[allow(unused)]
-    pub fn push_on_top<T>(&self, value: T) -> *mut T
-    where
-        T: Sized,
-    {
-        let kernel_stack_top = self.get_top();
-        let ptr_mut = (kernel_stack_top - core::mem::size_of::<T>()) as *mut T;
-        unsafe {
-            *ptr_mut = value;
-        }
-        ptr_mut
-    }
-    pub fn get_top(&self) -> usize {
-        let (_, kernel_stack_top) = kernel_stack_position(self.0);
-        kernel_stack_top
-    }
-}
-
-pub struct TaskUserRes {
-    pub tid: usize,
-    pub ustack_base: usize,
-    pub process: Weak<ProcessControlBlock>,
-}
-
-fn trap_cx_bottom_from_tid(tid: usize) -> usize {
-    TRAP_CONTEXT_BASE - tid * PAGE_SIZE
-}
-
-fn ustack_bottom_from_tid(ustack_base: usize, tid: usize) -> usize {
-    ustack_base + tid * (PAGE_SIZE + USER_STACK_SIZE)
-}
-
-impl TaskUserRes {
-    pub fn new(
-        process: Arc<ProcessControlBlock>,
-        ustack_base: usize,
-        alloc_user_res: bool,
-    ) -> Self {
-        let tid = process.inner_exclusive_access().alloc_tid();
-        let task_user_res = Self {
-            tid,
-            ustack_base,
-            process: Arc::downgrade(&process),
-        };
-        if alloc_user_res {
-            task_user_res.alloc_user_res();
-        }
-        task_user_res
-    }
-
-    pub fn alloc_user_res(&self) {
-        let process = self.process.upgrade().unwrap();
-        let mut process_inner = process.inner_exclusive_access();
-        // alloc user stack
-        let ustack_bottom = ustack_bottom_from_tid(self.ustack_base, self.tid);
-        let ustack_top = ustack_bottom + USER_STACK_SIZE;
-        process_inner.memory_set.insert_framed_area(
-            ustack_bottom.into(),
-            ustack_top.into(),
-            MapPermission::R | MapPermission::W | MapPermission::U,
-        );
-        // alloc trap_cx
-        let trap_cx_bottom = trap_cx_bottom_from_tid(self.tid);
-        let trap_cx_top = trap_cx_bottom + PAGE_SIZE;
-        process_inner.memory_set.insert_framed_area(
-            trap_cx_bottom.into(),
-            trap_cx_top.into(),
-            MapPermission::R | MapPermission::W,
-        );
-    }
-
-    fn dealloc_user_res(&self) {
-        // dealloc tid
-        let process = self.process.upgrade().unwrap();
-        let mut process_inner = process.inner_exclusive_access();
-        // dealloc ustack manually
-        let ustack_bottom_va: VirtAddr = ustack_bottom_from_tid(self.ustack_base, self.tid).into();
-        process_inner
-            .memory_set
-            .remove_area_with_start_vpn(ustack_bottom_va.into());
-        // dealloc trap_cx manually
-        let trap_cx_bottom_va: VirtAddr = trap_cx_bottom_from_tid(self.tid).into();
-        process_inner
-            .memory_set
-            .remove_area_with_start_vpn(trap_cx_bottom_va.into());
-    }
-
-    #[allow(unused)]
-    pub fn alloc_tid(&mut self) {
-        self.tid = self
-            .process
-            .upgrade()
-            .unwrap()
-            .inner_exclusive_access()
-            .alloc_tid();
-    }
-
-    pub fn dealloc_tid(&self) {
-        let process = self.process.upgrade().unwrap();
-        let mut process_inner = process.inner_exclusive_access();
-        process_inner.dealloc_tid(self.tid);
-    }
-
-    pub fn trap_cx_user_va(&self) -> usize {
-        trap_cx_bottom_from_tid(self.tid)
-    }
-
-    pub fn trap_cx_ppn(&self) -> PhysPageNum {
-        let process = self.process.upgrade().unwrap();
-        let process_inner = process.inner_exclusive_access();
-        let trap_cx_bottom_va: VirtAddr = trap_cx_bottom_from_tid(self.tid).into();
-        process_inner
-            .memory_set
-            .translate(trap_cx_bottom_va.into())
-            .unwrap()
-            .ppn()
-    }
-
-    pub fn ustack_base(&self) -> usize {
-        self.ustack_base
-    }
-    pub fn ustack_top(&self) -> usize {
-        ustack_bottom_from_tid(self.ustack_base, self.tid) + USER_STACK_SIZE
-    }
-}
-
-impl Drop for TaskUserRes {
-    fn drop(&mut self) {
-        self.dealloc_tid();
-        self.dealloc_user_res();
-    }
-}

os/src/task/manager.rs

@@ -1,62 +0,0 @@
-use super::{ProcessControlBlock, TaskControlBlock, TaskStatus};
-use crate::sync::UPIntrFreeCell;
-use alloc::collections::{BTreeMap, VecDeque};
-use alloc::sync::Arc;
-use lazy_static::*;
-
-pub struct TaskManager {
-    ready_queue: VecDeque<Arc<TaskControlBlock>>,
-}
-
-/// A simple FIFO scheduler.
-impl TaskManager {
-    pub fn new() -> Self {
-        Self {
-            ready_queue: VecDeque::new(),
-        }
-    }
-    pub fn add(&mut self, task: Arc<TaskControlBlock>) {
-        self.ready_queue.push_back(task);
-    }
-    pub fn fetch(&mut self) -> Option<Arc<TaskControlBlock>> {
-        self.ready_queue.pop_front()
-    }
-}
-
-lazy_static! {
-    pub static ref TASK_MANAGER: UPIntrFreeCell<TaskManager> =
-        unsafe { UPIntrFreeCell::new(TaskManager::new()) };
-    pub static ref PID2PCB: UPIntrFreeCell<BTreeMap<usize, Arc<ProcessControlBlock>>> =
-        unsafe { UPIntrFreeCell::new(BTreeMap::new()) };
-}
-
-pub fn add_task(task: Arc<TaskControlBlock>) {
-    TASK_MANAGER.exclusive_access().add(task);
-}
-
-pub fn wakeup_task(task: Arc<TaskControlBlock>) {
-    let mut task_inner = task.inner_exclusive_access();
-    task_inner.task_status = TaskStatus::Ready;
-    drop(task_inner);
-    add_task(task);
-}
-
-pub fn fetch_task() -> Option<Arc<TaskControlBlock>> {
-    TASK_MANAGER.exclusive_access().fetch()
-}
-
-pub fn pid2process(pid: usize) -> Option<Arc<ProcessControlBlock>> {
-    let map = PID2PCB.exclusive_access();
-    map.get(&pid).map(Arc::clone)
-}
-
-pub fn insert_into_pid2process(pid: usize, process: Arc<ProcessControlBlock>) {
-    PID2PCB.exclusive_access().insert(pid, process);
-}
-
-pub fn remove_from_pid2process(pid: usize) {
-    let mut map = PID2PCB.exclusive_access();
-    if map.remove(&pid).is_none() {
-        panic!("cannot find pid {} in pid2task!", pid);
-    }
-}

os/src/task/mod.rs

@@ -1,166 +1,135 @@
 mod context;
-mod id;
-mod manager;
-mod process;
-mod processor;
-mod signal;
 mod switch;
-#[allow(clippy::module_inception)]
 mod task;
 
-use self::id::TaskUserRes;
+use crate::config::MAX_APP_NUM;
-use crate::fs::{open_file, OpenFlags};
+use crate::loader::{get_num_app, init_app_cx};
-use crate::sbi::shutdown;
-use alloc::{sync::Arc, vec::Vec};
 use lazy_static::*;
-use manager::fetch_task;
-use process::ProcessControlBlock;
 use switch::__switch;
+use task::{TaskControlBlock, TaskStatus};
+use crate::sync::UPSafeCell;
 
 pub use context::TaskContext;
-pub use id::{kstack_alloc, pid_alloc, KernelStack, PidHandle, IDLE_PID};
-pub use manager::{add_task, pid2process, remove_from_pid2process, wakeup_task};
-pub use processor::{
-    current_kstack_top, current_process, current_task, current_trap_cx, current_trap_cx_user_va,
-    current_user_token, run_tasks, schedule, take_current_task,
-};
-pub use signal::SignalFlags;
-pub use task::{TaskControlBlock, TaskStatus};
 
-pub fn suspend_current_and_run_next() {
+pub struct TaskManager {
-    // There must be an application running.
+    num_app: usize,
-    let task = take_current_task().unwrap();
+    inner: UPSafeCell<TaskManagerInner>,
-
-    // ---- access current TCB exclusively
-    let mut task_inner = task.inner_exclusive_access();
-    let task_cx_ptr = &mut task_inner.task_cx as *mut TaskContext;
-    // Change status to Ready
-    task_inner.task_status = TaskStatus::Ready;
-    drop(task_inner);
-    // ---- release current TCB
-
-    // push back to ready queue.
-    add_task(task);
-    // jump to scheduling cycle
-    schedule(task_cx_ptr);
 }
 
-/// This function must be followed by a schedule
+struct TaskManagerInner {
-pub fn block_current_task() -> *mut TaskContext {
+    tasks: [TaskControlBlock; MAX_APP_NUM],
-    let task = take_current_task().unwrap();
+    current_task: usize,
-    let mut task_inner = task.inner_exclusive_access();
-    task_inner.task_status = TaskStatus::Blocked;
-    &mut task_inner.task_cx as *mut TaskContext
-}
-
-pub fn block_current_and_run_next() {
-    let task_cx_ptr = block_current_task();
-    schedule(task_cx_ptr);
-}
-
-/// Exit the current 'Running' task and run the next task in task list.
-pub fn exit_current_and_run_next(exit_code: i32) {
-    let task = take_current_task().unwrap();
-    let mut task_inner = task.inner_exclusive_access();
-    let process = task.process.upgrade().unwrap();
-    let tid = task_inner.res.as_ref().unwrap().tid;
-    // record exit code
-    task_inner.exit_code = Some(exit_code);
-    task_inner.res = None;
-    // here we do not remove the thread since we are still using the kstack
-    // it will be deallocated when sys_waittid is called
-    drop(task_inner);
-    drop(task);
-    // however, if this is the main thread of current process
-    // the process should terminate at once
-    if tid == 0 {
-        let pid = process.getpid();
-        if pid == IDLE_PID {
-            println!(
-                "[kernel] Idle process exit with exit_code {} ...",
-                exit_code
-            );
-            if exit_code != 0 {
-                //crate::sbi::shutdown(255); //255 == -1 for err hint
-                shutdown(true);
-            } else {
-                //crate::sbi::shutdown(0); //0 for success hint
-                shutdown(false);
-            }
-        }
-        remove_from_pid2process(pid);
-        let mut process_inner = process.inner_exclusive_access();
-        // mark this process as a zombie process
-        process_inner.is_zombie = true;
-        // record exit code of main process
-        process_inner.exit_code = exit_code;
-
-        {
-            // move all child processes under init process
-            let mut initproc_inner = INITPROC.inner_exclusive_access();
-            for child in process_inner.children.iter() {
-                child.inner_exclusive_access().parent = Some(Arc::downgrade(&INITPROC));
-                initproc_inner.children.push(child.clone());
-            }
-        }
-
-        // deallocate user res (including tid/trap_cx/ustack) of all threads
-        // it has to be done before we dealloc the whole memory_set
-        // otherwise they will be deallocated twice
-        let mut recycle_res = Vec::<TaskUserRes>::new();
-        for task in process_inner.tasks.iter().filter(|t| t.is_some()) {
-            let task = task.as_ref().unwrap();
-            let mut task_inner = task.inner_exclusive_access();
-            if let Some(res) = task_inner.res.take() {
-                recycle_res.push(res);
-            }
-        }
-        // dealloc_tid and dealloc_user_res require access to PCB inner, so we
-        // need to collect those user res first, then release process_inner
-        // for now to avoid deadlock/double borrow problem.
-        drop(process_inner);
-        recycle_res.clear();
-
-        let mut process_inner = process.inner_exclusive_access();
-        process_inner.children.clear();
-        // deallocate other data in user space i.e. program code/data section
-        process_inner.memory_set.recycle_data_pages();
-        // drop file descriptors
-        process_inner.fd_table.clear();
-        // Remove all tasks except for the main thread itself.
-        // This is because we are still using the kstack under the TCB
-        // of the main thread. This TCB, including its kstack, will be
-        // deallocated when the process is reaped via waitpid.
-        while process_inner.tasks.len() > 1 {
-            process_inner.tasks.pop();
-        }
-    }
-    drop(process);
-    // we do not have to save task context
-    let mut _unused = TaskContext::zero_init();
-    schedule(&mut _unused as *mut _);
 }
 
 lazy_static! {
-    pub static ref INITPROC: Arc<ProcessControlBlock> = {
+    pub static ref TASK_MANAGER: TaskManager = {
-        let inode = open_file("initproc", OpenFlags::RDONLY).unwrap();
+        let num_app = get_num_app();
-        let v = inode.read_all();
+        let mut tasks = [
-        ProcessControlBlock::new(v.as_slice())
+            TaskControlBlock {
+                task_cx: TaskContext::zero_init(),
+                task_status: TaskStatus::UnInit
+            };
+            MAX_APP_NUM
+        ];
+        for i in 0..num_app {
+            tasks[i].task_cx = TaskContext::goto_restore(init_app_cx(i));
+            tasks[i].task_status = TaskStatus::Ready;
+        }
+        TaskManager {
+            num_app,
+            inner: unsafe { UPSafeCell::new(TaskManagerInner {
+                tasks,
+                current_task: 0,
+            })},
+        }
     };
 }
 
-pub fn add_initproc() {
+impl TaskManager {
-    let _initproc = INITPROC.clone();
+    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(
+                &mut _unused as *mut TaskContext,
+                next_task_cx_ptr,
+            );
+        }
+        panic!("unreachable in run_first_task!");
+    }
+
+    fn mark_current_suspended(&self) {
+        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.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.exclusive_access();
+        let current = inner.current_task;
+        (current + 1..current + self.num_app + 1)
+            .map(|id| id % self.num_app)
+            .find(|id| {
+                inner.tasks[*id].task_status == TaskStatus::Ready
+            })
+    }
+
+    fn run_next_task(&self) {
+        if let Some(next) = self.find_next_task() {
+            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_ptr = &mut inner.tasks[current].task_cx as *mut TaskContext;
+            let next_task_cx_ptr = &inner.tasks[next].task_cx as *const TaskContext;
+            drop(inner);
+            // before this, we should drop local variables that must be dropped manually
+            unsafe {
+                __switch(
+                    current_task_cx_ptr,
+                    next_task_cx_ptr,
+                );
+            }
+            // go back to user mode
+        } else {
+            panic!("All applications completed!");
+        }
+    }
 }
 
-pub fn check_signals_of_current() -> Option<(i32, &'static str)> {
+pub fn run_first_task() {
-    let process = current_process();
+    TASK_MANAGER.run_first_task();
-    let process_inner = process.inner_exclusive_access();
-    process_inner.signals.check_error()
 }
 
-pub fn current_add_signal(signal: SignalFlags) {
+fn run_next_task() {
-    let process = current_process();
+    TASK_MANAGER.run_next_task();
-    let mut process_inner = process.inner_exclusive_access();
-    process_inner.signals |= signal;
 }
+
+fn mark_current_suspended() {
+    TASK_MANAGER.mark_current_suspended();
+}
+
+fn mark_current_exited() {
+    TASK_MANAGER.mark_current_exited();
+}
+
+pub fn suspend_current_and_run_next() {
+    mark_current_suspended();
+    run_next_task();
+}
+
+pub fn exit_current_and_run_next() {
+    mark_current_exited();
+    run_next_task();
+}

os/src/task/process.rs

@@ -1,258 +0,0 @@
-use super::id::RecycleAllocator;
-use super::manager::insert_into_pid2process;
-use super::TaskControlBlock;
-use super::{add_task, SignalFlags};
-use super::{pid_alloc, PidHandle};
-use crate::fs::{File, Stdin, Stdout};
-use crate::mm::{translated_refmut, MemorySet, KERNEL_SPACE};
-use crate::sync::{Condvar, Mutex, Semaphore, UPIntrFreeCell, UPIntrRefMut};
-use crate::trap::{trap_handler, TrapContext};
-use alloc::string::String;
-use alloc::sync::{Arc, Weak};
-use alloc::vec;
-use alloc::vec::Vec;
-
-pub struct ProcessControlBlock {
-    // immutable
-    pub pid: PidHandle,
-    // mutable
-    inner: UPIntrFreeCell<ProcessControlBlockInner>,
-}
-
-pub struct ProcessControlBlockInner {
-    pub is_zombie: bool,
-    pub memory_set: MemorySet,
-    pub parent: Option<Weak<ProcessControlBlock>>,
-    pub children: Vec<Arc<ProcessControlBlock>>,
-    pub exit_code: i32,
-    pub fd_table: Vec<Option<Arc<dyn File + Send + Sync>>>,
-    pub signals: SignalFlags,
-    pub tasks: Vec<Option<Arc<TaskControlBlock>>>,
-    pub task_res_allocator: RecycleAllocator,
-    pub mutex_list: Vec<Option<Arc<dyn Mutex>>>,
-    pub semaphore_list: Vec<Option<Arc<Semaphore>>>,
-    pub condvar_list: Vec<Option<Arc<Condvar>>>,
-}
-
-impl ProcessControlBlockInner {
-    #[allow(unused)]
-    pub fn get_user_token(&self) -> usize {
-        self.memory_set.token()
-    }
-
-    pub fn alloc_fd(&mut self) -> usize {
-        if let Some(fd) = (0..self.fd_table.len()).find(|fd| self.fd_table[*fd].is_none()) {
-            fd
-        } else {
-            self.fd_table.push(None);
-            self.fd_table.len() - 1
-        }
-    }
-
-    pub fn alloc_tid(&mut self) -> usize {
-        self.task_res_allocator.alloc()
-    }
-
-    pub fn dealloc_tid(&mut self, tid: usize) {
-        self.task_res_allocator.dealloc(tid)
-    }
-
-    pub fn thread_count(&self) -> usize {
-        self.tasks.len()
-    }
-
-    pub fn get_task(&self, tid: usize) -> Arc<TaskControlBlock> {
-        self.tasks[tid].as_ref().unwrap().clone()
-    }
-}
-
-impl ProcessControlBlock {
-    pub fn inner_exclusive_access(&self) -> UPIntrRefMut<'_, ProcessControlBlockInner> {
-        self.inner.exclusive_access()
-    }
-
-    pub fn new(elf_data: &[u8]) -> Arc<Self> {
-        // memory_set with elf program headers/trampoline/trap context/user stack
-        let (memory_set, ustack_base, entry_point) = MemorySet::from_elf(elf_data);
-        // allocate a pid
-        let pid_handle = pid_alloc();
-        let process = Arc::new(Self {
-            pid: pid_handle,
-            inner: unsafe {
-                UPIntrFreeCell::new(ProcessControlBlockInner {
-                    is_zombie: false,
-                    memory_set,
-                    parent: None,
-                    children: Vec::new(),
-                    exit_code: 0,
-                    fd_table: vec![
-                        // 0 -> stdin
-                        Some(Arc::new(Stdin)),
-                        // 1 -> stdout
-                        Some(Arc::new(Stdout)),
-                        // 2 -> stderr
-                        Some(Arc::new(Stdout)),
-                    ],
-                    signals: SignalFlags::empty(),
-                    tasks: Vec::new(),
-                    task_res_allocator: RecycleAllocator::new(),
-                    mutex_list: Vec::new(),
-                    semaphore_list: Vec::new(),
-                    condvar_list: Vec::new(),
-                })
-            },
-        });
-        // create a main thread, we should allocate ustack and trap_cx here
-        let task = Arc::new(TaskControlBlock::new(
-            Arc::clone(&process),
-            ustack_base,
-            true,
-        ));
-        // prepare trap_cx of main thread
-        let task_inner = task.inner_exclusive_access();
-        let trap_cx = task_inner.get_trap_cx();
-        let ustack_top = task_inner.res.as_ref().unwrap().ustack_top();
-        let kstack_top = task.kstack.get_top();
-        drop(task_inner);
-        *trap_cx = TrapContext::app_init_context(
-            entry_point,
-            ustack_top,
-            KERNEL_SPACE.exclusive_access().token(),
-            kstack_top,
-            trap_handler as usize,
-        );
-        // add main thread to the process
-        let mut process_inner = process.inner_exclusive_access();
-        process_inner.tasks.push(Some(Arc::clone(&task)));
-        drop(process_inner);
-        insert_into_pid2process(process.getpid(), Arc::clone(&process));
-        // add main thread to scheduler
-        add_task(task);
-        process
-    }
-
-    /// Only support processes with a single thread.
-    pub fn exec(self: &Arc<Self>, elf_data: &[u8], args: Vec<String>) {
-        assert_eq!(self.inner_exclusive_access().thread_count(), 1);
-        // memory_set with elf program headers/trampoline/trap context/user stack
-        let (memory_set, ustack_base, entry_point) = MemorySet::from_elf(elf_data);
-        let new_token = memory_set.token();
-        // substitute memory_set
-        self.inner_exclusive_access().memory_set = memory_set;
-        // then we alloc user resource for main thread again
-        // since memory_set has been changed
-        let task = self.inner_exclusive_access().get_task(0);
-        let mut task_inner = task.inner_exclusive_access();
-        task_inner.res.as_mut().unwrap().ustack_base = ustack_base;
-        task_inner.res.as_mut().unwrap().alloc_user_res();
-        task_inner.trap_cx_ppn = task_inner.res.as_mut().unwrap().trap_cx_ppn();
-        // push arguments on user stack
-        let mut user_sp = task_inner.res.as_mut().unwrap().ustack_top();
-        user_sp -= (args.len() + 1) * core::mem::size_of::<usize>();
-        let argv_base = user_sp;
-        let mut argv: Vec<_> = (0..=args.len())
-            .map(|arg| {
-                translated_refmut(
-                    new_token,
-                    (argv_base + arg * core::mem::size_of::<usize>()) as *mut usize,
-                )
-            })
-            .collect();
-        *argv[args.len()] = 0;
-        for i in 0..args.len() {
-            user_sp -= args[i].len() + 1;
-            *argv[i] = user_sp;
-            let mut p = user_sp;
-            for c in args[i].as_bytes() {
-                *translated_refmut(new_token, p as *mut u8) = *c;
-                p += 1;
-            }
-            *translated_refmut(new_token, p as *mut u8) = 0;
-        }
-        // make the user_sp aligned to 8B for k210 platform
-        user_sp -= user_sp % core::mem::size_of::<usize>();
-        // initialize trap_cx
-        let mut trap_cx = TrapContext::app_init_context(
-            entry_point,
-            user_sp,
-            KERNEL_SPACE.exclusive_access().token(),
-            task.kstack.get_top(),
-            trap_handler as usize,
-        );
-        trap_cx.x[10] = args.len();
-        trap_cx.x[11] = argv_base;
-        *task_inner.get_trap_cx() = trap_cx;
-    }
-
-    /// Only support processes with a single thread.
-    pub fn fork(self: &Arc<Self>) -> Arc<Self> {
-        let mut parent = self.inner_exclusive_access();
-        assert_eq!(parent.thread_count(), 1);
-        // clone parent's memory_set completely including trampoline/ustacks/trap_cxs
-        let memory_set = MemorySet::from_existed_user(&parent.memory_set);
-        // alloc a pid
-        let pid = pid_alloc();
-        // copy fd table
-        let mut new_fd_table: Vec<Option<Arc<dyn File + Send + Sync>>> = Vec::new();
-        for fd in parent.fd_table.iter() {
-            if let Some(file) = fd {
-                new_fd_table.push(Some(file.clone()));
-            } else {
-                new_fd_table.push(None);
-            }
-        }
-        // create child process pcb
-        let child = Arc::new(Self {
-            pid,
-            inner: unsafe {
-                UPIntrFreeCell::new(ProcessControlBlockInner {
-                    is_zombie: false,
-                    memory_set,
-                    parent: Some(Arc::downgrade(self)),
-                    children: Vec::new(),
-                    exit_code: 0,
-                    fd_table: new_fd_table,
-                    signals: SignalFlags::empty(),
-                    tasks: Vec::new(),
-                    task_res_allocator: RecycleAllocator::new(),
-                    mutex_list: Vec::new(),
-                    semaphore_list: Vec::new(),
-                    condvar_list: Vec::new(),
-                })
-            },
-        });
-        // add child
-        parent.children.push(Arc::clone(&child));
-        // create main thread of child process
-        let task = Arc::new(TaskControlBlock::new(
-            Arc::clone(&child),
-            parent
-                .get_task(0)
-                .inner_exclusive_access()
-                .res
-                .as_ref()
-                .unwrap()
-                .ustack_base(),
-            // here we do not allocate trap_cx or ustack again
-            // but mention that we allocate a new kstack here
-            false,
-        ));
-        // attach task to child process
-        let mut child_inner = child.inner_exclusive_access();
-        child_inner.tasks.push(Some(Arc::clone(&task)));
-        drop(child_inner);
-        // modify kstack_top in trap_cx of this thread
-        let task_inner = task.inner_exclusive_access();
-        let trap_cx = task_inner.get_trap_cx();
-        trap_cx.kernel_sp = task.kstack.get_top();
-        drop(task_inner);
-        insert_into_pid2process(child.getpid(), Arc::clone(&child));
-        // add this thread to scheduler
-        add_task(task);
-        child
-    }
-
-    pub fn getpid(&self) -> usize {
-        self.pid.0
-    }
-}

os/src/task/processor.rs

@@ -1,111 +0,0 @@
-use super::__switch;
-use super::{fetch_task, TaskStatus};
-use super::{ProcessControlBlock, TaskContext, TaskControlBlock};
-use crate::sync::UPIntrFreeCell;
-use crate::trap::TrapContext;
-use alloc::sync::Arc;
-use core::arch::asm;
-use lazy_static::*;
-
-pub struct Processor {
-    current: Option<Arc<TaskControlBlock>>,
-    idle_task_cx: TaskContext,
-}
-
-impl Processor {
-    pub fn new() -> Self {
-        Self {
-            current: None,
-            idle_task_cx: TaskContext::zero_init(),
-        }
-    }
-    fn get_idle_task_cx_ptr(&mut self) -> *mut TaskContext {
-        &mut self.idle_task_cx as *mut _
-    }
-    pub fn take_current(&mut self) -> Option<Arc<TaskControlBlock>> {
-        self.current.take()
-    }
-    pub fn current(&self) -> Option<Arc<TaskControlBlock>> {
-        self.current.as_ref().map(Arc::clone)
-    }
-}
-
-lazy_static! {
-    pub static ref PROCESSOR: UPIntrFreeCell<Processor> =
-        unsafe { UPIntrFreeCell::new(Processor::new()) };
-}
-
-pub fn run_tasks() {
-    loop {
-        let mut processor = PROCESSOR.exclusive_access();
-        if let Some(task) = fetch_task() {
-            let idle_task_cx_ptr = processor.get_idle_task_cx_ptr();
-            // access coming task TCB exclusively
-            let next_task_cx_ptr = task.inner.exclusive_session(|task_inner| {
-                task_inner.task_status = TaskStatus::Running;
-                &task_inner.task_cx as *const TaskContext
-            });
-            processor.current = Some(task);
-            // release processor manually
-            drop(processor);
-            unsafe {
-                __switch(idle_task_cx_ptr, next_task_cx_ptr);
-            }
-        } else {
-            println!("no tasks available in run_tasks");
-        }
-    }
-}
-
-pub fn take_current_task() -> Option<Arc<TaskControlBlock>> {
-    PROCESSOR.exclusive_access().take_current()
-}
-
-pub fn current_task() -> Option<Arc<TaskControlBlock>> {
-    PROCESSOR.exclusive_access().current()
-}
-
-pub fn current_process() -> Arc<ProcessControlBlock> {
-    current_task().unwrap().process.upgrade().unwrap()
-}
-
-pub fn current_user_token() -> usize {
-    let task = current_task().unwrap();
-    task.get_user_token()
-}
-
-pub fn current_trap_cx() -> &'static mut TrapContext {
-    current_task()
-        .unwrap()
-        .inner_exclusive_access()
-        .get_trap_cx()
-}
-
-pub fn current_trap_cx_user_va() -> usize {
-    current_task()
-        .unwrap()
-        .inner_exclusive_access()
-        .res
-        .as_ref()
-        .unwrap()
-        .trap_cx_user_va()
-}
-
-pub fn current_kstack_top() -> usize {
-    if let Some(task) = current_task() {
-        task.kstack.get_top()
-    } else {
-        let mut boot_stack_top;
-        unsafe { asm!("la {},boot_stack_top",out(reg) boot_stack_top) };
-        boot_stack_top
-    }
-    // current_task().unwrap().kstack.get_top()
-}
-
-pub fn schedule(switched_task_cx_ptr: *mut TaskContext) {
-    let idle_task_cx_ptr =
-        PROCESSOR.exclusive_session(|processor| processor.get_idle_task_cx_ptr());
-    unsafe {
-        __switch(switched_task_cx_ptr, idle_task_cx_ptr);
-    }
-}

os/src/task/signal.rs

@@ -1,29 +0,0 @@
-use bitflags::*;
-
-bitflags! {
-    pub struct SignalFlags: u32 {
-        const SIGINT    = 1 << 2;
-        const SIGILL    = 1 << 4;
-        const SIGABRT   = 1 << 6;
-        const SIGFPE    = 1 << 8;
-        const SIGSEGV   = 1 << 11;
-    }
-}
-
-impl SignalFlags {
-    pub fn check_error(&self) -> Option<(i32, &'static str)> {
-        if self.contains(Self::SIGINT) {
-            Some((-2, "Killed, SIGINT=2"))
-        } else if self.contains(Self::SIGILL) {
-            Some((-4, "Illegal Instruction, SIGILL=4"))
-        } else if self.contains(Self::SIGABRT) {
-            Some((-6, "Aborted, SIGABRT=6"))
-        } else if self.contains(Self::SIGFPE) {
-            Some((-8, "Erroneous Arithmetic Operation, SIGFPE=8"))
-        } else if self.contains(Self::SIGSEGV) {
-            Some((-11, "Segmentation Fault, SIGSEGV=11"))
-        } else {
-            None
-        }
-    }
-}

os/src/task/switch.rs

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

os/src/task/task.rs

@@ -1,80 +1,15 @@
-use super::id::TaskUserRes;
+use super::TaskContext;
-use super::{kstack_alloc, KernelStack, ProcessControlBlock, TaskContext};
-use crate::trap::TrapContext;
-use crate::{
-    mm::PhysPageNum,
-    sync::{UPIntrFreeCell, UPIntrRefMut},
-};
-use alloc::sync::{Arc, Weak};
 
+#[derive(Copy, Clone)]
 pub struct TaskControlBlock {
-    // immutable
-    pub process: Weak<ProcessControlBlock>,
-    pub kstack: KernelStack,
-    // mutable
-    pub inner: UPIntrFreeCell<TaskControlBlockInner>,
-}
-
-impl TaskControlBlock {
-    pub fn inner_exclusive_access(&self) -> UPIntrRefMut<'_, TaskControlBlockInner> {
-        self.inner.exclusive_access()
-    }
-
-    pub fn get_user_token(&self) -> usize {
-        let process = self.process.upgrade().unwrap();
-        let inner = process.inner_exclusive_access();
-        inner.memory_set.token()
-    }
-}
-
-pub struct TaskControlBlockInner {
-    pub res: Option<TaskUserRes>,
-    pub trap_cx_ppn: PhysPageNum,
-    pub task_cx: TaskContext,
     pub task_status: TaskStatus,
-    pub exit_code: Option<i32>,
+    pub task_cx: TaskContext,
-}
-
-impl TaskControlBlockInner {
-    pub fn get_trap_cx(&self) -> &'static mut TrapContext {
-        self.trap_cx_ppn.get_mut()
-    }
-
-    #[allow(unused)]
-    fn get_status(&self) -> TaskStatus {
-        self.task_status
-    }
-}
-
-impl TaskControlBlock {
-    pub fn new(
-        process: Arc<ProcessControlBlock>,
-        ustack_base: usize,
-        alloc_user_res: bool,
-    ) -> Self {
-        let res = TaskUserRes::new(Arc::clone(&process), ustack_base, alloc_user_res);
-        let trap_cx_ppn = res.trap_cx_ppn();
-        let kstack = kstack_alloc();
-        let kstack_top = kstack.get_top();
-        Self {
-            process: Arc::downgrade(&process),
-            kstack,
-            inner: unsafe {
-                UPIntrFreeCell::new(TaskControlBlockInner {
-                    res: Some(res),
-                    trap_cx_ppn,
-                    task_cx: TaskContext::goto_trap_return(kstack_top),
-                    task_status: TaskStatus::Ready,
-                    exit_code: None,
-                })
-            },
-        }
-    }
 }
 
 #[derive(Copy, Clone, PartialEq)]
 pub enum TaskStatus {
+    UnInit,
     Ready,
     Running,
-    Blocked,
+    Exited,
-}
+}

os/src/timer.rs

@@ -1,74 +1,18 @@
-use core::cmp::Ordering;
-
 use crate::config::CLOCK_FREQ;
 use crate::sbi::set_timer;
-use crate::sync::UPIntrFreeCell;
-use crate::task::{wakeup_task, TaskControlBlock};
-use alloc::collections::BinaryHeap;
-use alloc::sync::Arc;
-use lazy_static::*;
 use riscv::register::time;
 
 const TICKS_PER_SEC: usize = 100;
-const MSEC_PER_SEC: usize = 1000;
+const MICRO_PER_SEC: usize = 1_000_000;
 
 pub fn get_time() -> usize {
     time::read()
 }
 
-pub fn get_time_ms() -> usize {
+pub fn get_time_us() -> usize {
-    time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
+    time::read() / (CLOCK_FREQ / MICRO_PER_SEC)
 }
 
 pub fn set_next_trigger() {
     set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
 }
-
-pub struct TimerCondVar {
-    pub expire_ms: usize,
-    pub task: Arc<TaskControlBlock>,
-}
-
-impl PartialEq for TimerCondVar {
-    fn eq(&self, other: &Self) -> bool {
-        self.expire_ms == other.expire_ms
-    }
-}
-impl Eq for TimerCondVar {}
-impl PartialOrd for TimerCondVar {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        let a = -(self.expire_ms as isize);
-        let b = -(other.expire_ms as isize);
-        Some(a.cmp(&b))
-    }
-}
-
-impl Ord for TimerCondVar {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.partial_cmp(other).unwrap()
-    }
-}
-
-lazy_static! {
-    static ref TIMERS: UPIntrFreeCell<BinaryHeap<TimerCondVar>> =
-        unsafe { UPIntrFreeCell::new(BinaryHeap::<TimerCondVar>::new()) };
-}
-
-pub fn add_timer(expire_ms: usize, task: Arc<TaskControlBlock>) {
-    let mut timers = TIMERS.exclusive_access();
-    timers.push(TimerCondVar { expire_ms, task });
-}
-
-pub fn check_timer() {
-    let current_ms = get_time_ms();
-    TIMERS.exclusive_session(|timers| {
-        while let Some(timer) = timers.peek() {
-            if timer.expire_ms <= current_ms {
-                wakeup_task(Arc::clone(&timer.task));
-                timers.pop();
-            } else {
-                break;
-            }
-        }
-    });
-}

os/src/trap/context.rs

@@ -1,37 +1,21 @@
-use riscv::register::sstatus::{self, Sstatus, SPP};
+use riscv::register::sstatus::{Sstatus, self, SPP};
 
 #[repr(C)]
-#[derive(Debug)]
 pub struct TrapContext {
     pub x: [usize; 32],
     pub sstatus: Sstatus,
     pub sepc: usize,
-    pub kernel_satp: usize,
-    pub kernel_sp: usize,
-    pub trap_handler: usize,
 }
 
 impl TrapContext {
-    pub fn set_sp(&mut self, sp: usize) {
+    pub fn set_sp(&mut self, sp: usize) { self.x[2] = sp; }
-        self.x[2] = sp;
+    pub fn app_init_context(entry: usize, sp: usize) -> Self {
-    }
-    pub fn app_init_context(
-        entry: usize,
-        sp: usize,
-        kernel_satp: usize,
-        kernel_sp: usize,
-        trap_handler: usize,
-    ) -> Self {
         let mut sstatus = sstatus::read();
-        // set CPU privilege to User after trapping back
         sstatus.set_spp(SPP::User);
         let mut cx = Self {
             x: [0; 32],
             sstatus,
             sepc: entry,
-            kernel_satp,
-            kernel_sp,
-            trap_handler,
         };
         cx.set_sp(sp);
         cx

os/src/trap/mod.rs

@@ -1,169 +1,64 @@
 mod context;
 
-use crate::config::TRAMPOLINE;
-use crate::syscall::syscall;
-use crate::task::{
-    check_signals_of_current, current_add_signal, current_trap_cx, current_trap_cx_user_va,
-    current_user_token, exit_current_and_run_next, suspend_current_and_run_next, SignalFlags,
-};
-use crate::timer::{check_timer, set_next_trigger};
-use core::arch::{asm, global_asm};
 use riscv::register::{
     mtvec::TrapMode,
-    scause::{self, Exception, Interrupt, Trap},
+    stvec,
-    sie, sip, sscratch, sstatus, stval, stvec,
+    scause::{
+        self,
+        Trap,
+        Exception,
+        Interrupt,
+    },
+    stval,
+    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"));
 
 pub fn init() {
-    set_kernel_trap_entry();
+    extern "C" { fn __alltraps(); }
-}
-
-fn set_kernel_trap_entry() {
-    extern "C" {
-        fn __alltraps();
-        fn __alltraps_k();
-    }
-    let __alltraps_k_va = __alltraps_k as usize - __alltraps as usize + TRAMPOLINE;
     unsafe {
-        stvec::write(__alltraps_k_va, TrapMode::Direct);
+        stvec::write(__alltraps as usize, TrapMode::Direct);
-        sscratch::write(trap_from_kernel as usize);
-    }
-}
-
-fn set_user_trap_entry() {
-    unsafe {
-        stvec::write(TRAMPOLINE as usize, TrapMode::Direct);
     }
 }
 
 pub fn enable_timer_interrupt() {
-    unsafe {
+    unsafe { sie::set_stimer(); }
-        sie::set_stimer();
-    }
-}
-
-fn enable_supervisor_interrupt() {
-    unsafe {
-        sstatus::set_sie();
-    }
-}
-
-fn disable_supervisor_interrupt() {
-    unsafe {
-        sstatus::clear_sie();
-    }
 }
 
 #[no_mangle]
-pub fn trap_handler() -> ! {
+pub fn trap_handler(cx: &mut TrapContext) -> &mut TrapContext {
-    set_kernel_trap_entry();
     let scause = scause::read();
     let stval = stval::read();
-    // println!("into {:?}", scause.cause());
     match scause.cause() {
         Trap::Exception(Exception::UserEnvCall) => {
-            // jump to next instruction anyway
-            let mut cx = current_trap_cx();
             cx.sepc += 4;
-
+            cx.x[10] = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]) as usize;
-            enable_supervisor_interrupt();
-
-            // get system call return value
-            let result = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]);
-            // cx is changed during sys_exec, so we have to call it again
-            cx = current_trap_cx();
-            cx.x[10] = result as usize;
         }
-        Trap::Exception(Exception::StoreFault)
+        Trap::Exception(Exception::StoreFault) |
-        | Trap::Exception(Exception::StorePageFault)
+        Trap::Exception(Exception::StorePageFault) => {
-        | Trap::Exception(Exception::InstructionFault)
+            println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, core dumped.", stval, cx.sepc);
-        | Trap::Exception(Exception::InstructionPageFault)
+            exit_current_and_run_next();
-        | Trap::Exception(Exception::LoadFault)
-        | Trap::Exception(Exception::LoadPageFault) => {
-            /*
-            println!(
-                "[kernel] {:?} in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.",
-                scause.cause(),
-                stval,
-                current_trap_cx().sepc,
-            );
-            */
-            current_add_signal(SignalFlags::SIGSEGV);
         }
         Trap::Exception(Exception::IllegalInstruction) => {
-            current_add_signal(SignalFlags::SIGILL);
+            println!("[kernel] IllegalInstruction in application, core dumped.");
+            exit_current_and_run_next();
         }
         Trap::Interrupt(Interrupt::SupervisorTimer) => {
             set_next_trigger();
-            check_timer();
             suspend_current_and_run_next();
         }
-        Trap::Interrupt(Interrupt::SupervisorExternal) => {
-            crate::board::irq_handler();
-        }
         _ => {
-            panic!(
+            panic!("Unsupported trap {:?}, stval = {:#x}!", scause.cause(), stval);
-                "Unsupported trap {:?}, stval = {:#x}!",
-                scause.cause(),
-                stval
-            );
         }
     }
-    // check signals
+    cx
-    if let Some((errno, msg)) = check_signals_of_current() {
-        println!("[kernel] {}", msg);
-        exit_current_and_run_next(errno);
-    }
-    trap_return();
 }
 
-#[no_mangle]
+pub use context::TrapContext;
-pub fn trap_return() -> ! {
-    disable_supervisor_interrupt();
-    set_user_trap_entry();
-    let trap_cx_user_va = current_trap_cx_user_va();
-    let user_satp = current_user_token();
-    extern "C" {
-        fn __alltraps();
-        fn __restore();
-    }
-    let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE;
-    //println!("before return");
-    unsafe {
-        asm!(
-            "fence.i",
-            "jr {restore_va}",
-            restore_va = in(reg) restore_va,
-            in("a0") trap_cx_user_va,
-            in("a1") user_satp,
-            options(noreturn)
-        );
-    }
-}
-
-#[no_mangle]
-pub fn trap_from_kernel(_trap_cx: &TrapContext) {
-    let scause = scause::read();
-    let stval = stval::read();
-    match scause.cause() {
-        Trap::Interrupt(Interrupt::SupervisorExternal) => {
-            crate::board::irq_handler();
-        }
-        Trap::Interrupt(Interrupt::SupervisorTimer) => {
-            set_next_trigger();
-            check_timer();
-            // do not schedule now
-        }
-        _ => {
-            panic!(
-                "Unsupported trap from kernel: {:?}, stval = {:#x}!",
-                scause.cause(),
-                stval
-            );
-        }
-    }
-}
-
-pub use context::TrapContext;

os/src/trap/trap.S

@@ -5,16 +5,16 @@
 .macro LOAD_GP n
     ld x\n, \n*8(sp)
 .endm
-    .section .text.trampoline
+    .section .text
     .globl __alltraps
     .globl __restore
-    .globl __alltraps_k
-    .globl __restore_k
     .align 2
 __alltraps:
     csrrw sp, sscratch, sp
-    # now sp->*TrapContext in user space, sscratch->user stack
+    # now sp->kernel stack, sscratch->user stack
-    # save other general purpose registers
+    # allocate a TrapContext on kernel stack
+    addi sp, sp, -34*8
+    # save general-purpose registers
     sd x1, 1*8(sp)
     # skip sp(x2), we will save it later
     sd x3, 3*8(sp)
@@ -25,74 +25,28 @@ __alltraps:
         SAVE_GP %n
         .set n, n+1
     .endr
-    # we can use t0/t1/t2 freely, because they have been saved in TrapContext
+    # we can use t0/t1/t2 freely, because they were saved on kernel stack
     csrr t0, sstatus
     csrr t1, sepc
     sd t0, 32*8(sp)
     sd t1, 33*8(sp)
-    # read user stack from sscratch and save it in TrapContext
+    # read user stack from sscratch and save it on the kernel stack
     csrr t2, sscratch
     sd t2, 2*8(sp)
-    # load kernel_satp into t0
+    # set input argument of trap_handler(cx: &mut TrapContext)
-    ld t0, 34*8(sp)
+    mv a0, sp
-    # load trap_handler into t1
+    call trap_handler
-    ld t1, 36*8(sp)
-    # move to kernel_sp
-    ld sp, 35*8(sp)
-    # switch to kernel space
-    csrw satp, t0
-    sfence.vma
-    # jump to trap_handler
-    jr t1
 
 __restore:
-    # a0: *TrapContext in user space(Constant); a1: user space token
+    # now sp->kernel stack(after allocated), sscratch->user stack
-    # switch to user space
-    csrw satp, a1
-    sfence.vma
-    csrw sscratch, a0
-    mv sp, a0
-    # now sp points to TrapContext in user space, start restoring based on it
     # restore sstatus/sepc
     ld t0, 32*8(sp)
     ld t1, 33*8(sp)
+    ld t2, 2*8(sp)
     csrw sstatus, t0
     csrw sepc, t1
-    # restore general purpose registers except x0/sp/tp
+    csrw sscratch, t2
-    ld x1, 1*8(sp)
+    # restore general-purpuse registers except sp/tp
-    ld x3, 3*8(sp)
-    .set n, 5
-    .rept 27
-        LOAD_GP %n
-        .set n, n+1
-    .endr
-    # back to user stack
-    ld sp, 2*8(sp)
-    sret
-
-    .align 2
-__alltraps_k:
-    addi sp, sp, -34*8 
-    sd x1, 1*8(sp)
-    sd x3, 3*8(sp)
-    .set n, 5
-    .rept 27
-        SAVE_GP %n
-        .set n, n+1
-    .endr
-    csrr t0, sstatus
-    csrr t1, sepc
-    sd t0, 32*8(sp)
-    sd t1, 33*8(sp)
-    mv a0, sp
-    csrr t2, sscratch
-    jalr t2
-
-__restore_k:
-    ld t0, 32*8(sp)
-    ld t1, 33*8(sp)
-    csrw sstatus, t0
-    csrw sepc, t1
     ld x1, 1*8(sp)
     ld x3, 3*8(sp)
     .set n, 5
@@ -100,5 +54,8 @@ __restore_k:
         LOAD_GP %n
         .set n, n+1
     .endr
+    # release TrapContext on kernel stack
     addi sp, sp, 34*8
+    # now sp->kernel stack, sscratch->user stack
+    csrrw sp, sscratch, sp
     sret

ping.py

@@ -1,18 +0,0 @@
-import socket
-import sys
-import time
-
-sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-addr = ('localhost', 26099)
-sock.bind(addr)
-
-
-print("pinging...", file=sys.stderr)
-while True:
-        buf, raddr = sock.recvfrom(4096)
-        print("receive: " + buf.decode("utf-8"))
-        buf = "this is a ping to port 6200!".encode('utf-8')
-        sock.sendto(buf, ("127.0.0.1", 6200))
-        buf = "this is a ping to reply!".encode('utf-8')
-        sock.sendto(buf, raddr)
-        time.sleep(1)

rust-toolchain

@@ -0,0 +1 @@
+nightly-2021-10-15

rust-toolchain.toml

@@ -1,6 +0,0 @@
-[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"]

setenv.sh

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

user/.cargo/config

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

user/Cargo.toml

@@ -9,11 +9,5 @@ edition = "2018"
 [dependencies]
 buddy_system_allocator = "0.6"
 bitflags = "1.2.1"
-riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
+spin = "0.9"
 lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
-embedded-graphics = "0.7.1"
-oorandom ="11"
-virtio-input-decoder = "0.1.4"
-
-[profile.release]
-debug = true

user/Makefile

@@ -2,28 +2,39 @@ TARGET := riscv64gc-unknown-none-elf
 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
-CP := cp 
+PY := python3
 
-TEST ?= 
+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)
-	@cargo build --release
+	@python3 build.py
-ifeq ($(TEST), 1)
-	@$(CP) $(TARGET_DIR)/usertests $(TARGET_DIR)/initproc
-endif
 
 binary: elf
-	@$(foreach elf, $(ELFS), $(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf));)
+	@$(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
+.PHONY: elf binary build clean