Move task_lock spinlock into kcb struct

The task_lock spinlock was primarily used to protect access to the
Kernel Control Block (kcb) and its internal data structures. Move the
spinlock into the kcb_t struct as kcb_lock, consolidating related
state and synchronization primitives together.

All uses of the standalone task_lock spinlock are replaced by
kcb->kcb_lock accesses, improving code clarity and encapsulation of the
kernel's core control block.

Author: visitorckw

include/sys/task.h

@@ -13,6 +13,7 @@
  */
 
 #include <hal.h>
+#include <spinlock.h>
 #include <lib/list.h>
 #include <lib/queue.h>
 
@@ -104,6 +105,9 @@ typedef struct {
     /* Timer Management */
     list_t *timer_list;      /* List of active software timers */
     volatile uint32_t ticks; /* Global system tick, incremented by timer */
+    /* Timers */
+
+    spinlock_t kcb_lock;
 } kcb_t;
 
 /* Global pointer to the singleton Kernel Control Block */

kernel/task.c

@@ -26,6 +26,7 @@ static kcb_t kernel_state = {
     .task_count = 0,
     .ticks = 0,
     .preemptive = true, /* Default to preemptive mode */
+    .kcb_lock = SPINLOCK_INITIALIZER,
 };
 kcb_t *kcb = &kernel_state;
 
@@ -107,7 +108,6 @@ static inline uint8_t extract_priority_level(uint16_t prio)
         return 4; /* Default to normal priority */
     }
 }
-static spinlock_t task_lock = SPINLOCK_INITIALIZER;
 static uint32_t task_flags = 0;
 
 static inline bool is_valid_task(tcb_t *task)
@@ -594,12 +594,12 @@ int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)
     }
 
     /* Minimize critical section duration */
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
 
     if (!kcb->tasks) {
         kcb->tasks = list_create();
         if (!kcb->tasks) {
-            spin_unlock_irqrestore(&task_lock, task_flags);
+            spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
             free(tcb->stack);
             free(tcb);
             panic(ERR_KCB_ALLOC);
@@ -608,7 +608,7 @@ int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)
 
     list_node_t *node = list_pushback(kcb->tasks, tcb);
     if (!node) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         free(tcb->stack);
         free(tcb);
         panic(ERR_TCB_ALLOC);
@@ -621,7 +621,7 @@ int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)
     if (!kcb->task_current)
         kcb->task_current = node;
 
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
     /* Initialize execution context outside critical section. */
     hal_context_init(&tcb->context, (size_t) tcb->stack, new_stack_size,
@@ -643,16 +643,16 @@ int32_t mo_task_cancel(uint16_t id)
     if (id == 0 || id == mo_task_id())
         return ERR_TASK_CANT_REMOVE;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     list_node_t *node = find_task_node_by_id(id);
     if (!node) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
     tcb_t *tcb = node->data;
     if (!tcb || tcb->state == TASK_RUNNING) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_CANT_REMOVE;
     }
 
@@ -668,7 +668,7 @@ int32_t mo_task_cancel(uint16_t id)
         }
     }
 
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
     /* Free memory outside critical section */
     free(tcb->stack);
@@ -690,9 +690,9 @@ void mo_task_delay(uint16_t ticks)
     if (!ticks)
         return;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     if (unlikely(!kcb || !kcb->task_current || !kcb->task_current->data)) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return;
     }
 
@@ -701,7 +701,7 @@ void mo_task_delay(uint16_t ticks)
     /* Set delay and blocked state - scheduler will skip blocked tasks */
     self->delay = ticks;
     self->state = TASK_BLOCKED;
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
     mo_task_yield();
 }
@@ -711,24 +711,24 @@ int32_t mo_task_suspend(uint16_t id)
     if (id == 0)
         return ERR_TASK_NOT_FOUND;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     list_node_t *node = find_task_node_by_id(id);
     if (!node) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
     tcb_t *task = node->data;
     if (!task || (task->state != TASK_READY && task->state != TASK_RUNNING &&
                   task->state != TASK_BLOCKED)) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_CANT_SUSPEND;
     }
 
     task->state = TASK_SUSPENDED;
     bool is_current = (kcb->task_current == node);
 
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
     if (is_current)
         mo_task_yield();
@@ -741,22 +741,22 @@ int32_t mo_task_resume(uint16_t id)
     if (id == 0)
         return ERR_TASK_NOT_FOUND;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     list_node_t *node = find_task_node_by_id(id);
     if (!node) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
     tcb_t *task = node->data;
     if (!task || task->state != TASK_SUSPENDED) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_CANT_RESUME;
     }
 
     /* mark as ready - scheduler will find it */
     task->state = TASK_READY;
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
     return ERR_OK;
 }
 
@@ -765,16 +765,16 @@ int32_t mo_task_priority(uint16_t id, uint16_t priority)
     if (id == 0 || !is_valid_priority(priority))
         return ERR_TASK_INVALID_PRIO;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     list_node_t *node = find_task_node_by_id(id);
     if (!node) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
     tcb_t *task = node->data;
     if (!task) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
@@ -783,7 +783,7 @@ int32_t mo_task_priority(uint16_t id, uint16_t priority)
     task->prio_level = extract_priority_level(priority);
     task->time_slice = get_priority_timeslice(task->prio_level);
 
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
     return ERR_OK;
 }
@@ -793,21 +793,21 @@ int32_t mo_task_rt_priority(uint16_t id, void *priority)
     if (id == 0)
         return ERR_TASK_NOT_FOUND;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     list_node_t *node = find_task_node_by_id(id);
     if (!node) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
     tcb_t *task = node->data;
     if (!task) {
-        spin_unlock_irqrestore(&task_lock, task_flags);
+        spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
         return ERR_TASK_NOT_FOUND;
     }
 
     task->rt_prio = priority;
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
     return ERR_OK;
 }
 
@@ -823,9 +823,9 @@ int32_t mo_task_idref(void *task_entry)
     if (!task_entry || !kcb->tasks)
         return ERR_TASK_NOT_FOUND;
 
-    spin_lock_irqsave(&task_lock, &task_flags);
+    spin_lock_irqsave(&kcb->kcb_lock, &task_flags);
     list_node_t *node = list_foreach(kcb->tasks, refcmp, task_entry);
-    spin_unlock_irqrestore(&task_lock, task_flags);
+    spin_unlock_irqrestore(&kcb->kcb_lock, task_flags);
 
     return node ? ((tcb_t *) node->data)->id : ERR_TASK_NOT_FOUND;
 }