Add task termination infrastructure for fault handling

Implement deferred cleanup mechanism to safely terminate tasks that
encounter unrecoverable faults. Tasks cannot immediately free their own
resources since they execute on the stack being freed.

The solution uses a two-phase approach: when termination is requested,
the task is marked as suspended with a special flag indicating pending
cleanup, then yields to another task. After the context switch completes
and we're executing in a different context, the scheduler detects the
marked task and safely frees its resources.

This infrastructure enables graceful handling of PMP violations and
other unrecoverable task faults without panicking the entire system.

Author: HeatCrab

include/sys/task.h

@@ -44,6 +44,9 @@ enum task_states {
     TASK_SUSPENDED /* Task paused/excluded from scheduling until resumed */
 };
 
+/* Task Flags */
+#define TASK_FLAG_ZOMBIE 0x01 /* Task terminated, awaiting cleanup */
+
 /* Priority Level Constants for Priority-Aware Time Slicing */
 #define TASK_PRIORITY_LEVELS 8  /* Number of priority levels (0-7) */
 #define TASK_HIGHEST_PRIORITY 0 /* Highest priority level */
@@ -83,7 +86,7 @@ typedef struct tcb {
     uint16_t delay;     /* Ticks remaining for task in TASK_BLOCKED state */
     uint16_t id;        /* Unique task ID, assigned by kernel upon creation */
     uint8_t state;      /* Current lifecycle state (e.g., TASK_READY) */
-    uint8_t flags;      /* Task flags for future extensions (reserved) */
+    uint8_t flags;      /* Task flags (TASK_FLAG_ZOMBIE for deferred cleanup) */
 
     /* Real-time Scheduling Support */
     void *rt_prio; /* Opaque pointer for custom real-time scheduler hook */
@@ -281,6 +284,16 @@ uint64_t mo_uptime(void);
  */
 void _sched_block(queue_t *wait_q);
 
+/* Terminates the currently running task due to unrecoverable fault.
+ *
+ * Marks the current task as suspended and sets the zombie flag for deferred
+ * cleanup. Forces an immediate context switch to another task. The marked
+ * task's resources will be freed by the scheduler after the switch completes.
+ *
+ * This function does not return - execution continues in another task.
+ */
+void task_terminate_current(void) __attribute__((noreturn));
+
 /* Application Entry Point */
 
 /* The main entry point for the user application.

kernel/task.c

@@ -458,6 +458,48 @@ static int32_t noop_rtsched(void)
     return -1;
 }
 
+/* Helper to clean up zombie task resources from safe context */
+static void cleanup_zombie_task(tcb_t *zombie)
+{
+    if (!zombie || !(zombie->flags & TASK_FLAG_ZOMBIE))
+        return;
+
+    /* Find and remove task node from list */
+    CRITICAL_ENTER();
+
+    list_node_t *node = NULL;
+    list_node_t *iter = kcb->tasks->head;
+    while (iter) {
+        if (iter->data == zombie) {
+            node = iter;
+            break;
+        }
+        iter = iter->next;
+    }
+
+    if (node) {
+        list_remove(kcb->tasks, node);
+        kcb->task_count--;
+
+        /* Clear from cache */
+        for (int i = 0; i < TASK_CACHE_SIZE; i++) {
+            if (task_cache[i].task == zombie) {
+                task_cache[i].id = 0;
+                task_cache[i].task = NULL;
+            }
+        }
+    }
+
+    CRITICAL_LEAVE();
+
+    /* Free resources outside critical section */
+    if (zombie->mspace)
+        mo_memspace_destroy(zombie->mspace);
+
+    free(zombie->stack);
+    free(zombie);
+}
+
 /* The main entry point from the system tick interrupt. */
 void dispatcher(void)
 {
@@ -497,12 +539,17 @@ void dispatch(void)
     list_foreach(kcb->tasks, delay_update_batch, &ready_count);
 
     /* Save old task before scheduler modifies task_current */
-    memspace_t *old_mspace = ((tcb_t *) kcb->task_current->data)->mspace;
+    tcb_t *old_task = (tcb_t *)kcb->task_current->data;
+    memspace_t *old_mspace = old_task->mspace;
 
     /* Hook for real-time scheduler - if it selects a task, use it */
     if (kcb->rt_sched() < 0)
         sched_select_next_task(); /* Use O(1) priority scheduler */
 
+    /* Clean up zombie task from previous context switch */
+    if (old_task->flags & TASK_FLAG_ZOMBIE)
+        cleanup_zombie_task(old_task);
+
     hal_interrupt_tick();
 
     /* Switch PMP configuration if tasks have different memory spaces */
@@ -535,10 +582,15 @@ void yield(void)
         list_foreach(kcb->tasks, delay_update, NULL);
 
     /* Save old task before scheduler modifies task_current */
-    memspace_t *old_mspace = ((tcb_t *) kcb->task_current->data)->mspace;
+    tcb_t *old_task = (tcb_t *)kcb->task_current->data;
+    memspace_t *old_mspace = old_task->mspace;
 
     sched_select_next_task(); /* Use O(1) priority scheduler */
 
+    /* Clean up zombie task from previous context switch */
+    if (old_task->flags & TASK_FLAG_ZOMBIE)
+        cleanup_zombie_task(old_task);
+
     /* Switch PMP configuration if tasks have different memory spaces */
     memspace_t *new_mspace = ((tcb_t *) kcb->task_current->data)->mspace;
     pmp_switch_context(old_mspace, new_mspace);
@@ -714,6 +766,33 @@ int32_t mo_task_cancel(uint16_t id)
     return ERR_OK;
 }
 
+void task_terminate_current(void)
+{
+    NOSCHED_ENTER();
+
+    /* Verify we have a current task */
+    if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data)) {
+        NOSCHED_LEAVE();
+        panic(ERR_NO_TASKS);
+    }
+
+    tcb_t *self = kcb->task_current->data;
+
+    /* Mark as suspended to prevent re-scheduling */
+    self->state = TASK_SUSPENDED;
+
+    /* Set zombie flag for deferred cleanup */
+    self->flags |= TASK_FLAG_ZOMBIE;
+
+    NOSCHED_LEAVE();
+
+    /* Force immediate context switch - never returns */
+    _dispatch();
+
+    /* Unreachable */
+    __builtin_unreachable();
+}
+
 void mo_task_yield(void)
 {
     _yield();