Add idle task and initialization API

This commit introduces the system idle task and its initialization API
(idle_task_init()). The idle task serves as the default execution
context when no other runnable tasks exist in the system.

The sched_idle() function supports both preemptive and cooperative
modes. In sched_t, a list node named task_idle is added to record the
idle task sentinel. The idle task never enters any ready queue and its
priority level cannot be changed.

When idle_task_init() is called, the idle task is initialized as the
first execution context. This eliminates the need for additional APIs
in main() to set up the initial high-priority task during system launch.
This design allows task priorities to be adjusted safely during
app_main(), while keeping the scheduler’s entry point consistent.

Author: vicLin8712

include/sys/task.h

@@ -120,6 +120,9 @@ typedef struct {
 
     /* Weighted Round-Robin State per Priority Level */
     list_node_t *rr_cursors[TASK_PRIORITY_LEVELS]; /* Round-robin position */
+
+    /* System idle task */
+    list_node_t task_idle;
 } kcb_t;
 
 /* Global pointer to the singleton Kernel Control Block */
@@ -304,5 +307,19 @@ void _sched_block(queue_t *wait_q);
  */
 int32_t app_main(void);
 
+/* Initialize the idle task
+ *
+ * This function statically creates and initializes the idle task structure.
+ * It should be called once during system startup.
+ *
+ * The idle task is a permanent system task that runs when no other
+ * ready tasks exist. It is never enqueued into any ready queue and
+ * cannot be suspended, canceled, or priority modified.
+ *
+ * Only one idle task exists per hart. Its priority is fixed to the
+ * lowest level and its time slice is zero.
+ */
+void idle_task_init(void);
+
 /* Wake up and enqueue task into ready queue */
 void sched_wakeup_task(tcb_t *);

kernel/task.c

@@ -460,6 +460,20 @@ void sched_wakeup_task(tcb_t *task)
         sched_enqueue_task(task);
 }
 
+/* System idle task, it will be executed when no ready tasks in ready queue */
+static void sched_idle(void)
+{
+    if (!kcb->preemptive)
+        /* Cooperative mode idle */
+        while (1)
+            mo_task_yield();
+
+    /* Preemptive mode idle */
+    while (1)
+        mo_task_wfi();
+}
+
+
 /* Efficient Round-Robin Task Selection with O(n) Complexity
  *
  * Selects the next ready task using circular traversal of the master task list.
@@ -627,6 +641,52 @@ static bool init_task_stack(tcb_t *tcb, size_t stack_size)
     return true;
 }
 
+/* Initialize idle task */
+void idle_task_init(void)
+{
+    /* Ensure proper alignment */
+    size_t stack_size = DEFAULT_STACK_SIZE;
+    stack_size = (stack_size + 0xF) & ~0xFU;
+
+    /* Allocate and initialize TCB */
+    tcb_t *idle = malloc(sizeof(tcb_t));
+    if (!idle)
+        panic(ERR_TCB_ALLOC);
+
+    idle->entry = &sched_idle;
+    idle->delay = 0;
+    idle->rt_prio = NULL;
+    idle->state = TASK_READY;
+    idle->flags = 0;
+
+    /* Set idle task priority */
+    idle->prio = TASK_PRIO_IDLE;
+    idle->prio_level = 0;
+    idle->time_slice = 0;
+
+    /* Set idle task id and task count */
+    idle->id = kcb->next_tid++;
+    kcb->task_count++;
+
+    /* Initialize stack */
+    if (!init_task_stack(idle, stack_size)) {
+        free(idle);
+        panic(ERR_STACK_ALLOC);
+    }
+
+    /* Bindin idle task into kcb */
+    kcb->task_idle.data = idle;
+
+    /* Initialize idle task execution context */
+    hal_context_init(&idle->context, (size_t) idle->stack, stack_size,
+                     (size_t) &sched_idle);
+
+    printf("idle id %u: entry=%p stack=%p size=%u\n", idle->id, &sched_idle,
+           idle->stack, (unsigned int) stack_size);
+
+    return;
+}
+
 /* Task Management API */
 
 int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)