Remove hart parking and add spinlock synchronization during boot for SMP

Remove the old logic that parks all secondary harts in WFI, which
caused them to hang indefinitely. Instead, all harts proceed with boot.

To ensure proper initialization sequence, hart 0 performs hardware
setup, heap initialization, and task creation. Other harts spin-wait on
a spinlock-protected flag until hart 0 finishes initialization before
starting task dispatch.

Author: visitorckw

arch/riscv/boot.c

@@ -70,10 +70,6 @@ __attribute__((naked, section(".text.prologue"))) void _entry(void)
         "csrw   mideleg, zero\n" /* No interrupt delegation to S-mode */
         "csrw   medeleg, zero\n" /* No exception delegation to S-mode */
 
-        /* Park secondary harts (cores) - only hart 0 continues */
-        "csrr   t0, mhartid\n"
-        "bnez   t0, .Lpark_hart\n"
-
         /* Set the machine trap vector (mtvec) to point to our ISR */
         "la     t0, _isr\n"
         "csrw   mtvec, t0\n"
@@ -87,15 +83,12 @@ __attribute__((naked, section(".text.prologue"))) void _entry(void)
         "csrw   mie, t0\n"
 
         /* Jump to the C-level main function */
+        "csrr   a0, mhartid\n"
         "call   main\n"
 
         /* If main() ever returns, it is a fatal error */
         "call   hal_panic\n"
 
-        ".Lpark_hart:\n"
-        "wfi\n"
-        "j      .Lpark_hart\n"
-
         : /* no outputs */
         : "i"(MSTATUS_MPP_MACH), "i"(MIE_MEIE), "i"(STACK_SIZE_PER_HART)
         : "memory");

kernel/main.c

@@ -1,9 +1,13 @@
 #include <hal.h>
+#include <spinlock.h>
 #include <lib/libc.h>
 #include <sys/task.h>
 
 #include "private/error.h"
 
+static volatile bool finish = false;
+static spinlock_t finish_lock = SPINLOCK_INITIALIZER;
+
 /* C-level entry point for the kernel.
  *
  * This function is called from the boot code ('_entry'). It is responsible for
@@ -12,21 +16,36 @@
  *
  * Under normal operation, this function never returns.
  */
-int32_t main(void)
+int32_t main(int32_t hartid)
 {
     /* Initialize hardware abstraction layer and memory heap. */
     hal_hardware_init();
 
-    printf("Linmo kernel is starting...\n");
+    if (hartid == 0) {
+        printf("Linmo kernel is starting...\n");
+
+        mo_heap_init((void *) &_heap_start, (size_t) &_heap_size);
+        printf("Heap initialized, %u bytes available\n",
+            (unsigned int) (size_t) &_heap_size);
+
+        /* Call the application's main entry point to create initial tasks. */
+        kcb->preemptive = (bool) app_main();
+        printf("Scheduler mode: %s\n",
+            kcb->preemptive ? "Preemptive" : "Cooperative");
 
-    mo_heap_init((void *) &_heap_start, (size_t) &_heap_size);
-    printf("Heap initialized, %u bytes available\n",
-           (unsigned int) (size_t) &_heap_size);
+        spin_lock(&finish_lock);
+        finish = true;
+        spin_unlock(&finish_lock);
+    }
 
-    /* Call the application's main entry point to create initial tasks. */
-    kcb->preemptive = (bool) app_main();
-    printf("Scheduler mode: %s\n",
-           kcb->preemptive ? "Preemptive" : "Cooperative");
+    /* Make sure hardware initialize before running the first task. */
+    while (1) {
+        spin_lock(&finish_lock);
+        if (finish)
+            break;
+        spin_unlock(&finish_lock);
+    }
+    spin_unlock(&finish_lock);
 
     /* Verify that the application created at least one task.
      * If 'kcb->task_current' is still NULL, it means mo_task_spawn was never
@@ -40,6 +59,8 @@ int32_t main(void)
      */
     setjmp(kcb->context);
 
+    spin_lock(&finish_lock);
+
     /* Launch the first task.
      * 'kcb->task_current' was set by the first call to mo_task_spawn.
      * This function transfers control and does not return.
@@ -48,6 +69,8 @@ int32_t main(void)
     if (!first_task)
         panic(ERR_NO_TASKS);
 
+    spin_unlock(&finish_lock);
+
     hal_dispatch_init(first_task->context);
 
     /* This line should be unreachable. */