Use per-hart current task pointer in KCB

Previously, only a single global pointer tracked the current running
task, which worked for single-core systems. To support SMP, change the
Kernel Control Block (KCB) to maintain an array of current task
pointers, one per hart.

Added get_task_current() and set_task_current() helper functions to
retrieve and update the current task for the executing hart.

Modify kernel and HAL code to use these new functions instead of the
single global current task pointer, ensuring correct task tracking on
each hart.

Author: visitorckw

arch/riscv/hal.c

@@ -320,7 +320,7 @@ void hal_timer_disable(void)
  */
 void hal_interrupt_tick(void)
 {
-    tcb_t *task = kcb->task_current->data;
+    tcb_t *task = get_task_current(kcb)->data;
     if (unlikely(!task))
         hal_panic(); /* Fatal error - invalid task state */
 

include/sys/task.h

@@ -85,6 +85,8 @@ typedef struct tcb {
     void *rt_prio; /* Opaque pointer for custom real-time scheduler hook */
 } tcb_t;
 
+#define MAX_HARTS 8
+
 /* Kernel Control Block (KCB)
  *
  * Singleton structure holding global kernel state, including task lists,
@@ -93,7 +95,7 @@ typedef struct tcb {
 typedef struct {
     /* Task Management */
     list_t *tasks; /* Master list of all tasks (nodes contain tcb_t) */
-    list_node_t *task_current; /* Node of currently running task */
+    list_node_t *task_current[MAX_HARTS]; /* Node of currently running task */
     jmp_buf context; /* Saved context of main kernel thread before scheduling */
     uint16_t next_tid;   /* Monotonically increasing ID for next new task */
     uint16_t task_count; /* Cached count of active tasks for quick access */
@@ -123,6 +125,20 @@ extern kcb_t *kcb;
 
 /* Core Kernel and Task Management API */
 
+static inline list_node_t *get_task_current()
+{
+    const uint32_t mhartid = read_csr(mhartid);
+
+    return kcb->task_current[mhartid];
+}
+
+static inline void set_task_current(list_node_t *task)
+{
+    const uint32_t mhartid = read_csr(mhartid);
+
+    kcb->task_current[mhartid] = task;
+}
+
 /* System Control Functions */
 
 /* Prints a fatal error message and halts the system */

kernel/main.c

@@ -56,10 +56,10 @@ int32_t main(int32_t hartid)
     mo_task_spawn(idle_task, DEFAULT_STACK_SIZE);
 
     /* Verify that the application created at least one task.
-     * If 'kcb->task_current' is still NULL, it means mo_task_spawn was never
+     * If 'get_task_current()' is still NULL, it means mo_task_spawn was never
      * successfully called.
      */
-    if (!kcb->task_current)
+    if (!get_task_current())
         panic(ERR_NO_TASKS);
 
     /* Save the kernel's context. This is a formality to establish a base
@@ -70,10 +70,11 @@ int32_t main(int32_t hartid)
     spin_lock(&finish_lock);
 
     /* Launch the first task.
-     * 'kcb->task_current' was set by the first call to mo_task_spawn.
+     * 'get_task_current()' was set by the first call to mo_task_spawn.
      * This function transfers control and does not return.
      */
-    tcb_t *first_task = kcb->task_current->data;
+
+    tcb_t *first_task = get_task_current()->data;
     if (!first_task)
         panic(ERR_NO_TASKS);
 

kernel/mutex.c

@@ -49,11 +49,11 @@ static inline void cond_invalidate(cond_t *c)
  */
 static bool remove_self_from_waiters(list_t *waiters)
 {
-    if (unlikely(!waiters || !kcb || !kcb->task_current ||
-                 !kcb->task_current->data))
+    if (unlikely(!waiters || !kcb || !get_task_current() ||
+                 !get_task_current()->data))
         return false;
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
 
     /* Search for and remove self from waiters list */
     list_node_t *curr = waiters->head->next;
@@ -71,11 +71,11 @@ static bool remove_self_from_waiters(list_t *waiters)
 /* Atomic block operation with enhanced error checking */
 static void mutex_block_atomic(list_t *waiters)
 {
-    if (unlikely(!waiters || !kcb || !kcb->task_current ||
-                 !kcb->task_current->data))
+    if (unlikely(!waiters || !kcb || !get_task_current() ||
+                 !get_task_current()->data))
         panic(ERR_SEM_OPERATION);
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
 
     /* Add to waiters list */
     if (unlikely(!list_pushback(waiters, self)))
@@ -223,7 +223,7 @@ int32_t mo_mutex_timedlock(mutex_t *m, uint32_t ticks)
     }
 
     /* Slow path: must block with timeout using delay mechanism */
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
     if (unlikely(!list_pushback(m->waiters, self))) {
         spin_unlock_irqrestore(&mutex_lock, mutex_flags);
         panic(ERR_SEM_OPERATION);
@@ -384,7 +384,7 @@ int32_t mo_cond_wait(cond_t *c, mutex_t *m)
     if (unlikely(!mo_mutex_owned_by_current(m)))
         return ERR_NOT_OWNER;
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
 
     /* Atomically add to wait list */
     spin_lock_irqsave(&mutex_lock, &mutex_flags);
@@ -426,7 +426,7 @@ int32_t mo_cond_timedwait(cond_t *c, mutex_t *m, uint32_t ticks)
         return ERR_TIMEOUT;
     }
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
 
     /* Atomically add to wait list with timeout */
     spin_lock_irqsave(&mutex_lock, &mutex_flags);

kernel/task.c

@@ -19,7 +19,7 @@ void _timer_tick_handler(void);
 /* Kernel-wide control block (KCB) */
 static kcb_t kernel_state = {
     .tasks = NULL,
-    .task_current = NULL,
+    .task_current = {},
     .rt_sched = noop_rtsched,
     .timer_list = NULL, /* Managed by timer.c, but stored here. */
     .next_tid = 1,      /* Start from 1 to avoid confusion with invalid ID 0 */
@@ -145,10 +145,10 @@ static void task_stack_check(void)
     if (!should_check)
         return;
 
-    if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data))
+    if (unlikely(!kcb || !get_task_current() || !get_task_current()->data))
         panic(ERR_STACK_CHECK);
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
     if (unlikely(!is_valid_task(self)))
         panic(ERR_STACK_CHECK);
 
@@ -366,10 +366,10 @@ void sched_dequeue_task(tcb_t *task)
 /* Handle time slice expiration for current task */
 void sched_tick_current_task(void)
 {
-    if (unlikely(!kcb->task_current || !kcb->task_current->data))
+    if (unlikely(!get_task_current() || !get_task_current()->data))
         return;
 
-    tcb_t *current_task = kcb->task_current->data;
+    tcb_t *current_task = get_task_current()->data;
 
     /* Decrement time slice */
     if (current_task->time_slice > 0)
@@ -414,17 +414,17 @@ void sched_wakeup_task(tcb_t *task)
  */
 uint16_t sched_select_next_task(void)
 {
-    if (unlikely(!kcb->task_current || !kcb->task_current->data))
+    if (unlikely(!get_task_current() || !get_task_current()->data))
         panic(ERR_NO_TASKS);
 
-    tcb_t *current_task = kcb->task_current->data;
+    tcb_t *current_task = get_task_current()->data;
 
     /* Mark current task as ready if it was running */
     if (current_task->state == TASK_RUNNING)
         current_task->state = TASK_READY;
 
     /* Round-robin search: find next ready task in the master task list */
-    list_node_t *start_node = kcb->task_current;
+    list_node_t *start_node = get_task_current();
     list_node_t *node = start_node;
     int iterations = 0; /* Safety counter to prevent infinite loops */
 
@@ -441,7 +441,7 @@ uint16_t sched_select_next_task(void)
             continue;
 
         /* Found a ready task */
-        kcb->task_current = node;
+        get_task_current() = node;
         task->state = TASK_RUNNING;
         task->time_slice = get_priority_timeslice(task->prio_level);
 
@@ -478,14 +478,14 @@ void dispatcher(void)
 /* Top-level context-switch for preemptive scheduling. */
 void dispatch(void)
 {
-    if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data))
+    if (unlikely(!kcb || !get_task_current() || !get_task_current()->data))
         panic(ERR_NO_TASKS);
 
     /* Save current context using dedicated HAL routine that handles both
      * execution context and processor state for context switching.
      * Returns immediately if this is the restore path.
      */
-    if (hal_context_save(((tcb_t *) kcb->task_current->data)->context) != 0)
+    if (hal_context_save(((tcb_t *) get_task_current()->data)->context) != 0)
         return;
 
 #if CONFIG_STACK_PROTECTION
@@ -505,20 +505,20 @@ void dispatch(void)
     hal_interrupt_tick();
 
     /* Restore next task context */
-    hal_context_restore(((tcb_t *) kcb->task_current->data)->context, 1);
+    hal_context_restore(((tcb_t *) get_task_current()->data)->context, 1);
 }
 
 /* Cooperative context switch */
 void yield(void)
 {
-    if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data))
+    if (unlikely(!kcb || !get_task_current() || !get_task_current()->data))
         return;
 
     /* Process deferred timer work during yield */
     process_deferred_timer_work();
 
     /* HAL context switching is used for preemptive scheduling. */
-    if (hal_context_save(((tcb_t *) kcb->task_current->data)->context) != 0)
+    if (hal_context_save(((tcb_t *) get_task_current()->data)->context) != 0)
         return;
 
 #if CONFIG_STACK_PROTECTION
@@ -530,7 +530,7 @@ void yield(void)
         list_foreach(kcb->tasks, delay_update, NULL);
 
     sched_select_next_task(); /* Use O(1) priority scheduler */
-    hal_context_restore(((tcb_t *) kcb->task_current->data)->context, 1);
+    hal_context_restore(((tcb_t *) get_task_current()->data)->context, 1);
 }
 
 /* Stack initialization with minimal overhead */
@@ -618,8 +618,8 @@ int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)
     tcb->id = kcb->next_tid++;
     kcb->task_count++; /* Cached count of active tasks for quick access */
 
-    if (!kcb->task_current)
-        kcb->task_current = node;
+    if (!get_task_current())
+        set_task_current(node);
 
     spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
@@ -691,12 +691,12 @@ void mo_task_delay(uint16_t ticks)
         return;
 
     spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
-    if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data)) {
+    if (unlikely(!kcb || !get_task_current() || !get_task_current()->data)) {
         spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return;
     }
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
 
     /* Set delay and blocked state - scheduler will skip blocked tasks */
     self->delay = ticks;
@@ -726,7 +726,7 @@ int32_t mo_task_suspend(uint16_t id)
     }
 
     task->state = TASK_SUSPENDED;
-    bool is_current = (kcb->task_current == node);
+    bool is_current = (get_task_current() == node);
 
     spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
@@ -813,9 +813,9 @@ int32_t mo_task_rt_priority(uint16_t id, void *priority)
 
 uint16_t mo_task_id(void)
 {
-    if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data))
+    if (unlikely(!kcb || !get_task_current() || !get_task_current()->data))
         return 0;
-    return ((tcb_t *) kcb->task_current->data)->id;
+    return ((tcb_t *) get_task_current()->data)->id;
 }
 
 int32_t mo_task_idref(void *task_entry)
@@ -860,14 +860,14 @@ uint64_t mo_uptime(void)
 
 void _sched_block(queue_t *wait_q)
 {
-    if (unlikely(!wait_q || !kcb || !kcb->task_current ||
-                 !kcb->task_current->data))
+    if (unlikely(!wait_q || !kcb || !get_task_current() ||
+                 !get_task_current()->data))
         panic(ERR_SEM_OPERATION);
 
     /* Process deferred timer work before blocking */
     process_deferred_timer_work();
 
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
 
     if (queue_enqueue(wait_q, self) != 0)
         panic(ERR_SEM_OPERATION);