refactor(kernel): split syscall.rs into per-tier modules (simple, memory, lifecycle, capability, ipc)

crates/kernel/src/syscall/capability.rs

@@ -0,0 +1,46 @@
+use platform::Platform;
+
+use crate::{Kernel, SyscallOutcome, SyscallResult};
+
+impl<P: Platform> Kernel<P> {
+    pub(crate) fn handle_delegate(
+        &mut self,
+        caller_pid: types::id::ProcessId,
+        slot: types::bounded::CapSlot,
+        to_endpoint: types::bounded::CapSlot,
+        restrict: types::permission::PermissionSet,
+    ) -> SyscallOutcome {
+        let (resource, permissions) = match self.check_cap(
+            caller_pid,
+            slot,
+            types::permission::Permission::Delegate,
+        ) {
+            Ok(cap) => (cap.resource().clone(), *cap.permissions()),
+            Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
+        };
+
+        let restricted = permissions.restrict_to(&restrict);
+
+        let target_pid = match self.check_cap(
+            caller_pid,
+            to_endpoint,
+            types::permission::Permission::Execute,
+        ) {
+            Ok(cap) => match cap.resource() {
+                domain::resource::Resource::Process(pid) => *pid,
+                _ => return SyscallOutcome::Complete(SyscallResult::Error(
+                    domain::error::KernelError::PermissionDenied {
+                        slot: to_endpoint,
+                        needed: types::permission::Permission::Execute,
+                    },
+                )),
+            },
+            Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
+        };
+
+        match self.grant_cap(target_pid, resource, restricted) {
+            Ok(_) => SyscallOutcome::Complete(SyscallResult::Ok),
+            Err(e) => SyscallOutcome::Complete(SyscallResult::Error(e)),
+        }
+    }
+}