feat(kernel): seL4-style IPC, notifications, status ABI

- badges + Mint, Call/Reply/ReplyRecv w/ gen-checked reply slot
- cap transfer (1/msg, copy, needs Delegate, rechecked at delivery)
- notifications: signal/wait/poll/bind, irq -> notification routing
- WaitAny/WaitForInterrupt removed; a0=status, ErrorCode
- libkos: single ecall primitive, compat wrappers + typed new api
- fix: trap return clobbered user t0 on every trap
- fix: wait queues FIFO, delegate keeps badge, fault cap checked
- docs/ipc.md spec, ipc tests, ipc fuzz, kani ntfn + waitqueue

crates/domain/src/irq/tests.rs

@@ -1,50 +1,43 @@
 use super::*;
-use types::id::{IrqId, ThreadId};
+use types::badge::Badge;
+use types::generation::Generation;
+use types::id::{IrqId, NotificationId};
 
-fn irq(id: u16) -> IrqId {
-    IrqId::from_raw(id)
-}
-
-fn thread(id: u16) -> ThreadId {
-    ThreadId::from_raw(id)
+fn route(n: u16) -> IrqRoute {
+    IrqRoute {
+        notification: NotificationId::from_raw(n),
+        generation: Generation::initial(),
+        badge: Badge::new(1 << n),
+    }
 }
 
 #[test]
-fn new_table_has_no_owners() {
-    let table = IrqRoutingTable::new();
-    assert!(table.owner(irq(0)).is_none());
-    assert!(table.owner(irq(10)).is_none());
+fn new_table_routes_nothing() {
+    let t = IrqRoutingTable::new();
+    assert_eq!(t.route(IrqId::from_raw(10)), None);
 }
 
 #[test]
-fn register_and_lookup() {
-    let mut table = IrqRoutingTable::new();
-    table.register(irq(5), thread(1)).unwrap();
-    assert_eq!(table.owner(irq(5)), Some(thread(1)));
+fn set_then_route() {
+    let mut t = IrqRoutingTable::new();
+    assert!(t.set(IrqId::from_raw(10), route(3)));
+    assert_eq!(t.route(IrqId::from_raw(10)), Some(route(3)));
 }
 
 #[test]
-fn register_already_owned_fails() {
-    let mut table = IrqRoutingTable::new();
-    table.register(irq(5), thread(1)).unwrap();
-    assert!(table.register(irq(5), thread(2)).is_err());
+fn set_replaces_and_clear_removes() {
+    let mut t = IrqRoutingTable::new();
+    t.set(IrqId::from_raw(10), route(3));
+    t.set(IrqId::from_raw(10), route(4));
+    assert_eq!(t.route(IrqId::from_raw(10)), Some(route(4)));
+    t.clear(IrqId::from_raw(10));
+    assert_eq!(t.route(IrqId::from_raw(10)), None);
 }
 
 #[test]
-fn unregister_then_reregister() {
-    let mut table = IrqRoutingTable::new();
-    table.register(irq(5), thread(1)).unwrap();
-    table.unregister(irq(5));
-    assert!(table.owner(irq(5)).is_none());
-    table.register(irq(5), thread(2)).unwrap();
-    assert_eq!(table.owner(irq(5)), Some(thread(2)));
-}
-
-#[test]
-fn different_irqs_independent() {
-    let mut table = IrqRoutingTable::new();
-    table.register(irq(0), thread(10)).unwrap();
-    table.register(irq(1), thread(20)).unwrap();
-    assert_eq!(table.owner(irq(0)), Some(thread(10)));
-    assert_eq!(table.owner(irq(1)), Some(thread(20)));
+fn lines_beyond_the_table_are_rejected_without_panicking() {
+    let mut t = IrqRoutingTable::new();
+    assert!(!t.set(IrqId::from_raw(1000), route(1)));
+    assert_eq!(t.route(IrqId::from_raw(1000)), None);
+    t.clear(IrqId::from_raw(1000));
 }