[WIP] feat(hal-core): sketching irq mutex stuff

hal-core/Cargo.toml

@@ -14,3 +14,4 @@ thiserror = { workspace = true }
 maitake-sync = { path = "../maitake-sync", default-features = false }
 mycelium-util = { path = "../util" }
 embedded-graphics-core = { version = "0.3", optional = true }
+portable-atomic = "1.2"

hal-core/src/interrupt.rs

@@ -1,7 +1,9 @@
 use core::fmt;
 
 pub mod ctx;
+mod lock;
 pub use self::ctx::Context;
+pub use self::lock::IrqRawMutex;
 
 /// An interrupt controller for a platform.
 pub trait Control {
@@ -40,6 +42,27 @@
     }
 }
 
+pub trait MaskInterrupt<V> {
+    /// Mask the interrupt on vector `V`.
+    unsafe fn mask_irq(&self, vector: V);
+
+    /// Unmask the interrupt on vector `V`.
+    unsafe fn unmask_irq(&self, vector: V);
+}
+
+impl<T, V> MaskInterrupt<V> for &T
+where
+    T: MaskInterrupt<V>,
+{
+    unsafe fn mask_irq(&self, vector: V) {
+        (*self).mask_irq(vector);
+    }
+
+    unsafe fn unmask_irq(&self, vector: V) {
+        (*self).unmask_irq(vector);
+    }
+}
+
 pub trait Handlers<R: fmt::Debug + fmt::Display> {
     fn page_fault<C>(cx: C)
     where

hal-core/src/interrupt/lock.rs

@@ -0,0 +1,116 @@
+use super::MaskInterrupt;
+use maitake_sync::{blocking::RawMutex, spin::Spinlock};
+use portable_atomic::{AtomicBool, Ordering};
+
+/// A spinlock that also provides mutual exclusion against the interrupt handler
+/// for a particular interrupt vector.
+///
+/// While this spinlock is locked, the interrupt vector is masked, preventing
+/// the interrupt handler from running. The interrupt is unmasked when the
+/// spinlock is unlocked.
+///
+/// This type requires exclusive control over the masking and unmasking of that
+/// interrupt vector.
+#[derive(Debug)]
+pub struct IrqSpinlock<I, V> {
+    lock: Spinlock,
+    ctrl: I,
+    vector: V,
+}
+
+pub struct IrqSpinlockTable<V, const VECTORS: usize> {
+    locks: [AtomicBool; VECTORS],
+    _v: core::marker::PhantomData<fn(V)>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ClaimLockError {
+    AlreadyClaimed,
+    NoSuchIrq,
+}
+
+impl<I, V> IrqSpinlock<I, V>
+where
+    I: MaskInterrupt<V>,
+    V: Copy,
+{
+    /// # Safety
+    ///
+    /// Constructing an `IrqSpinlock` for a given interrupt vector requires
+    /// exclusive control over the masking and unmasking of that interrupt
+    /// vector.
+    pub unsafe fn new(ctrl: I, vector: V) -> Self {
+        Self {
+            lock: Spinlock::new(),
+            ctrl,
+            vector,
+        }
+    }
+}
+
+unsafe impl<I, V> RawMutex for IrqSpinlock<I, V>
+where
+    I: MaskInterrupt<V>,
+    V: Copy,
+{
+    type GuardMarker = ();
+
+    fn lock(&self) {
+        self.lock.lock();
+        unsafe {
+            // Safety: having locked the spinlock means we have exclusive access
+            // to that vector.
+            self.ctrl.mask_irq(self.vector)
+        };
+    }
+
+    fn try_lock(&self) -> bool {
+        if !self.lock.try_lock() {
+            return false;
+        }
+
+        unsafe {
+            // Safety: having locked the spinlock means we have exclusive access
+            // to that vector.
+            self.ctrl.mask_irq(self.vector)
+        };
+        true
+    }
+
+    unsafe fn unlock(&self) {
+        // Safety: the contract of `RawMutex::unlock` requires that the caller
+        // ensure that the mutex is locked, so this implies that we have
+        // exclusive access to that vector in the interrupt controller.
+        self.ctrl.unmask_irq(self.vector);
+        self.lock.unlock();
+    }
+
+    /// Returns `true` if the mutex is currently locked.
+    fn is_locked(&self) -> bool {
+        self.lock.is_locked()
+    }
+}
+
+impl<V, const VECTORS: usize> IrqSpinlockTable<V, VECTORS>
+where
+    V: Into<usize> + Copy,
+{
+    pub fn claim_lock<I>(&self, vector: V, ctrl: I) -> Result<IrqSpinlock<I, V>, ClaimLockError>
+    where
+        I: MaskInterrupt<V>,
+    {
+        let claimed = self
+            .locks
+            .get(vector.into())
+            .ok_or(ClaimLockError::NoSuchIrq)?;
+        claimed
+            .compare_exchange(true, false, Ordering::AcqRel, Ordering::Acquire)
+            .map_err(|_| ClaimLockError::AlreadyClaimed)?;
+        Ok(unsafe {
+            // Safety: we have just claimed the vector, so unless the interrupt
+            // controller hands out access to it through other mechanisms, we
+            // have exclusive access to it.
+            IrqSpinlock::new(ctrl, vector)
+        })
+    }
+}

src/tests.rs

@@ -28,13 +28,13 @@ mod alloc {
     mycotest::decl_test! {
         fn alloc_big() {
             use alloc::vec::Vec;
-            let mut v = Vec::new();
-
-            for i in 0..2048 {
-                v.push(i);
-            }
+            // let mut v = Vec::new();
+            panic!("lol");
+            // for i in 0..2048 {
+            //     v.push(i);
+            // }
 
-            tracing::info!(vec = ?v);
+            // tracing::info!(vec = ?v);
         }
     }
 }