From 3c10127ed495749cc06b581aeb04f4df3aa86c42 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:13:06 +0800 Subject: [PATCH 01/14] imports: riscv: add version with -xous support Add a local version of the `riscv` crate with support for `-xous-` as an OS. This allows us to build our kernel using `riscv32imac-unknown-xous-elf` as a target. Signed-off-by: Sean Cross --- imports/riscv-0.5.6/.github/CODEOWNERS | 1 + imports/riscv-0.5.6/.github/bors.toml | 4 + imports/riscv-0.5.6/.gitignore | 5 + imports/riscv-0.5.6/.travis.yml | 53 ++++ imports/riscv-0.5.6/CHANGELOG.md | 32 ++ imports/riscv-0.5.6/CODE_OF_CONDUCT.md | 37 +++ imports/riscv-0.5.6/Cargo.toml | 16 + imports/riscv-0.5.6/README.md | 36 +++ imports/riscv-0.5.6/asm.S | 282 ++++++++++++++++++ imports/riscv-0.5.6/asm.h | 48 +++ imports/riscv-0.5.6/assemble.ps1 | 20 ++ imports/riscv-0.5.6/assemble.sh | 22 ++ .../bin/riscv32i-unknown-none-elf.a | Bin 0 -> 72348 bytes .../bin/riscv32imac-unknown-none-elf.a | Bin 0 -> 71336 bytes .../bin/riscv32imac-unknown-xous-elf.a | Bin 0 -> 71336 bytes .../bin/riscv32imc-unknown-none-elf.a | Bin 0 -> 71336 bytes .../bin/riscv64gc-unknown-none-elf.a | Bin 0 -> 78570 bytes .../bin/riscv64imac-unknown-none-elf.a | Bin 0 -> 78570 bytes imports/riscv-0.5.6/build.rs | 26 ++ imports/riscv-0.5.6/check-blobs.sh | 21 ++ imports/riscv-0.5.6/ci/install.sh | 14 + imports/riscv-0.5.6/ci/script.sh | 16 + imports/riscv-0.5.6/src/asm.rs | 77 +++++ imports/riscv-0.5.6/src/interrupt.rs | 54 ++++ imports/riscv-0.5.6/src/lib.rs | 27 ++ imports/riscv-0.5.6/src/register/fcsr.rs | 132 ++++++++ .../riscv-0.5.6/src/register/hpmcounterx.rs | 82 +++++ imports/riscv-0.5.6/src/register/macros.rs | 270 +++++++++++++++++ imports/riscv-0.5.6/src/register/marchid.rs | 27 ++ imports/riscv-0.5.6/src/register/mcause.rs | 139 +++++++++ imports/riscv-0.5.6/src/register/mcycle.rs | 4 + imports/riscv-0.5.6/src/register/mcycleh.rs | 3 + imports/riscv-0.5.6/src/register/mepc.rs | 4 + imports/riscv-0.5.6/src/register/mhartid.rs | 3 + .../riscv-0.5.6/src/register/mhpmcounterx.rs | 84 ++++++ .../riscv-0.5.6/src/register/mhpmeventx.rs | 41 +++ imports/riscv-0.5.6/src/register/mideleg.rs | 76 +++++ imports/riscv-0.5.6/src/register/mie.rs | 103 +++++++ imports/riscv-0.5.6/src/register/mimpid.rs | 27 ++ imports/riscv-0.5.6/src/register/minstret.rs | 4 + imports/riscv-0.5.6/src/register/minstreth.rs | 3 + imports/riscv-0.5.6/src/register/mip.rs | 100 +++++++ imports/riscv-0.5.6/src/register/misa.rs | 60 ++++ imports/riscv-0.5.6/src/register/mod.rs | 114 +++++++ imports/riscv-0.5.6/src/register/mscratch.rs | 4 + imports/riscv-0.5.6/src/register/mstatus.rs | 200 +++++++++++++ imports/riscv-0.5.6/src/register/mtval.rs | 3 + imports/riscv-0.5.6/src/register/mtvec.rs | 47 +++ imports/riscv-0.5.6/src/register/mvendorid.rs | 32 ++ imports/riscv-0.5.6/src/register/pmpaddrx.rs | 28 ++ imports/riscv-0.5.6/src/register/pmpcfgx.rs | 23 ++ imports/riscv-0.5.6/src/register/satp.rs | 110 +++++++ imports/riscv-0.5.6/src/register/scause.rs | 117 ++++++++ imports/riscv-0.5.6/src/register/sepc.rs | 4 + imports/riscv-0.5.6/src/register/sie.rs | 76 +++++ imports/riscv-0.5.6/src/register/sip.rs | 55 ++++ imports/riscv-0.5.6/src/register/sscratch.rs | 4 + imports/riscv-0.5.6/src/register/sstatus.rs | 140 +++++++++ imports/riscv-0.5.6/src/register/stval.rs | 3 + imports/riscv-0.5.6/src/register/stvec.rs | 40 +++ imports/riscv-0.5.6/src/register/time.rs | 4 + imports/riscv-0.5.6/src/register/timeh.rs | 3 + imports/riscv-0.5.6/src/register/ucause.rs | 17 ++ imports/riscv-0.5.6/src/register/uepc.rs | 4 + imports/riscv-0.5.6/src/register/uie.rs | 49 +++ imports/riscv-0.5.6/src/register/uip.rs | 37 +++ imports/riscv-0.5.6/src/register/uscratch.rs | 4 + imports/riscv-0.5.6/src/register/ustatus.rs | 37 +++ imports/riscv-0.5.6/src/register/utval.rs | 3 + imports/riscv-0.5.6/src/register/utvec.rs | 40 +++ .../riscv-0.5.6/src/register/vexriscv/dci.rs | 10 + .../riscv-0.5.6/src/register/vexriscv/mim.rs | 4 + .../riscv-0.5.6/src/register/vexriscv/mip.rs | 3 + .../riscv-0.5.6/src/register/vexriscv/mod.rs | 13 + .../riscv-0.5.6/src/register/vexriscv/sim.rs | 4 + .../riscv-0.5.6/src/register/vexriscv/sip.rs | 3 + 76 files changed, 3188 insertions(+) create mode 100644 imports/riscv-0.5.6/.github/CODEOWNERS create mode 100644 imports/riscv-0.5.6/.github/bors.toml create mode 100644 imports/riscv-0.5.6/.gitignore create mode 100644 imports/riscv-0.5.6/.travis.yml create mode 100644 imports/riscv-0.5.6/CHANGELOG.md create mode 100644 imports/riscv-0.5.6/CODE_OF_CONDUCT.md create mode 100644 imports/riscv-0.5.6/Cargo.toml create mode 100644 imports/riscv-0.5.6/README.md create mode 100644 imports/riscv-0.5.6/asm.S create mode 100644 imports/riscv-0.5.6/asm.h create mode 100644 imports/riscv-0.5.6/assemble.ps1 create mode 100644 imports/riscv-0.5.6/assemble.sh create mode 100644 imports/riscv-0.5.6/bin/riscv32i-unknown-none-elf.a create mode 100644 imports/riscv-0.5.6/bin/riscv32imac-unknown-none-elf.a create mode 100644 imports/riscv-0.5.6/bin/riscv32imac-unknown-xous-elf.a create mode 100644 imports/riscv-0.5.6/bin/riscv32imc-unknown-none-elf.a create mode 100644 imports/riscv-0.5.6/bin/riscv64gc-unknown-none-elf.a create mode 100644 imports/riscv-0.5.6/bin/riscv64imac-unknown-none-elf.a create mode 100644 imports/riscv-0.5.6/build.rs create mode 100644 imports/riscv-0.5.6/check-blobs.sh create mode 100644 imports/riscv-0.5.6/ci/install.sh create mode 100644 imports/riscv-0.5.6/ci/script.sh create mode 100644 imports/riscv-0.5.6/src/asm.rs create mode 100644 imports/riscv-0.5.6/src/interrupt.rs create mode 100644 imports/riscv-0.5.6/src/lib.rs create mode 100644 imports/riscv-0.5.6/src/register/fcsr.rs create mode 100644 imports/riscv-0.5.6/src/register/hpmcounterx.rs create mode 100644 imports/riscv-0.5.6/src/register/macros.rs create mode 100644 imports/riscv-0.5.6/src/register/marchid.rs create mode 100644 imports/riscv-0.5.6/src/register/mcause.rs create mode 100644 imports/riscv-0.5.6/src/register/mcycle.rs create mode 100644 imports/riscv-0.5.6/src/register/mcycleh.rs create mode 100644 imports/riscv-0.5.6/src/register/mepc.rs create mode 100644 imports/riscv-0.5.6/src/register/mhartid.rs create mode 100644 imports/riscv-0.5.6/src/register/mhpmcounterx.rs create mode 100644 imports/riscv-0.5.6/src/register/mhpmeventx.rs create mode 100644 imports/riscv-0.5.6/src/register/mideleg.rs create mode 100644 imports/riscv-0.5.6/src/register/mie.rs create mode 100644 imports/riscv-0.5.6/src/register/mimpid.rs create mode 100644 imports/riscv-0.5.6/src/register/minstret.rs create mode 100644 imports/riscv-0.5.6/src/register/minstreth.rs create mode 100644 imports/riscv-0.5.6/src/register/mip.rs create mode 100644 imports/riscv-0.5.6/src/register/misa.rs create mode 100644 imports/riscv-0.5.6/src/register/mod.rs create mode 100644 imports/riscv-0.5.6/src/register/mscratch.rs create mode 100644 imports/riscv-0.5.6/src/register/mstatus.rs create mode 100644 imports/riscv-0.5.6/src/register/mtval.rs create mode 100644 imports/riscv-0.5.6/src/register/mtvec.rs create mode 100644 imports/riscv-0.5.6/src/register/mvendorid.rs create mode 100644 imports/riscv-0.5.6/src/register/pmpaddrx.rs create mode 100644 imports/riscv-0.5.6/src/register/pmpcfgx.rs create mode 100644 imports/riscv-0.5.6/src/register/satp.rs create mode 100644 imports/riscv-0.5.6/src/register/scause.rs create mode 100644 imports/riscv-0.5.6/src/register/sepc.rs create mode 100644 imports/riscv-0.5.6/src/register/sie.rs create mode 100644 imports/riscv-0.5.6/src/register/sip.rs create mode 100644 imports/riscv-0.5.6/src/register/sscratch.rs create mode 100644 imports/riscv-0.5.6/src/register/sstatus.rs create mode 100644 imports/riscv-0.5.6/src/register/stval.rs create mode 100644 imports/riscv-0.5.6/src/register/stvec.rs create mode 100644 imports/riscv-0.5.6/src/register/time.rs create mode 100644 imports/riscv-0.5.6/src/register/timeh.rs create mode 100644 imports/riscv-0.5.6/src/register/ucause.rs create mode 100644 imports/riscv-0.5.6/src/register/uepc.rs create mode 100644 imports/riscv-0.5.6/src/register/uie.rs create mode 100644 imports/riscv-0.5.6/src/register/uip.rs create mode 100644 imports/riscv-0.5.6/src/register/uscratch.rs create mode 100644 imports/riscv-0.5.6/src/register/ustatus.rs create mode 100644 imports/riscv-0.5.6/src/register/utval.rs create mode 100644 imports/riscv-0.5.6/src/register/utvec.rs create mode 100644 imports/riscv-0.5.6/src/register/vexriscv/dci.rs create mode 100644 imports/riscv-0.5.6/src/register/vexriscv/mim.rs create mode 100644 imports/riscv-0.5.6/src/register/vexriscv/mip.rs create mode 100644 imports/riscv-0.5.6/src/register/vexriscv/mod.rs create mode 100644 imports/riscv-0.5.6/src/register/vexriscv/sim.rs create mode 100644 imports/riscv-0.5.6/src/register/vexriscv/sip.rs diff --git a/imports/riscv-0.5.6/.github/CODEOWNERS b/imports/riscv-0.5.6/.github/CODEOWNERS new file mode 100644 index 000000000..87f6c03fa --- /dev/null +++ b/imports/riscv-0.5.6/.github/CODEOWNERS @@ -0,0 +1 @@ +* @rust-embedded/riscv \ No newline at end of file diff --git a/imports/riscv-0.5.6/.github/bors.toml b/imports/riscv-0.5.6/.github/bors.toml new file mode 100644 index 000000000..ca42be0a5 --- /dev/null +++ b/imports/riscv-0.5.6/.github/bors.toml @@ -0,0 +1,4 @@ +block_labels = ["needs-decision"] +delete_merged_branches = true +required_approvals = 1 +status = ["continuous-integration/travis-ci/push"] diff --git a/imports/riscv-0.5.6/.gitignore b/imports/riscv-0.5.6/.gitignore new file mode 100644 index 000000000..e38997ad9 --- /dev/null +++ b/imports/riscv-0.5.6/.gitignore @@ -0,0 +1,5 @@ +Cargo.lock +target/ +bin/*.after +bin/*.before +bin/*.o diff --git a/imports/riscv-0.5.6/.travis.yml b/imports/riscv-0.5.6/.travis.yml new file mode 100644 index 000000000..8810abe34 --- /dev/null +++ b/imports/riscv-0.5.6/.travis.yml @@ -0,0 +1,53 @@ +language: rust + +env: + - TARGET=x86_64-unknown-linux-gnu + - TARGET=riscv32imac-unknown-none-elf + +rust: + - nightly + - stable + - 1.30.0 # MSRV + +if: (branch = staging OR branch = trying OR branch = master) OR (type = pull_request AND branch = master) + +matrix: + include: + - env: TARGET=riscv64imac-unknown-none-elf + rust: nightly + if: (branch = staging OR branch = trying OR branch = master) OR (type = pull_request AND branch = master) + + - env: TARGET=riscv64gc-unknown-none-elf + rust: nightly + if: (branch = staging OR branch = trying OR branch = master) OR (type = pull_request AND branch = master) + + - env: CHECK_BLOBS=1 + rust: + language: bash + if: (branch = staging OR branch = trying OR branch = master) OR (type = pull_request AND branch = master) + + +install: + - ci/install.sh + +script: + - ci/script.sh + + +cache: + cargo: true + directories: + - gcc +before_cache: + # Travis can't cache files that are not readable by "others" + - chmod -R a+r $HOME/.cargo + +branches: + only: + - master + - staging + - trying + +notifications: + email: + on_success: never diff --git a/imports/riscv-0.5.6/CHANGELOG.md b/imports/riscv-0.5.6/CHANGELOG.md new file mode 100644 index 000000000..7268c8467 --- /dev/null +++ b/imports/riscv-0.5.6/CHANGELOG.md @@ -0,0 +1,32 @@ +# Change Log + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](http://keepachangelog.com/) +and this project adheres to [Semantic Versioning](http://semver.org/). + +## [Unreleased] + +## [v0.5.6] - 2020-03-14 + +### Added + +- Added vexriscv-specific registers + +## [v0.5.5] - 2020-02-28 + +### Added + +- Added `riscv32i-unknown-none-elf` target support +- Added user trap setup and handling registers +- Added write methods for the `mip` and `satp` registers +- Added `mideleg` register +- Added Changelog + +### Changed + +- Fixed MSRV by restricting the upper bound of `bare-metal` version + +[Unreleased]: https://github.com/rust-embedded/riscv/compare/v0.5.6...HEAD +[v0.5.6]: https://github.com/rust-embedded/riscv/compare/v0.5.5...v0.5.6 +[v0.5.5]: https://github.com/rust-embedded/riscv/compare/v0.5.4...v0.5.5 diff --git a/imports/riscv-0.5.6/CODE_OF_CONDUCT.md b/imports/riscv-0.5.6/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..fccadf9a9 --- /dev/null +++ b/imports/riscv-0.5.6/CODE_OF_CONDUCT.md @@ -0,0 +1,37 @@ +# The Rust Code of Conduct + +## Conduct + +**Contact**: [RISC-V team](https://github.com/rust-embedded/wg#the-riscv-team) + +* We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic. +* On IRC, please avoid using overtly sexual nicknames or other nicknames that might detract from a friendly, safe and welcoming environment for all. +* Please be kind and courteous. There's no need to be mean or rude. +* Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer. +* Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works. +* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term "harassment" as including the definition in the [Citizen Code of Conduct](http://citizencodeofconduct.org/); if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don't tolerate behavior that excludes people in socially marginalized groups. +* Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or any of the [RISC-V team][team] immediately. Whether you're a regular contributor or a newcomer, we care about making this community a safe place for you and we've got your back. +* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome. + +## Moderation + +These are the policies for upholding our community's standards of conduct. + +1. Remarks that violate the Rust standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner.) +2. Remarks that moderators find inappropriate, whether listed in the code of conduct or not, are also not allowed. +3. Moderators will first respond to such remarks with a warning. +4. If the warning is unheeded, the user will be "kicked," i.e., kicked out of the communication channel to cool off. +5. If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded. +6. Moderators may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology. +7. If a moderator bans someone and you think it was unjustified, please take it up with that moderator, or with a different moderator, **in private**. Complaints about bans in-channel are not allowed. +8. Moderators are held to a higher standard than other community members. If a moderator creates an inappropriate situation, they should expect less leeway than others. + +In the Rust community we strive to go the extra step to look out for each other. Don't just aim to be technically unimpeachable, try to be your best self. In particular, avoid flirting with offensive or sensitive issues, particularly if they're off-topic; this all too often leads to unnecessary fights, hurt feelings, and damaged trust; worse, it can drive people away from the community entirely. + +And if someone takes issue with something you said or did, resist the urge to be defensive. Just stop doing what it was they complained about and apologize. Even if you feel you were misinterpreted or unfairly accused, chances are good there was something you could've communicated better — remember that it's your responsibility to make your fellow Rustaceans comfortable. Everyone wants to get along and we are all here first and foremost because we want to talk about cool technology. You will find that people will be eager to assume good intent and forgive as long as you earn their trust. + +The enforcement policies listed above apply to all official embedded WG venues; including official IRC channels (#rust-embedded); GitHub repositories under rust-embedded; and all forums under rust-embedded.org (forum.rust-embedded.org). + +*Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) as well as the [Contributor Covenant v1.3.0](https://www.contributor-covenant.org/version/1/3/0/).* + +[team]: https://github.com/rust-embedded/wg#the-riscv-team diff --git a/imports/riscv-0.5.6/Cargo.toml b/imports/riscv-0.5.6/Cargo.toml new file mode 100644 index 000000000..cfe00a13e --- /dev/null +++ b/imports/riscv-0.5.6/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "riscv" +version = "0.5.6" +repository = "https://github.com/rust-embedded/riscv" +authors = ["The RISC-V Team "] +categories = ["embedded", "hardware-support", "no-std"] +description = "Low level access to RISC-V processors" +keywords = ["riscv", "register", "peripheral"] +license = "ISC" + +[dependencies] +bare-metal = ">=0.2.0,<0.2.5" +bit_field = "0.9.0" + +[features] +inline-asm = [] \ No newline at end of file diff --git a/imports/riscv-0.5.6/README.md b/imports/riscv-0.5.6/README.md new file mode 100644 index 000000000..807bd15b4 --- /dev/null +++ b/imports/riscv-0.5.6/README.md @@ -0,0 +1,36 @@ +[![crates.io](https://img.shields.io/crates/d/riscv.svg)](https://crates.io/crates/riscv) +[![crates.io](https://img.shields.io/crates/v/riscv.svg)](https://crates.io/crates/riscv) +[![Build Status](https://travis-ci.org/rust-embedded/riscv.svg?branch=master)](https://travis-ci.org/rust-embedded/riscv) + +# `riscv` + +> Low level access to RISC-V processors + +This project is developed and maintained by the [RISC-V team][team]. + +## [Documentation](https://docs.rs/crate/riscv) + +## License + +Copyright 2019 [RISC-V team][team] + +Permission to use, copy, modify, and/or distribute this software for any purpose +with or without fee is hereby granted, provided that the above copyright notice +and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. + +## Code of Conduct + +Contribution to this crate is organized under the terms of the [Rust Code of +Conduct][CoC], the maintainer of this crate, the [RISC-V team][team], promises +to intervene to uphold that code of conduct. + +[CoC]: CODE_OF_CONDUCT.md +[team]: https://github.com/rust-embedded/wg#the-riscv-team diff --git a/imports/riscv-0.5.6/asm.S b/imports/riscv-0.5.6/asm.S new file mode 100644 index 000000000..82da7845b --- /dev/null +++ b/imports/riscv-0.5.6/asm.S @@ -0,0 +1,282 @@ +#include "asm.h" + +.section .text.__ebreak +.global __ebreak +__ebreak: + ebreak + ret + +.section .text.__wfi +.global __wfi +__wfi: + wfi + ret + +.section .text.__sfence_vma_all +.global __sfence_vma_all +__sfence_vma_all: + sfence.vma + ret + +.section .text.__sfence_vma +.global __sfence_vma +__sfence_vma: + sfence.vma a0, a1 + ret + +// User Trap Setup +RW(0x000, ustatus) // User status register +RW(0x004, uie) // User interrupt-enable register +RW(0x005, utvec) // User trap handler base address + +// User Trap Handling +RW(0x040, uscratch) // Scratch register for user trap handlers +RW(0x041, uepc) // User exception program counter +RW(0x042, ucause) // User trap cause +RW(0x043, utval) // User bad address or instruction +RW(0x044, uip) // User interrupt pending + +// User Floating-Point CSRs +RW(0x001, fflags) // Floating-Point Accrued Exceptions +RW(0x002, frm) // Floating-Point Dynamic Rounding Mode +RW(0x003, fcsr) // Floating-Point Control and Status Register (frm + fflags) + +// User Counter/Timers +RO( 0xC00, cycle) // Cycle counter for RDCYCLE instruction +RO( 0xC01, time) // Timer for RDTIME instruction +RO( 0xC02, instret) // Instructions-retired counter for RDINSTRET instruction +RO( 0xC03, hpmcounter3) // Performance-monitoring counter +RO( 0xC04, hpmcounter4) // Performance-monitoring counter +RO( 0xC05, hpmcounter5) // Performance-monitoring counter +RO( 0xC06, hpmcounter6) // Performance-monitoring counter +RO( 0xC07, hpmcounter7) // Performance-monitoring counter +RO( 0xC08, hpmcounter8) // Performance-monitoring counter +RO( 0xC09, hpmcounter9) // Performance-monitoring counter +RO( 0xC0A, hpmcounter10) // Performance-monitoring counter +RO( 0xC0B, hpmcounter11) // Performance-monitoring counter +RO( 0xC0C, hpmcounter12) // Performance-monitoring counter +RO( 0xC0D, hpmcounter13) // Performance-monitoring counter +RO( 0xC0E, hpmcounter14) // Performance-monitoring counter +RO( 0xC0F, hpmcounter15) // Performance-monitoring counter +RO( 0xC10, hpmcounter16) // Performance-monitoring counter +RO( 0xC11, hpmcounter17) // Performance-monitoring counter +RO( 0xC12, hpmcounter18) // Performance-monitoring counter +RO( 0xC13, hpmcounter19) // Performance-monitoring counter +RO( 0xC14, hpmcounter20) // Performance-monitoring counter +RO( 0xC15, hpmcounter21) // Performance-monitoring counter +RO( 0xC16, hpmcounter22) // Performance-monitoring counter +RO( 0xC17, hpmcounter23) // Performance-monitoring counter +RO( 0xC18, hpmcounter24) // Performance-monitoring counter +RO( 0xC19, hpmcounter25) // Performance-monitoring counter +RO( 0xC1A, hpmcounter26) // Performance-monitoring counter +RO( 0xC1B, hpmcounter27) // Performance-monitoring counter +RO( 0xC1C, hpmcounter28) // Performance-monitoring counter +RO( 0xC1D, hpmcounter29) // Performance-monitoring counter +RO( 0xC1E, hpmcounter30) // Performance-monitoring counter +RO( 0xC1F, hpmcounter31) // Performance-monitoring counter +RO32(0xC80, cycleh) // Upper 32 bits of cycle, RV32I only +RO32(0xC81, timeh) // Upper 32 bits of time, RV32I only +RO32(0xC82, instreth) // Upper 32 bits of instret, RV32I only +RO32(0xC83, hpmcounter3h) // Upper 32 bits of hpmcounter3, RV32I only +RO32(0xC84, hpmcounter4h) +RO32(0xC85, hpmcounter5h) +RO32(0xC86, hpmcounter6h) +RO32(0xC87, hpmcounter7h) +RO32(0xC88, hpmcounter8h) +RO32(0xC89, hpmcounter9h) +RO32(0xC8A, hpmcounter10h) +RO32(0xC8B, hpmcounter11h) +RO32(0xC8C, hpmcounter12h) +RO32(0xC8D, hpmcounter13h) +RO32(0xC8E, hpmcounter14h) +RO32(0xC8F, hpmcounter15h) +RO32(0xC90, hpmcounter16h) +RO32(0xC91, hpmcounter17h) +RO32(0xC92, hpmcounter18h) +RO32(0xC93, hpmcounter19h) +RO32(0xC94, hpmcounter20h) +RO32(0xC95, hpmcounter21h) +RO32(0xC96, hpmcounter22h) +RO32(0xC97, hpmcounter23h) +RO32(0xC98, hpmcounter24h) +RO32(0xC99, hpmcounter25h) +RO32(0xC9A, hpmcounter26h) +RO32(0xC9B, hpmcounter27h) +RO32(0xC9C, hpmcounter28h) +RO32(0xC9D, hpmcounter29h) +RO32(0xC9E, hpmcounter30h) +RO32(0xC9F, hpmcounter31h) + +// Supervisor Trap Setup +RW(0x100, sstatus) // Supervisor status register +RW(0x102, sedeleg) // Supervisor exception delegation register +RW(0x103, sideleg) // Supervisor interrupt delegation register +RW(0x104, sie) // Supervisor interrupt-enable register +RW(0x105, stvec) // Supervisor trap handler base address +RW(0x106, scounteren) // Supervisor counter enable + +// Supervisor Trap Handling +RW(0x140, sscratch) // Scratch register for supervisor trap handlers +RW(0x141, sepc) // Supervisor exception program counter +RW(0x142, scause) // Supervisor trap cause +RW(0x143, stval) // Supervisor bad address or instruction +RW(0x144, sip) // Supervisor interrupt pending + +// Supervisor Protection and Translation +RW(0x180, satp) // Supervisor address translation and protection + +// Machine Information Registers +RO(0xF11, mvendorid) // Vendor ID +RO(0xF12, marchid) // Architecture ID +RO(0xF13, mimpid) // Implementation ID +RO(0xF14, mhartid) // Hardware thread ID + +// Machine Trap Setup +RW(0x300, mstatus) // Machine status register +RW(0x301, misa) // ISA and extensions +RW(0x302, medeleg) // Machine exception delegation register +RW(0x303, mideleg) // Machine interrupt delegation register +RW(0x304, mie) // Machine interrupt-enable register +RW(0x305, mtvec) // Machine trap handler base address +RW(0x306, mcounteren) // Machine counter enable + +// Machine Trap Handling +RW(0x340, mscratch) // Scratch register for machine trap handlers +RW(0x341, mepc) // Machine exception program counter +RW(0x342, mcause) // Machine trap cause +RW(0x343, mtval) // Machine bad address or instruction +RW(0x344, mip) // Machine interrupt pending + +// Machine Protection and Translation +RW( 0x3A0, pmpcfg0) // Physical memory protection configuration +RW32(0x3A1, pmpcfg1) // Physical memory protection configuration, RV32 only +RW( 0x3A2, pmpcfg2) // Physical memory protection configuration +RW32(0x3A3, pmpcfg3) // Physical memory protection configuration, RV32 only +RW( 0x3B0, pmpaddr0) // Physical memory protection address register +RW( 0x3B1, pmpaddr1) // Physical memory protection address register +RW( 0x3B2, pmpaddr2) // Physical memory protection address register +RW( 0x3B3, pmpaddr3) // Physical memory protection address register +RW( 0x3B4, pmpaddr4) // Physical memory protection address register +RW( 0x3B5, pmpaddr5) // Physical memory protection address register +RW( 0x3B6, pmpaddr6) // Physical memory protection address register +RW( 0x3B7, pmpaddr7) // Physical memory protection address register +RW( 0x3B8, pmpaddr8) // Physical memory protection address register +RW( 0x3B9, pmpaddr9) // Physical memory protection address register +RW( 0x3BA, pmpaddr10) // Physical memory protection address register +RW( 0x3BB, pmpaddr11) // Physical memory protection address register +RW( 0x3BC, pmpaddr12) // Physical memory protection address register +RW( 0x3BD, pmpaddr13) // Physical memory protection address register +RW( 0x3BE, pmpaddr14) // Physical memory protection address register +RW( 0x3BF, pmpaddr15) // Physical memory protection address register + +// Machine Counter/Timers +RO( 0xB00, mcycle) // Machine cycle counter +RO( 0xB02, minstret) // Machine instructions-retired counter +RO( 0xB03, mhpmcounter3) // Machine performance-monitoring counter +RO( 0xB04, mhpmcounter4) // Machine performance-monitoring counter +RO( 0xB05, mhpmcounter5) // Machine performance-monitoring counter +RO( 0xB06, mhpmcounter6) // Machine performance-monitoring counter +RO( 0xB07, mhpmcounter7) // Machine performance-monitoring counter +RO( 0xB08, mhpmcounter8) // Machine performance-monitoring counter +RO( 0xB09, mhpmcounter9) // Machine performance-monitoring counter +RO( 0xB0A, mhpmcounter10) // Machine performance-monitoring counter +RO( 0xB0B, mhpmcounter11) // Machine performance-monitoring counter +RO( 0xB0C, mhpmcounter12) // Machine performance-monitoring counter +RO( 0xB0D, mhpmcounter13) // Machine performance-monitoring counter +RO( 0xB0E, mhpmcounter14) // Machine performance-monitoring counter +RO( 0xB0F, mhpmcounter15) // Machine performance-monitoring counter +RO( 0xB10, mhpmcounter16) // Machine performance-monitoring counter +RO( 0xB11, mhpmcounter17) // Machine performance-monitoring counter +RO( 0xB12, mhpmcounter18) // Machine performance-monitoring counter +RO( 0xB13, mhpmcounter19) // Machine performance-monitoring counter +RO( 0xB14, mhpmcounter20) // Machine performance-monitoring counter +RO( 0xB15, mhpmcounter21) // Machine performance-monitoring counter +RO( 0xB16, mhpmcounter22) // Machine performance-monitoring counter +RO( 0xB17, mhpmcounter23) // Machine performance-monitoring counter +RO( 0xB18, mhpmcounter24) // Machine performance-monitoring counter +RO( 0xB19, mhpmcounter25) // Machine performance-monitoring counter +RO( 0xB1A, mhpmcounter26) // Machine performance-monitoring counter +RO( 0xB1B, mhpmcounter27) // Machine performance-monitoring counter +RO( 0xB1C, mhpmcounter28) // Machine performance-monitoring counter +RO( 0xB1D, mhpmcounter29) // Machine performance-monitoring counter +RO( 0xB1E, mhpmcounter30) // Machine performance-monitoring counter +RO( 0xB1F, mhpmcounter31) // Machine performance-monitoring counter +RO32(0xB80, mcycleh) // Upper 32 bits of mcycle, RV32I only +RO32(0xB82, minstreth) // Upper 32 bits of minstret, RV32I only +RO32(0xB83, mhpmcounter3h) // Upper 32 bits of mhpmcounter3, RV32I only +RO32(0xB84, mhpmcounter4h) +RO32(0xB85, mhpmcounter5h) +RO32(0xB86, mhpmcounter6h) +RO32(0xB87, mhpmcounter7h) +RO32(0xB88, mhpmcounter8h) +RO32(0xB89, mhpmcounter9h) +RO32(0xB8A, mhpmcounter10h) +RO32(0xB8B, mhpmcounter11h) +RO32(0xB8C, mhpmcounter12h) +RO32(0xB8D, mhpmcounter13h) +RO32(0xB8E, mhpmcounter14h) +RO32(0xB8F, mhpmcounter15h) +RO32(0xB90, mhpmcounter16h) +RO32(0xB91, mhpmcounter17h) +RO32(0xB92, mhpmcounter18h) +RO32(0xB93, mhpmcounter19h) +RO32(0xB94, mhpmcounter20h) +RO32(0xB95, mhpmcounter21h) +RO32(0xB96, mhpmcounter22h) +RO32(0xB97, mhpmcounter23h) +RO32(0xB98, mhpmcounter24h) +RO32(0xB99, mhpmcounter25h) +RO32(0xB9A, mhpmcounter26h) +RO32(0xB9B, mhpmcounter27h) +RO32(0xB9C, mhpmcounter28h) +RO32(0xB9D, mhpmcounter29h) +RO32(0xB9E, mhpmcounter30h) +RO32(0xB9F, mhpmcounter31h) + +RW(0x323, mhpmevent3) // Machine performance-monitoring event selector +RW(0x324, mhpmevent4) // Machine performance-monitoring event selector +RW(0x325, mhpmevent5) // Machine performance-monitoring event selector +RW(0x326, mhpmevent6) // Machine performance-monitoring event selector +RW(0x327, mhpmevent7) // Machine performance-monitoring event selector +RW(0x328, mhpmevent8) // Machine performance-monitoring event selector +RW(0x329, mhpmevent9) // Machine performance-monitoring event selector +RW(0x32A, mhpmevent10) // Machine performance-monitoring event selector +RW(0x32B, mhpmevent11) // Machine performance-monitoring event selector +RW(0x32C, mhpmevent12) // Machine performance-monitoring event selector +RW(0x32D, mhpmevent13) // Machine performance-monitoring event selector +RW(0x32E, mhpmevent14) // Machine performance-monitoring event selector +RW(0x32F, mhpmevent15) // Machine performance-monitoring event selector +RW(0x330, mhpmevent16) // Machine performance-monitoring event selector +RW(0x331, mhpmevent17) // Machine performance-monitoring event selector +RW(0x332, mhpmevent18) // Machine performance-monitoring event selector +RW(0x333, mhpmevent19) // Machine performance-monitoring event selector +RW(0x334, mhpmevent20) // Machine performance-monitoring event selector +RW(0x335, mhpmevent21) // Machine performance-monitoring event selector +RW(0x336, mhpmevent22) // Machine performance-monitoring event selector +RW(0x337, mhpmevent23) // Machine performance-monitoring event selector +RW(0x338, mhpmevent24) // Machine performance-monitoring event selector +RW(0x339, mhpmevent25) // Machine performance-monitoring event selector +RW(0x33A, mhpmevent26) // Machine performance-monitoring event selector +RW(0x33B, mhpmevent27) // Machine performance-monitoring event selector +RW(0x33C, mhpmevent28) // Machine performance-monitoring event selector +RW(0x33D, mhpmevent29) // Machine performance-monitoring event selector +RW(0x33E, mhpmevent30) // Machine performance-monitoring event selector +RW(0x33F, mhpmevent31) // Machine performance-monitoring event selector + +// Debug/Trace Registers (shared with Debug Mode) +RW(0x7A0, tselect) // Debug/Trace trigger register select +RW(0x7A1, tdata1) // First Debug/Trace trigger data register +RW(0x7A2, tdata2) // Second Debug/Trace trigger data register +RW(0x7A3, tdata3) // Third Debug/Trace trigger data register + +// Debug Mode Registers +RW(0x7B0, dcsr) // Debug control and status register +RW(0x7B1, dpc) // Debug PC +RW(0x7B2, dscratch) // Debug scratch register + +// VexRiscv custom registers +RW(0xBC0, vmim) // Machine IRQ Mask +RO(0xFC0, vmip) // Machine IRQ Pending +RW(0x9C0, vsim) // Supervisor IRQ Mask +RO(0xDC0, vsip) // Supervisor IRQ Pending +RO(0xCC0, vdci) // DCache Info diff --git a/imports/riscv-0.5.6/asm.h b/imports/riscv-0.5.6/asm.h new file mode 100644 index 000000000..2b675e7c5 --- /dev/null +++ b/imports/riscv-0.5.6/asm.h @@ -0,0 +1,48 @@ +#ifndef __ASM_H +#define __ASM_H + +#define REG_READ(name, offset) \ +.section .text.__read_ ## name; \ +.global __read_ ## name; \ +__read_ ## name: \ + csrrs a0, offset, x0; \ + ret + +#define REG_WRITE(name, offset) \ +.section .text.__write_ ## name; \ +.global __write_ ## name; \ +__write_ ## name: \ + csrrw x0, offset, a0; \ + ret + +#define REG_SET(name, offset) \ +.section .text.__set_ ## name; \ +.global __set_ ## name; \ +__set_ ## name: \ + csrrs x0, offset, a0; \ + ret + +#define REG_CLEAR(name, offset) \ +.section .text.__clear_ ## name; \ +.global __clear_ ## name; \ +__clear_ ## name: \ + csrrc x0, offset, a0; \ + ret + + +#define REG_READ_WRITE(name, offset) REG_READ(name, offset); REG_WRITE(name, offset) +#define REG_SET_CLEAR(name, offset) REG_SET(name, offset); REG_CLEAR(name, offset) + +#define RW(offset, name) REG_READ_WRITE(name, offset); REG_SET_CLEAR(name, offset) +#define RO(offset, name) REG_READ(name, offset) + +#if __riscv_xlen == 32 +#define RW32(offset, name) RW(offset, name) +#define RO32(offset, name) RO(offset, name) +#else +#define RW32(offset, name) +#define RO32(offset, name) +#endif + +#endif /* __ASM_H */ + diff --git a/imports/riscv-0.5.6/assemble.ps1 b/imports/riscv-0.5.6/assemble.ps1 new file mode 100644 index 000000000..1465c8e84 --- /dev/null +++ b/imports/riscv-0.5.6/assemble.ps1 @@ -0,0 +1,20 @@ +New-Item -Force -Name bin -Type Directory + +# remove existing blobs because otherwise this will append object files to the old blobs +Remove-Item -Force bin/*.a + +$crate = "riscv" + +riscv64-unknown-elf-gcc -c -mabi=ilp32 -march=rv32i asm.S -o bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv32i-unknown-none-elf.a bin/$crate.o + +riscv64-unknown-elf-gcc -c -mabi=ilp32 -march=rv32imc asm.S -o bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o + +riscv64-unknown-elf-gcc -c -mabi=lp64 -march=rv64imac asm.S -o bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv64imac-unknown-none-elf.a bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv64gc-unknown-none-elf.a bin/$crate.o + +Remove-Item bin/$crate.o diff --git a/imports/riscv-0.5.6/assemble.sh b/imports/riscv-0.5.6/assemble.sh new file mode 100644 index 000000000..8c6388488 --- /dev/null +++ b/imports/riscv-0.5.6/assemble.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +set -euxo pipefail + +crate=riscv + +# remove existing blobs because otherwise this will append object files to the old blobs +rm -f bin/*.a + +riscv64-unknown-elf-gcc -c -mabi=ilp32 -march=rv32i asm.S -o bin/$crate.o +ar crs bin/riscv32i-unknown-none-elf.a bin/$crate.o + +riscv64-unknown-elf-gcc -c -mabi=ilp32 -march=rv32imc asm.S -o bin/$crate.o +ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o +ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o +ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o + +riscv64-unknown-elf-gcc -c -mabi=lp64 -march=rv64imac asm.S -o bin/$crate.o +ar crs bin/riscv64imac-unknown-none-elf.a bin/$crate.o +ar crs bin/riscv64gc-unknown-none-elf.a bin/$crate.o + +rm bin/$crate.o diff --git a/imports/riscv-0.5.6/bin/riscv32i-unknown-none-elf.a b/imports/riscv-0.5.6/bin/riscv32i-unknown-none-elf.a new file mode 100644 index 0000000000000000000000000000000000000000..2d3f6eef1d5391b8138d11508b765bcd74686f31 GIT binary patch literal 72348 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%0D;K=O!K)CwYVgJg-VE@n1n&y) z%zf*$?cgr(a)S3XcryfVIe4=L@4w(R37+oG*ITpT^#pIO;PnS@zToW-UW?!z58gt- zs|T-D@Gb;ziQvrzuTAhC25*_*y#n3}!CMJlyWsr<-fF=s?7`RXTEW{Mymf*%1iXS^ zqfguJ4+F1I@T$SZpX4c>6UQ(N%$RxWrw z!K)Cw-M||oc*DV~61?NUs};O@@N$B80eCY6??&)u3*JNEH3{A;;57^0O7P|i-ml=z z7rbsg`TA`UydA+?D0subYZbiF;4KlnQ^0EzyjkEa6TIueTOoK4f!8j0FN3#Q@K%Di zR`7lSZ=K+6(u=RRg5dXEftvi7b64}@fmbMa!@%nYD0usW*D82p!CNADXMooxc+KD~ z6TAn&TOoL_g4Zs1tH4_=cq;gZ6Yll&TEW{Iymf*%2)u&e_rYn$zazja6uesSx(nWg z;Pn=~Tfr+5yr;nHCwT9HS1Ncvf;Uv~y7lJkW4Pe;1+QH2_6Dy)@J53-M)2yvs}j6R z!K)R#JHX2c-m~D%5WE%O%@(|0z-tn`&9>p|qgn9!gEv?34hC<&;7tOrMexo8Z=vAb z1YWD)JptYl!Fvb1Ho^M=yk&ydtq)($D+F&B@Y)4$BzUU@ZvuF01@9d2)(PJA;1vYl zgGf96Jpx{#;JpQ2cftD>yxxMh(YAa!7YW{u;Pn%{{lF^~ys_X76}&US8!mWPf>$nh z_kvd;c+Y`1M({oauS)QK1g}=`3bTBD#G#v*67JZ?53o z2;O|bTLfN<;JpFfLcv=FUaR2!1>O?D+hRMu-r59jckq@8-bnCP2;MmG+6C`4@Ky`n z9Pri(-kspB6THRX6$IZCN<03&2VSAzeGguD!P{VazCL;j-ge*>3ErOI^%J}b@Ja=* z7QCT?cL8|A1@C6?$_4Ln@G1oF-{6fAysyEl61;*P`1+_7yguON1aA;{GX!rGc(Vns z2D~Q0n+0C8;N1Y;T)|re-h9D(1H2Z&`x3l`f~Si3`e+rrt-xC%cmu#|6TCygTPAqb z;H?n6bHQsDylcT*EqD)sw^s081#g|;wS!j>eD5vo`1dDxg@V`9!Mhi{X2E+Nyt#t+5qR?j?`QB@1TV7_UmptvZ)fmY z1#ds_mI&Sn;I#?fH1L)Q-euse5WG9VYZtu5;H?(C55QY1ct3!*PVfqM=If&%_+Dt* z{_BBPD0usT*In?A0k5~cgV!W@Z-dt?cwd7zSMa**!q>-q z!RrHFi{K3gZ=v9g0`{U z+m)}kb%Iv}p83A}2Fm_udN~-pLcu!}yzYWG9=zUyHx0ZZ!Mhl|eu8%sc%_2(Ab3Ls z??v#23*HCdl?&c?;8h4-r+$3>juE_`;8h7;U+`)LZzy;`6}%?F zn+0C8;9UjYT*12?y!nFnBzP@?_ZD~y1@8;+S_SVf@RkT(W;edQv z1-}AMe&XYV!Z literal 0 HcmV?d00001 diff --git a/imports/riscv-0.5.6/bin/riscv32imac-unknown-none-elf.a b/imports/riscv-0.5.6/bin/riscv32imac-unknown-none-elf.a new file mode 100644 index 0000000000000000000000000000000000000000..c06d8ec33b73d3904b4306a5c7551370005f12bb GIT binary patch literal 71336 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 literal 0 HcmV?d00001 diff --git a/imports/riscv-0.5.6/bin/riscv64imac-unknown-none-elf.a b/imports/riscv-0.5.6/bin/riscv64imac-unknown-none-elf.a new file mode 100644 index 0000000000000000000000000000000000000000..46566ae5a349e93596b42c204197a65ebce01a97 GIT binary patch literal 78570 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 literal 0 HcmV?d00001 diff --git a/imports/riscv-0.5.6/build.rs b/imports/riscv-0.5.6/build.rs new file mode 100644 index 000000000..965af9740 --- /dev/null +++ b/imports/riscv-0.5.6/build.rs @@ -0,0 +1,26 @@ +use std::path::PathBuf; +use std::{env, fs}; + +fn main() { + let target = env::var("TARGET").unwrap(); + let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); + let name = env::var("CARGO_PKG_NAME").unwrap(); + + if target.starts_with("riscv") && env::var_os("CARGO_FEATURE_INLINE_ASM").is_none() { + fs::copy( + format!("bin/{}.a", target), + out_dir.join(format!("lib{}.a", name)), + ).unwrap(); + + println!("cargo:rustc-link-lib=static={}", name); + println!("cargo:rustc-link-search={}", out_dir.display()); + } + + if target.starts_with("riscv32") { + println!("cargo:rustc-cfg=riscv"); + println!("cargo:rustc-cfg=riscv32"); + } else if target.starts_with("riscv64") { + println!("cargo:rustc-cfg=riscv"); + println!("cargo:rustc-cfg=riscv64"); + } +} diff --git a/imports/riscv-0.5.6/check-blobs.sh b/imports/riscv-0.5.6/check-blobs.sh new file mode 100644 index 000000000..36d885e6e --- /dev/null +++ b/imports/riscv-0.5.6/check-blobs.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +# Checks that the blobs are up to date with the committed assembly files + +set -euxo pipefail + +for lib in $(ls bin/*.a); do + filename=$(basename $lib) + riscv64-unknown-elf-objdump -Cd $lib > bin/${filename%.a}.before +done + +./assemble.sh + +for lib in $(ls bin/*.a); do + filename=$(basename $lib) + riscv64-unknown-elf-objdump -Cd $lib > bin/${filename%.a}.after +done + +for cksum in $(ls bin/*.after); do + diff -u $cksum ${cksum%.after}.before +done diff --git a/imports/riscv-0.5.6/ci/install.sh b/imports/riscv-0.5.6/ci/install.sh new file mode 100644 index 000000000..0130ccd86 --- /dev/null +++ b/imports/riscv-0.5.6/ci/install.sh @@ -0,0 +1,14 @@ +#!/usr/bin/env bash + +set -euxo pipefail + +if [ -n "${TARGET:-}" ]; then + rustup target add $TARGET +fi + +if [ -n "${CHECK_BLOBS:-}" ]; then + if [ ! -d gcc/bin ]; then + mkdir -p gcc + curl -L https://static.dev.sifive.com/dev-tools/riscv64-unknown-elf-gcc-8.1.0-2018.12.0-x86_64-linux-ubuntu14.tar.gz | tar --strip-components=1 -C gcc -xz + fi +fi diff --git a/imports/riscv-0.5.6/ci/script.sh b/imports/riscv-0.5.6/ci/script.sh new file mode 100644 index 000000000..376bd732f --- /dev/null +++ b/imports/riscv-0.5.6/ci/script.sh @@ -0,0 +1,16 @@ +#!/usr/bin/env bash + +set -euxo pipefail + +if [ -n "${TARGET:-}" ]; then + cargo check --target $TARGET + + if [ $TRAVIS_RUST_VERSION = nightly ]; then + cargo check --target $TARGET --features inline-asm + fi +fi + +if [ -n "${CHECK_BLOBS:-}" ]; then + PATH="$PATH:$PWD/gcc/bin" + ./check-blobs.sh +fi diff --git a/imports/riscv-0.5.6/src/asm.rs b/imports/riscv-0.5.6/src/asm.rs new file mode 100644 index 000000000..8ce24b78f --- /dev/null +++ b/imports/riscv-0.5.6/src/asm.rs @@ -0,0 +1,77 @@ +//! Assembly instructions + +macro_rules! instruction { + ($(#[$attr:meta])*, $fnname:ident, $asm:expr, $asm_fn:ident) => ( + $(#[$attr])* + #[inline] + pub unsafe fn $fnname() { + match () { + #[cfg(all(riscv, feature = "inline-asm"))] + () => asm!($asm :::: "volatile"), + + #[cfg(all(riscv, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn(); + } + + $asm_fn(); + } + + #[cfg(not(riscv))] + () => unimplemented!(), + } + } + ) +} + + +instruction!( + /// `EBREAK` instruction wrapper + /// + /// Generates a breakpoint exception. + , ebreak, "ebreak", __ebreak); +instruction!( + /// `WFI` instruction wrapper + /// + /// Provides a hint to the implementation that the current hart can be stalled until an interrupt might need servicing. + /// The WFI instruction is just a hint, and a legal implementation is to implement WFI as a NOP. + , wfi, "wfi", __wfi); +instruction!( + /// `SFENCE.VMA` instruction wrapper (all address spaces and page table levels) + /// + /// Synchronizes updates to in-memory memory-management data structures with current execution. + /// Instruction execution causes implicit reads and writes to these data structures; however, these implicit references + /// are ordinarily not ordered with respect to loads and stores in the instruction stream. + /// Executing an `SFENCE.VMA` instruction guarantees that any stores in the instruction stream prior to the + /// `SFENCE.VMA` are ordered before all implicit references subsequent to the `SFENCE.VMA`. + , sfence_vma_all, "sfence.vma", __sfence_vma_all); + + +/// `SFENCE.VMA` instruction wrapper +/// +/// Synchronizes updates to in-memory memory-management data structures with current execution. +/// Instruction execution causes implicit reads and writes to these data structures; however, these implicit references +/// are ordinarily not ordered with respect to loads and stores in the instruction stream. +/// Executing an `SFENCE.VMA` instruction guarantees that any stores in the instruction stream prior to the +/// `SFENCE.VMA` are ordered before all implicit references subsequent to the `SFENCE.VMA`. +#[inline] +#[allow(unused_variables)] +pub unsafe fn sfence_vma(asid: usize, addr: usize) { + match () { + #[cfg(all(riscv, feature = "inline-asm"))] + () => asm!("sfence.vma $0, $1" :: "r"(asid), "r"(addr) :: "volatile"), + + #[cfg(all(riscv, not(feature = "inline-asm")))] + () => { + extern "C" { + fn __sfence_vma(asid: usize, addr: usize); + } + + __sfence_vma(asid, addr); + } + + #[cfg(not(riscv))] + () => unimplemented!(), + } +} diff --git a/imports/riscv-0.5.6/src/interrupt.rs b/imports/riscv-0.5.6/src/interrupt.rs new file mode 100644 index 000000000..b569e11e4 --- /dev/null +++ b/imports/riscv-0.5.6/src/interrupt.rs @@ -0,0 +1,54 @@ +//! Interrupts + +// NOTE: Adapted from cortex-m/src/interrupt.rs +pub use bare_metal::{CriticalSection, Mutex, Nr}; +use register::mstatus; + +/// Disables all interrupts +#[inline] +pub unsafe fn disable() { + match () { + #[cfg(riscv)] + () => mstatus::clear_mie(), + #[cfg(not(riscv))] + () => unimplemented!(), + } +} + +/// Enables all the interrupts +/// +/// # Safety +/// +/// - Do not call this function inside an `interrupt::free` critical section +#[inline] +pub unsafe fn enable() { + match () { + #[cfg(riscv)] + () => mstatus::set_mie(), + #[cfg(not(riscv))] + () => unimplemented!(), + } +} + +/// Execute closure `f` in an interrupt-free context. +/// +/// This as also known as a "critical section". +pub fn free(f: F) -> R +where + F: FnOnce(&CriticalSection) -> R, +{ + let mstatus = mstatus::read(); + + // disable interrupts + unsafe { disable(); } + + let r = f(unsafe { &CriticalSection::new() }); + + // If the interrupts were active before our `disable` call, then re-enable + // them. Otherwise, keep them disabled + if mstatus.mie() { + unsafe { enable(); } + } + + r +} diff --git a/imports/riscv-0.5.6/src/lib.rs b/imports/riscv-0.5.6/src/lib.rs new file mode 100644 index 000000000..4c3d76d71 --- /dev/null +++ b/imports/riscv-0.5.6/src/lib.rs @@ -0,0 +1,27 @@ +//! Low level access to RISC-V processors +//! +//! # Minimum Supported Rust Version (MSRV) +//! +//! This crate is guaranteed to compile on stable Rust 1.30 and up. It *might* +//! compile with older versions but that may change in any new patch release. +//! Note that `riscv64imac-unknown-none-elf` and `riscv64gc-unknown-none-elf` targets +//! are not supported on stable yet. +//! +//! # Features +//! +//! This crate provides: +//! +//! - Access to core registers like `mstatus` or `mcause`. +//! - Interrupt manipulation mechanisms. +//! - Wrappers around assembly instructions like `WFI`. + +#![no_std] +#![deny(warnings)] +#![cfg_attr(feature = "inline-asm", feature(asm))] + +extern crate bare_metal; +extern crate bit_field; + +pub mod asm; +pub mod interrupt; +pub mod register; diff --git a/imports/riscv-0.5.6/src/register/fcsr.rs b/imports/riscv-0.5.6/src/register/fcsr.rs new file mode 100644 index 000000000..ba204ff71 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/fcsr.rs @@ -0,0 +1,132 @@ +//! Floating-point control and status register + +use bit_field::BitField; + +/// Floating-point control and status register +#[derive(Clone, Copy, Debug)] +pub struct FCSR { + bits: u32, +} + +/// Accrued Exception Flags +#[derive(Clone, Copy, Debug)] +pub struct Flags(u32); + +/// Accrued Exception Flag +#[derive(Clone, Copy, Debug)] +pub enum Flag { + /// Inexact + NX = 0b00001, + + /// Underflow + UF = 0b00010, + + /// Overflow + OF = 0b00100, + + /// Divide by Zero + DZ = 0b01000, + + /// Invalid Operation + NV = 0b10000, +} + +impl Flags { + /// Inexact + #[inline] + pub fn nx(&self) -> bool { + self.0.get_bit(0) + } + + /// Underflow + #[inline] + pub fn uf(&self) -> bool { + self.0.get_bit(1) + } + + /// Overflow + #[inline] + pub fn of(&self) -> bool { + self.0.get_bit(2) + } + + /// Divide by Zero + #[inline] + pub fn dz(&self) -> bool { + self.0.get_bit(3) + } + + /// Invalid Operation + #[inline] + pub fn nv(&self) -> bool { + self.0.get_bit(4) + } +} + +/// Rounding Mode +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum RoundingMode { + RoundToNearestEven = 0b000, + RoundTowardsZero = 0b001, + RoundDown = 0b010, + RoundUp = 0b011, + RoundToNearestMaxMagnitude = 0b100, + Invalid = 0b111, +} + +impl FCSR { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> u32 { + self.bits + } + + /// Accrued Exception Flags + #[inline] + pub fn fflags(&self) -> Flags { + Flags(self.bits.get_bits(0..5)) + } + + /// Rounding Mode + #[inline] + pub fn frm(&self) -> RoundingMode { + match self.bits.get_bits(5..8) { + 0b000 => RoundingMode::RoundToNearestEven, + 0b001 => RoundingMode::RoundTowardsZero, + 0b010 => RoundingMode::RoundDown, + 0b011 => RoundingMode::RoundUp, + 0b100 => RoundingMode::RoundToNearestMaxMagnitude, + _ => RoundingMode::Invalid, + } + } +} + +read_csr!(0x003, __read_fcsr); +write_csr!(0x003, __write_fcsr); +clear!(0x003, __clear_fcsr); + +/// Reads the CSR +#[inline] +pub fn read() -> FCSR { + FCSR { bits: unsafe{ _read() as u32 } } +} + +/// Writes the CSR +#[inline] +pub unsafe fn set_rounding_mode(frm: RoundingMode) { + let old = read(); + let bits = ((frm as u32) << 5) | old.fflags().0; + _write(bits as usize); +} + +/// Resets `fflags` field bits +#[inline] +pub unsafe fn clear_flags() { + let mask = 0b11111; + _clear(mask); +} + +/// Resets `fflags` field bit +#[inline] +pub unsafe fn clear_flag(flag: Flag) { + _clear(flag as usize); +} diff --git a/imports/riscv-0.5.6/src/register/hpmcounterx.rs b/imports/riscv-0.5.6/src/register/hpmcounterx.rs new file mode 100644 index 000000000..5eb15b073 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/hpmcounterx.rs @@ -0,0 +1,82 @@ +macro_rules! reg { + ( + $addr:expr, $csrl:ident, $csrh:ident, $readf:ident, $writef:ident + ) => { + /// Performance-monitoring counter + pub mod $csrl { + read_csr_as_usize!($addr, $readf); + read_composite_csr!(super::$csrh::read(), read()); + } + } +} + +macro_rules! regh { + ( + $addr:expr, $csrh:ident, $readf:ident, $writef:ident + ) => { + /// Upper 32 bits of performance-monitoring counter (RV32I only) + pub mod $csrh { + read_csr_as_usize_rv32!($addr, $readf); + } + } +} + +reg!(0xC03, hpmcounter3, hpmcounter3h, __read_hpmcounter3, __write_hpmcounter3); +reg!(0xC04, hpmcounter4, hpmcounter4h, __read_hpmcounter4, __write_hpmcounter4); +reg!(0xC05, hpmcounter5, hpmcounter5h, __read_hpmcounter5, __write_hpmcounter5); +reg!(0xC06, hpmcounter6, hpmcounter6h, __read_hpmcounter6, __write_hpmcounter6); +reg!(0xC07, hpmcounter7, hpmcounter7h, __read_hpmcounter7, __write_hpmcounter7); +reg!(0xC08, hpmcounter8, hpmcounter8h, __read_hpmcounter8, __write_hpmcounter8); +reg!(0xC09, hpmcounter9, hpmcounter9h, __read_hpmcounter9, __write_hpmcounter9); +reg!(0xC0A, hpmcounter10, hpmcounter10h, __read_hpmcounter10, __write_hpmcounter10); +reg!(0xC0B, hpmcounter11, hpmcounter11h, __read_hpmcounter11, __write_hpmcounter11); +reg!(0xC0C, hpmcounter12, hpmcounter12h, __read_hpmcounter12, __write_hpmcounter12); +reg!(0xC0D, hpmcounter13, hpmcounter13h, __read_hpmcounter13, __write_hpmcounter13); +reg!(0xC0E, hpmcounter14, hpmcounter14h, __read_hpmcounter14, __write_hpmcounter14); +reg!(0xC0F, hpmcounter15, hpmcounter15h, __read_hpmcounter15, __write_hpmcounter15); +reg!(0xC10, hpmcounter16, hpmcounter16h, __read_hpmcounter16, __write_hpmcounter16); +reg!(0xC11, hpmcounter17, hpmcounter17h, __read_hpmcounter17, __write_hpmcounter17); +reg!(0xC12, hpmcounter18, hpmcounter18h, __read_hpmcounter18, __write_hpmcounter18); +reg!(0xC13, hpmcounter19, hpmcounter19h, __read_hpmcounter19, __write_hpmcounter19); +reg!(0xC14, hpmcounter20, hpmcounter20h, __read_hpmcounter20, __write_hpmcounter20); +reg!(0xC15, hpmcounter21, hpmcounter21h, __read_hpmcounter21, __write_hpmcounter21); +reg!(0xC16, hpmcounter22, hpmcounter22h, __read_hpmcounter22, __write_hpmcounter22); +reg!(0xC17, hpmcounter23, hpmcounter23h, __read_hpmcounter23, __write_hpmcounter23); +reg!(0xC18, hpmcounter24, hpmcounter24h, __read_hpmcounter24, __write_hpmcounter24); +reg!(0xC19, hpmcounter25, hpmcounter25h, __read_hpmcounter25, __write_hpmcounter25); +reg!(0xC1A, hpmcounter26, hpmcounter26h, __read_hpmcounter26, __write_hpmcounter26); +reg!(0xC1B, hpmcounter27, hpmcounter27h, __read_hpmcounter27, __write_hpmcounter27); +reg!(0xC1C, hpmcounter28, hpmcounter28h, __read_hpmcounter28, __write_hpmcounter28); +reg!(0xC1D, hpmcounter29, hpmcounter29h, __read_hpmcounter29, __write_hpmcounter29); +reg!(0xC1E, hpmcounter30, hpmcounter30h, __read_hpmcounter30, __write_hpmcounter30); +reg!(0xC1F, hpmcounter31, hpmcounter31h, __read_hpmcounter31, __write_hpmcounter31); + +regh!(0xC83, hpmcounter3h, __read_hpmcounter3h, __write_hpmcounter3h); +regh!(0xC84, hpmcounter4h, __read_hpmcounter4h, __write_hpmcounter4h); +regh!(0xC85, hpmcounter5h, __read_hpmcounter5h, __write_hpmcounter5h); +regh!(0xC86, hpmcounter6h, __read_hpmcounter6h, __write_hpmcounter6h); +regh!(0xC87, hpmcounter7h, __read_hpmcounter7h, __write_hpmcounter7h); +regh!(0xC88, hpmcounter8h, __read_hpmcounter8h, __write_hpmcounter8h); +regh!(0xC89, hpmcounter9h, __read_hpmcounter9h, __write_hpmcounter9h); +regh!(0xC8A, hpmcounter10h, __read_hpmcounter10h, __write_hpmcounter10h); +regh!(0xC8B, hpmcounter11h, __read_hpmcounter11h, __write_hpmcounter11h); +regh!(0xC8C, hpmcounter12h, __read_hpmcounter12h, __write_hpmcounter12h); +regh!(0xC8D, hpmcounter13h, __read_hpmcounter13h, __write_hpmcounter13h); +regh!(0xC8E, hpmcounter14h, __read_hpmcounter14h, __write_hpmcounter14h); +regh!(0xC8F, hpmcounter15h, __read_hpmcounter15h, __write_hpmcounter15h); +regh!(0xC90, hpmcounter16h, __read_hpmcounter16h, __write_hpmcounter16h); +regh!(0xC91, hpmcounter17h, __read_hpmcounter17h, __write_hpmcounter17h); +regh!(0xC92, hpmcounter18h, __read_hpmcounter18h, __write_hpmcounter18h); +regh!(0xC93, hpmcounter19h, __read_hpmcounter19h, __write_hpmcounter19h); +regh!(0xC94, hpmcounter20h, __read_hpmcounter20h, __write_hpmcounter20h); +regh!(0xC95, hpmcounter21h, __read_hpmcounter21h, __write_hpmcounter21h); +regh!(0xC96, hpmcounter22h, __read_hpmcounter22h, __write_hpmcounter22h); +regh!(0xC97, hpmcounter23h, __read_hpmcounter23h, __write_hpmcounter23h); +regh!(0xC98, hpmcounter24h, __read_hpmcounter24h, __write_hpmcounter24h); +regh!(0xC99, hpmcounter25h, __read_hpmcounter25h, __write_hpmcounter25h); +regh!(0xC9A, hpmcounter26h, __read_hpmcounter26h, __write_hpmcounter26h); +regh!(0xC9B, hpmcounter27h, __read_hpmcounter27h, __write_hpmcounter27h); +regh!(0xC9C, hpmcounter28h, __read_hpmcounter28h, __write_hpmcounter28h); +regh!(0xC9D, hpmcounter29h, __read_hpmcounter29h, __write_hpmcounter29h); +regh!(0xC9E, hpmcounter30h, __read_hpmcounter30h, __write_hpmcounter30h); +regh!(0xC9F, hpmcounter31h, __read_hpmcounter31h, __write_hpmcounter31h); diff --git a/imports/riscv-0.5.6/src/register/macros.rs b/imports/riscv-0.5.6/src/register/macros.rs new file mode 100644 index 000000000..b71b4d4cf --- /dev/null +++ b/imports/riscv-0.5.6/src/register/macros.rs @@ -0,0 +1,270 @@ +macro_rules! read_csr { + ($csr_number:expr, $asm_fn: ident) => { + /// Reads the CSR + #[inline] + unsafe fn _read() -> usize { + match () { + #[cfg(all(riscv, feature = "inline-asm"))] + () => { + let r: usize; + asm!("csrrs $0, $1, x0" : "=r"(r) : "i"($csr_number) :: "volatile"); + r + } + + #[cfg(all(riscv, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn() -> usize; + } + + $asm_fn() + } + + #[cfg(not(riscv))] + () => unimplemented!(), + } + } + }; +} + +macro_rules! read_csr_rv32 { + ($csr_number:expr, $asm_fn: ident) => { + /// Reads the CSR + #[inline] + unsafe fn _read() -> usize { + match () { + #[cfg(all(riscv32, feature = "inline-asm"))] + () => { + let r: usize; + asm!("csrrs $0, $1, x0" : "=r"(r) : "i"($csr_number) :: "volatile"); + r + } + + #[cfg(all(riscv32, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn() -> usize; + } + + $asm_fn() + } + + #[cfg(not(riscv32))] + () => unimplemented!(), + } + } + }; +} + +macro_rules! read_csr_as { + ($register:ident, $csr_number:expr, $asm_fn: ident) => { + read_csr!($csr_number, $asm_fn); + + /// Reads the CSR + #[inline] + pub fn read() -> $register { + $register { bits: unsafe{ _read() } } + } + }; +} + +macro_rules! read_csr_as_usize { + ($csr_number:expr, $asm_fn: ident) => { + read_csr!($csr_number, $asm_fn); + + /// Reads the CSR + #[inline] + pub fn read() -> usize { + unsafe{ _read() } + } + }; +} + +macro_rules! read_csr_as_usize_rv32 { + ($csr_number:expr, $asm_fn: ident) => { + read_csr_rv32!($csr_number, $asm_fn); + + /// Reads the CSR + #[inline] + pub fn read() -> usize { + unsafe{ _read() } + } + }; +} + +macro_rules! write_csr { + ($csr_number:expr, $asm_fn: ident) => { + /// Writes the CSR + #[inline] + #[allow(unused_variables)] + unsafe fn _write(bits: usize) { + match () { + #[cfg(all(riscv, feature = "inline-asm"))] + () => asm!("csrrw x0, $1, $0" :: "r"(bits), "i"($csr_number) :: "volatile"), + + #[cfg(all(riscv, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn(bits: usize); + } + + $asm_fn(bits); + } + + #[cfg(not(riscv))] + () => unimplemented!(), + } + } + }; +} + +macro_rules! write_csr_rv32 { + ($csr_number:expr, $asm_fn: ident) => { + /// Writes the CSR + #[inline] + #[allow(unused_variables)] + unsafe fn _write(bits: usize) { + match () { + #[cfg(all(riscv32, feature = "inline-asm"))] + () => asm!("csrrw x0, $1, $0" :: "r"(bits), "i"($csr_number) :: "volatile"), + + #[cfg(all(riscv32, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn(bits: usize); + } + + $asm_fn(bits); + } + + #[cfg(not(riscv32))] + () => unimplemented!(), + } + } + }; +} + +macro_rules! write_csr_as_usize { + ($csr_number:expr, $asm_fn: ident) => { + write_csr!($csr_number, $asm_fn); + + /// Writes the CSR + #[inline] + pub fn write(bits: usize) { + unsafe{ _write(bits) } + } + }; +} + +macro_rules! write_csr_as_usize_rv32 { + ($csr_number:expr, $asm_fn: ident) => { + write_csr_rv32!($csr_number, $asm_fn); + + /// Writes the CSR + #[inline] + pub fn write(bits: usize) { + unsafe{ _write(bits) } + } + }; +} + +macro_rules! set { + ($csr_number:expr, $asm_fn: ident) => { + /// Set the CSR + #[inline] + #[allow(unused_variables)] + unsafe fn _set(bits: usize) { + match () { + #[cfg(all(riscv, feature = "inline-asm"))] + () => asm!("csrrs x0, $1, $0" :: "r"(bits), "i"($csr_number) :: "volatile"), + + #[cfg(all(riscv, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn(bits: usize); + } + + $asm_fn(bits); + } + + #[cfg(not(riscv))] + () => unimplemented!(), + } + } + }; +} + +macro_rules! clear { + ($csr_number:expr, $asm_fn: ident) => { + /// Clear the CSR + #[inline] + #[allow(unused_variables)] + unsafe fn _clear(bits: usize) { + match () { + #[cfg(all(riscv, feature = "inline-asm"))] + () => asm!("csrrc x0, $1, $0" :: "r"(bits), "i"($csr_number) :: "volatile"), + + #[cfg(all(riscv, not(feature = "inline-asm")))] + () => { + extern "C" { + fn $asm_fn(bits: usize); + } + + $asm_fn(bits); + } + + #[cfg(not(riscv))] + () => unimplemented!(), + } + } + }; +} + +macro_rules! set_csr { + ($(#[$attr:meta])*, $set_field:ident, $e:expr) => { + $(#[$attr])* + #[inline] + pub unsafe fn $set_field() { + _set($e); + } + } +} + +macro_rules! clear_csr { + ($(#[$attr:meta])*, $clear_field:ident, $e:expr) => { + $(#[$attr])* + #[inline] + pub unsafe fn $clear_field() { + _clear($e); + } + } +} + +macro_rules! set_clear_csr { + ($(#[$attr:meta])*, $set_field:ident, $clear_field:ident, $e:expr) => { + set_csr!($(#[$attr])*, $set_field, $e); + clear_csr!($(#[$attr])*, $clear_field, $e); + } +} + +macro_rules! read_composite_csr { + ($hi:expr, $lo:expr) => { + /// Reads the CSR as a 64-bit value + #[inline] + pub fn read64() -> u64 { + match () { + #[cfg(riscv32)] + () => loop { + let hi = $hi; + let lo = $lo; + if hi == $hi { + return ((hi as u64) << 32) | lo as u64; + } + }, + + #[cfg(not(riscv32))] + () => $lo as u64, + } + } + } +} diff --git a/imports/riscv-0.5.6/src/register/marchid.rs b/imports/riscv-0.5.6/src/register/marchid.rs new file mode 100644 index 000000000..c10112e99 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/marchid.rs @@ -0,0 +1,27 @@ +//! marchid register + +use core::num::NonZeroUsize; + +/// marchid register +#[derive(Clone, Copy, Debug)] +pub struct Marchid { + bits: NonZeroUsize, +} + +impl Marchid { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits.get() + } +} + +read_csr!(0xF11, __read_marchid); + +/// Reads the CSR +#[inline] +pub fn read() -> Option { + let r = unsafe{ _read() }; + // When marchid is hardwired to zero it means that the marchid + // csr isn't implemented. + NonZeroUsize::new(r).map(|bits| Marchid { bits }) +} diff --git a/imports/riscv-0.5.6/src/register/mcause.rs b/imports/riscv-0.5.6/src/register/mcause.rs new file mode 100644 index 000000000..e0e6ffb44 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mcause.rs @@ -0,0 +1,139 @@ +//! mcause register + +/// mcause register +#[derive(Clone, Copy, Debug)] +pub struct Mcause { + bits: usize, +} + +/// Trap Cause +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum Trap { + Interrupt(Interrupt), + Exception(Exception), +} + +/// Interrupt +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum Interrupt { + UserSoft, + SupervisorSoft, + MachineSoft, + UserTimer, + SupervisorTimer, + MachineTimer, + UserExternal, + SupervisorExternal, + MachineExternal, + Unknown, +} + +/// Exception +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum Exception { + InstructionMisaligned, + InstructionFault, + IllegalInstruction, + Breakpoint, + LoadMisaligned, + LoadFault, + StoreMisaligned, + StoreFault, + UserEnvCall, + SupervisorEnvCall, + MachineEnvCall, + InstructionPageFault, + LoadPageFault, + StorePageFault, + Unknown, +} + +impl Interrupt { + pub fn from(nr: usize) -> Self { + match nr { + 0 => Interrupt::UserSoft, + 1 => Interrupt::SupervisorSoft, + 3 => Interrupt::MachineSoft, + 4 => Interrupt::UserTimer, + 5 => Interrupt::SupervisorTimer, + 7 => Interrupt::MachineTimer, + 8 => Interrupt::UserExternal, + 9 => Interrupt::SupervisorExternal, + 11 => Interrupt::MachineExternal, + _ => Interrupt::Unknown, + } + } +} + + +impl Exception { + pub fn from(nr: usize) -> Self { + match nr { + 0 => Exception::InstructionMisaligned, + 1 => Exception::InstructionFault, + 2 => Exception::IllegalInstruction, + 3 => Exception::Breakpoint, + 4 => Exception::LoadMisaligned, + 5 => Exception::LoadFault, + 6 => Exception::StoreMisaligned, + 7 => Exception::StoreFault, + 8 => Exception::UserEnvCall, + 9 => Exception::SupervisorEnvCall, + 11 => Exception::MachineEnvCall, + 12 => Exception::InstructionPageFault, + 13 => Exception::LoadPageFault, + 15 => Exception::StorePageFault, + _ => Exception::Unknown, + } + } +} +impl Mcause { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// Returns the code field + pub fn code(&self) -> usize { + match () { + #[cfg(target_pointer_width = "32")] + () => self.bits & !(1 << 31), + #[cfg(target_pointer_width = "64")] + () => self.bits & !(1 << 63), + #[cfg(target_pointer_width = "128")] + () => self.bits & !(1 << 127), + } + } + + /// Trap Cause + #[inline] + pub fn cause(&self) -> Trap { + if self.is_interrupt() { + Trap::Interrupt(Interrupt::from(self.code())) + } else { + Trap::Exception(Exception::from(self.code())) + } + } + + /// Is trap cause an interrupt. + #[inline] + pub fn is_interrupt(&self) -> bool { + match () { + #[cfg(target_pointer_width = "32")] + () => self.bits & (1 << 31) == 1 << 31, + #[cfg(target_pointer_width = "64")] + () => self.bits & (1 << 63) == 1 << 63, + #[cfg(target_pointer_width = "128")] + () => self.bits & (1 << 127) == 1 << 127, + } + } + + /// Is trap cause an exception. + #[inline] + pub fn is_exception(&self) -> bool { + !self.is_interrupt() + } +} + +read_csr_as!(Mcause, 0x342, __read_mcause); diff --git a/imports/riscv-0.5.6/src/register/mcycle.rs b/imports/riscv-0.5.6/src/register/mcycle.rs new file mode 100644 index 000000000..95d172b23 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mcycle.rs @@ -0,0 +1,4 @@ +//! mcycle register + +read_csr_as_usize!(0xB00, __read_mcycle); +read_composite_csr!(super::mcycleh::read(), read()); diff --git a/imports/riscv-0.5.6/src/register/mcycleh.rs b/imports/riscv-0.5.6/src/register/mcycleh.rs new file mode 100644 index 000000000..784dca4fa --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mcycleh.rs @@ -0,0 +1,3 @@ +//! mcycleh register + +read_csr_as_usize_rv32!(0xB80, __read_mcycleh); diff --git a/imports/riscv-0.5.6/src/register/mepc.rs b/imports/riscv-0.5.6/src/register/mepc.rs new file mode 100644 index 000000000..160dff56d --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mepc.rs @@ -0,0 +1,4 @@ +//! mepc register + +read_csr_as_usize!(0x341, __read_mepc); +write_csr_as_usize!(0x341, __write_mepc); diff --git a/imports/riscv-0.5.6/src/register/mhartid.rs b/imports/riscv-0.5.6/src/register/mhartid.rs new file mode 100644 index 000000000..396038823 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mhartid.rs @@ -0,0 +1,3 @@ +//! mhartid register + +read_csr_as_usize!(0xf14, __read_mhartid); diff --git a/imports/riscv-0.5.6/src/register/mhpmcounterx.rs b/imports/riscv-0.5.6/src/register/mhpmcounterx.rs new file mode 100644 index 000000000..df3b6c423 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mhpmcounterx.rs @@ -0,0 +1,84 @@ +macro_rules! reg { + ( + $addr:expr, $csrl:ident, $csrh:ident, $readf:ident, $writef:ident + ) => { + /// Machine performance-monitoring counter + pub mod $csrl { + read_csr_as_usize!($addr, $readf); + write_csr_as_usize!($addr, $writef); + read_composite_csr!(super::$csrh::read(), read()); + } + } +} + +macro_rules! regh { + ( + $addr:expr, $csrh:ident, $readf:ident, $writef:ident + ) => { + /// Upper 32 bits of machine performance-monitoring counter (RV32I only) + pub mod $csrh { + read_csr_as_usize_rv32!($addr, $readf); + write_csr_as_usize_rv32!($addr, $writef); + } + } +} + +reg!(0xB03, mhpmcounter3, mhpmcounter3h, __read_mhpmcounter3, __write_mhpmcounter3); +reg!(0xB04, mhpmcounter4, mhpmcounter4h, __read_mhpmcounter4, __write_mhpmcounter4); +reg!(0xB05, mhpmcounter5, mhpmcounter5h, __read_mhpmcounter5, __write_mhpmcounter5); +reg!(0xB06, mhpmcounter6, mhpmcounter6h, __read_mhpmcounter6, __write_mhpmcounter6); +reg!(0xB07, mhpmcounter7, mhpmcounter7h, __read_mhpmcounter7, __write_mhpmcounter7); +reg!(0xB08, mhpmcounter8, mhpmcounter8h, __read_mhpmcounter8, __write_mhpmcounter8); +reg!(0xB09, mhpmcounter9, mhpmcounter9h, __read_mhpmcounter9, __write_mhpmcounter9); +reg!(0xB0A, mhpmcounter10, mhpmcounter10h, __read_mhpmcounter10, __write_mhpmcounter10); +reg!(0xB0B, mhpmcounter11, mhpmcounter11h, __read_mhpmcounter11, __write_mhpmcounter11); +reg!(0xB0C, mhpmcounter12, mhpmcounter12h, __read_mhpmcounter12, __write_mhpmcounter12); +reg!(0xB0D, mhpmcounter13, mhpmcounter13h, __read_mhpmcounter13, __write_mhpmcounter13); +reg!(0xB0E, mhpmcounter14, mhpmcounter14h, __read_mhpmcounter14, __write_mhpmcounter14); +reg!(0xB0F, mhpmcounter15, mhpmcounter15h, __read_mhpmcounter15, __write_mhpmcounter15); +reg!(0xB10, mhpmcounter16, mhpmcounter16h, __read_mhpmcounter16, __write_mhpmcounter16); +reg!(0xB11, mhpmcounter17, mhpmcounter17h, __read_mhpmcounter17, __write_mhpmcounter17); +reg!(0xB12, mhpmcounter18, mhpmcounter18h, __read_mhpmcounter18, __write_mhpmcounter18); +reg!(0xB13, mhpmcounter19, mhpmcounter19h, __read_mhpmcounter19, __write_mhpmcounter19); +reg!(0xB14, mhpmcounter20, mhpmcounter20h, __read_mhpmcounter20, __write_mhpmcounter20); +reg!(0xB15, mhpmcounter21, mhpmcounter21h, __read_mhpmcounter21, __write_mhpmcounter21); +reg!(0xB16, mhpmcounter22, mhpmcounter22h, __read_mhpmcounter22, __write_mhpmcounter22); +reg!(0xB17, mhpmcounter23, mhpmcounter23h, __read_mhpmcounter23, __write_mhpmcounter23); +reg!(0xB18, mhpmcounter24, mhpmcounter24h, __read_mhpmcounter24, __write_mhpmcounter24); +reg!(0xB19, mhpmcounter25, mhpmcounter25h, __read_mhpmcounter25, __write_mhpmcounter25); +reg!(0xB1A, mhpmcounter26, mhpmcounter26h, __read_mhpmcounter26, __write_mhpmcounter26); +reg!(0xB1B, mhpmcounter27, mhpmcounter27h, __read_mhpmcounter27, __write_mhpmcounter27); +reg!(0xB1C, mhpmcounter28, mhpmcounter28h, __read_mhpmcounter28, __write_mhpmcounter28); +reg!(0xB1D, mhpmcounter29, mhpmcounter29h, __read_mhpmcounter29, __write_mhpmcounter29); +reg!(0xB1E, mhpmcounter30, mhpmcounter30h, __read_mhpmcounter30, __write_mhpmcounter30); +reg!(0xB1F, mhpmcounter31, mhpmcounter31h, __read_mhpmcounter31, __write_mhpmcounter31); + +regh!(0xB83, mhpmcounter3h, __read_mhpmcounter3h, __write_mhpmcounter3h); +regh!(0xB84, mhpmcounter4h, __read_mhpmcounter4h, __write_mhpmcounter4h); +regh!(0xB85, mhpmcounter5h, __read_mhpmcounter5h, __write_mhpmcounter5h); +regh!(0xB86, mhpmcounter6h, __read_mhpmcounter6h, __write_mhpmcounter6h); +regh!(0xB87, mhpmcounter7h, __read_mhpmcounter7h, __write_mhpmcounter7h); +regh!(0xB88, mhpmcounter8h, __read_mhpmcounter8h, __write_mhpmcounter8h); +regh!(0xB89, mhpmcounter9h, __read_mhpmcounter9h, __write_mhpmcounter9h); +regh!(0xB8A, mhpmcounter10h, __read_mhpmcounter10h, __write_mhpmcounter10h); +regh!(0xB8B, mhpmcounter11h, __read_mhpmcounter11h, __write_mhpmcounter11h); +regh!(0xB8C, mhpmcounter12h, __read_mhpmcounter12h, __write_mhpmcounter12h); +regh!(0xB8D, mhpmcounter13h, __read_mhpmcounter13h, __write_mhpmcounter13h); +regh!(0xB8E, mhpmcounter14h, __read_mhpmcounter14h, __write_mhpmcounter14h); +regh!(0xB8F, mhpmcounter15h, __read_mhpmcounter15h, __write_mhpmcounter15h); +regh!(0xB90, mhpmcounter16h, __read_mhpmcounter16h, __write_mhpmcounter16h); +regh!(0xB91, mhpmcounter17h, __read_mhpmcounter17h, __write_mhpmcounter17h); +regh!(0xB92, mhpmcounter18h, __read_mhpmcounter18h, __write_mhpmcounter18h); +regh!(0xB93, mhpmcounter19h, __read_mhpmcounter19h, __write_mhpmcounter19h); +regh!(0xB94, mhpmcounter20h, __read_mhpmcounter20h, __write_mhpmcounter20h); +regh!(0xB95, mhpmcounter21h, __read_mhpmcounter21h, __write_mhpmcounter21h); +regh!(0xB96, mhpmcounter22h, __read_mhpmcounter22h, __write_mhpmcounter22h); +regh!(0xB97, mhpmcounter23h, __read_mhpmcounter23h, __write_mhpmcounter23h); +regh!(0xB98, mhpmcounter24h, __read_mhpmcounter24h, __write_mhpmcounter24h); +regh!(0xB99, mhpmcounter25h, __read_mhpmcounter25h, __write_mhpmcounter25h); +regh!(0xB9A, mhpmcounter26h, __read_mhpmcounter26h, __write_mhpmcounter26h); +regh!(0xB9B, mhpmcounter27h, __read_mhpmcounter27h, __write_mhpmcounter27h); +regh!(0xB9C, mhpmcounter28h, __read_mhpmcounter28h, __write_mhpmcounter28h); +regh!(0xB9D, mhpmcounter29h, __read_mhpmcounter29h, __write_mhpmcounter29h); +regh!(0xB9E, mhpmcounter30h, __read_mhpmcounter30h, __write_mhpmcounter30h); +regh!(0xB9F, mhpmcounter31h, __read_mhpmcounter31h, __write_mhpmcounter31h); diff --git a/imports/riscv-0.5.6/src/register/mhpmeventx.rs b/imports/riscv-0.5.6/src/register/mhpmeventx.rs new file mode 100644 index 000000000..78f6fef9c --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mhpmeventx.rs @@ -0,0 +1,41 @@ +macro_rules! reg { + ( + $addr:expr, $csr:ident, $readf:ident, $writef:ident + ) => { + /// Machine performance-monitoring event selector + pub mod $csr { + read_csr_as_usize!($addr, $readf); + write_csr_as_usize!($addr, $writef); + } + } +} + +reg!(0x323, mhpmevent3, __read_mhpmevent3, __write_mhpmevent3); +reg!(0x324, mhpmevent4, __read_mhpmevent4, __write_mhpmevent4); +reg!(0x325, mhpmevent5, __read_mhpmevent5, __write_mhpmevent5); +reg!(0x326, mhpmevent6, __read_mhpmevent6, __write_mhpmevent6); +reg!(0x327, mhpmevent7, __read_mhpmevent7, __write_mhpmevent7); +reg!(0x328, mhpmevent8, __read_mhpmevent8, __write_mhpmevent8); +reg!(0x329, mhpmevent9, __read_mhpmevent9, __write_mhpmevent9); +reg!(0x32A, mhpmevent10, __read_mhpmevent10, __write_mhpmevent10); +reg!(0x32B, mhpmevent11, __read_mhpmevent11, __write_mhpmevent11); +reg!(0x32C, mhpmevent12, __read_mhpmevent12, __write_mhpmevent12); +reg!(0x32D, mhpmevent13, __read_mhpmevent13, __write_mhpmevent13); +reg!(0x32E, mhpmevent14, __read_mhpmevent14, __write_mhpmevent14); +reg!(0x32F, mhpmevent15, __read_mhpmevent15, __write_mhpmevent15); +reg!(0x330, mhpmevent16, __read_mhpmevent16, __write_mhpmevent16); +reg!(0x331, mhpmevent17, __read_mhpmevent17, __write_mhpmevent17); +reg!(0x332, mhpmevent18, __read_mhpmevent18, __write_mhpmevent18); +reg!(0x333, mhpmevent19, __read_mhpmevent19, __write_mhpmevent19); +reg!(0x334, mhpmevent20, __read_mhpmevent20, __write_mhpmevent20); +reg!(0x335, mhpmevent21, __read_mhpmevent21, __write_mhpmevent21); +reg!(0x336, mhpmevent22, __read_mhpmevent22, __write_mhpmevent22); +reg!(0x337, mhpmevent23, __read_mhpmevent23, __write_mhpmevent23); +reg!(0x338, mhpmevent24, __read_mhpmevent24, __write_mhpmevent24); +reg!(0x339, mhpmevent25, __read_mhpmevent25, __write_mhpmevent25); +reg!(0x33A, mhpmevent26, __read_mhpmevent26, __write_mhpmevent26); +reg!(0x33B, mhpmevent27, __read_mhpmevent27, __write_mhpmevent27); +reg!(0x33C, mhpmevent28, __read_mhpmevent28, __write_mhpmevent28); +reg!(0x33D, mhpmevent29, __read_mhpmevent29, __write_mhpmevent29); +reg!(0x33E, mhpmevent30, __read_mhpmevent30, __write_mhpmevent30); +reg!(0x33F, mhpmevent31, __read_mhpmevent31, __write_mhpmevent31); diff --git a/imports/riscv-0.5.6/src/register/mideleg.rs b/imports/riscv-0.5.6/src/register/mideleg.rs new file mode 100644 index 000000000..a08b3c2e8 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mideleg.rs @@ -0,0 +1,76 @@ +//! mideleg register + +use bit_field::BitField; + +/// mideleg register +#[derive(Clone, Copy, Debug)] +pub struct Mideleg { + bits: usize, +} + +impl Mideleg { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Enable + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Software Interrupt Enable + #[inline] + pub fn ssoft(&self) -> bool { + self.bits.get_bit(1) + } + + /// User Timer Interrupt Enable + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Timer Interrupt Enable + #[inline] + pub fn stimer(&self) -> bool { + self.bits.get_bit(5) + } + + /// User External Interrupt Enable + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } + + /// Supervisor External Interrupt Enable + #[inline] + pub fn sext(&self) -> bool { + self.bits.get_bit(9) + } +} + +read_csr_as!(Mideleg, 0x304, __read_mideleg); +set!(0x303, __set_mideleg); +clear!(0x303, __clear_mideleg); + +set_clear_csr!( + /// User Software Interrupt Pending + , set_usoft, clear_usoft, 1 << 0); +set_clear_csr!( + /// Supervisor Software Interrupt Pending + , set_ssoft, clear_ssoft, 1 << 1); +set_clear_csr!( + /// User Timer Interrupt Pending + , set_utimer, clear_utimer, 1 << 4); +set_clear_csr!( + /// Supervisor Timer Interrupt Pending + , set_stimer, clear_stimer, 1 << 5); +set_clear_csr!( + /// User External Interrupt Pending + , set_uext, clear_uext, 1 << 8); +set_clear_csr!( + /// Supervisor External Interrupt Pending + , set_sext, clear_sext, 1 << 9); diff --git a/imports/riscv-0.5.6/src/register/mie.rs b/imports/riscv-0.5.6/src/register/mie.rs new file mode 100644 index 000000000..121a5b5bf --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mie.rs @@ -0,0 +1,103 @@ +//! mie register + +use bit_field::BitField; + +/// mie register +#[derive(Clone, Copy, Debug)] +pub struct Mie { + bits: usize, +} + +impl Mie { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Enable + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Software Interrupt Enable + #[inline] + pub fn ssoft(&self) -> bool { + self.bits.get_bit(1) + } + + /// Machine Software Interrupt Enable + #[inline] + pub fn msoft(&self) -> bool { + self.bits.get_bit(3) + } + + /// User Timer Interrupt Enable + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Timer Interrupt Enable + #[inline] + pub fn stimer(&self) -> bool { + self.bits.get_bit(5) + } + + /// Machine Timer Interrupt Enable + #[inline] + pub fn mtimer(&self) -> bool { + self.bits.get_bit(7) + } + + /// User External Interrupt Enable + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } + + /// Supervisor External Interrupt Enable + #[inline] + pub fn sext(&self) -> bool { + self.bits.get_bit(9) + } + + /// Machine External Interrupt Enable + #[inline] + pub fn mext(&self) -> bool { + self.bits.get_bit(11) + } +} + +read_csr_as!(Mie, 0x304, __read_mie); +set!(0x304, __set_mie); +clear!(0x304, __clear_mie); + +set_clear_csr!( + /// User Software Interrupt Enable + , set_usoft, clear_usoft, 1 << 0); +set_clear_csr!( + /// Supervisor Software Interrupt Enable + , set_ssoft, clear_ssoft, 1 << 1); +set_clear_csr!( + /// Machine Software Interrupt Enable + , set_msoft, clear_msoft, 1 << 3); +set_clear_csr!( + /// User Timer Interrupt Enable + , set_utimer, clear_utimer, 1 << 4); +set_clear_csr!( + /// Supervisor Timer Interrupt Enable + , set_stimer, clear_stimer, 1 << 5); +set_clear_csr!( + /// Machine Timer Interrupt Enable + , set_mtimer, clear_mtimer, 1 << 7); +set_clear_csr!( + /// User External Interrupt Enable + , set_uext, clear_uext, 1 << 8); +set_clear_csr!( + /// Supervisor External Interrupt Enable + , set_sext, clear_sext, 1 << 9); +set_clear_csr!( + /// Machine External Interrupt Enable + , set_mext, clear_mext, 1 << 11); diff --git a/imports/riscv-0.5.6/src/register/mimpid.rs b/imports/riscv-0.5.6/src/register/mimpid.rs new file mode 100644 index 000000000..e49a24678 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mimpid.rs @@ -0,0 +1,27 @@ +//! mimpid register + +use core::num::NonZeroUsize; + +/// mimpid register +#[derive(Clone, Copy, Debug)] +pub struct Mimpid { + bits: NonZeroUsize, +} + +impl Mimpid { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits.get() + } +} + +read_csr!(0xF11, __read_mimpid); + +/// Reads the CSR +#[inline] +pub fn read() -> Option { + let r = unsafe{ _read() }; + // When mimpid is hardwired to zero it means that the mimpid + // csr isn't implemented. + NonZeroUsize::new(r).map(|bits| Mimpid { bits }) +} diff --git a/imports/riscv-0.5.6/src/register/minstret.rs b/imports/riscv-0.5.6/src/register/minstret.rs new file mode 100644 index 000000000..d553dd8f8 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/minstret.rs @@ -0,0 +1,4 @@ +//! minstret register + +read_csr_as_usize!(0xB02, __read_minstret); +read_composite_csr!(super::minstreth::read(), read()); diff --git a/imports/riscv-0.5.6/src/register/minstreth.rs b/imports/riscv-0.5.6/src/register/minstreth.rs new file mode 100644 index 000000000..56bc54eff --- /dev/null +++ b/imports/riscv-0.5.6/src/register/minstreth.rs @@ -0,0 +1,3 @@ +//! minstreth register + +read_csr_as_usize_rv32!(0xB82, __read_minstreth); diff --git a/imports/riscv-0.5.6/src/register/mip.rs b/imports/riscv-0.5.6/src/register/mip.rs new file mode 100644 index 000000000..1a4cf82c9 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mip.rs @@ -0,0 +1,100 @@ +//! mip register + +use bit_field::BitField; + +/// mip register +#[derive(Clone, Copy, Debug)] +pub struct Mip { + bits: usize, +} + +impl Mip { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Pending + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Software Interrupt Pending + #[inline] + pub fn ssoft(&self) -> bool { + self.bits.get_bit(1) + } + + /// Machine Software Interrupt Pending + #[inline] + pub fn msoft(&self) -> bool { + self.bits.get_bit(3) + } + + /// User Timer Interrupt Pending + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Timer Interrupt Pending + #[inline] + pub fn stimer(&self) -> bool { + self.bits.get_bit(5) + } + + /// Machine Timer Interrupt Pending + #[inline] + pub fn mtimer(&self) -> bool { + self.bits.get_bit(7) + } + + /// User External Interrupt Pending + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } + + /// Supervisor External Interrupt Pending + #[inline] + pub fn sext(&self) -> bool { + self.bits.get_bit(9) + } + + /// Machine External Interrupt Pending + #[inline] + pub fn mext(&self) -> bool { + self.bits.get_bit(11) + } +} + +read_csr_as!(Mip, 0x344, __read_mip); +set!(0x344, __set_mip); +clear!(0x344, __clear_mip); + +set_clear_csr!( + /// User Software Interrupt Pending + , set_usoft, clear_usoft, 1 << 0); +set_clear_csr!( + /// Supervisor Software Interrupt Pending + , set_ssoft, clear_ssoft, 1 << 1); +set_clear_csr!( + /// Machine Software Interrupt Pending + , set_msoft, clear_msoft, 1 << 3); +set_clear_csr!( + /// User Timer Interrupt Pending + , set_utimer, clear_utimer, 1 << 4); +set_clear_csr!( + /// Supervisor Timer Interrupt Pending + , set_stimer, clear_stimer, 1 << 5); +set_clear_csr!( + /// Machine Timer Interrupt Pending + , set_mtimer, clear_mtimer, 1 << 7); +set_clear_csr!( + /// User External Interrupt Pending + , set_uext, clear_uext, 1 << 8); +set_clear_csr!( + /// Supervisor External Interrupt Pending + , set_sext, clear_sext, 1 << 9); diff --git a/imports/riscv-0.5.6/src/register/misa.rs b/imports/riscv-0.5.6/src/register/misa.rs new file mode 100644 index 000000000..792e22cc6 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/misa.rs @@ -0,0 +1,60 @@ +//! misa register + +use core::num::NonZeroUsize; + +/// misa register +#[derive(Clone, Copy, Debug)] +pub struct Misa { + bits: NonZeroUsize, +} + +/// Machine XLEN +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum MXL { + XLEN32, + XLEN64, + XLEN128, +} + +impl Misa { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits.get() + } + + /// Returns the machine xlen. + pub fn mxl(&self) -> MXL { + let value = match () { + #[cfg(target_pointer_width = "32")] + () => (self.bits() >> 30) as u8, + #[cfg(target_pointer_width = "64")] + () => (self.bits() >> 62) as u8, + }; + match value { + 1 => MXL::XLEN32, + 2 => MXL::XLEN64, + 3 => MXL::XLEN128, + _ => unreachable!(), + } + } + + /// Returns true when the atomic extension is implemented. + pub fn has_extension(&self, extension: char) -> bool { + let bit = extension as u8 - 65; + if bit > 25 { + return false; + } + self.bits() & (1 << bit) == (1 << bit) + } +} + +read_csr!(0x301, __read_misa); + +/// Reads the CSR +#[inline] +pub fn read() -> Option { + let r = unsafe{ _read() }; + // When misa is hardwired to zero it means that the misa csr + // isn't implemented. + NonZeroUsize::new(r).map(|bits| Misa { bits }) +} diff --git a/imports/riscv-0.5.6/src/register/mod.rs b/imports/riscv-0.5.6/src/register/mod.rs new file mode 100644 index 000000000..54a9f4600 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mod.rs @@ -0,0 +1,114 @@ +//! RISC-V CSR's +//! +//! The following registers are not available on 64-bit implementations. +//! +//! - cycleh +//! - timeh +//! - instreth +//! - hpmcounter[3-31]h +//! - mcycleh +//! - minstreth +//! - mhpmcounter[3-31]h + +#[macro_use] +mod macros; + +// User Trap Setup +pub mod ustatus; +pub mod uie; +pub mod utvec; + +// User Trap Handling +pub mod uscratch; +pub mod uepc; +pub mod ucause; +pub mod utval; +pub mod uip; + +// User Floating-Point CSRs +// TODO: frm, fflags +pub mod fcsr; + + +// User Counter/Timers +// TODO: cycle[h], instret[h] +pub mod time; +mod hpmcounterx; +pub use self::hpmcounterx::*; +pub mod timeh; + + +// Supervisor Trap Setup +// TODO: sedeleg, sideleg +pub mod sstatus; +pub mod sie; +pub mod stvec; +// TODO: scounteren + + +// Supervisor Trap Handling +pub mod sscratch; +pub mod sepc; +pub mod scause; +pub mod stval; +pub mod sip; + + +// Supervisor Protection and Translation +pub mod satp; + + +// Machine Information Registers +pub mod mvendorid; +pub mod marchid; +pub mod mimpid; +pub mod mhartid; + + +// Machine Trap Setup +pub mod mstatus; +pub mod misa; +// TODO: medeleg +pub mod mideleg; +pub mod mie; +pub mod mtvec; +// TODO: mcounteren + + +// Machine Trap Handling +pub mod mscratch; +pub mod mepc; +pub mod mcause; +pub mod mtval; +pub mod mip; + + +// Machine Protection and Translation +mod pmpcfgx; +pub use self::pmpcfgx::*; +mod pmpaddrx; +pub use self::pmpaddrx::*; + + +// Machine Counter/Timers +pub mod mcycle; +pub mod minstret; +mod mhpmcounterx; +pub use self::mhpmcounterx::*; +pub mod mcycleh; +pub mod minstreth; + + +// Machine Counter Setup +mod mhpmeventx; +pub use self::mhpmeventx::*; + + +// TODO: Debug/Trace Registers (shared with Debug Mode) + + +// TODO: Debug Mode Registers + + +// Vexriscv custom CSRs +pub mod vexriscv; diff --git a/imports/riscv-0.5.6/src/register/mscratch.rs b/imports/riscv-0.5.6/src/register/mscratch.rs new file mode 100644 index 000000000..c5ef9fec6 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mscratch.rs @@ -0,0 +1,4 @@ +//! mscratch register + +read_csr_as_usize!(0x340, __read_mscratch); +write_csr_as_usize!(0x340, __write_mscratch); diff --git a/imports/riscv-0.5.6/src/register/mstatus.rs b/imports/riscv-0.5.6/src/register/mstatus.rs new file mode 100644 index 000000000..6c34c835c --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mstatus.rs @@ -0,0 +1,200 @@ +//! mstatus register +// TODO: Virtualization, Memory Privilege and Extension Context Fields + +use bit_field::BitField; +use core::mem::size_of; + +/// mstatus register +#[derive(Clone, Copy, Debug)] +pub struct Mstatus { + bits: usize, +} + +/// Additional extension state +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum XS { + /// All off + AllOff = 0, + + /// None dirty or clean, some on + NoneDirtyOrClean = 1, + + /// None dirty, some clean + NoneDirtySomeClean = 2, + + /// Some dirty + SomeDirty = 3, +} + +/// Floating-point extension state +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum FS { + Off = 0, + Initial = 1, + Clean = 2, + Dirty = 3, +} + +/// Machine Previous Privilege Mode +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum MPP { + Machine = 3, + Supervisor = 1, + User = 0, +} + +/// Supervisor Previous Privilege Mode +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum SPP { + Supervisor = 1, + User = 0, +} + +impl Mstatus { + /// User Interrupt Enable + #[inline] + pub fn uie(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Interrupt Enable + #[inline] + pub fn sie(&self) -> bool { + self.bits.get_bit(1) + } + + /// Machine Interrupt Enable + #[inline] + pub fn mie(&self) -> bool { + self.bits.get_bit(3) + } + + /// User Previous Interrupt Enable + #[inline] + pub fn upie(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Previous Interrupt Enable + #[inline] + pub fn spie(&self) -> bool { + self.bits.get_bit(5) + } + + /// Machine Previous Interrupt Enable + #[inline] + pub fn mpie(&self) -> bool { + self.bits.get_bit(7) + } + + /// Supervisor Previous Privilege Mode + #[inline] + pub fn spp(&self) -> SPP { + match self.bits.get_bit(8) { + true => SPP::Supervisor, + false => SPP::User, + } + } + + /// Machine Previous Privilege Mode + #[inline] + pub fn mpp(&self) -> MPP { + match self.bits.get_bits(11..13) { + 0b00 => MPP::User, + 0b01 => MPP::Supervisor, + 0b11 => MPP::Machine, + _ => unreachable!(), + } + } + + /// Floating-point extension state + /// + /// Encodes the status of the floating-point unit, + /// including the CSR `fcsr` and floating-point data registers `f0–f31`. + #[inline] + pub fn fs(&self) -> FS { + match self.bits.get_bits(13..15) { + 0b00 => FS::Off, + 0b01 => FS::Initial, + 0b10 => FS::Clean, + 0b11 => FS::Dirty, + _ => unreachable!(), + } + } + + /// Additional extension state + /// + /// Encodes the status of additional user-mode extensions and associated state. + #[inline] + pub fn xs(&self) -> XS { + match self.bits.get_bits(15..17) { + 0b00 => XS::AllOff, + 0b01 => XS::NoneDirtyOrClean, + 0b10 => XS::NoneDirtySomeClean, + 0b11 => XS::SomeDirty, + _ => unreachable!(), + } + } + + /// Whether either the FS field or XS field + /// signals the presence of some dirty state + #[inline] + pub fn sd(&self) -> bool { + self.bits.get_bit(size_of::() * 8 - 1) + } +} + + +read_csr_as!(Mstatus, 0x300, __read_mstatus); +write_csr!(0x300, __write_mstatus); +set!(0x300, __set_mstatus); +clear!(0x300, __clear_mstatus); + +set_clear_csr!( + /// User Interrupt Enable + , set_uie, clear_uie, 1 << 0); + +set_clear_csr!( + /// Supervisor Interrupt Enable + , set_sie, clear_sie, 1 << 1); + +set_clear_csr!( + /// Machine Interrupt Enable + , set_mie, clear_mie, 1 << 3); + +set_csr!( + /// User Previous Interrupt Enable + , set_upie, 1 << 4); + +set_csr!( + /// Supervisor Previous Interrupt Enable + , set_spie, 1 << 5); + +set_csr!( + /// Machine Previous Interrupt Enable + , set_mpie, 1 << 7); + +/// Supervisor Previous Privilege Mode +#[inline] +pub unsafe fn set_spp(spp: SPP) { + match spp { + SPP::Supervisor => _set(1 << 8), + SPP::User => _clear(1 << 8), + } +} + +/// Machine Previous Privilege Mode +#[inline] +pub unsafe fn set_mpp(mpp: MPP) { + let mut value = _read(); + value.set_bits(11..13, mpp as usize); + _write(value); +} + +/// Floating-point extension state +#[inline] +pub unsafe fn set_fs(fs: FS) { + let mut value = _read(); + value.set_bits(13..15, fs as usize); + _write(value); +} diff --git a/imports/riscv-0.5.6/src/register/mtval.rs b/imports/riscv-0.5.6/src/register/mtval.rs new file mode 100644 index 000000000..2afb7cb67 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mtval.rs @@ -0,0 +1,3 @@ +//! mtval register + +read_csr_as_usize!(0x343, __read_mtval); diff --git a/imports/riscv-0.5.6/src/register/mtvec.rs b/imports/riscv-0.5.6/src/register/mtvec.rs new file mode 100644 index 000000000..247e05fa1 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mtvec.rs @@ -0,0 +1,47 @@ +//! mtvec register + +/// mtvec register +#[derive(Clone, Copy, Debug)] +pub struct Mtvec { + bits: usize, +} + +/// Trap mode +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum TrapMode { + Direct = 0, + Vectored = 1, +} + +impl Mtvec { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits + } + + /// Returns the trap-vector base-address + pub fn address(&self) -> usize { + self.bits - (self.bits & 0b11) + } + + /// Returns the trap-vector mode + pub fn trap_mode(&self) -> TrapMode { + let mode = self.bits & 0b11; + match mode { + 0 => TrapMode::Direct, + 1 => TrapMode::Vectored, + _ => unimplemented!() + } + } +} + +read_csr_as!(Mtvec, 0x305, __read_mtvec); + +write_csr!(0x305, __write_mtvec); + +/// Writes the CSR +#[inline] +pub unsafe fn write(addr: usize, mode: TrapMode) { + let bits = addr + mode as usize; + _write(bits); +} diff --git a/imports/riscv-0.5.6/src/register/mvendorid.rs b/imports/riscv-0.5.6/src/register/mvendorid.rs new file mode 100644 index 000000000..a76ffb8a9 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/mvendorid.rs @@ -0,0 +1,32 @@ +//! mvendorid register + +use core::num::NonZeroUsize; + +/// mvendorid register +#[derive(Clone, Copy, Debug)] +pub struct Mvendorid { + bits: NonZeroUsize, +} + +impl Mvendorid { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits.get() + } + + /// Returns the JEDEC manufacturer ID + pub fn jedec_manufacturer(&self) -> usize { + self.bits() >> 7 + } +} + +read_csr!(0xF11, __read_mvendorid); + +/// Reads the CSR +#[inline] +pub fn read() -> Option { + let r = unsafe{ _read() }; + // When mvendorid is hardwired to zero it means that the mvendorid + // csr isn't implemented. + NonZeroUsize::new(r).map(|bits| Mvendorid { bits }) +} diff --git a/imports/riscv-0.5.6/src/register/pmpaddrx.rs b/imports/riscv-0.5.6/src/register/pmpaddrx.rs new file mode 100644 index 000000000..d615dde7a --- /dev/null +++ b/imports/riscv-0.5.6/src/register/pmpaddrx.rs @@ -0,0 +1,28 @@ +macro_rules! reg { + ( + $addr:expr, $csr:ident, $readf:ident, $writef:ident + ) => { + /// Physical memory protection address register + pub mod $csr { + read_csr_as_usize!($addr, $readf); + write_csr_as_usize!($addr, $writef); + } + } +} + +reg!(0x3B0, pmpaddr0, __read_pmpaddr0, __write_pmpaddr0); +reg!(0x3B1, pmpaddr1, __read_pmpaddr1, __write_pmpaddr1); +reg!(0x3B2, pmpaddr2, __read_pmpaddr2, __write_pmpaddr2); +reg!(0x3B3, pmpaddr3, __read_pmpaddr3, __write_pmpaddr3); +reg!(0x3B4, pmpaddr4, __read_pmpaddr4, __write_pmpaddr4); +reg!(0x3B5, pmpaddr5, __read_pmpaddr5, __write_pmpaddr5); +reg!(0x3B6, pmpaddr6, __read_pmpaddr6, __write_pmpaddr6); +reg!(0x3B7, pmpaddr7, __read_pmpaddr7, __write_pmpaddr7); +reg!(0x3B8, pmpaddr8, __read_pmpaddr8, __write_pmpaddr8); +reg!(0x3B9, pmpaddr9, __read_pmpaddr9, __write_pmpaddr9); +reg!(0x3BA, pmpaddr10, __read_pmpaddr10, __write_pmpaddr10); +reg!(0x3BB, pmpaddr11, __read_pmpaddr11, __write_pmpaddr11); +reg!(0x3BC, pmpaddr12, __read_pmpaddr12, __write_pmpaddr12); +reg!(0x3BD, pmpaddr13, __read_pmpaddr13, __write_pmpaddr13); +reg!(0x3BE, pmpaddr14, __read_pmpaddr14, __write_pmpaddr14); +reg!(0x3BF, pmpaddr15, __read_pmpaddr15, __write_pmpaddr15); diff --git a/imports/riscv-0.5.6/src/register/pmpcfgx.rs b/imports/riscv-0.5.6/src/register/pmpcfgx.rs new file mode 100644 index 000000000..ec27251c0 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/pmpcfgx.rs @@ -0,0 +1,23 @@ +/// Physical memory protection configuration +pub mod pmpcfg0 { + read_csr_as_usize!(0x3A0, __read_pmpcfg0); + write_csr_as_usize!(0x3A0, __write_pmpcfg0); +} + +/// Physical memory protection configuration, RV32 only +pub mod pmpcfg1 { + read_csr_as_usize_rv32!(0x3A1, __read_pmpcfg1); + write_csr_as_usize_rv32!(0x3A1, __write_pmpcfg1); +} + +/// Physical memory protection configuration +pub mod pmpcfg2 { + read_csr_as_usize!(0x3A2, __read_pmpcfg2); + write_csr_as_usize!(0x3A2, __write_pmpcfg2); +} + +/// Physical memory protection configuration, RV32 only +pub mod pmpcfg3 { + read_csr_as_usize_rv32!(0x3A3, __read_pmpcfg3); + write_csr_as_usize_rv32!(0x3A3, __write_pmpcfg3); +} diff --git a/imports/riscv-0.5.6/src/register/satp.rs b/imports/riscv-0.5.6/src/register/satp.rs new file mode 100644 index 000000000..d1821d378 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/satp.rs @@ -0,0 +1,110 @@ +//! satp register + +#[cfg(riscv)] +use bit_field::BitField; + +/// satp register +#[derive(Clone, Copy, Debug)] +pub struct Satp { + bits: usize, +} + +impl Satp { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// Current address-translation scheme + #[inline] + #[cfg(riscv32)] + pub fn mode(&self) -> Mode { + match self.bits.get_bit(31) { + false => Mode::Bare, + true => Mode::Sv32, + } + } + + /// Current address-translation scheme + #[inline] + #[cfg(riscv64)] + pub fn mode(&self) -> Mode { + match self.bits.get_bits(60..64) { + 0 => Mode::Bare, + 8 => Mode::Sv39, + 9 => Mode::Sv48, + 10 => Mode::Sv57, + 11 => Mode::Sv64, + _ => unreachable!(), + } + } + + /// Address space identifier + #[inline] + #[cfg(riscv32)] + pub fn asid(&self) -> usize { + self.bits.get_bits(22..31) + } + + /// Address space identifier + #[inline] + #[cfg(riscv64)] + pub fn asid(&self) -> usize { + self.bits.get_bits(44..60) + } + + /// Physical page number + #[inline] + #[cfg(riscv32)] + pub fn ppn(&self) -> usize { + self.bits.get_bits(0..22) + } + + /// Physical page number + #[inline] + #[cfg(riscv64)] + pub fn ppn(&self) -> usize { + self.bits.get_bits(0..44) + } +} + +#[cfg(riscv32)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Mode { + Bare = 0, + Sv32 = 1, +} + +#[cfg(riscv64)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum Mode { + Bare = 0, + Sv39 = 8, + Sv48 = 9, + Sv57 = 10, + Sv64 = 11, +} + +read_csr_as!(Satp, 0x180, __read_satp); +write_csr_as_usize!(0x180, __write_satp); + +#[inline] +#[cfg(riscv32)] +pub unsafe fn set(mode: Mode, asid: usize, ppn: usize) { + let mut bits = 0usize; + bits.set_bits(31..32, mode as usize); + bits.set_bits(22..31, asid); + bits.set_bits(0..22, ppn); + _write(bits); +} + +#[inline] +#[cfg(riscv64)] +pub unsafe fn set(mode: Mode, asid: usize, ppn: usize) { + let mut bits = 0usize; + bits.set_bits(60..64, mode as usize); + bits.set_bits(44..60, asid); + bits.set_bits(0..44, ppn); + _write(bits); +} diff --git a/imports/riscv-0.5.6/src/register/scause.rs b/imports/riscv-0.5.6/src/register/scause.rs new file mode 100644 index 000000000..a9ffe92c9 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/scause.rs @@ -0,0 +1,117 @@ +//! scause register + +use bit_field::BitField; +use core::mem::size_of; + +/// scause register +#[derive(Clone, Copy)] +pub struct Scause { + bits: usize, +} + +/// Trap Cause +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum Trap { + Interrupt(Interrupt), + Exception(Exception), +} + +/// Interrupt +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum Interrupt { + UserSoft, + SupervisorSoft, + UserTimer, + SupervisorTimer, + UserExternal, + SupervisorExternal, + Unknown, +} + +/// Exception +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum Exception { + InstructionMisaligned, + InstructionFault, + IllegalInstruction, + Breakpoint, + LoadFault, + StoreMisaligned, + StoreFault, + UserEnvCall, + InstructionPageFault, + LoadPageFault, + StorePageFault, + Unknown, +} + +impl Interrupt { + pub fn from(nr: usize) -> Self { + match nr { + 0 => Interrupt::UserSoft, + 1 => Interrupt::SupervisorSoft, + 4 => Interrupt::UserTimer, + 5 => Interrupt::SupervisorTimer, + 8 => Interrupt::UserExternal, + 9 => Interrupt::SupervisorExternal, + _ => Interrupt::Unknown, + } + } +} + +impl Exception { + pub fn from(nr: usize) -> Self { + match nr { + 0 => Exception::InstructionMisaligned, + 1 => Exception::InstructionFault, + 2 => Exception::IllegalInstruction, + 3 => Exception::Breakpoint, + 5 => Exception::LoadFault, + 6 => Exception::StoreMisaligned, + 7 => Exception::StoreFault, + 8 => Exception::UserEnvCall, + 12 => Exception::InstructionPageFault, + 13 => Exception::LoadPageFault, + 15 => Exception::StorePageFault, + _ => Exception::Unknown, + } + } +} + +impl Scause { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// Returns the code field + pub fn code(&self) -> usize { + let bit = 1 << (size_of::() * 8 - 1); + self.bits & !bit + } + + /// Trap Cause + #[inline] + pub fn cause(&self) -> Trap { + if self.is_interrupt() { + Trap::Interrupt(Interrupt::from(self.code())) + } else { + Trap::Exception(Exception::from(self.code())) + } + } + + /// Is trap cause an interrupt. + #[inline] + pub fn is_interrupt(&self) -> bool { + self.bits.get_bit(size_of::() * 8 - 1) + } + + /// Is trap cause an exception. + #[inline] + pub fn is_exception(&self) -> bool { + !self.is_interrupt() + } +} + +read_csr_as!(Scause, 0x142, __read_scause); diff --git a/imports/riscv-0.5.6/src/register/sepc.rs b/imports/riscv-0.5.6/src/register/sepc.rs new file mode 100644 index 000000000..aba69dfca --- /dev/null +++ b/imports/riscv-0.5.6/src/register/sepc.rs @@ -0,0 +1,4 @@ +//! sepc register + +read_csr_as_usize!(0x141, __read_sepc); +write_csr_as_usize!(0x141, __write_sepc); diff --git a/imports/riscv-0.5.6/src/register/sie.rs b/imports/riscv-0.5.6/src/register/sie.rs new file mode 100644 index 000000000..b65211099 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/sie.rs @@ -0,0 +1,76 @@ +//! sie register + +use bit_field::BitField; + +/// sie register +#[derive(Clone, Copy, Debug)] +pub struct Sie { + bits: usize, +} + +impl Sie { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Enable + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Software Interrupt Enable + #[inline] + pub fn ssoft(&self) -> bool { + self.bits.get_bit(1) + } + + /// User Timer Interrupt Enable + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Timer Interrupt Enable + #[inline] + pub fn stimer(&self) -> bool { + self.bits.get_bit(5) + } + + /// User External Interrupt Enable + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } + + /// Supervisor External Interrupt Enable + #[inline] + pub fn sext(&self) -> bool { + self.bits.get_bit(9) + } +} + +read_csr_as!(Sie, 0x104, __read_sie); +set!(0x104, __set_sie); +clear!(0x104, __clear_sie); + +set_clear_csr!( + /// User Software Interrupt Enable + , set_usoft, clear_usoft, 1 << 0); +set_clear_csr!( + /// Supervisor Software Interrupt Enable + , set_ssoft, clear_ssoft, 1 << 1); +set_clear_csr!( + /// User Timer Interrupt Enable + , set_utimer, clear_utimer, 1 << 4); +set_clear_csr!( + /// Supervisor Timer Interrupt Enable + , set_stimer, clear_stimer, 1 << 5); +set_clear_csr!( + /// User External Interrupt Enable + , set_uext, clear_uext, 1 << 8); +set_clear_csr!( + /// Supervisor External Interrupt Enable + , set_sext, clear_sext, 1 << 9); diff --git a/imports/riscv-0.5.6/src/register/sip.rs b/imports/riscv-0.5.6/src/register/sip.rs new file mode 100644 index 000000000..f625661a2 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/sip.rs @@ -0,0 +1,55 @@ +//! sip register + +use bit_field::BitField; + +/// sip register +#[derive(Clone, Copy, Debug)] +pub struct Sip { + bits: usize, +} + +impl Sip { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Pending + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Software Interrupt Pending + #[inline] + pub fn ssoft(&self) -> bool { + self.bits.get_bit(1) + } + + /// User Timer Interrupt Pending + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Timer Interrupt Pending + #[inline] + pub fn stimer(&self) -> bool { + self.bits.get_bit(5) + } + + /// User External Interrupt Pending + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } + + /// Supervisor External Interrupt Pending + #[inline] + pub fn sext(&self) -> bool { + self.bits.get_bit(9) + } +} + +read_csr_as!(Sip, 0x144, __read_sip); diff --git a/imports/riscv-0.5.6/src/register/sscratch.rs b/imports/riscv-0.5.6/src/register/sscratch.rs new file mode 100644 index 000000000..349812c15 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/sscratch.rs @@ -0,0 +1,4 @@ +//! sscratch register + +read_csr_as_usize!(0x140, __read_sscratch); +write_csr_as_usize!(0x140, __write_sscratch); diff --git a/imports/riscv-0.5.6/src/register/sstatus.rs b/imports/riscv-0.5.6/src/register/sstatus.rs new file mode 100644 index 000000000..68908fcda --- /dev/null +++ b/imports/riscv-0.5.6/src/register/sstatus.rs @@ -0,0 +1,140 @@ +//! sstatus register + +use bit_field::BitField; +use core::mem::size_of; +pub use super::mstatus::FS; + +/// Supervisor Status Register +#[derive(Clone, Copy, Debug)] +pub struct Sstatus { + bits: usize, +} + +/// Supervisor Previous Privilege Mode +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum SPP { + Supervisor = 1, + User = 0, +} + +impl Sstatus { + /// User Interrupt Enable + #[inline] + pub fn uie(&self) -> bool { + self.bits.get_bit(0) + } + + /// Supervisor Interrupt Enable + #[inline] + pub fn sie(&self) -> bool { + self.bits.get_bit(1) + } + + /// User Previous Interrupt Enable + #[inline] + pub fn upie(&self) -> bool { + self.bits.get_bit(4) + } + + /// Supervisor Previous Interrupt Enable + #[inline] + pub fn spie(&self) -> bool { + self.bits.get_bit(5) + } + + /// Supervisor Previous Privilege Mode + #[inline] + pub fn spp(&self) -> SPP { + match self.bits.get_bit(8) { + true => SPP::Supervisor, + false => SPP::User, + } + } + + /// The status of the floating-point unit + #[inline] + pub fn fs(&self) -> FS { + match self.bits.get_bits(13..15) { + 0 => FS::Off, + 1 => FS::Initial, + 2 => FS::Clean, + 3 => FS::Dirty, + _ => unreachable!(), + } + } + + /// The status of additional user-mode extensions + /// and associated state + #[inline] + pub fn xs(&self) -> FS { + match self.bits.get_bits(15..17) { + 0 => FS::Off, + 1 => FS::Initial, + 2 => FS::Clean, + 3 => FS::Dirty, + _ => unreachable!(), + } + } + + /// Permit Supervisor User Memory access + #[inline] + pub fn sum(&self) -> bool { + self.bits.get_bit(18) + } + + /// Make eXecutable Readable + #[inline] + pub fn mxr(&self) -> bool { + self.bits.get_bit(19) + } + + /// Whether either the FS field or XS field + /// signals the presence of some dirty state + #[inline] + pub fn sd(&self) -> bool { + self.bits.get_bit(size_of::() * 8 - 1) + } +} + +read_csr_as!(Sstatus, 0x100, __read_sstatus); +write_csr!(0x100, __write_sstatus); +set!(0x100, __set_sstatus); +clear!(0x100, __clear_sstatus); + +set_clear_csr!( + /// User Interrupt Enable + , set_uie, clear_uie, 1 << 0); +set_clear_csr!( + /// Supervisor Interrupt Enable + , set_sie, clear_sie, 1 << 1); +set_csr!( + /// User Previous Interrupt Enable + , set_upie, 1 << 4); +set_csr!( + /// Supervisor Previous Interrupt Enable + , set_spie, 1 << 5); +set_clear_csr!( + /// Make eXecutable Readable + , set_mxr, clear_mxr, 1 << 19); +set_clear_csr!( + /// Permit Supervisor User Memory access + , set_sum, clear_sum, 1 << 18); + +/// Supervisor Previous Privilege Mode +#[inline] +#[cfg(riscv)] +pub unsafe fn set_spp(spp: SPP) { + match spp { + SPP::Supervisor => _set(1 << 8), + SPP::User => _clear(1 << 8), + } +} + +/// The status of the floating-point unit +#[inline] +#[cfg(riscv)] +pub unsafe fn set_fs(fs: FS) { + let mut value = _read(); + value.set_bits(13..15, fs as usize); + _write(value); +} diff --git a/imports/riscv-0.5.6/src/register/stval.rs b/imports/riscv-0.5.6/src/register/stval.rs new file mode 100644 index 000000000..722cc1947 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/stval.rs @@ -0,0 +1,3 @@ +//! stval register + +read_csr_as_usize!(0x143, __read_stval); diff --git a/imports/riscv-0.5.6/src/register/stvec.rs b/imports/riscv-0.5.6/src/register/stvec.rs new file mode 100644 index 000000000..2bbbefa32 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/stvec.rs @@ -0,0 +1,40 @@ +//! stvec register + +pub use crate::register::mtvec::TrapMode; + +/// stvec register +#[derive(Clone, Copy, Debug)] +pub struct Stvec { + bits: usize, +} + +impl Stvec { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits + } + + /// Returns the trap-vector base-address + pub fn address(&self) -> usize { + self.bits - (self.bits & 0b11) + } + + /// Returns the trap-vector mode + pub fn trap_mode(&self) -> TrapMode { + let mode = self.bits & 0b11; + match mode { + 0 => TrapMode::Direct, + 1 => TrapMode::Vectored, + _ => unimplemented!() + } + } +} + +read_csr_as!(Stvec, 0x105, __read_stvec); +write_csr!(0x105, __write_stvec); + +/// Writes the CSR +#[inline] +pub unsafe fn write(addr: usize, mode: TrapMode) { + _write(addr + mode as usize); +} diff --git a/imports/riscv-0.5.6/src/register/time.rs b/imports/riscv-0.5.6/src/register/time.rs new file mode 100644 index 000000000..665b50792 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/time.rs @@ -0,0 +1,4 @@ +//! time register + +read_csr_as_usize!(0xC01, __read_time); +read_composite_csr!(super::timeh::read(), read()); diff --git a/imports/riscv-0.5.6/src/register/timeh.rs b/imports/riscv-0.5.6/src/register/timeh.rs new file mode 100644 index 000000000..ff725dbe7 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/timeh.rs @@ -0,0 +1,3 @@ +//! timeh register + +read_csr_as_usize_rv32!(0xC81, __read_timeh); diff --git a/imports/riscv-0.5.6/src/register/ucause.rs b/imports/riscv-0.5.6/src/register/ucause.rs new file mode 100644 index 000000000..06dd8a336 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/ucause.rs @@ -0,0 +1,17 @@ +//! ucause register + +/// ucause register +#[derive(Clone, Copy, Debug)] +pub struct Ucause { + bits: usize, +} + +impl Ucause { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } +} + +read_csr_as!(Ucause, 0x042, __read_ucause); diff --git a/imports/riscv-0.5.6/src/register/uepc.rs b/imports/riscv-0.5.6/src/register/uepc.rs new file mode 100644 index 000000000..1c9fa0e32 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/uepc.rs @@ -0,0 +1,4 @@ +//! uepc register + +read_csr_as_usize!(0x041, __read_uepc); +write_csr_as_usize!(0x041, __write_uepc); diff --git a/imports/riscv-0.5.6/src/register/uie.rs b/imports/riscv-0.5.6/src/register/uie.rs new file mode 100644 index 000000000..4a5e9e038 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/uie.rs @@ -0,0 +1,49 @@ +//! uie register + +use bit_field::BitField; + +/// uie register +#[derive(Clone, Copy, Debug)] +pub struct Uie { + bits: usize, +} + +impl Uie { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Enable + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// User Timer Interrupt Enable + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// User External Interrupt Enable + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } +} + +read_csr_as!(Uie, 0x004, __read_uie); +set!(0x004, __set_uie); +clear!(0x004, __clear_uie); + +set_clear_csr!( + /// User Software Interrupt Enable + , set_usoft, clear_usoft, 1 << 0); +set_clear_csr!( + /// User Timer Interrupt Enable + , set_utimer, clear_utimer, 1 << 4); +set_clear_csr!( + /// User External Interrupt Enable + , set_uext, clear_uext, 1 << 8); diff --git a/imports/riscv-0.5.6/src/register/uip.rs b/imports/riscv-0.5.6/src/register/uip.rs new file mode 100644 index 000000000..ec92ad874 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/uip.rs @@ -0,0 +1,37 @@ +//! uip register + +use bit_field::BitField; + +/// uip register +#[derive(Clone, Copy, Debug)] +pub struct Uip { + bits: usize, +} + +impl Uip { + /// Returns the contents of the register as raw bits + #[inline] + pub fn bits(&self) -> usize { + self.bits + } + + /// User Software Interrupt Pending + #[inline] + pub fn usoft(&self) -> bool { + self.bits.get_bit(0) + } + + /// User Timer Interrupt Pending + #[inline] + pub fn utimer(&self) -> bool { + self.bits.get_bit(4) + } + + /// User External Interrupt Pending + #[inline] + pub fn uext(&self) -> bool { + self.bits.get_bit(8) + } +} + +read_csr_as!(Uip, 0x044, __read_uip); diff --git a/imports/riscv-0.5.6/src/register/uscratch.rs b/imports/riscv-0.5.6/src/register/uscratch.rs new file mode 100644 index 000000000..2bc225395 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/uscratch.rs @@ -0,0 +1,4 @@ +//! uscratch register + +read_csr_as_usize!(0x040, __read_uscratch); +write_csr_as_usize!(0x040, __write_uscratch); diff --git a/imports/riscv-0.5.6/src/register/ustatus.rs b/imports/riscv-0.5.6/src/register/ustatus.rs new file mode 100644 index 000000000..81890bad6 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/ustatus.rs @@ -0,0 +1,37 @@ +//! ustatus register +// TODO: Virtualization, Memory Privilege and Extension Context Fields + +use bit_field::BitField; + +/// ustatus register +#[derive(Clone, Copy, Debug)] +pub struct Ustatus { + bits: usize, +} + +impl Ustatus { + /// User Interrupt Enable + #[inline] + pub fn uie(&self) -> bool { + self.bits.get_bit(0) + } + + /// User Previous Interrupt Enable + #[inline] + pub fn upie(&self) -> bool { + self.bits.get_bit(4) + } +} + +read_csr_as!(Ustatus, 0x000, __read_ustatus); +write_csr!(0x000, __write_ustatus); +set!(0x000, __set_ustatus); +clear!(0x000, __clear_ustatus); + +set_clear_csr!( + /// User Interrupt Enable + , set_uie, clear_uie, 1 << 0); + +set_csr!( + /// User Previous Interrupt Enable + , set_upie, 1 << 4); diff --git a/imports/riscv-0.5.6/src/register/utval.rs b/imports/riscv-0.5.6/src/register/utval.rs new file mode 100644 index 000000000..b87dca631 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/utval.rs @@ -0,0 +1,3 @@ +//! utval register + +read_csr_as_usize!(0x043, __read_utval); diff --git a/imports/riscv-0.5.6/src/register/utvec.rs b/imports/riscv-0.5.6/src/register/utvec.rs new file mode 100644 index 000000000..31b610962 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/utvec.rs @@ -0,0 +1,40 @@ +//! stvec register + +pub use crate::register::mtvec::TrapMode; + +/// stvec register +#[derive(Clone, Copy, Debug)] +pub struct Utvec { + bits: usize, +} + +impl Utvec { + /// Returns the contents of the register as raw bits + pub fn bits(&self) -> usize { + self.bits + } + + /// Returns the trap-vector base-address + pub fn address(&self) -> usize { + self.bits - (self.bits & 0b11) + } + + /// Returns the trap-vector mode + pub fn trap_mode(&self) -> TrapMode { + let mode = self.bits & 0b11; + match mode { + 0 => TrapMode::Direct, + 1 => TrapMode::Vectored, + _ => unimplemented!() + } + } +} + +read_csr_as!(Utvec, 0x005, __read_utvec); +write_csr!(0x005, __write_utvec); + +/// Writes the CSR +#[inline] +pub unsafe fn write(addr: usize, mode: TrapMode) { + _write(addr + mode as usize); +} diff --git a/imports/riscv-0.5.6/src/register/vexriscv/dci.rs b/imports/riscv-0.5.6/src/register/vexriscv/dci.rs new file mode 100644 index 000000000..afd80fff3 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/vexriscv/dci.rs @@ -0,0 +1,10 @@ +//! vexriscv dci register -- dcache info +//! +//! This register is only available if the core was built with +//! `DBusCachedPlugin` enabled and `csrInfo` set to `true`. +//! +//! See +//! [DBusCachedPlugin.scala](https://github.com/SpinalHDL/VexRiscv/blob/95237b23ea2d658cb3e0aa77680ca2851ef5d882/src/main/scala/vexriscv/plugin/DBusCachedPlugin.scala#L358) +//! for more information. + +read_csr_as_usize!(0xCC0, __read_vdci); diff --git a/imports/riscv-0.5.6/src/register/vexriscv/mim.rs b/imports/riscv-0.5.6/src/register/vexriscv/mim.rs new file mode 100644 index 000000000..f29769214 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/vexriscv/mim.rs @@ -0,0 +1,4 @@ +//! vexriscv mim register -- machine irq mask + +read_csr_as_usize!(0xBC0, __read_vmim); +write_csr_as_usize!(0xBC0, __write_vmim); diff --git a/imports/riscv-0.5.6/src/register/vexriscv/mip.rs b/imports/riscv-0.5.6/src/register/vexriscv/mip.rs new file mode 100644 index 000000000..78a76d028 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/vexriscv/mip.rs @@ -0,0 +1,3 @@ +//! vexriscv mip register -- machine irq pending + +read_csr_as_usize!(0xFC0, __read_vmip); diff --git a/imports/riscv-0.5.6/src/register/vexriscv/mod.rs b/imports/riscv-0.5.6/src/register/vexriscv/mod.rs new file mode 100644 index 000000000..907b5bf62 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/vexriscv/mod.rs @@ -0,0 +1,13 @@ +//! VexRiscv CSRs +//! +//! [VexRiscv](https://github.com/SpinalHDL/VexRiscv) is a RISC-V softcore +//! written in Scala. It is highly configurable, and can be built with features +//! such as a dcache and an external interrupt controller. +//! +//! These features use vendor-specific CSRs, which are available using this +//! module. +pub mod dci; +pub mod mim; +pub mod mip; +pub mod sim; +pub mod sip; diff --git a/imports/riscv-0.5.6/src/register/vexriscv/sim.rs b/imports/riscv-0.5.6/src/register/vexriscv/sim.rs new file mode 100644 index 000000000..87e8158fc --- /dev/null +++ b/imports/riscv-0.5.6/src/register/vexriscv/sim.rs @@ -0,0 +1,4 @@ +//! vexriscv sim register -- supervisor irq mask + +read_csr_as_usize!(0x9C0, __read_vsim); +write_csr_as_usize!(0x9C0, __write_vsim); diff --git a/imports/riscv-0.5.6/src/register/vexriscv/sip.rs b/imports/riscv-0.5.6/src/register/vexriscv/sip.rs new file mode 100644 index 000000000..b56943581 --- /dev/null +++ b/imports/riscv-0.5.6/src/register/vexriscv/sip.rs @@ -0,0 +1,3 @@ +//! vexriscv sip register -- supervisor irq pending + +read_csr_as_usize!(0xDC0, __read_vsip); From 19653e9c536c5b6e0f6cc695d72b740f8bb5d219 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:14:24 +0800 Subject: [PATCH 02/14] kernel: compatibility with `riscv32imac-unknown-xous-elf` Signed-off-by: Sean Cross --- kernel/assemble.ps1 | 1 + kernel/assemble.sh | 1 + kernel/bin/riscv32i-unknown-none-elf.a | Bin 9078 -> 9062 bytes kernel/bin/riscv32imac-unknown-none-elf.a | Bin 8886 -> 8870 bytes kernel/bin/riscv32imac-unknown-xous-elf.a | Bin 0 -> 8870 bytes kernel/bin/riscv32imc-unknown-none-elf.a | Bin 8886 -> 8870 bytes kernel/bin/riscv64gc-unknown-none-elf.a | Bin 14254 -> 14238 bytes kernel/bin/riscv64imac-unknown-none-elf.a | Bin 14254 -> 14238 bytes kernel/build.rs | 2 +- kernel/link.x | 1 + kernel/src/arch/hosted/mod.rs | 332 ++++++++++++---------- kernel/src/arch/hosted/process.rs | 2 +- kernel/src/debug/mod.rs | 30 +- kernel/src/main.rs | 8 +- kernel/src/services.rs | 7 +- kernel/src/syscall.rs | 5 +- kernel/utralib/src/lib.rs | 2 +- 17 files changed, 219 insertions(+), 172 deletions(-) create mode 100644 kernel/bin/riscv32imac-unknown-xous-elf.a diff --git a/kernel/assemble.ps1 b/kernel/assemble.ps1 index b0295d439..a56afbec4 100644 --- a/kernel/assemble.ps1 +++ b/kernel/assemble.ps1 @@ -5,6 +5,7 @@ $crate = "xous-kernel" riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32imac src/asm.S -o bin/$crate.o riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o riscv64-unknown-elf-ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32i src/asm.S -DSKIP_MULTICORE -o bin/$crate.o diff --git a/kernel/assemble.sh b/kernel/assemble.sh index 773c791a9..28c5ccc25 100755 --- a/kernel/assemble.sh +++ b/kernel/assemble.sh @@ -14,6 +14,7 @@ rm -f bin/*.a riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32imac src/asm.S -o bin/$crate.o ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o +ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32i src/asm.S -DSKIP_MULTICORE -o bin/$crate.o diff --git a/kernel/bin/riscv32i-unknown-none-elf.a b/kernel/bin/riscv32i-unknown-none-elf.a index 78f087d64a5d653b8fd10b7d97268a8a8034e97c..bc88a1f90b914febb384ac02b03e013226dc04e9 100644 GIT binary patch delta 188 zcmez7_RMX91ec+ik)@HjsiB3zM5P%j2%dt1fdU9XNJ9eyGcz*<1q%yfqlx!47zH-7 zGah7BakYwZ&QD2=iO4T42C|A$W3p3=@=|jc-2Flo9D@~%^o)%*|6wcQWK`aqFOV<5 zC@}fHfH>`jd;5lo>fDPghcBRGGXVNNP-e4kTSB S^DC<}woEn$k|C4hmBj%Hd^FJj delta 204 zcmaFn_RVdA1ebvV3`|s-p@QHkC_vZ{(#*sJtjxl~#A4z-4Mv5{?2HFlP4qMJb5r$` zO7rqEQ}vVcQ&ROS@=J?#lk##L(GAeIg&z~>A z7%*90!Jl!@C@{HQQJYbJ@@7S4MvKYU71bG2CjSSL5tG%G)EQeQ R`vb`%lgokRl*#jz!~w^fHPHY7 delta 204 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 R`vb`%lgokRl*#jz!~w^fHPHY7 delta 204 zcmZ4Hy3KWh1ebvV3`|s-p@QHkC_vZ{(#*sJtjxm9)NJBC4aS7c?2I2-O!PDIb5r$` zO7rqEQ}vVcQ&ROS@=J?#lkbY9QIOnIN#zf?o76VyDsWI89MR}^U#6GJt{Rc2TS&&V5^C^)va!d?jlPiqt7;jAeZd}j!VRE?%i2QD{pRr-`c2jpo%gO&u&6yUk zPA)JKo7`tAFgealf>C2~xtTrZ16GLfnv?e%$xprq6c?EM-OQe`V6wTnJ!gjjM0Phw F7680FOmhGL diff --git a/kernel/bin/riscv64imac-unknown-none-elf.a b/kernel/bin/riscv64imac-unknown-none-elf.a index dc4ff04e8af6297030309b6c9ba5459d53325422..3e38f01244b5d726bf2538c7506fead82643a4bb 100644 GIT binary patch delta 236 zcmZ3NKQDiR1ec+ik)@HjsiB3zM5P(32%dt1fdU9XNJ9eyGcz*<1w#`91B;3G^%*TT z^D{cK>bY9QIOnIN#zf?o76VyDsWI89MR}^U#6GJt{Rc2TS&&V5^C^)va!d?jlPiqt7;jAeZd}j!VRE?%i2QD{pRr-`c2jpo%gO&u&6yUk zPA)JKo7`tAFgealf>C2~xtTrZ16GLfnv?e%$xprq6c?EM-OQe`V6wTnJ!gjjM0Phw F7680FOmhGL diff --git a/kernel/build.rs b/kernel/build.rs index 7b30e8adf..fa21b2647 100644 --- a/kernel/build.rs +++ b/kernel/build.rs @@ -17,7 +17,7 @@ fn main() { // If we're not running on a desktop-class operating system, emit the "baremetal" // config setting. This will enable software to do tasks such as // managing memory. - if target_os == "none" { + if target_os == "none" || target_os == "xous" { println!("Target {} is bare metal", target); println!("cargo:rustc-cfg=baremetal"); } else { diff --git a/kernel/link.x b/kernel/link.x index 8848cfb5d..0028887c0 100644 --- a/kernel/link.x +++ b/kernel/link.x @@ -69,6 +69,7 @@ SECTIONS /DISCARD/ : { *(.eh_frame); + *(.eh_frame_hdr); } } diff --git a/kernel/src/arch/hosted/mod.rs b/kernel/src/arch/hosted/mod.rs index 79ca7526e..833070905 100644 --- a/kernel/src/arch/hosted/mod.rs +++ b/kernel/src/arch/hosted/mod.rs @@ -85,22 +85,25 @@ fn handle_connection( chn: Sender, should_exit: std::sync::Arc, ) { - enum ServerMessage { - Exit, - ServerPacket([usize; 9]), - ServerPacketWithData([usize; 9], Vec), - } + // enum ServerMessage { + // Exit, + // ServerPacket(Box), + // ServerPacketWithData([usize; 9], Vec), + // } - fn conn_thread(mut conn: TcpStream, sender: Sender, _pid: PID) { + fn conn_thread(mut conn: TcpStream, sender: Sender, pid: PID) { loop { let mut raw_data = [0u8; 9 * std::mem::size_of::()]; + + // Read bytes from the connection. This will fail when the connection closes, + // so send a `Termination` message across the channel. if let Err(_e) = conn.read_exact(&mut raw_data) { #[cfg(not(test))] eprintln!( "KERNEL({}): client disconnected: {} -- shutting down virtual process", - _pid, _e + pid, _e ); - sender.send(ServerMessage::Exit).ok(); + // sender.send(ServerMessage::Exit).ok(); return; } @@ -111,40 +114,68 @@ fn handle_connection( { *word = usize::from_le_bytes(bytes.try_into().unwrap()); } + let thread_id = packet_data[0] as TID; + let mut call = match crate::SysCall::from_args( + packet_data[1], + packet_data[2], + packet_data[3], + packet_data[4], + packet_data[5], + packet_data[6], + packet_data[7], + packet_data[8], + ) { + Ok(call) => call, + Err(e) => { + eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e); + eprintln!( + "Raw packet: {:08x} {} {} {} {} {} {} {}", + packet_data[0], + packet_data[1], + packet_data[2], + packet_data[3], + packet_data[4], + packet_data[5], + packet_data[6], + packet_data[7] + ); + continue; + } + }; + + if let Some(mem) = unsafe { call.memory_mut() } { + let mut data = vec![0u8; mem.len()]; + if conn.read_exact(&mut data).is_err() { + return; + } + + let sliced_data = data.into_boxed_slice(); + assert_eq!( + sliced_data.len(), + mem.len(), + "deconstructed data {} != message buf length {}", + sliced_data.len(), + mem.len() + ); + *mem = unsafe { + xous_kernel::MemoryRange::new( + Box::into_raw(sliced_data) as *mut u8 as usize, + mem.len(), + ) + .unwrap() + }; + } sender - .send( - if (packet_data[1] == xous_kernel::syscall::SysCallNumber::SendMessage as _ - || packet_data[1] - == xous_kernel::syscall::SysCallNumber::TrySendMessage as _) - && (packet_data[3] == 1 || packet_data[3] == 2 || packet_data[3] == 3) - { - let mut v = vec![0; packet_data[6]]; - if conn.read_exact(&mut v).is_err() { - sender.send(ServerMessage::Exit).ok(); - return; - } - ServerMessage::ServerPacketWithData(packet_data, v) - } else if packet_data[1] - == xous_kernel::syscall::SysCallNumber::ReturnMemory as _ - { - let mut v = vec![0; packet_data[4]]; - if conn.read_exact(&mut v).is_err() { - sender.send(ServerMessage::Exit).ok(); - return; - } - ServerMessage::ServerPacketWithData(packet_data, v) - } else { - ServerMessage::ServerPacket(packet_data) - }, - ) + .send(ThreadMessage::SysCall(pid, thread_id, call)) .unwrap(); } } - let (sender, receiver) = unbounded(); - let conn_sender = sender.clone(); - std::thread::Builder::new() + // let (sender, receiver) = unbounded(); + // let conn_sender = sender.clone(); + let conn_sender = chn.clone(); + let conn_thread = std::thread::Builder::new() .name(format!("PID {}: client connection thread", pid)) .spawn(move || { conn_thread(conn, conn_sender, pid); @@ -155,122 +186,124 @@ fn handle_connection( .name(format!("PID {}: client should_exit thread", pid)) .spawn(move || loop { if should_exit.load(core::sync::atomic::Ordering::Relaxed) { - // eprintln!("KERNEL: should_exit == 1"); - sender.send(ServerMessage::Exit).ok(); + eprintln!("KERNEL: should_exit == 1"); + // sender.send(ServerMessage::Exit).ok(); + // WARNING: This functionality is unimplemented right now return; } std::thread::park_timeout(std::time::Duration::from_secs(1)); }) .unwrap(); - for msg in receiver { - match msg { - ServerMessage::Exit => { - #[cfg(not(test))] - eprintln!("KERNEL({}): Received ServerMessage::Exit", pid); - break; - } - ServerMessage::ServerPacket(pkt) => { - let thread_id = pkt[0]; - let call = xous_kernel::SysCall::from_args( - pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], - ); - match call { - Err(e) => { - eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e); - eprintln!( - "Raw packet: {:08x} {} {} {} {} {} {} {}", - pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7] - ); - } - Ok(call) => chn - .send(ThreadMessage::SysCall(pid, thread_id, call)) - .expect("couldn't make syscall"), - } - } - ServerMessage::ServerPacketWithData(pkt, data) => { - let thread_id = pkt[0]; - let call = xous_kernel::SysCall::from_args( - pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], - ); - match call { - Err(e) => { - eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e); - eprintln!( - "Raw packet: {:08x} {} {} {} {} {} {} {}", - pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7] - ); - } - Ok(mut call) => { - // eprintln!( - // "Received packet: {:08x} {} {} {} {} {} {} {}: {:?}", - // pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], call - // ); - match call { - SysCall::SendMessage(ref _cid, ref mut envelope) - | SysCall::TrySendMessage(ref _cid, ref mut envelope) => { - match envelope { - xous_kernel::Message::MutableBorrow(msg) - | xous_kernel::Message::Borrow(msg) - | xous_kernel::Message::Move(msg) => { - // Update the address pointer. This will get turned back into a - // usable pointer by casting it back into a &[T] on the other - // side. This is just a pointer to the start of data - // as well as the index into the data it points at. The lengths - // should still be equal once we reconstitute the data in the - // other process. - // ::debug_here::debug_here!(); - let sliced_data = data.into_boxed_slice(); - assert_eq!( - sliced_data.len(), - msg.buf.len(), - "deconstructed data {} != message buf length {}", - sliced_data.len(), - msg.buf.len() - ); - msg.buf = unsafe { - xous_kernel::MemoryRange::new( - Box::into_raw(sliced_data) as *mut u8 as usize, - msg.buf.len(), - ) - .unwrap() - }; - } - xous_kernel::Message::Scalar(_) - | xous_kernel::Message::BlockingScalar(_) => (), - } - } - SysCall::ReturnMemory( - ref _sender, - ref mut buf, - ref _offset, - ref _valid, - ) => { - let sliced_data = data.into_boxed_slice(); - assert_eq!( - sliced_data.len(), - buf.len(), - "deconstructed data {} != message buf length {}", - sliced_data.len(), - buf.len() - ); - *buf = unsafe { - xous_kernel::MemoryRange::new( - Box::into_raw(sliced_data) as *mut u8 as usize, - buf.len(), - ) - .unwrap() - }; - } - _ => panic!("unsupported message type"), - } - chn.send(ThreadMessage::SysCall(pid, thread_id, call)) - .expect("couldn't make syscall"); - } - } - } - } - } + // for msg in receiver { + // match msg { + // ServerMessage::Exit => { + // #[cfg(not(test))] + // eprintln!("KERNEL({}): Received ServerMessage::Exit", pid); + // break; + // } + // ServerMessage::ServerPacket(pkt) => { + // let thread_id = pkt[0]; + // let call = xous_kernel::SysCall::from_args( + // pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], + // ); + // match call { + // Err(e) => { + // eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e); + // eprintln!( + // "Raw packet: {:08x} {} {} {} {} {} {} {}", + // pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7] + // ); + // } + // Ok(call) => chn + // .send(ThreadMessage::SysCall(pid, thread_id, call)) + // .expect("couldn't make syscall"), + // } + // } + // ServerMessage::ServerPacketWithData(pkt, data) => { + // let thread_id = pkt[0]; + // let call = xous_kernel::SysCall::from_args( + // pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], + // ); + // match call { + // Err(e) => { + // eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e); + // eprintln!( + // "Raw packet: {:08x} {} {} {} {} {} {} {}", + // pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7] + // ); + // } + // Ok(mut call) => { + // // eprintln!( + // // "Received packet: {:08x} {} {} {} {} {} {} {}: {:?}", + // // pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], call + // // ); + // match call { + // SysCall::SendMessage(ref _cid, ref mut envelope) + // | SysCall::TrySendMessage(ref _cid, ref mut envelope) => { + // match envelope { + // xous_kernel::Message::MutableBorrow(msg) + // | xous_kernel::Message::Borrow(msg) + // | xous_kernel::Message::Move(msg) => { + // // Update the address pointer. This will get turned back into a + // // usable pointer by casting it back into a &[T] on the other + // // side. This is just a pointer to the start of data + // // as well as the index into the data it points at. The lengths + // // should still be equal once we reconstitute the data in the + // // other process. + // // ::debug_here::debug_here!(); + // let sliced_data = data.into_boxed_slice(); + // assert_eq!( + // sliced_data.len(), + // msg.buf.len(), + // "deconstructed data {} != message buf length {}", + // sliced_data.len(), + // msg.buf.len() + // ); + // msg.buf = unsafe { + // xous_kernel::MemoryRange::new( + // Box::into_raw(sliced_data) as *mut u8 as usize, + // msg.buf.len(), + // ) + // .unwrap() + // }; + // } + // xous_kernel::Message::Scalar(_) + // | xous_kernel::Message::BlockingScalar(_) => (), + // } + // } + // SysCall::ReturnMemory( + // ref _sender, + // ref mut buf, + // ref _offset, + // ref _valid, + // ) => { + // let sliced_data = data.into_boxed_slice(); + // assert_eq!( + // sliced_data.len(), + // buf.len(), + // "deconstructed data {} != message buf length {}", + // sliced_data.len(), + // buf.len() + // ); + // *buf = unsafe { + // xous_kernel::MemoryRange::new( + // Box::into_raw(sliced_data) as *mut u8 as usize, + // buf.len(), + // ) + // .unwrap() + // }; + // } + // _ => panic!("unsupported message type"), + // } + // chn.send(ThreadMessage::SysCall(pid, thread_id, call)) + // .expect("couldn't make syscall"); + // } + // } + // } + // } + // } + conn_thread.join().unwrap(); #[cfg(not(test))] eprintln!( "KERNEL({}): Finished the thread so sending TerminateProcess", @@ -535,6 +568,7 @@ pub fn idle() -> bool { } } ThreadMessage::SysCall(pid, thread_id, call) => { + // let measurement_start = std::time::Instant::now(); // println!("KERNEL({}): Received syscall {:?}", pid, call); crate::arch::process::set_current_pid(pid); // println!("KERNEL({}): Now running as the new process", pid); @@ -607,6 +641,12 @@ pub fn idle() -> bool { .ok(); }); crate::arch::process::set_current_pid(existing_pid); + // println!( + // "KERNEL [{:2}:{:2}] Syscall took {:7} usec", + // pid, + // thread_id, + // measurement_start.elapsed().as_micros() + // ); } if is_shutdown { diff --git a/kernel/src/arch/hosted/process.rs b/kernel/src/arch/hosted/process.rs index 7c0aff16e..f41c66d7c 100644 --- a/kernel/src/arch/hosted/process.rs +++ b/kernel/src/arch/hosted/process.rs @@ -391,7 +391,7 @@ impl Process { let process = &mut process_table.table[current_pid_idx].as_mut().unwrap(); let conn = process.conn.as_mut().unwrap(); conn.write_all(bytes).unwrap(); - conn.flush().unwrap(); + // conn.flush().unwrap(); }); Ok(()) } diff --git a/kernel/src/debug/mod.rs b/kernel/src/debug/mod.rs index a6eaf3f3c..a63e65bca 100644 --- a/kernel/src/debug/mod.rs +++ b/kernel/src/debug/mod.rs @@ -3,7 +3,7 @@ #[cfg(baremetal)] use core::fmt::{Error, Write}; -#[cfg(target_os = "none")] +#[cfg(baremetal)] use utralib::generated::*; #[cfg(baremetal)] @@ -12,7 +12,7 @@ pub static mut DEBUG_OUTPUT: Option<&'static mut dyn Write> = None; #[macro_use] #[cfg(all( not(test), - target_os = "none", + baremetal, any(feature = "debug-print", feature = "print-panics") ))] pub mod debug_print_hardware { @@ -21,12 +21,12 @@ pub mod debug_print_hardware { } #[cfg(all( not(test), - target_os = "none", + baremetal, any(feature = "debug-print", feature = "print-panics") ))] pub use crate::debug::debug_print_hardware::SUPERVISOR_UART_ADDR; -#[cfg(all(target_os = "none"))] +#[cfg(baremetal)] #[macro_export] macro_rules! print { ($($args:tt)+) => {{ @@ -39,7 +39,7 @@ macro_rules! print { }}; } -#[cfg(target_os = "none")] +#[cfg(baremetal)] #[macro_export] macro_rules! println { @@ -54,15 +54,15 @@ macro_rules! println }); } -#[cfg(target_os = "none")] +#[cfg(baremetal)] pub struct Uart {} -#[cfg(target_os = "none")] +#[cfg(baremetal)] pub static mut UART: Uart = Uart {}; #[cfg(all(target_os = "none", feature = "wrap-print"))] static mut CHAR_COUNT: usize = 0; -#[cfg(target_os = "none")] +#[cfg(baremetal)] impl Uart { #[allow(dead_code)] pub fn init(self) { @@ -117,10 +117,10 @@ impl Uart { } } -#[cfg(all(feature = "gdbserver", target_os = "none"))] +#[cfg(all(feature = "gdbserver", baremetal))] mod gdb_server; -#[cfg(all(feature = "gdbserver", target_os = "none"))] +#[cfg(all(feature = "gdbserver", baremetal))] impl gdbstub::Connection for Uart { type Error = (); @@ -144,7 +144,7 @@ impl gdbstub::Connection for Uart { #[cfg(all( not(test), - target_os = "none", + baremetal, any(feature = "debug-print", feature = "print-panics") ))] pub fn irq(_irq_number: usize, _arg: *mut usize) { @@ -157,11 +157,11 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) { #[cfg(all( not(test), - target_os = "none", + baremetal, any(feature = "debug-print", feature = "print-panics") ))] fn process_irq_character(b: u8) { - #[cfg(all(feature = "gdbserver", target_os = "none"))] + #[cfg(all(feature = "gdbserver", baremetal))] if gdb_server::handle(b) { return; } @@ -257,7 +257,7 @@ fn process_irq_character(b: u8) { }); println!("{} k total", total_bytes / 1024); } - #[cfg(all(feature = "gdbserver", target_os = "none"))] + #[cfg(all(feature = "gdbserver", baremetal))] b'g' => { println!("Starting GDB server -- attach your debugger now"); gdb_server::setup(); @@ -277,7 +277,7 @@ fn process_irq_character(b: u8) { } } -#[cfg(target_os = "none")] +#[cfg(baremetal)] impl Write for Uart { fn write_str(&mut self, s: &str) -> Result<(), Error> { for c in s.bytes() { diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 27cb11d94..226690ba5 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -4,7 +4,7 @@ #![cfg_attr(baremetal, no_main)] #![cfg_attr(baremetal, no_std)] -#[cfg(target_os = "none")] +#[cfg(baremetal)] #[macro_use] extern crate bitflags; @@ -28,9 +28,9 @@ mod syscall; use services::SystemServices; use xous_kernel::*; -#[cfg(target_os = "none")] +#[cfg(baremetal)] use core::panic::PanicInfo; -#[cfg(target_os = "none")] +#[cfg(baremetal)] #[panic_handler] fn handle_panic(_arg: &PanicInfo) -> ! { println!("PANIC in PID {}: {}", crate::arch::current_pid(), _arg); @@ -150,7 +150,7 @@ pub extern "C" fn kmain() { // Note that at this point, no new direct children of INIT may be created. let mut pid = None; - #[cfg(not(any(target_os = "none", all(ci, test))))] + #[cfg(not(any(target_os = "none", target_os = "xous", all(ci, test))))] { use std::panic; panic::set_hook(Box::new(|arg| { diff --git a/kernel/src/services.rs b/kernel/src/services.rs index f234f9311..d38d6e120 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -1914,7 +1914,7 @@ impl SystemServices { /// within the current process. pub fn sidx_from_cid(&self, cid: CID) -> Option { // println!("KERNEL({}): Attempting to get SIDX from CID {}", crate::arch::process::current_pid(), cid); - if cid == 0 || cid == 1 { + if cid < 2 { return None; } @@ -1930,8 +1930,9 @@ impl SystemServices { // println!("KERNEL({}): CID {} doesn't exist in the connection map", crate::arch::process::current_pid(), cid + 2); // println!("KERNEL({}): Process inner is: {:?}", crate::arch::process::current_pid(), process_inner); // } - let mut server_idx = process_inner.connection_map[cid as usize]?.get() as usize; - if server_idx == 1 { + let connection_value = *process_inner.connection_map.get(cid as usize)?; + let mut server_idx = connection_value?.get() as usize; + if server_idx < 2 { // println!("KERNEL({}): CID {} is no longer valid", crate::arch::process::current_pid(), cid + 2); return None; } diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 3a99101e9..0646183a3 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -600,7 +600,8 @@ fn receive_message(pid: PID, tid: TID, sid: SID, blocking: ExecutionType) -> Sys pub fn handle(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult { #[cfg(feature = "debug-print")] print!("KERNEL({}:{}): Syscall {:x?}", pid, tid, call); - + // let call_string = format!("{:x?}", call); + // let start_time = std::time::Instant::now(); #[allow(clippy::let_and_return)] let result = if in_irq && !call.can_call_from_interrupt() { Err(xous_kernel::Error::InvalidSyscall) @@ -608,6 +609,8 @@ pub fn handle(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult handle_inner(pid, tid, in_irq, call) }; + // println!("KERNEL [{:2}:{:2}] Syscall took {:7} usec: {}", pid, tid, start_time.elapsed().as_micros(), call_string); + #[cfg(feature = "debug-print")] println!( " -> ({}:{}) {:x?}", diff --git a/kernel/utralib/src/lib.rs b/kernel/utralib/src/lib.rs index 6cf78339f..24d4bdeb5 100644 --- a/kernel/utralib/src/lib.rs +++ b/kernel/utralib/src/lib.rs @@ -1,3 +1,3 @@ -#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(any(target_os = "none", target_os = "xous"), no_std)] pub mod generated; pub use generated::*; From bb0339652a43afec769243f2ade73beddf35d254 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:15:29 +0800 Subject: [PATCH 03/14] kernel: use local copy of `riscv` crate A local copy of the `riscv` crate is used in order to get support for the `xous` target_os. Signed-off-by: Sean Cross --- kernel/Cargo.lock | 2 -- kernel/Cargo.toml | 25 +++++++++++++++---------- 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/kernel/Cargo.lock b/kernel/Cargo.lock index 17a4f6657..4a125f367 100644 --- a/kernel/Cargo.lock +++ b/kernel/Cargo.lock @@ -453,8 +453,6 @@ dependencies = [ [[package]] name = "riscv" version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a12a859c86dbbcad4eb18daa0465932d907687abfa909c9cc0ca32dc237c8c3" dependencies = [ "bare-metal", "bit_field", diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 90df965a1..36d2d7f38 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -9,20 +9,25 @@ resolver = "2" [dependencies] bitflags = "1.2.1" # gdbstub branch "dev/0.6" -gdbstub = {git = "https://github.com/daniel5151/gdbstub.git", optional = true, default_features = false, rev = "5c702d063baaf78e4ebed7842cc8b96195d119a8"} -gdbstub_arch = {git = "https://github.com/daniel5151/gdbstub.git", optional = true, rev = "5c702d063baaf78e4ebed7842cc8b96195d119a8"} -sha3 = {default-features = false, version = "0.8.2"} -stats_alloc = {version = "0.1.8", optional = true} -xous-kernel = {package = "xous", path = "../xous-rs", features = ["forget-memory-messages"]} +gdbstub = { git = "https://github.com/daniel5151/gdbstub.git", optional = true, default_features = false, rev = "5c702d063baaf78e4ebed7842cc8b96195d119a8" } +gdbstub_arch = { git = "https://github.com/daniel5151/gdbstub.git", optional = true, rev = "5c702d063baaf78e4ebed7842cc8b96195d119a8" } +sha3 = { default-features = false, version = "0.8.2" } +stats_alloc = { version = "0.1.8", optional = true } +xous-kernel = { package = "xous", path = "../xous-rs", features = [ + "forget-memory-messages", +] } [target.'cfg(any(windows,unix))'.dev-dependencies] -xous-kernel = {package = "xous", path = "../xous-rs", features = ["forget-memory-messages", "processes-as-threads"]} +xous-kernel = { package = "xous", path = "../xous-rs", features = [ + "forget-memory-messages", + "processes-as-threads", +] } [target.'cfg(not(any(windows, unix)))'.dependencies] -utralib = {path = "utralib"} +utralib = { path = "utralib" } [target.'cfg(target_arch = "riscv32")'.dependencies] -riscv = "0.5.6" +riscv = { version = "0.5.6", path = "../imports/riscv-0.5.6" } [features] debug-print = [] @@ -42,7 +47,7 @@ rand = "0.7" [profile.release] codegen-units = 1 # 1 better optimizations -debug = true # symbols are nice and they don't increase the size on Flash -lto = "fat" +debug = true # symbols are nice and they don't increase the size on Flash +lto = "fat" # panic = "abort" # Remove some panic information # opt-level = 'z' # Optimize for size instead of performance From 184274782c515cd6b03b9bc6b0ddf5ba89e952f5 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:16:13 +0800 Subject: [PATCH 04/14] kernel: config: temporarily remove support for lto LTO is currently broken with Rust 1.54. Signed-off-by: Sean Cross --- kernel/.cargo/config | 1 - 1 file changed, 1 deletion(-) diff --git a/kernel/.cargo/config b/kernel/.cargo/config index 6ad13b533..2b608c286 100644 --- a/kernel/.cargo/config +++ b/kernel/.cargo/config @@ -14,7 +14,6 @@ rustflags = [ [target.riscv32imac-unknown-xous-elf] rustflags = [ "-C", "link-arg=-Tlink.x", - "-C", "linker-plugin-lto=yes", "-C", "force-frame-pointers=no", ] From f952d0d9fe8f5f88b60f4a71b4c253a167cc8a1b Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:17:53 +0800 Subject: [PATCH 05/14] loader: cargo: add support for -xous- target_os Add link commands to the cargo config so that the loader can be built for the `riscv32imac-unknown-xous-elf` target. Signed-off-by: Sean Cross --- loader/.cargo/config | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/loader/.cargo/config b/loader/.cargo/config index efe45bcfb..07b5cbc8b 100644 --- a/loader/.cargo/config +++ b/loader/.cargo/config @@ -13,3 +13,11 @@ rustflags = [ "-C", "force-frame-pointers=no", "-C", "link-arg=-Map=loader.map", ] + +[target.riscv32imac-unknown-xous-elf] +rustflags = [ + "-C", "link-arg=-Tlink.x", + "-C", "linker-plugin-lto=yes", + "-C", "force-frame-pointers=no", + "-C", "link-arg=-Map=loader.map", +] From c9c02b5d933c192d74d90031effb12d471aee1bd Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:18:56 +0800 Subject: [PATCH 06/14] loader: initial riscv32imac-unknown-xous compat Initial changes required to get the loader building for the `riscv32imac-unknown-xous-elf` target. Signed-off-by: Sean Cross --- loader/assemble.ps1 | 1 + loader/assemble.sh | 1 + loader/bin/riscv32i-unknown-none-elf.a | Bin 3462 -> 3442 bytes loader/bin/riscv32imac-unknown-none-elf.a | Bin 3462 -> 3446 bytes loader/bin/riscv32imac-unknown-xous-elf.a | Bin 0 -> 3446 bytes loader/bin/riscv32imc-unknown-none-elf.a | Bin 3462 -> 3446 bytes loader/bin/riscv64gc-unknown-none-elf.a | Bin 5290 -> 5282 bytes loader/bin/riscv64imac-unknown-none-elf.a | Bin 5290 -> 5282 bytes loader/link.x | 1 + loader/sha2/src/lib.rs | 2 +- loader/utralib/src/lib.rs | 2 +- 11 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 loader/bin/riscv32imac-unknown-xous-elf.a diff --git a/loader/assemble.ps1 b/loader/assemble.ps1 index b0295d439..a56afbec4 100644 --- a/loader/assemble.ps1 +++ b/loader/assemble.ps1 @@ -5,6 +5,7 @@ $crate = "xous-kernel" riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32imac src/asm.S -o bin/$crate.o riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o +riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o riscv64-unknown-elf-ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32i src/asm.S -DSKIP_MULTICORE -o bin/$crate.o diff --git a/loader/assemble.sh b/loader/assemble.sh index 9ee94973b..5e305f861 100755 --- a/loader/assemble.sh +++ b/loader/assemble.sh @@ -10,6 +10,7 @@ rm -f bin/*.a riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32imac src/asm.S -o bin/$crate.o ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o +ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32i src/asm.S -DSKIP_MULTICORE -o bin/$crate.o diff --git a/loader/bin/riscv32i-unknown-none-elf.a b/loader/bin/riscv32i-unknown-none-elf.a index 00b0e5c35fad69b0cefff96122432a76a2b67a56..e4622674b93ab22aba1b33d35767c5d486b6d7ce 100755 GIT binary patch delta 197 zcmZpZ{veT7>Y8Blgk(w`GHK< zqB3KnOrrvW$p^V)H%l{DGchV}p3eH6m2uDHer|t8fywuQoGwM&i i%%jYz&cwhVHTgG>GNa36d0utKmdWlwGGcN*uQ&j7A2l!l delta 240 zcmew))h0bbn%&I6z`(-PV4_mI0+gwsV4wg35Yo`Vz|71{LBZI_a^gZwCLXShXC5$y zxmm^JBo?Komgg5`#}t(om*|#f=EWrEr=-SIi z=^2|cILb0GFcf7LCzmlW3Imy}MP=JH+>;k_$!z9gu3%y`+uY3hot5#z zVqJjz=4op%aiUcL6AZUoTl;6-A z5x53Iu2F+aL(ouL^dC4yU{Jr~Y0}E zV#Oehj1Zns!{N;$mS>qZ%y^V>g>jYf1;#T_ZV#s?aB46MX8G()?C=Bp#WAN$-2qH(w U91I-+98Yux=>_DGI@Fx*KY*5DtpET3 delta 641 zcmZvYJ4?e*6vyw0NfjIMF{mh**a|7d>TO!%1Ba?b(Lq5G1cRm4D8*_d@ljly)WxCY z3_6M+U7YOT2XJu^^kWDvx+sXCH>O>JXZYR!|J-xVeSCDBbQU^mHA?Bw04)Ym-G4GZ zEX!1O!ex|FP19sKrVgvcs}LvF7azmiJ6HS)wMgG^iQLxHSc=%@~8;?*eW#Px*&sw zr$Rr(@lKe7B-Z*Qm_)@lG40&5E$X&9I#!u7#Mbu8BOP7M_b}b$cZ(8iX;xjGESG&H z9`d;C55hAZ`4zaq5@QcOF`nTk;|ofn0=GED_<$zkD4vUo@WTFm9Ph=T5atMp;Hwyf RC2VX^-~tC3bC_yq`vp!SZ8ZP@ diff --git a/loader/bin/riscv32imac-unknown-xous-elf.a b/loader/bin/riscv32imac-unknown-xous-elf.a new file mode 100644 index 0000000000000000000000000000000000000000..ef790b671ce3471cdc84a4a7df0cff563c6f6d96 GIT binary patch literal 3446 zcmb7`U2GIp6vxl(v=u>WKM<;@3{$xv!m{0#HXtFbhL0F91~Ad2vCOs$tSq}Qv#ll3 z2>7D$!5U(GFedoq3nnHcHa=kF&n6^3V#NP{?wMuwqA{N2-ueB{Irn4k zy>oXr?up{rQ+rqL2s&+Kyu7PCv2$YAND!3LP`(a=v2vDwe5Hu^D2=SlB&{fJNmOZ~ zPI=~ZHEvYvve=wYwp%VXG339EGEypykB6goeTX&MBaw%B~OB3H-zdGpOyt;hj&gA7w-+0TuObuVD$oqwxzsG+q z7i4n67jN`pMLsNuT)tG0Wa&t$dF#$??@GR(<$*MMVQ_Iso?CJ4M!`##3K*ehC=nS* z`qqu@y_iT)`VI5&B|zd)urqj|sOT#c4^n-Fz6Z|TZ!1K*@=-UY8;`g;1k0nhJU-@B=I zu)7_56r}CjzC2)&cGxxAw|n~8=3I69C7d2mT%E2rqq%A<2cCa1m^vDii=$q?{Q#vyf9j>mCu%D&ajGD&7#T=aS!7FbohLoVdnJHgPtkwZaKQ*)hitR zfTPzqnrmaNOL_o-D$(&={e%-Yj^66%qNB@>9(VL!M?d4}{f<89=tGWv!O_PYJ?-e@ zj;=WRgri?|G_NLWc0b}w>Uu6XdePCZ=X4tZzO4Ai{mqcznR4}s9oGLhckX{k8(VWxZP&bWiH0K=s{itAMqdBjEL;Ob3$VPMC z0EdJ0ija-wyaf*R0wNpDd58XoP{GJXbKV1oYv~ms8_oFu9P%*1$VPKM0*6ENija-w zd;$(1rdNb)H0M)r_z1lsWTQEsfy4Fmija-wTmy%CVUmsJd`Z6^X0p+oujuD51dMDn z=X-FtfnE`^(VQQ^VSoxoHk$JjINV6D2-yTAk)Kh*FvXOO=KM;(e&}SQIXsTuR-4Zw z;yq=V+v#nx%%%5?WiFGq*)m_r;|B^0P`oEelKy6R`lI0XGpzlv&&}Gu6qEC3T2Teh zR&1ZAGHO*9TT+~hT9FhhNg~C#T91nK7Hf?fLaCmsR_0I6)N74uhojaw(M01k7*#59 zb)h31#ZlvA6@A(a42dv*!;4X?71t{BEd>9EaqB%4{lsO=XQLYozve+Kze1B{3 z;@{yV*&o*+>+c9SYXg)e2t5Xr?bu;(zQ14a^4a{j4q1P%n^KEB5)jd5Krps+v2XtyACSWIiiSl&g!o}Epds5W3t^wUUP y%%Sm_oeAoL5R+)w2j&=@6B*NKp8=q}jeXlmP|N!3htAFlL(^#ZvF7lR<^2s&Di6N^ literal 0 HcmV?d00001 diff --git a/loader/bin/riscv32imc-unknown-none-elf.a b/loader/bin/riscv32imc-unknown-none-elf.a index fe2b07cc1dfe9bb7e77a6bc1d672e3810966c834..ef790b671ce3471cdc84a4a7df0cff563c6f6d96 100755 GIT binary patch delta 570 zcmZ9Iu}cC`9LL`~@03uXLNHRgQz1=6&y()ZAyP>VqJjz=4op%aiUcL6AZUoTl;6-A z5x53Iu2F+aL(ouL^dC4yU{Jr~Y0}E zV#Oehj1Zns!{N;$mS>qZ%y^V>g>jYf1;#T_ZV#s?aB46MX8G()?C=Bp#WAN$-2qH(w U91I-+98Yux=>_DGI@Fx*KY*5DtpET3 delta 641 zcmZvYJ4?e*6vyw0NfjIMF{mh**a|7d>TO!%1Ba?b(Lq5G1cRm4D8*_d@ljly)WxCY z3_6M+U7YOT2XJu^^kWDvx+sXCH>O>JXZYR!|J-xVeSCDBbQU^mHA?Bw04)Ym-G4GZ zEX!1O!ex|FP19sKrVgvcs}LvF7azmiJ6HS)wMgG^iQLxHSc=%@~8;?*eW#Px*&sw zr$Rr(@lKe7B-Z*Qm_)@lG40&5E$X&9I#!u7#Mbu8BOP7M_b}b$cZ(8iX;xjGESG&H z9`d;C55hAZ`4zaq5@QcOF`nTk;|ofn0=GED_<$zkD4vUo@WTFm9Ph=T5atMp;Hwyf RC2VX^-~tC3bC_yq`vp!SZ8ZP@ diff --git a/loader/bin/riscv64gc-unknown-none-elf.a b/loader/bin/riscv64gc-unknown-none-elf.a index 8eeeea44c696a4997be6508035b5a3da91b70e59..6ec46e5fb710ff2986ce28650e0f66dce7f5fc1a 100755 GIT binary patch delta 809 zcmZ`%L1+^}6rGvfWD^TD*$p%yLDzV&0qIUQY1R~RQ=>*y3R(<>24XeA3PL2oQbZKm zizrCq>p>_==~2DqP|x<5i=YR=n*k3V_2wn+ZZerB9k!LW+8%CjA7&Vpw-rS ztDWRVmyx)TIio0jq6qyDdp`z+?Tt?qlXN;U_)B;GSF|S+(!E9(C|s^$^5i6Nb_Fn&KjY|5EBx(%@QaJkMT?3G=jKz z3QaMZ_dD~7ggbZ;?6(l&t!MFGtkU!NBWjrQMPoM(N*y+;FJsZC#cCe6tLXVO$bKGs z!pX@_RzPm!W6vqXXzHc_)GMplg~(59Px$lfQeX>YP5{+l17&> z5hy*q+|!Yw&TKVwri=}+v-CL;`@a*nQ}sF*>{hD|lR fP>f*J%~I$o27Lx0V$xLRe{xHlf0b z;JxDqQM|}bQoQvbxTD}*ya--~-t?k)tfDVz%F3Ys;rqV-dtZLu|H$D&Z=pLY8kExI z96ivgbAePP0K-scnW)+B`as0ax$=&&Tmd4cHY3RV0r z%)l!C5K^#)nNaGQb@H*VMiXvN@b66U?_xWYf^Ec5`TXMvnGXIAnb_e3d=}247LMU@ zSO)_ia0*@&v-nPk_@`T911k7Q^zO(@<^7dlUYv1yZ1%{{jCr2C67(~Sy=NZP$UmK5 z3<43xQ=>5B)uHzO7ee&0gG&F4v?2K$+>C1Q8rxA5KHw3+GGq!y^l1=U> t;2(JfI#^IlQRVz$_)&=Cb45F|KI};n-z!Vd#erh7rz}jHaE$Hg#DAMAi|YUY diff --git a/loader/bin/riscv64imac-unknown-none-elf.a b/loader/bin/riscv64imac-unknown-none-elf.a index 8eeeea44c696a4997be6508035b5a3da91b70e59..6ec46e5fb710ff2986ce28650e0f66dce7f5fc1a 100755 GIT binary patch delta 809 zcmZ`%L1+^}6rGvfWD^TD*$p%yLDzV&0qIUQY1R~RQ=>*y3R(<>24XeA3PL2oQbZKm zizrCq>p>_==~2DqP|x<5i=YR=n*k3V_2wn+ZZerB9k!LW+8%CjA7&Vpw-rS ztDWRVmyx)TIio0jq6qyDdp`z+?Tt?qlXN;U_)B;GSF|S+(!E9(C|s^$^5i6Nb_Fn&KjY|5EBx(%@QaJkMT?3G=jKz z3QaMZ_dD~7ggbZ;?6(l&t!MFGtkU!NBWjrQMPoM(N*y+;FJsZC#cCe6tLXVO$bKGs z!pX@_RzPm!W6vqXXzHc_)GMplg~(59Px$lfQeX>YP5{+l17&> z5hy*q+|!Yw&TKVwri=}+v-CL;`@a*nQ}sF*>{hD|lR fP>f*J%~I$o27Lx0V$xLRe{xHlf0b z;JxDqQM|}bQoQvbxTD}*ya--~-t?k)tfDVz%F3Ys;rqV-dtZLu|H$D&Z=pLY8kExI z96ivgbAePP0K-scnW)+B`as0ax$=&&Tmd4cHY3RV0r z%)l!C5K^#)nNaGQb@H*VMiXvN@b66U?_xWYf^Ec5`TXMvnGXIAnb_e3d=}247LMU@ zSO)_ia0*@&v-nPk_@`T911k7Q^zO(@<^7dlUYv1yZ1%{{jCr2C67(~Sy=NZP$UmK5 z3<43xQ=>5B)uHzO7ee&0gG&F4v?2K$+>C1Q8rxA5KHw3+GGq!y^l1=U> t;2(JfI#^IlQRVz$_)&=Cb45F|KI};n-z!Vd#erh7rz}jHaE$Hg#DAMAi|YUY diff --git a/loader/link.x b/loader/link.x index 035c30181..0664ad85d 100644 --- a/loader/link.x +++ b/loader/link.x @@ -133,6 +133,7 @@ SECTIONS /DISCARD/ : { *(.eh_frame); + *(.eh_frame_hdr); } } diff --git a/loader/sha2/src/lib.rs b/loader/sha2/src/lib.rs index 87ad49c7d..e3538eec1 100644 --- a/loader/sha2/src/lib.rs +++ b/loader/sha2/src/lib.rs @@ -1,4 +1,4 @@ -#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(any(target_os = "none", target_os = "xous"), no_std)] use digest::{BlockInput, FixedOutputDirty, Reset, Update}; use digest::consts::{U64, U128}; diff --git a/loader/utralib/src/lib.rs b/loader/utralib/src/lib.rs index 6cf78339f..24d4bdeb5 100644 --- a/loader/utralib/src/lib.rs +++ b/loader/utralib/src/lib.rs @@ -1,3 +1,3 @@ -#![cfg_attr(target_os = "none", no_std)] +#![cfg_attr(any(target_os = "none", target_os = "xous"), no_std)] pub mod generated; pub use generated::*; From f5de6551bcef413ebe940b05adca0ed338cb13f1 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:19:41 +0800 Subject: [PATCH 07/14] loader: cargo: load packages that work with xous target Load versions of the dalek crates that support the xous target. Signed-off-by: Sean Cross --- loader/Cargo.lock | 52 ++++++++++++++++++++++++----------------------- loader/Cargo.toml | 33 ++++++++++++------------------ 2 files changed, 40 insertions(+), 45 deletions(-) diff --git a/loader/Cargo.lock b/loader/Cargo.lock index 5383ded1f..3fe0b6f90 100644 --- a/loader/Cargo.lock +++ b/loader/Cargo.lock @@ -1,5 +1,7 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +version = 3 + [[package]] name = "ansi_term" version = "0.11.0" @@ -11,9 +13,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.33" +version = "1.0.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1fd36ffbb1fb7c834eac128ea8d0e310c5aeb635548f9d58861e1308d46e71c" +checksum = "28ae2b3dec75a406790005a200b1bd89785afc02517a00ca99ecfe093ee9e6cf" [[package]] name = "atty" @@ -28,9 +30,9 @@ dependencies = [ [[package]] name = "bitflags" -version = "1.2.1" +version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "block-buffer" @@ -65,7 +67,7 @@ dependencies = [ [[package]] name = "com_rs" version = "0.1.0" -source = "git+https://github.com/betrusted-io/com_rs?branch=main#4b45a42ad2d932550566d6c32ec1e1dd60e93c67" +source = "git+https://github.com/betrusted-io/com_rs?branch=main#8959b373adc359f03a0da7c000bd8208b47d90a7" [[package]] name = "convert_case" @@ -76,7 +78,7 @@ checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" [[package]] name = "curve25519-dalek" version = "3.1.0" -source = "git+https://github.com/betrusted-io/curve25519-dalek.git?branch=main#c0ee5bf18c606b51bbffb02fde5801ac129b4e7d" +source = "git+https://github.com/betrusted-io/curve25519-dalek.git?branch=main#93538aab361685775710cdb24c2093c2590e5911" dependencies = [ "byteorder", "digest", @@ -98,9 +100,9 @@ dependencies = [ [[package]] name = "ed25519" -version = "1.1.1" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d0860415b12243916284c67a9be413e044ee6668247b99ba26d94b2bc06c8f6" +checksum = "4620d40f6d2601794401d6dd95a5cf69b6c157852539470eeda433a99b3c0efc" dependencies = [ "signature", ] @@ -120,7 +122,7 @@ dependencies = [ [[package]] name = "engine25519-as" version = "0.1.0" -source = "git+https://github.com/betrusted-io/engine25519-as.git?rev=6681e73c1fdc4a460b5ef9f9c7c91aef546d00f3#6681e73c1fdc4a460b5ef9f9c7c91aef546d00f3" +source = "git+https://github.com/betrusted-io/engine25519-as.git?rev=274b82899d28535ac6d4b7869e26eef2039578d5#274b82899d28535ac6d4b7869e26eef2039578d5" [[package]] name = "generic-array" @@ -134,9 +136,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.1.17" +version = "0.1.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" dependencies = [ "libc", ] @@ -149,9 +151,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.97" +version = "0.2.99" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12b8adadd720df158f4d70dfe7ccc6adb0472d7c55ca83445f6a5ab3e36f8fb6" +checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765" [[package]] name = "loader" @@ -166,9 +168,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.3.3" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" +checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc" [[package]] name = "opaque-debug" @@ -178,9 +180,9 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" [[package]] name = "proc-macro2" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038" +checksum = "5c7ed8b8c7b886ea3ed7dde405212185f423ab44682667c8c6dd14aa1d9f6612" dependencies = [ "unicode-xid", ] @@ -233,9 +235,9 @@ checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a" [[package]] name = "subtle" -version = "2.4.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e81da0851ada1f3e9d4312c704aa4f8806f0f9d69faaf8df2f3464b4a9437c2" +checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601" [[package]] name = "svd2utra" @@ -249,9 +251,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.73" +version = "1.0.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f71489ff30030d2ae598524f61326b902466f72a0fb1a8564c001cc63425bcc7" +checksum = "1873d832550d4588c3dbc20f01361ab00bfe741048f71e3fecf145a7cc18b29c" dependencies = [ "proc-macro2", "quote", @@ -260,9 +262,9 @@ dependencies = [ [[package]] name = "synstructure" -version = "0.12.4" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701" +checksum = "474aaa926faa1603c40b7885a9eaea29b444d1cb2850cb7c0e37bb1a4182f4fa" dependencies = [ "proc-macro2", "quote", @@ -340,9 +342,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] name = "zeroize" -version = "1.3.0" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd" +checksum = "377db0846015f7ae377174787dd452e1c5f5a9050bc6f954911d01f116daa0cd" dependencies = [ "zeroize_derive", ] diff --git a/loader/Cargo.toml b/loader/Cargo.toml index 18a98ccdd..18eb661d7 100644 --- a/loader/Cargo.toml +++ b/loader/Cargo.toml @@ -6,23 +6,20 @@ edition = "2018" description = "Initial kernel loader for Xous" [dependencies] -utralib = {path = "utralib"} +utralib = { path = "utralib" } [dependencies.com_rs] -git="https://github.com/betrusted-io/com_rs" -branch="main" +git = "https://github.com/betrusted-io/com_rs" +branch = "main" [dependencies.curve25519-dalek] -git="https://github.com/betrusted-io/curve25519-dalek.git" -branch="main" -#path = "../../curve25519-dalek" package = "curve25519-dalek" -version = "3.1.0" +version = "3" default-features = false features = ["u32e_backend"] [dependencies.ed25519-dalek] -version="1.0.1" +version = "1.0.1" default-features = false #features = ["u32_backend"] @@ -36,13 +33,8 @@ earlyprintk = [] #default = ["debug-print"] default = [] -[profile.release] -codegen-units = 1 # 1 better optimizations -debug = true # symbols are nice and they don't increase the size on Flash -lto = "fat" - [target.'cfg(not(any(windows, unix)))'.dependencies] -utralib = { path = "utralib"} +utralib = { path = "utralib" } # patch key references into our local name space [patch.crates-io.sha2] @@ -54,9 +46,10 @@ default-features = false path = "utralib" [patch.crates-io.curve25519-dalek] -git="https://github.com/betrusted-io/curve25519-dalek.git" -branch="main" -package = "curve25519-dalek" -version = "3.1.0" -default-features = false -features = ["u32e_backend"] \ No newline at end of file +git = "https://github.com/betrusted-io/curve25519-dalek.git" +branch = "main" + +[profile.release] +codegen-units = 1 # 1 better optimizations +debug = true # symbols are nice and they don't increase the size on Flash +lto = "fat" From 7dee05082c242813ee58fea2c93b0bcca813ccc8 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:21:19 +0800 Subject: [PATCH 08/14] xous: syscall: add function to modify memory ptr Add a function to modify the pointer of a MemoryRange. This is used by `hosted` mode in order to modify memory pointers when we receive them from the remote client. Signed-off-by: Sean Cross --- xous-rs/src/syscall.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index df717e5d8..5650b29e6 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -985,6 +985,25 @@ impl SysCall { } } + /// If the syscall has memory attached to it, return the memory, mutably + /// + /// # Safety + /// + /// This function is only safe to call to fixup the pointer. It should + /// not be used for any other purpose. + pub unsafe fn memory_mut(&mut self) -> Option<&mut MemoryRange> { + match self { + SysCall::TrySendMessage(_, msg) | SysCall::SendMessage(_, msg) => match msg { + Message::Move(memory_message) + | Message::Borrow(memory_message) + | Message::MutableBorrow(memory_message) => Some(&mut memory_message.buf), + _ => None, + }, + SysCall::ReturnMemory(_, range, _, _) => Some(range), + _ => None, + } + } + /// Returns `true` if the given syscall may be called from an IRQ context pub fn can_call_from_interrupt(&self) -> bool { if let SysCall::TrySendMessage(_cid, msg) = self { From 83f88f6fdeee88bd3b0e67d2a29dd4c4fa5f371a Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:22:07 +0800 Subject: [PATCH 09/14] xous: hosted: improve performance by removing a copy Remove one copy step when receiving packets. This should improve performance of Hosted mode by around 1.5x. Signed-off-by: Sean Cross --- xous-rs/src/arch/hosted/mod.rs | 246 +-------------------------- xous-rs/src/arch/hosted/threading.rs | 243 ++++++++++++++++++++++++++ 2 files changed, 248 insertions(+), 241 deletions(-) create mode 100644 xous-rs/src/arch/hosted/threading.rs diff --git a/xous-rs/src/arch/hosted/mod.rs b/xous-rs/src/arch/hosted/mod.rs index b43b90dd2..8ceb6071d 100644 --- a/xous-rs/src/arch/hosted/mod.rs +++ b/xous-rs/src/arch/hosted/mod.rs @@ -1,18 +1,18 @@ -use std::cell::RefCell; use std::collections::HashMap; use std::convert::TryInto; use std::io::{Read, Write}; use std::mem::size_of; use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream, ToSocketAddrs}; -use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::{Arc, Condvar, Mutex}; -use std::thread_local; use crate::{Result, SysCall, SysCallResult, PID, TID}; mod mem; pub use mem::*; +mod threading; +pub use threading::*; + lazy_static::lazy_static! { static ref NETWORK_CONNECT_ADDRESS: SocketAddr = { std::env::var("XOUS_SERVER") @@ -96,11 +96,6 @@ lazy_static::lazy_static! { /// The network address to connect to when making a kernel call static ref CHILD_PROCESS_ADDRESS: Arc> = Arc::new(Mutex::new(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0))); } -thread_local!(static THREAD_ID: RefCell> = RefCell::new(None)); - -/// Describes the parameters required to create a new thread on this platform. -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct ThreadInit {} pub fn set_xous_address(new_address: SocketAddr) { *CHILD_PROCESS_ADDRESS.lock().unwrap() = new_address; @@ -110,53 +105,6 @@ pub fn set_thread_id(new_tid: TID) { THREAD_ID.with(|tid| *tid.borrow_mut() = Some(new_tid)); } -static FAKE_THREAD_COUNTER: AtomicUsize = AtomicUsize::new(65536); - -/// Obtain this thread's ID. This value is set whenever a new thread is -/// created via xous syscalls. However, if a new thread is created using -/// something other than a xous syscall (e.g. by doing `std::thread::spawn()), -/// then the kernel doesn't have a record of the new thread. -/// If that happens, then register a new thread with the kernel. -fn thread_id() -> TID { - THREAD_ID.with(|tid| { - if let Some(tid) = *tid.borrow() { - return tid; - } - let call = crate::SysCall::CreateThread(ThreadInit {}); - - let fake_tid = FAKE_THREAD_COUNTER.fetch_add(1, Ordering::SeqCst); - println!( - "Thread ID not defined! Creating a fake thread. Syscall TID: {}.", - fake_tid - ); - - // assert!(SERVER_CONNECTION - // .call_tracker - // .lock() - // .unwrap() - // .insert(fake_tid, ()) - // .is_none()); - - send_syscall_from_tid(&call, fake_tid); - let response = read_syscall_result(fake_tid); - - // assert!(SERVER_CONNECTION - // .response_tracker - // .lock() - // .unwrap() - // .remove(&fake_tid) - // .is_some()); - let new_tid = if let crate::Result::ThreadID(new_tid) = response { - new_tid - } else { - panic!("unable to get new TID, got response: {:?}", response) - }; - println!("Created a fake thread ID: {}", new_tid); - *tid.borrow_mut() = Some(new_tid); - new_tid - }) -} - /// A 16-byte random nonce that identifies this process to the kernel. This /// is usually provided through the environment variable `XOUS_PROCESS_KEY`. #[derive(Copy, Clone, Debug, PartialEq)] @@ -245,8 +193,6 @@ pub fn wait_process(mut joiner: ProcessHandle) -> crate::SysCallResult { }) } -pub struct WaitHandle(std::thread::JoinHandle); - #[derive(PartialEq)] enum CallMemoryKind { Borrow, @@ -264,10 +210,6 @@ struct ServerConnection { // response_tracker: Arc>>, } -pub fn thread_to_args(call: usize, _init: &ThreadInit) -> [usize; 8] { - [call, 0, 0, 0, 0, 0, 0, 0] -} - pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] { [ call, @@ -281,18 +223,6 @@ pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] { ] } -pub fn args_to_thread( - _a1: usize, - _a2: usize, - _a3: usize, - _a4: usize, - _a5: usize, - _a6: usize, - _a7: usize, -) -> core::result::Result { - Ok(ThreadInit {}) -} - pub fn args_to_process( a1: usize, a2: usize, @@ -314,174 +244,6 @@ pub fn args_to_process( }) } -pub fn create_thread_0_pre(_f: &fn() -> U) -> core::result::Result -where - U: Send + 'static, -{ - Ok(ThreadInit {}) -} -pub fn create_thread_1_pre( - _f: &fn(usize) -> U, - _arg1: &usize, -) -> core::result::Result -where - U: Send + 'static, -{ - Ok(ThreadInit {}) -} -pub fn create_thread_2_pre( - _f: &fn(usize, usize) -> U, - _arg1: &usize, - _arg2: &usize, -) -> core::result::Result -where - U: Send + 'static, -{ - Ok(ThreadInit {}) -} -pub fn create_thread_3_pre( - _f: &fn(usize, usize, usize) -> U, - _arg1: &usize, - _arg2: &usize, - _arg3: &usize, -) -> core::result::Result -where - U: Send + 'static, -{ - Ok(ThreadInit {}) -} -pub fn create_thread_4_pre( - _f: &fn(usize, usize, usize, usize) -> U, - _arg1: &usize, - _arg2: &usize, - _arg3: &usize, - _arg4: &usize, -) -> core::result::Result -where - U: Send + 'static, -{ - Ok(ThreadInit {}) -} - -pub fn create_thread_0_post( - f: fn() -> U, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - U: Send + 'static, -{ - create_thread_post(f, thread_id) -} - -pub fn create_thread_1_post( - f: fn(usize) -> U, - arg1: usize, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - U: Send + 'static, -{ - create_thread_post(move || f(arg1), thread_id) -} - -pub fn create_thread_2_post( - f: fn(usize, usize) -> U, - arg1: usize, - arg2: usize, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - U: Send + 'static, -{ - create_thread_post(move || f(arg1, arg2), thread_id) -} - -pub fn create_thread_3_post( - f: fn(usize, usize, usize) -> U, - arg1: usize, - arg2: usize, - arg3: usize, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - U: Send + 'static, -{ - create_thread_post(move || f(arg1, arg2, arg3), thread_id) -} - -pub fn create_thread_4_post( - f: fn(usize, usize, usize, usize) -> U, - arg1: usize, - arg2: usize, - arg3: usize, - arg4: usize, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - U: Send + 'static, -{ - create_thread_post(move || f(arg1, arg2, arg3, arg4), thread_id) -} - -pub fn create_thread_simple_pre( - _f: &fn(T) -> U, - _arg: &T, -) -> core::result::Result -where - T: Send + 'static, - U: Send + 'static, -{ - Ok(ThreadInit {}) -} - -pub fn create_thread_simple_post( - f: fn(T) -> U, - arg: T, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - T: Send + 'static, - U: Send + 'static, -{ - create_thread_post(move || f(arg), thread_id) -} - -pub fn create_thread_pre(_f: &F) -> core::result::Result -where - F: FnOnce() -> T, - F: Send + 'static, - T: Send + 'static, -{ - Ok(ThreadInit {}) -} - -/// Spawn a new thread with the given thread ID. -pub fn create_thread_post( - f: F, - thread_id: TID, -) -> core::result::Result, crate::Error> -where - F: FnOnce() -> U, - F: Send + 'static, - U: Send + 'static, -{ - std::thread::Builder::new() - .spawn(move || { - THREAD_ID.with(|tid| *tid.borrow_mut() = Some(thread_id)); - f() - }) - .map(WaitHandle) - .map_err(|_| crate::Error::InternalError) -} - -pub fn wait_thread(joiner: WaitHandle) -> crate::SysCallResult { - joiner - .0 - .join() - .map(|_| Result::Ok) - .map_err(|_| crate::Error::InternalError) -} - /// Perform a synchronous syscall to the kernel. pub fn syscall(call: SysCall) -> SysCallResult { let tid = thread_id(); @@ -509,6 +271,7 @@ pub fn syscall(call: SysCall) -> SysCallResult { .insert(tid, (range, kind)); } + // let start_time = std::time::Instant::now(); loop { // assert!(SERVER_CONNECTION // .call_tracker @@ -530,6 +293,7 @@ pub fn syscall(call: SysCall) -> SysCallResult { // .remove(&tid) // .is_some()); if let Some(val) = result { + // println!("[{:2}:{:2}] Syscall took {:7} usec: {:x?}", PROCESS_ID.get(), tid, start_time.elapsed().as_micros(), call); return val; } diff --git a/xous-rs/src/arch/hosted/threading.rs b/xous-rs/src/arch/hosted/threading.rs new file mode 100644 index 000000000..e0d0542c1 --- /dev/null +++ b/xous-rs/src/arch/hosted/threading.rs @@ -0,0 +1,243 @@ +use std::cell::RefCell; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::thread_local; + +use crate::{Result, TID}; + +thread_local!(pub static THREAD_ID: RefCell> = RefCell::new(None)); + +/// Describes the parameters required to create a new thread on this platform. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct ThreadInit {} +pub struct WaitHandle(std::thread::JoinHandle); + +pub fn thread_to_args(call: usize, _init: &ThreadInit) -> [usize; 8] { + [call, 0, 0, 0, 0, 0, 0, 0] +} + +pub fn args_to_thread( + _a1: usize, + _a2: usize, + _a3: usize, + _a4: usize, + _a5: usize, + _a6: usize, + _a7: usize, +) -> core::result::Result { + Ok(ThreadInit {}) +} + +pub fn create_thread_0_pre(_f: &fn() -> U) -> core::result::Result +where + U: Send + 'static, +{ + Ok(ThreadInit {}) +} +pub fn create_thread_1_pre( + _f: &fn(usize) -> U, + _arg1: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + Ok(ThreadInit {}) +} +pub fn create_thread_2_pre( + _f: &fn(usize, usize) -> U, + _arg1: &usize, + _arg2: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + Ok(ThreadInit {}) +} +pub fn create_thread_3_pre( + _f: &fn(usize, usize, usize) -> U, + _arg1: &usize, + _arg2: &usize, + _arg3: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + Ok(ThreadInit {}) +} +pub fn create_thread_4_pre( + _f: &fn(usize, usize, usize, usize) -> U, + _arg1: &usize, + _arg2: &usize, + _arg3: &usize, + _arg4: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + Ok(ThreadInit {}) +} + +pub fn create_thread_0_post( + f: fn() -> U, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + create_thread_post(f, thread_id) +} + +pub fn create_thread_1_post( + f: fn(usize) -> U, + arg1: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + create_thread_post(move || f(arg1), thread_id) +} + +pub fn create_thread_2_post( + f: fn(usize, usize) -> U, + arg1: usize, + arg2: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + create_thread_post(move || f(arg1, arg2), thread_id) +} + +pub fn create_thread_3_post( + f: fn(usize, usize, usize) -> U, + arg1: usize, + arg2: usize, + arg3: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + create_thread_post(move || f(arg1, arg2, arg3), thread_id) +} + +pub fn create_thread_4_post( + f: fn(usize, usize, usize, usize) -> U, + arg1: usize, + arg2: usize, + arg3: usize, + arg4: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + create_thread_post(move || f(arg1, arg2, arg3, arg4), thread_id) +} + +pub fn create_thread_simple_pre( + _f: &fn(T) -> U, + _arg: &T, +) -> core::result::Result +where + T: Send + 'static, + U: Send + 'static, +{ + Ok(ThreadInit {}) +} + +pub fn create_thread_simple_post( + f: fn(T) -> U, + arg: T, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + T: Send + 'static, + U: Send + 'static, +{ + create_thread_post(move || f(arg), thread_id) +} + +pub fn create_thread_pre(_f: &F) -> core::result::Result +where + F: FnOnce() -> T, + F: Send + 'static, + T: Send + 'static, +{ + Ok(ThreadInit {}) +} + +/// Spawn a new thread with the given thread ID. +pub fn create_thread_post( + f: F, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + F: FnOnce() -> U, + F: Send + 'static, + U: Send + 'static, +{ + std::thread::Builder::new() + .spawn(move || { + THREAD_ID.with(|tid| *tid.borrow_mut() = Some(thread_id)); + f() + }) + .map(WaitHandle) + .map_err(|_| crate::Error::InternalError) +} + +pub fn wait_thread(joiner: WaitHandle) -> crate::SysCallResult { + joiner + .0 + .join() + .map(|_| Result::Ok) + .map_err(|_| crate::Error::InternalError) +} + +static FAKE_THREAD_COUNTER: AtomicUsize = AtomicUsize::new(65536); + +/// Obtain this thread's ID. This value is set whenever a new thread is +/// created via xous syscalls. However, if a new thread is created using +/// something other than a xous syscall (e.g. by doing `std::thread::spawn()), +/// then the kernel doesn't have a record of the new thread. +/// If that happens, then register a new thread with the kernel. +pub(crate) fn thread_id() -> TID { + THREAD_ID.with(|tid| { + if let Some(tid) = *tid.borrow() { + return tid; + } + let call = crate::SysCall::CreateThread(ThreadInit {}); + + let fake_tid = FAKE_THREAD_COUNTER.fetch_add(1, Ordering::SeqCst); + println!( + "Thread ID not defined! Creating a fake thread. Syscall TID: {}.", + fake_tid + ); + + // assert!(SERVER_CONNECTION + // .call_tracker + // .lock() + // .unwrap() + // .insert(fake_tid, ()) + // .is_none()); + + super::send_syscall_from_tid(&call, fake_tid); + let response = super::read_syscall_result(fake_tid); + + // assert!(SERVER_CONNECTION + // .response_tracker + // .lock() + // .unwrap() + // .remove(&fake_tid) + // .is_some()); + let new_tid = if let crate::Result::ThreadID(new_tid) = response { + new_tid + } else { + panic!("unable to get new TID, got response: {:?}", response) + }; + println!("Created a fake thread ID: {}", new_tid); + *tid.borrow_mut() = Some(new_tid); + new_tid + }) +} From e96d356e15d544953eeb7fd2599065a96d955ae1 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:22:50 +0800 Subject: [PATCH 10/14] xtask: build kernel using `riscv32imac-unknown-xous-elf` Signed-off-by: Sean Cross --- xtask/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xtask/src/main.rs b/xtask/src/main.rs index b26da2cda..bfdd55570 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -8,7 +8,7 @@ use std::{ type DynError = Box; const PROGRAM_TARGET: &str = "riscv32imac-unknown-xous-elf"; -const KERNEL_TARGET: &str = "riscv32imac-unknown-none-elf"; +const KERNEL_TARGET: &str = "riscv32imac-unknown-xous-elf"; enum MemorySpec { SvdFile(String), From 66a68f1757bcb36ba3da5d952e0164d0c7879ac0 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:23:09 +0800 Subject: [PATCH 11/14] emulation: use riscv32imac-unknown-xous-elf loader Use the new target for the loader. Signed-off-by: Sean Cross --- emulation/xous-release.resc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/emulation/xous-release.resc b/emulation/xous-release.resc index 26d76aba9..251632e31 100644 --- a/emulation/xous-release.resc +++ b/emulation/xous-release.resc @@ -53,7 +53,7 @@ sysbus SilenceRange <0xF0023000, 0xF0023FFF> # The macro `reset` gets called implicitly when running `machine Reset` macro reset """ - sysbus LoadELF @../loader/target/riscv32imac-unknown-none-elf/release/loader + sysbus LoadELF @../loader/target/riscv32imac-unknown-xous-elf/release/loader sysbus LoadBinary @../target/riscv32imac-unknown-xous-elf/release/xous.img 0x20980000 # Set $a0 to point at the args binary cpu SetRegisterUnsafe 10 0x20980000 From 05801f3f06ad90cd3e4143d3c9d20c36faec2c7f Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:30:35 +0800 Subject: [PATCH 12/14] xtask: add simple check for toolchain This adds a simple check for the proper Rust toolchain. A more advance test will advise on toolchain installation. Signed-off-by: Sean Cross --- xtask/src/main.rs | 39 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) diff --git a/xtask/src/main.rs b/xtask/src/main.rs index bfdd55570..1fb3fd3b0 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -224,7 +224,12 @@ Please refer to tools/README_UPDATE.md for instructions on how to set up `usb_up ) } -fn update_usb(do_kernel: bool, do_loader: bool, nuke_soc: bool, stage_soc: bool) -> Result<(), DynError> { +fn update_usb( + do_kernel: bool, + do_loader: bool, + nuke_soc: bool, + stage_soc: bool, +) -> Result<(), DynError> { use std::io::{BufRead, BufReader, Error, ErrorKind}; use std::process::Stdio; @@ -534,6 +539,37 @@ fn build_kernel(debug: bool) -> Result { Ok(path) } +static DONE_COMPILER_CHECK: std::sync::atomic::AtomicBool = + std::sync::atomic::AtomicBool::new(false); +fn ensure_compiler(target: &Option<&str>) -> Result<(), String> { + use std::process::Stdio; + if DONE_COMPILER_CHECK.load(std::sync::atomic::Ordering::SeqCst) { + return Ok(()) + } + let target = target.unwrap_or(PROGRAM_TARGET).to_owned(); + let have_toolchain = Command::new("rustc") + .stderr(Stdio::null()) + .stdout(Stdio::null()) + .args(&[ + "--target", + &target, + "--print", + "sysroot", + ]) + .spawn() + .unwrap() + .wait() + .unwrap() + .success(); + + DONE_COMPILER_CHECK.store(have_toolchain, std::sync::atomic::Ordering::SeqCst); + if have_toolchain { + Ok(()) + } else { + Err(format!("Toolchain for {} not found", target)) + } +} + fn build( packages: &[&str], debug: bool, @@ -541,6 +577,7 @@ fn build( directory: Option, extra_args: Option<&[&str]>, ) -> Result { + ensure_compiler(&target)?; let stream = if debug { "debug" } else { "release" }; let mut args = vec!["build"]; print!("Building"); From 3c917d9be4e9550af254232055d7a35f0d04bcfb Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Thu, 19 Aug 2021 11:52:00 +0800 Subject: [PATCH 13/14] xtask: offer to download the toolchain If the toolchain does not exist, offer to download it for the user. Signed-off-by: Sean Cross --- xtask/Cargo.toml | 9 +- xtask/src/main.rs | 225 +++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 209 insertions(+), 25 deletions(-) diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml index aede498e0..95361f9b1 100644 --- a/xtask/Cargo.toml +++ b/xtask/Cargo.toml @@ -1,12 +1,13 @@ [package] name = "xtask" +description = "Cargo-based build system for Xous" version = "0.1.0" authors = ["Sean Cross "] edition = "2018" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [dependencies] +curl = "0.4" +atty = "0.2" filetime = "0.2" -#"ed25519-dalek" = "1" -#"pem" = "0.8" \ No newline at end of file +rustc_version = "0.4" +zip = "0.5" \ No newline at end of file diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 1fb3fd3b0..0bbbf0cf3 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -9,6 +9,9 @@ type DynError = Box; const PROGRAM_TARGET: &str = "riscv32imac-unknown-xous-elf"; const KERNEL_TARGET: &str = "riscv32imac-unknown-xous-elf"; +const TOOLCHAIN_URL_PREFIX: &str = + "https://github.com/betrusted-io/rust/releases/latest/download/riscv32imac-unknown-xous_"; +const TOOLCHAIN_URL_SUFFIX: &str = ".zip"; enum MemorySpec { SvdFile(String), @@ -539,35 +542,215 @@ fn build_kernel(debug: bool) -> Result { Ok(path) } +/// Since we use the same TARGET for all calls to `build()`, +/// cache it inside an atomic boolean. If this is `true` then +/// it means we can assume the check passed already. static DONE_COMPILER_CHECK: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); + +/// Ensure we have a compatible compiler toolchain. We use a new Target, +/// and we want to give the user a friendly way of installing the latest +/// Rust toolchain. fn ensure_compiler(target: &Option<&str>) -> Result<(), String> { use std::process::Stdio; if DONE_COMPILER_CHECK.load(std::sync::atomic::Ordering::SeqCst) { - return Ok(()) + return Ok(()); } - let target = target.unwrap_or(PROGRAM_TARGET).to_owned(); - let have_toolchain = Command::new("rustc") - .stderr(Stdio::null()) - .stdout(Stdio::null()) - .args(&[ - "--target", - &target, - "--print", - "sysroot", - ]) - .spawn() - .unwrap() - .wait() - .unwrap() - .success(); - DONE_COMPILER_CHECK.store(have_toolchain, std::sync::atomic::Ordering::SeqCst); - if have_toolchain { - Ok(()) - } else { - Err(format!("Toolchain for {} not found", target)) + /// Return the sysroot for the given target. If the target does not exist, + /// return None. + fn get_sysroot(target: Option<&str>) -> Result, String> { + let mut args = vec!["--print", "sysroot"]; + if let Some(target) = target { + args.push("--target"); + args.push(target); + } + + let sysroot_cmd = Command::new("rustc") + .stderr(Stdio::null()) + .stdout(Stdio::piped()) + .args(&args) + .spawn() + .expect("could not run rustc"); + let sysroot_output = sysroot_cmd.wait_with_output().unwrap(); + let have_toolchain = sysroot_output.status.success(); + + let toolchain_path = String::from_utf8(sysroot_output.stdout) + .map_err(|_| "Unable to find Rust sysroot".to_owned())? + .trim() + .to_owned(); + + if have_toolchain { + Ok(Some(toolchain_path)) + } else { + Ok(None) + } } + + // If the sysroot exists, then we're good. + let target = target.unwrap_or(PROGRAM_TARGET); + if get_sysroot(Some(target))?.is_some() { + DONE_COMPILER_CHECK.store(true, std::sync::atomic::Ordering::SeqCst); + return Ok(()); + } + + // Since no sysroot exists, we must download a new one. + let toolchain_path = + get_sysroot(None)?.ok_or_else(|| "default toolchain not installed".to_owned())?; + // If the terminal is a tty, offer to download the latest toolchain. + if !atty::is(atty::Stream::Stdin) { + return Err(format!("Toolchain for {} not found", target)); + } + + // Version 1.54 was the last major version that was released. + let ver = rustc_version::version().unwrap(); + if ver.major == 1 && ver.minor < 54 { + return Err("Rust 1.54 or higher is required".into()); + } + + // Ask the user if they want to install the toolchain. + let mut buffer = String::new(); + let stdin = std::io::stdin(); + let mut stdout = std::io::stdout(); + println!(); + println!( + "Error: Toolchain for {} was not found on this system!", + target + ); + loop { + print!("Would you like this program to attempt to download and install it? [Y/n] "); + stdout.flush().unwrap(); + buffer.clear(); + stdin.read_line(&mut buffer).unwrap(); + + let trimmed = buffer.trim(); + + if trimmed == "n" || trimmed == "N" { + return Err(format!("Please install the {} toolchain", target)); + } + + if trimmed == "y" || trimmed == "Y" || trimmed.is_empty() { + break; + } + println!(); + } + + let toolchain_url = format!( + "{}{}.{}.{}{}", + TOOLCHAIN_URL_PREFIX, ver.major, ver.minor, ver.patch, TOOLCHAIN_URL_SUFFIX + ); + + println!( + "Attempting to install toolchain for {} into {}", + target, toolchain_path + ); + println!("Downloading from {}...", toolchain_url); + + print!("Download rogress: 0%"); + stdout.flush().unwrap(); + let mut zip_data = vec![]; + { + let mut easy = curl::easy::Easy::new(); + easy.url(&toolchain_url).unwrap(); + easy.follow_location(true).unwrap(); + easy.progress(true).unwrap(); + let mut transfer = easy.transfer(); + transfer + .progress_function( + |total_bytes, bytes_so_far, _total_uploaded, _uploaded_so_far| { + // If either number is infinite, don't print anything and just continue. + if total_bytes.is_infinite() || bytes_so_far.is_infinite() { + return true; + } + + // Display progress. + print!( + "\rDownload progress: {:3.02}% ", + bytes_so_far / total_bytes * 100.0 + ); + stdout.flush().unwrap(); + + // Return `true` to continue the transfer. + true + }, + ) + .unwrap(); + transfer + .write_function(|data| { + zip_data.extend_from_slice(data); + Ok(data.len()) + }) + .unwrap(); + transfer + .perform() + .map_err(|e| format!("Unable to download toolchain: {}", e))?; + println!(); + } + println!( + "Download successful. Total data size is {} bytes", + zip_data.len() + ); + + /// Extract the zipfile to the target directory, ensuring that all files + /// contained within are created. + fn extract_zip>( + archive_data: P, + extract_to: P2, + ) -> Result<(), String> { + let mut archive = zip::ZipArchive::new(archive_data) + .map_err(|e| format!("unable to extract zip: {}", e))?; + for i in 0..archive.len() { + let mut entry_in_archive = archive + .by_index(i) + .map_err(|e| format!("unable to locate file index {}: {}", i, e))?; + // println!( + // "Trying to extract file {}", + // entry_in_archive.mangled_name().display() + // ); + + let output_path = extract_to.as_ref().join(entry_in_archive.mangled_name()); + if entry_in_archive.is_dir() { + std::fs::create_dir_all(&output_path).map_err(|e| { + format!( + "unable to create directory {}: {}", + output_path.display(), + e + ) + })?; + } else { + // Create the parent directory if necessary + if let Some(parent) = output_path.parent() { + if !parent.exists() { + std::fs::create_dir_all(&parent).map_err(|e| { + format!( + "unable to create directory {}: {}", + output_path.display(), + e + ) + })?; + } + } + let mut outfile = std::fs::File::create(&output_path).map_err(|e| { + format!("unable to create file {}: {}", output_path.display(), e) + })?; + std::io::copy(&mut entry_in_archive, &mut outfile).map_err(|e| { + format!( + "unable to write extracted file {}: {}", + output_path.display(), + e + ) + })?; + } + } + Ok(()) + } + println!("Extracting toolchain to {}...", toolchain_path); + extract_zip(std::io::Cursor::new(zip_data), &toolchain_path)?; + + println!("Toolchain successfully installed"); + + DONE_COMPILER_CHECK.store(true, std::sync::atomic::Ordering::SeqCst); + Ok(()) } fn build( From 1e2f31a753d030c7e0e9a25adcad69add500d493 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Thu, 19 Aug 2021 11:54:48 +0800 Subject: [PATCH 14/14] Cargo: add lockfile settings for xtask xtask now includes libcurl and unzip in order to be able to extract the toolchain. Signed-off-by: Sean Cross --- Cargo.lock | 162 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 162 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index 44be69827..e6960a123 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -231,6 +231,27 @@ version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae44d1a3d5a19df61dd0c8beb138458ac2a53a7ac09eba97d55592540004306b" +[[package]] +name = "bzip2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6afcd980b5f3a45017c57e57a2fcccbb351cc43a356ce117ef760ef8052b89b0" +dependencies = [ + "bzip2-sys", + "libc", +] + +[[package]] +name = "bzip2-sys" +version = "0.1.11+1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + [[package]] name = "cb-test-c1" version = "0.1.0" @@ -491,6 +512,36 @@ dependencies = [ "cipher", ] +[[package]] +name = "curl" +version = "0.4.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a872858e9cb9e3b96c80dd78774ad9e32e44d3b05dc31e142b858d14aebc82c" +dependencies = [ + "curl-sys", + "libc", + "openssl-probe", + "openssl-sys", + "schannel", + "socket2", + "winapi", +] + +[[package]] +name = "curl-sys" +version = "0.4.45+curl-7.78.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de9e5a72b1c744eb5dd20b2be4d7eb84625070bb5c4ab9b347b70464ab1e62eb" +dependencies = [ + "cc", + "libc", + "libz-sys", + "openssl-sys", + "pkg-config", + "vcpkg", + "winapi", +] + [[package]] name = "curve25519-dalek" version = "3.1.0" @@ -935,6 +986,18 @@ dependencies = [ "winapi", ] +[[package]] +name = "libz-sys" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66" +dependencies = [ + "cc", + "libc", + "pkg-config", + "vcpkg", +] + [[package]] name = "llio" version = "0.1.0" @@ -1115,6 +1178,25 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" +[[package]] +name = "openssl-probe" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a" + +[[package]] +name = "openssl-sys" +version = "0.9.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1996d2d305e561b70d1ee0c53f1542833f4e1ac6ce9a6708b6ff2738ca67dc82" +dependencies = [ + "autocfg", + "cc", + "libc", + "pkg-config", + "vcpkg", +] + [[package]] name = "orbclient" version = "0.3.30" @@ -1521,12 +1603,31 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c" +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver", +] + [[package]] name = "ryu" version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e" +[[package]] +name = "schannel" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75" +dependencies = [ + "lazy_static", + "winapi", +] + [[package]] name = "sdl2" version = "0.34.3" @@ -1555,6 +1656,12 @@ dependencies = [ "version-compare", ] +[[package]] +name = "semver" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" + [[package]] name = "serde" version = "1.0.123" @@ -1653,6 +1760,17 @@ version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e" +[[package]] +name = "socket2" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e" +dependencies = [ + "cfg-if 1.0.0", + "libc", + "winapi", +] + [[package]] name = "spin" version = "0.5.2" @@ -1837,6 +1955,26 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "thiserror" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93119e4feac1cbe6c798c34d3a53ea0026b0b1de6a120deef895137c0529bfe2" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "060d69a0afe7796bf42e9e2ff91f5ee691fb15c53d38b4b62a9a53eb23164745" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "thread_local" version = "1.1.2" @@ -1946,6 +2084,12 @@ dependencies = [ "svd2utra", ] +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + [[package]] name = "vec_map" version = "0.8.2" @@ -2293,7 +2437,11 @@ dependencies = [ name = "xtask" version = "0.1.0" dependencies = [ + "atty", + "curl", "filetime", + "rustc_version", + "zip", ] [[package]] @@ -2322,3 +2470,17 @@ dependencies = [ "syn", "synstructure", ] + +[[package]] +name = "zip" +version = "0.5.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93ab48844d61251bb3835145c521d88aa4031d7139e8485990f60ca911fa0815" +dependencies = [ + "byteorder", + "bzip2", + "crc32fast", + "flate2", + "thiserror", + "time", +]