feat(test-kernel): 测试关闭核

Author: YdrMaster

sbi-rt/src/binary.rs

@@ -5,6 +5,7 @@
 /// > SBI functions must return a pair of values in a0 and a1,
 /// > with a0 returning an error code.
 /// > This is analogous to returning the C structure `SbiRet`.
+#[derive(PartialEq, Eq)]
 #[repr(C)]
 pub struct SbiRet {
     /// Error number

test-kernel/src/main.rs

@@ -5,10 +5,7 @@
 #![no_std]
 #![no_main]
 
-use core::{
-    arch::asm,
-    sync::atomic::{AtomicUsize, Ordering},
-};
+use core::arch::asm;
 use riscv::register::{
     scause::Trap,
     sepc,
@@ -64,30 +61,10 @@ unsafe extern "C" fn _start(hartid: usize, device_tree_paddr: usize) -> ! {
     )
 }
 
-/// 副核入口。此前副核被 SBI 阻塞。
-///
-/// # Safety
-///
-/// 裸函数。
-#[naked]
-unsafe extern "C" fn secondary_hart_start(hartid: usize) -> ! {
-    asm!(
-        "csrw sie, zero",      // 关中断
-        "call {select_stack}", // 设置启动栈
-        "j    {main}",         // 进入 rust
-        select_stack = sym select_stack,
-        main = sym secondary_rust_main,
-        options(noreturn)
-    )
-}
-
 /// 为每个核记录一个预期的陷入原因，实现陷入代理测试。
 /// 总是可以安全地使用，因为这是（硬件）线程独立变量。
 static mut EXPECTED: [Option<Trap>; 8] = [None; 8];
 
-/// 每个核的启动函数里 +1
-static STARTED: AtomicUsize = AtomicUsize::new(0);
-
 extern "C" fn primary_rust_main(hartid: usize, dtb_pa: usize) -> ! {
     zero_bss();
 
@@ -112,41 +89,10 @@ extern "C" fn primary_rust_main(hartid: usize, dtb_pa: usize) -> ! {
     unsafe { stvec::write(start_trap as usize, TrapMode::Direct) };
     test::trap_delegate(hartid);
 
-    println!();
-    STARTED.fetch_add(1, Ordering::SeqCst);
-    let pc: usize;
-    unsafe { asm!("auipc {}, 0", out(reg) pc) };
-    println!("pc = {pc:#x}");
-    // 启动副核
-    for id in 0..smp {
-        if id != hartid {
-            println!("hart{id} is booting...");
-            let ret = sbi::hart_start(id, secondary_hart_start as usize, 0);
-            if ret.error != sbi::SBI_SUCCESS {
-                panic!("start hart{id} failed: {ret:?}");
-            }
-        } else {
-            println!("hart{id} is the primary hart.");
-        }
-    }
-    while STARTED.load(Ordering::SeqCst) < smp {
-        for id in 0..smp {
-            print!("{:?}", sbi::hart_get_status(id));
-        }
-        println!("({}/{smp})", STARTED.load(Ordering::SeqCst));
-        for _ in 0..0x8000_0000usize {
-            core::hint::spin_loop();
-        }
-    }
-    println!("All harts boot successfully!");
-    shutdown()
-}
+    test::start_stop_harts(hartid, smp);
 
-extern "C" fn secondary_rust_main(_hart_id: usize) -> ! {
-    STARTED.fetch_add(1, Ordering::SeqCst);
-    loop {
-        core::hint::spin_loop();
-    }
+    sbi::system_reset(sbi::RESET_TYPE_SHUTDOWN, sbi::RESET_REASON_NO_REASON);
+    unreachable!()
 }
 
 extern "C" fn rust_trap_exception(trap_frame: &mut TrapFrame) {
@@ -310,11 +256,3 @@ fn zero_bss() {
     }
     unsafe { r0::zero_bss(&mut sbss, &mut ebss) };
 }
-
-fn shutdown() -> ! {
-    use sbi::{system_reset, RESET_REASON_NO_REASON, RESET_TYPE_SHUTDOWN};
-    system_reset(RESET_TYPE_SHUTDOWN, RESET_REASON_NO_REASON);
-    loop {
-        core::hint::spin_loop();
-    }
-}

test-kernel/src/test.rs

@@ -1,4 +1,6 @@
-pub(crate) fn base_extension() {
+use core::sync::atomic::{AtomicUsize, Ordering};
+
+pub(crate) fn base_extension() {
     println!(
         "
 [test-kernel] Testing base extension"
@@ -77,3 +79,81 @@ pub(crate) fn trap_delegate(hartid: usize) {
 [test-kernel] Illegal exception delegate success"
     );
 }
+
+/// 操作一个静态的原子变量。
+/// 现在除启动核外，所有核都处于 STOPPED 状态，
+/// 主核在 [`sbi::hart_start`] 之前给原子变量 +1。
+/// 核启动后，会自动给原子变量 -1。
+/// 所有核成功启动则原子变量值归零。
+/// 所有核一起等待原子变量归零，然后副核调用 [`sbi::hart_stop`] 关闭。
+/// 主核等待所有副核关闭，然后退出。
+pub(crate) fn start_stop_harts(hartid: usize, smp: usize) {
+    static STARTED: AtomicUsize = AtomicUsize::new(0);
+
+    #[naked]
+    unsafe extern "C" fn test_start_entry(hartid: usize) -> ! {
+        core::arch:: asm!(
+            "csrw sie, zero",      // 关中断
+            "call {select_stack}", // 设置启动栈
+            "j    {main}",         // 进入 rust
+            select_stack = sym crate::select_stack,
+            main = sym secondary_rust_main,
+            options(noreturn)
+        )
+    }
+
+    extern "C" fn secondary_rust_main(_hart_id: usize) -> ! {
+        STARTED.fetch_sub(1, Ordering::AcqRel);
+        while STARTED.load(Ordering::Acquire) != 0 {
+            delay(0x8000_0000usize);
+        }
+        sbi::hart_stop();
+        unreachable!()
+    }
+
+    println!(
+        "
+[test-kernel] Testing start harts"
+    );
+
+    // 启动副核
+    for id in 0..smp {
+        if id != hartid {
+            println!("[test-kernel] Hart{id} is booting...");
+            STARTED.fetch_add(1, Ordering::AcqRel);
+            let ret = sbi::hart_start(id, test_start_entry as usize, 0);
+            if ret.error != sbi::SBI_SUCCESS {
+                panic!("[test-kernel] Start hart{id} failed: {ret:?}");
+            }
+        } else {
+            println!("[test-kernel] Hart{id} is the primary hart.");
+        }
+    }
+    // 等待副核启动完成
+    while STARTED.load(Ordering::Acquire) != 0 {
+        for id in 0..smp {
+            print!("{:?}", sbi::hart_get_status(id));
+        }
+        println!("({}/{smp})", STARTED.load(Ordering::SeqCst));
+        delay(0x8000_0000usize);
+    }
+    println!("[test-kernel] All harts boot successfully!");
+    // 等待副核关闭
+    for id in 0..smp {
+        const STOPPED: sbi::SbiRet = sbi::SbiRet { error: 0, value: 1 };
+        if id != hartid {
+            while sbi::hart_get_status(id) != STOPPED {
+                delay(0x8000_0000usize);
+            }
+            println!("[test-kernel] Hart{id} stopped.");
+        }
+    }
+    println!("[test-kernel] All harts stop successfully!");
+}
+
+#[inline(always)]
+fn delay(cycle: usize) {
+    for _ in 0..cycle {
+        core::hint::spin_loop();
+    }
+}