Merge pull request #6 from guttatus/test-kernel

feat: support booting test kernel with U-Boot SPL Test kernel

Cargo.lock

@@ -22,9 +22,15 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "critical-section"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7059fff8937831a9ae6f0fe4d658ffabf58f2ca96aa9dec1c889f936f705f216"
+checksum = "f64009896348fc5af4222e9cf7d7d82a95a256c634ebcf61c53e4ea461422242"
+
+[[package]]
+name = "dtb-walker"
+version = "0.2.0-alpha.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9404d41caa1aa659f7be44d5a902e318c0672900822fe9ca41d9e38c14b52332"
 
 [[package]]
 name = "embedded-hal"
@@ -50,9 +56,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "naked-function"
@@ -83,22 +89,32 @@ checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.82"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rcore-console"
+version = "0.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63aae49a6d2e6fd69821507a979b5871e4c47dc3abc9066347fa5c4a51a73dd6"
+dependencies = [
+ "log",
+ "spin",
+]
+
 [[package]]
 name = "riscv"
 version = "0.11.1"
@@ -111,9 +127,9 @@ dependencies = [
 
 [[package]]
 name = "riscv-decode"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec7a6dc0b0bb96a4d23271864a45c0d24dcd9dde2a1b630a35f79fa29c588bf"
+checksum = "cf8b4cfb0da0528321d22daee4299a23a8c5ac8848623d716e898d2a9eec0694"
 
 [[package]]
 name = "rustsbi"
@@ -164,6 +180,19 @@ dependencies = [
  "sbi-rt",
 ]
 
+[[package]]
+name = "rustsbi-test-kernel"
+version = "0.0.0"
+dependencies = [
+ "dtb-walker",
+ "log",
+ "rcore-console",
+ "riscv",
+ "sbi-testing",
+ "spin",
+ "uart16550",
+]
+
 [[package]]
 name = "sbi-rt"
 version = "0.0.3"
@@ -179,6 +208,18 @@ version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e36312fb5ddc10d08ecdc65187402baba4ac34585cb9d1b78522ae2358d890"
 
+[[package]]
+name = "sbi-testing"
+version = "0.0.3-alpha.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135c0f1ce07ede77a7e1c3daff35d20d37b54fd1037ac02ab9595c231518531e"
+dependencies = [
+ "log",
+ "riscv",
+ "sbi-rt",
+ "sbi-spec",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -187,9 +228,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "serde"
-version = "1.0.202"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
@@ -197,16 +238,16 @@ dependencies = [
 [[package]]
 name = "serde-device-tree"
 version = "0.0.1"
-source = "git+https://github.com/rustsbi/serde-device-tree#b8c2da9ee425cce49480731fa48e2ea39b457803"
+source = "git+https://github.com/rustsbi/serde-device-tree#0e6edab85de8c915f8831f8bedd0be2db7e6b7f9"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.202"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -230,9 +271,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.61"
+version = "2.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c993ed8ccba56ae856363b1845da7266a7cb78e1d146c8a32d54b45a8b831fc9"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -247,6 +288,6 @@ checksum = "939f6f9ccad815fe3efca8fd06f2ec1620c0387fb1bca2b231b61ce710bffb9b"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"

Cargo.toml

@@ -1,36 +1,10 @@
-cargo-features = ["per-package-target"]
-
-[package]
-name = "rustsbi-prototyper"
-version = "0.0.0"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-forced-target = "riscv64imac-unknown-none-elf"
-
-[dependencies]
-aclint = "0.0.0"
-log = "0.4.21"
-panic-halt = "0.2.0"
-riscv = "0.11.1"
-rustsbi = { version = "0.4.0-alpha.3", features = ["machine"] }
-sbi-spec = { version = "0.0.7", features = ["legacy"] }
-serde = { version = "1.0.202", default-features = false, features = ["derive"]}
-serde-device-tree = { git = "https://github.com/rustsbi/serde-device-tree", default-features = false }
-sifive-test-device = "0.0.0"
-spin = "0.9.8"
-uart16550 = "0.0.1"
-riscv-decode = "0.2.1"
-fast-trap = { version = "0.0.1", features = ["riscv-m"] }
-
-
-[[bin]]
-name = "rustsbi-prototyper"
-test = false
-bench = false
-
 [workspace]
-members = ["supervisor"]
+resolver = "2"
+members = [
+  "prototyper",
+  "test-kernel",
+  "supervisor"
+]
 
 [workspace.package]
 edition = "2021"

Makefile.toml

@@ -1,15 +1,39 @@
+[config]
+default_to_workspace = false
+
 [tasks.clean]
 command = "cargo"
 args = ["clean"]
 
-[tasks.build]
+[tasks.prototyper-build]
 command = "cargo"
-args = ["build", "--release"]
-dependencies = ["clean"]
+args = ["build", "-prustsbi-prototyper", "--release"]
 
-[tasks.bin]
+[tasks.prototyper]
 command = "rust-objcopy"
 args = ["--binary-architecture=riscv64", "target/riscv64imac-unknown-none-elf/release/rustsbi-prototyper",
         "--output-target=binary", "target/riscv64imac-unknown-none-elf/release/rustsbi-prototyper.bin"
 ]
-dependencies = ["build"]
+dependencies = ["prototyper-build"]
+
+[tasks.test-kernel-build]
+command = "cargo"
+args = ["build", "-prustsbi-test-kernel", "--release"]
+
+[tasks.test-kernel]
+command = "rust-objcopy"
+args = ["--binary-architecture=riscv64", "target/riscv64imac-unknown-none-elf/release/rustsbi-test-kernel",
+        "--output-target=binary", "target/riscv64imac-unknown-none-elf/release/rustsbi-test-kernel.bin"
+]
+dependencies = ["test-kernel-build"]
+
+[tasks.test-kernel-itb]
+script = '''
+cp test-kernel/scripts/rustsbi-test-kernel.its target/riscv64imac-unknown-none-elf/release
+cd target/riscv64imac-unknown-none-elf/release/
+mkimage -f rustsbi-test-kernel.its  rustsbi-test-kernel.itb
+rm rustsbi-test-kernel.its
+cd ../../../
+'''
+dependencies = ["prototyper", "test-kernel"]
+

docs/booting-linux-kernel-in-qemu-using-uboot-and-rustsbi.md

@@ -280,7 +280,7 @@ $ cd prototyper
 编译RustSBI  Prototyper
 
 ``` shell
-$ cargo make bin
+$ cargo make prototyper
 ```
 
 ## 编译U-Boot SPL

docs/booting-openEuler-23.09-in-qemu-using-uboot-and-rustsbi.md

@@ -50,7 +50,7 @@ $ cd prototyper
 编译RustSBI  Prototyper
 
 ``` shell
-$ cargo make bin
+$ cargo make prototyper
 ```
 
 ## 编译U-Boot SPL
@@ -104,4 +104,4 @@ $ qemu-system-riscv64 \
     -device virtio-net-device,netdev=usernet \
     -netdev user,id=usernet,hostfwd=tcp::12055-:22 \
     -device qemu-xhci -usb -device usb-kbd -device usb-tablet
-```
+```

docs/booting-test-kernel-in-qemu-using-uboot-spl-and-rustsbi.md

@@ -0,0 +1,152 @@
+# 使用RustSBI & U-Boot SPL在QEMU中启动Test Kernel
+
+本教程给出了使用RustSBI和U-Boot SPL在QEMU中启动Test Kernel的基本流程。
+
+请读者在其主机上安装必要的软件来尝试本教程的脚本。本教程是在Arch Linux上开发的。
+
+[环境配置](#环境配置)小节给出了本教程的环境配置方法，用户在使用本教程时需要先完成环境配置小节内容。
+
+
+本教程使用软件版本如下：
+
+|         软件          |  版本   |
+| :-------------------: | :-----: |
+| riscv64-linux-gnu-gcc | 14.1.0  |
+|  qemu-system-riscv64  |  9.0.1  |
+|  RustSBI Prototyper   |  0.0.0  |
+|        U-Boot         | 2024.04 |
+|     Linux Kernel      |   6.2   |
+|        busybox        | 1.36.0  |
+
+## 环境配置
+
+### 安装交叉编译器、QEMU和相关依赖
+
+For Arhc Linux:
+
+``` shell
+$ sudo pacman -S git riscv64-linux-gnu-gcc qemu-system-riscv uboot-tools
+```
+
+For Ubuntu:
+
+``` shell
+$ sudo apt-get update && sudo apt-get upgrade
+$ sudo apt-get install git qemu-system-misc gcc-riscv64-linux-gnu u-boot-tools
+```
+
+#### 测试是否成功安装
+
+For riscv64-linux-gnu-gcc:
+
+``` shell
+$ riscv64-linux-gnu-gcc --version
+```
+
+它将输出以下版本信息
+
+``` 
+riscv64-linux-gnu-gcc (GCC) 14.1.0
+Copyright (C) 2024 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions.  There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+```
+
+For QEMU:
+
+``` shell
+$ qemu-system-riscv64 --version
+```
+
+它将输出以下版本信息
+
+``` 
+QEMU emulator version 9.0.1
+Copyright (c) 2003-2024 Fabrice Bellard and the QEMU Project developers
+```
+
+### 准备RustSBI Prototyper, Test Kernel, U-Boot源码
+
+创建工作目录并进入该目录
+
+``` shell
+$ mkdir workshop && cd workshop
+```
+
+Clone RustSBI Prototyper
+
+``` shell
+$ git clone https://github.com/rustsbi/prototyper.git && cd prototyper && git checkout main && cd ..
+```
+
+Clone U-Boot
+
+``` shell
+$ git clone https://github.com/u-boot/u-boot.git && cd u-boot && git checkout v2024.04 && cd ..
+```
+
+## 编译RustSBI  Prototyper
+
+进入prototyper目录
+
+``` shell
+$ cd prototyper
+```
+
+编译RustSBI Prototyper和Test Kernel
+
+``` shell
+$ cargo make test-kernel-itb
+```
+
+本小节将使用二进制文件 `./target/riscv64imac-unknown-none-elf/release/rustsbi-test-kernel.itb`。
+
+## 编译U-Boot SPL
+
+进入U-Boot目录
+
+``` shell
+$ cd u-boot
+```
+
+导出环境变量
+
+``` shell
+$ export ARCH=riscv
+$ export CROSS_COMPILE=riscv64-linux-gnu-
+$ export OPENSBI=../prototyper/target/riscv64imac-unknown-none-elf/release/rustsbi-prototyper.bin 
+```
+
+生成`.config`文件
+
+``` shell
+# To generate .config file out of board configuration file
+$ make qemu-riscv64_spl_defconfig
+# add bootcmd value
+$ make menuconfig
+```
+
+编译U-Boot
+
+``` shell
+# To build U-Boot
+$ make -j$(nproc)
+```
+
+本小节将使用二进制文件 `./spl/u-boot-spl`。
+
+## 使用RustSBI 原型系统和U-Boot启动Linux Kernel
+
+进入`workshop`目录
+
+``` shell
+$ cd workshop
+```
+
+运行下面命令
+
+``` shell
+$ qemu-system-riscv64 -M virt -smp 1 -m 256M -nographic \
+          -bios ./u-boot/spl/u-boot-spl \
+          -device loader,file=./prototyper/target/riscv64imac-unknown-none-elf/release/rustsbi-test-kernel.itb,addr=0x80200000 
+```
+

prototyper/Cargo.toml

@@ -0,0 +1,31 @@
+cargo-features = ["per-package-target"]
+
+[package]
+name = "rustsbi-prototyper"
+version = "0.0.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+forced-target = "riscv64imac-unknown-none-elf"
+
+[dependencies]
+aclint = "0.0.0"
+log = "0.4.21"
+panic-halt = "0.2.0"
+riscv = "0.11.1"
+rustsbi = { version = "0.4.0-alpha.3", features = ["machine"] }
+sbi-spec = { version = "0.0.7", features = ["legacy"] }
+serde = { version = "1.0.202", default-features = false, features = ["derive"]}
+serde-device-tree = { git = "https://github.com/rustsbi/serde-device-tree", default-features = false }
+sifive-test-device = "0.0.0"
+spin = "0.9.8"
+uart16550 = "0.0.1"
+riscv-decode = "0.2.1"
+fast-trap = { version = "0.0.1", features = ["riscv-m"] }
+
+
+[[bin]]
+name = "rustsbi-prototyper"
+test = false
+bench = false
+

build.rs → prototyper/build.rs

@@ -6,6 +6,7 @@ fn main() {
 
     std::fs::write(ld, LINKER_SCRIPT).unwrap();
 
+    println!("cargo:rerun-if-env-changed=RUST_LOG");
     println!("cargo:rustc-link-arg=-T{}", ld.display());
     println!("cargo:rustc-link-search={}", out.display());
 }

prototyper/src/board.rs

@@ -0,0 +1,26 @@
+//! Board support, including peripheral and core drivers.
+use core::mem::MaybeUninit;
+use rustsbi::RustSBI;
+
+use crate::clint::ClintDevice;
+use crate::reset::TestDevice;
+use crate::console::ConsoleDevice;
+use crate::hsm::Hsm;
+use crate::rfence::RFence;
+
+pub(crate) static mut SBI: MaybeUninit<Board> = MaybeUninit::uninit();
+
+#[derive(RustSBI, Default)]
+#[rustsbi(dynamic)]
+pub struct Board<'a> {
+    #[rustsbi(console)]
+    pub uart16550: Option<ConsoleDevice<'a>>,
+    #[rustsbi(ipi, timer)]
+    pub clint: Option<ClintDevice<'a>>,
+    #[rustsbi(hsm)]
+    pub hsm: Option<Hsm>,
+    #[rustsbi(reset)]
+    pub sifive_test: Option<TestDevice<'a>>,
+    #[rustsbi(fence)]
+    pub rfence: Option<RFence>
+}

src/fail.rs → prototyper/src/fail.rs

@@ -14,7 +14,7 @@ pub fn device_tree_format(err: dt::ParseDeviceTreeError) -> Dtb {
 }
 
 #[cold]
-pub fn device_tree_deserialize<'a>(err: serde_device_tree::Error) -> Tree<'a> {
+pub fn device_tree_deserialize<'a>(err: serde_device_tree::error::Error) -> Tree<'a> {
     error!("Device tree deserialization error: {:?}", err);
     reset::fail()
 }

src/main.rs → prototyper/src/main.rs

@@ -7,31 +7,33 @@ extern crate log;
 #[macro_use]
 mod macros;
 
+mod board;
 mod clint;
 mod console;
-mod hsm;
-mod reset;
-mod rfence;
-mod board;
 mod dt;
 mod dynamic;
 mod fail;
+mod hart_context;
+mod hsm;
+mod reset;
+mod rfence;
 mod riscv_spec;
 mod trap;
 mod trap_stack;
-mod hart_context;
 
 use clint::ClintDevice;
 use core::sync::atomic::{AtomicBool, Ordering};
 use core::{arch::asm, mem::MaybeUninit};
+use reset::TestDevice;
 use riscv::register::mstatus;
 
 use crate::board::{Board, SBI};
 use crate::clint::SIFIVECLINT;
 use crate::console::{ConsoleDevice, CONSOLE};
 use crate::hsm::{local_remote_hsm, Hsm};
+use crate::reset::RESET;
 use crate::rfence::RFence;
-use crate::riscv_spec::{menvcfg,current_hartid};
+use crate::riscv_spec::{current_hartid, menvcfg};
 use crate::trap::trap_vec;
 use crate::trap_stack::NUM_HART_MAX;
 
@@ -58,6 +60,7 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
             serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize);
 
         // TODO: The device base address needs to be parsed from FDT
+        reset::init(0x100000);
         console::init(0x10000000);
         clint::init(0x2000000);
 
@@ -82,8 +85,8 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
                 uart16550: Some(ConsoleDevice::new(&CONSOLE)),
                 clint: Some(ClintDevice::new(&SIFIVECLINT, NUM_HART_MAX)),
                 hsm: Some(Hsm),
-                sifive_test: None,
-                rfence: Some(RFence)
+                sifive_test: Some(TestDevice::new(&RESET)),
+                rfence: Some(RFence),
             });
         }
 
@@ -106,7 +109,12 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
             opaque,
         });
 
-        info!("Redirecting hart {} to 0x{:0>16x} in {:?} mode.", current_hartid(), next_addr, mpp);
+        info!(
+            "Redirecting hart {} to 0x{:0>16x} in {:?} mode.",
+            current_hartid(),
+            next_addr,
+            mpp
+        );
     } else {
         // TODO: PMP configuration needs to be obtained through the memory range in the device tree
         use riscv::register::*;
@@ -185,7 +193,6 @@ unsafe extern "C" fn start() -> ! {
     )
 }
 
-
 #[derive(Debug)]
 pub struct NextStage {
     start_addr: usize,

prototyper/src/reset.rs

@@ -0,0 +1,67 @@
+use core::{
+    ptr::null_mut,
+    sync::atomic::{
+        AtomicPtr,
+        Ordering::{Relaxed, Release},
+    },
+};
+use rustsbi::SbiRet;
+use sifive_test_device::SifiveTestDevice;
+
+pub(crate) static RESET: AtomicPtr<SifiveTestDevice> = AtomicPtr::new(null_mut());
+
+pub fn init(base: usize) {
+    RESET.store(base as _, Release);
+}
+
+pub fn fail() -> ! {
+    let sifive_test = RESET.load(Relaxed);
+    if sifive_test.is_null() {
+        trace!("test fail, begin dead loop");
+        loop {
+            core::hint::spin_loop()
+        }
+    } else {
+        trace!("test fail, invoke process exit procedure on SiFive Test device");
+        unsafe { (*sifive_test).fail(0) }
+    }
+}
+
+
+pub struct TestDevice<'a> {
+    pub sifive_test: &'a AtomicPtr<SifiveTestDevice>,
+}
+
+impl<'a> TestDevice<'a> {
+    pub fn new(sifive_test: &'a AtomicPtr<SifiveTestDevice>) -> Self {
+        Self { sifive_test }
+    }
+}
+
+impl<'a> rustsbi::Reset for TestDevice<'a> {
+    #[inline]
+    fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet {
+        use rustsbi::spec::srst::{
+            RESET_REASON_NO_REASON, RESET_REASON_SYSTEM_FAILURE, RESET_TYPE_COLD_REBOOT,
+            RESET_TYPE_SHUTDOWN, RESET_TYPE_WARM_REBOOT,
+        };
+        match reset_type {
+            RESET_TYPE_SHUTDOWN => match reset_reason {
+                RESET_REASON_NO_REASON => unsafe {
+                    (*self.sifive_test.load(Relaxed)).pass();
+                },
+                RESET_REASON_SYSTEM_FAILURE => unsafe {
+                    (*self.sifive_test.load(Relaxed)).fail(u16::MAX);
+                },
+                value => unsafe {
+                    (*self.sifive_test.load(Relaxed)).fail(value as _);
+                },
+            },
+            RESET_TYPE_COLD_REBOOT | RESET_TYPE_WARM_REBOOT => unsafe {
+                (*self.sifive_test.load(Relaxed)).reset();
+            },
+
+            _ => SbiRet::invalid_param(),
+        }
+    }
+}

src/board.rs

@@ -1,50 +0,0 @@
-//! Board support, including peripheral and core drivers.
-use core::mem::MaybeUninit;
-use rustsbi::{RustSBI, SbiRet};
-
-use crate::clint::ClintDevice;
-use crate::console::ConsoleDevice;
-use crate::hsm::Hsm;
-use crate::rfence::RFence;
-
-pub(crate) static mut SBI: MaybeUninit<Board> = MaybeUninit::uninit();
-
-#[derive(RustSBI, Default)]
-#[rustsbi(dynamic)]
-pub struct Board<'a> {
-    #[rustsbi(console)]
-    pub uart16550: Option<ConsoleDevice<'a>>,
-    #[rustsbi(ipi, timer)]
-    pub clint: Option<ClintDevice<'a>>,
-    #[rustsbi(hsm)]
-    pub hsm: Option<Hsm>,
-    #[rustsbi(reset)]
-    pub sifive_test: Option<SifiveTestDevice<'a>>,
-    #[rustsbi(fence)]
-    pub rfence: Option<RFence>
-}
-
-pub struct SifiveTestDevice<'a> {
-    pub sifive_test: &'a sifive_test_device::SifiveTestDevice,
-}
-
-impl<'a> rustsbi::Reset for SifiveTestDevice<'a> {
-    #[inline]
-    fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet {
-        use rustsbi::spec::srst::{
-            RESET_REASON_NO_REASON, RESET_REASON_SYSTEM_FAILURE, RESET_TYPE_COLD_REBOOT,
-            RESET_TYPE_SHUTDOWN, RESET_TYPE_WARM_REBOOT,
-        };
-        match reset_type {
-            RESET_TYPE_SHUTDOWN => match reset_reason {
-                RESET_REASON_NO_REASON => self.sifive_test.pass(),
-                RESET_REASON_SYSTEM_FAILURE => self.sifive_test.fail(-1 as _),
-                value => self.sifive_test.fail(value as _),
-            },
-            RESET_TYPE_COLD_REBOOT | RESET_TYPE_WARM_REBOOT => {
-                self.sifive_test.reset();
-            }
-            _ => SbiRet::invalid_param(),
-        }
-    }
-}

src/reset.rs

@@ -1,29 +0,0 @@
-use sifive_test_device::SifiveTestDevice;
-use spin::Mutex;
-
-static RESET: Mutex<MachineReset> = Mutex::new(MachineReset::DeadLoop);
-
-pub fn fail() -> ! {
-    let lock = RESET.lock();
-    match *lock {
-        MachineReset::DeadLoop => {
-            trace!("test fail, begin dead loop");
-            loop {
-                core::hint::spin_loop()
-            }
-        }
-        MachineReset::SifiveTest(test) => {
-            trace!("test fail, invoke process exit procedure on SiFive Test device");
-            unsafe { &*test }.fail(0)
-        }
-    }
-}
-
-enum MachineReset {
-    DeadLoop,
-    #[allow(unused)] // TODO use on FDT parsing
-    SifiveTest(*const SifiveTestDevice),
-}
-
-unsafe impl Send for MachineReset {}
-unsafe impl Sync for MachineReset {}

test-kernel/Cargo.toml

@@ -0,0 +1,26 @@
+cargo-features = ["per-package-target"]
+
+[package]
+name = "rustsbi-test-kernel"
+version = "0.0.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+forced-target = "riscv64imac-unknown-none-elf"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+sbi-testing = { version = "0.0.3-alpha.2", features = ["log"] }
+log = "0.4"
+riscv = "0.11.1"
+spin = "0.9"
+uart16550 = "0.0.1"
+rcore-console = "0.0.0"
+dtb-walker = "=0.2.0-alpha.3"
+
+[[bin]]
+name = "rustsbi-test-kernel"
+test = false
+bench = false

test-kernel/build.rs

@@ -0,0 +1,46 @@
+use std::{env, path::PathBuf};
+
+fn main() {
+    let out = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    let ld = &out.join("rustsbi-test-kernel.ld");
+
+    std::fs::write(ld, LINKER_SCRIPT).unwrap();
+
+    println!("cargo:rustc-link-arg=-T{}", ld.display());
+    println!("cargo:rustc-link-search={}", out.display());
+}
+
+const LINKER_SCRIPT: &[u8] = b"OUTPUT_ARCH(riscv)
+ENTRY(_start) 
+SECTIONS {
+    . = 0x80200000;
+    .text : ALIGN(8) { 
+        *(.text.entry)
+        *(.text .text.*)
+    }
+    .rodata : ALIGN(8) { 
+        srodata = .;
+        *(.rodata .rodata.*)
+        *(.srodata .srodata.*)
+        . = ALIGN(8);  
+        erodata = .;
+    } 
+    .data : ALIGN(8) { 
+        sdata = .;
+        *(.data .data.*)
+        *(.sdata .sdata.*)
+        . = ALIGN(8); 
+        edata = .;
+    }
+    sidata = LOADADDR(.data);
+    .bss (NOLOAD) : ALIGN(8) {  
+        *(.bss.uninit)
+        sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+        ebss = .;
+    } 
+    /DISCARD/ : {
+        *(.eh_frame)
+    }
+}";

test-kernel/scripts/rustsbi-test-kernel.its

@@ -0,0 +1,44 @@
+/*
+ * Configuration to load RustSBI before RustSBI Test Kernel
+ */
+ 
+/dts-v1/;
+
+/ {
+			description = "Configuration to load RustSBI before RustSBI Test Kernel";
+
+			images {
+				kernel {
+					description = "rustsbi-test-kernel";
+					data = /incbin/("./rustsbi-test-kernel.bin");
+					type = "standalone";
+					os = "u-boot";
+					arch = "riscv";
+					compression = "none";
+					load = /bits/ 64 <0x80200000>;
+				};
+
+				rustsbi {
+					description = "RustSBI Firmware";
+					data = /incbin/("./rustsbi-prototyper.bin");
+					type = "firmware";
+					os = "opensbi";
+					arch = "riscv";
+					compression = "none";
+					load = /bits/ 64 <0x80100000>;
+					entry = /bits/ 64 <0x80100000>;
+				};
+
+			};
+
+		configurations {
+				default = "conf-1";
+
+				conf-1 {
+					description = "RustSBI & RustSBI Test Kernel";
+					firmware = "rustsbi";
+					loadables = "kernel";
+				};
+		};
+};
+

test-kernel/src/main.rs

@@ -0,0 +1,176 @@
+#![no_std]
+#![no_main]
+#![feature(naked_functions,asm_const)]
+#![deny(warnings)]
+
+#[macro_use]
+extern crate rcore_console;
+
+use core::{arch::asm, ptr::null};
+use sbi_testing::sbi;
+use uart16550::Uart16550;
+
+/// 内核入口。
+///
+/// # Safety
+///
+/// 裸函数。
+#[naked]
+#[no_mangle]
+#[link_section = ".text.entry"]
+unsafe extern "C" fn _start(hartid: usize, device_tree_paddr: usize) -> ! {
+    const STACK_SIZE: usize = 16384; // 16 KiB
+
+    #[link_section = ".bss.uninit"]
+    static mut STACK: [u8; STACK_SIZE] = [0u8; STACK_SIZE];
+
+    asm!(
+        // clear bss segment
+        "   la      t0, sbss
+            la      t1, ebss
+        1:  bgeu    t0, t1, 2f
+            sd      zero, 0(t0)
+            addi    t0, t0, 8
+            j       1b",
+        "2:",
+        "   la sp, {stack} + {stack_size}",
+        "   j  {main}",
+        stack_size = const STACK_SIZE,
+        stack      =   sym STACK,
+        main       =   sym rust_main,
+        options(noreturn),
+    )
+}
+
+extern "C" fn rust_main(hartid: usize, dtb_pa: usize) -> ! {
+    let BoardInfo {
+        smp,
+        frequency,
+        uart,
+    } = BoardInfo::parse(dtb_pa);
+    unsafe { UART = Uart16550Map(uart as _) };
+    rcore_console::init_console(&Console);
+    rcore_console::set_log_level(option_env!("LOG"));
+    println!(
+        r"
+ _____         _     _  __                    _
+|_   _|__  ___| |_  | |/ /___ _ __ _ __   ___| |
+  | |/ _ \/ __| __| | ' // _ \ '__| '_ \ / _ \ |
+  | |  __/\__ \ |_  | . \  __/ |  | | | |  __/ |
+  |_|\___||___/\__| |_|\_\___|_|  |_| |_|\___|_|
+================================================
+| boot hart id          | {hartid:20} |
+| smp                   | {smp:20} |
+| timebase frequency    | {frequency:17} Hz |
+| dtb physical address  | {dtb_pa:#20x} |
+------------------------------------------------"
+    );
+    let testing = sbi_testing::Testing {
+        hartid,
+        hart_mask: (1 << smp) - 1,
+        hart_mask_base: 0,
+        delay: frequency,
+    };
+    if testing.test() {
+        sbi::system_reset(sbi::Shutdown, sbi::NoReason);
+    } else {
+        sbi::system_reset(sbi::Shutdown, sbi::SystemFailure);
+    }
+    unreachable!()
+}
+
+#[cfg_attr(not(test), panic_handler)]
+fn panic(info: &core::panic::PanicInfo) -> ! {
+    let (hart_id, pc): (usize, usize);
+    unsafe { asm!("mv    {}, tp", out(reg) hart_id) };
+    unsafe { asm!("auipc {},  0", out(reg) pc) };
+    println!("[test-kernel-panic] hart {hart_id} {info}");
+    println!("[test-kernel-panic] pc = {pc:#x}");
+    println!("[test-kernel-panic] SBI test FAILED due to panic");
+    sbi::system_reset(sbi::Shutdown, sbi::SystemFailure);
+    loop {}
+}
+
+struct BoardInfo {
+    smp: usize,
+    frequency: u64,
+    uart: usize,
+}
+
+impl BoardInfo {
+    fn parse(dtb_pa: usize) -> Self {
+        use dtb_walker::{Dtb, DtbObj, HeaderError as E, Property, Str, WalkOperation::*};
+
+        let mut ans = Self {
+            smp: 0,
+            frequency: 0,
+            uart: 0,
+        };
+        unsafe {
+            Dtb::from_raw_parts_filtered(dtb_pa as _, |e| {
+                matches!(e, E::Misaligned(4) | E::LastCompVersion(_))
+            })
+        }
+        .unwrap()
+        .walk(|ctx, obj| match obj {
+            DtbObj::SubNode { name } => {
+                if ctx.is_root() && (name == Str::from("cpus") || name == Str::from("soc")) {
+                    StepInto
+                } else if ctx.name() == Str::from("cpus") && name.starts_with("cpu@") {
+                    ans.smp += 1;
+                    StepOver
+                } else if ctx.name() == Str::from("soc")
+                    && (name.starts_with("uart") || name.starts_with("serial"))
+                {
+                    StepInto
+                } else {
+                    StepOver
+                }
+            }
+            DtbObj::Property(Property::Reg(mut reg)) => {
+                if ctx.name().starts_with("uart") || ctx.name().starts_with("serial") {
+                    ans.uart = reg.next().unwrap().start;
+                }
+                StepOut
+            }
+            DtbObj::Property(Property::General { name, value }) => {
+                if ctx.name() == Str::from("cpus") && name == Str::from("timebase-frequency") {
+                    ans.frequency = match *value {
+                        [a, b, c, d] => u32::from_be_bytes([a, b, c, d]) as _,
+                        [a, b, c, d, e, f, g, h] => u64::from_be_bytes([a, b, c, d, e, f, g, h]),
+                        _ => unreachable!(),
+                    };
+                }
+                StepOver
+            }
+            DtbObj::Property(_) => StepOver,
+        });
+        ans
+    }
+}
+
+struct Console;
+static mut UART: Uart16550Map = Uart16550Map(null());
+
+pub struct Uart16550Map(*const Uart16550<u8>);
+
+unsafe impl Sync for Uart16550Map {}
+
+impl Uart16550Map {
+    #[inline]
+    pub fn get(&self) -> &Uart16550<u8> {
+        unsafe { &*self.0 }
+    }
+}
+
+impl rcore_console::Console for Console {
+    #[inline]
+    fn put_char(&self, c: u8) {
+        unsafe { UART.get().write(core::slice::from_ref(&c)) };
+    }
+
+    #[inline]
+    fn put_str(&self, s: &str) {
+        unsafe { UART.get().write(s.as_bytes()) };
+    }
+}