feat: 修改各模块传入 &‘static dyn Trait，但 LegacyStdio 改不了

src/ipi.rs

@@ -1,10 +1,9 @@
 use crate::ecall::SbiRet;
 use crate::hart_mask::HartMask;
-use crate::util::OnceFatBox;
-use alloc::boxed::Box;
+use crate::util::AmoOncePtr;
 
 /// Inter-processor interrupt support
-pub trait Ipi: Send {
+pub trait Ipi: Send + Sync {
     /// Send an inter-processor interrupt to all the harts defined in `hart_mask`.
     ///
     /// Inter-processor interrupts manifest at the receiving harts as the supervisor software interrupts.
@@ -20,12 +19,11 @@ pub trait Ipi: Send {
     }
 }
 
-static IPI: OnceFatBox<dyn Ipi + Sync + 'static> = OnceFatBox::new();
+static IPI: AmoOncePtr<dyn Ipi> = AmoOncePtr::new();
 
 #[doc(hidden)] // use through a macro
-pub fn init_ipi<T: Ipi + Sync + 'static>(ipi: T) {
-    let result = IPI.set(Box::new(ipi));
-    if result.is_err() {
+pub fn init_ipi(ipi: &'static dyn Ipi) {
+    if IPI.try_call_once(ipi) {
         panic!("load sbi module when already loaded")
     }
 }

src/pmu.rs

@@ -1,6 +1,5 @@
 use crate::ecall::SbiRet;
-use crate::util::OnceFatBox;
-use alloc::boxed::Box;
+use crate::util::AmoOncePtr;
 
 /// Performance Monitoring Unit Extension
 ///
@@ -37,7 +36,7 @@ use alloc::boxed::Box;
 ///    event_idx[19:16] = type;
 ///    event_idx[15:0] = code;
 /// ```
-pub trait Pmu: Send {
+pub trait Pmu: Send + Sync {
     /// Returns the number of counters (both hardware and firmware).
     ///
     /// The value is returned in `SbiRet.value`; this call always returns SBI_SUCCESS in `SbiRet.error`.
@@ -59,7 +58,7 @@ pub trait Pmu: Send {
     ///
     /// Returns the `counter_info` described above in `SbiRet.value`.
     ///
-    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:    
+    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:
     ///
     /// | Return code             | Description
     /// |:------------------------|:----------------------------------------------
@@ -95,7 +94,7 @@ pub trait Pmu: Send {
     /// set of counters specified by the `counter_idx_base` and `counter_idx_mask`.
     ///
     /// *NOTE:* The *SBI_PMU_CFG_FLAG_AUTO_START* flag in `config_flags` has no
-    /// impact on the counter value.    
+    /// impact on the counter value.
     ///
     /// *NOTE:* The `config_flags[3:7]` bits are event filtering hints so these
     /// can be ignored or overridden by the SBI implementation for security concerns
@@ -105,7 +104,7 @@ pub trait Pmu: Send {
     ///
     /// Returns the `counter_idx` in `sbiret.value` upon success.
     ///
-    /// In case of failure, the possible error codes returned in `sbiret.error` are shown in the table below:    
+    /// In case of failure, the possible error codes returned in `sbiret.error` are shown in the table below:
     ///
     /// | Return code           | Description
     /// |:----------------------|:----------------------------------------------
@@ -139,7 +138,7 @@ pub trait Pmu: Send {
     ///
     /// # Return value
     ///
-    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:    
+    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:
     ///
     /// | Return code             | Description
     /// |:------------------------|:----------------------------------------------
@@ -167,7 +166,7 @@ pub trait Pmu: Send {
     ///
     /// # Return value
     ///
-    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:    
+    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:
     ///
     /// | Return code             | Description
     /// |:------------------------|:----------------------------------------------
@@ -189,7 +188,7 @@ pub trait Pmu: Send {
     ///
     /// # Return value
     ///
-    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:    
+    /// The possible return error codes returned in `SbiRet.error` are shown in the table below:
     ///
     /// | Return code             | Description
     /// |:------------------------|:----------------------------------------------
@@ -200,12 +199,11 @@ pub trait Pmu: Send {
 
 // TODO: all the events here
 
-static PMU: OnceFatBox<dyn Pmu + Sync + 'static> = OnceFatBox::new();
+static PMU: AmoOncePtr<dyn Pmu> = AmoOncePtr::new();
 
 #[doc(hidden)] // use through a macro or a call from implementation
-pub fn init_pmu<T: Pmu + Sync + 'static>(pmu: T) {
-    let result = PMU.set(Box::new(pmu));
-    if result.is_err() {
+pub fn init_pmu(pmu: &'static dyn Pmu) {
+    if PMU.try_call_once(pmu) {
         panic!("load sbi module when already loaded")
     }
 }

src/reset.rs

@@ -1,6 +1,5 @@
 use crate::ecall::SbiRet;
-use crate::util::OnceFatBox;
-use alloc::boxed::Box;
+use crate::util::AmoOncePtr;
 
 /// System Reset Extension
 ///
@@ -10,7 +9,7 @@ use alloc::boxed::Box;
 /// could be machine mode firmware or hypervisor.
 ///
 /// Ref: [Section 9, RISC-V Supervisor Binary Interface Specification](https://github.com/riscv-non-isa/riscv-sbi-doc/blob/master/riscv-sbi.adoc#9-system-reset-extension-eid-0x53525354-srst)
-pub trait Reset: Send {
+pub trait Reset: Send + Sync {
     /// Reset the system based on provided `reset_type` and `reset_reason`.
     ///
     /// This is a synchronous call and does not return if it succeeds.
@@ -51,7 +50,7 @@ pub trait Reset: Send {
     }
 }
 
-static RESET: OnceFatBox<dyn Reset + Sync + 'static> = OnceFatBox::new();
+static RESET: AmoOncePtr<dyn Reset> = AmoOncePtr::new();
 
 #[doc(hidden)]
 #[allow(unused)]
@@ -71,9 +70,8 @@ pub const RESET_REASON_NO_REASON: usize = 0x0000_0000;
 pub const RESET_REASON_SYSTEM_FAILURE: usize = 0x0000_0001;
 
 #[doc(hidden)] // use through a macro
-pub fn init_reset<T: Reset + Sync + 'static>(reset: T) {
-    let result = RESET.set(Box::new(reset));
-    if result.is_err() {
+pub fn init_reset(reset: &'static dyn Reset) {
+    if !RESET.try_call_once(reset) {
         panic!("load sbi module when already loaded")
     }
 }

src/rfence.rs

@@ -1,14 +1,13 @@
 use crate::ecall::SbiRet;
 use crate::hart_mask::HartMask;
-use crate::util::OnceFatBox;
-use alloc::boxed::Box;
+use crate::util::AmoOncePtr;
 
 /// Remote fence support
 ///
 /// The remote fence function acts as a full TLB flush if
 /// - `start_addr` and `size` are both 0, or
 /// - `size` is equal to `usize::MAX`.
-pub trait Rfence: Send {
+pub trait Rfence: Send + Sync {
     /// Instructs remote harts to execute `FENCE.I` instruction.
     ///
     /// # Return value
@@ -137,12 +136,11 @@ pub trait Rfence: Send {
     }
 }
 
-static RFENCE: OnceFatBox<dyn Rfence + Sync + 'static> = OnceFatBox::new();
+static RFENCE: AmoOncePtr<dyn Rfence> = AmoOncePtr::new();
 
 #[doc(hidden)] // use through a macro
-pub fn init_rfence<T: Rfence + Sync + 'static>(rfence: T) {
-    let result = RFENCE.set(Box::new(rfence));
-    if result.is_err() {
+pub fn init_rfence(rfence: &'static dyn Rfence) {
+    if RFENCE.try_call_once(rfence) {
         panic!("load sbi module when already loaded")
     }
 }

src/timer.rs

@@ -1,8 +1,7 @@
-use crate::util::OnceFatBox;
-use alloc::boxed::Box;
+use crate::util::AmoOncePtr;
 
 /// Timer programmer support
-pub trait Timer: Send {
+pub trait Timer: Send + Sync {
     /// Programs the clock for next event after `stime_value` time.
     ///
     /// `stime_value` is in absolute time. This function must clear the pending timer interrupt bit as well.
@@ -13,12 +12,11 @@ pub trait Timer: Send {
     fn set_timer(&self, stime_value: u64);
 }
 
-static TIMER: OnceFatBox<dyn Timer + Sync + 'static> = OnceFatBox::new();
+static TIMER: AmoOncePtr<dyn Timer> = AmoOncePtr::new();
 
 #[doc(hidden)] // use through a macro
-pub fn init_timer<T: Timer + Sync + 'static>(timer: T) {
-    let result = TIMER.set(Box::new(timer));
-    if result.is_err() {
+pub fn init_timer(timer: &'static dyn Timer) {
+    if !TIMER.try_call_once(timer) {
         panic!("load sbi module when already loaded")
     }
 }

src/util.rs

@@ -1,128 +1,13 @@
 //! useful structures
 
-// Ref: once_cell
-
-use alloc::boxed::Box;
 use core::{
     arch::asm,
     cell::UnsafeCell,
-    fmt::{self, Debug},
-    marker::PhantomData,
     mem::MaybeUninit,
     ops::{Deref, DerefMut},
-    ptr::{self, Pointee},
+    ptr::Pointee,
 };
 
-/// A thread-safe fat pointer cell which can be written to only once.
-pub struct OnceFatBox<T: ?Sized> {
-    thin_ptr: UnsafeCell<*mut ()>,
-    lock: UnsafeCell<u32>,
-    meta: MaybeUninit<<T as Pointee>::Metadata>,
-    _marker: PhantomData<Option<Box<T>>>,
-}
-
-impl<T: ?Sized> Default for OnceFatBox<T> {
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T: ?Sized> Drop for OnceFatBox<T> {
-    #[inline]
-    fn drop(&mut self) {
-        let data_address = *self.thin_ptr.get_mut();
-        if !data_address.is_null() {
-            let metadata = unsafe { self.meta.assume_init() };
-            let fat_ptr: *mut T = ptr::from_raw_parts_mut(data_address, metadata);
-            drop(unsafe { Box::from_raw(fat_ptr) })
-        }
-    }
-}
-
-impl<T: ?Sized + Debug> Debug for OnceFatBox<T>
-where
-    <T as Pointee>::Metadata: Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OnceFatBox")
-            .field("address", &self.thin_ptr)
-            .field("meta", &self.meta)
-            .finish()
-    }
-}
-
-impl<T: ?Sized> OnceFatBox<T> {
-    /// Creates a new empty cell.
-    #[inline]
-    pub const fn new() -> OnceFatBox<T> {
-        OnceFatBox {
-            thin_ptr: UnsafeCell::new(ptr::null_mut()),
-            lock: UnsafeCell::new(0),
-            meta: MaybeUninit::uninit(), // value meaning ignored when thin_ptr is null
-            _marker: PhantomData,
-        }
-    }
-
-    /// Gets a reference to the underlying value.
-    #[inline]
-    pub fn get(&self) -> Option<&T> {
-        let data_address = self.thin_ptr.get();
-        if data_address.is_null() {
-            return None;
-        }
-        let metadata = unsafe { self.meta.assume_init() };
-        let fat_ptr: *const T = ptr::from_raw_parts(unsafe { *data_address }, metadata);
-        Some(unsafe { &*fat_ptr })
-    }
-
-    /// Sets the contents of this cell to `value`.
-    ///
-    /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was full.
-    #[inline]
-    pub fn set(&self, value: Box<T>) -> Result<(), Box<T>> {
-        let fat_ptr = Box::into_raw(value);
-        let data_address = fat_ptr as *mut ();
-        // compare-exchange using amo operations
-        let exchange = unsafe {
-            let mut ans = Err(());
-            asm!(
-                "li     {one}, 1",
-                "1: lw  {tmp}, ({lock})", // check if lock is held
-                // "call   {relax}", // spin loop hint
-                "bnez   {tmp}, 1b", // retry if held
-                "amoswap.w.aq {tmp}, {one}, ({lock})", // attempt to acquire lock
-                "bnez   {tmp}, 1b", // retry if held
-                lock = in(reg) self.lock.get(),
-                tmp = out(reg) _,
-                one = out(reg) _,
-                // relax = sym pause,
-                options(nostack)
-            );
-            // critical section begin
-            if (*self.thin_ptr.get()).is_null() {
-                // not 'self.thin_ptr.get().is_null()'
-                *self.thin_ptr.get() = data_address;
-                *(self.meta.as_ptr() as *mut _) = ptr::metadata(fat_ptr);
-                ans = Ok(())
-            }
-            // critical section end
-            asm!(
-                "amoswap.w.rl x0, x0, ({lock})", // release lock by storing 0
-                lock = in(reg) self.lock.get(),
-            );
-            ans
-        };
-        if exchange.is_err() {
-            let value = unsafe { Box::from_raw(fat_ptr) };
-            return Err(value);
-        }
-        Ok(())
-    }
-}
-
-unsafe impl<T: Sync + Send + ?Sized> Sync for OnceFatBox<T> {}
-
 /// Use only amo instructions on mutex; no lr/sc instruction is used
 pub struct AmoMutex<T: ?Sized> {
     lock: UnsafeCell<u32>,
@@ -238,7 +123,7 @@ impl<T: ?Sized> AmoOncePtr<T> {
             // 取得锁，初始化对象
             unsafe {
                 // amo rl 保证先初始化 meta 后设置指针
-                (*self.meta.get()) = MaybeUninit::new(ptr::metadata(ptr));
+                (*self.meta.get()) = MaybeUninit::new(core::ptr::metadata(ptr));
                 #[cfg(target_pointer_width = "32")]
                 asm!(
                     "amoswap.d.rl zero, {src}, ({dst})",
@@ -307,9 +192,15 @@ impl<T: ?Sized> AmoOncePtr<T> {
         }
     }
 
+    /// 强行获得一个可变的引用，可能导致运行时异常。
+    #[inline]
+    pub unsafe fn get_mut(&self) -> Option<&mut T> {
+        self.get().map(|t| &mut *(t as *const _ as *mut _))
+    }
+
     /// 利用指针和元数据生成引用。需要保证传入的指针非空。如果能传入非空指针，meta 也一定存在。
     #[inline]
     unsafe fn build_ref_unchecked(&self, ptr: *const ()) -> &T {
-        &*ptr::from_raw_parts(ptr, (*self.meta.get()).assume_init())
+        &*core::ptr::from_raw_parts(ptr, (*self.meta.get()).assume_init())
     }
 }