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

@@ -325,7 +325,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

@@ -61,6 +61,8 @@ typedef struct {
     void *rt_prio; /* Opaque pointer for a custom real-time scheduler hook. */
 } tcb_t;
 
+#define MAX_HARTS 8
+
 /* Kernel Control Block (KCB)
  *
  * A singleton structure that holds the global state of the kernel, including
@@ -69,7 +71,7 @@ typedef struct {
 typedef struct {
     /* Task Management */
     list_t *tasks; /* The master list of all tasks (nodes contain tcb_t). */
-    list_node_t *task_current; /* Node of the currently running task. */
+    list_node_t *task_current[MAX_HARTS]; /* Node of the currently running task. */
     /* Saved context of the main kernel thread before scheduling starts. */
     jmp_buf context;
     uint16_t next_tid; /* Monotonically increasing ID for the next new task. */
@@ -113,6 +115,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;
+}
+
 /* Prints a fatal error message and halts the system. */
 void panic(int32_t ecode);
 

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

@@ -47,10 +47,10 @@ static list_node_t *find_node_by_data(list_t *list, void *data)
  */
 static void mutex_block_atomic(list_t *waiters)
 {
-    if (!waiters || !kcb || !kcb->task_current || !kcb->task_current->data)
+    if (!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 (!list_pushback(waiters, self))
@@ -198,7 +198,7 @@ int32_t mo_mutex_timedlock(mutex_t *m, uint32_t ticks)
     }
 
     /* Must block with timeout */
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
     if (!list_pushback(m->waiters, self)) {
         spin_unlock_irqrestore(&mutex_lock, mutex_flags);
         panic(ERR_SEM_OPERATION);
@@ -353,7 +353,7 @@ int32_t mo_cond_wait(cond_t *c, mutex_t *m)
 
     /* Atomically add to wait list and block */
     spin_lock_irqsave(&mutex_lock, &mutex_flags);
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
     if (!list_pushback(c->waiters, self)) {
         spin_unlock_irqrestore(&mutex_lock, mutex_flags);
         panic(ERR_SEM_OPERATION);
@@ -399,7 +399,7 @@ int32_t mo_cond_timedwait(cond_t *c, mutex_t *m, uint32_t ticks)
 
     /* Atomically add to wait list */
     spin_lock_irqsave(&mutex_lock, &mutex_flags);
-    tcb_t *self = kcb->task_current->data;
+    tcb_t *self = get_task_current()->data;
     if (!list_pushback(c->waiters, self)) {
         spin_unlock_irqrestore(&mutex_lock, mutex_flags);
         panic(ERR_SEM_OPERATION);

kernel/task.c

@@ -23,7 +23,7 @@ void _timer_tick_handler(void);
  */
 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 */
@@ -85,10 +85,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);
 
@@ -205,7 +205,7 @@ void _yield(void) __attribute__((weak, alias("yield")));
 /* Scheduler with hint-based ready task search */
 static list_node_t *find_next_ready_task(void)
 {
-    if (unlikely(!kcb->task_current))
+    if (unlikely(!get_task_current()))
         return NULL;
 
     list_node_t *node;
@@ -225,7 +225,7 @@ static list_node_t *find_next_ready_task(void)
         }
     }
 
-    node = kcb->task_current;
+    node = get_task_current();
     while (itcnt++ < SCHED_IMAX) {
         node = list_cnext(kcb->tasks, node);
         if (unlikely(!node || !node->data))
@@ -258,11 +258,11 @@ static list_node_t *find_next_ready_task(void)
 /* Scheduler with reduced overhead */
 static uint16_t schedule_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);
 
     /* Mark the previously running task as ready for the next cycle. */
-    tcb_t *current_task = kcb->task_current->data;
+    tcb_t *current_task = get_task_current()->data;
     if (current_task->state == TASK_RUNNING)
         current_task->state = TASK_READY;
 
@@ -273,7 +273,7 @@ static uint16_t schedule_next_task(void)
     }
 
     /* Update scheduler state */
-    kcb->task_current = next_node;
+    set_task_current(next_node);
     tcb_t *next_task = next_node->data;
     next_task->state = TASK_RUNNING;
 
@@ -297,11 +297,11 @@ 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);
 
     /* Return from longjmp: context is restored, continue task execution. */
-    if (setjmp(((tcb_t *) kcb->task_current->data)->context) != 0)
+    if (setjmp(((tcb_t *) get_task_current()->data)->context) != 0)
         return;
 
     task_stack_check();
@@ -313,16 +313,16 @@ void dispatch(void)
     }
 
     hal_interrupt_tick();
-    longjmp(((tcb_t *) kcb->task_current->data)->context, 1);
+    longjmp(((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;
 
-    if (setjmp(((tcb_t *) kcb->task_current->data)->context) != 0)
+    if (setjmp(((tcb_t *) get_task_current()->data)->context) != 0)
         return;
 
     task_stack_check();
@@ -332,7 +332,7 @@ void yield(void)
         list_foreach(kcb->tasks, delay_update, NULL);
 
     schedule_next_task();
-    longjmp(((tcb_t *) kcb->task_current->data)->context, 1);
+    longjmp(((tcb_t *) get_task_current()->data)->context, 1);
 }
 
 /* Stack initialization with minimal overhead */
@@ -411,8 +411,8 @@ int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)
     tcb->id = kcb->next_tid++;
     kcb->task_count++;
 
-    if (!kcb->task_current)
-        kcb->task_current = node;
+    if (!get_task_current())
+        set_task_current(node);
 
     spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
@@ -483,12 +483,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;
     self->delay = ticks;
     self->state = TASK_BLOCKED;
     spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
@@ -516,7 +516,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);
 
     /* Clear ready hint if suspending that task */
     if (kcb->last_ready_hint == node)
@@ -603,9 +603,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)
@@ -647,11 +647,11 @@ 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);
 
-    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);