refactor(prototyper): refactor the `Board` structure to reduce the number of global variables

prototyper/src/board.rs

@@ -1,55 +1,287 @@
 use aclint::SifiveClint;
 use core::{
+    cell::RefCell,
+    fmt::{Display, Formatter, Result},
     ops::Range,
-    ptr::null_mut,
-    sync::atomic::{AtomicPtr, Ordering::Release},
+    sync::atomic::{AtomicBool, AtomicPtr, Ordering},
 };
+use serde_device_tree::Dtb;
 use sifive_test_device::SifiveTestDevice;
 use spin::Mutex;
 use uart16550::Uart16550;
 use uart_xilinx::uart_lite::uart::MmioUartAxiLite;
 
-use crate::sbi::console::ConsoleDevice;
-use crate::sbi::ipi::IpiDevice;
-use crate::sbi::reset::ResetDevice;
+use crate::fail;
+use crate::sbi::console::{ConsoleDevice, SbiConsole};
+use crate::sbi::extensions;
+use crate::sbi::hsm::SbiHsm;
+use crate::sbi::ipi::{IpiDevice, SbiIpi};
+use crate::sbi::logger;
+use crate::sbi::reset::{ResetDevice, SbiReset};
+use crate::sbi::trap_stack;
+use crate::sbi::trap_stack::NUM_HART_MAX;
 use crate::sbi::Sbi;
+use crate::{dt, sbi::rfence::SbiRFence};
 
 pub(crate) const UART16650_COMPATIBLE: &str = "ns16550a";
 pub(crate) const UARTAXILITE_COMPATIBLE: &str = "xlnx,xps-uartlite-1.00.a";
 pub(crate) const SIFIVETEST_COMPATIBLE: &str = "sifive,test0";
 pub(crate) const SIFIVECLINT_COMPATIBLE: &str = "riscv,clint0";
 
-pub struct Device {
+type BaseAddress = usize;
+/// Store finite-length string on the stack.
+pub(crate) struct StringInline<const N: usize>(usize, [u8; N]);
+
+impl<const N: usize> Display for StringInline<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "{}", unsafe {
+            core::str::from_utf8_unchecked(&self.1[..self.0])
+        })
+    }
+}
+
+pub struct BoardInfo {
     pub memory_range: Option<Range<usize>>,
-    pub uart: Option<Mutex<MachineConsole>>,
-    pub sifive_test: AtomicPtr<SifiveTestDevice>,
-    pub sifive_clint: AtomicPtr<SifiveClint>,
+    pub console: Option<(BaseAddress, MachineConsoleType)>,
+    pub reset: Option<BaseAddress>,
+    pub ipi: Option<BaseAddress>,
+    pub cpu_num: Option<usize>,
+    pub model: StringInline<128>,
+}
+
+impl BoardInfo {
+    pub const fn new() -> Self {
+        BoardInfo {
+            memory_range: None,
+            console: None,
+            reset: None,
+            ipi: None,
+            cpu_num: None,
+            model: StringInline(0, [0u8; 128]),
+        }
+    }
 }
 
-pub struct Board<'a> {
-    pub sbi: Sbi<'a, MachineConsole, SifiveClint, SifiveTestDevice>,
-    pub device: Device,
+pub struct Board {
+    pub info: BoardInfo,
+    pub sbi: Sbi<MachineConsole, SifiveClint, SifiveTestDevice>,
+    pub ready: AtomicBool,
 }
 
-pub(crate) static mut BOARD: Board<'static> = Board {
-    device: Device {
-        memory_range: None,
-        uart: None,
-        sifive_test: AtomicPtr::new(null_mut()),
-        sifive_clint: AtomicPtr::new(null_mut()),
-    },
-    sbi: Sbi {
-        console: None,
-        ipi: None,
-        reset: None,
-        hsm: None,
-        rfence: None,
-    },
-};
+#[allow(unused)]
+impl Board {
+    pub const fn new() -> Self {
+        Board {
+            info: BoardInfo::new(),
+            sbi: Sbi::new(),
+            ready: AtomicBool::new(false),
+        }
+    }
+
+    pub fn init(&mut self, dtb: &RefCell<Dtb>) {
+        self.info_init(dtb);
+        self.sbi_init();
+        logger::Logger::init().unwrap();
+        trap_stack::prepare_for_trap();
+        self.ready.swap(true, Ordering::Release);
+    }
+
+    pub fn have_console(&self) -> bool {
+        match self.sbi.console {
+            None => false,
+            Some(_) => true,
+        }
+    }
+
+    pub fn have_reset(&self) -> bool {
+        match self.sbi.reset {
+            None => false,
+            Some(_) => true,
+        }
+    }
+
+    pub fn have_ipi(&self) -> bool {
+        match self.sbi.ipi {
+            None => false,
+            Some(_) => true,
+        }
+    }
+
+    pub fn have_hsm(&self) -> bool {
+        match self.sbi.hsm {
+            None => false,
+            Some(_) => true,
+        }
+    }
+
+    pub fn have_rfence(&self) -> bool {
+        match self.sbi.rfence {
+            None => false,
+            Some(_) => true,
+        }
+    }
+
+    pub fn ready(&self) -> bool {
+        self.ready.load(Ordering::Acquire)
+    }
+
+    pub fn print_board_info(&self) {
+        info!("RustSBI version {}", rustsbi::VERSION);
+        rustsbi::LOGO.lines().for_each(|line| info!("{}", line));
+        info!("Initializing RustSBI machine-mode environment.");
+        info!("Number of CPU: {:?}", self.info.cpu_num);
+        info!("Model: {}", self.info.model);
+        info!("Clint device: {:x?}", self.info.ipi);
+        info!("Console device: {:x?}", self.info.console);
+    }
+
+    fn info_init(&mut self, dtb: &RefCell<Dtb>) {
+        // TODO: should remove `fail:device_tree_deserialize`.
+        let root: serde_device_tree::buildin::Node = serde_device_tree::from_raw_mut(&dtb)
+            .unwrap_or_else(fail::device_tree_deserialize_root);
+        let tree =
+            serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize);
+
+        //  Get console device info
+        for console_path in tree.chosen.stdout_path.iter() {
+            if let Some(node) = root.find(console_path) {
+                let info = dt::get_compatible_and_range(&node);
+                let result = info.is_some_and(|info| {
+                    let (compatible, regs) = info;
+                    for device_id in compatible.iter() {
+                        if device_id == UART16650_COMPATIBLE {
+                            self.info.console = Some((regs.start, MachineConsoleType::Uart16550));
+                            return true;
+                        }
+                        if device_id == UARTAXILITE_COMPATIBLE {
+                            self.info.console = Some((regs.start, MachineConsoleType::UartAxiLite));
+                            return true;
+                        }
+                    }
+                    false
+                });
+                if result {
+                    break;
+                }
+            }
+        }
+
+        // Get ipi and reset device info
+        let mut find_device = |node: &serde_device_tree::buildin::Node| {
+            let info = dt::get_compatible_and_range(node);
+            if let Some(info) = info {
+                let (compatible, regs) = info;
+                let base_address = regs.start;
+                for device_id in compatible.iter() {
+                    // Initialize clint device.
+                    if device_id == SIFIVECLINT_COMPATIBLE {
+                        self.info.ipi = Some(base_address);
+                    }
+                    // Initialize reset device.
+                    if device_id == SIFIVETEST_COMPATIBLE {
+                        self.info.reset = Some(base_address);
+                    }
+                }
+            }
+        };
+        root.search(&mut find_device);
+
+        // Get memory info
+        // TODO: More than one memory node or range?
+        let memory_reg = tree
+            .memory
+            .iter()
+            .next()
+            .unwrap()
+            .deserialize::<dt::Memory>()
+            .reg;
+        let memory_range = memory_reg.iter().next().unwrap().0;
+        self.info.memory_range = Some(memory_range);
+
+        // Get cpu number info
+        self.info.cpu_num = Some(tree.cpus.cpu.len());
+
+        // Get model info
+        if let Some(model) = tree.model {
+            let model = model.iter().next().unwrap_or("<unspecified>");
+            self.info.model.0 = model.as_bytes().len();
+            self.info.model.1[..self.info.model.0].copy_from_slice(model.as_bytes());
+        } else {
+            let model = "<unspecified>";
+            self.info.model.0 = model.as_bytes().len();
+            self.info.model.1[..self.info.model.0].copy_from_slice(model.as_bytes());
+        }
+
+        // TODO: Need a better extension initialization method
+        extensions::init(&tree.cpus.cpu);
+    }
+
+    fn sbi_init(&mut self) {
+        self.sbi_console_init();
+        self.sbi_ipi_init();
+        self.sbi_hsm_init();
+        self.sbi_reset_init();
+        self.sbi_rfence_init();
+    }
+
+    fn sbi_console_init(&mut self) {
+        if let Some((base, console_type)) = self.info.console {
+            let new_console = match console_type {
+                MachineConsoleType::Uart16550 => MachineConsole::Uart16550(base as _),
+                MachineConsoleType::UartAxiLite => {
+                    MachineConsole::UartAxiLite(MmioUartAxiLite::new(base))
+                }
+            };
+            self.sbi.console = Some(SbiConsole::new(Mutex::new(new_console)));
+        } else {
+            self.sbi.console = None;
+        }
+    }
+
+    fn sbi_reset_init(&mut self) {
+        if let Some(base) = self.info.reset {
+            self.sbi.reset = Some(SbiReset::new(AtomicPtr::new(base as _)));
+        } else {
+            self.sbi.reset = None;
+        }
+    }
+
+    fn sbi_ipi_init(&mut self) {
+        if let Some(base) = self.info.ipi {
+            self.sbi.ipi = Some(SbiIpi::new(
+                AtomicPtr::new(base as _),
+                self.info.cpu_num.unwrap_or(NUM_HART_MAX),
+            ));
+        } else {
+            self.sbi.ipi = None;
+        }
+    }
+
+    fn sbi_hsm_init(&mut self) {
+        // TODO: Can HSM work properly when there is no ipi device?
+        if let Some(_) = self.info.ipi {
+            self.sbi.hsm = Some(SbiHsm);
+        } else {
+            self.sbi.hsm = None;
+        }
+    }
+
+    fn sbi_rfence_init(&mut self) {
+        // TODO: Can rfence work properly when there is no ipi device?
+        if let Some(_) = self.info.ipi {
+            self.sbi.rfence = Some(SbiRFence);
+        } else {
+            self.sbi.rfence = None;
+        }
+    }
+}
+
+pub(crate) static mut BOARD: Board = Board::new();
 
 /// Console Device: Uart16550
 #[doc(hidden)]
 #[allow(unused)]
+#[derive(Clone, Copy, Debug)]
 pub enum MachineConsoleType {
     Uart16550,
     UartAxiLite,
@@ -80,15 +312,6 @@ impl ConsoleDevice for MachineConsole {
     }
 }
 
-#[doc(hidden)]
-pub(crate) fn console_dev_init(console_type: MachineConsoleType, base: usize) {
-    let new_console = match console_type {
-        MachineConsoleType::Uart16550 => MachineConsole::Uart16550(base as _),
-        MachineConsoleType::UartAxiLite => MachineConsole::UartAxiLite(MmioUartAxiLite::new(base)),
-    };
-    unsafe { BOARD.device.uart = Some(Mutex::new(new_console)) };
-}
-
 /// Ipi Device: Sifive Clint
 impl IpiDevice for SifiveClint {
     #[inline(always)]
@@ -127,13 +350,6 @@ impl IpiDevice for SifiveClint {
     }
 }
 
-#[doc(hidden)]
-pub(crate) fn ipi_dev_init(base: usize) {
-    unsafe {
-        BOARD.device.sifive_clint.store(base as _, Release);
-    }
-}
-
 /// Reset Device: SifiveTestDevice
 impl ResetDevice for SifiveTestDevice {
     #[inline]
@@ -151,10 +367,3 @@ impl ResetDevice for SifiveTestDevice {
         self.reset()
     }
 }
-
-#[doc(hidden)]
-pub fn reset_dev_init(base: usize) {
-    unsafe {
-        BOARD.device.sifive_test.store(base as _, Release);
-    }
-}

prototyper/src/fail.rs

@@ -1,6 +1,6 @@
 use serde_device_tree::Dtb;
 
-use crate::dt::{self, ParseDeviceTreeError, Tree};
+use crate::dt::{self, Tree};
 use crate::sbi::reset;
 
 #[cfg(not(feature = "payload"))]
@@ -8,20 +8,31 @@ use crate::platform::dynamic;
 #[cfg(not(feature = "payload"))]
 use riscv::register::mstatus;
 
+// TODO: Need a better way to handle device tree parsing errors
+
 /// Handles device tree format parsing errors by logging and resetting.
 #[cold]
-pub fn device_tree_format(err: dt::ParseDeviceTreeError) -> Dtb {
-    match err {
-        ParseDeviceTreeError::Format => error!("- FDT format error"),
+pub fn device_tree_format(_err: dt::ParseDeviceTreeError) -> Dtb {
+    loop {
+        core::hint::spin_loop()
     }
-    reset::fail()
 }
 
 /// Handles device tree deserialization errors by logging and resetting.
 #[cold]
-pub fn device_tree_deserialize<'a>(err: serde_device_tree::error::Error) -> Tree<'a> {
-    error!("Device tree deserialization error: {:?}", err);
-    reset::fail()
+pub fn device_tree_deserialize<'a>(_err: serde_device_tree::error::Error) -> Tree<'a> {
+    loop {
+        core::hint::spin_loop()
+    }
+}
+
+#[cold]
+pub fn device_tree_deserialize_root<'a>(
+    _err: serde_device_tree::error::Error,
+) -> serde_device_tree::buildin::Node<'a> {
+    loop {
+        core::hint::spin_loop()
+    }
 }
 
 /// Handles invalid dynamic information data by logging details and resetting.

prototyper/src/macros.rs

@@ -4,9 +4,11 @@
 macro_rules! print {
     ($($arg:tt)*) => {
         use core::fmt::Write;
-        let console = unsafe { $crate::board::BOARD.sbi.console.as_mut().unwrap() };
-        console.write_fmt(core::format_args!($($arg)*)).unwrap();
-        drop(console);
+        if unsafe {$crate::board::BOARD.have_console()} {
+            let console = unsafe { $crate::board::BOARD.sbi.console.as_mut().unwrap() };
+            console.write_fmt(core::format_args!($($arg)*)).unwrap();
+            drop(console);
+        }
     }
 }
 
@@ -15,8 +17,10 @@ macro_rules! println {
     () => ($crate::print!("\n"));
     ($($arg:tt)*) => {{
         use core::fmt::Write;
-        let console = unsafe { $crate::board::BOARD.sbi.console.as_mut().unwrap() };
-        console.write_fmt(core::format_args!($($arg)*)).unwrap();
-        console.write_char('\n').unwrap();
+        if unsafe {$crate::board::BOARD.have_console()} {
+            let console = unsafe { $crate::board::BOARD.sbi.console.as_mut().unwrap() };
+            console.write_fmt(core::format_args!($($arg)*)).unwrap();
+            console.write_char('\n').unwrap();
+        }
     }}
 }

prototyper/src/main.rs

@@ -16,23 +16,15 @@ mod riscv_spec;
 mod sbi;
 
 use core::arch::asm;
-use core::sync::atomic::{AtomicBool, Ordering};
 
-use sbi::extensions;
-
-use crate::board::{MachineConsoleType, BOARD};
+use crate::board::BOARD;
 use crate::riscv_spec::{current_hartid, menvcfg};
-use crate::sbi::console::SbiConsole;
 use crate::sbi::extensions::{hart_extension_probe, Extension};
 use crate::sbi::hart_context::NextStage;
-use crate::sbi::hsm::{local_remote_hsm, SbiHsm};
-use crate::sbi::ipi::{self, SbiIpi};
-use crate::sbi::logger;
-use crate::sbi::reset::SbiReset;
-use crate::sbi::rfence::SbiRFence;
+use crate::sbi::hsm::local_remote_hsm;
+use crate::sbi::ipi;
 use crate::sbi::trap::{self, trap_vec};
 use crate::sbi::trap_stack;
-use crate::sbi::Sbi;
 
 pub const START_ADDRESS: usize = 0x80000000;
 pub const R_RISCV_RELATIVE: usize = 3;
@@ -40,121 +32,20 @@ pub const R_RISCV_RELATIVE: usize = 3;
 #[no_mangle]
 extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
     // Track whether SBI is initialized and ready.
-    static SBI_READY: AtomicBool = AtomicBool::new(false);
 
     let boot_hart_info = platform::get_boot_hart(opaque, nonstandard_a2);
     // boot hart task entry.
     if boot_hart_info.is_boot_hart {
-        // 1. Init FDT
         // parse the device tree
-        // TODO: shoule remove `fail:device_tree_format`
         let fdt_addr = boot_hart_info.fdt_address;
         let dtb = dt::parse_device_tree(fdt_addr).unwrap_or_else(fail::device_tree_format);
         let dtb = dtb.share();
 
-        // TODO: should remove `fail:device_tree_deserialize`.
-        let root: serde_device_tree::buildin::Node = serde_device_tree::from_raw_mut(&dtb).unwrap();
-        let tree =
-            serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize);
-        // 2. Init device
-        // TODO: The device base address should be find in a better way.
-        for console_path in tree.chosen.stdout_path.iter() {
-            if let Some(node) = root.find(console_path) {
-                let info = dt::get_compatible_and_range(&node);
-                let result = info.is_some_and(|info| {
-                    let (compatible, regs) = info;
-                    for device_id in compatible.iter() {
-                        if device_id == board::UART16650_COMPATIBLE {
-                            board::console_dev_init(MachineConsoleType::Uart16550, regs.start);
-                            return true;
-                        }
-                        if device_id == board::UARTAXILITE_COMPATIBLE {
-                            board::console_dev_init(MachineConsoleType::UartAxiLite, regs.start);
-                            return true;
-                        }
-                    }
-                    false
-                });
-                if result {
-                    break;
-                }
-            }
-        }
-
-        let mut clint_device_address: Option<usize> = None;
-        let mut find_device = |node: &serde_device_tree::buildin::Node| {
-            let info = dt::get_compatible_and_range(node);
-            if let Some(info) = info {
-                let (compatible, regs) = info;
-                let base_address = regs.start;
-                for device_id in compatible.iter() {
-                    // Initialize clint device.
-                    if device_id == board::SIFIVECLINT_COMPATIBLE {
-                        clint_device_address = Some(base_address);
-                        board::ipi_dev_init(base_address);
-                    }
-                    // Initialize reset device.
-                    if device_id == board::SIFIVETEST_COMPATIBLE {
-                        board::reset_dev_init(base_address);
-                    }
-                }
-            }
-        };
-        root.search(&mut find_device);
-        let cpu_num = tree.cpus.cpu.len();
-
-        // Initialize console and IPI devices.
-
-        // 3. Init the SBI implementation
-        // TODO: More than one memory node or range?
-        let memory_reg = tree
-            .memory
-            .iter()
-            .next()
-            .unwrap()
-            .deserialize::<dt::Memory>()
-            .reg;
-        let memory_range = memory_reg.iter().next().unwrap().0;
-
-        // 3. Init SBI
         unsafe {
-            BOARD.device.memory_range = Some(memory_range);
-            BOARD.sbi = Sbi {
-                console: Some(SbiConsole::new(BOARD.device.uart.as_ref().unwrap())),
-                ipi: Some(SbiIpi::new(&BOARD.device.sifive_clint, cpu_num)),
-                hsm: Some(SbiHsm),
-                reset: Some(SbiReset::new(&BOARD.device.sifive_test)),
-                rfence: Some(SbiRFence),
-            };
+            BOARD.init(&dtb);
+            BOARD.print_board_info();
         }
-
-        // Setup trap handling.
-        trap_stack::prepare_for_trap();
-        extensions::init(&tree.cpus.cpu);
-        SBI_READY.swap(true, Ordering::AcqRel);
-
-        // 4. Init Logger
-        logger::Logger::init().unwrap();
-
-        info!("RustSBI version {}", rustsbi::VERSION);
-        rustsbi::LOGO.lines().for_each(|line| info!("{}", line));
-        info!("Initializing RustSBI machine-mode environment.");
-
-        info!("Number of CPU: {}", cpu_num);
-        if let Some(model) = tree.model {
-            info!("Model: {}", model.iter().next().unwrap_or("<unspecified>"));
-        }
-        info!("Clint device: {:x?}", clint_device_address);
-        info!(
-            "Chosen stdout item: {}",
-            tree.chosen
-                .stdout_path
-                .iter()
-                .next()
-                .unwrap_or("<unspecified>")
-        );
-
-        platform::set_pmp(unsafe { BOARD.device.memory_range.as_ref().unwrap() });
+        platform::set_pmp(unsafe { BOARD.info.memory_range.as_ref().unwrap() });
 
         // Get boot information and prepare for kernel entry.
         let boot_info = platform::get_boot_info(nonstandard_a2);
@@ -178,11 +69,11 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
         trap_stack::prepare_for_trap();
 
         // Wait for boot hart to complete SBI initialization.
-        while !SBI_READY.load(Ordering::Relaxed) {
+        while !unsafe { BOARD.ready() } {
             core::hint::spin_loop()
         }
 
-        platform::set_pmp(unsafe { BOARD.device.memory_range.as_ref().unwrap() });
+        platform::set_pmp(unsafe { BOARD.info.memory_range.as_ref().unwrap() });
     }
 
     // Clear all pending IPIs.

prototyper/src/sbi/console.rs

@@ -22,17 +22,17 @@ pub trait ConsoleDevice {
 ///
 /// This provides a safe interface for interacting with console hardware through the
 /// SBI specification.
-pub struct SbiConsole<'a, T: ConsoleDevice> {
-    inner: &'a Mutex<T>,
+pub struct SbiConsole<T: ConsoleDevice> {
+    inner: Mutex<T>,
 }
 
-impl<'a, T: ConsoleDevice> SbiConsole<'a, T> {
+impl<T: ConsoleDevice> SbiConsole<T> {
     /// Creates a new SBI console that wraps the provided locked console device.
     ///
     /// # Arguments
     /// * `inner` - A mutex containing the console device implementation
     #[inline]
-    pub fn new(inner: &'a Mutex<T>) -> Self {
+    pub fn new(inner: Mutex<T>) -> Self {
         Self { inner }
     }
 
@@ -67,7 +67,7 @@ impl<'a, T: ConsoleDevice> SbiConsole<'a, T> {
     }
 }
 
-impl<'a, T: ConsoleDevice> Console for SbiConsole<'a, T> {
+impl<T: ConsoleDevice> Console for SbiConsole<T> {
     /// Write a physical memory buffer to the console.
     #[inline]
     fn write(&self, bytes: Physical<&[u8]>) -> SbiRet {
@@ -96,7 +96,7 @@ impl<'a, T: ConsoleDevice> Console for SbiConsole<'a, T> {
     }
 }
 
-impl<'a, T: ConsoleDevice> fmt::Write for SbiConsole<'a, T> {
+impl<T: ConsoleDevice> fmt::Write for SbiConsole<T> {
     /// Implement Write trait for string formatting.
     #[inline]
     fn write_str(&mut self, s: &str) -> fmt::Result {

prototyper/src/sbi/ipi.rs

@@ -34,14 +34,14 @@ pub trait IpiDevice {
 }
 
 /// SBI IPI implementation.
-pub struct SbiIpi<'a, T: IpiDevice> {
+pub struct SbiIpi<T: IpiDevice> {
     /// Reference to atomic pointer to IPI device.
-    pub ipi_dev: &'a AtomicPtr<T>,
+    pub ipi_dev: AtomicPtr<T>,
     /// Maximum hart ID in the system
     pub max_hart_id: usize,
 }
 
-impl<'a, T: IpiDevice> rustsbi::Timer for SbiIpi<'a, T> {
+impl<T: IpiDevice> rustsbi::Timer for SbiIpi<T> {
     /// Set timer value for current hart.
     #[inline]
     fn set_timer(&self, stime_value: u64) {
@@ -64,7 +64,7 @@ impl<'a, T: IpiDevice> rustsbi::Timer for SbiIpi<'a, T> {
     }
 }
 
-impl<'a, T: IpiDevice> rustsbi::Ipi for SbiIpi<'a, T> {
+impl<T: IpiDevice> rustsbi::Ipi for SbiIpi<T> {
     /// Send IPI to specified harts.
     #[inline]
     fn send_ipi(&self, hart_mask: rustsbi::HartMask) -> SbiRet {
@@ -92,10 +92,10 @@ impl<'a, T: IpiDevice> rustsbi::Ipi for SbiIpi<'a, T> {
     }
 }
 
-impl<'a, T: IpiDevice> SbiIpi<'a, T> {
+impl<T: IpiDevice> SbiIpi<T> {
     /// Create new SBI IPI instance.
     #[inline]
-    pub fn new(ipi_dev: &'a AtomicPtr<T>, max_hart_id: usize) -> Self {
+    pub fn new(ipi_dev: AtomicPtr<T>, max_hart_id: usize) -> Self {
         Self {
             ipi_dev,
             max_hart_id,

prototyper/src/sbi/mod.rs

@@ -21,15 +21,27 @@ use rfence::SbiRFence;
 
 #[derive(RustSBI, Default)]
 #[rustsbi(dynamic)]
-pub struct Sbi<'a, C: ConsoleDevice, I: IpiDevice, R: ResetDevice> {
+pub struct Sbi<C: ConsoleDevice, I: IpiDevice, R: ResetDevice> {
     #[rustsbi(console)]
-    pub console: Option<SbiConsole<'a, C>>,
+    pub console: Option<SbiConsole<C>>,
     #[rustsbi(ipi, timer)]
-    pub ipi: Option<SbiIpi<'a, I>>,
+    pub ipi: Option<SbiIpi<I>>,
     #[rustsbi(hsm)]
     pub hsm: Option<SbiHsm>,
     #[rustsbi(reset)]
-    pub reset: Option<SbiReset<'a, R>>,
+    pub reset: Option<SbiReset<R>>,
     #[rustsbi(fence)]
     pub rfence: Option<SbiRFence>,
 }
+
+impl<C: ConsoleDevice, I: IpiDevice, R: ResetDevice> Sbi<C, I, R> {
+    pub const fn new() -> Self {
+        Sbi {
+            console: None,
+            ipi: None,
+            hsm: None,
+            reset: None,
+            rfence: None,
+        }
+    }
+}

prototyper/src/sbi/reset.rs

@@ -9,12 +9,12 @@ pub trait ResetDevice {
     fn reset(&self) -> !;
 }
 
-pub struct SbiReset<'a, T: ResetDevice> {
-    pub reset_dev: &'a AtomicPtr<T>,
+pub struct SbiReset<T: ResetDevice> {
+    pub reset_dev: AtomicPtr<T>,
 }
 
-impl<'a, T: ResetDevice> SbiReset<'a, T> {
-    pub fn new(reset_dev: &'a AtomicPtr<T>) -> Self {
+impl<'a, T: ResetDevice> SbiReset<T> {
+    pub fn new(reset_dev: AtomicPtr<T>) -> Self {
         Self { reset_dev }
     }
 
@@ -32,7 +32,7 @@ impl<'a, T: ResetDevice> SbiReset<'a, T> {
     }
 }
 
-impl<'a, T: ResetDevice> rustsbi::Reset for SbiReset<'a, T> {
+impl<T: ResetDevice> rustsbi::Reset for SbiReset<T> {
     #[inline]
     fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet {
         use rustsbi::spec::srst::{
@@ -61,5 +61,8 @@ impl<'a, T: ResetDevice> rustsbi::Reset for SbiReset<'a, T> {
 }
 
 pub fn fail() -> ! {
-    unsafe { BOARD.sbi.reset.as_ref().unwrap().fail() }
+    match unsafe { BOARD.sbi.reset.as_ref() } {
+        Some(reset) => reset.fail(),
+        None => panic!("SBI or IPI device not initialized"),
+    }
 }