Implement event-driven UART coroutine

This fixes boot failure and CPU spinning issues in SMP mode through
hybrid polling strategy that dynamically switches between blocking and
non-blocking modes based on hart activity.
1. Event loop optimization
   - Observe hart states BEFORE resuming them
   - Set poll_timeout = -1 when all harts idle (event-driven)
   - Set poll_timeout = 0 when harts have work (polling)
   - Always resume harts unconditionally (avoid deadlock)
2. UART coroutine support
   - Hart yields when no stdin data available
   - Event loop resumes hart when stdin becomes readable
   - Spurious wakeup handling with state re-check
3. Coroutine state tracking
   - waiting_hart_id tracks which hart is waiting for UART
   - has_waiting_hart enables quick idle state check
   - Sentinel value (UINT32_MAX) for single-core fallback

Author: jserv

coro.c

@@ -607,5 +607,9 @@ bool coro_is_suspended(uint32_t slot_id)
 
 uint32_t coro_current_hart_id(void)
 {
+    /* Return sentinel value if coroutine subsystem not initialized */
+    if (!coro_state.initialized)
+        return UINT32_MAX;
+
     return coro_state.current_hart;
 }

device.h

@@ -60,6 +60,9 @@ typedef struct {
     /* I/O handling */
     int in_fd, out_fd;
     bool in_ready;
+    /* Coroutine support for input waiting (SMP mode) */
+    uint32_t waiting_hart_id; /**< Hart ID waiting for input */
+    bool has_waiting_hart;    /**< true if a hart is yielding for input */
 } u8250_state_t;
 
 void u8250_update_interrupts(u8250_state_t *uart);

main.c

@@ -768,6 +768,8 @@ static int semu_init(emu_state_t *emu, int argc, char **argv)
 
     /* Set up peripherals */
     emu->uart.in_fd = 0, emu->uart.out_fd = 1;
+    emu->uart.waiting_hart_id = UINT32_MAX;
+    emu->uart.has_waiting_hart = false;
     capture_keyboard_input(); /* set up uart */
 #if SEMU_HAS(VIRTIONET)
     /* Always set ram pointer, even if netdev is not configured.
@@ -1177,29 +1179,42 @@ static int semu_run(emu_state_t *emu)
                 pfd_count++;
             }
 
-            /* Determine poll timeout based on hart WFI states:
+            /* Determine poll timeout based on hart states BEFORE resuming them.
+             * This check must happen before coro_resume_hart() modifies flags.
+             *
              * - If no harts are STARTED, block indefinitely (wait for IPI)
-             * - If all STARTED harts are in WFI, block indefinitely
+             * - If all STARTED harts are idle (WFI or UART waiting), block
              * - Otherwise, use non-blocking poll (timeout=0)
              */
             int poll_timeout = 0;
             uint32_t started_harts = 0;
-            uint32_t wfi_harts = 0;
+            uint32_t idle_harts = 0;
             for (uint32_t i = 0; i < vm->n_hart; i++) {
                 if (vm->hart[i]->hsm_status == SBI_HSM_STATE_STARTED) {
                     started_harts++;
-                    if (vm->hart[i]->in_wfi)
-                        wfi_harts++;
+                    /* Count hart as idle if it's in WFI or waiting for UART */
+                    if (vm->hart[i]->in_wfi ||
+                        (emu->uart.has_waiting_hart &&
+                         emu->uart.waiting_hart_id == i)) {
+                        idle_harts++;
+                    }
                 }
             }
-            /* Block if no harts running or all running harts are waiting */
+
+            /* Set poll timeout based on current idle state.
+             * Block if no harts running or all running harts are idle.
+             */
             if (pfd_count > 0 &&
-                (started_harts == 0 || wfi_harts == started_harts))
-                poll_timeout = -1;
+                (started_harts == 0 || idle_harts == started_harts)) {
+                poll_timeout = -1; /* Blocking poll - wait for events */
+            } else {
+                poll_timeout = 0; /* Non-blocking poll - harts have work */
+            }
 
             /* Execute poll() to wait for I/O events.
-             * - timeout=0: non-blocking poll when harts are running
-             * - timeout=-1: blocking poll when all harts in WFI (idle state)
+             * - timeout=0: non-blocking poll when harts are active
+             * - timeout=-1: blocking poll when all harts idle (WFI or UART
+             * wait)
              */
             if (pfd_count > 0) {
                 int nevents = poll(pfds, pfd_count, poll_timeout);
@@ -1231,6 +1246,11 @@ static int semu_run(emu_state_t *emu)
              * Each hart executes a batch of instructions, then yields back.
              * Harts in WFI will clear their in_wfi flag when resuming from
              * coro_yield() in wfi_handler().
+             *
+             * Note: We must always resume harts after poll() returns, even if
+             * all harts appear idle. The in_wfi flag is only cleared during
+             * resume, so skipping resume would cause a deadlock where harts
+             * remain stuck waiting even after events arrive.
              */
             for (uint32_t i = 0; i < vm->n_hart; i++) {
                 coro_resume_hart(i);

uart.c

@@ -6,6 +6,7 @@
 #include <termios.h>
 #include <unistd.h>
 
+#include "coro.h"
 #include "device.h"
 #include "riscv.h"
 #include "riscv_private.h"
@@ -86,12 +87,45 @@ static void u8250_handle_out(u8250_state_t *uart, uint8_t value)
         fprintf(stderr, "failed to write UART output: %s\n", strerror(errno));
 }
 
+/* Wait for UART input using coroutine yield (SMP mode only)
+ * This function allows a hart to yield when no UART input is available,
+ * preventing CPU spinning when waiting for stdin. The hart will be resumed
+ * by the event loop when stdin becomes readable.
+ */
+static void u8250_wait_for_input(u8250_state_t *uart)
+{
+    /* Only yield in SMP mode - single-core mode doesn't use coroutines */
+    uint32_t hart_id = coro_current_hart_id();
+    if (hart_id == UINT32_MAX)
+        return; /* Not in a coroutine, skip yielding */
+
+    /* Mark this hart as waiting for UART input */
+    uart->waiting_hart_id = hart_id;
+    uart->has_waiting_hart = true;
+
+    /* Yield until stdin has data available. The event loop will resume this
+     * hart when poll() detects POLLIN on stdin fd.
+     */
+    coro_yield();
+
+    /* Resumed - clear waiting state */
+    uart->has_waiting_hart = false;
+    uart->waiting_hart_id = UINT32_MAX;
+}
+
 static uint8_t u8250_handle_in(u8250_state_t *uart)
 {
     uint8_t value = 0;
     u8250_check_ready(uart);
-    if (!uart->in_ready)
-        return value;
+
+    /* If no data available, yield and wait for stdin to become readable */
+    if (!uart->in_ready) {
+        u8250_wait_for_input(uart);
+        /* After resume, re-check if data is now available */
+        u8250_check_ready(uart);
+        if (!uart->in_ready)
+            return value; /* Spurious wakeup - still no data */
+    }
 
     if (read(uart->in_fd, &value, 1) < 0)
         fprintf(stderr, "failed to read UART input: %s\n", strerror(errno));