Add more OS-independent synchronization abstractions and utilities

Cargo.toml

@@ -66,6 +66,7 @@ members = [
     "crates/private/tests/root-task/verus/core",
     "crates/private/tests/root-task/verus/task",
     "crates/sel4",
+    "crates/sel4-abstract-rc",
     "crates/sel4-async/block-io",
     "crates/sel4-async/block-io/fat",
     "crates/sel4-async/io",
@@ -136,6 +137,7 @@ members = [
     "crates/sel4-shared-ring-buffer/smoltcp",
     "crates/sel4-stack",
     "crates/sel4-sync",
+    "crates/sel4-sync/trivial",
     "crates/sel4-synthetic-elf",
     "crates/sel4-test-harness",
     "crates/sel4/bitfield-ops",

crates/drivers/virtio/hal-impl/src/lib.rs

@@ -14,9 +14,9 @@ use virtio_drivers::{BufferDirection, Hal, PhysAddr, PAGE_SIZE};
 use sel4_bounce_buffer_allocator::{Basic, BounceBufferAllocator};
 use sel4_externally_shared::{ExternallySharedRef, ExternallySharedRefExt};
 use sel4_immediate_sync_once_cell::ImmediateSyncOnceCell;
-use sel4_sync::{lock_api::Mutex, GenericRawMutex, PanickingMutexSyncOps};
+use sel4_sync::{lock_api::Mutex, PanickingRawMutex};
 
-static GLOBAL_STATE: ImmediateSyncOnceCell<Mutex<GenericRawMutex<PanickingMutexSyncOps>, State>> =
+static GLOBAL_STATE: ImmediateSyncOnceCell<Mutex<PanickingRawMutex, State>> =
     ImmediateSyncOnceCell::new();
 
 struct State {
@@ -56,14 +56,11 @@ impl HalImpl {
             BounceBufferAllocator::new(Basic::new(dma_region_size), max_alignment);
 
         GLOBAL_STATE
-            .set(Mutex::from_raw(
-                GenericRawMutex::new(PanickingMutexSyncOps::new()),
-                State {
-                    dma_region,
-                    dma_region_paddr,
-                    bounce_buffer_allocator,
-                },
-            ))
+            .set(Mutex::new(State {
+                dma_region,
+                dma_region_paddr,
+                bounce_buffer_allocator,
+            }))
             .ok()
             .unwrap();
     }

crates/examples/microkit/http-server/pds/server/src/main.rs

@@ -110,6 +110,7 @@ fn init() -> impl Handler {
             BounceBufferAllocator::new(Basic::new(dma_region.as_ptr().len()), 1);
 
         DeviceImpl::new(
+            Default::default(),
             dma_region,
             bounce_buffer_allocator,
             RingBuffers::from_ptrs_using_default_initialization_strategy_for_role(

crates/examples/root-task/spawn-task/child/src/runtime.rs

@@ -10,7 +10,7 @@ use sel4::CapTypeForFrameObjectOfFixedSize;
 use sel4_dlmalloc::{StaticDlmallocGlobalAlloc, StaticHeap};
 use sel4_panicking::catch_unwind;
 use sel4_panicking_env::abort;
-use sel4_sync::{GenericRawMutex, PanickingMutexSyncOps};
+use sel4_sync::PanickingRawMutex;
 
 use crate::main;
 
@@ -24,12 +24,9 @@ static STATIC_HEAP: StaticHeap<HEAP_SIZE> = StaticHeap::new();
 
 #[global_allocator]
 static GLOBAL_ALLOCATOR: StaticDlmallocGlobalAlloc<
-    GenericRawMutex<PanickingMutexSyncOps>,
+    PanickingRawMutex,
     &'static StaticHeap<HEAP_SIZE>,
-> = StaticDlmallocGlobalAlloc::new(
-    GenericRawMutex::new(PanickingMutexSyncOps::new()),
-    &STATIC_HEAP,
-);
+> = StaticDlmallocGlobalAlloc::new(PanickingRawMutex::new(), &STATIC_HEAP);
 
 sel4_panicking_env::register_debug_put_char!(sel4::debug_put_char);
 

crates/private/support/sel4-simple-task/runtime/src/global_allocator.rs

@@ -5,23 +5,28 @@
 //
 
 use sel4_dlmalloc::{StaticDlmallocGlobalAlloc, StaticHeapBounds};
-use sel4_sync::{AbstractMutexSyncOps, GenericRawMutex};
+use sel4_sync::{GenericRawMutex, MutexSyncOps};
 
 use crate::{get_static_heap_bounds, get_static_heap_mutex_notification};
 
 #[global_allocator]
 #[allow(clippy::type_complexity)]
 static GLOBAL_ALLOCATOR: StaticDlmallocGlobalAlloc<
-    GenericRawMutex<AbstractMutexSyncOps<fn(), fn()>>,
+    GenericRawMutex<MutexSyncOpsImpl>,
     fn() -> StaticHeapBounds,
 > = StaticDlmallocGlobalAlloc::new(
-    GenericRawMutex::new(AbstractMutexSyncOps {
-        signal: || {
-            get_static_heap_mutex_notification().signal();
-        },
-        wait: || {
-            get_static_heap_mutex_notification().wait();
-        },
-    }),
+    GenericRawMutex::new(MutexSyncOpsImpl),
     get_static_heap_bounds,
 );
+
+struct MutexSyncOpsImpl;
+
+impl MutexSyncOps for MutexSyncOpsImpl {
+    fn signal(&self) {
+        get_static_heap_mutex_notification().signal();
+    }
+
+    fn wait(&self) {
+        get_static_heap_mutex_notification().wait();
+    }
+}

crates/sel4-abstract-rc/Cargo.nix

@@ -0,0 +1,11 @@
+#
+# Copyright 2024, Colias Group, LLC
+#
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+{ mk }:
+
+mk {
+  package.name = "sel4-abstract-rc";
+}

crates/sel4-abstract-rc/Cargo.toml

@@ -0,0 +1,17 @@
+#
+# Copyright 2023, Colias Group, LLC
+#
+# SPDX-License-Identifier: BSD-2-Clause
+#
+#
+# This file is generated from './Cargo.nix'. You can edit this file directly
+# if you are not using this project's Cargo manifest management tools.
+# See 'hacking/cargo-manifest-management/README.md' for more information.
+#
+
+[package]
+name = "sel4-abstract-rc"
+version = "0.1.0"
+authors = ["Nick Spinale <[email protected]>"]
+edition = "2021"
+license = "BSD-2-Clause"

crates/sel4-abstract-rc/src/lib.rs

@@ -0,0 +1,35 @@
+//
+// Copyright 2024, Colias Group, LLC
+//
+// SPDX-License-Identifier: BSD-2-Clause
+//
+
+#![no_std]
+
+extern crate alloc;
+
+use alloc::rc::Rc;
+use alloc::sync::Arc;
+use core::ops::Deref;
+
+pub trait AbstractRcT {
+    type Rc<T>: AbstractRc<T>;
+}
+
+pub struct RcT(());
+
+impl AbstractRcT for RcT {
+    type Rc<T> = Rc<T>;
+}
+
+pub struct ArcT(());
+
+impl AbstractRcT for ArcT {
+    type Rc<T> = Arc<T>;
+}
+
+pub trait AbstractRc<T>: Deref<Target = T> + From<T> + Clone {}
+
+impl<T> AbstractRc<T> for Rc<T> {}
+
+impl<T> AbstractRc<T> for Arc<T> {}

crates/sel4-capdl-initializer/src/main.rs

@@ -113,16 +113,13 @@ fn static_heap_bounds() -> StaticHeapBounds {
 
 mod heap {
     use sel4_dlmalloc::{StaticDlmallocGlobalAlloc, StaticHeapBounds};
-    use sel4_sync::{GenericRawMutex, PanickingMutexSyncOps};
+    use sel4_sync::PanickingRawMutex;
 
     use super::static_heap_bounds;
 
     #[global_allocator]
     static GLOBAL_ALLOCATOR: StaticDlmallocGlobalAlloc<
-        GenericRawMutex<PanickingMutexSyncOps>,
+        PanickingRawMutex,
         fn() -> StaticHeapBounds,
-    > = StaticDlmallocGlobalAlloc::new(
-        GenericRawMutex::new(PanickingMutexSyncOps::new()),
-        static_heap_bounds,
-    );
+    > = StaticDlmallocGlobalAlloc::new(PanickingRawMutex::new(), static_heap_bounds);
 }

crates/sel4-microkit/src/heap.rs

@@ -23,12 +23,9 @@ macro_rules! declare_heap {
 
                     #[global_allocator]
                     static GLOBAL_ALLOCATOR: StaticDlmallocGlobalAlloc<
-                        GenericRawMutex<PanickingMutexSyncOps>,
+                        PanickingRawMutex,
                         &'static StaticHeap<{ $size }>,
-                    > = StaticDlmallocGlobalAlloc::new(
-                        GenericRawMutex::new(PanickingMutexSyncOps::new()),
-                        &STATIC_HEAP,
-                    );
+                    > = StaticDlmallocGlobalAlloc::new(PanickingRawMutex::new(), &STATIC_HEAP);
                 }
             }
         };
@@ -37,5 +34,5 @@ macro_rules! declare_heap {
 
 pub mod _private {
     pub use sel4_dlmalloc::{StaticDlmallocGlobalAlloc, StaticHeap};
-    pub use sel4_sync::{GenericRawMutex, PanickingMutexSyncOps};
+    pub use sel4_sync::PanickingRawMutex;
 }

crates/sel4-root-task/src/heap.rs

@@ -44,14 +44,10 @@ macro_rules! declare_heap {
 
                     #[global_allocator]
                     static GLOBAL_ALLOCATOR: StaticDlmallocGlobalAlloc<
-                        GenericRawMutex<
-                            IndirectNotificationMutexSyncOps<fn() -> sel4::cap::Notification>,
-                        >,
+                        GenericRawMutex<fn() -> sel4::cap::Notification>,
                         &'static StaticHeap<{ SIZE }>,
                     > = StaticDlmallocGlobalAlloc::new(
-                        GenericRawMutex::new(IndirectNotificationMutexSyncOps::new(
-                            get_global_allocator_mutex_notification,
-                        )),
+                        GenericRawMutex::new(get_global_allocator_mutex_notification),
                         &STATIC_HEAP,
                     );
                 }
@@ -62,7 +58,7 @@ macro_rules! declare_heap {
 
 pub mod _private {
     pub use sel4_dlmalloc::{StaticDlmallocGlobalAlloc, StaticHeap};
-    pub use sel4_sync::{GenericRawMutex, IndirectNotificationMutexSyncOps};
+    pub use sel4_sync::GenericRawMutex;
 
     pub use super::get_global_allocator_mutex_notification;
 }

crates/sel4-shared-ring-buffer/smoltcp/Cargo.nix

@@ -9,9 +9,11 @@
 mk {
   package.name = "sel4-shared-ring-buffer-smoltcp";
   dependencies = {
-    inherit (versions) log;
+    inherit (versions) log lock_api;
     smoltcp = smoltcpWith [];
     inherit (localCrates)
+      sel4-abstract-rc
+      sel4-sync-trivial
       sel4-shared-ring-buffer
       sel4-shared-ring-buffer-bookkeeping
       sel4-bounce-buffer-allocator

crates/sel4-shared-ring-buffer/smoltcp/Cargo.toml

@@ -17,11 +17,14 @@ edition = "2021"
 license = "BSD-2-Clause"
 
 [dependencies]
+lock_api = "0.4.12"
 log = "0.4.17"
+sel4-abstract-rc = { path = "../../sel4-abstract-rc" }
 sel4-bounce-buffer-allocator = { path = "../../sel4-bounce-buffer-allocator" }
 sel4-externally-shared = { path = "../../sel4-externally-shared", features = ["unstable"] }
 sel4-shared-ring-buffer = { path = ".." }
 sel4-shared-ring-buffer-bookkeeping = { path = "../bookkeeping" }
+sel4-sync-trivial = { path = "../../sel4-sync/trivial" }
 
 [dependencies.smoltcp]
 version = "0.10.0"