fix: 移除 LegacyStdio 可变性要求

src/legacy_stdio.rs

@@ -1,101 +1,36 @@
 //! 这个模块的两个宏应该公开
 //! 如果制造实例的时候，给定了stdout，那么就会打印到这个stdout里面
 
-use crate::util::{AmoMutex, NullableMut};
+use crate::util::AmoOnceRef;
 use core::fmt;
 
 /// Legacy standard input/output
-pub trait LegacyStdio: Send {
+pub trait LegacyStdio: Send + Sync {
     /// Get a character from legacy stdin
-    fn getchar(&mut self) -> u8;
+    fn getchar(&self) -> u8;
     /// Put a character into legacy stdout
-    fn putchar(&mut self, ch: u8);
+    fn putchar(&self, ch: u8);
 }
 
-// /// Use serial in `embedded-hal` as legacy standard input/output
-// struct EmbeddedHalSerial<T> {
-//     inner: T,
-// }
-
-// impl<T> EmbeddedHalSerial<T> {
-//     /// Create a wrapper with a value
-//     #[inline]
-//     fn new(inner: T) -> Self {
-//         Self { inner }
-//     }
-// }
-
-// impl<T: Send> LegacyStdio for EmbeddedHalSerial<T>
-// where
-//     T: Read<u8> + Write<u8>,
-// {
-//     #[inline]
-//     fn getchar(&mut self) -> u8 {
-//         // 直接调用embedded-hal里面的函数
-//         // 关于unwrap：因为这个是legacy函数，这里没有详细的处理流程，就panic掉
-//         block!(self.inner.read()).ok().unwrap()
-//     }
-
-//     #[inline]
-//     fn putchar(&mut self, ch: u8) {
-//         // 直接调用函数写一个字节
-//         block!(self.inner.write(ch)).ok();
-//         // 写一次flush一次，因为是legacy，就不考虑效率了
-//         block!(self.inner.flush()).ok();
-//     }
-// }
-
-// struct Fused<T, R>(T, R);
-
-// // 和上面的原理差不多，就是分开了
-// impl<T, R> LegacyStdio for Fused<T, R>
-// where
-//     T: Write<u8> + Send + 'static,
-//     R: Read<u8> + Send + 'static,
-// {
-//     #[inline]
-//     fn getchar(&mut self) -> u8 {
-//         block!(self.1.read()).ok().unwrap()
-//     }
-
-//     #[inline]
-//     fn putchar(&mut self, ch: u8) {
-//         block!(self.0.write(ch)).ok();
-//         block!(self.0.flush()).ok();
-//     }
-// }
-
-static STDIO: AmoMutex<NullableMut<dyn LegacyStdio>> = AmoMutex::new(NullableMut::new());
+static STDIO: AmoOnceRef<dyn LegacyStdio> = AmoOnceRef::new();
 
 #[inline]
-pub fn init_legacy_stdio(stdio: &'static mut dyn LegacyStdio) {
-    STDIO.lock().set(stdio);
+pub fn init_legacy_stdio(stdio: &'static dyn LegacyStdio) {
+    if !STDIO.try_call_once(stdio) {
+        panic!("load sbi module when already loaded")
+    }
 }
 
-// pub fn init_legacy_stdio_embedded_hal<T: Read<u8> + Write<u8> + Send + 'static>(serial: T) {
-//     let serial = EmbeddedHalSerial::new(serial);
-//     *LEGACY_STDIO.lock() = Some(Box::new(serial));
-// }
-
-// pub fn init_legacy_stdio_embedded_hal_fuse<T, R>(tx: T, rx: R)
-// where
-//     T: Write<u8> + Send + 'static,
-//     R: Read<u8> + Send + 'static,
-// {
-//     let serial = Fused(tx, rx);
-//     *LEGACY_STDIO.lock() = Some(Box::new(serial));
-// }
-
 #[inline]
 pub fn legacy_stdio_putchar(ch: u8) {
-    if let Some(stdio) = STDIO.lock().get() {
+    if let Some(stdio) = STDIO.get() {
         stdio.putchar(ch)
     }
 }
 
 #[inline]
 pub fn legacy_stdio_getchar() -> usize {
-    if let Some(stdio) = STDIO.lock().get() {
+    if let Some(stdio) = STDIO.get() {
         stdio.getchar() as usize
     } else {
         // According to RISC-V SBI spec 0.3.1-rc1, Section 4.3, this function returns -1
@@ -109,7 +44,7 @@ struct Stdout;
 impl fmt::Write for Stdout {
     #[inline]
     fn write_str(&mut self, s: &str) -> fmt::Result {
-        if let Some(stdio) = STDIO.lock().get() {
+        if let Some(stdio) = STDIO.get() {
             for byte in s.as_bytes() {
                 stdio.putchar(*byte)
             }

src/util.rs

@@ -1,88 +1,6 @@
 //! useful structures
 
-use core::{
-    arch::asm,
-    cell::UnsafeCell,
-    marker::PhantomData,
-    mem::MaybeUninit,
-    ops::{Deref, DerefMut},
-    ptr::Pointee,
-};
-
-/// Use only amo instructions on mutex; no lr/sc instruction is used
-pub struct AmoMutex<T: ?Sized> {
-    lock: UnsafeCell<u32>,
-    data: UnsafeCell<T>,
-}
-
-pub struct AmoMutexGuard<'a, T: ?Sized> {
-    lock: *mut u32,
-    data: &'a mut T,
-}
-
-impl<T> AmoMutex<T> {
-    /// Create a new AmoMutex
-    #[inline]
-    pub const fn new(data: T) -> Self {
-        Self {
-            lock: UnsafeCell::new(0),
-            data: UnsafeCell::new(data),
-        }
-    }
-
-    /// Locks the mutex and returns a guard that permits access to the inner data.
-    #[inline]
-    pub fn lock(&self) -> AmoMutexGuard<T> {
-        let lock = self.lock.get();
-        unsafe {
-            asm!(
-                "1: lw           {tmp}, ({lock})",        // check if lock is held
-                "   bnez         {tmp}, 1b",              // retry if held
-                "   amoswap.w.aq {tmp}, {one}, ({lock})", // attempt to acquire lock
-                "   bnez         {tmp}, 1b",              // retry if held
-                tmp  = out(reg) _,
-                lock =  in(reg) lock,
-                one  =  in(reg) 1,
-                options(nostack)
-            );
-        }
-        AmoMutexGuard {
-            lock,
-            data: unsafe { &mut *self.data.get() },
-        }
-    }
-}
-
-unsafe impl<T: ?Sized + Send> Sync for AmoMutex<T> {}
-unsafe impl<T: ?Sized + Send> Send for AmoMutex<T> {}
-
-impl<'a, T: ?Sized> Deref for AmoMutexGuard<'a, T> {
-    type Target = T;
-    #[inline]
-    fn deref(&self) -> &T {
-        self.data
-    }
-}
-
-impl<'a, T: ?Sized> DerefMut for AmoMutexGuard<'a, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut T {
-        self.data
-    }
-}
-
-impl<'a, T: ?Sized> Drop for AmoMutexGuard<'a, T> {
-    /// The dropping of the mutex guard will release the lock it was created from.
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            asm!(
-                "amoswap.w.rl zero, zero, ({lock})", // release lock by storing 0
-                lock = in(reg) self.lock,
-            );
-        }
-    }
-}
+use core::{arch::asm, cell::UnsafeCell, marker::PhantomData, mem::MaybeUninit, ptr::Pointee};
 
 /// 只使用 AMO 指令的一次初始化引用存储。
 pub struct AmoOnceRef<'a, T: ?Sized> {
@@ -205,39 +123,77 @@ impl<'a, T: ?Sized> AmoOnceRef<'a, T> {
     }
 }
 
-/// 分解一个胖指针，使之 Sized。
-pub struct NullableMut<'a, T: ?Sized> {
-    ptr: *mut (),
-    meta: MaybeUninit<<T as Pointee>::Metadata>,
-    _lifetime: PhantomData<&'a ()>,
-}
-
-/// 如果 NullableMut 保存的引用是静态的，自然可以随意移动。
-unsafe impl<T: ?Sized> Send for NullableMut<'static, T> {}
-
-/// NullableMut 不提供锁。
-unsafe impl<T: ?Sized + Sync> Sync for NullableMut<'static, T> {}
-
-impl<'a, T: ?Sized> NullableMut<'a, T> {
-    pub const fn new() -> Self {
-        Self {
-            ptr: core::ptr::null_mut(),
-            meta: MaybeUninit::uninit(),
-            _lifetime: PhantomData,
-        }
-    }
-
-    pub fn set(&mut self, r#ref: &'a mut T) {
-        let ptr = r#ref as *mut T;
-        self.ptr = ptr.cast();
-        self.meta = MaybeUninit::new(core::ptr::metadata(ptr));
-    }
-
-    pub fn get(&mut self) -> Option<&mut T> {
-        if !self.ptr.is_null() {
-            Some(unsafe { &mut *core::ptr::from_raw_parts_mut(self.ptr, self.meta.assume_init()) })
-        } else {
-            None
-        }
-    }
-}
+// /// Use only amo instructions on mutex; no lr/sc instruction is used
+// pub struct AmoMutex<T: ?Sized> {
+//     lock: UnsafeCell<u32>,
+//     data: UnsafeCell<T>,
+// }
+
+// pub struct AmoMutexGuard<'a, T: ?Sized> {
+//     lock: *mut u32,
+//     data: &'a mut T,
+// }
+
+// impl<T> AmoMutex<T> {
+//     /// Create a new AmoMutex
+//     #[inline]
+//     pub const fn new(data: T) -> Self {
+//         Self {
+//             lock: UnsafeCell::new(0),
+//             data: UnsafeCell::new(data),
+//         }
+//     }
+
+//     /// Locks the mutex and returns a guard that permits access to the inner data.
+//     #[inline]
+//     pub fn lock(&self) -> AmoMutexGuard<T> {
+//         let lock = self.lock.get();
+//         unsafe {
+//             asm!(
+//                 "1: lw           {tmp}, ({lock})",        // check if lock is held
+//                 "   bnez         {tmp}, 1b",              // retry if held
+//                 "   amoswap.w.aq {tmp}, {one}, ({lock})", // attempt to acquire lock
+//                 "   bnez         {tmp}, 1b",              // retry if held
+//                 tmp  = out(reg) _,
+//                 lock =  in(reg) lock,
+//                 one  =  in(reg) 1,
+//                 options(nostack)
+//             );
+//         }
+//         AmoMutexGuard {
+//             lock,
+//             data: unsafe { &mut *self.data.get() },
+//         }
+//     }
+// }
+
+// unsafe impl<T: ?Sized + Send> Sync for AmoMutex<T> {}
+// unsafe impl<T: ?Sized + Send> Send for AmoMutex<T> {}
+
+// impl<'a, T: ?Sized> Deref for AmoMutexGuard<'a, T> {
+//     type Target = T;
+//     #[inline]
+//     fn deref(&self) -> &T {
+//         self.data
+//     }
+// }
+
+// impl<'a, T: ?Sized> DerefMut for AmoMutexGuard<'a, T> {
+//     #[inline]
+//     fn deref_mut(&mut self) -> &mut T {
+//         self.data
+//     }
+// }
+
+// impl<'a, T: ?Sized> Drop for AmoMutexGuard<'a, T> {
+//     /// The dropping of the mutex guard will release the lock it was created from.
+//     #[inline]
+//     fn drop(&mut self) {
+//         unsafe {
+//             asm!(
+//                 "amoswap.w.rl zero, zero, ({lock})", // release lock by storing 0
+//                 lock = in(reg) self.lock,
+//             );
+//         }
+//     }
+// }