Compare commits
35 commits
Author | SHA1 | Date | |
---|---|---|---|
![]() |
a91f29c7a3 | ||
![]() |
8b14fb6842 | ||
![]() |
0aaa7bba53 | ||
![]() |
b03d06c330 | ||
![]() |
92d9170fca | ||
![]() |
4e22f9d2fc | ||
![]() |
5a24228565 | ||
![]() |
859afce7e3 | ||
![]() |
93ea7f9d4d | ||
![]() |
fd00e8de3a | ||
![]() |
7b815ac2f5 | ||
![]() |
8731d981ec | ||
![]() |
8dfbb05fc2 | ||
![]() |
92b949a01f | ||
![]() |
f1aabb5e0e | ||
![]() |
5a40784918 | ||
![]() |
80b03c6740 | ||
![]() |
cd9c1708a6 | ||
![]() |
8406e8d8fe | ||
![]() |
db66972228 | ||
![]() |
9944ac8701 | ||
![]() |
6666ca5344 | ||
![]() |
e0646c2d53 | ||
![]() |
a8388036f1 | ||
![]() |
fd8f673dbe | ||
![]() |
e4eee06cb2 | ||
![]() |
2beee556e8 | ||
![]() |
15ea8d934a | ||
![]() |
923abbbc96 | ||
![]() |
1ea79921bd | ||
![]() |
1d4041a418 | ||
![]() |
b4ade2c68e | ||
![]() |
45fb4113d1 | ||
![]() |
5985986249 | ||
![]() |
abdfaeae89 |
57 changed files with 1374 additions and 1784 deletions
1
.dockerignore
Normal file
1
.dockerignore
Normal file
|
@ -0,0 +1 @@
|
|||
*/*
|
16
.gitignore
vendored
16
.gitignore
vendored
|
@ -1,6 +1,16 @@
|
|||
.idea/*
|
||||
os/target/*
|
||||
os/.idea/*
|
||||
.idea
|
||||
Cargo.lock
|
||||
target
|
||||
os/src/link_app.S
|
||||
os/last-*
|
||||
os/Cargo.lock
|
||||
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
|
40
Dockerfile
Normal file
40
Dockerfile
Normal file
|
@ -0,0 +1,40 @@
|
|||
FROM ubuntu:18.04
|
||||
LABEL maintainer="dinghao188" \
|
||||
version="1.1" \
|
||||
description="ubuntu 18.04 with tools for tsinghua's rCore-Tutorial-V3"
|
||||
|
||||
#install some deps
|
||||
RUN set -x \
|
||||
&& apt-get update \
|
||||
&& apt-get install -y curl wget autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev \
|
||||
gawk build-essential bison flex texinfo gperf libtool patchutils bc xz-utils \
|
||||
zlib1g-dev libexpat-dev pkg-config libglib2.0-dev libpixman-1-dev git tmux python3
|
||||
|
||||
#install rust and qemu
|
||||
RUN set -x; \
|
||||
RUSTUP='/root/rustup.sh' \
|
||||
&& cd $HOME \
|
||||
#install rust
|
||||
&& curl https://sh.rustup.rs -sSf > $RUSTUP && chmod +x $RUSTUP \
|
||||
&& $RUSTUP -y --default-toolchain nightly --profile minimal \
|
||||
|
||||
#compile qemu
|
||||
&& wget https://ftp.osuosl.org/pub/blfs/conglomeration/qemu/qemu-5.0.0.tar.xz \
|
||||
&& tar xvJf qemu-5.0.0.tar.xz \
|
||||
&& cd qemu-5.0.0 \
|
||||
&& ./configure --target-list=riscv64-softmmu,riscv64-linux-user \
|
||||
&& make -j$(nproc) install \
|
||||
&& cd $HOME && rm -rf qemu-5.0.0 qemu-5.0.0.tar.xz
|
||||
|
||||
#for chinese network
|
||||
RUN set -x; \
|
||||
APT_CONF='/etc/apt/sources.list'; \
|
||||
CARGO_CONF='/root/.cargo/config'; \
|
||||
BASHRC='/root/.bashrc' \
|
||||
&& echo 'export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static' >> $BASHRC \
|
||||
&& echo 'export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup' >> $BASHRC \
|
||||
&& touch $CARGO_CONF \
|
||||
&& echo '[source.crates-io]' > $CARGO_CONF \
|
||||
&& echo "replace-with = 'ustc'" >> $CARGO_CONF \
|
||||
&& echo '[source.ustc]' >> $CARGO_CONF \
|
||||
&& echo 'registry = "git://mirrors.ustc.edu.cn/crates.io-index"' >> $CARGO_CONF
|
8
Makefile
Normal file
8
Makefile
Normal file
|
@ -0,0 +1,8 @@
|
|||
DOCKER_NAME ?= dinghao188/rcore-tutorial
|
||||
.PHONY: docker build_docker
|
||||
|
||||
docker:
|
||||
docker run --rm -it --mount type=bind,source=$(shell pwd),destination=/mnt ${DOCKER_NAME}
|
||||
|
||||
build_docker:
|
||||
docker build -t ${DOCKER_NAME} .
|
67
README.md
67
README.md
|
@ -1,2 +1,67 @@
|
|||
# rCore-Tutorial-v3
|
||||
rCore-Tutorial version 3.
|
||||
rCore-Tutorial version 3.5. See the [Documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/).
|
||||
|
||||
## news
|
||||
- 2021.11.20: Now we are updating our labs. Please checkout chX-dev Branches for our current new labs. (Notice: please see the [Dependency] section in the end of this doc)
|
||||
|
||||
## Overview
|
||||
|
||||
This project aims to show how to write an **Unix-like OS** running on **RISC-V** platforms **from scratch** in **[Rust](https://www.rust-lang.org/)** for **beginners** without any background knowledge about **computer architectures, assembly languages or operating systems**.
|
||||
|
||||
## Features
|
||||
|
||||
* Platform supported: `qemu-system-riscv64` simulator or dev boards based on [Kendryte K210 SoC](https://canaan.io/product/kendryteai) such as [Maix Dock](https://www.seeedstudio.com/Sipeed-MAIX-Dock-p-4815.html)
|
||||
* OS
|
||||
* concurrency of multiple processes
|
||||
* preemptive scheduling(Round-Robin algorithm)
|
||||
* dynamic memory management in kernel
|
||||
* virtual memory
|
||||
* a simple file system with a block cache
|
||||
* an interactive shell in the userspace
|
||||
* **only 4K+ LoC**
|
||||
* [A detailed documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/) in spite of the lack of comments in the code(English version is not available at present)
|
||||
|
||||
## Run our project
|
||||
|
||||
TODO:
|
||||
|
||||
## Working in progress
|
||||
|
||||
Now we are still updating our project, you can find latest changes on branches `chX-dev` such as `ch1-dev`. We are intended to publish first release 3.5.0 after completing most of the tasks mentioned below.
|
||||
|
||||
Overall progress: ch7
|
||||
|
||||
### Completed
|
||||
|
||||
* [x] automatically clean up and rebuild before running our project on a different platform
|
||||
* [x] fix `power` series application in early chapters, now you can find modulus in the output
|
||||
* [x] use `UPSafeCell` instead of `RefCell` or `spin::Mutex` in order to access static data structures and adjust its API so that it cannot be borrowed twice at a time(mention `& .exclusive_access().task[0]` in `run_first_task`)
|
||||
* [x] move `TaskContext` into `TaskControlBlock` instead of restoring it in place on kernel stack(since ch3), eliminating annoying `task_cx_ptr2`
|
||||
* [x] replace `llvm_asm!` with `asm!`
|
||||
* [x] expand the fs image size generated by `rcore-fs-fuse` to 128MiB
|
||||
* [x] add a new test named `huge_write` which evaluates the fs performance(qemu\~500KiB/s k210\~50KiB/s)
|
||||
* [x] flush all block cache to disk after a fs transaction which involves write operation
|
||||
* [x] replace `spin::Mutex` with `UPSafeCell` before SMP chapter
|
||||
* [x] add codes for a new chapter about synchronization & mutual exclusion(uniprocessor only)
|
||||
|
||||
### Todo(High priority)
|
||||
|
||||
* [ ] support Allwinner's RISC-V D1 chip
|
||||
* [ ] bug fix: we should call `find_pte` rather than `find_pte_create` in `PageTable::unmap`
|
||||
* [ ] bug fix: check validity of level-3 pte in `find_pte` instead of checking it outside this function
|
||||
* [ ] use old fs image optionally, do not always rebuild the image
|
||||
* [ ] add new system calls: getdents64/fstat
|
||||
* [ ] shell functionality improvement(to be continued...)
|
||||
* [ ] give every non-zero process exit code an unique and clear error type
|
||||
* [ ] effective error handling of mm module
|
||||
|
||||
### Todo(Low priority)
|
||||
|
||||
* [ ] rewrite practice doc and remove some inproper questions
|
||||
* [ ] provide smooth debug experience at a Rust source code level
|
||||
* [ ] format the code using official tools
|
||||
|
||||
|
||||
### Crates
|
||||
|
||||
We will add them later.
|
||||
|
|
Binary file not shown.
Binary file not shown.
18
dev-env-info.md
Normal file
18
dev-env-info.md
Normal file
|
@ -0,0 +1,18 @@
|
|||
# rCore-Tutorial-v3
|
||||
rCore-Tutorial version 3.x
|
||||
|
||||
## Dependency
|
||||
|
||||
### Binaries
|
||||
|
||||
* rustc: 1.57.0-nightly (e1e9319d9 2021-10-14)
|
||||
|
||||
* cargo-binutils: 0.3.3
|
||||
|
||||
* qemu: 5.0.0
|
||||
|
||||
* rustsbi-lib: 0.2.0-alpha.4
|
||||
|
||||
rustsbi-qemu: d4968dd2
|
||||
|
||||
rustsbi-k210: b689314e
|
132
os/Cargo.lock
generated
132
os/Cargo.lock
generated
|
@ -1,132 +0,0 @@
|
|||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "0.7.15"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bare-metal"
|
||||
version = "0.2.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
|
||||
dependencies = [
|
||||
"rustc_version",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bit_field"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
|
||||
|
||||
[[package]]
|
||||
name = "lazy_static"
|
||||
version = "1.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
|
||||
dependencies = [
|
||||
"spin",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.3.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
|
||||
|
||||
[[package]]
|
||||
name = "os"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"riscv",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax",
|
||||
"thread_local",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.6.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189"
|
||||
|
||||
[[package]]
|
||||
name = "riscv"
|
||||
version = "0.6.0"
|
||||
source = "git+https://github.com/rcore-os/riscv#21e32ee1dc786cc0d5006ceee0040ce4f8398575"
|
||||
dependencies = [
|
||||
"bare-metal",
|
||||
"bit_field",
|
||||
"bitflags",
|
||||
"riscv-target",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "riscv-target"
|
||||
version = "0.1.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "88aa938cda42a0cf62a20cfe8d139ff1af20c2e681212b5b34adb5a58333f222"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"regex",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustc_version"
|
||||
version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
|
||||
dependencies = [
|
||||
"semver",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "0.9.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
|
||||
dependencies = [
|
||||
"semver-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver-parser"
|
||||
version = "0.7.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
|
||||
|
||||
[[package]]
|
||||
name = "spin"
|
||||
version = "0.5.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
|
||||
|
||||
[[package]]
|
||||
name = "thread_local"
|
||||
version = "1.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
]
|
48
os/Makefile
48
os/Makefile
|
@ -3,17 +3,24 @@ TARGET := riscv64gc-unknown-none-elf
|
|||
MODE := release
|
||||
KERNEL_ELF := target/$(TARGET)/$(MODE)/os
|
||||
KERNEL_BIN := $(KERNEL_ELF).bin
|
||||
KERNEL_ENTRY_PA := 0x80020000
|
||||
DISASM_TMP := target/$(TARGET)/$(MODE)/asm
|
||||
|
||||
# BOARD
|
||||
BOARD ?= qemu
|
||||
SBI ?= rustsbi
|
||||
BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
|
||||
BOARD ?= qemu
|
||||
SBI ?= rustsbi
|
||||
BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
|
||||
K210_BOOTLOADER_SIZE := 131072
|
||||
|
||||
# KERNEL ENTRY
|
||||
ifeq ($(BOARD), qemu)
|
||||
KERNEL_ENTRY_PA := 0x80200000
|
||||
else ifeq ($(BOARD), k210)
|
||||
KERNEL_ENTRY_PA := 0x80020000
|
||||
endif
|
||||
|
||||
# Run K210
|
||||
K210-SERIALPORT = /dev/ttyUSB0
|
||||
K210-BURNER = ../tools/kflash.py
|
||||
K210-BURNER = ../tools/kflash.py
|
||||
|
||||
# Binutils
|
||||
OBJDUMP := rust-objdump --arch-name=riscv64
|
||||
|
@ -22,14 +29,32 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
|
|||
# Disassembly
|
||||
DISASM ?= -x
|
||||
|
||||
build: $(KERNEL_BIN)
|
||||
TEST ?= 0
|
||||
|
||||
build: env switch-check $(KERNEL_BIN)
|
||||
|
||||
switch-check:
|
||||
ifeq ($(BOARD), qemu)
|
||||
(which last-qemu) || (rm last-k210 -f && touch last-qemu && make clean)
|
||||
else ifeq ($(BOARD), k210)
|
||||
(which last-k210) || (rm last-qemu -f && touch last-k210 && make clean)
|
||||
endif
|
||||
|
||||
env:
|
||||
(rustup target list | grep "riscv64gc-unknown-none-elf (installed)") || rustup target add $(TARGET)
|
||||
cargo install cargo-binutils --vers =0.3.3
|
||||
rustup component add rust-src
|
||||
rustup component add llvm-tools-preview
|
||||
|
||||
$(KERNEL_BIN): kernel
|
||||
@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
|
||||
|
||||
kernel:
|
||||
@cd ../user && make build
|
||||
@cd ../user && make build TEST=$(TEST)
|
||||
@echo Platform: $(BOARD)
|
||||
@cp src/linker-$(BOARD).ld src/linker.ld
|
||||
@cargo build --release --features "board_$(BOARD)"
|
||||
@rm src/linker.ld
|
||||
|
||||
clean:
|
||||
@cargo clean
|
||||
|
@ -44,6 +69,8 @@ disasm-vim: kernel
|
|||
|
||||
run: run-inner
|
||||
|
||||
|
||||
|
||||
run-inner: build
|
||||
ifeq ($(BOARD),qemu)
|
||||
@qemu-system-riscv64 \
|
||||
|
@ -52,12 +79,13 @@ ifeq ($(BOARD),qemu)
|
|||
-bios $(BOOTLOADER) \
|
||||
-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA)
|
||||
else
|
||||
(which $(K210-BURNER)) || (cd .. && git clone https://github.com/sipeed/kflash.py.git && mv kflash.py tools)
|
||||
@cp $(BOOTLOADER) $(BOOTLOADER).copy
|
||||
@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=128K seek=1
|
||||
@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=$(K210_BOOTLOADER_SIZE) seek=1
|
||||
@mv $(BOOTLOADER).copy $(KERNEL_BIN)
|
||||
@sudo chmod 777 $(K210-SERIALPORT)
|
||||
python3 $(K210-BURNER) -p $(K210-SERIALPORT) -b 1500000 $(KERNEL_BIN)
|
||||
miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
|
||||
python3 -m serial.tools.miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
|
||||
endif
|
||||
|
||||
debug: build
|
||||
|
@ -66,4 +94,4 @@ debug: build
|
|||
tmux split-window -h "riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'" && \
|
||||
tmux -2 attach-session -d
|
||||
|
||||
.PHONY: build kernel clean disasm disasm-vim run-inner
|
||||
.PHONY: build env kernel clean disasm disasm-vim run-inner switch-check
|
||||
|
|
37
os/build.rs
37
os/build.rs
|
@ -1,16 +1,17 @@
|
|||
use std::fs::{read_dir, File};
|
||||
use std::io::{Result, Write};
|
||||
use std::fs::{File, read_dir};
|
||||
|
||||
fn main() {
|
||||
println!("cargo:rerun-if-changed=../user/src/bin/");
|
||||
println!("cargo:rerun-if-changed=../user/src/");
|
||||
println!("cargo:rerun-if-changed={}", TARGET_PATH);
|
||||
insert_app_data().unwrap();
|
||||
}
|
||||
|
||||
static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/debug/";
|
||||
static TARGET_PATH: &str = "../user/build/bin/";
|
||||
|
||||
fn insert_app_data() -> Result<()> {
|
||||
let mut f = File::create("src/link_app.S").unwrap();
|
||||
let mut apps: Vec<_> = read_dir("../user/src/bin")
|
||||
let mut apps: Vec<_> = read_dir("../user/build/bin/")
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|dir_entry| {
|
||||
|
@ -21,33 +22,35 @@ fn insert_app_data() -> Result<()> {
|
|||
.collect();
|
||||
apps.sort();
|
||||
|
||||
writeln!(f, r#"
|
||||
.align 4
|
||||
writeln!(
|
||||
f,
|
||||
r#"
|
||||
.align 3
|
||||
.section .data
|
||||
.global _num_app
|
||||
_num_app:
|
||||
.quad {}
|
||||
"#, apps.len())?;
|
||||
.quad {}"#,
|
||||
apps.len()
|
||||
)?;
|
||||
|
||||
for i in 0..apps.len() {
|
||||
writeln!(f, r#"
|
||||
.quad app_{}_start
|
||||
"#, i)?;
|
||||
writeln!(f, r#" .quad app_{}_start"#, i)?;
|
||||
}
|
||||
writeln!(f, r#"
|
||||
.quad app_{}_end
|
||||
"#, apps.len() - 1)?;
|
||||
writeln!(f, r#" .quad app_{}_end"#, apps.len() - 1)?;
|
||||
|
||||
for (idx, app) in apps.iter().enumerate() {
|
||||
println!("app_{}: {}", idx, app);
|
||||
writeln!(f, r#"
|
||||
writeln!(
|
||||
f,
|
||||
r#"
|
||||
.section .data
|
||||
.global app_{0}_start
|
||||
.global app_{0}_end
|
||||
app_{0}_start:
|
||||
.incbin "{2}{1}.bin"
|
||||
app_{0}_end:
|
||||
"#, idx, app, TARGET_PATH)?;
|
||||
app_{0}_end:"#,
|
||||
idx, app, TARGET_PATH
|
||||
)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
|
@ -1,11 +1,11 @@
|
|||
pub const USER_STACK_SIZE: usize = 4096 * 2;
|
||||
pub const KERNEL_STACK_SIZE: usize = 4096 * 2;
|
||||
pub const MAX_APP_NUM: usize = 4;
|
||||
pub const APP_BASE_ADDRESS: usize = 0x80100000;
|
||||
pub const MAX_APP_NUM: usize = 8;
|
||||
pub const APP_BASE_ADDRESS: usize = 0x80400000;
|
||||
pub const APP_SIZE_LIMIT: usize = 0x20000;
|
||||
|
||||
#[cfg(feature = "board_k210")]
|
||||
pub const CPU_FREQ: usize = 10000000;
|
||||
pub const CLOCK_FREQ: usize = 403000000 / 62;
|
||||
|
||||
#[cfg(feature = "board_qemu")]
|
||||
pub const CPU_FREQ: usize = 12500000;
|
||||
pub const CLOCK_FREQ: usize = 12500000;
|
|
@ -18,6 +18,7 @@ SECTIONS
|
|||
srodata = .;
|
||||
.rodata : {
|
||||
*(.rodata .rodata.*)
|
||||
*(.srodata .srodata.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
|
@ -25,6 +26,7 @@ SECTIONS
|
|||
sdata = .;
|
||||
.data : {
|
||||
*(.data .data.*)
|
||||
*(.sdata .sdata.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
|
@ -33,6 +35,7 @@ SECTIONS
|
|||
*(.bss.stack)
|
||||
sbss = .;
|
||||
*(.bss .bss.*)
|
||||
*(.sbss .sbss.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
48
os/src/linker-qemu.ld
Normal file
48
os/src/linker-qemu.ld
Normal file
|
@ -0,0 +1,48 @@
|
|||
OUTPUT_ARCH(riscv)
|
||||
ENTRY(_start)
|
||||
BASE_ADDRESS = 0x80200000;
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
. = BASE_ADDRESS;
|
||||
skernel = .;
|
||||
|
||||
stext = .;
|
||||
.text : {
|
||||
*(.text.entry)
|
||||
*(.text .text.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
etext = .;
|
||||
srodata = .;
|
||||
.rodata : {
|
||||
*(.rodata .rodata.*)
|
||||
*(.srodata .srodata.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
erodata = .;
|
||||
sdata = .;
|
||||
.data : {
|
||||
*(.data .data.*)
|
||||
*(.sdata .sdata.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
edata = .;
|
||||
.bss : {
|
||||
*(.bss.stack)
|
||||
sbss = .;
|
||||
*(.bss .bss.*)
|
||||
*(.sbss .sbss.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
ebss = .;
|
||||
ekernel = .;
|
||||
|
||||
/DISCARD/ : {
|
||||
*(.eh_frame)
|
||||
}
|
||||
}
|
|
@ -1,13 +1,14 @@
|
|||
use crate::trap::TrapContext;
|
||||
use crate::task::TaskContext;
|
||||
use crate::config::*;
|
||||
|
||||
#[repr(align(4096))]
|
||||
#[derive(Copy, Clone)]
|
||||
struct KernelStack {
|
||||
data: [u8; KERNEL_STACK_SIZE],
|
||||
}
|
||||
|
||||
#[repr(align(4096))]
|
||||
#[derive(Copy, Clone)]
|
||||
struct UserStack {
|
||||
data: [u8; USER_STACK_SIZE],
|
||||
}
|
||||
|
@ -26,14 +27,10 @@ impl KernelStack {
|
|||
fn get_sp(&self) -> usize {
|
||||
self.data.as_ptr() as usize + KERNEL_STACK_SIZE
|
||||
}
|
||||
pub fn push_context(&self, trap_cx: TrapContext, task_cx: TaskContext) -> &'static mut TaskContext {
|
||||
unsafe {
|
||||
let trap_cx_ptr = (self.get_sp() - core::mem::size_of::<TrapContext>()) as *mut TrapContext;
|
||||
*trap_cx_ptr = trap_cx;
|
||||
let task_cx_ptr = (trap_cx_ptr as usize - core::mem::size_of::<TaskContext>()) as *mut TaskContext;
|
||||
*task_cx_ptr = task_cx;
|
||||
task_cx_ptr.as_mut().unwrap()
|
||||
}
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -60,7 +57,7 @@ pub fn load_apps() {
|
|||
core::slice::from_raw_parts(num_app_ptr.add(1), num_app + 1)
|
||||
};
|
||||
// clear i-cache first
|
||||
unsafe { llvm_asm!("fence.i" :::: "volatile"); }
|
||||
unsafe { asm!("fence.i"); }
|
||||
// load apps
|
||||
for i in 0..num_app {
|
||||
let base_i = get_base_i(i);
|
||||
|
@ -79,9 +76,8 @@ pub fn load_apps() {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn init_app_cx(app_id: usize) -> &'static TaskContext {
|
||||
pub fn init_app_cx(app_id: usize) -> usize {
|
||||
KERNEL_STACK[app_id].push_context(
|
||||
TrapContext::app_init_context(get_base_i(app_id), USER_STACK[app_id].get_sp()),
|
||||
TaskContext::goto_restore(),
|
||||
)
|
||||
}
|
||||
|
|
|
@ -1,9 +1,8 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
#![feature(global_asm)]
|
||||
#![feature(llvm_asm)]
|
||||
#![feature(asm)]
|
||||
#![feature(panic_info_message)]
|
||||
#![feature(const_in_array_repeat_expressions)]
|
||||
|
||||
#[macro_use]
|
||||
mod console;
|
||||
|
@ -15,6 +14,7 @@ mod loader;
|
|||
mod config;
|
||||
mod task;
|
||||
mod timer;
|
||||
mod sync;
|
||||
|
||||
global_asm!(include_str!("entry.asm"));
|
||||
global_asm!(include_str!("link_app.S"));
|
||||
|
@ -24,9 +24,12 @@ fn clear_bss() {
|
|||
fn sbss();
|
||||
fn ebss();
|
||||
}
|
||||
(sbss as usize..ebss as usize).for_each(|a| {
|
||||
unsafe { (a as *mut u8).write_volatile(0) }
|
||||
});
|
||||
unsafe {
|
||||
core::slice::from_raw_parts_mut(
|
||||
sbss as usize as *mut u8,
|
||||
ebss as usize - sbss as usize,
|
||||
).fill(0);
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
|
@ -35,7 +38,6 @@ pub fn rust_main() -> ! {
|
|||
println!("[kernel] Hello, world!");
|
||||
trap::init();
|
||||
loader::load_apps();
|
||||
trap::enable_interrupt();
|
||||
trap::enable_timer_interrupt();
|
||||
timer::set_next_trigger();
|
||||
task::run_first_task();
|
||||
|
|
|
@ -14,11 +14,12 @@ const SBI_SHUTDOWN: usize = 8;
|
|||
fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
|
||||
let mut ret;
|
||||
unsafe {
|
||||
llvm_asm!("ecall"
|
||||
: "={x10}" (ret)
|
||||
: "{x10}" (arg0), "{x11}" (arg1), "{x12}" (arg2), "{x17}" (which)
|
||||
: "memory"
|
||||
: "volatile"
|
||||
asm!(
|
||||
"ecall",
|
||||
inlateout("x10") arg0 => ret,
|
||||
in("x11") arg1,
|
||||
in("x12") arg2,
|
||||
in("x17") which,
|
||||
);
|
||||
}
|
||||
ret
|
||||
|
|
3
os/src/sync/mod.rs
Normal file
3
os/src/sync/mod.rs
Normal file
|
@ -0,0 +1,3 @@
|
|||
mod up;
|
||||
|
||||
pub use up::UPSafeCell;
|
27
os/src/sync/up.rs
Normal file
27
os/src/sync/up.rs
Normal file
|
@ -0,0 +1,27 @@
|
|||
use core::cell::{RefCell, RefMut};
|
||||
|
||||
/// Wrap a static data structure inside it so that we are
|
||||
/// able to access it without any `unsafe`.
|
||||
///
|
||||
/// We should only use it in uniprocessor.
|
||||
///
|
||||
/// In order to get mutable reference of inner data, call
|
||||
/// `exclusive_access`.
|
||||
pub struct UPSafeCell<T> {
|
||||
/// inner data
|
||||
inner: RefCell<T>,
|
||||
}
|
||||
|
||||
unsafe impl<T> Sync for UPSafeCell<T> {}
|
||||
|
||||
impl<T> UPSafeCell<T> {
|
||||
/// User is responsible to guarantee that inner struct is only used in
|
||||
/// uniprocessor.
|
||||
pub unsafe fn new(value: T) -> Self {
|
||||
Self { inner: RefCell::new(value) }
|
||||
}
|
||||
/// Panic if the data has been borrowed.
|
||||
pub fn exclusive_access(&self) -> RefMut<'_, T> {
|
||||
self.inner.borrow_mut()
|
||||
}
|
||||
}
|
|
@ -14,7 +14,7 @@ pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize {
|
|||
SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]),
|
||||
SYSCALL_EXIT => sys_exit(args[0] as i32),
|
||||
SYSCALL_YIELD => sys_yield(),
|
||||
SYSCALL_GET_TIME => sys_get_time(),
|
||||
SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal, args[1]),
|
||||
_ => panic!("Unsupported syscall_id: {}", syscall_id),
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2,10 +2,17 @@ use crate::task::{
|
|||
suspend_current_and_run_next,
|
||||
exit_current_and_run_next,
|
||||
};
|
||||
use crate::timer::get_time;
|
||||
use crate::timer::get_time_us;
|
||||
|
||||
pub fn sys_exit(xstate: i32) -> ! {
|
||||
println!("[kernel] Application exited with code {}", xstate);
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub struct TimeVal {
|
||||
pub sec: usize,
|
||||
pub usec: usize,
|
||||
}
|
||||
|
||||
pub fn sys_exit(exit_code: i32) -> ! {
|
||||
println!("[kernel] Application exited with code {}", exit_code);
|
||||
exit_current_and_run_next();
|
||||
panic!("Unreachable in sys_exit!");
|
||||
}
|
||||
|
@ -15,6 +22,17 @@ pub fn sys_yield() -> isize {
|
|||
0
|
||||
}
|
||||
|
||||
pub fn sys_get_time() -> isize {
|
||||
get_time() as isize
|
||||
// pub fn sys_get_time() -> isize {
|
||||
// get_time_ms() as isize
|
||||
// }
|
||||
|
||||
pub fn sys_get_time(ts: *mut TimeVal, _tz: usize) -> isize {
|
||||
let us = get_time_us();
|
||||
unsafe {
|
||||
*ts = TimeVal {
|
||||
sec: us / 1_000_000,
|
||||
usec: us % 1_000_000,
|
||||
};
|
||||
}
|
||||
0
|
||||
}
|
|
@ -1,14 +1,24 @@
|
|||
#[derive(Copy, Clone)]
|
||||
#[repr(C)]
|
||||
pub struct TaskContext {
|
||||
ra: usize,
|
||||
sp: usize,
|
||||
s: [usize; 12],
|
||||
}
|
||||
|
||||
impl TaskContext {
|
||||
pub fn goto_restore() -> Self {
|
||||
pub fn zero_init() -> Self {
|
||||
Self {
|
||||
ra: 0,
|
||||
sp: 0,
|
||||
s: [0; 12],
|
||||
}
|
||||
}
|
||||
pub fn goto_restore(kstack_ptr: usize) -> Self {
|
||||
extern "C" { fn __restore(); }
|
||||
Self {
|
||||
ra: __restore as usize,
|
||||
sp: kstack_ptr,
|
||||
s: [0; 12],
|
||||
}
|
||||
}
|
||||
|
|
|
@ -4,16 +4,16 @@ mod task;
|
|||
|
||||
use crate::config::MAX_APP_NUM;
|
||||
use crate::loader::{get_num_app, init_app_cx};
|
||||
use core::cell::RefCell;
|
||||
use lazy_static::*;
|
||||
use switch::__switch;
|
||||
use task::{TaskControlBlock, TaskStatus};
|
||||
use crate::sync::UPSafeCell;
|
||||
|
||||
pub use context::TaskContext;
|
||||
|
||||
pub struct TaskManager {
|
||||
num_app: usize,
|
||||
inner: RefCell<TaskManagerInner>,
|
||||
inner: UPSafeCell<TaskManagerInner>,
|
||||
}
|
||||
|
||||
struct TaskManagerInner {
|
||||
|
@ -21,55 +21,62 @@ struct TaskManagerInner {
|
|||
current_task: usize,
|
||||
}
|
||||
|
||||
unsafe impl Sync for TaskManager {}
|
||||
|
||||
lazy_static! {
|
||||
pub static ref TASK_MANAGER: TaskManager = {
|
||||
let num_app = get_num_app();
|
||||
let mut tasks = [
|
||||
TaskControlBlock { task_cx_ptr: 0, task_status: TaskStatus::UnInit };
|
||||
TaskControlBlock {
|
||||
task_cx: TaskContext::zero_init(),
|
||||
task_status: TaskStatus::UnInit
|
||||
};
|
||||
MAX_APP_NUM
|
||||
];
|
||||
for i in 0..num_app {
|
||||
tasks[i].task_cx_ptr = init_app_cx(i) as * const _ as usize;
|
||||
tasks[i].task_cx = TaskContext::goto_restore(init_app_cx(i));
|
||||
tasks[i].task_status = TaskStatus::Ready;
|
||||
}
|
||||
TaskManager {
|
||||
num_app,
|
||||
inner: RefCell::new(TaskManagerInner {
|
||||
inner: unsafe { UPSafeCell::new(TaskManagerInner {
|
||||
tasks,
|
||||
current_task: 0,
|
||||
}),
|
||||
})},
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl TaskManager {
|
||||
fn run_first_task(&self) {
|
||||
self.inner.borrow_mut().tasks[0].task_status = TaskStatus::Running;
|
||||
let next_task_cx = self.inner.borrow().tasks[0].get_task_cx_ptr2();
|
||||
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(
|
||||
&0usize as *const _,
|
||||
next_task_cx,
|
||||
&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.borrow_mut();
|
||||
let mut inner = self.inner.exclusive_access();
|
||||
let current = inner.current_task;
|
||||
inner.tasks[current].task_status = TaskStatus::Ready;
|
||||
}
|
||||
|
||||
fn mark_current_exited(&self) {
|
||||
let mut inner = self.inner.borrow_mut();
|
||||
let mut inner = self.inner.exclusive_access();
|
||||
let current = inner.current_task;
|
||||
inner.tasks[current].task_status = TaskStatus::Exited;
|
||||
}
|
||||
|
||||
fn find_next_task(&self) -> Option<usize> {
|
||||
let inner = self.inner.borrow();
|
||||
let inner = self.inner.exclusive_access();
|
||||
let current = inner.current_task;
|
||||
(current + 1..current + self.num_app + 1)
|
||||
.map(|id| id % self.num_app)
|
||||
|
@ -80,19 +87,21 @@ impl TaskManager {
|
|||
|
||||
fn run_next_task(&self) {
|
||||
if let Some(next) = self.find_next_task() {
|
||||
let mut inner = self.inner.borrow_mut();
|
||||
let mut inner = self.inner.exclusive_access();
|
||||
let current = inner.current_task;
|
||||
inner.tasks[next].task_status = TaskStatus::Running;
|
||||
inner.current_task = next;
|
||||
let current_task_cx = inner.tasks[current].get_task_cx_ptr2();
|
||||
let next_task_cx = inner.tasks[next].get_task_cx_ptr2();
|
||||
core::mem::drop(inner);
|
||||
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,
|
||||
next_task_cx,
|
||||
current_task_cx_ptr,
|
||||
next_task_cx_ptr,
|
||||
);
|
||||
}
|
||||
// go back to user mode
|
||||
} else {
|
||||
panic!("All applications completed!");
|
||||
}
|
||||
|
|
|
@ -1,34 +1,34 @@
|
|||
.altmacro
|
||||
.macro SAVE_SN n
|
||||
sd s\n, (\n+1)*8(sp)
|
||||
sd s\n, (\n+2)*8(a0)
|
||||
.endm
|
||||
.macro LOAD_SN n
|
||||
ld s\n, (\n+1)*8(sp)
|
||||
ld s\n, (\n+2)*8(a1)
|
||||
.endm
|
||||
.section .text
|
||||
.globl __switch
|
||||
__switch:
|
||||
# __switch(current_task_cx: &*const TaskContext, next_task_cx: &*const TaskContext)
|
||||
# push TaskContext to current sp and save its address to where a0 points to
|
||||
addi sp, sp, -13*8
|
||||
sd sp, 0(a0)
|
||||
# fill TaskContext with ra & s0-s11
|
||||
sd ra, 0(sp)
|
||||
# __switch(
|
||||
# current_task_cx_ptr: *mut TaskContext,
|
||||
# next_task_cx_ptr: *const TaskContext
|
||||
# )
|
||||
# save kernel stack of current task
|
||||
sd sp, 8(a0)
|
||||
# save ra & s0~s11 of current execution
|
||||
sd ra, 0(a0)
|
||||
.set n, 0
|
||||
.rept 12
|
||||
SAVE_SN %n
|
||||
.set n, n + 1
|
||||
.endr
|
||||
# ready for loading TaskContext a1 points to
|
||||
ld sp, 0(a1)
|
||||
# load registers in the TaskContext
|
||||
ld ra, 0(sp)
|
||||
# restore ra & s0~s11 of next execution
|
||||
ld ra, 0(a1)
|
||||
.set n, 0
|
||||
.rept 12
|
||||
LOAD_SN %n
|
||||
.set n, n + 1
|
||||
.endr
|
||||
# pop TaskContext
|
||||
addi sp, sp, 13*8
|
||||
# restore kernel stack of next task
|
||||
ld sp, 8(a1)
|
||||
ret
|
||||
|
||||
|
|
|
@ -1,5 +1,10 @@
|
|||
global_asm!(include_str!("switch.S"));
|
||||
|
||||
use super::TaskContext;
|
||||
|
||||
extern "C" {
|
||||
pub fn __switch(current_task_cx: *const usize, next_task_cx: *const usize);
|
||||
pub fn __switch(
|
||||
current_task_cx_ptr: *mut TaskContext,
|
||||
next_task_cx_ptr: *const TaskContext
|
||||
);
|
||||
}
|
||||
|
|
|
@ -1,12 +1,9 @@
|
|||
pub struct TaskControlBlock {
|
||||
pub task_cx_ptr: usize,
|
||||
pub task_status: TaskStatus,
|
||||
}
|
||||
use super::TaskContext;
|
||||
|
||||
impl TaskControlBlock {
|
||||
pub fn get_task_cx_ptr2(&self) -> *const usize {
|
||||
&self.task_cx_ptr as *const usize
|
||||
}
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct TaskControlBlock {
|
||||
pub task_status: TaskStatus,
|
||||
pub task_cx: TaskContext,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
|
|
@ -1,13 +1,18 @@
|
|||
use riscv::register::time;
|
||||
use crate::config::CLOCK_FREQ;
|
||||
use crate::sbi::set_timer;
|
||||
use crate::config::CPU_FREQ;
|
||||
use riscv::register::time;
|
||||
|
||||
const TICKS_PER_SEC: usize = 100;
|
||||
const MICRO_PER_SEC: usize = 1_000_000;
|
||||
|
||||
pub fn get_time() -> usize {
|
||||
time::read()
|
||||
}
|
||||
|
||||
pub fn set_next_trigger() {
|
||||
set_timer(get_time() + CPU_FREQ / TICKS_PER_SEC);
|
||||
pub fn get_time_us() -> usize {
|
||||
time::read() / (CLOCK_FREQ / MICRO_PER_SEC)
|
||||
}
|
||||
|
||||
pub fn set_next_trigger() {
|
||||
set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
|
||||
}
|
|
@ -10,7 +10,6 @@ use riscv::register::{
|
|||
Interrupt,
|
||||
},
|
||||
stval,
|
||||
sstatus,
|
||||
sie,
|
||||
};
|
||||
use crate::syscall::syscall;
|
||||
|
@ -29,10 +28,6 @@ pub fn init() {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn enable_interrupt() {
|
||||
unsafe { sstatus::set_sie(); }
|
||||
}
|
||||
|
||||
pub fn enable_timer_interrupt() {
|
||||
unsafe { sie::set_stimer(); }
|
||||
}
|
||||
|
|
|
@ -1 +1 @@
|
|||
nightly-2020-11-01
|
||||
nightly-2021-10-15
|
||||
|
|
1452
tools/kflash.py
1452
tools/kflash.py
File diff suppressed because one or more lines are too long
5
user/Cargo.lock
generated
5
user/Cargo.lock
generated
|
@ -1,5 +0,0 @@
|
|||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
[[package]]
|
||||
name = "user_lib"
|
||||
version = "0.1.0"
|
|
@ -7,3 +7,7 @@ edition = "2018"
|
|||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
buddy_system_allocator = "0.6"
|
||||
bitflags = "1.2.1"
|
||||
spin = "0.9"
|
||||
lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
|
||||
|
|
|
@ -1,23 +1,40 @@
|
|||
TARGET := riscv64gc-unknown-none-elf
|
||||
MODE := debug
|
||||
MODE := release
|
||||
APP_DIR := src/bin
|
||||
TARGET_DIR := target/$(TARGET)/$(MODE)
|
||||
APPS := $(wildcard $(APP_DIR)/*.rs)
|
||||
ELFS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%, $(APPS))
|
||||
BINS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%.bin, $(APPS))
|
||||
|
||||
BUILD_DIR := build
|
||||
OBJDUMP := rust-objdump --arch-name=riscv64
|
||||
OBJCOPY := rust-objcopy --binary-architecture=riscv64
|
||||
PY := python3
|
||||
|
||||
TEST ?= 0
|
||||
ifeq ($(TEST), 0)
|
||||
APPS := $(filter-out $(wildcard $(APP_DIR)/test*.rs), $(wildcard $(APP_DIR)/*.rs))
|
||||
else
|
||||
APPS := $(wildcard $(APP_DIR)/test$(TEST)*.rs)
|
||||
endif
|
||||
ELFS := $(patsubst $(APP_DIR)/%.rs, $(TARGET_DIR)/%, $(APPS))
|
||||
|
||||
elf: $(APPS)
|
||||
@python3 build.py
|
||||
|
||||
binary: elf
|
||||
$(foreach elf, $(ELFS), $(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf));)
|
||||
@$(foreach elf, $(ELFS), \
|
||||
$(OBJCOPY) $(elf) --strip-all -O binary $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.bin, $(elf)); \
|
||||
cp $(elf) $(patsubst $(TARGET_DIR)/%, $(TARGET_DIR)/%.elf, $(elf));)
|
||||
|
||||
build: binary
|
||||
pre:
|
||||
@mkdir -p $(BUILD_DIR)/bin/
|
||||
@mkdir -p $(BUILD_DIR)/elf/
|
||||
@mkdir -p $(BUILD_DIR)/app/
|
||||
@$(foreach t, $(APPS), cp $(t) $(BUILD_DIR)/app/;)
|
||||
|
||||
build: clean pre binary
|
||||
@$(foreach t, $(ELFS), cp $(t).bin $(BUILD_DIR)/bin/;)
|
||||
@$(foreach t, $(ELFS), cp $(t).elf $(BUILD_DIR)/elf/;)
|
||||
|
||||
clean:
|
||||
@cargo clean
|
||||
@rm -rf $(BUILD_DIR)
|
||||
|
||||
.PHONY: elf binary build clean
|
|
@ -1,11 +1,11 @@
|
|||
import os
|
||||
|
||||
base_address = 0x80100000
|
||||
base_address = 0x80400000
|
||||
step = 0x20000
|
||||
linker = 'src/linker.ld'
|
||||
|
||||
app_id = 0
|
||||
apps = os.listdir('src/bin')
|
||||
apps = os.listdir('build/app')
|
||||
apps.sort()
|
||||
for app in apps:
|
||||
app = app[:app.find('.')]
|
||||
|
@ -18,7 +18,7 @@ for app in apps:
|
|||
lines.append(line)
|
||||
with open(linker, 'w+') as f:
|
||||
f.writelines(lines)
|
||||
os.system('cargo build --bin %s' % app)
|
||||
os.system('cargo build --bin %s --release' % app)
|
||||
print('[build.py] application %s start with address %s' %(app, hex(base_address+step*app_id)))
|
||||
with open(linker, 'w+') as f:
|
||||
f.writelines(lines_before)
|
||||
|
|
|
@ -1,18 +0,0 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::{sys_get_time, sys_yield};
|
||||
|
||||
#[no_mangle]
|
||||
fn main() -> i32 {
|
||||
let current_timer = sys_get_time();
|
||||
let wait_for = current_timer + 10000000;
|
||||
while sys_get_time() < wait_for {
|
||||
sys_yield();
|
||||
}
|
||||
println!("Test sleep OK!");
|
||||
0
|
||||
}
|
|
@ -10,7 +10,7 @@ const LEN: usize = 100;
|
|||
fn main() -> i32 {
|
||||
let p = 3u64;
|
||||
let m = 998244353u64;
|
||||
let iter: usize = 100000;
|
||||
let iter: usize = 200000;
|
||||
let mut s = [0u64; LEN];
|
||||
let mut cur = 0usize;
|
||||
s[cur] = 1;
|
||||
|
@ -22,7 +22,7 @@ fn main() -> i32 {
|
|||
println!("power_3 [{}/{}]", i, iter);
|
||||
}
|
||||
}
|
||||
println!("{}^{} = {}", p, iter, s[cur]);
|
||||
println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
|
||||
println!("Test power_3 OK!");
|
||||
0
|
||||
}
|
|
@ -10,7 +10,7 @@ const LEN: usize = 100;
|
|||
fn main() -> i32 {
|
||||
let p = 5u64;
|
||||
let m = 998244353u64;
|
||||
let iter: usize = 70000;
|
||||
let iter: usize = 140000;
|
||||
let mut s = [0u64; LEN];
|
||||
let mut cur = 0usize;
|
||||
s[cur] = 1;
|
||||
|
@ -22,7 +22,7 @@ fn main() -> i32 {
|
|||
println!("power_5 [{}/{}]", i, iter);
|
||||
}
|
||||
}
|
||||
println!("{}^{} = {}", p, iter, s[cur]);
|
||||
println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
|
||||
println!("Test power_5 OK!");
|
||||
0
|
||||
}
|
|
@ -10,7 +10,7 @@ const LEN: usize = 100;
|
|||
fn main() -> i32 {
|
||||
let p = 7u64;
|
||||
let m = 998244353u64;
|
||||
let iter: usize = 80000;
|
||||
let iter: usize = 160000;
|
||||
let mut s = [0u64; LEN];
|
||||
let mut cur = 0usize;
|
||||
s[cur] = 1;
|
||||
|
@ -22,7 +22,7 @@ fn main() -> i32 {
|
|||
println!("power_7 [{}/{}]", i, iter);
|
||||
}
|
||||
}
|
||||
println!("{}^{} = {}", p, iter, s[cur]);
|
||||
println!("{}^{} = {}(MOD {})", p, iter, s[cur], m);
|
||||
println!("Test power_7 OK!");
|
||||
0
|
||||
}
|
24
user/src/bin/sleep.rs
Normal file
24
user/src/bin/sleep.rs
Normal file
|
@ -0,0 +1,24 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::{get_time, yield_};
|
||||
|
||||
/// 正确输出:(无报错信息)
|
||||
/// get_time OK! {...}
|
||||
/// Test sleep OK!
|
||||
|
||||
#[no_mangle]
|
||||
fn main() -> i32 {
|
||||
let current_time = get_time();
|
||||
assert!(current_time > 0);
|
||||
println!("get_time OK! {}", current_time);
|
||||
let wait_for = current_time + 3000;
|
||||
while get_time() < wait_for {
|
||||
yield_();
|
||||
}
|
||||
println!("Test sleep OK!");
|
||||
0
|
||||
}
|
22
user/src/bin/sleep1.rs
Normal file
22
user/src/bin/sleep1.rs
Normal file
|
@ -0,0 +1,22 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::{get_time, sleep};
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> i32 {
|
||||
let start = get_time();
|
||||
println!("current time_msec = {}", start);
|
||||
sleep(100);
|
||||
let end = get_time();
|
||||
println!(
|
||||
"time_msec = {} after sleeping 100 ticks, delta = {}ms!",
|
||||
end,
|
||||
end - start
|
||||
);
|
||||
println!("Test sleep1 passed!");
|
||||
0
|
||||
}
|
53
user/src/bin/test1_write0.rs
Normal file
53
user/src/bin/test1_write0.rs
Normal file
|
@ -0,0 +1,53 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
#![feature(asm)]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
extern crate core;
|
||||
use core::slice;
|
||||
use user_lib::{write, STDOUT};
|
||||
|
||||
/// 正确输出:
|
||||
/// Test write0 OK!
|
||||
|
||||
const STACK_SIZE: usize = 0x1000;
|
||||
|
||||
unsafe fn r_sp() -> usize {
|
||||
let mut sp: usize;
|
||||
asm!("mv {}, sp", out(reg) sp);
|
||||
sp
|
||||
}
|
||||
|
||||
unsafe fn stack_range() -> (usize, usize) {
|
||||
let sp = r_sp();
|
||||
let top = (sp + STACK_SIZE - 1) & (!(STACK_SIZE - 1));
|
||||
(top - STACK_SIZE, top)
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> i32 {
|
||||
assert_eq!(
|
||||
write(STDOUT, unsafe {
|
||||
#[allow(clippy::zero_ptr)]
|
||||
slice::from_raw_parts(0x0 as *const _, 10)
|
||||
}),
|
||||
-1
|
||||
);
|
||||
let (bottom, top) = unsafe { stack_range() };
|
||||
assert_eq!(
|
||||
write(STDOUT, unsafe {
|
||||
slice::from_raw_parts((top - 5) as *const _, 10)
|
||||
}),
|
||||
-1
|
||||
);
|
||||
assert_eq!(
|
||||
write(STDOUT, unsafe {
|
||||
slice::from_raw_parts((bottom - 5) as *const _, 10)
|
||||
}),
|
||||
-1
|
||||
);
|
||||
// TODO: test string located in .data section
|
||||
println!("Test write0 OK!");
|
||||
0
|
||||
}
|
31
user/src/bin/test1_write1.rs
Normal file
31
user/src/bin/test1_write1.rs
Normal file
|
@ -0,0 +1,31 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{write, STDOUT};
|
||||
const DATA_STRING: &str = "string from data section\n";
|
||||
|
||||
/// 正确输出:
|
||||
/// string from data section
|
||||
/// strinstring from stack section
|
||||
/// strin
|
||||
/// Test write1 OK!
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> i32 {
|
||||
assert_eq!(write(1234, DATA_STRING.as_bytes()), -1);
|
||||
assert_eq!(
|
||||
write(STDOUT, DATA_STRING.as_bytes()),
|
||||
DATA_STRING.len() as isize
|
||||
);
|
||||
assert_eq!(write(STDOUT, &DATA_STRING.as_bytes()[..5]), 5);
|
||||
let stack_string = "string from stack section\n";
|
||||
assert_eq!(
|
||||
write(STDOUT, stack_string.as_bytes()),
|
||||
stack_string.len() as isize
|
||||
);
|
||||
assert_eq!(write(STDOUT, &stack_string.as_bytes()[..5]), 5);
|
||||
println!("\nTest write1 OK!");
|
||||
0
|
||||
}
|
20
user/src/bin/test2_setprio.rs
Normal file
20
user/src/bin/test2_setprio.rs
Normal file
|
@ -0,0 +1,20 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::set_priority;
|
||||
|
||||
/// 正确输出:(无报错信息)
|
||||
/// Test set_priority OK!
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> i32 {
|
||||
assert_eq!(set_priority(10), 10);
|
||||
assert_eq!(set_priority(isize::MAX), isize::MAX);
|
||||
assert_eq!(set_priority(0), -1);
|
||||
assert_eq!(set_priority(1), -1);
|
||||
assert_eq!(set_priority(-10), -1);
|
||||
println!("Test set_priority OK!");
|
||||
0
|
||||
}
|
43
user/src/bin/test3_stride0.rs
Normal file
43
user/src/bin/test3_stride0.rs
Normal file
|
@ -0,0 +1,43 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{get_time, set_priority};
|
||||
|
||||
/*
|
||||
理想结果:6个进程退出时,输出 count 基本正比于 priority
|
||||
*/
|
||||
|
||||
fn spin_delay() {
|
||||
let mut j = true;
|
||||
for _ in 0..10 {
|
||||
j = !j;
|
||||
}
|
||||
}
|
||||
|
||||
// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
|
||||
const MAX_TIME: isize = 1000;
|
||||
pub fn count_during(prio: isize) -> isize {
|
||||
let start_time = get_time();
|
||||
let mut acc = 0;
|
||||
set_priority(prio);
|
||||
loop {
|
||||
spin_delay();
|
||||
acc += 1;
|
||||
if acc % 400 == 0 {
|
||||
let time = get_time() - start_time;
|
||||
if time > MAX_TIME {
|
||||
return acc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> usize {
|
||||
let prio = 5;
|
||||
let count = count_during(prio);
|
||||
println!("priority = {}, exitcode = {}", prio, count);
|
||||
0
|
||||
}
|
39
user/src/bin/test3_stride1.rs
Normal file
39
user/src/bin/test3_stride1.rs
Normal file
|
@ -0,0 +1,39 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{get_time, set_priority};
|
||||
|
||||
fn spin_delay() {
|
||||
let mut j = true;
|
||||
for _ in 0..10 {
|
||||
j = !j;
|
||||
}
|
||||
}
|
||||
|
||||
// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
|
||||
const MAX_TIME: isize = 1000;
|
||||
fn count_during(prio: isize) -> isize {
|
||||
let start_time = get_time();
|
||||
let mut acc = 0;
|
||||
set_priority(prio);
|
||||
loop {
|
||||
spin_delay();
|
||||
acc += 1;
|
||||
if acc % 400 == 0 {
|
||||
let time = get_time() - start_time;
|
||||
if time > MAX_TIME {
|
||||
return acc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> usize {
|
||||
let prio = 6;
|
||||
let count = count_during(prio);
|
||||
println!("priority = {}, exitcode = {}", prio, count);
|
||||
0
|
||||
}
|
39
user/src/bin/test3_stride2.rs
Normal file
39
user/src/bin/test3_stride2.rs
Normal file
|
@ -0,0 +1,39 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{get_time, set_priority};
|
||||
|
||||
fn spin_delay() {
|
||||
let mut j = true;
|
||||
for _ in 0..10 {
|
||||
j = !j;
|
||||
}
|
||||
}
|
||||
|
||||
// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
|
||||
const MAX_TIME: isize = 1000;
|
||||
fn count_during(prio: isize) -> isize {
|
||||
let start_time = get_time();
|
||||
let mut acc = 0;
|
||||
set_priority(prio);
|
||||
loop {
|
||||
spin_delay();
|
||||
acc += 1;
|
||||
if acc % 400 == 0 {
|
||||
let time = get_time() - start_time;
|
||||
if time > MAX_TIME {
|
||||
return acc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> usize {
|
||||
let prio = 7;
|
||||
let count = count_during(prio);
|
||||
println!("priority = {}, exitcode = {}", prio, count);
|
||||
0
|
||||
}
|
39
user/src/bin/test3_stride3.rs
Normal file
39
user/src/bin/test3_stride3.rs
Normal file
|
@ -0,0 +1,39 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{get_time, set_priority};
|
||||
|
||||
fn spin_delay() {
|
||||
let mut j = true;
|
||||
for _ in 0..10 {
|
||||
j = !j;
|
||||
}
|
||||
}
|
||||
|
||||
// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
|
||||
const MAX_TIME: isize = 1000;
|
||||
fn count_during(prio: isize) -> isize {
|
||||
let start_time = get_time();
|
||||
let mut acc = 0;
|
||||
set_priority(prio);
|
||||
loop {
|
||||
spin_delay();
|
||||
acc += 1;
|
||||
if acc % 400 == 0 {
|
||||
let time = get_time() - start_time;
|
||||
if time > MAX_TIME {
|
||||
return acc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> usize {
|
||||
let prio = 8;
|
||||
let count = count_during(prio);
|
||||
println!("priority = {}, exitcode = {}", prio, count);
|
||||
0
|
||||
}
|
39
user/src/bin/test3_stride4.rs
Normal file
39
user/src/bin/test3_stride4.rs
Normal file
|
@ -0,0 +1,39 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{get_time, set_priority};
|
||||
|
||||
fn spin_delay() {
|
||||
let mut j = true;
|
||||
for _ in 0..10 {
|
||||
j = !j;
|
||||
}
|
||||
}
|
||||
|
||||
// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
|
||||
const MAX_TIME: isize = 1000;
|
||||
fn count_during(prio: isize) -> isize {
|
||||
let start_time = get_time();
|
||||
let mut acc = 0;
|
||||
set_priority(prio);
|
||||
loop {
|
||||
spin_delay();
|
||||
acc += 1;
|
||||
if acc % 400 == 0 {
|
||||
let time = get_time() - start_time;
|
||||
if time > MAX_TIME {
|
||||
return acc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> usize {
|
||||
let prio = 9;
|
||||
let count = count_during(prio);
|
||||
println!("priority = {}, exitcode = {}", prio, count);
|
||||
0
|
||||
}
|
39
user/src/bin/test3_stride5.rs
Normal file
39
user/src/bin/test3_stride5.rs
Normal file
|
@ -0,0 +1,39 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
use user_lib::{get_time, set_priority};
|
||||
|
||||
fn spin_delay() {
|
||||
let mut j = true;
|
||||
for _ in 0..10 {
|
||||
j = !j;
|
||||
}
|
||||
}
|
||||
|
||||
// to get enough accuracy, MAX_TIME (the running time of each process) should > 1000 mseconds.
|
||||
const MAX_TIME: isize = 1000;
|
||||
fn count_during(prio: isize) -> isize {
|
||||
let start_time = get_time();
|
||||
let mut acc = 0;
|
||||
set_priority(prio);
|
||||
loop {
|
||||
spin_delay();
|
||||
acc += 1;
|
||||
if acc % 400 == 0 {
|
||||
let time = get_time() - start_time;
|
||||
if time > MAX_TIME {
|
||||
return acc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn main() -> usize {
|
||||
let prio = 10;
|
||||
let count = count_during(prio);
|
||||
println!("priority = {}, exitcode = {}", prio, count);
|
||||
0
|
||||
}
|
30
user/src/bin/yield0.rs
Normal file
30
user/src/bin/yield0.rs
Normal file
|
@ -0,0 +1,30 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::yield_;
|
||||
|
||||
const WIDTH: usize = 10;
|
||||
const HEIGHT: usize = 5;
|
||||
|
||||
/*
|
||||
理想结果:三个程序交替输出 ABC
|
||||
*/
|
||||
|
||||
#[no_mangle]
|
||||
fn main() -> i32 {
|
||||
for i in 0..HEIGHT {
|
||||
let buf = ['A' as u8; WIDTH];
|
||||
println!(
|
||||
"{} [{}/{}]",
|
||||
core::str::from_utf8(&buf).unwrap(),
|
||||
i + 1,
|
||||
HEIGHT
|
||||
);
|
||||
yield_();
|
||||
}
|
||||
println!("Test write A OK!");
|
||||
0
|
||||
}
|
31
user/src/bin/yield1.rs
Normal file
31
user/src/bin/yield1.rs
Normal file
|
@ -0,0 +1,31 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::yield_;
|
||||
|
||||
const WIDTH: usize = 10;
|
||||
const HEIGHT: usize = 5;
|
||||
|
||||
/*
|
||||
理想结果:三个程序交替输出 ABC
|
||||
*/
|
||||
|
||||
#[no_mangle]
|
||||
#[no_mangle]
|
||||
fn main() -> i32 {
|
||||
for i in 0..HEIGHT {
|
||||
let buf = ['B' as u8; WIDTH];
|
||||
println!(
|
||||
"{} [{}/{}]",
|
||||
core::str::from_utf8(&buf).unwrap(),
|
||||
i + 1,
|
||||
HEIGHT
|
||||
);
|
||||
yield_();
|
||||
}
|
||||
println!("Test write B OK!");
|
||||
0
|
||||
}
|
31
user/src/bin/yield2.rs
Normal file
31
user/src/bin/yield2.rs
Normal file
|
@ -0,0 +1,31 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
|
||||
#[macro_use]
|
||||
extern crate user_lib;
|
||||
|
||||
use user_lib::yield_;
|
||||
|
||||
/*
|
||||
理想结果:三个程序交替输出 ABC
|
||||
*/
|
||||
|
||||
const WIDTH: usize = 10;
|
||||
const HEIGHT: usize = 5;
|
||||
|
||||
#[no_mangle]
|
||||
#[no_mangle]
|
||||
fn main() -> i32 {
|
||||
for i in 0..HEIGHT {
|
||||
let buf = ['C' as u8; WIDTH];
|
||||
println!(
|
||||
"{} [{}/{}]",
|
||||
core::str::from_utf8(&buf).unwrap(),
|
||||
i + 1,
|
||||
HEIGHT
|
||||
);
|
||||
yield_();
|
||||
}
|
||||
println!("Test write C OK!");
|
||||
0
|
||||
}
|
|
@ -1,17 +1,52 @@
|
|||
use alloc::collections::vec_deque::VecDeque;
|
||||
use alloc::sync::Arc;
|
||||
use core::fmt::{self, Write};
|
||||
use crate::syscall::{STDOUT, sys_write};
|
||||
use spin::mutex::Mutex;
|
||||
|
||||
struct Stdout;
|
||||
pub const STDIN: usize = 0;
|
||||
pub const STDOUT: usize = 1;
|
||||
|
||||
impl Write for Stdout {
|
||||
const CONSOLE_BUFFER_SIZE: usize = 256 * 10;
|
||||
|
||||
use super::{read, write};
|
||||
use lazy_static::*;
|
||||
|
||||
struct ConsoleBuffer(VecDeque<u8>);
|
||||
|
||||
lazy_static! {
|
||||
static ref CONSOLE_BUFFER: Arc<Mutex<ConsoleBuffer>> = {
|
||||
let buffer = VecDeque::<u8>::with_capacity(CONSOLE_BUFFER_SIZE);
|
||||
Arc::new(Mutex::new(ConsoleBuffer(buffer)))
|
||||
};
|
||||
}
|
||||
|
||||
impl ConsoleBuffer {
|
||||
fn flush(&mut self) -> isize {
|
||||
let s: &[u8] = self.0.make_contiguous();
|
||||
let ret = write(STDOUT, s);
|
||||
self.0.clear();
|
||||
ret
|
||||
}
|
||||
}
|
||||
|
||||
impl Write for ConsoleBuffer {
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
sys_write(STDOUT, s.as_bytes());
|
||||
for c in s.as_bytes().iter() {
|
||||
self.0.push_back(*c);
|
||||
if (*c == b'\n' || self.0.len() == CONSOLE_BUFFER_SIZE) && -1 == self.flush() {
|
||||
return Err(fmt::Error);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unused)]
|
||||
pub fn print(args: fmt::Arguments) {
|
||||
Stdout.write_fmt(args).unwrap();
|
||||
let mut buf = CONSOLE_BUFFER.lock();
|
||||
// buf.write_fmt(args).unwrap();
|
||||
// BUG FIX: 关闭 stdout 后,本函数不能触发 panic,否则会造成死锁
|
||||
buf.write_fmt(args);
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
|
@ -27,3 +62,14 @@ macro_rules! println {
|
|||
$crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn getchar() -> u8 {
|
||||
let mut c = [0u8; 1];
|
||||
read(STDIN, &mut c);
|
||||
c[0]
|
||||
}
|
||||
|
||||
pub fn flush() {
|
||||
let mut buf = CONSOLE_BUFFER.lock();
|
||||
buf.flush();
|
||||
}
|
||||
|
|
|
@ -1,10 +1,17 @@
|
|||
use crate::exit;
|
||||
|
||||
#[panic_handler]
|
||||
fn panic_handler(panic_info: &core::panic::PanicInfo) -> ! {
|
||||
let err = panic_info.message().unwrap();
|
||||
if let Some(location) = panic_info.location() {
|
||||
println!("Panicked at {}:{}, {}", location.file(), location.line(), err);
|
||||
println!(
|
||||
"Panicked at {}:{}, {}",
|
||||
location.file(),
|
||||
location.line(),
|
||||
err
|
||||
);
|
||||
} else {
|
||||
println!("Panicked: {}", err);
|
||||
}
|
||||
loop {}
|
||||
exit(-1);
|
||||
}
|
230
user/src/lib.rs
230
user/src/lib.rs
|
@ -1,19 +1,43 @@
|
|||
#![no_std]
|
||||
#![feature(llvm_asm)]
|
||||
#![feature(asm)]
|
||||
#![feature(linkage)]
|
||||
#![feature(panic_info_message)]
|
||||
#![feature(alloc_error_handler)]
|
||||
|
||||
#[macro_use]
|
||||
pub mod console;
|
||||
mod syscall;
|
||||
mod lang_items;
|
||||
mod syscall;
|
||||
|
||||
extern crate alloc;
|
||||
extern crate core;
|
||||
#[macro_use]
|
||||
extern crate bitflags;
|
||||
|
||||
use buddy_system_allocator::LockedHeap;
|
||||
pub use console::{flush, STDIN, STDOUT};
|
||||
pub use syscall::*;
|
||||
|
||||
const USER_HEAP_SIZE: usize = 16384;
|
||||
|
||||
static mut HEAP_SPACE: [u8; USER_HEAP_SIZE] = [0; USER_HEAP_SIZE];
|
||||
|
||||
#[global_allocator]
|
||||
static HEAP: LockedHeap = LockedHeap::empty();
|
||||
|
||||
#[alloc_error_handler]
|
||||
pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! {
|
||||
panic!("Heap allocation error, layout = {:?}", layout);
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[link_section = ".text.entry"]
|
||||
pub extern "C" fn _start() -> ! {
|
||||
clear_bss();
|
||||
syscall::sys_exit(main());
|
||||
panic!("unreachable after sys_exit!");
|
||||
unsafe {
|
||||
HEAP.lock()
|
||||
.init(HEAP_SPACE.as_ptr() as usize, USER_HEAP_SIZE);
|
||||
}
|
||||
exit(main());
|
||||
}
|
||||
|
||||
#[linkage = "weak"]
|
||||
|
@ -22,14 +46,194 @@ fn main() -> i32 {
|
|||
panic!("Cannot find main!");
|
||||
}
|
||||
|
||||
fn clear_bss() {
|
||||
extern "C" {
|
||||
fn start_bss();
|
||||
fn end_bss();
|
||||
bitflags! {
|
||||
pub struct OpenFlags: u32 {
|
||||
const RDONLY = 0;
|
||||
const WRONLY = 1 << 0;
|
||||
const RDWR = 1 << 1;
|
||||
const CREATE = 1 << 9;
|
||||
const TRUNC = 1 << 10;
|
||||
}
|
||||
(start_bss as usize..end_bss as usize).for_each(|addr| {
|
||||
unsafe { (addr as *mut u8).write_volatile(0); }
|
||||
});
|
||||
}
|
||||
|
||||
pub use syscall::*;
|
||||
#[repr(C)]
|
||||
#[derive(Debug, Default)]
|
||||
pub struct TimeVal {
|
||||
pub sec: usize,
|
||||
pub usec: usize,
|
||||
}
|
||||
|
||||
impl TimeVal {
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub struct Stat {
|
||||
/// ID of device containing file
|
||||
pub dev: u64,
|
||||
/// inode number
|
||||
pub ino: u64,
|
||||
/// file type and mode
|
||||
pub mode: StatMode,
|
||||
/// number of hard links
|
||||
pub nlink: u32,
|
||||
/// unused pad
|
||||
pad: [u64; 7],
|
||||
}
|
||||
|
||||
impl Stat {
|
||||
pub fn new() -> Self {
|
||||
Stat {
|
||||
dev: 0,
|
||||
ino: 0,
|
||||
mode: StatMode::NULL,
|
||||
nlink: 0,
|
||||
pad: [0; 7],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Stat {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
pub struct StatMode: u32 {
|
||||
const NULL = 0;
|
||||
/// directory
|
||||
const DIR = 0o040000;
|
||||
/// ordinary regular file
|
||||
const FILE = 0o100000;
|
||||
}
|
||||
}
|
||||
|
||||
const AT_FDCWD: isize = -100;
|
||||
|
||||
pub fn open(path: &str, flags: OpenFlags) -> isize {
|
||||
sys_openat(AT_FDCWD as usize, path, flags.bits, OpenFlags::RDWR.bits)
|
||||
}
|
||||
|
||||
pub fn close(fd: usize) -> isize {
|
||||
if fd == STDOUT {
|
||||
console::flush();
|
||||
}
|
||||
sys_close(fd)
|
||||
}
|
||||
|
||||
pub fn read(fd: usize, buf: &mut [u8]) -> isize {
|
||||
sys_read(fd, buf)
|
||||
}
|
||||
|
||||
pub fn write(fd: usize, buf: &[u8]) -> isize {
|
||||
sys_write(fd, buf)
|
||||
}
|
||||
|
||||
pub fn link(old_path: &str, new_path: &str) -> isize {
|
||||
sys_linkat(AT_FDCWD as usize, old_path, AT_FDCWD as usize, new_path, 0)
|
||||
}
|
||||
|
||||
pub fn unlink(path: &str) -> isize {
|
||||
sys_unlinkat(AT_FDCWD as usize, path, 0)
|
||||
}
|
||||
|
||||
pub fn fstat(fd: usize, st: &Stat) -> isize {
|
||||
sys_fstat(fd, st)
|
||||
}
|
||||
|
||||
pub fn mail_read(buf: &mut [u8]) -> isize {
|
||||
sys_mail_read(buf)
|
||||
}
|
||||
|
||||
pub fn mail_write(pid: usize, buf: &[u8]) -> isize {
|
||||
sys_mail_write(pid, buf)
|
||||
}
|
||||
|
||||
pub fn exit(exit_code: i32) -> ! {
|
||||
console::flush();
|
||||
sys_exit(exit_code);
|
||||
}
|
||||
|
||||
pub fn yield_() -> isize {
|
||||
sys_yield()
|
||||
}
|
||||
|
||||
pub fn get_time() -> isize {
|
||||
let time = TimeVal::new();
|
||||
match sys_get_time(&time, 0) {
|
||||
0 => ((time.sec & 0xffff) * 1000 + time.usec / 1000) as isize,
|
||||
_ => -1,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn getpid() -> isize {
|
||||
sys_getpid()
|
||||
}
|
||||
|
||||
pub fn fork() -> isize {
|
||||
sys_fork()
|
||||
}
|
||||
|
||||
pub fn exec(path: &str) -> isize {
|
||||
sys_exec(path)
|
||||
}
|
||||
|
||||
pub fn set_priority(prio: isize) -> isize {
|
||||
sys_set_priority(prio)
|
||||
}
|
||||
|
||||
pub fn wait(exit_code: &mut i32) -> isize {
|
||||
loop {
|
||||
match sys_waitpid(-1, exit_code as *mut _) {
|
||||
-2 => {
|
||||
sys_yield();
|
||||
}
|
||||
n => {
|
||||
return n;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn waitpid(pid: usize, exit_code: &mut i32) -> isize {
|
||||
loop {
|
||||
match sys_waitpid(pid as isize, exit_code as *mut _) {
|
||||
-2 => {
|
||||
sys_yield();
|
||||
}
|
||||
n => {
|
||||
return n;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn sleep(period_ms: usize) {
|
||||
let start = get_time();
|
||||
while get_time() < start + period_ms as isize {
|
||||
sys_yield();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn mmap(start: usize, len: usize, prot: usize) -> isize {
|
||||
sys_mmap(start, len, prot)
|
||||
}
|
||||
|
||||
pub fn munmap(start: usize, len: usize) -> isize {
|
||||
sys_munmap(start, len)
|
||||
}
|
||||
|
||||
pub fn spawn(path: &str) -> isize {
|
||||
sys_spawn(path)
|
||||
}
|
||||
|
||||
pub fn dup(fd: usize) -> isize {
|
||||
sys_dup(fd)
|
||||
}
|
||||
pub fn pipe(pipe_fd: &mut [usize]) -> isize {
|
||||
sys_pipe(pipe_fd)
|
||||
}
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
OUTPUT_ARCH(riscv)
|
||||
ENTRY(_start)
|
||||
|
||||
BASE_ADDRESS = 0x80100000;
|
||||
BASE_ADDRESS = 0x80400000;
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
|
@ -13,13 +13,16 @@ SECTIONS
|
|||
}
|
||||
.rodata : {
|
||||
*(.rodata .rodata.*)
|
||||
*(.srodata .srodata.*)
|
||||
}
|
||||
.data : {
|
||||
*(.data .data.*)
|
||||
*(.sdata .sdata.*)
|
||||
}
|
||||
.bss : {
|
||||
start_bss = .;
|
||||
*(.bss .bss.*)
|
||||
*(.sbss .sbss.*)
|
||||
end_bss = .;
|
||||
}
|
||||
/DISCARD/ : {
|
||||
|
|
|
@ -1,35 +1,179 @@
|
|||
pub const STDOUT: usize = 1;
|
||||
use super::{Stat, TimeVal};
|
||||
|
||||
const SYSCALL_WRITE: usize = 64;
|
||||
const SYSCALL_EXIT: usize = 93;
|
||||
const SYSCALL_YIELD: usize = 124;
|
||||
const SYSCALL_GET_TIME: usize = 169;
|
||||
pub const SYSCALL_OPENAT: usize = 56;
|
||||
pub const SYSCALL_CLOSE: usize = 57;
|
||||
pub const SYSCALL_READ: usize = 63;
|
||||
pub const SYSCALL_WRITE: usize = 64;
|
||||
pub const SYSCALL_UNLINKAT: usize = 35;
|
||||
pub const SYSCALL_LINKAT: usize = 37;
|
||||
pub const SYSCALL_FSTAT: usize = 80;
|
||||
pub const SYSCALL_EXIT: usize = 93;
|
||||
pub const SYSCALL_YIELD: usize = 124;
|
||||
pub const SYSCALL_GETTIMEOFDAY: usize = 169;
|
||||
pub const SYSCALL_GETPID: usize = 172;
|
||||
pub const SYSCALL_FORK: usize = 220;
|
||||
pub const SYSCALL_EXEC: usize = 221;
|
||||
pub const SYSCALL_WAITPID: usize = 260;
|
||||
pub const SYSCALL_SET_PRIORITY: usize = 140;
|
||||
pub const SYSCALL_MUNMAP: usize = 215;
|
||||
pub const SYSCALL_MMAP: usize = 222;
|
||||
pub const SYSCALL_SPAWN: usize = 400;
|
||||
pub const SYSCALL_MAIL_READ: usize = 401;
|
||||
pub const SYSCALL_MAIL_WRITE: usize = 402;
|
||||
pub const SYSCALL_DUP: usize = 24;
|
||||
pub const SYSCALL_PIPE: usize = 59;
|
||||
|
||||
fn syscall(id: usize, args: [usize; 3]) -> isize {
|
||||
pub fn syscall(id: usize, args: [usize; 3]) -> isize {
|
||||
let mut ret: isize;
|
||||
unsafe {
|
||||
llvm_asm!("ecall"
|
||||
: "={x10}" (ret)
|
||||
: "{x10}" (args[0]), "{x11}" (args[1]), "{x12}" (args[2]), "{x17}" (id)
|
||||
: "memory"
|
||||
: "volatile"
|
||||
asm!(
|
||||
"ecall",
|
||||
inlateout("x10") args[0] => ret,
|
||||
in("x11") args[1],
|
||||
in("x12") args[2],
|
||||
in("x17") id
|
||||
);
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
pub fn syscall6(id: usize, args: [usize; 6]) -> isize {
|
||||
let mut ret: isize;
|
||||
unsafe {
|
||||
asm!(
|
||||
"ecall",
|
||||
inlateout("x10") args[0] => ret,
|
||||
in("x11") args[1],
|
||||
in("x12") args[2],
|
||||
in("x13") args[3],
|
||||
in("x14") args[4],
|
||||
in("x15") args[5],
|
||||
in("x17") id
|
||||
);
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
pub fn sys_openat(dirfd: usize, path: &str, flags: u32, mode: u32) -> isize {
|
||||
syscall6(
|
||||
SYSCALL_OPENAT,
|
||||
[
|
||||
dirfd,
|
||||
path.as_ptr() as usize,
|
||||
flags as usize,
|
||||
mode as usize,
|
||||
0,
|
||||
0,
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sys_close(fd: usize) -> isize {
|
||||
syscall(SYSCALL_CLOSE, [fd, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_read(fd: usize, buffer: &mut [u8]) -> isize {
|
||||
syscall(
|
||||
SYSCALL_READ,
|
||||
[fd, buffer.as_mut_ptr() as usize, buffer.len()],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sys_write(fd: usize, buffer: &[u8]) -> isize {
|
||||
syscall(SYSCALL_WRITE, [fd, buffer.as_ptr() as usize, buffer.len()])
|
||||
}
|
||||
|
||||
pub fn sys_exit(xstate: i32) -> isize {
|
||||
syscall(SYSCALL_EXIT, [xstate as usize, 0, 0])
|
||||
pub fn sys_linkat(
|
||||
old_dirfd: usize,
|
||||
old_path: &str,
|
||||
new_dirfd: usize,
|
||||
new_path: &str,
|
||||
flags: usize,
|
||||
) -> isize {
|
||||
syscall6(
|
||||
SYSCALL_LINKAT,
|
||||
[
|
||||
old_dirfd,
|
||||
old_path.as_ptr() as usize,
|
||||
new_dirfd,
|
||||
new_path.as_ptr() as usize,
|
||||
flags,
|
||||
0,
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sys_unlinkat(dirfd: usize, path: &str, flags: usize) -> isize {
|
||||
syscall(SYSCALL_UNLINKAT, [dirfd, path.as_ptr() as usize, flags])
|
||||
}
|
||||
|
||||
pub fn sys_fstat(fd: usize, st: &Stat) -> isize {
|
||||
syscall(SYSCALL_FSTAT, [fd, st as *const _ as usize, 0])
|
||||
}
|
||||
|
||||
pub fn sys_mail_read(buffer: &mut [u8]) -> isize {
|
||||
syscall(
|
||||
SYSCALL_MAIL_READ,
|
||||
[buffer.as_ptr() as usize, buffer.len(), 0],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sys_mail_write(pid: usize, buffer: &[u8]) -> isize {
|
||||
syscall(
|
||||
SYSCALL_MAIL_WRITE,
|
||||
[pid, buffer.as_ptr() as usize, buffer.len()],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sys_exit(exit_code: i32) -> ! {
|
||||
syscall(SYSCALL_EXIT, [exit_code as usize, 0, 0]);
|
||||
panic!("sys_exit never returns!");
|
||||
}
|
||||
|
||||
pub fn sys_yield() -> isize {
|
||||
syscall(SYSCALL_YIELD, [0, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_get_time() -> isize {
|
||||
syscall(SYSCALL_GET_TIME, [0, 0, 0])
|
||||
pub fn sys_get_time(time: &TimeVal, tz: usize) -> isize {
|
||||
syscall(SYSCALL_GETTIMEOFDAY, [time as *const _ as usize, tz, 0])
|
||||
}
|
||||
|
||||
pub fn sys_getpid() -> isize {
|
||||
syscall(SYSCALL_GETPID, [0, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_fork() -> isize {
|
||||
syscall(SYSCALL_FORK, [0, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_exec(path: &str) -> isize {
|
||||
syscall(SYSCALL_EXEC, [path.as_ptr() as usize, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_waitpid(pid: isize, xstatus: *mut i32) -> isize {
|
||||
syscall(SYSCALL_WAITPID, [pid as usize, xstatus as usize, 0])
|
||||
}
|
||||
|
||||
pub fn sys_set_priority(prio: isize) -> isize {
|
||||
syscall(SYSCALL_SET_PRIORITY, [prio as usize, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_mmap(start: usize, len: usize, prot: usize) -> isize {
|
||||
syscall(SYSCALL_MMAP, [start, len, prot])
|
||||
}
|
||||
|
||||
pub fn sys_munmap(start: usize, len: usize) -> isize {
|
||||
syscall(SYSCALL_MUNMAP, [start, len, 0])
|
||||
}
|
||||
|
||||
pub fn sys_spawn(path: &str) -> isize {
|
||||
syscall(SYSCALL_SPAWN, [path.as_ptr() as usize, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_dup(fd: usize) -> isize {
|
||||
syscall(SYSCALL_DUP, [fd, 0, 0])
|
||||
}
|
||||
|
||||
pub fn sys_pipe(pipe: &mut [usize]) -> isize {
|
||||
syscall(SYSCALL_PIPE, [pipe.as_mut_ptr() as usize, 0, 0])
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue