Add task termination infrastructure

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 zombie flag indicating pending
cleanup, then yields to another task. The scheduler detects zombie tasks
during task selection and safely frees their resources from a different
task's context.

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

@@ -395,6 +395,48 @@ void sched_wakeup_task(tcb_t *task)
     }
 }
 
+/* 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);
+}
+
 /* Efficient Round-Robin Task Selection with O(n) Complexity
  *
  * Selects the next ready task using circular traversal of the master task list.
@@ -417,6 +459,16 @@ uint16_t sched_select_next_task(void)
 
     tcb_t *current_task = kcb->task_current->data;
 
+    /* Clean up current task if it's a zombie before proceeding */
+    if (current_task->flags & TASK_FLAG_ZOMBIE) {
+        cleanup_zombie_task(current_task);
+        /* After cleanup, move to first real task to start fresh search */
+        kcb->task_current = kcb->tasks->head->next;
+        if (!kcb->task_current || !kcb->task_current->data)
+            panic(ERR_NO_TASKS);
+        current_task = kcb->task_current->data;
+    }
+
     /* Mark current task as ready if it was running */
     if (current_task->state == TASK_RUNNING)
         current_task->state = TASK_READY;
@@ -434,6 +486,16 @@ uint16_t sched_select_next_task(void)
 
         tcb_t *task = node->data;
 
+        /* Clean up zombie tasks during scheduling */
+        if (task->flags & TASK_FLAG_ZOMBIE) {
+            list_node_t *next_node = list_cnext(kcb->tasks, node);
+            cleanup_zombie_task(task);
+            node = next_node ? next_node : kcb->tasks->head;
+            if (!node || !node->data)
+                continue;
+            task = node->data;
+        }
+
         /* Skip non-ready tasks */
         if (task->state != TASK_READY)
             continue;
@@ -458,6 +520,7 @@ static int32_t noop_rtsched(void)
     return -1;
 }
 
+
 /* The main entry point from the system tick interrupt. */
 void dispatcher(void)
 {
@@ -496,8 +559,9 @@ void dispatch(void)
     uint32_t ready_count = 0;
     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;
+    /* Save old task's memory space for PMP context switching */
+    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)
@@ -534,8 +598,9 @@ void yield(void)
     if (!kcb->preemptive)
         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;
+    /* Save old task's memory space for PMP context switching */
+    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 */
 
@@ -714,6 +779,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();