IPC Core

Define kernel IPC objects for endpoints and notifications. Why it matters: These are the kernel objects through which all inter-process communication flows — endpoints for synchronous rendezvous, notifications for async signals. Focus on `Message` and `Endpoint` in `kernel/src/ipc/message.rs` while you trace the snippet.

/// A small, register-sized IPC message.
///
/// `label` identifies the operation (similar to a method selector in Mach or
/// a message tag in seL4).  `data` carries up to four 64-bit words of inline
/// payload — enough for most control operations.
///
/// Capability grants are deferred to Phase 7+.  For now, if a server needs to
/// share memory with a client it must use a pre-arranged shared address.
#[derive(Debug, Clone, Copy, Default)]
pub struct Message {
    /// Operation identifier, chosen by convention between sender and receiver.
    pub label: u64,
    /// Inline data payload — up to 4 machine words.
    pub data: [u64; 4],
}

View on GitHub

Add a per-process capability table with validation. Why it matters: Every IPC operation must go through capability validation — a process can only use handles it legitimately holds, preventing capability forgery. Focus on `CapabilityTable` and `CapHandle` in `kernel/src/ipc/capability.rs` while you trace the snippet.

/// Fixed-size per-process capability table (64 slots).
///
/// `None` means the slot is empty.  Slots are filled on [`insert`][Self::insert]
/// and cleared on [`remove`][Self::remove].
pub struct CapabilityTable {
    slots: [Option<Capability>; Self::SIZE],
}

View on GitHub

Implement blocking recv and send primitives. Why it matters: Synchronous IPC requires the ability to block the calling task until a partner arrives on the endpoint, then transfer the message and wake both sides. Focus on `recv_msg` and `send_msg` in `kernel/src/ipc/endpoint.rs` while you trace the snippet.

/// Receive a message from an endpoint.
///
/// If a sender is already waiting, dequeue it, wake it (if it used `send`
/// rather than `call`), copy its message, and return the message label.
/// If the endpoint is for a `call`, insert a reply capability into the
/// server's table instead of waking the sender immediately.
///
/// If no sender is waiting, the calling task blocks until one arrives.
///
/// Returns the message label on success, or `u64::MAX` on error.
pub fn recv(receiver: TaskId, ep_id: EndpointId) -> u64 {
    let action = {
        let mut reg = ENDPOINTS.lock();
        let ep = match reg.get_mut(ep_id) {
            Some(e) => e,
            None => return u64::MAX,
        };
        if let Some(pending) = ep.senders.pop_front() {
            Some(pending)
        } else {
            // No sender yet — enqueue self and block.
            ep.receivers.push_back(receiver);
            None
        }

View on GitHub