Compare commits
424 commits
Author | SHA1 | Date | |
---|---|---|---|
![]() |
8f24c0f16a | ||
![]() |
9c3a12a342 | ||
![]() |
60483378d7 | ||
![]() |
53f615b30f | ||
![]() |
dc1f9c9585 | ||
![]() |
4b77f293a6 | ||
![]() |
2cd7a39e48 | ||
![]() |
88a4a0ad11 | ||
![]() |
3fb0dbcf06 | ||
![]() |
a0a1cfb338 | ||
![]() |
35948f351c | ||
![]() |
972534f70c | ||
![]() |
94d5e66f36 | ||
![]() |
fa676157da | ||
![]() |
790c45ecb6 | ||
![]() |
4709a3f2a6 | ||
![]() |
3d48ce4c00 | ||
![]() |
74b250adcb | ||
![]() |
a117791e2c | ||
![]() |
a8de24e578 | ||
![]() |
827bb05b2e | ||
![]() |
25782f6757 | ||
![]() |
41eaf2895e | ||
![]() |
e3a1389c15 | ||
![]() |
2a8c86ab1f | ||
![]() |
8ac0534091 | ||
![]() |
fbd74f8a96 | ||
![]() |
45ab29ae1b | ||
![]() |
099b9b2ddd | ||
![]() |
6c7a9558d2 | ||
![]() |
f62593673c | ||
![]() |
1896ddf509 | ||
![]() |
5a63d8e1fe | ||
![]() |
9832bafb44 | ||
![]() |
cd2e97b840 | ||
![]() |
1a71b071f4 | ||
![]() |
e48a85dd4b | ||
![]() |
8a9228d1fe | ||
![]() |
7cbefedc23 | ||
![]() |
9ba3bea9db | ||
![]() |
3924a5f756 | ||
![]() |
2dc89534a4 | ||
![]() |
09232ae31f | ||
![]() |
508bd2bb01 | ||
![]() |
02be18684d | ||
![]() |
dd4678ff0e | ||
![]() |
2e81c8960c | ||
![]() |
1a2838d670 | ||
![]() |
4ce5f89c9c | ||
![]() |
64a38b5cdf | ||
![]() |
55d9cfa1cd | ||
![]() |
d31be8cba0 | ||
![]() |
9355acf903 | ||
![]() |
680f7fed26 | ||
![]() |
e80b7057a4 | ||
![]() |
f358ece527 | ||
![]() |
191eb13c21 | ||
![]() |
642c2aa9a8 | ||
![]() |
8cfd457341 | ||
![]() |
bc80eda2a4 | ||
![]() |
9d9d3f496b | ||
![]() |
b3d434d539 | ||
![]() |
ffe22a57fb | ||
![]() |
210edd929b | ||
![]() |
c0141d34d9 | ||
![]() |
29ef0a52d5 | ||
![]() |
c12e3b733d | ||
![]() |
24e40f3722 | ||
![]() |
4ccf22f581 | ||
![]() |
274a7c0eb2 | ||
![]() |
8326bf1516 | ||
![]() |
fe2f776fe8 | ||
![]() |
4e84c5767e | ||
![]() |
3183b81f87 | ||
![]() |
f0cecc4940 | ||
![]() |
4430e86d5a | ||
![]() |
4022cc3ed7 | ||
![]() |
73fcb72cbb | ||
![]() |
2cbd237260 | ||
![]() |
b40120f8ff | ||
![]() |
a67f3f0d2f | ||
![]() |
2dfd195841 | ||
![]() |
f2635c2dba | ||
![]() |
e0eb517517 | ||
![]() |
beaef1f304 | ||
![]() |
944f114cf8 | ||
![]() |
4aaa7f9206 | ||
![]() |
e71bbcbc8d | ||
![]() |
6d1960ecd9 | ||
![]() |
b1c5751546 | ||
![]() |
2e57ec432a | ||
![]() |
58bf26222f | ||
![]() |
8947b7e4c3 | ||
![]() |
01856f5243 | ||
![]() |
4e5f16cb23 | ||
![]() |
3144455b55 | ||
![]() |
b45dd60594 | ||
![]() |
728b6e5819 | ||
![]() |
932ae94711 | ||
![]() |
206c09fe86 | ||
![]() |
b1173161fc | ||
![]() |
775755cf12 | ||
![]() |
3fba081487 | ||
![]() |
f6214968c8 | ||
![]() |
bcdb63187b | ||
![]() |
1df9c1a98d | ||
![]() |
7a74f84073 | ||
![]() |
6bcb91a7d0 | ||
![]() |
a8355d6c35 | ||
![]() |
21287b2f8f | ||
![]() |
300c7efb14 | ||
![]() |
9fee963ade | ||
![]() |
28a2bd68cc | ||
![]() |
25a398adc2 | ||
![]() |
25f4e37168 | ||
![]() |
5a62191294 | ||
![]() |
836849e09b | ||
![]() |
03fed62db1 | ||
![]() |
d28f40d7ec | ||
![]() |
6d435500f4 | ||
![]() |
637cb41d46 | ||
![]() |
d3cc2b05c0 | ||
![]() |
1ae775ee08 | ||
![]() |
abebbdb070 | ||
![]() |
ad3958b7d0 | ||
![]() |
3337b81d89 | ||
![]() |
62931b3663 | ||
![]() |
529f8ccb5d | ||
![]() |
986773bec2 | ||
![]() |
91990ebadc | ||
![]() |
c16f90d271 | ||
![]() |
e7d6406f45 | ||
![]() |
8e6f364ecc | ||
![]() |
746692766d | ||
![]() |
5eb679c1e6 | ||
![]() |
e2a7c72b98 | ||
![]() |
eddb2d345d | ||
![]() |
35c4055dd0 | ||
![]() |
3ef23549bf | ||
![]() |
0e1f637e28 | ||
![]() |
f3a5a45b94 | ||
![]() |
85d840dd56 | ||
![]() |
b2682acf40 | ||
![]() |
27a535fd03 | ||
![]() |
4a2dd8c5bb | ||
![]() |
91ecb4196d | ||
![]() |
7c2d1efee3 | ||
![]() |
2658b4bfb0 | ||
![]() |
a6c8f4de34 | ||
![]() |
45c2caf564 | ||
![]() |
c348cbdbfa | ||
![]() |
5b0c372507 | ||
![]() |
b7b8ffb1d6 | ||
![]() |
093db48d04 | ||
![]() |
07029a2e5f | ||
![]() |
10e1c57b7d | ||
![]() |
e693b86835 | ||
![]() |
ff62de0722 | ||
![]() |
ef70c1aa73 | ||
![]() |
fc19596945 | ||
![]() |
3979bfcfe0 | ||
![]() |
ad6f19bd22 | ||
![]() |
9a6de792e9 | ||
![]() |
ff35909a41 | ||
![]() |
98d390aab7 | ||
![]() |
81bdc727d6 | ||
![]() |
c7bf9631e9 | ||
![]() |
9d38f29fcc | ||
![]() |
a2c08cdf1c | ||
![]() |
e906b6c8d2 | ||
![]() |
917140c405 | ||
![]() |
ad3fac45d5 | ||
![]() |
f25fe0431c | ||
![]() |
a8e8644865 | ||
![]() |
5f9634d9c1 | ||
![]() |
174a218430 | ||
![]() |
4f3308aa38 | ||
![]() |
56d3444fc6 | ||
![]() |
80503e80ee | ||
![]() |
0d9dd75a57 | ||
![]() |
f87938a885 | ||
![]() |
65593e604b | ||
![]() |
a67aa60ceb | ||
![]() |
e3467d391d | ||
![]() |
4e2436f757 | ||
![]() |
babcd45c9c | ||
![]() |
040bba5f40 | ||
![]() |
85ea693a18 | ||
![]() |
8d6a1bcc79 | ||
![]() |
7173195e52 | ||
![]() |
879f5a5ba5 | ||
![]() |
ae6afe93cb | ||
![]() |
a1a4520b23 | ||
![]() |
564212b685 | ||
![]() |
db89fef127 | ||
![]() |
2275dee52d | ||
![]() |
9c51d69727 | ||
![]() |
a71d91ae6a | ||
![]() |
5e4296d141 | ||
![]() |
10cd895fb8 | ||
![]() |
3995a58fb1 | ||
![]() |
b8e368bf39 | ||
![]() |
d8e7ffec69 | ||
![]() |
9732599114 | ||
![]() |
2f42401b48 | ||
![]() |
500c0d9e58 | ||
![]() |
13cd4e1562 | ||
![]() |
5b49af2079 | ||
![]() |
12ff9896e7 | ||
![]() |
fb196d35a9 | ||
![]() |
ba611a1458 | ||
![]() |
26f44233f6 | ||
![]() |
704eae3bb0 | ||
![]() |
fef12c79f1 | ||
![]() |
c6db34e2c7 | ||
![]() |
017758bf2b | ||
![]() |
e1ae9b6236 | ||
![]() |
7b1ef5f8e7 | ||
![]() |
60143939d4 | ||
![]() |
9159035767 | ||
![]() |
26bc01f3bc | ||
![]() |
5c721b17f7 | ||
![]() |
59f13cb536 | ||
![]() |
ae3ba9c26f | ||
![]() |
c9583b0f53 | ||
![]() |
f4fd3ee9a7 | ||
![]() |
f495dbb1e6 | ||
![]() |
737340b0a0 | ||
![]() |
5e8cf728a7 | ||
![]() |
a3e665d6f4 | ||
![]() |
2cad6d291e | ||
![]() |
f6ebd1ac68 | ||
![]() |
916442b57e | ||
![]() |
838d0a7b2f | ||
![]() |
a32e35d48d | ||
![]() |
b535f5ba98 | ||
![]() |
94156ab1f7 | ||
![]() |
3f0c3f6dfd | ||
![]() |
4262726f0b | ||
![]() |
a0a6863368 | ||
![]() |
ef3f87d31b | ||
![]() |
be21b02661 | ||
![]() |
50c7932c65 | ||
![]() |
98a7b866b5 | ||
![]() |
b3bce3bef2 | ||
![]() |
a3ec647496 | ||
![]() |
7171f92972 | ||
![]() |
1a7420ac97 | ||
![]() |
6c45c33b41 | ||
![]() |
f8f03d2b74 | ||
![]() |
26ca0de950 | ||
![]() |
28a0eaf045 | ||
![]() |
4757dc4bb2 | ||
![]() |
8fc2612da3 | ||
![]() |
243aa53c29 | ||
![]() |
fbacac0585 | ||
![]() |
efc5e6b76c | ||
![]() |
fa38a39fd4 | ||
![]() |
45c33f2ce2 | ||
![]() |
9bc1e8d2e9 | ||
![]() |
5b56961b8c | ||
![]() |
c951c1781e | ||
![]() |
db6a93e60d | ||
![]() |
8974a29245 | ||
![]() |
d1e55d85d8 | ||
![]() |
ff5055386b | ||
![]() |
a341b338c8 | ||
![]() |
4fa4e9cab4 | ||
![]() |
ad0a7bcaa1 | ||
![]() |
6d88ef9d99 | ||
![]() |
cb1d46c8ee | ||
![]() |
3c08a99a64 | ||
![]() |
b3beeecac2 | ||
![]() |
d574e7809a | ||
![]() |
5d2d508e25 | ||
![]() |
2d5032f1ea | ||
![]() |
0ffc62f7c8 | ||
![]() |
ebc39af487 | ||
![]() |
a4d955f927 | ||
![]() |
d7498f139f | ||
![]() |
b8a14182cd | ||
![]() |
692830a31e | ||
![]() |
ea7f50d905 | ||
![]() |
8ba989ad00 | ||
![]() |
5343c731ba | ||
![]() |
65dee70eb9 | ||
![]() |
ed70e9b6b9 | ||
![]() |
b5fe8fa066 | ||
![]() |
44b622be2b | ||
![]() |
51a2cc8235 | ||
![]() |
569e2fe2fe | ||
![]() |
2453f1a549 | ||
![]() |
1b127b7165 | ||
![]() |
aacae6bc3d | ||
![]() |
e98ffcc981 | ||
![]() |
0d3010fb87 | ||
![]() |
a17852a706 | ||
![]() |
1f3a92bd8d | ||
![]() |
2e96c07973 | ||
![]() |
86cc97b334 | ||
![]() |
568c48cd7d | ||
![]() |
ac43589e9d | ||
![]() |
e214d0f91b | ||
![]() |
5c23e38321 | ||
![]() |
62c7a420df | ||
![]() |
88d0d2164f | ||
![]() |
26219e7c95 | ||
![]() |
1b1361c6c0 | ||
![]() |
86b4ecc377 | ||
![]() |
42b5b44ff8 | ||
![]() |
9da207d605 | ||
![]() |
d1cde16ddb | ||
![]() |
e68039eaec | ||
![]() |
a374f4f448 | ||
![]() |
b5b3a12bb0 | ||
![]() |
6d0c2ad00c | ||
![]() |
79c36d3c41 | ||
![]() |
c4ee62e338 | ||
![]() |
394dd61259 | ||
![]() |
536a28bd59 | ||
![]() |
685ca2c1ea | ||
![]() |
ff685b86c8 | ||
![]() |
34f26c5e8f | ||
![]() |
28ef057fe3 | ||
![]() |
c8d851fc2b | ||
![]() |
67b2dde709 | ||
![]() |
f9c3c674ad | ||
![]() |
b3466b7c0f | ||
![]() |
72310e6d39 | ||
![]() |
72d8e7d14e | ||
![]() |
c43ec12175 | ||
![]() |
2e67eb1db0 | ||
![]() |
1c9ce9ca07 | ||
![]() |
17580c6902 | ||
![]() |
1921d65184 | ||
![]() |
cd6dfbf59c | ||
![]() |
93c51af1bf | ||
![]() |
94972a3323 | ||
![]() |
c98c7c6558 | ||
![]() |
84407af1ae | ||
![]() |
a4300091d1 | ||
![]() |
3559f26b37 | ||
![]() |
1c1edc1d80 | ||
![]() |
24a31f9d5f | ||
![]() |
20fc5bee1a | ||
![]() |
973797f10e | ||
![]() |
88c40d08b2 | ||
![]() |
2cfb42d1f6 | ||
![]() |
234e8a7e9d | ||
![]() |
170c458555 | ||
![]() |
3ac26b21b9 | ||
![]() |
3251e0f26e | ||
![]() |
21095633d5 | ||
![]() |
a529c57aef | ||
![]() |
fd4e3305bc | ||
![]() |
ae4c317dd4 | ||
![]() |
00b7e3be94 | ||
![]() |
f091c12f65 | ||
![]() |
760a7d5994 | ||
![]() |
1cc7293e96 | ||
![]() |
b9aa2569bf | ||
![]() |
e9e9fc3164 | ||
![]() |
0566322753 | ||
![]() |
d67f492094 | ||
![]() |
abcd996fb3 | ||
![]() |
4021105561 | ||
![]() |
2e6b6e3c86 | ||
![]() |
0940e8f647 | ||
![]() |
d99b71a9d5 | ||
![]() |
298d00440c | ||
![]() |
513cb2055a | ||
![]() |
cacf60b389 | ||
![]() |
54946d4706 | ||
![]() |
ad3931733c | ||
![]() |
fb8c1cbebe | ||
![]() |
c49a71eb80 | ||
![]() |
06725c7593 | ||
![]() |
2cbfda9bd1 | ||
![]() |
b5b6ff92b2 | ||
![]() |
3b45b483a0 | ||
![]() |
09c3be9d6f | ||
![]() |
780a73ed6f | ||
![]() |
76a8d7527c | ||
![]() |
7bd8a10178 | ||
![]() |
c651f1b3de | ||
![]() |
c0b4201623 | ||
![]() |
08bc677d3b | ||
![]() |
b121689d08 | ||
![]() |
b68278f22e | ||
![]() |
a3802a4b91 | ||
![]() |
760de97155 | ||
![]() |
94267a47c4 | ||
![]() |
5787214ef6 | ||
![]() |
8713046a4a | ||
![]() |
015a8b6407 | ||
![]() |
3c1419185d | ||
![]() |
00eaa64e7d | ||
![]() |
ed9ca7f62d | ||
![]() |
15bc00732c | ||
![]() |
1ad242a886 | ||
![]() |
c5cf3aa83e | ||
![]() |
eca5ee2eb7 | ||
![]() |
2d34cab989 | ||
![]() |
e93a4a0b76 | ||
![]() |
e5bd98973d | ||
![]() |
a3496698b3 | ||
![]() |
48a11e53ff | ||
![]() |
f69b3e11dd | ||
![]() |
63fe64ec0f | ||
![]() |
d0af7d26be | ||
![]() |
8fbadfc951 | ||
![]() |
e56ea17566 | ||
![]() |
58dbb3ffa5 | ||
![]() |
a9066d75e5 | ||
![]() |
e538b204ce | ||
![]() |
9e861c2819 | ||
![]() |
485db04a2b | ||
![]() |
1008d92c35 | ||
![]() |
9366099b28 | ||
![]() |
d38b24a9cb | ||
![]() |
b6f4327a3f | ||
![]() |
e37e5708e4 | ||
![]() |
528d99258a | ||
![]() |
850559e5da |
178 changed files with 11429 additions and 2219 deletions
21
.devcontainer/devcontainer.json
Normal file
21
.devcontainer/devcontainer.json
Normal file
|
@ -0,0 +1,21 @@
|
|||
{
|
||||
"name": "rcore-tutorial-v3",
|
||||
"build": {
|
||||
"dockerfile": "../Dockerfile",
|
||||
"args": {
|
||||
"QEMU_VERSION": "7.0.0",
|
||||
"DEBIAN_FRONTEND": "noninteractive",
|
||||
"GDB_VERSION": "14.1"
|
||||
}
|
||||
},
|
||||
"postCreateCommand": "rustup show",
|
||||
"customizations": {
|
||||
"vscode": {
|
||||
"extensions": [
|
||||
"rust-lang.rust-analyzer",
|
||||
"ms-vscode.cpptools",
|
||||
"tamasfe.even-better-toml"
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
2
.dockerignore
Normal file
2
.dockerignore
Normal file
|
@ -0,0 +1,2 @@
|
|||
*/*
|
||||
!rust-toolchain.toml
|
68
.github/workflows/doc-and-test.yml
vendored
Normal file
68
.github/workflows/doc-and-test.yml
vendored
Normal file
|
@ -0,0 +1,68 @@
|
|||
name: Build Rust Doc And Run tests
|
||||
|
||||
on: [push]
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
rust_toolchain: nightly-2024-01-18
|
||||
|
||||
jobs:
|
||||
build-doc:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: ${{ env.rust_toolchain }}
|
||||
components: rust-src, llvm-tools-preview
|
||||
target: riscv64gc-unknown-none-elf
|
||||
- name: Build doc
|
||||
run: cd os && cargo doc --no-deps --verbose
|
||||
- name: Deploy to Github Pages
|
||||
uses: peaceiris/actions-gh-pages@v3
|
||||
with:
|
||||
github_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
publish_dir: ./os/target/riscv64gc-unknown-none-elf/doc
|
||||
destination_dir: ${{ github.ref_name }}
|
||||
|
||||
run-tests:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: ${{ env.rust_toolchain }}
|
||||
components: rust-src, llvm-tools-preview
|
||||
target: riscv64gc-unknown-none-elf
|
||||
- uses: actions-rs/install@v0.1
|
||||
with:
|
||||
crate: cargo-binutils
|
||||
version: latest
|
||||
use-tool-cache: true
|
||||
- name: Cache QEMU
|
||||
uses: actions/cache@v3
|
||||
with:
|
||||
path: qemu-7.0.0
|
||||
key: qemu-7.0.0-x86_64-riscv64
|
||||
- name: Install QEMU
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install ninja-build -y
|
||||
if [ ! -d qemu-7.0.0 ]; then
|
||||
wget https://download.qemu.org/qemu-7.0.0.tar.xz
|
||||
tar -xf qemu-7.0.0.tar.xz
|
||||
cd qemu-7.0.0
|
||||
./configure --target-list=riscv64-softmmu
|
||||
make -j
|
||||
else
|
||||
cd qemu-7.0.0
|
||||
fi
|
||||
sudo make install
|
||||
qemu-system-riscv64 --version
|
||||
|
||||
- name: Run usertests
|
||||
run: cd os && make run TEST=1
|
||||
timeout-minutes: 10
|
||||
|
20
.gitignore
vendored
20
.gitignore
vendored
|
@ -1,6 +1,16 @@
|
|||
.idea/*
|
||||
os/target/*
|
||||
os/.idea/*
|
||||
.*/*
|
||||
!.github/*
|
||||
!.vscode/settings.json
|
||||
!.devcontainer/devcontainer.json
|
||||
|
||||
**/target/
|
||||
**/Cargo.lock
|
||||
|
||||
os/src/link_app.S
|
||||
user/target/*
|
||||
user/.idea/*
|
||||
os/src/linker.ld
|
||||
os/last-*
|
||||
os/.gdb_history
|
||||
os/virt.out
|
||||
tools/
|
||||
pushall.sh
|
||||
.vscode/*.log
|
||||
|
|
13
.vscode/settings.json
vendored
Normal file
13
.vscode/settings.json
vendored
Normal file
|
@ -0,0 +1,13 @@
|
|||
{
|
||||
// Prevent "can't find crate for `test`" error on no_std
|
||||
// Ref: https://github.com/rust-lang/vscode-rust/issues/729
|
||||
// For vscode-rust plugin users:
|
||||
"rust.target": "riscv64gc-unknown-none-elf",
|
||||
"rust.all_targets": false,
|
||||
// For Rust Analyzer plugin users:
|
||||
"rust-analyzer.cargo.target": "riscv64gc-unknown-none-elf",
|
||||
"rust-analyzer.checkOnSave.allTargets": false,
|
||||
// "rust-analyzer.cargo.features": [
|
||||
// "board_qemu"
|
||||
// ]
|
||||
}
|
72
Dockerfile
Normal file
72
Dockerfile
Normal file
|
@ -0,0 +1,72 @@
|
|||
# syntax=docker/dockerfile:1
|
||||
|
||||
# Stage 1 Build QEMU
|
||||
# - https://www.qemu.org/download/
|
||||
# - https://wiki.qemu.org/Hosts/Linux#Building_QEMU_for_Linux
|
||||
# - https://wiki.qemu.org/Documentation/Platforms/RISCV
|
||||
|
||||
FROM ubuntu:20.04 as build_qemu
|
||||
|
||||
ARG QEMU_VERSION=7.0.0
|
||||
|
||||
RUN sed -i 's/archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \
|
||||
sed -i 's/security.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \
|
||||
apt-get update && \
|
||||
DEBIAN_FRONTEND=noninteractive apt-get install -y wget build-essential libglib2.0-dev libfdt-dev libpixman-1-dev zlib1g-dev ninja-build
|
||||
|
||||
RUN wget https://download.qemu.org/qemu-${QEMU_VERSION}.tar.xz && \
|
||||
tar xf qemu-${QEMU_VERSION}.tar.xz && \
|
||||
cd qemu-${QEMU_VERSION} && \
|
||||
./configure --target-list=riscv64-softmmu,riscv64-linux-user && \
|
||||
make -j$(nproc) && \
|
||||
make install
|
||||
|
||||
# Stage 2 Set Lab Environment
|
||||
FROM ubuntu:20.04 as build
|
||||
|
||||
WORKDIR /tmp
|
||||
|
||||
# 2.0. Install general tools
|
||||
RUN sed -i 's/archive.ubuntu.com/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list && \
|
||||
apt-get update && \
|
||||
DEBIAN_FRONTEND=noninteractive apt-get install -y jq curl git python3 wget build-essential \
|
||||
# qemu dependency
|
||||
libglib2.0-0 libfdt1 libpixman-1-0 zlib1g \
|
||||
# gdb
|
||||
gdb-multiarch
|
||||
|
||||
# 2.1. Copy qemu
|
||||
COPY --from=build_qemu /usr/local/bin/* /usr/local/bin
|
||||
|
||||
# 2.2. Install Rust
|
||||
# - https://www.rust-lang.org/tools/install
|
||||
ENV RUSTUP_HOME=/usr/local/rustup \
|
||||
CARGO_HOME=/usr/local/cargo \
|
||||
PATH=/usr/local/cargo/bin:$PATH \
|
||||
RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static \
|
||||
RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup
|
||||
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
|
||||
sh -s -- -y --no-modify-path --profile minimal --default-toolchain nightly
|
||||
|
||||
# 2.3. Build env for labs
|
||||
# See os/Makefile `env:` for example.
|
||||
# This avoids having to wait for these steps each time using a new container.
|
||||
COPY rust-toolchain.toml rust-toolchain.toml
|
||||
RUN rustup target add riscv64gc-unknown-none-elf && \
|
||||
cargo install toml-cli cargo-binutils && \
|
||||
RUST_VERSION=$(toml get -r rust-toolchain.toml toolchain.channel) && \
|
||||
Components=$(toml get -r rust-toolchain.toml toolchain.components | jq -r 'join(" ")') && \
|
||||
rustup install $RUST_VERSION && \
|
||||
rustup component add --toolchain $RUST_VERSION $Components
|
||||
|
||||
# 2.4. Set GDB
|
||||
RUN ln -s /usr/bin/gdb-multiarch /usr/bin/riscv64-unknown-elf-gdb
|
||||
|
||||
# Stage 3 Sanity checking
|
||||
FROM build as test
|
||||
RUN qemu-system-riscv64 --version && \
|
||||
qemu-riscv64 --version && \
|
||||
rustup --version && \
|
||||
cargo --version && \
|
||||
rustc --version && \
|
||||
riscv64-unknown-elf-gdb --version
|
12
Makefile
Normal file
12
Makefile
Normal file
|
@ -0,0 +1,12 @@
|
|||
DOCKER_TAG ?= rcore-tutorial-v3:latest
|
||||
.PHONY: docker build_docker
|
||||
|
||||
docker:
|
||||
docker run --rm -it -v ${PWD}:/mnt -w /mnt --name rcore-tutorial-v3 ${DOCKER_TAG} bash
|
||||
|
||||
build_docker:
|
||||
docker build -t ${DOCKER_TAG} --target build .
|
||||
|
||||
fmt:
|
||||
cd easy-fs; cargo fmt; cd ../easy-fs-fuse cargo fmt; cd ../os ; cargo fmt; cd ../user; cargo fmt; cd ..
|
||||
|
294
README.md
294
README.md
|
@ -1,2 +1,294 @@
|
|||
# rCore-Tutorial-v3
|
||||
rCore-Tutorial version 3.
|
||||
rCore-Tutorial version 3.6. See the [Documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/).
|
||||
|
||||
rCore-Tutorial API Docs. See the [API Docs of Ten OSes ](#OS-API-DOCS)
|
||||
|
||||
If you don't know Rust Language and try to learn it, please visit [Rust Learning Resources](https://github.com/rcore-os/rCore/wiki/study-resource-of-system-programming-in-RUST)
|
||||
|
||||
Official QQ group number: 735045051
|
||||
|
||||
## news
|
||||
- 23/06/2022: Version 3.6.0 is on the way! Now we directly update the code on chX branches, please periodically check if there are any updates.
|
||||
|
||||
## Overview
|
||||
|
||||
This project aims to show how to write an **Unix-like OS** running on **RISC-V** platforms **from scratch** in **[Rust](https://www.rust-lang.org/)** for **beginners** without any background knowledge about **computer architectures, assembly languages or operating systems**.
|
||||
|
||||
## Features
|
||||
|
||||
* Platform supported: `qemu-system-riscv64` simulator or dev boards based on [Kendryte K210 SoC](https://canaan.io/product/kendryteai) such as [Maix Dock](https://www.seeedstudio.com/Sipeed-MAIX-Dock-p-4815.html)
|
||||
* OS
|
||||
* concurrency of multiple processes each of which contains mutiple native threads
|
||||
* preemptive scheduling(Round-Robin algorithm)
|
||||
* dynamic memory management in kernel
|
||||
* virtual memory
|
||||
* a simple file system with a block cache
|
||||
* an interactive shell in the userspace
|
||||
* **only 4K+ LoC**
|
||||
* [A detailed documentation in Chinese](https://rcore-os.github.io/rCore-Tutorial-Book-v3/) in spite of the lack of comments in the code(English version is not available at present)
|
||||
|
||||
## Prerequisites
|
||||
|
||||
### Install Rust
|
||||
|
||||
See [official guide](https://www.rust-lang.org/tools/install).
|
||||
|
||||
Install some tools:
|
||||
|
||||
```sh
|
||||
$ rustup target add riscv64gc-unknown-none-elf
|
||||
$ cargo install cargo-binutils --vers =0.3.3
|
||||
$ rustup component add llvm-tools-preview
|
||||
$ rustup component add rust-src
|
||||
```
|
||||
|
||||
### Install Qemu
|
||||
|
||||
Here we manually compile and install Qemu 7.0.0. For example, on Ubuntu 18.04:
|
||||
|
||||
```sh
|
||||
# install dependency packages
|
||||
$ sudo apt install autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev \
|
||||
gawk build-essential bison flex texinfo gperf libtool patchutils bc \
|
||||
zlib1g-dev libexpat-dev pkg-config libglib2.0-dev libpixman-1-dev git tmux python3 python3-pip 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
|
||||
|
||||
```sh
|
||||
$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
|
||||
$ cd rCore-Tutorial-v3/os
|
||||
$ make run
|
||||
```
|
||||
|
||||
After outputing some debug messages, the kernel lists all the applications available and enter the user shell:
|
||||
|
||||
```
|
||||
/**** APPS ****
|
||||
mpsc_sem
|
||||
usertests
|
||||
pipetest
|
||||
forktest2
|
||||
cat
|
||||
initproc
|
||||
race_adder_loop
|
||||
threads_arg
|
||||
race_adder_mutex_spin
|
||||
race_adder_mutex_blocking
|
||||
forktree
|
||||
user_shell
|
||||
huge_write
|
||||
race_adder
|
||||
race_adder_atomic
|
||||
threads
|
||||
stack_overflow
|
||||
filetest_simple
|
||||
forktest_simple
|
||||
cmdline_args
|
||||
run_pipe_test
|
||||
forktest
|
||||
matrix
|
||||
exit
|
||||
fantastic_text
|
||||
sleep_simple
|
||||
yield
|
||||
hello_world
|
||||
pipe_large_test
|
||||
sleep
|
||||
phil_din_mutex
|
||||
**************/
|
||||
Rust user shell
|
||||
>>
|
||||
```
|
||||
|
||||
You can run any application except for `initproc` and `user_shell` itself. To run an application, just input its filename and hit enter. `usertests` can run a bunch of applications, thus it is recommended.
|
||||
|
||||
Type `Ctrl+a` then `x` to exit Qemu.
|
||||
|
||||
### K210
|
||||
|
||||
Before chapter 6, you do not need a SD card:
|
||||
|
||||
```sh
|
||||
$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
|
||||
$ cd rCore-Tutorial-v3/os
|
||||
$ make run BOARD=k210
|
||||
```
|
||||
|
||||
From chapter 6, before running the kernel, we should insert a SD card into PC and manually write the filesystem image to it:
|
||||
|
||||
```sh
|
||||
$ cd rCore-Tutorial-v3/os
|
||||
$ make sdcard
|
||||
```
|
||||
|
||||
By default it will overwrite the device `/dev/sdb` which is the SD card, but you can provide another location. For example, `make sdcard SDCARD=/dev/sdc`.
|
||||
|
||||
After that, remove the SD card from PC and insert it to the slot of K210. Connect the K210 to PC and then:
|
||||
|
||||
```sh
|
||||
$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
|
||||
$ cd rCore-Tutorial-v3/os
|
||||
$ make run BOARD=k210
|
||||
```
|
||||
|
||||
Type `Ctrl+]` to disconnect from K210.
|
||||
|
||||
|
||||
## Show runtime debug info of OS kernel version
|
||||
The branch of ch9-log contains a lot of debug info. You could try to run rcore tutorial
|
||||
for understand the internal behavior of os kernel.
|
||||
|
||||
```sh
|
||||
$ git clone https://github.com/rcore-os/rCore-Tutorial-v3.git
|
||||
$ cd rCore-Tutorial-v3/os
|
||||
$ git checkout ch9-log
|
||||
$ make run
|
||||
......
|
||||
[rustsbi] RustSBI version 0.2.0-alpha.10, adapting to RISC-V SBI v0.3
|
||||
.______ __ __ _______.___________. _______..______ __
|
||||
| _ \ | | | | / | | / || _ \ | |
|
||||
| |_) | | | | | | (----`---| |----`| (----`| |_) || |
|
||||
| / | | | | \ \ | | \ \ | _ < | |
|
||||
| |\ \----.| `--' |.----) | | | .----) | | |_) || |
|
||||
| _| `._____| \______/ |_______/ |__| |_______/ |______/ |__|
|
||||
|
||||
[rustsbi] Implementation: RustSBI-QEMU Version 0.0.2
|
||||
[rustsbi-dtb] Hart count: cluster0 with 1 cores
|
||||
[rustsbi] misa: RV64ACDFIMSU
|
||||
[rustsbi] mideleg: ssoft, stimer, sext (0x222)
|
||||
[rustsbi] medeleg: ima, ia, bkpt, la, sa, uecall, ipage, lpage, spage (0xb1ab)
|
||||
[rustsbi] pmp0: 0x10000000 ..= 0x10001fff (rw-)
|
||||
[rustsbi] pmp1: 0x2000000 ..= 0x200ffff (rw-)
|
||||
[rustsbi] pmp2: 0xc000000 ..= 0xc3fffff (rw-)
|
||||
[rustsbi] pmp3: 0x80000000 ..= 0x8fffffff (rwx)
|
||||
[rustsbi] enter supervisor 0x80200000
|
||||
[KERN] rust_main() begin
|
||||
[KERN] clear_bss() begin
|
||||
[KERN] clear_bss() end
|
||||
[KERN] mm::init() begin
|
||||
[KERN] mm::init_heap() begin
|
||||
[KERN] mm::init_heap() end
|
||||
[KERN] mm::init_frame_allocator() begin
|
||||
[KERN] mm::frame_allocator::lazy_static!FRAME_ALLOCATOR begin
|
||||
......
|
||||
```
|
||||
|
||||
## Rustdoc
|
||||
|
||||
Currently it can only help you view the code since only a tiny part of the code has been documented.
|
||||
|
||||
You can open a doc html of `os` using `cargo doc --no-deps --open` under `os` directory.
|
||||
|
||||
### OS-API-DOCS
|
||||
The API Docs for Ten OS
|
||||
1. [Lib-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch1/os/index.html)
|
||||
1. [Batch-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch2/os/index.html)
|
||||
1. [MultiProg-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch3-coop/os/index.html)
|
||||
1. [TimeSharing-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch3/os/index.html)
|
||||
1. [AddrSpace-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch4/os/index.html)
|
||||
1. [Process-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch5/os/index.html)
|
||||
1. [FileSystem-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch6/os/index.html)
|
||||
1. [IPC-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch7/os/index.html)
|
||||
1. [SyncMutex-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch8/os/index.html)
|
||||
1. [IODevice-OS API doc](https://learningos.github.io/rCore-Tutorial-v3/ch9/os/index.html)
|
||||
|
||||
## Working in progress
|
||||
|
||||
Our first release 3.6.0 (chapter 1-9) has been published, and we are still working on it.
|
||||
|
||||
* chapter 9: need more descripts about different I/O devices
|
||||
|
||||
Here are the updates since 3.5.0:
|
||||
|
||||
### Completed
|
||||
|
||||
* [x] automatically clean up and rebuild before running our project on a different platform
|
||||
* [x] fix `power` series application in early chapters, now you can find modulus in the output
|
||||
* [x] use `UPSafeCell` instead of `RefCell` or `spin::Mutex` in order to access static data structures and adjust its API so that it cannot be borrowed twice at a time(mention `& .exclusive_access().task[0]` in `run_first_task`)
|
||||
* [x] move `TaskContext` into `TaskControlBlock` instead of restoring it in place on kernel stack(since ch3), eliminating annoying `task_cx_ptr2`
|
||||
* [x] replace `llvm_asm!` with `asm!`
|
||||
* [x] expand the fs image size generated by `rcore-fs-fuse` to 128MiB
|
||||
* [x] add a new test named `huge_write` which evaluates the fs performance(qemu\~500KiB/s k210\~50KiB/s)
|
||||
* [x] flush all block cache to disk after a fs transaction which involves write operation
|
||||
* [x] replace `spin::Mutex` with `UPSafeCell` before SMP chapter
|
||||
* [x] add codes for a new chapter about synchronization & mutual exclusion(uniprocessor only)
|
||||
* [x] bug fix: we should call `find_pte` rather than `find_pte_create` in `PageTable::unmap`
|
||||
* [x] clarify: "check validity of level-3 pte in `find_pte` instead of checking it outside this function" should not be a bug
|
||||
* [x] code of chapter 8: synchronization on a uniprocessor
|
||||
* [x] switch the code of chapter 6 and chapter 7
|
||||
* [x] support signal mechanism in chapter 7/8(only works for apps with a single thread)
|
||||
* [x] Add boards/ directory and support rustdoc, for example you can use `cargo doc --no-deps --open` to view the documentation of a crate
|
||||
* [x] code of chapter 9: device drivers based on interrupts, including UART, block, keyboard, mouse, gpu devices
|
||||
* [x] add CI autotest and doc in github
|
||||
### Todo(High priority)
|
||||
|
||||
* [ ] review documentation, current progress: 8/9
|
||||
* [ ] use old fs image optionally, do not always rebuild the image
|
||||
* [ ] shell functionality improvement(to be continued...)
|
||||
* [ ] give every non-zero process exit code an unique and clear error type
|
||||
* [ ] effective error handling of mm module
|
||||
* [ ] add more os functions for understanding os conecpts and principles
|
||||
### Todo(Low priority)
|
||||
|
||||
* [ ] rewrite practice doc and remove some inproper questions
|
||||
* [ ] provide smooth debug experience at a Rust source code level
|
||||
* [ ] format the code using official tools
|
||||
|
||||
### Crates
|
||||
|
||||
We will add them later.
|
||||
|
|
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
|
16
easy-fs-fuse/Cargo.toml
Normal file
16
easy-fs-fuse/Cargo.toml
Normal file
|
@ -0,0 +1,16 @@
|
|||
[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 = []
|
155
easy-fs-fuse/src/main.rs
Normal file
155
easy-fs-fuse/src/main.rs
Normal file
|
@ -0,0 +1,155 @@
|
|||
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(())
|
||||
}
|
3
easy-fs/.gitignore
vendored
Normal file
3
easy-fs/.gitignore
vendored
Normal file
|
@ -0,0 +1,3 @@
|
|||
.idea/
|
||||
target/
|
||||
Cargo.lock
|
18
easy-fs/Cargo.toml
Normal file
18
easy-fs/Cargo.toml
Normal file
|
@ -0,0 +1,18 @@
|
|||
[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 = []
|
69
easy-fs/src/bitmap.rs
Normal file
69
easy-fs/src/bitmap.rs
Normal file
|
@ -0,0 +1,69 @@
|
|||
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
|
||||
}
|
||||
}
|
142
easy-fs/src/block_cache.rs
Normal file
142
easy-fs/src/block_cache.rs
Normal file
|
@ -0,0 +1,142 @@
|
|||
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();
|
||||
}
|
||||
}
|
7
easy-fs/src/block_dev.rs
Normal file
7
easy-fs/src/block_dev.rs
Normal file
|
@ -0,0 +1,7 @@
|
|||
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);
|
||||
}
|
147
easy-fs/src/efs.rs
Normal file
147
easy-fs/src/efs.rs
Normal file
|
@ -0,0 +1,147 @@
|
|||
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,
|
||||
)
|
||||
}
|
||||
}
|
409
easy-fs/src/layout.rs
Normal file
409
easy-fs/src/layout.rs
Normal file
|
@ -0,0 +1,409 @@
|
|||
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
|
||||
}
|
||||
}
|
18
easy-fs/src/lib.rs
Normal file
18
easy-fs/src/lib.rs
Normal file
|
@ -0,0 +1,18 @@
|
|||
#![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;
|
186
easy-fs/src/vfs.rs
Normal file
186
easy-fs/src/vfs.rs
Normal file
|
@ -0,0 +1,186 @@
|
|||
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();
|
||||
}
|
||||
}
|
BIN
figures/logo.png
Normal file
BIN
figures/logo.png
Normal file
Binary file not shown.
After Width: | Height: | Size: 54 KiB |
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",
|
||||
]
|
|
@ -2,14 +2,24 @@
|
|||
name = "os"
|
||||
version = "0.1.0"
|
||||
authors = ["Yifan Wu <shinbokuow@163.com>"]
|
||||
edition = "2018"
|
||||
edition = "2021"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] }
|
||||
lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
|
||||
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"] }
|
||||
|
||||
[features]
|
||||
board_qemu = []
|
||||
board_k210 = []
|
||||
[profile.release]
|
||||
debug = true
|
||||
|
|
101
os/Makefile
101
os/Makefile
|
@ -3,17 +3,28 @@ 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
|
||||
FS_IMG := ../user/target/$(TARGET)/$(MODE)/fs.img
|
||||
APPS := ../user/src/bin/*
|
||||
|
||||
# BOARD
|
||||
BOARD ?= qemu
|
||||
SBI ?= rustsbi
|
||||
BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
|
||||
BOARD := qemu
|
||||
SBI ?= rustsbi
|
||||
BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin
|
||||
|
||||
# Run K210
|
||||
K210-SERIALPORT = /dev/ttyUSB0
|
||||
K210-BURNER = ../tools/kflash.py
|
||||
# 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
|
||||
|
||||
# Binutils
|
||||
OBJDUMP := rust-objdump --arch-name=riscv64
|
||||
|
@ -22,14 +33,32 @@ OBJCOPY := rust-objcopy --binary-architecture=riscv64
|
|||
# Disassembly
|
||||
DISASM ?= -x
|
||||
|
||||
build: $(KERNEL_BIN)
|
||||
# Run usertests or usershell
|
||||
TEST ?=
|
||||
|
||||
build: env $(KERNEL_BIN) fs-img
|
||||
|
||||
env:
|
||||
(rustup target list | grep "riscv64gc-unknown-none-elf (installed)") || rustup target add $(TARGET)
|
||||
cargo install cargo-binutils
|
||||
rustup component add rust-src
|
||||
rustup component add llvm-tools-preview
|
||||
|
||||
$(KERNEL_BIN): kernel
|
||||
@$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@
|
||||
|
||||
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
|
||||
@cargo build --release --features "board_$(BOARD)"
|
||||
@echo Platform: $(BOARD)
|
||||
@cp src/linker-$(BOARD).ld src/linker.ld
|
||||
@cargo build --release
|
||||
@rm src/linker.ld
|
||||
|
||||
clean:
|
||||
@cargo clean
|
||||
|
@ -39,31 +68,45 @@ disasm: kernel
|
|||
|
||||
disasm-vim: kernel
|
||||
@$(OBJDUMP) $(DISASM) $(KERNEL_ELF) > $(DISASM_TMP)
|
||||
@vim $(DISASM_TMP)
|
||||
@nvim $(DISASM_TMP)
|
||||
@rm $(DISASM_TMP)
|
||||
|
||||
run: run-inner
|
||||
|
||||
run-inner: build
|
||||
ifeq ($(BOARD),qemu)
|
||||
@qemu-system-riscv64 \
|
||||
-machine virt \
|
||||
-nographic \
|
||||
-bios $(BOOTLOADER) \
|
||||
-device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA)
|
||||
else
|
||||
@cp $(BOOTLOADER) $(BOOTLOADER).copy
|
||||
@dd if=$(KERNEL_BIN) of=$(BOOTLOADER).copy bs=128K seek=1
|
||||
@mv $(BOOTLOADER).copy $(KERNEL_BIN)
|
||||
@sudo chmod 777 $(K210-SERIALPORT)
|
||||
python3 $(K210-BURNER) -p $(K210-SERIALPORT) -b 1500000 $(KERNEL_BIN)
|
||||
miniterm --eol LF --dtr 0 --rts 0 --filter direct $(K210-SERIALPORT) 115200
|
||||
endif
|
||||
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
|
||||
|
||||
debug: build
|
||||
fdt:
|
||||
@qemu-system-riscv64 -M 128m -machine virt,dumpdtb=virt.out
|
||||
fdtdump virt.out
|
||||
|
||||
QEMU_NAME := qemu-system-riscv64
|
||||
qemu-version-check:
|
||||
@sh scripts/qemu-ver-check.sh $(QEMU_NAME)
|
||||
|
||||
run-inner: qemu-version-check build
|
||||
@qemu-system-riscv64 $(QEMU_ARGS)
|
||||
|
||||
debug: qemu-version-check build
|
||||
@tmux new-session -d \
|
||||
"qemu-system-riscv64 -machine virt -nographic -bios $(BOOTLOADER) -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) -s -S" && \
|
||||
"qemu-system-riscv64 $(QEMU_ARGS) -s -S" && \
|
||||
tmux split-window -h "riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'" && \
|
||||
tmux -2 attach-session -d
|
||||
|
||||
.PHONY: build kernel clean disasm disasm-vim run-inner
|
||||
gdbserver: qemu-version-check build
|
||||
@qemu-system-riscv64 $(QEMU_ARGS) -s -S
|
||||
|
||||
gdbclient:
|
||||
@riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'
|
||||
|
||||
.PHONY: build env kernel clean disasm disasm-vim run-inner fs-img gdbserver gdbclient fdt qemu-version-check
|
||||
|
|
53
os/build.rs
53
os/build.rs
|
@ -1,53 +1,6 @@
|
|||
use std::io::{Result, Write};
|
||||
use std::fs::{File, read_dir};
|
||||
static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/release/";
|
||||
|
||||
fn main() {
|
||||
println!("cargo:rerun-if-changed=../user/src/bin/");
|
||||
insert_app_data().unwrap();
|
||||
println!("cargo:rerun-if-changed=../user/src/");
|
||||
println!("cargo:rerun-if-changed={}", TARGET_PATH);
|
||||
}
|
||||
|
||||
static TARGET_PATH: &str = "../user/target/riscv64gc-unknown-none-elf/debug/";
|
||||
|
||||
fn insert_app_data() -> Result<()> {
|
||||
let mut f = File::create("src/link_app.S").unwrap();
|
||||
let mut apps: Vec<_> = read_dir("../user/src/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 4
|
||||
.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(())
|
||||
}
|
26
os/scripts/qemu-ver-check.sh
Normal file
26
os/scripts/qemu-ver-check.sh
Normal file
|
@ -0,0 +1,26 @@
|
|||
#!/bin/sh
|
||||
|
||||
# Argument1: The filename of qemu executable, e.g. qemu-system-riscv64
|
||||
QEMU_PATH=$(which $1)
|
||||
RET=$?
|
||||
MINIMUM_MAJOR_VERSION=7
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
NC='\033[0m'
|
||||
if [ $RET != 0 ]
|
||||
then
|
||||
echo "$1 not found"
|
||||
exit 1
|
||||
else
|
||||
QEMU_VERSION=$($1 --version|head -n 1|awk '{print $4}')
|
||||
MAJOR_VERSION=$(echo $QEMU_VERSION|cut -c1-1)
|
||||
if [ $MAJOR_VERSION -lt $MINIMUM_MAJOR_VERSION ]
|
||||
then
|
||||
echo "${RED}Error: Required major version of QEMU is ${MINIMUM_MAJOR_VERSION}, " \
|
||||
"but current is ${QEMU_VERSION}.${NC}"
|
||||
exit 1
|
||||
else
|
||||
echo "${GREEN}QEMU version is ${QEMU_VERSION}(>=${MINIMUM_MAJOR_VERSION}), OK!${NC}"
|
||||
exit 0
|
||||
fi
|
||||
fi
|
BIN
os/src/assert/desktop.bmp
Normal file
BIN
os/src/assert/desktop.bmp
Normal file
Binary file not shown.
After Width: | Height: | Size: 2.9 MiB |
BIN
os/src/assert/file.bmp
Normal file
BIN
os/src/assert/file.bmp
Normal file
Binary file not shown.
After Width: | Height: | Size: 12 KiB |
BIN
os/src/assert/folder.bmp
Normal file
BIN
os/src/assert/folder.bmp
Normal file
Binary file not shown.
After Width: | Height: | Size: 12 KiB |
BIN
os/src/assert/mouse.bmp
Normal file
BIN
os/src/assert/mouse.bmp
Normal file
Binary file not shown.
After Width: | Height: | Size: 12 KiB |
55
os/src/boards/qemu.rs
Normal file
55
os/src/boards/qemu.rs
Normal file
|
@ -0,0 +1,55 @@
|
|||
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);
|
||||
}
|
|
@ -1,11 +1,12 @@
|
|||
#[allow(unused)]
|
||||
|
||||
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 APP_SIZE_LIMIT: usize = 0x20000;
|
||||
pub const KERNEL_HEAP_SIZE: usize = 0x100_0000;
|
||||
pub const PAGE_SIZE: usize = 0x1000;
|
||||
pub const PAGE_SIZE_BITS: usize = 0xc;
|
||||
|
||||
#[cfg(feature = "board_k210")]
|
||||
pub const CPU_FREQ: usize = 10000000;
|
||||
pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
|
||||
pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE;
|
||||
|
||||
#[cfg(feature = "board_qemu")]
|
||||
pub const CPU_FREQ: usize = 12500000;
|
||||
pub use crate::board::{CLOCK_FREQ, MEMORY_END, MMIO};
|
||||
|
|
|
@ -1,12 +1,13 @@
|
|||
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() {
|
||||
console_putchar(c as usize);
|
||||
UART.write(c as u8);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
@ -19,15 +20,13 @@ 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)+)?))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
28
os/src/drivers/block/mod.rs
Normal file
28
os/src/drivers/block/mod.rs
Normal file
|
@ -0,0 +1,28 @@
|
|||
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!");
|
||||
}
|
87
os/src/drivers/block/virtio_blk.rs
Normal file
87
os/src/drivers/block/virtio_blk.rs
Normal file
|
@ -0,0 +1,87 @@
|
|||
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,
|
||||
}
|
||||
}
|
||||
}
|
1
os/src/drivers/bus/mod.rs
Normal file
1
os/src/drivers/bus/mod.rs
Normal file
|
@ -0,0 +1 @@
|
|||
pub mod virtio;
|
48
os/src/drivers/bus/virtio.rs
Normal file
48
os/src/drivers/bus/virtio.rs
Normal file
|
@ -0,0 +1,48 @@
|
|||
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
|
||||
}
|
||||
}
|
17
os/src/drivers/chardev/mod.rs
Normal file
17
os/src/drivers/chardev/mod.rs
Normal file
|
@ -0,0 +1,17 @@
|
|||
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());
|
||||
}
|
186
os/src/drivers/chardev/ns16550a.rs
Normal file
186
os/src/drivers/chardev/ns16550a.rs
Normal file
|
@ -0,0 +1,186 @@
|
|||
///! 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();
|
||||
}
|
||||
}
|
||||
}
|
68
os/src/drivers/gpu/mod.rs
Normal file
68
os/src/drivers/gpu/mod.rs
Normal file
|
@ -0,0 +1,68 @@
|
|||
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) {}
|
||||
}
|
83
os/src/drivers/input/mod.rs
Normal file
83
os/src/drivers/input/mod.rs
Normal file
|
@ -0,0 +1,83 @@
|
|||
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();
|
||||
};
|
||||
}
|
||||
}
|
13
os/src/drivers/mod.rs
Normal file
13
os/src/drivers/mod.rs
Normal file
|
@ -0,0 +1,13 @@
|
|||
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::*;
|
46
os/src/drivers/net/mod.rs
Normal file
46
os/src/drivers/net/mod.rs
Normal file
|
@ -0,0 +1,46 @@
|
|||
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))
|
||||
}
|
||||
}
|
||||
}
|
124
os/src/drivers/plic.rs
Normal file
124
os/src/drivers/plic.rs
Normal file
|
@ -0,0 +1,124 @@
|
|||
#[allow(clippy::upper_case_acronyms)]
|
||||
pub struct PLIC {
|
||||
base_addr: usize,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum IntrTargetPriority {
|
||||
Machine = 0,
|
||||
Supervisor = 1,
|
||||
}
|
||||
|
||||
impl IntrTargetPriority {
|
||||
pub fn supported_number() -> usize {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
impl PLIC {
|
||||
fn priority_ptr(&self, intr_source_id: usize) -> *mut u32 {
|
||||
assert!(intr_source_id > 0 && intr_source_id <= 132);
|
||||
(self.base_addr + intr_source_id * 4) as *mut u32
|
||||
}
|
||||
fn hart_id_with_priority(hart_id: usize, target_priority: IntrTargetPriority) -> usize {
|
||||
let priority_num = IntrTargetPriority::supported_number();
|
||||
hart_id * priority_num + target_priority as usize
|
||||
}
|
||||
fn enable_ptr(
|
||||
&self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
intr_source_id: usize,
|
||||
) -> (*mut u32, usize) {
|
||||
let id = Self::hart_id_with_priority(hart_id, target_priority);
|
||||
let (reg_id, reg_shift) = (intr_source_id / 32, intr_source_id % 32);
|
||||
(
|
||||
(self.base_addr + 0x2000 + 0x80 * id + 0x4 * reg_id) as *mut u32,
|
||||
reg_shift,
|
||||
)
|
||||
}
|
||||
fn threshold_ptr_of_hart_with_priority(
|
||||
&self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
) -> *mut u32 {
|
||||
let id = Self::hart_id_with_priority(hart_id, target_priority);
|
||||
(self.base_addr + 0x20_0000 + 0x1000 * id) as *mut u32
|
||||
}
|
||||
fn claim_comp_ptr_of_hart_with_priority(
|
||||
&self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
) -> *mut u32 {
|
||||
let id = Self::hart_id_with_priority(hart_id, target_priority);
|
||||
(self.base_addr + 0x20_0004 + 0x1000 * id) as *mut u32
|
||||
}
|
||||
pub unsafe fn new(base_addr: usize) -> Self {
|
||||
Self { base_addr }
|
||||
}
|
||||
pub fn set_priority(&mut self, intr_source_id: usize, priority: u32) {
|
||||
assert!(priority < 8);
|
||||
unsafe {
|
||||
self.priority_ptr(intr_source_id).write_volatile(priority);
|
||||
}
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn get_priority(&mut self, intr_source_id: usize) -> u32 {
|
||||
unsafe { self.priority_ptr(intr_source_id).read_volatile() & 7 }
|
||||
}
|
||||
pub fn enable(
|
||||
&mut self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
intr_source_id: usize,
|
||||
) {
|
||||
let (reg_ptr, shift) = self.enable_ptr(hart_id, target_priority, intr_source_id);
|
||||
unsafe {
|
||||
reg_ptr.write_volatile(reg_ptr.read_volatile() | 1 << shift);
|
||||
}
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn disable(
|
||||
&mut self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
intr_source_id: usize,
|
||||
) {
|
||||
let (reg_ptr, shift) = self.enable_ptr(hart_id, target_priority, intr_source_id);
|
||||
unsafe {
|
||||
reg_ptr.write_volatile(reg_ptr.read_volatile() & (!(1u32 << shift)));
|
||||
}
|
||||
}
|
||||
pub fn set_threshold(
|
||||
&mut self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
threshold: u32,
|
||||
) {
|
||||
assert!(threshold < 8);
|
||||
let threshold_ptr = self.threshold_ptr_of_hart_with_priority(hart_id, target_priority);
|
||||
unsafe {
|
||||
threshold_ptr.write_volatile(threshold);
|
||||
}
|
||||
}
|
||||
#[allow(unused)]
|
||||
pub fn get_threshold(&mut self, hart_id: usize, target_priority: IntrTargetPriority) -> u32 {
|
||||
let threshold_ptr = self.threshold_ptr_of_hart_with_priority(hart_id, target_priority);
|
||||
unsafe { threshold_ptr.read_volatile() & 7 }
|
||||
}
|
||||
pub fn claim(&mut self, hart_id: usize, target_priority: IntrTargetPriority) -> u32 {
|
||||
let claim_comp_ptr = self.claim_comp_ptr_of_hart_with_priority(hart_id, target_priority);
|
||||
unsafe { claim_comp_ptr.read_volatile() }
|
||||
}
|
||||
pub fn complete(
|
||||
&mut self,
|
||||
hart_id: usize,
|
||||
target_priority: IntrTargetPriority,
|
||||
completion: u32,
|
||||
) {
|
||||
let claim_comp_ptr = self.claim_comp_ptr_of_hart_with_priority(hart_id, target_priority);
|
||||
unsafe {
|
||||
claim_comp_ptr.write_volatile(completion);
|
||||
}
|
||||
}
|
||||
}
|
|
@ -5,8 +5,8 @@ _start:
|
|||
call rust_main
|
||||
|
||||
.section .bss.stack
|
||||
.globl boot_stack
|
||||
boot_stack:
|
||||
.globl boot_stack_lower_bound
|
||||
boot_stack_lower_bound:
|
||||
.space 4096 * 16
|
||||
.globl boot_stack_top
|
||||
boot_stack_top:
|
||||
boot_stack_top:
|
||||
|
|
139
os/src/fs/inode.rs
Normal file
139
os/src/fs/inode.rs
Normal file
|
@ -0,0 +1,139 @@
|
|||
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
|
||||
}
|
||||
}
|
16
os/src/fs/mod.rs
Normal file
16
os/src/fs/mod.rs
Normal file
|
@ -0,0 +1,16 @@
|
|||
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};
|
173
os/src/fs/pipe.rs
Normal file
173
os/src/fs/pipe.rs
Normal file
|
@ -0,0 +1,173 @@
|
|||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
46
os/src/fs/stdio.rs
Normal file
46
os/src/fs/stdio.rs
Normal file
|
@ -0,0 +1,46 @@
|
|||
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()
|
||||
}
|
||||
}
|
|
@ -1,12 +1,38 @@
|
|||
use core::panic::PanicInfo;
|
||||
use crate::sbi::shutdown;
|
||||
use crate::task::current_kstack_top;
|
||||
use core::arch::asm;
|
||||
use core::panic::PanicInfo;
|
||||
use log::*;
|
||||
|
||||
#[panic_handler]
|
||||
fn panic(info: &PanicInfo) -> ! {
|
||||
if let Some(location) = info.location() {
|
||||
println!("[kernel] Panicked at {}:{} {}", location.file(), location.line(), info.message().unwrap());
|
||||
error!(
|
||||
"[kernel] Panicked at {}:{} {}",
|
||||
location.file(),
|
||||
location.line(),
|
||||
info.message().unwrap()
|
||||
);
|
||||
} else {
|
||||
println!("[kernel] Panicked: {}", info.message().unwrap());
|
||||
error!("[kernel] Panicked: {}", info.message().unwrap());
|
||||
}
|
||||
shutdown()
|
||||
unsafe {
|
||||
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---");
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
OUTPUT_ARCH(riscv)
|
||||
ENTRY(_start)
|
||||
BASE_ADDRESS = 0x80020000;
|
||||
BASE_ADDRESS = 0x80200000;
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
|
@ -10,6 +10,10 @@ SECTIONS
|
|||
stext = .;
|
||||
.text : {
|
||||
*(.text.entry)
|
||||
. = ALIGN(4K);
|
||||
strampoline = .;
|
||||
*(.text.trampoline);
|
||||
. = ALIGN(4K);
|
||||
*(.text .text.*)
|
||||
}
|
||||
|
||||
|
@ -18,6 +22,7 @@ SECTIONS
|
|||
srodata = .;
|
||||
.rodata : {
|
||||
*(.rodata .rodata.*)
|
||||
*(.srodata .srodata.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
|
@ -25,14 +30,17 @@ SECTIONS
|
|||
sdata = .;
|
||||
.data : {
|
||||
*(.data .data.*)
|
||||
*(.sdata .sdata.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
edata = .;
|
||||
sbss_with_stack = .;
|
||||
.bss : {
|
||||
*(.bss.stack)
|
||||
sbss = .;
|
||||
*(.bss .bss.*)
|
||||
*(.sbss .sbss.*)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
|
@ -1,87 +0,0 @@
|
|||
use crate::trap::TrapContext;
|
||||
use crate::task::TaskContext;
|
||||
use crate::config::*;
|
||||
|
||||
#[repr(align(4096))]
|
||||
struct KernelStack {
|
||||
data: [u8; KERNEL_STACK_SIZE],
|
||||
}
|
||||
|
||||
#[repr(align(4096))]
|
||||
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, 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()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 { llvm_asm!("fence.i" :::: "volatile"); }
|
||||
// load apps
|
||||
for i in 0..num_app {
|
||||
let base_i = get_base_i(i);
|
||||
// clear region
|
||||
(base_i..base_i + APP_SIZE_LIMIT).for_each(|addr| unsafe {
|
||||
(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) -> &'static TaskContext {
|
||||
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,43 +1,76 @@
|
|||
#![no_std]
|
||||
#![no_main]
|
||||
#![feature(global_asm)]
|
||||
#![feature(llvm_asm)]
|
||||
#![feature(panic_info_message)]
|
||||
#![feature(const_in_array_repeat_expressions)]
|
||||
#![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 lang_items;
|
||||
mod sbi;
|
||||
mod syscall;
|
||||
mod trap;
|
||||
mod loader;
|
||||
mod config;
|
||||
mod drivers;
|
||||
mod fs;
|
||||
mod lang_items;
|
||||
mod mm;
|
||||
mod net;
|
||||
mod sbi;
|
||||
mod sync;
|
||||
mod syscall;
|
||||
mod task;
|
||||
mod timer;
|
||||
mod trap;
|
||||
|
||||
global_asm!(include_str!("entry.asm"));
|
||||
global_asm!(include_str!("link_app.S"));
|
||||
use crate::drivers::chardev::CharDevice;
|
||||
use crate::drivers::chardev::UART;
|
||||
|
||||
core::arch::global_asm!(include_str!("entry.asm"));
|
||||
|
||||
fn clear_bss() {
|
||||
extern "C" {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
use lazy_static::*;
|
||||
use sync::UPIntrFreeCell;
|
||||
|
||||
lazy_static! {
|
||||
pub static ref DEV_NON_BLOCKING_ACCESS: UPIntrFreeCell<bool> =
|
||||
unsafe { UPIntrFreeCell::new(false) };
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub fn rust_main() -> ! {
|
||||
clear_bss();
|
||||
println!("[kernel] Hello, world!");
|
||||
mm::init();
|
||||
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_interrupt();
|
||||
trap::enable_timer_interrupt();
|
||||
timer::set_next_trigger();
|
||||
task::run_first_task();
|
||||
board::device_init();
|
||||
fs::list_apps();
|
||||
task::add_initproc();
|
||||
*DEV_NON_BLOCKING_ACCESS.exclusive_access() = true;
|
||||
task::run_tasks();
|
||||
panic!("Unreachable in rust_main!");
|
||||
}
|
||||
}
|
||||
|
|
270
os/src/mm/address.rs
Normal file
270
os/src/mm/address.rs
Normal file
|
@ -0,0 +1,270 @@
|
|||
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>;
|
162
os/src/mm/frame_allocator.rs
Normal file
162
os/src/mm/frame_allocator.rs
Normal file
|
@ -0,0 +1,162 @@
|
|||
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!");
|
||||
}
|
45
os/src/mm/heap_allocator.rs
Normal file
45
os/src/mm/heap_allocator.rs
Normal file
|
@ -0,0 +1,45 @@
|
|||
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!");
|
||||
}
|
380
os/src/mm/memory_set.rs
Normal file
380
os/src/mm/memory_set.rs
Normal file
|
@ -0,0 +1,380 @@
|
|||
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!");
|
||||
}
|
21
os/src/mm/mod.rs
Normal file
21
os/src/mm/mod.rs
Normal file
|
@ -0,0 +1,21 @@
|
|||
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();
|
||||
}
|
249
os/src/mm/page_table.rs
Normal file
249
os/src/mm/page_table.rs
Normal file
|
@ -0,0 +1,249 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
136
os/src/net/mod.rs
Normal file
136
os/src/net/mod.rs
Normal file
|
@ -0,0 +1,136 @@
|
|||
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);
|
||||
}
|
141
os/src/net/port_table.rs
Normal file
141
os/src/net/port_table.rs
Normal file
|
@ -0,0 +1,141 @@
|
|||
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
|
||||
}
|
||||
}
|
123
os/src/net/socket.rs
Normal file
123
os/src/net/socket.rs
Normal file
|
@ -0,0 +1,123 @@
|
|||
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()
|
||||
}
|
113
os/src/net/tcp.rs
Normal file
113
os/src/net/tcp.rs
Normal file
|
@ -0,0 +1,113 @@
|
|||
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)
|
||||
}
|
||||
}
|
95
os/src/net/udp.rs
Normal file
95
os/src/net/udp.rs
Normal file
|
@ -0,0 +1,95 @@
|
|||
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)
|
||||
}
|
||||
}
|
|
@ -1,43 +1,15 @@
|
|||
#![allow(unused)]
|
||||
|
||||
const SBI_SET_TIMER: usize = 0;
|
||||
const SBI_CONSOLE_PUTCHAR: usize = 1;
|
||||
const SBI_CONSOLE_GETCHAR: usize = 2;
|
||||
const SBI_CLEAR_IPI: usize = 3;
|
||||
const SBI_SEND_IPI: usize = 4;
|
||||
const SBI_REMOTE_FENCE_I: usize = 5;
|
||||
const SBI_REMOTE_SFENCE_VMA: usize = 6;
|
||||
const SBI_REMOTE_SFENCE_VMA_ASID: usize = 7;
|
||||
const SBI_SHUTDOWN: usize = 8;
|
||||
|
||||
#[inline(always)]
|
||||
fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize {
|
||||
let mut ret;
|
||||
unsafe {
|
||||
llvm_asm!("ecall"
|
||||
: "={x10}" (ret)
|
||||
: "{x10}" (arg0), "{x11}" (arg1), "{x12}" (arg2), "{x17}" (which)
|
||||
: "memory"
|
||||
: "volatile"
|
||||
);
|
||||
}
|
||||
ret
|
||||
}
|
||||
|
||||
/// use sbi call to set timer
|
||||
pub fn set_timer(timer: usize) {
|
||||
sbi_call(SBI_SET_TIMER, timer, 0, 0);
|
||||
sbi_rt::set_timer(timer as _);
|
||||
}
|
||||
|
||||
pub fn console_putchar(c: usize) {
|
||||
sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0);
|
||||
/// use sbi call to shutdown the kernel
|
||||
pub fn shutdown(failure: bool) -> ! {
|
||||
use sbi_rt::{system_reset, NoReason, Shutdown, SystemFailure};
|
||||
if !failure {
|
||||
system_reset(Shutdown, NoReason);
|
||||
} else {
|
||||
system_reset(Shutdown, SystemFailure);
|
||||
}
|
||||
unreachable!()
|
||||
}
|
||||
|
||||
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!");
|
||||
}
|
||||
|
||||
|
|
58
os/src/sync/condvar.rs
Normal file
58
os/src/sync/condvar.rs
Normal file
|
@ -0,0 +1,58 @@
|
|||
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();
|
||||
}
|
||||
}
|
9
os/src/sync/mod.rs
Normal file
9
os/src/sync/mod.rs
Normal file
|
@ -0,0 +1,9 @@
|
|||
mod condvar;
|
||||
mod mutex;
|
||||
mod semaphore;
|
||||
mod up;
|
||||
|
||||
pub use condvar::Condvar;
|
||||
pub use mutex::{Mutex, MutexBlocking, MutexSpin};
|
||||
pub use semaphore::Semaphore;
|
||||
pub use up::{UPIntrFreeCell, UPIntrRefMut};
|
88
os/src/sync/mutex.rs
Normal file
88
os/src/sync/mutex.rs
Normal file
|
@ -0,0 +1,88 @@
|
|||
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;
|
||||
}
|
||||
}
|
||||
}
|
45
os/src/sync/semaphore.rs
Normal file
45
os/src/sync/semaphore.rs
Normal file
|
@ -0,0 +1,45 @@
|
|||
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();
|
||||
}
|
||||
}
|
||||
}
|
140
os/src/sync/up.rs
Normal file
140
os/src/sync/up.rs
Normal file
|
@ -0,0 +1,140 @@
|
|||
use core::cell::{RefCell, RefMut, UnsafeCell};
|
||||
use core::ops::{Deref, DerefMut};
|
||||
use lazy_static::*;
|
||||
use riscv::register::sstatus;
|
||||
|
||||
/*
|
||||
/// Wrap a static data structure inside it so that we are
|
||||
/// able to access it without any `unsafe`.
|
||||
///
|
||||
/// 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()
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
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()
|
||||
}
|
||||
}
|
|
@ -1,15 +1,99 @@
|
|||
const FD_STDOUT: usize = 1;
|
||||
use crate::fs::{make_pipe, open_file, OpenFlags};
|
||||
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 {
|
||||
match fd {
|
||||
FD_STDOUT => {
|
||||
let slice = unsafe { core::slice::from_raw_parts(buf, len) };
|
||||
let str = core::str::from_utf8(slice).unwrap();
|
||||
print!("{}", str);
|
||||
len as isize
|
||||
},
|
||||
_ => {
|
||||
panic!("Unsupported fd in sys_write!");
|
||||
}
|
||||
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] {
|
||||
if !file.writable() {
|
||||
return -1;
|
||||
}
|
||||
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
|
||||
}
|
||||
|
|
34
os/src/syscall/gui.rs
Normal file
34
os/src/syscall/gui.rs
Normal file
|
@ -0,0 +1,34 @@
|
|||
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
|
||||
}
|
28
os/src/syscall/input.rs
Normal file
28
os/src/syscall/input.rs
Normal file
|
@ -0,0 +1,28 @@
|
|||
//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
|
||||
}
|
||||
}
|
|
@ -1,21 +1,90 @@
|
|||
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(),
|
||||
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),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
53
os/src/syscall/net.rs
Normal file
53
os/src/syscall/net.rs
Normal file
|
@ -0,0 +1,53 @@
|
|||
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
|
||||
}
|
|
@ -1,12 +1,16 @@
|
|||
use crate::fs::{open_file, OpenFlags};
|
||||
use crate::mm::{translated_ref, translated_refmut, translated_str};
|
||||
use crate::task::{
|
||||
suspend_current_and_run_next,
|
||||
exit_current_and_run_next,
|
||||
current_process, current_task, current_user_token, exit_current_and_run_next, pid2process,
|
||||
suspend_current_and_run_next, SignalFlags,
|
||||
};
|
||||
use crate::timer::get_time;
|
||||
use crate::timer::get_time_ms;
|
||||
use alloc::string::String;
|
||||
use alloc::sync::Arc;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
pub fn sys_exit(xstate: i32) -> ! {
|
||||
println!("[kernel] Application exited with code {}", xstate);
|
||||
exit_current_and_run_next();
|
||||
pub fn sys_exit(exit_code: i32) -> ! {
|
||||
exit_current_and_run_next(exit_code);
|
||||
panic!("Unreachable in sys_exit!");
|
||||
}
|
||||
|
||||
|
@ -16,5 +20,98 @@ pub fn sys_yield() -> isize {
|
|||
}
|
||||
|
||||
pub fn sys_get_time() -> isize {
|
||||
get_time() as isize
|
||||
}
|
||||
get_time_ms() as isize
|
||||
}
|
||||
|
||||
pub fn sys_getpid() -> isize {
|
||||
current_task().unwrap().process.upgrade().unwrap().getpid() as isize
|
||||
}
|
||||
|
||||
pub fn sys_fork() -> isize {
|
||||
let current_process = current_process();
|
||||
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) {
|
||||
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
|
||||
}
|
||||
}
|
||||
|
|
134
os/src/syscall/sync.rs
Normal file
134
os/src/syscall/sync.rs
Normal file
|
@ -0,0 +1,134 @@
|
|||
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
|
||||
}
|
85
os/src/syscall/thread.rs
Normal file
85
os/src/syscall/thread.rs
Normal file
|
@ -0,0 +1,85 @@
|
|||
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
|
||||
}
|
||||
}
|
|
@ -1,16 +1,25 @@
|
|||
use crate::trap::trap_return;
|
||||
|
||||
#[repr(C)]
|
||||
pub struct TaskContext {
|
||||
ra: usize,
|
||||
sp: usize,
|
||||
s: [usize; 12],
|
||||
}
|
||||
|
||||
impl TaskContext {
|
||||
pub fn goto_restore() -> Self {
|
||||
extern "C" { fn __restore(); }
|
||||
pub fn zero_init() -> Self {
|
||||
Self {
|
||||
ra: __restore as usize,
|
||||
ra: 0,
|
||||
sp: 0,
|
||||
s: [0; 12],
|
||||
}
|
||||
}
|
||||
pub fn goto_trap_return(kstack_ptr: usize) -> Self {
|
||||
Self {
|
||||
ra: trap_return as usize,
|
||||
sp: kstack_ptr,
|
||||
s: [0; 12],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
226
os/src/task/id.rs
Normal file
226
os/src/task/id.rs
Normal file
|
@ -0,0 +1,226 @@
|
|||
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();
|
||||
}
|
||||
}
|
62
os/src/task/manager.rs
Normal file
62
os/src/task/manager.rs
Normal file
|
@ -0,0 +1,62 @@
|
|||
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);
|
||||
}
|
||||
}
|
|
@ -1,126 +1,166 @@
|
|||
mod context;
|
||||
mod id;
|
||||
mod manager;
|
||||
mod process;
|
||||
mod processor;
|
||||
mod signal;
|
||||
mod switch;
|
||||
#[allow(clippy::module_inception)]
|
||||
mod task;
|
||||
|
||||
use crate::config::MAX_APP_NUM;
|
||||
use crate::loader::{get_num_app, init_app_cx};
|
||||
use core::cell::RefCell;
|
||||
use self::id::TaskUserRes;
|
||||
use crate::fs::{open_file, OpenFlags};
|
||||
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};
|
||||
|
||||
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 struct TaskManager {
|
||||
num_app: usize,
|
||||
inner: RefCell<TaskManagerInner>,
|
||||
pub fn suspend_current_and_run_next() {
|
||||
// There must be an application running.
|
||||
let task = take_current_task().unwrap();
|
||||
|
||||
// ---- 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);
|
||||
}
|
||||
|
||||
struct TaskManagerInner {
|
||||
tasks: [TaskControlBlock; MAX_APP_NUM],
|
||||
current_task: usize,
|
||||
/// This function must be followed by a schedule
|
||||
pub fn block_current_task() -> *mut TaskContext {
|
||||
let task = take_current_task().unwrap();
|
||||
let mut task_inner = task.inner_exclusive_access();
|
||||
task_inner.task_status = TaskStatus::Blocked;
|
||||
&mut task_inner.task_cx as *mut TaskContext
|
||||
}
|
||||
|
||||
unsafe impl Sync for TaskManager {}
|
||||
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 TASK_MANAGER: TaskManager = {
|
||||
let num_app = get_num_app();
|
||||
let mut tasks = [
|
||||
TaskControlBlock { task_cx_ptr: 0, 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_status = TaskStatus::Ready;
|
||||
}
|
||||
TaskManager {
|
||||
num_app,
|
||||
inner: RefCell::new(TaskManagerInner {
|
||||
tasks,
|
||||
current_task: 0,
|
||||
}),
|
||||
}
|
||||
pub static ref INITPROC: Arc<ProcessControlBlock> = {
|
||||
let inode = open_file("initproc", OpenFlags::RDONLY).unwrap();
|
||||
let v = inode.read_all();
|
||||
ProcessControlBlock::new(v.as_slice())
|
||||
};
|
||||
}
|
||||
|
||||
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();
|
||||
unsafe {
|
||||
__switch(
|
||||
&0usize as *const _,
|
||||
next_task_cx,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn mark_current_suspended(&self) {
|
||||
let mut inner = self.inner.borrow_mut();
|
||||
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 current = inner.current_task;
|
||||
inner.tasks[current].task_status = TaskStatus::Exited;
|
||||
}
|
||||
|
||||
fn find_next_task(&self) -> Option<usize> {
|
||||
let inner = self.inner.borrow();
|
||||
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.borrow_mut();
|
||||
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);
|
||||
unsafe {
|
||||
__switch(
|
||||
current_task_cx,
|
||||
next_task_cx,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
panic!("All applications completed!");
|
||||
}
|
||||
}
|
||||
pub fn add_initproc() {
|
||||
let _initproc = INITPROC.clone();
|
||||
}
|
||||
|
||||
pub fn run_first_task() {
|
||||
TASK_MANAGER.run_first_task();
|
||||
pub fn check_signals_of_current() -> Option<(i32, &'static str)> {
|
||||
let process = current_process();
|
||||
let process_inner = process.inner_exclusive_access();
|
||||
process_inner.signals.check_error()
|
||||
}
|
||||
|
||||
fn run_next_task() {
|
||||
TASK_MANAGER.run_next_task();
|
||||
pub fn current_add_signal(signal: SignalFlags) {
|
||||
let process = current_process();
|
||||
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();
|
||||
}
|
258
os/src/task/process.rs
Normal file
258
os/src/task/process.rs
Normal file
|
@ -0,0 +1,258 @@
|
|||
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
|
||||
}
|
||||
}
|
111
os/src/task/processor.rs
Normal file
111
os/src/task/processor.rs
Normal file
|
@ -0,0 +1,111 @@
|
|||
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);
|
||||
}
|
||||
}
|
29
os/src/task/signal.rs
Normal file
29
os/src/task/signal.rs
Normal file
|
@ -0,0 +1,29 @@
|
|||
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
|
||||
}
|
||||
}
|
||||
}
|
|
@ -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,8 @@
|
|||
use super::TaskContext;
|
||||
use core::arch::global_asm;
|
||||
|
||||
global_asm!(include_str!("switch.S"));
|
||||
|
||||
extern "C" {
|
||||
pub fn __switch(current_task_cx: *const usize, next_task_cx: *const usize);
|
||||
pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext);
|
||||
}
|
||||
|
|
|
@ -1,18 +1,80 @@
|
|||
use super::id::TaskUserRes;
|
||||
use super::{kstack_alloc, KernelStack, ProcessControlBlock, TaskContext};
|
||||
use crate::trap::TrapContext;
|
||||
use crate::{
|
||||
mm::PhysPageNum,
|
||||
sync::{UPIntrFreeCell, UPIntrRefMut},
|
||||
};
|
||||
use alloc::sync::{Arc, Weak};
|
||||
|
||||
pub struct TaskControlBlock {
|
||||
pub task_cx_ptr: usize,
|
||||
pub task_status: TaskStatus,
|
||||
// immutable
|
||||
pub process: Weak<ProcessControlBlock>,
|
||||
pub kstack: KernelStack,
|
||||
// mutable
|
||||
pub inner: UPIntrFreeCell<TaskControlBlockInner>,
|
||||
}
|
||||
|
||||
impl TaskControlBlock {
|
||||
pub fn get_task_cx_ptr2(&self) -> *const usize {
|
||||
&self.task_cx_ptr as *const usize
|
||||
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>,
|
||||
}
|
||||
|
||||
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,
|
||||
Exited,
|
||||
}
|
||||
Blocked,
|
||||
}
|
||||
|
|
|
@ -1,13 +1,74 @@
|
|||
use riscv::register::time;
|
||||
use core::cmp::Ordering;
|
||||
|
||||
use crate::config::CLOCK_FREQ;
|
||||
use crate::sbi::set_timer;
|
||||
use crate::config::CPU_FREQ;
|
||||
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;
|
||||
|
||||
pub fn get_time() -> usize {
|
||||
time::read()
|
||||
}
|
||||
|
||||
pub fn get_time_ms() -> usize {
|
||||
time::read() / (CLOCK_FREQ / MSEC_PER_SEC)
|
||||
}
|
||||
|
||||
pub fn set_next_trigger() {
|
||||
set_timer(get_time() + CPU_FREQ / TICKS_PER_SEC);
|
||||
}
|
||||
set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
|
@ -1,21 +1,37 @@
|
|||
use riscv::register::sstatus::{Sstatus, self, SPP};
|
||||
use riscv::register::sstatus::{self, Sstatus, 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) { self.x[2] = sp; }
|
||||
pub fn app_init_context(entry: usize, sp: usize) -> Self {
|
||||
pub fn set_sp(&mut self, sp: usize) {
|
||||
self.x[2] = sp;
|
||||
}
|
||||
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
|
||||
|
|
|
@ -1,69 +1,169 @@
|
|||
mod context;
|
||||
|
||||
use riscv::register::{
|
||||
mtvec::TrapMode,
|
||||
stvec,
|
||||
scause::{
|
||||
self,
|
||||
Trap,
|
||||
Exception,
|
||||
Interrupt,
|
||||
},
|
||||
stval,
|
||||
sstatus,
|
||||
sie,
|
||||
};
|
||||
use crate::config::TRAMPOLINE;
|
||||
use crate::syscall::syscall;
|
||||
use crate::task::{
|
||||
exit_current_and_run_next,
|
||||
suspend_current_and_run_next,
|
||||
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},
|
||||
sie, sip, sscratch, sstatus, stval, stvec,
|
||||
};
|
||||
use crate::timer::set_next_trigger;
|
||||
|
||||
global_asm!(include_str!("trap.S"));
|
||||
|
||||
pub fn init() {
|
||||
extern "C" { fn __alltraps(); }
|
||||
set_kernel_trap_entry();
|
||||
}
|
||||
|
||||
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 as usize, TrapMode::Direct);
|
||||
stvec::write(__alltraps_k_va, TrapMode::Direct);
|
||||
sscratch::write(trap_from_kernel as usize);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn enable_interrupt() {
|
||||
unsafe { sstatus::set_sie(); }
|
||||
fn set_user_trap_entry() {
|
||||
unsafe {
|
||||
stvec::write(TRAMPOLINE as usize, TrapMode::Direct);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn enable_timer_interrupt() {
|
||||
unsafe { sie::set_stimer(); }
|
||||
unsafe {
|
||||
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(cx: &mut TrapContext) -> &mut TrapContext {
|
||||
pub fn trap_handler() -> ! {
|
||||
set_kernel_trap_entry();
|
||||
let scause = scause::read();
|
||||
let stval = stval::read();
|
||||
// println!("into {:?}", scause.cause());
|
||||
match scause.cause() {
|
||||
Trap::Exception(Exception::UserEnvCall) => {
|
||||
// jump to next instruction anyway
|
||||
let mut cx = current_trap_cx();
|
||||
cx.sepc += 4;
|
||||
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::StorePageFault) => {
|
||||
println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, core dumped.", stval, cx.sepc);
|
||||
exit_current_and_run_next();
|
||||
Trap::Exception(Exception::StoreFault)
|
||||
| Trap::Exception(Exception::StorePageFault)
|
||||
| Trap::Exception(Exception::InstructionFault)
|
||||
| Trap::Exception(Exception::InstructionPageFault)
|
||||
| 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) => {
|
||||
println!("[kernel] IllegalInstruction in application, core dumped.");
|
||||
exit_current_and_run_next();
|
||||
current_add_signal(SignalFlags::SIGILL);
|
||||
}
|
||||
Trap::Interrupt(Interrupt::SupervisorTimer) => {
|
||||
set_next_trigger();
|
||||
check_timer();
|
||||
suspend_current_and_run_next();
|
||||
}
|
||||
Trap::Interrupt(Interrupt::SupervisorExternal) => {
|
||||
crate::board::irq_handler();
|
||||
}
|
||||
_ => {
|
||||
panic!("Unsupported trap {:?}, stval = {:#x}!", scause.cause(), stval);
|
||||
panic!(
|
||||
"Unsupported trap {:?}, stval = {:#x}!",
|
||||
scause.cause(),
|
||||
stval
|
||||
);
|
||||
}
|
||||
}
|
||||
cx
|
||||
// check signals
|
||||
if let Some((errno, msg)) = check_signals_of_current() {
|
||||
println!("[kernel] {}", msg);
|
||||
exit_current_and_run_next(errno);
|
||||
}
|
||||
trap_return();
|
||||
}
|
||||
|
||||
pub use context::TrapContext;
|
||||
#[no_mangle]
|
||||
pub fn trap_return() -> ! {
|
||||
disable_supervisor_interrupt();
|
||||
set_user_trap_entry();
|
||||
let trap_cx_user_va = current_trap_cx_user_va();
|
||||
let user_satp = current_user_token();
|
||||
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;
|
||||
|
|
|
@ -5,16 +5,16 @@
|
|||
.macro LOAD_GP n
|
||||
ld x\n, \n*8(sp)
|
||||
.endm
|
||||
.section .text
|
||||
.section .text.trampoline
|
||||
.globl __alltraps
|
||||
.globl __restore
|
||||
.globl __alltraps_k
|
||||
.globl __restore_k
|
||||
.align 2
|
||||
__alltraps:
|
||||
csrrw sp, sscratch, sp
|
||||
# now sp->kernel stack, sscratch->user stack
|
||||
# allocate a TrapContext on kernel stack
|
||||
addi sp, sp, -34*8
|
||||
# save general-purpose registers
|
||||
# now sp->*TrapContext in user space, sscratch->user stack
|
||||
# save other general purpose registers
|
||||
sd x1, 1*8(sp)
|
||||
# skip sp(x2), we will save it later
|
||||
sd x3, 3*8(sp)
|
||||
|
@ -25,28 +25,40 @@ __alltraps:
|
|||
SAVE_GP %n
|
||||
.set n, n+1
|
||||
.endr
|
||||
# we can use t0/t1/t2 freely, because they were saved on kernel stack
|
||||
# we can use t0/t1/t2 freely, because they have been saved in TrapContext
|
||||
csrr t0, sstatus
|
||||
csrr t1, sepc
|
||||
sd t0, 32*8(sp)
|
||||
sd t1, 33*8(sp)
|
||||
# read user stack from sscratch and save it on the kernel stack
|
||||
# read user stack from sscratch and save it in TrapContext
|
||||
csrr t2, sscratch
|
||||
sd t2, 2*8(sp)
|
||||
# set input argument of trap_handler(cx: &mut TrapContext)
|
||||
mv a0, sp
|
||||
call trap_handler
|
||||
# load kernel_satp into t0
|
||||
ld t0, 34*8(sp)
|
||||
# load trap_handler into t1
|
||||
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:
|
||||
# now sp->kernel stack(after allocated), sscratch->user stack
|
||||
# a0: *TrapContext in user space(Constant); a1: user space token
|
||||
# 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
|
||||
csrw sscratch, t2
|
||||
# restore general-purpuse registers except sp/tp
|
||||
# restore general purpose registers except x0/sp/tp
|
||||
ld x1, 1*8(sp)
|
||||
ld x3, 3*8(sp)
|
||||
.set n, 5
|
||||
|
@ -54,8 +66,39 @@ __restore:
|
|||
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
|
||||
# back to user stack
|
||||
ld sp, 2*8(sp)
|
||||
sret
|
||||
|
||||
.align 2
|
||||
__alltraps_k:
|
||||
addi sp, sp, -34*8
|
||||
sd x1, 1*8(sp)
|
||||
sd x3, 3*8(sp)
|
||||
.set n, 5
|
||||
.rept 27
|
||||
SAVE_GP %n
|
||||
.set n, n+1
|
||||
.endr
|
||||
csrr t0, sstatus
|
||||
csrr t1, sepc
|
||||
sd t0, 32*8(sp)
|
||||
sd t1, 33*8(sp)
|
||||
mv a0, sp
|
||||
csrr t2, sscratch
|
||||
jalr t2
|
||||
|
||||
__restore_k:
|
||||
ld t0, 32*8(sp)
|
||||
ld t1, 33*8(sp)
|
||||
csrw sstatus, t0
|
||||
csrw sepc, t1
|
||||
ld x1, 1*8(sp)
|
||||
ld x3, 3*8(sp)
|
||||
.set n, 5
|
||||
.rept 27
|
||||
LOAD_GP %n
|
||||
.set n, n+1
|
||||
.endr
|
||||
addi sp, sp, 34*8
|
||||
sret
|
||||
|
|
18
ping.py
Normal file
18
ping.py
Normal file
|
@ -0,0 +1,18 @@
|
|||
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)
|
|
@ -1 +0,0 @@
|
|||
nightly-2020-11-01
|
6
rust-toolchain.toml
Normal file
6
rust-toolchain.toml
Normal file
|
@ -0,0 +1,6 @@
|
|||
[toolchain]
|
||||
profile = "minimal"
|
||||
# use the nightly version of the last stable toolchain, see <https://forge.rust-lang.org/>
|
||||
channel = "nightly-2024-05-01"
|
||||
components = ["rust-src", "llvm-tools", "rustfmt", "clippy"]
|
||||
targets = ["riscv64gc-unknown-none-elf"]
|
2
setenv.sh
Normal file
2
setenv.sh
Normal file
|
@ -0,0 +1,2 @@
|
|||
export PATH=$(rustc --print sysroot)/bin:$PATH
|
||||
export RUST_SRC_PATH=$(rustc --print sysroot)/lib/rustlib/src/rust/library/
|
1452
tools/kflash.py
1452
tools/kflash.py
File diff suppressed because one or more lines are too long
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue