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

@@ -95,8 +95,8 @@ typedef struct sched {
     list_node_t *rr_cursors[TASK_PRIORITY_LEVELS]; /* Round-robin position */
 
     /* Hart-Specific Data */
-    uint8_t hart_id; /* RISC-V hart identifier */
-
+    uint8_t hart_id;        /* RISC-V hart identifier */
+    list_node_t *task_idle; /* Idle task */
 } sched_t;
 
 /* Kernel Control Block (KCB)
@@ -303,3 +303,17 @@ void _sched_block(queue_t *wait_q);
  * Returns 'true' to enable preemptive scheduling, or 'false' for cooperative
  */
 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);

kernel/task.c

@@ -21,6 +21,7 @@ static sched_t hart0 = {
     .ready_queues = {NULL},
     .rr_cursors = {NULL},
     .hart_id = 0,
+    .task_idle = NULL,
 };
 
 /* Kernel-wide control block (KCB) */
@@ -463,6 +464,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 (Cursor-Based, O(1) Complexity)
  *
  * Selects the next ready task by advancing the per-priority round-robin
@@ -621,6 +636,63 @@ 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);
+    }
+
+    /* Allocate and initialize idle task node */
+    list_node_t *idle_task_node = malloc(sizeof(list_node_t));
+    if (!idle_task_node) {
+        free(idle->stack);
+        free(idle);
+        panic(ERR_STACK_ALLOC);
+    }
+    idle_task_node->data = idle;
+    idle_task_node->next = NULL;
+    kcb->harts->task_idle = idle_task_node;
+
+    /* 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);
+
+    if (!kcb->task_current)
+        kcb->task_current = kcb->harts->task_idle;
+
+    return;
+}
+
 /* Task Management API */
 
 int32_t mo_task_spawn(void *task_entry, uint16_t stack_size_req)