feat(test-kernel): 测试 hsm 所有功能

Author: YdrMaster

rustsbi-qemu/src/execute/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
     clint, hart_id,
-    qemu_hsm::{QemuHsm, SUSPEND_RETENTIVE},
+    qemu_hsm::{QemuHsm, SUSPEND_NON_RETENTIVE},
     Supervisor,
 };
 
@@ -64,7 +64,7 @@ pub(crate) fn execute_supervisor(hsm: &QemuHsm, supervisor: Supervisor) {
                 if ctx.a(7) == EID_HSM && ans.error == 0 {
                     match ctx.a(6) {
                         FID_HART_STOP => return,
-                        FID_HART_SUSPEND if ctx.a(0) == SUSPEND_RETENTIVE => return,
+                        FID_HART_SUSPEND if ctx.a(0) == SUSPEND_NON_RETENTIVE => return,
                         _ => {}
                     }
                 }

sbi-rt/Cargo.toml

@@ -1,10 +1,6 @@
 [package]
 name = "sbi-rt"
 version = "0.1.0"
-authors = ["luojia65 <me@luojia.cc>"]
+authors = ["YdrMaster <ydrml@hotmail.com>"]
 edition = "2021"
 publish = false
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]

test-kernel/src/test.rs

@@ -78,31 +78,46 @@ pub(crate) fn trap_delegate(hartid: usize) {
     );
 }
 
-/// 操作一个静态的原子变量。
-/// 现在除启动核外，所有核都处于 STOPPED 状态，
-/// 主核在 [`sbi::hart_start`] 之前给原子变量 +1。
-/// 核启动后，会自动给原子变量 -1。
-/// 所有核成功启动则原子变量值归零。
-/// 所有核一起等待原子变量归零，然后副核调用 [`sbi::hart_stop`] 关闭。
-/// 主核等待所有副核关闭，然后退出。
+/// 所有副核：启动 -> 不可恢复休眠 -> 唤醒 -> 可恢复休眠 -> 唤醒 -> 关闭。
 pub(crate) fn start_stop_harts(hartid: usize, smp: usize) {
+    const SUSPENDED: sbi::SbiRet = sbi::SbiRet {
+        error: sbi::RET_SUCCESS,
+        value: sbi::HART_STATE_SUSPENDED,
+    };
+    const STOPPED: sbi::SbiRet = sbi::SbiRet {
+        error: sbi::RET_SUCCESS,
+        value: sbi::HART_STATE_STOPPED,
+    };
+
     use spin::{Barrier, Once};
-    static BARRIER: Once<Barrier> = Once::new();
+    static STARTED: Once<Barrier> = Once::new();
+    static RESUMED: Once<Barrier> = Once::new();
 
     #[naked]
-    unsafe extern "C" fn test_start_entry(hartid: usize) -> ! {
+    unsafe extern "C" fn test_entry(hartid: usize, main: usize) -> ! {
         core::arch:: asm!(
             "csrw sie, zero",      // 关中断
             "call {select_stack}", // 设置启动栈
-            "j    {main}",         // 进入 rust
+            "jr   a1",             // 进入 rust
             select_stack = sym crate::select_stack,
-            main = sym secondary_rust_main,
             options(noreturn)
         )
     }
 
-    extern "C" fn secondary_rust_main(hart_id: usize) -> ! {
-        BARRIER.wait().wait();
+    extern "C" fn start_rust_main(hart_id: usize) -> ! {
+        STARTED.wait().wait();
+        let ret = sbi::hart_suspend(
+            sbi::HART_SUSPEND_TYPE_NON_RETENTIVE,
+            test_entry as _,
+            resume_rust_main as _,
+        );
+        unreachable!("suspend [{hart_id}] but {ret:?}");
+    }
+
+    extern "C" fn resume_rust_main(hart_id: usize) -> ! {
+        RESUMED.wait().wait();
+        let ret = sbi::hart_suspend(sbi::HART_SUSPEND_TYPE_RETENTIVE, 0, 0);
+        assert_eq!(sbi::RET_SUCCESS, ret.error);
         let ret = sbi::hart_stop();
         unreachable!("stop [{hart_id}] but {ret:?}");
     }
@@ -113,11 +128,12 @@ pub(crate) fn start_stop_harts(hartid: usize, smp: usize) {
     );
 
     // 启动副核
-    let barrier = BARRIER.call_once(|| Barrier::new(smp));
+    let started = STARTED.call_once(|| Barrier::new(smp));
+    let resumed = RESUMED.call_once(|| Barrier::new(smp));
     for id in 0..smp {
         if id != hartid {
             println!("[test-kernel] Hart{id} is booting...");
-            let ret = sbi::hart_start(id, test_start_entry as usize, 0);
+            let ret = sbi::hart_start(id, test_entry as _, start_rust_main as _);
             if ret.error != sbi::RET_SUCCESS {
                 panic!("[test-kernel] Start hart{id} failed: {ret:?}");
             }
@@ -126,19 +142,38 @@ pub(crate) fn start_stop_harts(hartid: usize, smp: usize) {
         }
     }
     // 等待副核启动完成
-    barrier.wait();
+    started.wait();
     print!("[test-kernel] All harts boot successfully!\n");
-    // 等待副核关闭
+    // 等待副核休眠（不可恢复）
+    for id in 0..smp {
+        if id != hartid {
+            while sbi::hart_get_status(id) != SUSPENDED {
+                core::hint::spin_loop();
+            }
+            println!("[test-kernel] Hart{id} suspended.");
+        } else {
+            println!("[test-kernel] Hart{id} is the primary hart.");
+        }
+    }
+    // 全部唤醒
+    sbi::send_ipi(0, -1isize as usize);
+    // 等待副核恢复完成
+    resumed.wait();
+    print!("[test-kernel] All harts resume successfully!\n");
     for id in 0..smp {
-        const STOPPED: sbi::SbiRet = sbi::SbiRet {
-            error: sbi::RET_SUCCESS,
-            value: sbi::HART_STATE_STOPPED,
-        };
         if id != hartid {
+            // 等待副核休眠
+            while sbi::hart_get_status(id) != SUSPENDED {
+                core::hint::spin_loop();
+            }
+            print!("[test-kernel] Hart{id} suspended, ");
+            // 单独唤醒
+            sbi::send_ipi(1usize << id, 0);
+            // 等待副核关闭
             while sbi::hart_get_status(id) != STOPPED {
                 core::hint::spin_loop();
             }
-            println!("[test-kernel] Hart{id} stopped.");
+            println!("then stopped.");
         } else {
             println!("[test-kernel] Hart{id} is the primary hart.");
         }