Split out Microkit runtime from rest of Microkit API

Cargo.toml

@@ -104,6 +104,7 @@ members = [
     "crates/sel4-kernel-loader/payload-types",
     "crates/sel4-logging",
     "crates/sel4-microkit",
+    "crates/sel4-microkit/base",
     "crates/sel4-microkit/macros",
     "crates/sel4-microkit/message",
     "crates/sel4-microkit/message/types",

crates/private/tests/microkit/passive-server-with-deferred-action/pds/server/src/bin/server.rs

@@ -28,7 +28,7 @@ impl Handler for HandlerImpl {
     type Error = Infallible;
 
     fn notified(&mut self, _channel: Channel) -> Result<(), Self::Error> {
-        self.deferred_action.defer(CLIENT.defer_notify()).unwrap();
+        self.deferred_action.defer_notify(CLIENT).unwrap();
         Ok(())
     }
 

crates/sel4-initialize-tls/src/lib.rs

@@ -77,14 +77,15 @@ impl TlsImage {
         Layout::from_size_align(self.memsz, self.align).unwrap()
     }
 
+    #[allow(clippy::missing_safety_doc)]
     pub unsafe fn initialize_tls_reservation(&self, tls_reservation_start: *mut u8) {
         let reservation_layout = self.reservation_layout();
 
         let image_data_window = slice::from_raw_parts(self.vaddr as *mut u8, self.filesz);
 
         let segment_start =
             tls_reservation_start.wrapping_byte_add(reservation_layout.segment_offset());
-        let segment_window = slice::from_raw_parts_mut(segment_start as *mut u8, self.memsz);
+        let segment_window = slice::from_raw_parts_mut(segment_start, self.memsz);
         let (tdata, tbss) = segment_window.split_at_mut(self.filesz);
 
         tdata.copy_from_slice(image_data_window);

crates/sel4-microkit/Cargo.nix

@@ -11,14 +11,13 @@ mk {
   dependencies = {
     inherit (versions) cfg-if;
     inherit (localCrates)
-      sel4-panicking
-      sel4-panicking-env
       sel4-immediate-sync-once-cell
-      sel4-immutable-cell
+      sel4-panicking-env
+      sel4-panicking
       sel4-dlmalloc
       sel4-sync
+      sel4-microkit-base
       sel4-microkit-macros
-      sel4-externally-shared
     ;
     sel4-runtime-common = localCrates.sel4-runtime-common // { features = [ "tls" "unwinding" "start" ]; };
     sel4 = localCrates.sel4 // { features = [ "single-threaded" ]; };

crates/sel4-microkit/Cargo.toml

@@ -26,9 +26,8 @@ unwinding = ["sel4-panicking/unwinding"]
 cfg-if = "1.0.0"
 sel4 = { path = "../sel4", features = ["single-threaded"] }
 sel4-dlmalloc = { path = "../sel4-dlmalloc" }
-sel4-externally-shared = { path = "../sel4-externally-shared" }
 sel4-immediate-sync-once-cell = { path = "../sel4-immediate-sync-once-cell" }
-sel4-immutable-cell = { path = "../sel4-immutable-cell" }
+sel4-microkit-base = { path = "base" }
 sel4-microkit-macros = { path = "macros" }
 sel4-panicking = { path = "../sel4-panicking" }
 sel4-panicking-env = { path = "../sel4-panicking/env" }

crates/sel4-microkit/base/Cargo.nix

@@ -0,0 +1,20 @@
+#
+# Copyright 2023, Colias Group, LLC
+#
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+{ mk, localCrates }:
+
+mk {
+  package.name = "sel4-microkit-base";
+  dependencies = {
+    inherit (localCrates)
+      sel4-immutable-cell
+      sel4
+    ;
+  };
+  features = {
+    extern-symbols = [];
+  };
+}

crates/sel4-microkit/base/Cargo.toml

@@ -0,0 +1,24 @@
+#
+# 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-microkit-base"
+version = "0.1.0"
+authors = ["Nick Spinale <[email protected]>"]
+edition = "2021"
+license = "BSD-2-Clause"
+
+[features]
+extern-symbols = []
+
+[dependencies]
+sel4 = { path = "../../sel4" }
+sel4-immutable-cell = { path = "../../sel4-immutable-cell" }

crates/sel4-microkit/base/src/channel.rs

@@ -0,0 +1,81 @@
+//
+// Copyright 2023, Colias Group, LLC
+//
+// SPDX-License-Identifier: BSD-2-Clause
+//
+
+use core::fmt;
+
+use crate::MessageInfo;
+
+const BASE_OUTPUT_NOTIFICATION_SLOT: usize = 10;
+const BASE_ENDPOINT_SLOT: usize = BASE_OUTPUT_NOTIFICATION_SLOT + 64;
+const BASE_IRQ_SLOT: usize = BASE_ENDPOINT_SLOT + 64;
+
+const MAX_CHANNELS: usize = 63;
+
+/// A channel between this protection domain and another, identified by a channel index.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct Channel {
+    index: usize,
+}
+
+impl Channel {
+    pub const fn new(index: usize) -> Self {
+        assert!(index < MAX_CHANNELS);
+        Self { index }
+    }
+
+    fn cap<T: sel4::CapType>(&self, base_slot: usize) -> sel4::Cap<T> {
+        sel4::Cap::from_bits((base_slot + self.index) as sel4::CPtrBits)
+    }
+
+    #[doc(hidden)]
+    pub fn notification(&self) -> sel4::Notification {
+        self.cap::<sel4::cap_type::Notification>(BASE_OUTPUT_NOTIFICATION_SLOT)
+    }
+
+    #[doc(hidden)]
+    pub fn irq_handler(&self) -> sel4::IrqHandler {
+        self.cap::<sel4::cap_type::IrqHandler>(BASE_IRQ_SLOT)
+    }
+
+    #[doc(hidden)]
+    pub fn endpoint(&self) -> sel4::Endpoint {
+        self.cap::<sel4::cap_type::Endpoint>(BASE_ENDPOINT_SLOT)
+    }
+
+    pub fn notify(&self) {
+        self.notification().signal()
+    }
+
+    pub fn irq_ack(&self) -> Result<(), IrqAckError> {
+        self.irq_handler()
+            .irq_handler_ack()
+            .map_err(IrqAckError::from_inner)
+    }
+
+    pub fn pp_call(&self, msg_info: MessageInfo) -> MessageInfo {
+        MessageInfo::from_inner(self.endpoint().call(msg_info.into_inner()))
+    }
+}
+
+/// Error type returned by [`Channel::irq_ack`].
+#[derive(Debug, PartialEq, Eq)]
+pub struct IrqAckError(sel4::Error);
+
+impl IrqAckError {
+    fn from_inner(inner: sel4::Error) -> Self {
+        Self(inner)
+    }
+
+    fn inner(&self) -> &sel4::Error {
+        &self.0
+    }
+}
+
+impl fmt::Display for IrqAckError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "irq ack error: {:?}", self.inner())
+    }
+}

crates/sel4-microkit/base/src/lib.rs

@@ -0,0 +1,25 @@
+//
+// Copyright 2024, Colias Group, LLC
+//
+// SPDX-License-Identifier: BSD-2-Clause
+//
+
+#![no_std]
+#![feature(used_with_arg)]
+
+mod channel;
+mod message;
+mod symbols;
+
+pub use channel::{Channel, IrqAckError};
+pub use message::{
+    get_mr, set_mr, with_msg_bytes, with_msg_bytes_mut, with_msg_regs, with_msg_regs_mut,
+    MessageInfo, MessageLabel, MessageRegisterValue,
+};
+pub use symbols::{ipc_buffer_ptr, pd_is_passive, pd_name};
+
+// For macros
+#[doc(hidden)]
+pub mod _private {
+    pub use sel4_immutable_cell::ImmutableCell;
+}

crates/sel4-microkit/src/message.rs → crates/sel4-microkit/base/src/message.rs

@@ -4,8 +4,6 @@
 // SPDX-License-Identifier: BSD-2-Clause
 //
 
-//! Utilities for handling IPC messages for protected procedure calls.
-
 pub type MessageLabel = sel4::Word;
 pub type MessageRegisterValue = sel4::Word;
 
@@ -15,16 +13,18 @@ pub struct MessageInfo {
 }
 
 impl MessageInfo {
-    pub(crate) fn from_sel4(inner: sel4::MessageInfo) -> Self {
+    #[doc(hidden)]
+    pub fn from_inner(inner: sel4::MessageInfo) -> Self {
         Self { inner }
     }
 
-    pub(crate) fn into_sel4(self) -> sel4::MessageInfo {
+    #[doc(hidden)]
+    pub fn into_inner(self) -> sel4::MessageInfo {
         self.inner
     }
 
     pub fn new(label: MessageLabel, count: usize) -> Self {
-        Self::from_sel4(sel4::MessageInfo::new(label, 0, 0, count))
+        Self::from_inner(sel4::MessageInfo::new(label, 0, 0, count))
     }
 
     pub fn label(&self) -> MessageLabel {