fix(kernel): fix kill wait-queue cleanup, RegionId tracking, ReleasePages ownership, and SwitchTo scheduler state

crates/kernel/src/lib.rs

@@ -136,6 +136,31 @@ impl<P: Platform> Kernel<P> {
         self.processes.get(pid).is_ok()
     }
 
+    pub(crate) fn cleanup_threads(&mut self, thread_ids: &[Option<ThreadId>; 4]) {
+        use domain::scheduler::Scheduler;
+        for slot in thread_ids {
+            if let Some(tid) = slot {
+                self.endpoints.remove_thread_from_all(*tid);
+                self.cleanup_wait_any(*tid);
+                self.scheduler.remove(*tid);
+                self.pending_messages[tid.raw() as usize] = None;
+                self.pending_results[tid.raw() as usize] = None;
+                let _ = self.threads.destroy(*tid);
+            }
+        }
+    }
+
+    pub(crate) fn cleanup_wait_any(&mut self, tid: ThreadId) {
+        if let Some(wait_set) = self.wait_sets[tid.raw() as usize].take() {
+            for ep_slot in wait_set.endpoints() {
+                if let Some(_slot) = ep_slot {
+                    self.endpoints.remove_thread_from_all(tid);
+                    break;
+                }
+            }
+        }
+    }
+
     fn check_cap(
         &self,
         owner: ProcessId,

crates/kernel/src/syscall.rs

@@ -60,12 +60,7 @@ impl<P: Platform> Kernel<P> {
             }
         };
 
-        for slot in &thread_ids {
-            if let Some(tid) = slot {
-                self.scheduler.remove(*tid);
-                let _ = self.threads.destroy(*tid);
-            }
-        }
+        self.cleanup_threads(&thread_ids);
 
         let _ = self.processes.destroy(pid);
         self.process_memory[pid.raw() as usize] = None;
@@ -159,11 +154,22 @@ impl<P: Platform> Kernel<P> {
             count,
             types::generation::Generation::initial(),
         );
-        let _region_id = self.regions.insert(region);
+        let region_id = match self.regions.insert(region) {
+            Some(id) => id,
+            None => {
+                self.page_pool.free(addr, pages);
+                if let Some(pm) = &mut self.process_memory[pid.raw() as usize] {
+                    let _ = pm.release(pages);
+                }
+                return SyscallOutcome::Complete(SyscallResult::Error(
+                    domain::error::KernelError::OutOfMemory,
+                ));
+            }
+        };
 
         let slot = match self.grant_cap(
             pid,
-            domain::resource::Resource::Memory(types::id::RegionId::from_raw(0)),
+            domain::resource::Resource::Memory(region_id),
             types::permission::PermissionSet::empty()
                 .with(types::permission::Permission::Read)
                 .with(types::permission::Permission::Write),
@@ -184,12 +190,21 @@ impl<P: Platform> Kernel<P> {
         let pages = count.value() as usize;
         let phys = types::address::PhysicalAddress::from_raw(addr.raw());
 
+        let region_id = match self.regions.find_by_base(pid, phys) {
+            Some((rid, _)) => rid,
+            None => return SyscallOutcome::Complete(SyscallResult::Error(
+                domain::error::KernelError::OutOfMemory,
+            )),
+        };
+
         if !self.page_pool.free(phys, pages) {
             return SyscallOutcome::Complete(SyscallResult::Error(
                 domain::error::KernelError::OutOfMemory,
             ));
         }
 
+        let _ = self.regions.remove(region_id);
+
         if let Some(pm) = &mut self.process_memory[pid.raw() as usize] {
             let _ = pm.release(pages);
         }
@@ -315,12 +330,7 @@ impl<P: Platform> Kernel<P> {
             }
         };
 
-        for slot in &thread_ids {
-            if let Some(tid) = slot {
-                self.scheduler.remove(*tid);
-                let _ = self.threads.destroy(*tid);
-            }
-        }
+        self.cleanup_threads(&thread_ids);
 
         let _ = self.processes.destroy(target_pid);
         self.process_memory[target_pid.raw() as usize] = None;
@@ -409,14 +419,14 @@ impl<P: Platform> Kernel<P> {
             self.pending_results[receiver_tid.raw() as usize] =
                 Some(SyscallResult::Message(message));
 
+            let core = self.platform.core_id();
+
             let receiver = match self.threads.get_mut(receiver_tid) {
                 Ok(t) => t,
                 Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
             };
-            let priority = receiver.priority();
             let _ = receiver.unblock();
-            let core = self.platform.core_id();
-            self.scheduler.add(receiver_tid, priority, core);
+            let _ = receiver.set_running(core);
 
             let caller = match self.threads.get_mut(caller_tid) {
                 Ok(t) => t,
@@ -426,8 +436,7 @@ impl<P: Platform> Kernel<P> {
             let _ = caller.preempt();
             self.scheduler.add(caller_tid, caller_priority, core);
 
-            self.scheduler.next(core);
-            let _ = self.threads.get_mut(receiver_tid).map(|t| t.set_running(core));
+            self.scheduler.set_current(core, receiver_tid);
 
             SyscallOutcome::SwitchTo(receiver_tid)
         } else {