From 5cf4d12c8c7c6d92cd4bc44634ff8ba2e5e2446f Mon Sep 17 00:00:00 2001 From: "github-classroom[bot]" <66690702+github-classroom[bot]@users.noreply.github.com> Date: Mon, 29 Apr 2024 08:10:53 +0000 Subject: [PATCH] Initialize ch4 --- .dockerignore | 1 + .github/workflows/build.yml | 89 +++++ .gitignore | 19 + .gitlab-ci.yml | 12 + .vscode/settings.json | 13 + Dockerfile | 90 +++++ LICENSE | 674 +++++++++++++++++++++++++++++++++++ Makefile | 12 + README.md | 50 +++ bootloader/rustsbi-qemu.bin | Bin 0 -> 38592 bytes os/.cargo/config.toml | 7 + os/Cargo.toml | 15 + os/Makefile | 83 +++++ os/build.rs | 60 ++++ os/src/config.rs | 25 ++ os/src/console.rs | 34 ++ os/src/entry.asm | 12 + os/src/lang_items.rs | 20 ++ os/src/linker.ld | 53 +++ os/src/loader.rs | 26 ++ os/src/logging.rs | 45 +++ os/src/main.rs | 110 ++++++ os/src/mm/address.rs | 273 ++++++++++++++ os/src/mm/frame_allocator.rs | 137 +++++++ os/src/mm/heap_allocator.rs | 48 +++ os/src/mm/memory_set.rs | 412 +++++++++++++++++++++ os/src/mm/mod.rs | 28 ++ os/src/mm/page_table.rs | 173 +++++++++ os/src/sbi.rs | 40 +++ os/src/sync/mod.rs | 5 + os/src/sync/up.rs | 30 ++ os/src/syscall/fs.rs | 23 ++ os/src/syscall/mod.rs | 46 +++ os/src/syscall/process.rs | 76 ++++ os/src/task/context.rs | 32 ++ os/src/task/mod.rs | 204 +++++++++++ os/src/task/switch.S | 34 ++ os/src/task/switch.rs | 15 + os/src/task/task.rs | 112 ++++++ os/src/timer.rs | 35 ++ os/src/trap/context.rs | 49 +++ os/src/trap/mod.rs | 135 +++++++ os/src/trap/trap.S | 69 ++++ rust-toolchain.toml | 5 + 44 files changed, 3431 insertions(+) create mode 100644 .dockerignore create mode 100644 .github/workflows/build.yml create mode 100644 .gitignore create mode 100644 .gitlab-ci.yml create mode 100644 .vscode/settings.json create mode 100644 Dockerfile create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100755 bootloader/rustsbi-qemu.bin create mode 100644 os/.cargo/config.toml create mode 100644 os/Cargo.toml create mode 100644 os/Makefile create mode 100644 os/build.rs create mode 100644 os/src/config.rs create mode 100644 os/src/console.rs create mode 100644 os/src/entry.asm create mode 100644 os/src/lang_items.rs create mode 100644 os/src/linker.ld create mode 100644 os/src/loader.rs create mode 100644 os/src/logging.rs create mode 100644 os/src/main.rs create mode 100644 os/src/mm/address.rs create mode 100644 os/src/mm/frame_allocator.rs create mode 100644 os/src/mm/heap_allocator.rs create mode 100644 os/src/mm/memory_set.rs create mode 100644 os/src/mm/mod.rs create mode 100644 os/src/mm/page_table.rs create mode 100644 os/src/sbi.rs create mode 100644 os/src/sync/mod.rs create mode 100644 os/src/sync/up.rs create mode 100644 os/src/syscall/fs.rs create mode 100644 os/src/syscall/mod.rs create mode 100644 os/src/syscall/process.rs create mode 100644 os/src/task/context.rs create mode 100644 os/src/task/mod.rs create mode 100644 os/src/task/switch.S create mode 100644 os/src/task/switch.rs create mode 100644 os/src/task/task.rs create mode 100644 os/src/timer.rs create mode 100644 os/src/trap/context.rs create mode 100644 os/src/trap/mod.rs create mode 100644 os/src/trap/trap.S create mode 100644 rust-toolchain.toml diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..df3359d --- /dev/null +++ b/.dockerignore @@ -0,0 +1 @@ +*/* \ No newline at end of file diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..07719e1 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,89 @@ +name: Jobs + +on: [push] + +env: + CARGO_TERM_COLOR: always + rust_toolchain: nightly + +jobs: + build-doc: + if: github.repository == 'LearningOS/rCore-Tutorial-Code-2024S' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Build doc + run: | + git clone https://github.com/LearningOS/rCore-Tutorial-Test-2024S.git user + cd os + make + cargo doc --no-deps --verbose + - name: Push to gh-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 }} + basic-test: + runs-on: ubuntu-latest + outputs: + points: ${{ steps.end.outputs.points}} + container: + image: duskmoon/dev-env:rcore-ci + steps: + - uses: actions/checkout@v4 + - name: Run tests + run: | + qemu-system-riscv64 --version + rustup target add riscv64gc-unknown-none-elf + git config --global --add safe.directory /__w/${{ github.event.repository.name }}/${{ github.event.repository.name }} + git clone https://github.com/LearningOS/rCore-Tutorial-Checker-2024S.git ci-user + git clone https://github.com/LearningOS/rCore-Tutorial-Test-2024S.git ci-user/user + ID=`git rev-parse --abbrev-ref HEAD | grep -oP 'ch\K[0-9]'` + # cd ci-user && make test CHAPTER=$ID passwd=${{ secrets.BASE_TEST_TOKEN }} + cd ci-user && make test CHAPTER=$ID passwd=${{ secrets.BASE_TEST_TOKEN }} > ../output.txt + cat ../output.txt + - name: end + id: end + run: | + cat output.txt | grep -a "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}" + cat output.txt | grep -a "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}" >> $GITHUB_OUTPUT + gitlab-mirror: + if: github.repository == 'LearningOS/rCore-Tutorial-Code-2024S' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v1 + - name: Mirror + trigger CI + uses: tkf2019/gitlab-mirror-and-ci-action@master + with: + args: "https://git.tsinghua.edu.cn/os-lab/2024s/public/rcore-tutorial-code-2024s" + env: + GITLAB_HOSTNAME: "git.tsinghua.edu.cn" + GITLAB_PROJECT_ID: "29091" + GITLAB_PROJECT_NAME: "rcore-tutorial-code-2024s" + GITLAB_PROJECT_TOKEN: ${{secrets.GITLAB_PROJECT_TOKEN}} + GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}} + deploy: + if: github.repository != 'LearningOS/rCore-Tutorial-Code-2024S' + name: Deploy to pages + needs: basic-test + runs-on: ubuntu-latest + permissions: write-all + steps: + - uses: actions/checkout@v3 + continue-on-error: true + with: + ref: 'gh-pages' + - name: Save Log File + uses: yfblock/multi-rank-log@main + with: + public-dir: classroom + points: ${{ needs.basic-test.outputs.points }} + - name: GitHub Pages + uses: crazy-max/ghaction-github-pages@v3 + with: + target_branch: gh-pages + build_dir: ./classroom + keep_history: true + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..42539ab --- /dev/null +++ b/.gitignore @@ -0,0 +1,19 @@ +.*/* +!.github/* +!.vscode/settings.json +.idea +Cargo.lock +target +os/src/link_app.S +os/last-* +os/Cargo.lock +os/.gdb_history +easy-fs/Cargo.lock +easy-fs/target/* +easy-fs-fuse/Cargo.lock +easy-fs-fuse/target/* +tools/ +pushall.sh +*.bak + +user/* diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..5b9a600 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,12 @@ +default: + image: tkf2023/env:rcore-ci + +stages: + - test + +test-code-job: + stage: test + script: + - git clone https://token:${RCORE_CHECKER_REPO_READ_TOKEN_2024S}@git.tsinghua.edu.cn/os-lab/2024s/ta/rcore-tutorial-checker-2024s.git ci-user + - git clone https://token:${RCORE_TEST_REPO_READ_TOKEN_2024S}@git.tsinghua.edu.cn/os-lab/2024s/public/rcore-tutorial-test-2024s.git ci-user/user + - cd ci-user && make test CHAPTER=`echo $CI_COMMIT_REF_NAME | grep -oP 'ch\K[0-9]'` passwd=$BASE_TEST_TOKEN OFFLINE=1 diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..6a40655 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,13 @@ +{ + // Prevent "can't find crate for `test`" error on no_std + // Ref: https://github.com/rust-lang/vscode-rust/issues/729 + // For vscode-rust plugin users: + "rust.target": "riscv64gc-unknown-none-elf", + "rust.all_targets": false, + // For Rust Analyzer plugin users: + "rust-analyzer.cargo.target": "riscv64gc-unknown-none-elf", + "rust-analyzer.checkOnSave.allTargets": false, + // "rust-analyzer.cargo.features": [ + // "board_qemu" + // ] +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..5aea6ff --- /dev/null +++ b/Dockerfile @@ -0,0 +1,90 @@ +# syntax=docker/dockerfile:1 +# This Dockerfile is adapted from https://github.com/LearningOS/rCore-Tutorial-v3/blob/main/Dockerfile +# with the following major updates: +# - ubuntu 18.04 -> 20.04 +# - qemu 5.0.0 -> 7.0.0 +# - Extensive comments linking to relevant documentation +FROM ubuntu:20.04 + +ARG QEMU_VERSION=7.0.0 +ARG HOME=/root + +# 0. Install general tools +ARG DEBIAN_FRONTEND=noninteractive +RUN apt-get update && \ + apt-get install -y \ + curl \ + git \ + python3 \ + wget + +# 1. Set up QEMU RISC-V +# - https://learningos.github.io/rust-based-os-comp2022/0setup-devel-env.html#qemu +# - https://www.qemu.org/download/ +# - https://wiki.qemu.org/Documentation/Platforms/RISCV +# - https://risc-v-getting-started-guide.readthedocs.io/en/latest/linux-qemu.html + +# 1.1. Download source +WORKDIR ${HOME} +RUN wget https://download.qemu.org/qemu-${QEMU_VERSION}.tar.xz && \ + tar xvJf qemu-${QEMU_VERSION}.tar.xz + +# 1.2. Install dependencies +# - https://risc-v-getting-started-guide.readthedocs.io/en/latest/linux-qemu.html#prerequisites +RUN apt-get install -y \ + 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 git \ + ninja-build pkg-config libglib2.0-dev libpixman-1-dev libsdl2-dev + +# 1.3. Build and install from source +WORKDIR ${HOME}/qemu-${QEMU_VERSION} +RUN ./configure --target-list=riscv64-softmmu,riscv64-linux-user && \ + make -j$(nproc) && \ + make install + +# 1.4. Clean up +WORKDIR ${HOME} +RUN rm -rf qemu-${QEMU_VERSION} qemu-${QEMU_VERSION}.tar.xz + +# 1.5. Sanity checking +RUN qemu-system-riscv64 --version && \ + qemu-riscv64 --version + +# 2. Set up Rust +# - https://learningos.github.io/rust-based-os-comp2022/0setup-devel-env.html#qemu +# - https://www.rust-lang.org/tools/install +# - https://github.com/rust-lang/docker-rust/blob/master/Dockerfile-debian.template + +# 2.1. Install +ENV RUSTUP_HOME=/usr/local/rustup \ + CARGO_HOME=/usr/local/cargo \ + PATH=/usr/local/cargo/bin:$PATH \ + RUST_VERSION=nightly +RUN set -eux; \ + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o rustup-init; \ + chmod +x rustup-init; \ + ./rustup-init -y --no-modify-path --profile minimal --default-toolchain $RUST_VERSION; \ + rm rustup-init; \ + chmod -R a+w $RUSTUP_HOME $CARGO_HOME; + +# 2.2. Sanity checking +RUN rustup --version && \ + cargo --version && \ + rustc --version + +# 2.3 Env +RUN cargo install cargo-binutils; \ + rustup target add riscv64gc-unknown-none-elf; \ + rustup component add rust-src; \ + rustup component add llvm-tools-preview; \ + rustup component add rustfmt; \ + rustup component add clippy; + +# 3. Cargo vendor +WORKDIR ${HOME} +COPY os/vendor ./os-vendor +COPY user/vendor ./user-vendor + +# Ready to go +WORKDIR ${HOME} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..ede5291 --- /dev/null +++ b/Makefile @@ -0,0 +1,12 @@ +DOCKER_NAME ?= rcore-tutorial-v3 +.PHONY: docker build_docker + +docker: + docker run --rm -it -v ${PWD}:/mnt -w /mnt ${DOCKER_NAME} bash + +build_docker: + docker build -t ${DOCKER_NAME} . + +fmt: + cd os ; cargo fmt; cd .. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..9b17d52 --- /dev/null +++ b/README.md @@ -0,0 +1,50 @@ +# rCore-Tutorial-Code-2024S + +### Code +- [Soure Code of labs for 2024S](https://github.com/LearningOS/rCore-Tutorial-Code-2024S) +### Documents + +- Concise Manual: [rCore-Tutorial-Guide-2024S](https://LearningOS.github.io/rCore-Tutorial-Guide-2024S/) + +- Detail Book [rCore-Tutorial-Book-v3](https://rcore-os.github.io/rCore-Tutorial-Book-v3/) + + +### OS API docs of rCore Tutorial Code 2024S +- [OS API docs of ch1](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch1/os/index.html) + AND [OS API docs of ch2](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch2/os/index.html) +- [OS API docs of ch3](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch3/os/index.html) + AND [OS API docs of ch4](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch4/os/index.html) +- [OS API docs of ch5](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch5/os/index.html) + AND [OS API docs of ch6](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch6/os/index.html) +- [OS API docs of ch7](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch7/os/index.html) + AND [OS API docs of ch8](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch8/os/index.html) +- [OS API docs of ch9](https://learningos.github.io/rCore-Tutorial-Code-2024S/ch9/os/index.html) + +### Related Resources +- [Learning Resource](https://github.com/LearningOS/rust-based-os-comp2022/blob/main/relatedinfo.md) + + +### Build & Run + +```bash +# setup build&run environment first +$ git clone https://github.com/LearningOS/rCore-Tutorial-Code-2024S.git +$ cd rCore-Tutorial-Code-2024S +$ git clone https://github.com/LearningOS/rCore-Tutorial-Test-2024S.git user +$ cd os +$ git checkout ch$ID +$ make run +``` +Notice: $ID is from [1-9] + +### Grading + +```bash +# setup build&run environment first +$ git clone https://github.com/LearningOS/rCore-Tutorial-Code-2024S.git +$ cd rCore-Tutorial-Code-2024S +$ git clone https://github.com/LearningOS/rCore-Tutorial-Checker-2024S.git ci-user +$ git clone https://github.com/LearningOS/rCore-Tutorial-Test-2024S.git ci-user/user +$ cd ci-user && make test CHAPTER=$ID +``` +Notice: $ID is from [3,4,5,6,8] \ No newline at end of file diff --git a/bootloader/rustsbi-qemu.bin b/bootloader/rustsbi-qemu.bin new file mode 100755 index 0000000000000000000000000000000000000000..8960e1709acabe565de24e92cba81a9a094ebcc8 GIT binary patch literal 38592 zcmdSC3s@9K)-YT>P4^54Iyekhbw>!O^TiQGFiOmVu}5XqH6~z^-E0_}K{0Y?FeEVx z3_V;Ts2PD6;_isTB5&3hXTc=qB1ypLCVojaYLa)8MY#wDT~t6!ME+A<-GId0_I>~V zdH#MJ>VE3fsj72MRh=p`)ls27I}y@QO;7AxpBWT&g`vH7Zq>9+qiy+I8 z)8^0I%tUL{{qG>;k#4(OeX+Llx>7V4$ z%q->Ig~`PnuWIn}u|Qo6v&SbJT-H|Iz*Vlnd5=wkaR2+mRps*`zIRfjcOw#vM=Kgp zzIWd9b7nAJ&Mn7L-Z#!=XVI1IuWx^4M!)Z+>yfcXkkfJ;1r#ud)OoBuw#Pc(6=_^4 zg@#3{7$J|VOv5$g=7zK@dhD*0n}*GGS&if4MJ)eV=T|FKs>M7}DX|S4Kc&IluF9h{ zsyq+6b1C{8b&ub@o|=bjsL5O`OCwA9Yp{`wms z<@&Ccp_uclJMX)==yJr>B?EPyFZ)R~4BQRvLlf5uq;|)aNk~n*azUtmB2$Oy#VlwbQ{}mMYiJFvZ?x=)5vD=JYK3kwKl*ha6%pt`g zKTviAhG|R_3g?~Tp?iBwZ}>N$)xyE}i3u08Vsh$pl5k&;c3XTBp`C2! zmeIaI=MYLtX9ohWhFp%hxVlrMrCOw=dX$#B*G6c`2yQ@2s==MW3{E02Yg1%ew*L43 z4lP>`O>L(mT#=iwm#aj0M(BQ3BEWo6ua?K_N{K=R2h<}Jnk)?5i9+b*@f13oHaY8R z!rG+6NwFgoYUW96TFj#qYCVNePCDBc*c;Ll)3v%?q!1D*G699@f4{}Q)Hb_ zSdvto#Enp-X06n}4~JL=mcOpcn7S6{nNvKX>Og=n9 z8&KQVfpUNCx>LHf>X&Y z1IOI(_E@HIl9;Jto_=r7W%k!dj8@EZ#ap|~ewf6#ig_-1`z_PpJTG>*(aI~xsyv6R z>?g>|G@*TT2MVJ5(LTj#6r^Z?xK|-LKvE1kE?Q+}$0D=LAjk3fq#2JiiHBb`6DX*@D8B zwV^pPF8gl1R#A>qs2TQrMy>t7Rh1Da(q|CKCCQAm3M}dvdLzvJoAvcn##e{Vc0^WhU+A9QXi6N+)u*45BM#&X&*7 zD2AvQvabv%bqXjc6Mqa{nM@6Dl=oECZ8x z_cN&6$ormlXA%QgHaAme4D~cFbV#94V<=;^3ygZNG1FlTtsEF0w%Zc<%pGx|n!#qE zZ8%7ApsmjlbkwH-MQR(7LaT{m6mx=AUe4?e#P1$JPGd8=QFfs0m5|T1x@ z)ZZkdK?no7LHmGiBV`$9eLJCB%`~}85z-GboLs8Lpi&X-PM3v{tbrnwp9`TGD0H=t zecc7xb-867|DBSWzMQ|v(0NPvOANgTw7mRW53X(7Uv7~)I#|-G&WUy=SJqQEBIHyy zAbY-2-FBTB(hS1L{PR3y$FuQIgA{Xr$0Po>y*Z4qC)eyQlY7&6_ovzAfV*+ ze^7kY1hⅇ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 J>R;)1`3F5ESe5_) literal 0 HcmV?d00001 diff --git a/os/.cargo/config.toml b/os/.cargo/config.toml new file mode 100644 index 0000000..4275fca --- /dev/null +++ b/os/.cargo/config.toml @@ -0,0 +1,7 @@ +[build] +target = "riscv64gc-unknown-none-elf" + +[target.riscv64gc-unknown-none-elf] +rustflags = [ + "-Clink-arg=-Tsrc/linker.ld", "-Cforce-frame-pointers=yes" +] diff --git a/os/Cargo.toml b/os/Cargo.toml new file mode 100644 index 0000000..e609076 --- /dev/null +++ b/os/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "os" +version = "0.1.0" +authors = ["Yifan Wu "] +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +bitflags = "1.2.1" +buddy_system_allocator = "0.6" +lazy_static = { version = "1.4.0", features = ["spin_no_std"] } +log = "0.4" +riscv = { git = "https://github.com/rcore-os/riscv", features = ["inline-asm"] } +xmas-elf = "0.7.0" diff --git a/os/Makefile b/os/Makefile new file mode 100644 index 0000000..aed0c96 --- /dev/null +++ b/os/Makefile @@ -0,0 +1,83 @@ +# Building +TARGET := riscv64gc-unknown-none-elf +MODE := release +KERNEL_ELF := target/$(TARGET)/$(MODE)/os +KERNEL_BIN := $(KERNEL_ELF).bin +DISASM_TMP := target/$(TARGET)/$(MODE)/asm +OFFLINE := + +# BOARD +BOARD := qemu +SBI ?= rustsbi +BOOTLOADER := ../bootloader/$(SBI)-$(BOARD).bin + +# Building mode argument +ifeq ($(MODE), release) + MODE_ARG := --release +endif + +# KERNEL ENTRY +KERNEL_ENTRY_PA := 0x80200000 + +# Binutils +OBJDUMP := rust-objdump --arch-name=riscv64 +OBJCOPY := rust-objcopy --binary-architecture=riscv64 + +CHAPTER ?= $(shell git rev-parse --abbrev-ref HEAD | sed -E 's/ch([0-9])/\1/') +TEST ?= $(CHAPTER) +BASE ?= 1 + +# Disassembly +DISASM ?= -x + +build: env $(KERNEL_BIN) + +env: +ifeq ($(OFFLINE),) + (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 +endif + +$(KERNEL_BIN): kernel + @$(OBJCOPY) $(KERNEL_ELF) --strip-all -O binary $@ + +kernel: + @make -C ../user build TEST=$(TEST) CHAPTER=$(CHAPTER) BASE=$(BASE) + @echo Platform: $(BOARD) + @cargo build $(MODE_ARG) + +clean: + @cargo clean + +disasm: kernel + @$(OBJDUMP) $(DISASM) $(KERNEL_ELF) | less + +disasm-vim: kernel + @$(OBJDUMP) $(DISASM) $(KERNEL_ELF) > $(DISASM_TMP) + @vim $(DISASM_TMP) + @rm $(DISASM_TMP) + +run: run-inner + +run-inner: build + @qemu-system-riscv64 \ + -machine virt \ + -nographic \ + -bios $(BOOTLOADER) \ + -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) + +debug: build + @tmux new-session -d \ + "qemu-system-riscv64 -machine virt -nographic -bios $(BOOTLOADER) -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) -s -S" && \ + tmux split-window -h "riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234'" && \ + tmux -2 attach-session -d + +gdbserver: build + @qemu-system-riscv64 -machine virt -nographic -bios $(BOOTLOADER) -device loader,file=$(KERNEL_BIN),addr=$(KERNEL_ENTRY_PA) -s -S + +gdbclient: + @riscv64-unknown-elf-gdb -ex 'file $(KERNEL_ELF)' -ex 'set arch riscv:rv64' -ex 'target remote localhost:1234' + +.PHONY: build env kernel clean disasm disasm-vim run-inner gdbserver gdbclient diff --git a/os/build.rs b/os/build.rs new file mode 100644 index 0000000..63845c7 --- /dev/null +++ b/os/build.rs @@ -0,0 +1,60 @@ +//! Building applications linker + +use std::fs::{read_dir, File}; +use std::io::{Result, Write}; + +fn main() { + println!("cargo:rerun-if-changed=../user/src/"); + println!("cargo:rerun-if-changed={}", TARGET_PATH); + insert_app_data().unwrap(); +} + +static TARGET_PATH: &str = "../user/build/elf/"; + +/// get app data and build linker +fn insert_app_data() -> Result<()> { + let mut f = File::create("src/link_app.S").unwrap(); + let mut apps: Vec<_> = read_dir("../user/build/elf/") + .unwrap() + .into_iter() + .map(|dir_entry| { + let mut name_with_ext = dir_entry.unwrap().file_name().into_string().unwrap(); + name_with_ext.drain(name_with_ext.find('.').unwrap()..name_with_ext.len()); + name_with_ext + }) + .collect(); + apps.sort(); + + writeln!( + f, + r#" + .align 3 + .section .data + .global _num_app +_num_app: + .quad {}"#, + apps.len() + )?; + + for i in 0..apps.len() { + writeln!(f, r#" .quad app_{}_start"#, i)?; + } + writeln!(f, r#" .quad app_{}_end"#, apps.len() - 1)?; + + for (idx, app) in apps.iter().enumerate() { + println!("app_{}: {}", idx, app); + writeln!( + f, + r#" + .section .data + .global app_{0}_start + .global app_{0}_end + .align 3 +app_{0}_start: + .incbin "{2}{1}.elf" +app_{0}_end:"#, + idx, app, TARGET_PATH + )?; + } + Ok(()) +} diff --git a/os/src/config.rs b/os/src/config.rs new file mode 100644 index 0000000..5761cdd --- /dev/null +++ b/os/src/config.rs @@ -0,0 +1,25 @@ +//! Constants in the kernel + +#[allow(unused)] + +/// user app's stack size +pub const USER_STACK_SIZE: usize = 4096 * 2; +/// kernel stack size +pub const KERNEL_STACK_SIZE: usize = 4096 * 2; +/// kernel heap size +pub const KERNEL_HEAP_SIZE: usize = 0x200_0000; + +/// page size : 4KB +pub const PAGE_SIZE: usize = 0x1000; +/// page size bits: 12 +pub const PAGE_SIZE_BITS: usize = 0xc; +/// the max number of syscall +pub const MAX_SYSCALL_NUM: usize = 500; +/// the virtual addr of trapoline +pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1; +/// the virtual addr of trap context +pub const TRAP_CONTEXT_BASE: usize = TRAMPOLINE - PAGE_SIZE; +/// clock frequency +pub const CLOCK_FREQ: usize = 12500000; +/// the physical memory end +pub const MEMORY_END: usize = 0x88000000; diff --git a/os/src/console.rs b/os/src/console.rs new file mode 100644 index 0000000..f7d13ac --- /dev/null +++ b/os/src/console.rs @@ -0,0 +1,34 @@ +//! SBI console driver, for text output +use crate::sbi::console_putchar; +use core::fmt::{self, Write}; + +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); + } + Ok(()) + } +} + +pub fn print(args: fmt::Arguments) { + Stdout.write_fmt(args).unwrap(); +} + +/// Print! to the host console using the format string and arguments. +#[macro_export] +macro_rules! print { + ($fmt: literal $(, $($arg: tt)+)?) => { + $crate::console::print(format_args!($fmt $(, $($arg)+)?)) + } +} + +/// Println! to the host console using the format string and arguments. +#[macro_export] +macro_rules! println { + ($fmt: literal $(, $($arg: tt)+)?) => { + $crate::console::print(format_args!(concat!($fmt, "\n") $(, $($arg)+)?)) + } +} diff --git a/os/src/entry.asm b/os/src/entry.asm new file mode 100644 index 0000000..3a9990f --- /dev/null +++ b/os/src/entry.asm @@ -0,0 +1,12 @@ + .section .text.entry + .globl _start +_start: + la sp, boot_stack_top + call rust_main + + .section .bss.stack + .globl boot_stack_lower_bound +boot_stack_lower_bound: + .space 4096 * 16 + .globl boot_stack_top +boot_stack_top: \ No newline at end of file diff --git a/os/src/lang_items.rs b/os/src/lang_items.rs new file mode 100644 index 0000000..e8cf681 --- /dev/null +++ b/os/src/lang_items.rs @@ -0,0 +1,20 @@ +//! The panic handler + +use crate::sbi::shutdown; +use core::panic::PanicInfo; + +#[panic_handler] +/// panic handler +fn panic(info: &PanicInfo) -> ! { + if let Some(location) = info.location() { + println!( + "[kernel] Panicked at {}:{} {}", + location.file(), + location.line(), + info.message().unwrap() + ); + } else { + println!("[kernel] Panicked: {}", info.message().unwrap()); + } + shutdown() +} diff --git a/os/src/linker.ld b/os/src/linker.ld new file mode 100644 index 0000000..5baafbd --- /dev/null +++ b/os/src/linker.ld @@ -0,0 +1,53 @@ +OUTPUT_ARCH(riscv) +ENTRY(_start) +BASE_ADDRESS = 0x80200000; + +SECTIONS +{ + . = BASE_ADDRESS; + skernel = .; + + stext = .; + .text : { + *(.text.entry) + . = ALIGN(4K); + strampoline = .; + *(.text.trampoline); + . = ALIGN(4K); + *(.text .text.*) + } + + . = ALIGN(4K); + etext = .; + srodata = .; + .rodata : { + *(.rodata .rodata.*) + *(.srodata .srodata.*) + } + + . = ALIGN(4K); + erodata = .; + sdata = .; + .data : { + *(.data .data.*) + *(.sdata .sdata.*) + } + + . = ALIGN(4K); + edata = .; + sbss_with_stack = .; + .bss : { + *(.bss.stack) + sbss = .; + *(.bss .bss.*) + *(.sbss .sbss.*) + } + + . = ALIGN(4K); + ebss = .; + ekernel = .; + + /DISCARD/ : { + *(.eh_frame) + } +} \ No newline at end of file diff --git a/os/src/loader.rs b/os/src/loader.rs new file mode 100644 index 0000000..855187d --- /dev/null +++ b/os/src/loader.rs @@ -0,0 +1,26 @@ +//! Loading user applications into memory + +/// Get the total number of applications. +pub fn get_num_app() -> usize { + extern "C" { + fn _num_app(); + } + unsafe { (_num_app as usize as *const usize).read_volatile() } +} + +/// get applications data +pub fn get_app_data(app_id: usize) -> &'static [u8] { + 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) }; + assert!(app_id < num_app); + unsafe { + core::slice::from_raw_parts( + app_start[app_id] as *const u8, + app_start[app_id + 1] - app_start[app_id], + ) + } +} diff --git a/os/src/logging.rs b/os/src/logging.rs new file mode 100644 index 0000000..f6f0b69 --- /dev/null +++ b/os/src/logging.rs @@ -0,0 +1,45 @@ +//! Global logger + +use log::{Level, LevelFilter, Log, Metadata, Record}; + +/// a simple logger +struct SimpleLogger; + +impl Log for SimpleLogger { + fn enabled(&self, _metadata: &Metadata) -> bool { + true + } + fn log(&self, record: &Record) { + if !self.enabled(record.metadata()) { + return; + } + let color = match record.level() { + Level::Error => 31, // Red + Level::Warn => 93, // BrightYellow + Level::Info => 34, // Blue + Level::Debug => 32, // Green + Level::Trace => 90, // BrightBlack + }; + println!( + "\u{1B}[{}m[{:>5}] {}\u{1B}[0m", + color, + record.level(), + record.args(), + ); + } + fn flush(&self) {} +} + +/// initiate logger +pub fn init() { + static LOGGER: SimpleLogger = SimpleLogger; + log::set_logger(&LOGGER).unwrap(); + log::set_max_level(match option_env!("LOG") { + Some("ERROR") => LevelFilter::Error, + Some("WARN") => LevelFilter::Warn, + Some("INFO") => LevelFilter::Info, + Some("DEBUG") => LevelFilter::Debug, + Some("TRACE") => LevelFilter::Trace, + _ => LevelFilter::Off, + }); +} diff --git a/os/src/main.rs b/os/src/main.rs new file mode 100644 index 0000000..d79e798 --- /dev/null +++ b/os/src/main.rs @@ -0,0 +1,110 @@ +//! The main module and entrypoint +//! +//! Various facilities of the kernels are implemented as submodules. The most +//! important ones are: +//! +//! - [`trap`]: Handles all cases of switching from userspace to the kernel +//! - [`task`]: Task management +//! - [`syscall`]: System call handling and implementation +//! +//! The operating system also starts in this module. Kernel code starts +//! executing from `entry.asm`, after which [`rust_main()`] is called to +//! initialize various pieces of functionality. (See its source code for +//! details.) +//! +//! We then call [`task::run_first_task()`] and for the first time go to +//! userspace. + +#![deny(missing_docs)] +#![deny(warnings)] +#![no_std] +#![no_main] +#![feature(panic_info_message)] +#![feature(alloc_error_handler)] + +#[macro_use] +extern crate bitflags; +#[macro_use] +extern crate log; + +extern crate alloc; + +#[macro_use] +mod console; +pub mod config; +pub mod lang_items; +mod loader; +pub mod logging; +pub mod mm; +pub mod sbi; +pub mod sync; +pub mod syscall; +pub mod task; +pub mod timer; +pub mod trap; + +core::arch::global_asm!(include_str!("entry.asm")); +core::arch::global_asm!(include_str!("link_app.S")); + +/// clear BSS segment +fn clear_bss() { + extern "C" { + fn sbss(); + fn ebss(); + } + unsafe { + core::slice::from_raw_parts_mut(sbss as usize as *mut u8, ebss as usize - sbss as usize) + .fill(0); + } +} + +/// kernel log info +fn kernel_log_info() { + extern "C" { + fn stext(); // begin addr of text segment + fn etext(); // end addr of text segment + fn srodata(); // start addr of Read-Only data segment + fn erodata(); // end addr of Read-Only data ssegment + fn sdata(); // start addr of data segment + fn edata(); // end addr of data segment + fn sbss(); // start addr of BSS segment + fn ebss(); // end addr of BSS segment + fn boot_stack_lower_bound(); // stack lower bound + fn boot_stack_top(); // stack top + } + logging::init(); + println!("[kernel] Hello, world!"); + trace!( + "[kernel] .text [{:#x}, {:#x})", + stext as usize, + etext as usize + ); + debug!( + "[kernel] .rodata [{:#x}, {:#x})", + srodata as usize, erodata as usize + ); + info!( + "[kernel] .data [{:#x}, {:#x})", + sdata as usize, edata as usize + ); + warn!( + "[kernel] boot_stack top=bottom={:#x}, lower_bound={:#x}", + boot_stack_top as usize, boot_stack_lower_bound as usize + ); + error!("[kernel] .bss [{:#x}, {:#x})", sbss as usize, ebss as usize); +} + +#[no_mangle] +/// the rust entry-point of os +pub fn rust_main() -> ! { + clear_bss(); + kernel_log_info(); + mm::init(); + println!("[kernel] back to world!"); + mm::remap_test(); + trap::init(); + trap::enable_timer_interrupt(); + timer::set_next_trigger(); + task::run_first_task(); + panic!("Unreachable in rust_main!"); +} diff --git a/os/src/mm/address.rs b/os/src/mm/address.rs new file mode 100644 index 0000000..59a6acf --- /dev/null +++ b/os/src/mm/address.rs @@ -0,0 +1,273 @@ +//! Implementation of physical and virtual address and page number. +use super::PageTableEntry; +use crate::config::{PAGE_SIZE, PAGE_SIZE_BITS}; +use core::fmt::{self, Debug, Formatter}; +/// physical address +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; + +/// physical address +#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)] +pub struct PhysAddr(pub usize); +/// virtual address +#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)] +pub struct VirtAddr(pub usize); +/// physical page number +#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)] +pub struct PhysPageNum(pub usize); +/// virtual page number +#[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 for PhysAddr { + fn from(v: usize) -> Self { + Self(v & ((1 << PA_WIDTH_SV39) - 1)) + } +} +impl From for PhysPageNum { + fn from(v: usize) -> Self { + Self(v & ((1 << PPN_WIDTH_SV39) - 1)) + } +} +impl From for VirtAddr { + fn from(v: usize) -> Self { + Self(v & ((1 << VA_WIDTH_SV39) - 1)) + } +} +impl From for VirtPageNum { + fn from(v: usize) -> Self { + Self(v & ((1 << VPN_WIDTH_SV39) - 1)) + } +} +impl From for usize { + fn from(v: PhysAddr) -> Self { + v.0 + } +} +impl From for usize { + fn from(v: PhysPageNum) -> Self { + v.0 + } +} +impl From 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 for usize { + fn from(v: VirtPageNum) -> Self { + v.0 + } +} +/// virtual address impl +impl VirtAddr { + /// Get the (floor) virtual page number + pub fn floor(&self) -> VirtPageNum { + VirtPageNum(self.0 / PAGE_SIZE) + } + + /// Get the (ceil) virtual page number + pub fn ceil(&self) -> VirtPageNum { + VirtPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) + } + + /// Get the page offset of virtual address + pub fn page_offset(&self) -> usize { + self.0 & (PAGE_SIZE - 1) + } + + /// Check if the virtual address is aligned by page size + pub fn aligned(&self) -> bool { + self.page_offset() == 0 + } +} +impl From for VirtPageNum { + fn from(v: VirtAddr) -> Self { + assert_eq!(v.page_offset(), 0); + v.floor() + } +} +impl From for VirtAddr { + fn from(v: VirtPageNum) -> Self { + Self(v.0 << PAGE_SIZE_BITS) + } +} +impl PhysAddr { + /// Get the (floor) physical page number + pub fn floor(&self) -> PhysPageNum { + PhysPageNum(self.0 / PAGE_SIZE) + } + /// Get the (ceil) physical page number + pub fn ceil(&self) -> PhysPageNum { + PhysPageNum((self.0 - 1 + PAGE_SIZE) / PAGE_SIZE) + } + /// Get the page offset of physical address + pub fn page_offset(&self) -> usize { + self.0 & (PAGE_SIZE - 1) + } + /// Check if the physical address is aligned by page size + pub fn aligned(&self) -> bool { + self.page_offset() == 0 + } +} +impl From for PhysPageNum { + fn from(v: PhysAddr) -> Self { + assert_eq!(v.page_offset(), 0); + v.floor() + } +} +impl From for PhysAddr { + fn from(v: PhysPageNum) -> Self { + Self(v.0 << PAGE_SIZE_BITS) + } +} + +impl VirtPageNum { + /// Get the indexes of the page table entry + 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 { + ///Get mutable reference to `PhysAddr` value + /// Get the mutable reference of physical address + pub fn get_mut(&self) -> &'static mut T { + unsafe { (self.0 as *mut T).as_mut().unwrap() } + } +} +impl PhysPageNum { + /// Get the reference of page table(array of ptes) + 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) } + } + /// Get the reference of page(array of bytes) + 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) } + } + /// Get the mutable reference of physical address + pub fn get_mut(&self) -> &'static mut T { + let pa: PhysAddr = (*self).into(); + pa.get_mut() + } +} + +/// iterator for phy/virt page number +pub trait StepByOne { + /// step by one element(page number) + fn step(&mut self); +} +impl StepByOne for VirtPageNum { + fn step(&mut self) { + self.0 += 1; + } +} + +#[derive(Copy, Clone)] +/// a simple range structure for type T +pub struct SimpleRange +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ + l: T, + r: T, +} +impl SimpleRange +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 IntoIterator for SimpleRange +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ + type Item = T; + type IntoIter = SimpleRangeIterator; + fn into_iter(self) -> Self::IntoIter { + SimpleRangeIterator::new(self.l, self.r) + } +} +/// iterator for the simple range structure +pub struct SimpleRangeIterator +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ + current: T, + end: T, +} +impl SimpleRangeIterator +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ + pub fn new(l: T, r: T) -> Self { + Self { current: l, end: r } + } +} +impl Iterator for SimpleRangeIterator +where + T: StepByOne + Copy + PartialEq + PartialOrd + Debug, +{ + type Item = T; + fn next(&mut self) -> Option { + if self.current == self.end { + None + } else { + let t = self.current; + self.current.step(); + Some(t) + } + } +} +/// a simple range structure for virtual page number +pub type VPNRange = SimpleRange; diff --git a/os/src/mm/frame_allocator.rs b/os/src/mm/frame_allocator.rs new file mode 100644 index 0000000..01e62fd --- /dev/null +++ b/os/src/mm/frame_allocator.rs @@ -0,0 +1,137 @@ +//! Implementation of [`FrameAllocator`] which +//! controls all the frames in the operating system. + +use super::{PhysAddr, PhysPageNum}; +use crate::config::MEMORY_END; +use crate::sync::UPSafeCell; +use alloc::vec::Vec; +use core::fmt::{self, Debug, Formatter}; +use lazy_static::*; + +/// tracker for physical page frame allocation and deallocation +pub struct FrameTracker { + /// physical page number + pub ppn: PhysPageNum, +} + +impl FrameTracker { + /// Create a new 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; + fn dealloc(&mut self, ppn: PhysPageNum); +} +/// an implementation for frame allocator +pub struct StackFrameAllocator { + current: usize, + end: usize, + recycled: Vec, +} + +impl StackFrameAllocator { + pub fn init(&mut self, l: PhysPageNum, r: PhysPageNum) { + self.current = l.0; + self.end = r.0; + // trace!("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 { + 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 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! { + /// frame allocator instance through lazy_static! + pub static ref FRAME_ALLOCATOR: UPSafeCell = + unsafe { UPSafeCell::new(FrameAllocatorImpl::new()) }; +} +/// initiate the frame allocator using `ekernel` and `MEMORY_END` +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(), + ); +} + +/// Allocate a physical page frame in FrameTracker style +pub fn frame_alloc() -> Option { + FRAME_ALLOCATOR + .exclusive_access() + .alloc() + .map(FrameTracker::new) +} + +/// Deallocate a physical page frame with a given ppn +pub fn frame_dealloc(ppn: PhysPageNum) { + FRAME_ALLOCATOR.exclusive_access().dealloc(ppn); +} + +#[allow(unused)] +/// a simple test for frame allocator +pub fn frame_allocator_test() { + let mut v: Vec = 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!"); +} diff --git a/os/src/mm/heap_allocator.rs b/os/src/mm/heap_allocator.rs new file mode 100644 index 0000000..e5f8b30 --- /dev/null +++ b/os/src/mm/heap_allocator.rs @@ -0,0 +1,48 @@ +//! The global allocator +use crate::config::KERNEL_HEAP_SIZE; +use buddy_system_allocator::LockedHeap; + +#[global_allocator] +/// heap allocator instance +static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty(); + +#[alloc_error_handler] +/// panic when heap allocation error occurs +pub fn handle_alloc_error(layout: core::alloc::Layout) -> ! { + panic!("Heap allocation error, layout = {:?}", layout); +} +/// heap space ([u8; KERNEL_HEAP_SIZE]) +static mut HEAP_SPACE: [u8; KERNEL_HEAP_SIZE] = [0; KERNEL_HEAP_SIZE]; +/// initiate heap allocator +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 = 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!"); +} diff --git a/os/src/mm/memory_set.rs b/os/src/mm/memory_set.rs new file mode 100644 index 0000000..7a7b7ea --- /dev/null +++ b/os/src/mm/memory_set.rs @@ -0,0 +1,412 @@ +//! Implementation of [`MapArea`] and [`MemorySet`]. + +use super::{frame_alloc, FrameTracker}; +use super::{PTEFlags, PageTable, PageTableEntry}; +use super::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum}; +use super::{StepByOne, VPNRange}; +use crate::config::{ + KERNEL_STACK_SIZE, MEMORY_END, PAGE_SIZE, TRAMPOLINE, TRAP_CONTEXT_BASE, USER_STACK_SIZE, +}; +use crate::sync::UPSafeCell; +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! { + /// The kernel's initial memory mapping(kernel address space) + pub static ref KERNEL_SPACE: Arc> = + Arc::new(unsafe { UPSafeCell::new(MemorySet::new_kernel()) }); +} +/// address space +pub struct MemorySet { + page_table: PageTable, + areas: Vec, +} + +impl MemorySet { + /// Create a new empty `MemorySet`. + pub fn new_bare() -> Self { + Self { + page_table: PageTable::new(), + areas: Vec::new(), + } + } + /// Get the page table token + 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, + ); + } + 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(&mut 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 + info!(".text [{:#x}, {:#x})", stext as usize, etext as usize); + info!(".rodata [{:#x}, {:#x})", srodata as usize, erodata as usize); + info!(".data [{:#x}, {:#x})", sdata as usize, edata as usize); + info!( + ".bss [{:#x}, {:#x})", + sbss_with_stack as usize, ebss as usize + ); + info!("mapping .text section"); + memory_set.push( + MapArea::new( + (stext as usize).into(), + (etext as usize).into(), + MapType::Identical, + MapPermission::R | MapPermission::X, + ), + None, + ); + info!("mapping .rodata section"); + memory_set.push( + MapArea::new( + (srodata as usize).into(), + (erodata as usize).into(), + MapType::Identical, + MapPermission::R, + ), + None, + ); + info!("mapping .data section"); + memory_set.push( + MapArea::new( + (sdata as usize).into(), + (edata as usize).into(), + MapType::Identical, + MapPermission::R | MapPermission::W, + ), + None, + ); + info!("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, + ); + info!("mapping physical memory"); + memory_set.push( + MapArea::new( + (ekernel as usize).into(), + MEMORY_END.into(), + MapType::Identical, + MapPermission::R | MapPermission::W, + ), + None, + ); + memory_set + } + /// Include sections in elf and trampoline and TrapContext and user stack, + /// 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]), + ); + } + } + // map user stack with U flags + let max_end_va: VirtAddr = max_end_vpn.into(); + let mut user_stack_bottom: usize = max_end_va.into(); + // guard page + user_stack_bottom += PAGE_SIZE; + let user_stack_top = user_stack_bottom + USER_STACK_SIZE; + memory_set.push( + MapArea::new( + user_stack_bottom.into(), + user_stack_top.into(), + MapType::Framed, + MapPermission::R | MapPermission::W | MapPermission::U, + ), + None, + ); + // used in sbrk + memory_set.push( + MapArea::new( + user_stack_top.into(), + user_stack_top.into(), + MapType::Framed, + MapPermission::R | MapPermission::W | MapPermission::U, + ), + None, + ); + // map TrapContext + memory_set.push( + MapArea::new( + TRAP_CONTEXT_BASE.into(), + TRAMPOLINE.into(), + MapType::Framed, + MapPermission::R | MapPermission::W, + ), + None, + ); + ( + memory_set, + user_stack_top, + elf.header.pt2.entry_point() as usize, + ) + } + /// Change page table by writing satp CSR Register. + pub fn activate(&self) { + let satp = self.page_table.token(); + unsafe { + satp::write(satp); + asm!("sfence.vma"); + } + } + /// Translate a virtual page number to a page table entry + pub fn translate(&self, vpn: VirtPageNum) -> Option { + self.page_table.translate(vpn) + } + /// shrink the area to new_end + #[allow(unused)] + pub fn shrink_to(&mut self, start: VirtAddr, new_end: VirtAddr) -> bool { + if let Some(area) = self + .areas + .iter_mut() + .find(|area| area.vpn_range.get_start() == start.floor()) + { + area.shrink_to(&mut self.page_table, new_end.ceil()); + true + } else { + false + } + } + + /// append the area to new_end + #[allow(unused)] + pub fn append_to(&mut self, start: VirtAddr, new_end: VirtAddr) -> bool { + if let Some(area) = self + .areas + .iter_mut() + .find(|area| area.vpn_range.get_start() == start.floor()) + { + area.append_to(&mut self.page_table, new_end.ceil()); + true + } else { + false + } + } +} +/// map area structure, controls a contiguous piece of virtual memory +pub struct MapArea { + vpn_range: VPNRange, + data_frames: BTreeMap, + 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 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); + } + } + let pte_flags = PTEFlags::from_bits(self.map_perm.bits).unwrap(); + page_table.map(vpn, ppn, pte_flags); + } + #[allow(unused)] + 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); + } + } + #[allow(unused)] + pub fn unmap(&mut self, page_table: &mut PageTable) { + for vpn in self.vpn_range { + self.unmap_one(page_table, vpn); + } + } + #[allow(unused)] + pub fn shrink_to(&mut self, page_table: &mut PageTable, new_end: VirtPageNum) { + for vpn in VPNRange::new(new_end, self.vpn_range.get_end()) { + self.unmap_one(page_table, vpn) + } + self.vpn_range = VPNRange::new(self.vpn_range.get_start(), new_end); + } + #[allow(unused)] + pub fn append_to(&mut self, page_table: &mut PageTable, new_end: VirtPageNum) { + for vpn in VPNRange::new(self.vpn_range.get_end(), new_end) { + self.map_one(page_table, vpn) + } + self.vpn_range = VPNRange::new(self.vpn_range.get_start(), new_end); + } + /// data: start-aligned but maybe with shorter length + /// assume that all frames were cleared before + pub fn copy_data(&mut self, page_table: &mut 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)] +/// map type for memory set: identical or framed +pub enum MapType { + Identical, + Framed, +} + +bitflags! { + /// map permission corresponding to that in pte: `R W X U` + pub struct MapPermission: u8 { + ///Readable + const R = 1 << 1; + ///Writable + const W = 1 << 2; + ///Excutable + const X = 1 << 3; + ///Accessible in U mode + const U = 1 << 4; + } +} + +/// Return (bottom, top) of a kernel stack in kernel space. +pub fn kernel_stack_position(app_id: usize) -> (usize, usize) { + let top = TRAMPOLINE - app_id * (KERNEL_STACK_SIZE + PAGE_SIZE); + let bottom = top - KERNEL_STACK_SIZE; + (bottom, top) +} + +/// remap test in kernel space +#[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!"); +} diff --git a/os/src/mm/mod.rs b/os/src/mm/mod.rs new file mode 100644 index 0000000..06f045c --- /dev/null +++ b/os/src/mm/mod.rs @@ -0,0 +1,28 @@ +//! Memory management implementation +//! +//! SV39 page-based virtual-memory architecture for RV64 systems, and +//! everything about memory management, like frame allocator, page table, +//! map area and memory set, is implemented here. +//! +//! Every task or process has a memory_set to control its virtual memory. + +mod address; +mod frame_allocator; +mod heap_allocator; +mod memory_set; +mod page_table; + +pub use address::{PhysAddr, PhysPageNum, VirtAddr, VirtPageNum}; +use address::{StepByOne, VPNRange}; +pub use frame_allocator::{frame_alloc, FrameTracker}; +pub use memory_set::remap_test; +pub use memory_set::{kernel_stack_position, MapPermission, MemorySet, KERNEL_SPACE}; +pub use page_table::{translated_byte_buffer, PageTableEntry}; +use page_table::{PTEFlags, PageTable}; + +/// initiate heap allocator, frame allocator and kernel space +pub fn init() { + heap_allocator::init_heap(); + frame_allocator::init_frame_allocator(); + KERNEL_SPACE.exclusive_access().activate(); +} diff --git a/os/src/mm/page_table.rs b/os/src/mm/page_table.rs new file mode 100644 index 0000000..7946e33 --- /dev/null +++ b/os/src/mm/page_table.rs @@ -0,0 +1,173 @@ +//! Implementation of [`PageTableEntry`] and [`PageTable`]. + +use super::{frame_alloc, FrameTracker, PhysPageNum, StepByOne, VirtAddr, VirtPageNum}; +use alloc::vec; +use alloc::vec::Vec; +use bitflags::*; + +bitflags! { + /// page table entry flags + 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)] +/// page table entry structure +pub struct PageTableEntry { + /// bits of page table entry + pub bits: usize, +} + +impl PageTableEntry { + /// Create a new page table entry + pub fn new(ppn: PhysPageNum, flags: PTEFlags) -> Self { + PageTableEntry { + bits: ppn.0 << 10 | flags.bits as usize, + } + } + /// Create an empty page table entry + pub fn empty() -> Self { + PageTableEntry { bits: 0 } + } + /// Get the physical page number from the page table entry + pub fn ppn(&self) -> PhysPageNum { + (self.bits >> 10 & ((1usize << 44) - 1)).into() + } + /// Get the flags from the page table entry + pub fn flags(&self) -> PTEFlags { + PTEFlags::from_bits(self.bits as u8).unwrap() + } + /// The page pointered by page table entry is valid? + pub fn is_valid(&self) -> bool { + (self.flags() & PTEFlags::V) != PTEFlags::empty() + } + /// The page pointered by page table entry is readable? + pub fn readable(&self) -> bool { + (self.flags() & PTEFlags::R) != PTEFlags::empty() + } + /// The page pointered by page table entry is writable? + pub fn writable(&self) -> bool { + (self.flags() & PTEFlags::W) != PTEFlags::empty() + } + /// The page pointered by page table entry is executable? + pub fn executable(&self) -> bool { + (self.flags() & PTEFlags::X) != PTEFlags::empty() + } +} + +/// page table structure +pub struct PageTable { + root_ppn: PhysPageNum, + frames: Vec, +} + +/// Assume that it won't oom when creating/mapping. +impl PageTable { + /// Create a new page table + 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(), + } + } + /// Find PageTableEntry by VirtPageNum, create a frame for a 4KB page table if not exist + 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 + } + /// Find PageTableEntry by VirtPageNum + 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 + } + /// set the map between virtual page number and physical page number + #[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); + } + /// remove the map between virtual page number and physical page number + #[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(); + } + /// get the page table entry from the virtual page number + pub fn translate(&self, vpn: VirtPageNum) -> Option { + self.find_pte(vpn).map(|pte| *pte) + } + /// get the token from the page table + pub fn token(&self) -> usize { + 8usize << 60 | self.root_ppn.0 + } +} + +/// Translate&Copy a ptr[u8] array with LENGTH len to a mutable u8 Vec through page table +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 +} diff --git a/os/src/sbi.rs b/os/src/sbi.rs new file mode 100644 index 0000000..efb5369 --- /dev/null +++ b/os/src/sbi.rs @@ -0,0 +1,40 @@ +//! SBI call wrappers + +use core::arch::asm; + +const SBI_SET_TIMER: usize = 0; +const SBI_CONSOLE_PUTCHAR: usize = 1; +const SBI_SHUTDOWN: usize = 8; + +/// general sbi call +#[inline(always)] +fn sbi_call(which: usize, arg0: usize, arg1: usize, arg2: usize) -> usize { + let mut ret; + unsafe { + asm!( + "li x16, 0", + "ecall", + inlateout("x10") arg0 => ret, + in("x11") arg1, + in("x12") arg2, + in("x17") which, + ); + } + ret +} + +/// use sbi call to set timer +pub fn set_timer(timer: usize) { + sbi_call(SBI_SET_TIMER, timer, 0, 0); +} + +/// use sbi call to putchar in console (qemu uart handler) +pub fn console_putchar(c: usize) { + sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0); +} + +/// use sbi call to shutdown the kernel +pub fn shutdown() -> ! { + sbi_call(SBI_SHUTDOWN, 0, 0, 0); + panic!("It should shutdown!"); +} diff --git a/os/src/sync/mod.rs b/os/src/sync/mod.rs new file mode 100644 index 0000000..4743e31 --- /dev/null +++ b/os/src/sync/mod.rs @@ -0,0 +1,5 @@ +//! Synchronization and interior mutability primitives + +mod up; + +pub use up::UPSafeCell; diff --git a/os/src/sync/up.rs b/os/src/sync/up.rs new file mode 100644 index 0000000..d64ae1f --- /dev/null +++ b/os/src/sync/up.rs @@ -0,0 +1,30 @@ +//! Uniprocessor interior mutability primitives +use core::cell::{RefCell, RefMut}; + +/// Wrap a static data structure inside it so that we are +/// able to access it without any `unsafe`. +/// +/// We should only use it in uniprocessor. +/// +/// In order to get mutable reference of inner data, call +/// `exclusive_access`. +pub struct UPSafeCell { + /// inner data + inner: RefCell, +} + +unsafe impl Sync for UPSafeCell {} + +impl UPSafeCell { + /// 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() + } +} diff --git a/os/src/syscall/fs.rs b/os/src/syscall/fs.rs new file mode 100644 index 0000000..a1c5638 --- /dev/null +++ b/os/src/syscall/fs.rs @@ -0,0 +1,23 @@ +//! File and filesystem-related syscalls + +use crate::mm::translated_byte_buffer; +use crate::task::current_user_token; + +const FD_STDOUT: usize = 1; + +/// write buf of length `len` to a file with `fd` +pub fn sys_write(fd: usize, buf: *const u8, len: usize) -> isize { + trace!("kernel: sys_write"); + match fd { + FD_STDOUT => { + let buffers = translated_byte_buffer(current_user_token(), buf, len); + for buffer in buffers { + print!("{}", core::str::from_utf8(buffer).unwrap()); + } + len as isize + } + _ => { + panic!("Unsupported fd in sys_write!"); + } + } +} diff --git a/os/src/syscall/mod.rs b/os/src/syscall/mod.rs new file mode 100644 index 0000000..4a5297d --- /dev/null +++ b/os/src/syscall/mod.rs @@ -0,0 +1,46 @@ +//! Implementation of syscalls +//! +//! The single entry point to all system calls, [`syscall()`], is called +//! whenever userspace wishes to perform a system call using the `ecall` +//! instruction. In this case, the processor raises an 'Environment call from +//! U-mode' exception, which is handled as one of the cases in +//! [`crate::trap::trap_handler`]. +//! +//! For clarity, each single syscall is implemented as its own function, named +//! `sys_` then the name of the syscall. You can find functions like this in +//! submodules, and you should also implement syscalls this way. +const SYSCALL_WRITE: usize = 64; +/// exit syscall +const SYSCALL_EXIT: usize = 93; +/// yield syscall +const SYSCALL_YIELD: usize = 124; +/// gettime syscall +const SYSCALL_GET_TIME: usize = 169; +/// sbrk syscall +const SYSCALL_SBRK: usize = 214; +/// munmap syscall +const SYSCALL_MUNMAP: usize = 215; +/// mmap syscall +const SYSCALL_MMAP: usize = 222; +/// taskinfo syscall +const SYSCALL_TASK_INFO: usize = 410; + +mod fs; +mod process; + +use fs::*; +use process::*; +/// handle syscall exception with `syscall_id` and other arguments +pub fn syscall(syscall_id: usize, args: [usize; 3]) -> isize { + match syscall_id { + SYSCALL_WRITE => sys_write(args[0], args[1] as *const u8, args[2]), + SYSCALL_EXIT => sys_exit(args[0] as i32), + SYSCALL_YIELD => sys_yield(), + SYSCALL_GET_TIME => sys_get_time(args[0] as *mut TimeVal, args[1]), + SYSCALL_TASK_INFO => sys_task_info(args[0] as *mut TaskInfo), + SYSCALL_MMAP => sys_mmap(args[0], args[1], args[2]), + SYSCALL_MUNMAP => sys_munmap(args[0], args[1]), + SYSCALL_SBRK => sys_sbrk(args[0] as i32), + _ => panic!("Unsupported syscall_id: {}", syscall_id), + } +} diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs new file mode 100644 index 0000000..e2f6662 --- /dev/null +++ b/os/src/syscall/process.rs @@ -0,0 +1,76 @@ +//! Process management syscalls +use crate::{ + config::MAX_SYSCALL_NUM, + task::{ + change_program_brk, exit_current_and_run_next, suspend_current_and_run_next, TaskStatus, + }, +}; + +#[repr(C)] +#[derive(Debug)] +pub struct TimeVal { + pub sec: usize, + pub usec: usize, +} + +/// Task information +#[allow(dead_code)] +pub struct TaskInfo { + /// Task status in it's life cycle + status: TaskStatus, + /// The numbers of syscall called by task + syscall_times: [u32; MAX_SYSCALL_NUM], + /// Total running time of task + time: usize, +} + +/// task exits and submit an exit code +pub fn sys_exit(_exit_code: i32) -> ! { + trace!("kernel: sys_exit"); + exit_current_and_run_next(); + panic!("Unreachable in sys_exit!"); +} + +/// current task gives up resources for other tasks +pub fn sys_yield() -> isize { + trace!("kernel: sys_yield"); + suspend_current_and_run_next(); + 0 +} + +/// YOUR JOB: get time with second and microsecond +/// HINT: You might reimplement it with virtual memory management. +/// HINT: What if [`TimeVal`] is splitted by two pages ? +pub fn sys_get_time(_ts: *mut TimeVal, _tz: usize) -> isize { + trace!("kernel: sys_get_time"); + -1 +} + +/// YOUR JOB: Finish sys_task_info to pass testcases +/// HINT: You might reimplement it with virtual memory management. +/// HINT: What if [`TaskInfo`] is splitted by two pages ? +pub fn sys_task_info(_ti: *mut TaskInfo) -> isize { + trace!("kernel: sys_task_info NOT IMPLEMENTED YET!"); + -1 +} + +// YOUR JOB: Implement mmap. +pub fn sys_mmap(_start: usize, _len: usize, _port: usize) -> isize { + trace!("kernel: sys_mmap NOT IMPLEMENTED YET!"); + -1 +} + +// YOUR JOB: Implement munmap. +pub fn sys_munmap(_start: usize, _len: usize) -> isize { + trace!("kernel: sys_munmap NOT IMPLEMENTED YET!"); + -1 +} +/// change data segment size +pub fn sys_sbrk(size: i32) -> isize { + trace!("kernel: sys_sbrk"); + if let Some(old_brk) = change_program_brk(size) { + old_brk as isize + } else { + -1 + } +} diff --git a/os/src/task/context.rs b/os/src/task/context.rs new file mode 100644 index 0000000..81c8029 --- /dev/null +++ b/os/src/task/context.rs @@ -0,0 +1,32 @@ +//! Implementation of [`TaskContext`] +use crate::trap::trap_return; + +#[repr(C)] +/// task context structure containing some registers +pub struct TaskContext { + /// Ret position after task switching + ra: usize, + /// Stack pointer + sp: usize, + /// s0-11 register, callee saved + s: [usize; 12], +} + +impl TaskContext { + /// Create a new empty task context + pub fn zero_init() -> Self { + Self { + ra: 0, + sp: 0, + s: [0; 12], + } + } + /// Create a new task context with a trap return addr and a kernel stack pointer + pub fn goto_trap_return(kstack_ptr: usize) -> Self { + Self { + ra: trap_return as usize, + sp: kstack_ptr, + s: [0; 12], + } + } +} diff --git a/os/src/task/mod.rs b/os/src/task/mod.rs new file mode 100644 index 0000000..a745df8 --- /dev/null +++ b/os/src/task/mod.rs @@ -0,0 +1,204 @@ +//! Task management implementation +//! +//! Everything about task management, like starting and switching tasks is +//! implemented here. +//! +//! A single global instance of [`TaskManager`] called `TASK_MANAGER` controls +//! all the tasks in the operating system. +//! +//! Be careful when you see `__switch` ASM function in `switch.S`. Control flow around this function +//! might not be what you expect. + +mod context; +mod switch; +#[allow(clippy::module_inception)] +mod task; + +use crate::loader::{get_app_data, get_num_app}; +use crate::sync::UPSafeCell; +use crate::trap::TrapContext; +use alloc::vec::Vec; +use lazy_static::*; +use switch::__switch; +pub use task::{TaskControlBlock, TaskStatus}; + +pub use context::TaskContext; + +/// The task manager, where all the tasks are managed. +/// +/// Functions implemented on `TaskManager` deals with all task state transitions +/// and task context switching. For convenience, you can find wrappers around it +/// in the module level. +/// +/// Most of `TaskManager` are hidden behind the field `inner`, to defer +/// borrowing checks to runtime. You can see examples on how to use `inner` in +/// existing functions on `TaskManager`. +pub struct TaskManager { + /// total number of tasks + num_app: usize, + /// use inner value to get mutable access + inner: UPSafeCell, +} + +/// The task manager inner in 'UPSafeCell' +struct TaskManagerInner { + /// task list + tasks: Vec, + /// id of current `Running` task + current_task: usize, +} + +lazy_static! { + /// a `TaskManager` global instance through lazy_static! + pub static ref TASK_MANAGER: TaskManager = { + println!("init TASK_MANAGER"); + let num_app = get_num_app(); + println!("num_app = {}", num_app); + let mut tasks: Vec = Vec::new(); + for i in 0..num_app { + tasks.push(TaskControlBlock::new(get_app_data(i), i)); + } + TaskManager { + num_app, + inner: unsafe { + UPSafeCell::new(TaskManagerInner { + tasks, + current_task: 0, + }) + }, + } + }; +} + +impl TaskManager { + /// Run the first task in task list. + /// + /// Generally, the first task in task list is an idle task (we call it zero process later). + /// But in ch4, we load apps statically, so the first task is a real app. + fn run_first_task(&self) -> ! { + let mut inner = self.inner.exclusive_access(); + let next_task = &mut inner.tasks[0]; + next_task.task_status = TaskStatus::Running; + let next_task_cx_ptr = &next_task.task_cx as *const TaskContext; + drop(inner); + let mut _unused = TaskContext::zero_init(); + // before this, we should drop local variables that must be dropped manually + unsafe { + __switch(&mut _unused as *mut _, next_task_cx_ptr); + } + panic!("unreachable in run_first_task!"); + } + + /// Change the status of current `Running` task into `Ready`. + fn mark_current_suspended(&self) { + let mut inner = self.inner.exclusive_access(); + let cur = inner.current_task; + inner.tasks[cur].task_status = TaskStatus::Ready; + } + + /// Change the status of current `Running` task into `Exited`. + fn mark_current_exited(&self) { + let mut inner = self.inner.exclusive_access(); + let cur = inner.current_task; + inner.tasks[cur].task_status = TaskStatus::Exited; + } + + /// Find next task to run and return task id. + /// + /// In this case, we only return the first `Ready` task in task list. + fn find_next_task(&self) -> Option { + let inner = self.inner.exclusive_access(); + let current = inner.current_task; + (current + 1..current + self.num_app + 1) + .map(|id| id % self.num_app) + .find(|id| inner.tasks[*id].task_status == TaskStatus::Ready) + } + + /// Get the current 'Running' task's token. + fn get_current_token(&self) -> usize { + let inner = self.inner.exclusive_access(); + inner.tasks[inner.current_task].get_user_token() + } + + /// Get the current 'Running' task's trap contexts. + fn get_current_trap_cx(&self) -> &'static mut TrapContext { + let inner = self.inner.exclusive_access(); + inner.tasks[inner.current_task].get_trap_cx() + } + + /// Change the current 'Running' task's program break + pub fn change_current_program_brk(&self, size: i32) -> Option { + let mut inner = self.inner.exclusive_access(); + let cur = inner.current_task; + inner.tasks[cur].change_program_brk(size) + } + + /// Switch current `Running` task to the task we have found, + /// or there is no `Ready` task and we can exit with all applications completed + fn run_next_task(&self) { + if let Some(next) = self.find_next_task() { + let mut inner = self.inner.exclusive_access(); + let current = inner.current_task; + inner.tasks[next].task_status = TaskStatus::Running; + inner.current_task = next; + let current_task_cx_ptr = &mut inner.tasks[current].task_cx as *mut TaskContext; + let next_task_cx_ptr = &inner.tasks[next].task_cx as *const TaskContext; + drop(inner); + // before this, we should drop local variables that must be dropped manually + unsafe { + __switch(current_task_cx_ptr, next_task_cx_ptr); + } + // go back to user mode + } else { + panic!("All applications completed!"); + } + } +} + +/// Run the first task in task list. +pub fn run_first_task() { + TASK_MANAGER.run_first_task(); +} + +/// Switch current `Running` task to the task we have found, +/// or there is no `Ready` task and we can exit with all applications completed +fn run_next_task() { + TASK_MANAGER.run_next_task(); +} + +/// Change the status of current `Running` task into `Ready`. +fn mark_current_suspended() { + TASK_MANAGER.mark_current_suspended(); +} + +/// Change the status of current `Running` task into `Exited`. +fn mark_current_exited() { + TASK_MANAGER.mark_current_exited(); +} + +/// Suspend the current 'Running' task and run the next task in task list. +pub fn suspend_current_and_run_next() { + mark_current_suspended(); + run_next_task(); +} + +/// Exit the current 'Running' task and run the next task in task list. +pub fn exit_current_and_run_next() { + mark_current_exited(); + run_next_task(); +} + +/// Get the current 'Running' task's token. +pub fn current_user_token() -> usize { + TASK_MANAGER.get_current_token() +} + +/// Get the current 'Running' task's trap contexts. +pub fn current_trap_cx() -> &'static mut TrapContext { + TASK_MANAGER.get_current_trap_cx() +} + +/// Change the current 'Running' task's program break +pub fn change_program_brk(size: i32) -> Option { + TASK_MANAGER.change_current_program_brk(size) +} diff --git a/os/src/task/switch.S b/os/src/task/switch.S new file mode 100644 index 0000000..3f985d2 --- /dev/null +++ b/os/src/task/switch.S @@ -0,0 +1,34 @@ +.altmacro +.macro SAVE_SN n + sd s\n, (\n+2)*8(a0) +.endm +.macro LOAD_SN n + ld s\n, (\n+2)*8(a1) +.endm + .section .text + .globl __switch +__switch: + # __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 + # restore ra & s0~s11 of next execution + ld ra, 0(a1) + .set n, 0 + .rept 12 + LOAD_SN %n + .set n, n + 1 + .endr + # restore kernel stack of next task + ld sp, 8(a1) + ret + diff --git a/os/src/task/switch.rs b/os/src/task/switch.rs new file mode 100644 index 0000000..960b0b3 --- /dev/null +++ b/os/src/task/switch.rs @@ -0,0 +1,15 @@ +//! Rust wrapper around `__switch`. +//! +//! Switching to a different task's context happens here. The actual +//! implementation must not be in Rust and (essentially) has to be in assembly +//! language (Do you know why?), so this module really is just a wrapper around +//! `switch.S`. + +core::arch::global_asm!(include_str!("switch.S")); +use super::TaskContext; + +extern "C" { + /// Switch to the context of `next_task_cx_ptr`, saving the current context + /// in `current_task_cx_ptr`. + pub fn __switch(current_task_cx_ptr: *mut TaskContext, next_task_cx_ptr: *const TaskContext); +} diff --git a/os/src/task/task.rs b/os/src/task/task.rs new file mode 100644 index 0000000..dce6981 --- /dev/null +++ b/os/src/task/task.rs @@ -0,0 +1,112 @@ +//! Types related to task management +use super::TaskContext; +use crate::config::TRAP_CONTEXT_BASE; +use crate::mm::{ + kernel_stack_position, MapPermission, MemorySet, PhysPageNum, VirtAddr, KERNEL_SPACE, +}; +use crate::trap::{trap_handler, TrapContext}; + +/// The task control block (TCB) of a task. +pub struct TaskControlBlock { + /// Save task context + pub task_cx: TaskContext, + + /// Maintain the execution status of the current process + pub task_status: TaskStatus, + + /// Application address space + pub memory_set: MemorySet, + + /// The phys page number of trap context + pub trap_cx_ppn: PhysPageNum, + + /// The size(top addr) of program which is loaded from elf file + pub base_size: usize, + + /// Heap bottom + pub heap_bottom: usize, + + /// Program break + pub program_brk: usize, +} + +impl TaskControlBlock { + /// get the trap context + pub fn get_trap_cx(&self) -> &'static mut TrapContext { + self.trap_cx_ppn.get_mut() + } + /// get the user token + pub fn get_user_token(&self) -> usize { + self.memory_set.token() + } + /// Based on the elf info in program, build the contents of task in a new address space + pub fn new(elf_data: &[u8], app_id: usize) -> Self { + // memory_set with elf program headers/trampoline/trap context/user stack + let (memory_set, user_sp, entry_point) = MemorySet::from_elf(elf_data); + let trap_cx_ppn = memory_set + .translate(VirtAddr::from(TRAP_CONTEXT_BASE).into()) + .unwrap() + .ppn(); + let task_status = TaskStatus::Ready; + // map a kernel-stack in kernel space + let (kernel_stack_bottom, kernel_stack_top) = kernel_stack_position(app_id); + KERNEL_SPACE.exclusive_access().insert_framed_area( + kernel_stack_bottom.into(), + kernel_stack_top.into(), + MapPermission::R | MapPermission::W, + ); + let task_control_block = Self { + task_status, + task_cx: TaskContext::goto_trap_return(kernel_stack_top), + memory_set, + trap_cx_ppn, + base_size: user_sp, + heap_bottom: user_sp, + program_brk: user_sp, + }; + // prepare TrapContext in user space + let trap_cx = task_control_block.get_trap_cx(); + *trap_cx = TrapContext::app_init_context( + entry_point, + user_sp, + KERNEL_SPACE.exclusive_access().token(), + kernel_stack_top, + trap_handler as usize, + ); + task_control_block + } + /// change the location of the program break. return None if failed. + pub fn change_program_brk(&mut self, size: i32) -> Option { + let old_break = self.program_brk; + let new_brk = self.program_brk as isize + size as isize; + if new_brk < self.heap_bottom as isize { + return None; + } + let result = if size < 0 { + self.memory_set + .shrink_to(VirtAddr(self.heap_bottom), VirtAddr(new_brk as usize)) + } else { + self.memory_set + .append_to(VirtAddr(self.heap_bottom), VirtAddr(new_brk as usize)) + }; + if result { + self.program_brk = new_brk as usize; + Some(old_break) + } else { + None + } + } +} + +#[derive(Copy, Clone, PartialEq)] +/// task status: UnInit, Ready, Running, Exited +pub enum TaskStatus { + /// uninitialized + UnInit, + /// ready to run + Ready, + /// running + Running, + /// exited + Exited, +} diff --git a/os/src/timer.rs b/os/src/timer.rs new file mode 100644 index 0000000..8314d4b --- /dev/null +++ b/os/src/timer.rs @@ -0,0 +1,35 @@ +//! RISC-V timer-related functionality + +use crate::config::CLOCK_FREQ; +use crate::sbi::set_timer; +use riscv::register::time; +/// The number of ticks per second +const TICKS_PER_SEC: usize = 100; +#[allow(dead_code)] +/// The number of milliseconds per second +const MSEC_PER_SEC: usize = 1000; +/// The number of microseconds per second +#[allow(dead_code)] +const MICRO_PER_SEC: usize = 1_000_000; + +/// Get the current time in ticks +pub fn get_time() -> usize { + time::read() +} + +/// get current time in milliseconds +#[allow(dead_code)] +pub fn get_time_ms() -> usize { + time::read() * MSEC_PER_SEC / CLOCK_FREQ +} + +/// get current time in microseconds +#[allow(dead_code)] +pub fn get_time_us() -> usize { + time::read() * MICRO_PER_SEC / CLOCK_FREQ +} + +/// Set the next timer interrupt +pub fn set_next_trigger() { + set_timer(get_time() + CLOCK_FREQ / TICKS_PER_SEC); +} diff --git a/os/src/trap/context.rs b/os/src/trap/context.rs new file mode 100644 index 0000000..b187cb4 --- /dev/null +++ b/os/src/trap/context.rs @@ -0,0 +1,49 @@ +//! Implementation of [`TrapContext`] +use riscv::register::sstatus::{self, Sstatus, SPP}; + +#[repr(C)] +#[derive(Debug)] +/// trap context structure containing sstatus, sepc and registers +pub struct TrapContext { + /// General-Purpose Register x0-31 + pub x: [usize; 32], + /// Supervisor Status Register + pub sstatus: Sstatus, + /// Supervisor Exception Program Counter + pub sepc: usize, + /// Token of kernel address space + pub kernel_satp: usize, + /// Kernel stack pointer of the current application + pub kernel_sp: usize, + /// Virtual address of trap handler entry point in kernel + pub trap_handler: usize, +} + +impl TrapContext { + /// put the sp(stack pointer) into x\[2\] field of TrapContext + pub fn set_sp(&mut self, sp: usize) { + self.x[2] = sp; + } + /// init the trap context of an application + 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, // entry point of app + kernel_satp, // addr of page table + kernel_sp, // kernel stack + trap_handler, // addr of trap_handler function + }; + cx.set_sp(sp); // app's user stack pointer + cx // return initial Trap Context of app + } +} diff --git a/os/src/trap/mod.rs b/os/src/trap/mod.rs new file mode 100644 index 0000000..a024d9c --- /dev/null +++ b/os/src/trap/mod.rs @@ -0,0 +1,135 @@ +//! Trap handling functionality +//! +//! For rCore, we have a single trap entry point, namely `__alltraps`. At +//! initialization in [`init()`], we set the `stvec` CSR to point to it. +//! +//! All traps go through `__alltraps`, which is defined in `trap.S`. The +//! assembly language code does just enough work restore the kernel space +//! context, ensuring that Rust code safely runs, and transfers control to +//! [`trap_handler()`]. +//! +//! It then calls different functionality based on what exactly the exception +//! was. For example, timer interrupts trigger task preemption, and syscalls go +//! to [`syscall()`]. + +mod context; + +use crate::config::{TRAMPOLINE, TRAP_CONTEXT_BASE}; +use crate::syscall::syscall; +use crate::task::{ + current_trap_cx, current_user_token, exit_current_and_run_next, suspend_current_and_run_next, +}; +use crate::timer::set_next_trigger; +use core::arch::{asm, global_asm}; +use riscv::register::{ + mtvec::TrapMode, + scause::{self, Exception, Interrupt, Trap}, + sie, stval, stvec, +}; + +global_asm!(include_str!("trap.S")); + +/// Initialize trap handling +pub fn init() { + set_kernel_trap_entry(); +} + +fn set_kernel_trap_entry() { + unsafe { + stvec::write(trap_from_kernel as usize, TrapMode::Direct); + } +} + +fn set_user_trap_entry() { + unsafe { + stvec::write(TRAMPOLINE as usize, TrapMode::Direct); + } +} + +/// enable timer interrupt in supervisor mode +pub fn enable_timer_interrupt() { + unsafe { + sie::set_stimer(); + } +} + +/// trap handler +#[no_mangle] +pub fn trap_handler() -> ! { + set_kernel_trap_entry(); + let cx = current_trap_cx(); + let scause = scause::read(); // get trap cause + let stval = stval::read(); // get extra value + // trace!("into {:?}", scause.cause()); + match scause.cause() { + Trap::Exception(Exception::UserEnvCall) => { + // jump to next instruction anyway + cx.sepc += 4; + // get system call return value + cx.x[10] = syscall(cx.x[17], [cx.x[10], cx.x[11], cx.x[12]]) as usize; + } + Trap::Exception(Exception::StoreFault) + | Trap::Exception(Exception::StorePageFault) + | Trap::Exception(Exception::LoadFault) + | Trap::Exception(Exception::LoadPageFault) => { + println!("[kernel] PageFault in application, bad addr = {:#x}, bad instruction = {:#x}, kernel killed it.", stval, cx.sepc); + exit_current_and_run_next(); + } + Trap::Exception(Exception::IllegalInstruction) => { + println!("[kernel] IllegalInstruction in application, kernel killed it."); + exit_current_and_run_next(); + } + Trap::Interrupt(Interrupt::SupervisorTimer) => { + set_next_trigger(); + suspend_current_and_run_next(); + } + _ => { + panic!( + "Unsupported trap {:?}, stval = {:#x}!", + scause.cause(), + stval + ); + } + } + //println!("before trap_return"); + trap_return(); +} + +#[no_mangle] +/// return to user space +/// set the new addr of __restore asm function in TRAMPOLINE page, +/// set the reg a0 = trap_cx_ptr, reg a1 = phy addr of usr page table, +/// finally, jump to new addr of __restore asm function +pub fn trap_return() -> ! { + set_user_trap_entry(); + let trap_cx_ptr = TRAP_CONTEXT_BASE; + let user_satp = current_user_token(); + extern "C" { + fn __alltraps(); + fn __restore(); + } + let restore_va = __restore as usize - __alltraps as usize + TRAMPOLINE; + // trace!("[kernel] trap_return: ..before return"); + unsafe { + asm!( + "fence.i", + "jr {restore_va}", // jump to new addr of __restore asm function + restore_va = in(reg) restore_va, + in("a0") trap_cx_ptr, // a0 = virt addr of Trap Context + in("a1") user_satp, // a1 = phy addr of usr page table + options(noreturn) + ); + } +} + +#[no_mangle] +/// handle trap from kernel +/// Unimplement: traps/interrupts/exceptions from kernel mode +/// Todo: Chapter 9: I/O device +pub fn trap_from_kernel() -> ! { + use riscv::register::sepc; + trace!("stval = {:#x}, sepc = {:#x}", stval::read(), sepc::read()); + panic!("a trap {:?} from kernel!", scause::read().cause()); +} + +pub use context::TrapContext; diff --git a/os/src/trap/trap.S b/os/src/trap/trap.S new file mode 100644 index 0000000..c0e2d15 --- /dev/null +++ b/os/src/trap/trap.S @@ -0,0 +1,69 @@ +.altmacro +.macro SAVE_GP n + sd x\n, \n*8(sp) +.endm +.macro LOAD_GP n + ld x\n, \n*8(sp) +.endm + .section .text.trampoline + .globl __alltraps + .globl __restore + .align 2 +__alltraps: + csrrw sp, sscratch, sp + # 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) + # skip tp(x4), application does not use it + # save x5~x31 + .set n, 5 + .rept 27 + SAVE_GP %n + .set n, n+1 + .endr + # 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 in TrapContext + csrr t2, sscratch + sd t2, 2*8(sp) + # 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: + # 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) + csrw sstatus, t0 + csrw sepc, t1 + # restore general purpose registers except x0/sp/tp + ld x1, 1*8(sp) + ld x3, 3*8(sp) + .set n, 5 + .rept 27 + LOAD_GP %n + .set n, n+1 + .endr + # back to user stack + ld sp, 2*8(sp) + sret diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 0000000..e5e44e7 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,5 @@ +[toolchain] +profile = "minimal" +# use the nightly version of the last stable toolchain, see +channel = "nightly-2024-02-25" +components = ["rust-src", "llvm-tools-preview", "rustfmt", "clippy"]