Deshab-OS/CODE/linux/initramfs/bin/utsm_exec_daemon.c

// SPDX-License-Identifier: GPL-2.0
/*
 * utsm_exec_daemon — Linux guest side exec daemon for Deshab Linux compat layer.
 *
 * Runs as the first userspace process (PID 2, after init) in the Linux guest.
 * Communicates with UTSM via /dev/utsm ioctl interface:
 *
 *   1. Send EXEC_READY, then ioctl(PARK) → HLT → guest parks
 *      (this is the first HLT; linux_launch() returns to UTSM)
 *   2. On vmresume: ioctl(RECV_MSG) → EXEC_REQUEST
 *   3. fork + exec the requested program, capture stdout/stderr via pipe
 *   4. Stream output back via ioctl(SEND_MSG, EXEC_STDOUT/STDERR)
 *   5. Send EXEC_EXIT with waitpid exit code
 *   6. Loop: ioctl(PARK) → wait for next request
 *
 * Build: static musl/glibc binary, stripped, copied into initramfs /bin/.
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <dirent.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <sched.h>
#include <poll.h>

/* Shared IPC protocol — must match UTSM side */
#include "../../../utsm-ipc/ipc_proto.h"

/* Ioctl definitions — must match utsm_hcall.c driver */
#define UTSM_IOCTL_RECV_MSG  _IOWR('U', 1, struct utsm_ioctl_msg)
#define UTSM_IOCTL_SEND_MSG  _IOWR('U', 2, struct utsm_ioctl_msg)
#define UTSM_IOCTL_PARK      _IO('U', 3)
#define UTSM_IOCTL_GET_READY _IOR('U', 4, int)
#define UTSM_IOCTL_WRITE_POOL _IOW('U', 5, struct utsm_ioctl_pool)
#define UTSM_IOCTL_READ_POOL  _IOWR('U', 6, struct utsm_ioctl_pool)

struct utsm_ioctl_msg {
    unsigned int type;
    unsigned int data_len;
    unsigned int reserved;
    unsigned int buf_size;
    unsigned char data[UTSM_IPC_MSG_DATA_SIZE];
};

/* Pool transfer descriptor — must match utsm_hcall.c driver */
struct utsm_ioctl_pool {
    unsigned int offset;
    unsigned int len;
    unsigned long long user_buf;
};

static int g_utsm_fd = -1;
static volatile sig_atomic_t g_async_live;

/* pool_write 定义在文件传输段（下文），exec 同步路径复用同一通道 */
static int pool_write(unsigned int offset, const void *buf, unsigned int len);
static int send_msg(unsigned int type, const void *data, unsigned int len);
static void err_write(const char *s, unsigned int len);

/* ===== exec 超时看门狗（P3 补完） =====
 * park-and-resume 模型下 UTSM 在 guest 运行期间完全不执行，宿主侧无法
 * 看门狗。子进程超时必须 guest 内兜底：alarm + SIGALRM → SIGKILL，
 * 保证 daemon 在 UTSM_EXEC_TIMEOUT_SEC 内一定 park，整系统不冻结。 */
static volatile sig_atomic_t g_exec_timed_out = 0;
static volatile sig_atomic_t g_exec_child = -1;

static void on_exec_alarm(int sig)
{
    (void)sig;
    g_exec_timed_out = 1;
    if (g_exec_child > 0)
        kill((pid_t)g_exec_child, SIGKILL);
}

/* EXEC_EXIT 必须送达：ring 满（-EAGAIN）时短暂重试。新协议下 stdout
 * 走 payload_pool，ring 内通常只有这一条消息，满的概率极低。 */
static void send_exit_msg(const struct ipc_exec_exit *ex)
{
    for (int t = 0; t < 200; t++) {
        if (send_msg(UTSM_MSG_EXEC_EXIT, ex, sizeof(*ex)) == 0)
            return;
        usleep(1000);
    }
    err_write("utsm_exec_daemon: EXEC_EXIT send failed (ring full)\n", 52);
}

/* Send a typed message to UTSM via the linux_to_utsm ring */
static int send_msg(unsigned int type, const void *data, unsigned int len)
{
    struct utsm_ioctl_msg umsg;
    memset(&umsg, 0, sizeof(umsg));
    umsg.type = type;
    umsg.data_len = len;
    umsg.buf_size = UTSM_IPC_MSG_DATA_SIZE;
    if (data && len > 0) {
        if (len > UTSM_IPC_MSG_DATA_SIZE)
            len = UTSM_IPC_MSG_DATA_SIZE;
        memcpy(umsg.data, data, len);
        umsg.data_len = len;
    }
    return ioctl(g_utsm_fd, UTSM_IOCTL_SEND_MSG, &umsg);
}

/* Receive a message from UTSM (non-blocking). Returns 0 on success, -EAGAIN if empty. */
static int recv_msg(struct utsm_ioctl_msg *umsg)
{
    memset(umsg, 0, sizeof(*umsg));
    umsg->buf_size = UTSM_IPC_MSG_DATA_SIZE;
    return ioctl(g_utsm_fd, UTSM_IOCTL_RECV_MSG, umsg);
}

/* Park: HLT → VM-Exit → UTSM parks guest. Returns on vmresume. */
static int park(void)
{
    return ioctl(g_utsm_fd, UTSM_IOCTL_PARK);
}

/* Best-effort write to the child's stderr (exec failure path);
 * the result is intentionally ignored. */
static void err_write(const char *s, unsigned int len)
{
    ssize_t n = write(STDERR_FILENO, s, len);
    (void)n;
}

static void kmsg_write(const char *s)
{
    int fd;
    if (!s) return;
    fd = open("/dev/kmsg", O_WRONLY | O_CLOEXEC);
    if (fd < 0) return;
    (void)write(fd, s, strlen(s));
    close(fd);
}

static int path_needs_deshab_libs(const char *path)
{
    if (!path || !path[0])
        return 0;
    if (strstr(path, "deshab-kde-session"))
        return 0;
    if (strstr(path, "/bin/sh") || strstr(path, "/bin/bash") ||
        strstr(path, "/usr/bin/bash") || strstr(path, "/usr/bin/env"))
        return 0;
    return 1;
}

/* Nested TSC is often marked unstable, so usleep() returns immediately
 * and async children never run on the only vCPU. A yield loop also
 * starves D-state I/O: PID 1 stays runnable and idle never runs.
 * poll(POLLIN, 10ms) on /dev/utsm sleeps interruptibly so Plasma/session
 * and virtio completions can run. Driver poll does not wait-queue, so
 * a new EXEC_REQUEST is seen at the next timeout. */
static void donate_cpu(void)
{
    struct pollfd pfd;

    memset(&pfd, 0, sizeof(pfd));
    pfd.fd = g_utsm_fd;
    pfd.events = POLLIN;
    if (poll(&pfd, 1, 10) < 0) {
        unsigned i;
        for (i = 0; i < 64u; i++)
            sched_yield();
    }
}

/* ===== Exec request handler =====
 *
 * Fork a child to exec the requested program. Parent reads stdout/stderr
 * from a pipe and streams chunks back to UTSM via EXEC_STDOUT/EXEC_STDERR
 * messages. Finally sends EXEC_EXIT with the child's exit status.
 *
 * argv parsing: argv_blob contains NUL-terminated argv[0..argc-1]
 * concatenated. We split it into a char* array for execv. */
static void handle_exec_request(const struct ipc_exec_request *req)
{
    /* Parse argv_blob into argv[] array */
    char *argv[UTSM_EXEC_MAX_ARGS + 1];
    int argc = (int)req->argc;
    if (argc > UTSM_EXEC_MAX_ARGS) argc = UTSM_EXEC_MAX_ARGS;
    if (argc < 1) {
        struct ipc_exec_exit ex = { .exit_code = 1, .flags = 0,
                                    .stdout_len = 0, .stdout_total = 0 };
        send_exit_msg(&ex);
        return;
    }

    const char *blob = req->argv_blob;
    int blob_consumed = 0;
    for (int i = 0; i < argc; i++) {
        if (blob_consumed >= UTSM_EXEC_ARGV_MAX) {
            argv[i] = (char *)"";
            continue;
        }
        argv[i] = (char *)(blob + blob_consumed);
        int slen = strnlen(blob + blob_consumed, UTSM_EXEC_ARGV_MAX - blob_consumed);
        blob_consumed += slen + 1;
    }
    argv[argc] = NULL;

    /* VSCode Phase 5: ASYNC launch path.
     * The caller (desktop IDE attach / app icon) wants to start a long-running
     * GUI program (X server, VSCode) without blocking the UTSM side for its
     * whole lifetime. We fork, detach the child into its own session with
     * stdio routed to /dev/null, reply EXEC_EXIT(0) immediately (0 = spawned
     * ok), and never waitpid — SIGCHLD is SIG_IGN so the kernel reaps it. */
    if (req->flags & UTSM_EXEC_FLAG_ASYNC) {
        pid_t pid = fork();
        if (pid < 0) {
            struct ipc_exec_exit ex = { .exit_code = 127, .flags = 0,
                                        .stdout_len = 0, .stdout_total = 0 };
            send_exit_msg(&ex);
            return;
        }
        if (pid == 0) {
            char line[192];
            /* Child: new session, no controlling tty, stdio → /dev/null */
            setsid();
            int nullfd = open("/dev/null", O_RDWR);
            if (nullfd >= 0) {
                dup2(nullfd, STDIN_FILENO);
                dup2(nullfd, STDOUT_FILENO);
                dup2(nullfd, STDERR_FILENO);
                if (nullfd > STDERR_FILENO) close(nullfd);
            }
            /* DISPLAY 指向 virtio-gpu X server。不要把 LD_LIBRARY_PATH
             * 套到 bash/session：/usr/lib/deshab 会劫持 glibc。 */
            if (path_needs_deshab_libs(req->path))
                setenv("LD_LIBRARY_PATH", "/usr/lib/deshab", 1);
            setenv("DISPLAY", ":0", 1);
            snprintf(line, sizeof(line),
                     "[deshab-kde] async exec %s\n", req->path);
            kmsg_write(line);
            execv(req->path, argv);
            snprintf(line, sizeof(line),
                     "[deshab-kde] execv failed errno=%d path=%s\n",
                     errno, req->path);
            kmsg_write(line);
            _exit(127);  /* execv 仅失败时返回 */
        }
        /* Parent: report successful spawn immediately */
        g_async_live = 1;
        {
            char line[128];
            snprintf(line, sizeof(line),
                     "[deshab-kde] async spawn pid=%d\n", (int)pid);
            kmsg_write(line);
        }
        struct ipc_exec_exit ex = { .exit_code = 0, .flags = 0,
                                    .stdout_len = 0, .stdout_total = 0 };
        send_exit_msg(&ex);
        return;
    }

    /* Create a pipe for child stdout+stderr */
    int pipefd[2];
    if (pipe(pipefd) != 0) {
        struct ipc_exec_exit ex = { .exit_code = 126, .flags = 0,
                                    .stdout_len = 0, .stdout_total = 0 };
        send_exit_msg(&ex);
        return;
    }

    pid_t pid = fork();
    if (pid < 0) {
        /* fork failed */
        close(pipefd[0]);
        close(pipefd[1]);
        struct ipc_exec_exit ex = { .exit_code = 127, .flags = 0,
                                    .stdout_len = 0, .stdout_total = 0 };
        send_exit_msg(&ex);
        return;
    }

    if (pid == 0) {
        /* Child: redirect stdout + stderr to pipe write end, then exec */
        close(pipefd[0]);
        dup2(pipefd[1], STDOUT_FILENO);
        dup2(pipefd[1], STDERR_FILENO);
        close(pipefd[1]);

        if (path_needs_deshab_libs(req->path))
            setenv("LD_LIBRARY_PATH", "/usr/lib/deshab", 1);

        execv(req->path, argv);
        /* execv only returns on failure */
        const char *err1 = "utsm_exec_daemon: exec failed: ";
        err_write(err1, (unsigned int)strlen(err1));
        err_write(req->path, (unsigned int)strnlen(req->path, UTSM_EXEC_PATH_MAX));
        const char *err2 = ": ";
        err_write(err2, (unsigned int)strlen(err2));
        const char *emsg = strerror(errno);
        err_write(emsg, (unsigned int)strlen(emsg));
        err_write("\n", 1);
        _exit(127);
    }

    /* Parent: read child output from pipe, stage into payload_pool.
     * P3 大输出改造：旧路径逐条 EXEC_STDOUT 入 ring（64 槽 × 240B ≈ 15KB，
     * 满则 -EAGAIN 静默丢弃）；现直写 payload_pool（~1MB），EXEC_EXIT
     * 携带 stdout_len/stdout_total，UTSM 侧按新协议从 pool 拷出。 */
    close(pipefd[1]);

    /* 安装超时看门狗：UTSM_EXEC_TIMEOUT_SEC 内子进程不退 → SIGKILL。
     * 不设 SA_RESTART：SIGALRM 中断 read(EINTR)，随后子进程死亡 pipe EOF。 */
    g_exec_timed_out = 0;
    g_exec_child = pid;
    {
        struct sigaction sa;
        memset(&sa, 0, sizeof(sa));
        sa.sa_handler = on_exec_alarm;
        sigemptyset(&sa.sa_mask);
        sigaction(SIGALRM, &sa, NULL);
        alarm(UTSM_EXEC_TIMEOUT_SEC);
    }

    char buf[4096];
    unsigned int pool_off = 0;
    unsigned int total = 0;
    int truncated = 0;
    ssize_t n;
    for (;;) {
        n = read(pipefd[0], buf, sizeof(buf));
        if (n > 0) {
            total += (unsigned int)n;
            if (!truncated) {
                unsigned int room = (pool_off < UTSM_IPC_PAYLOAD_SIZE)
                                    ? (UTSM_IPC_PAYLOAD_SIZE - pool_off) : 0;
                unsigned int chunk = ((unsigned int)n < room) ? (unsigned int)n : room;
                if (chunk > 0) {
                    if (pool_write(pool_off, buf, chunk) != 0) {
                        /* pool 写入失败：后续输出全部丢弃，记截断 */
                        truncated = 1;
                    } else {
                        pool_off += chunk;
                    }
                }
                if (chunk < (unsigned int)n)
                    truncated = 1;
            }
            continue;
        }
        if (n < 0 && errno == EINTR)
            continue;  /* SIGALRM 打断；子进程已被 SIGKILL，下轮 EOF */
        break;         /* EOF 或真实错误 */
    }
    close(pipefd[0]);

    /* Wait for child and send exit code */
    int status = 0;
    waitpid(pid, &status, 0);
    alarm(0);
    g_exec_child = -1;

    struct ipc_exec_exit ex;
    ex.flags = UTSM_EXEC_EXIT_F_POOL;
    ex.stdout_len = pool_off;
    ex.stdout_total = total;
    if (truncated)
        ex.flags |= UTSM_EXEC_EXIT_F_TRUNC;
    if (g_exec_timed_out) {
        ex.flags |= UTSM_EXEC_EXIT_F_TIMEOUT;
        ex.exit_code = 124;  /* GNU timeout 惯例 */
    } else if (WIFEXITED(status)) {
        ex.exit_code = (unsigned int)WEXITSTATUS(status);
    } else if (WIFSIGNALED(status)) {
        ex.exit_code = 128u + (unsigned int)WTERMSIG(status);
    } else {
        ex.exit_code = 1;
    }
    send_exit_msg(&ex);
}

/* ===== File transfer handlers (Phase 3) =====
 *
 * UTSM sends FILE_LIST_REQUEST / FILE_READ_REQUEST with an ipc_file_request
 * payload. Bulk result data is staged into the shared payload_pool via
 * UTSM_IOCTL_WRITE_POOL, then a FILE_RESPONSE message (ipc_file_response)
 * carries status + data_len + total_size back to UTSM.
 *
 * Directory listing format: one entry per line, directories suffixed '/'. */

/* Staging buffer for file reads / listings (capped by pool capacity ~1MB) */
#define FT_STAGE_SIZE (768 * 1024)
static unsigned char g_ft_stage[FT_STAGE_SIZE];

static int pool_write(unsigned int offset, const void *buf, unsigned int len)
{
    struct utsm_ioctl_pool p;
    p.offset = offset;
    p.len = len;
    p.user_buf = (unsigned long long)(uintptr_t)buf;
    return ioctl(g_utsm_fd, UTSM_IOCTL_WRITE_POOL, &p);
}

static int pool_read(unsigned int offset, void *buf, unsigned int len)
{
    struct utsm_ioctl_pool p;
    p.offset = offset;
    p.len = len;
    p.user_buf = (unsigned long long)(uintptr_t)buf;
    return ioctl(g_utsm_fd, UTSM_IOCTL_READ_POOL, &p);
}

static unsigned int errno_to_file_status(int e)
{
    switch (e) {
    case ENOENT:  return UTSM_FILE_ERR_NOENT;
    case ENOTDIR: return UTSM_FILE_ERR_NOTDIR;
    case EISDIR:  return UTSM_FILE_ERR_ISDIR;
    case EACCES:  return UTSM_FILE_ERR_PERM;
    case ENOSPC:
    case EFBIG:   return UTSM_FILE_ERR_NOSPC;
    default:      return UTSM_FILE_ERR_IO;
    }
}

static void send_file_response(unsigned int status, unsigned int data_len,
                               unsigned long long total_size)
{
    struct ipc_file_response resp;
    memset(&resp, 0, sizeof(resp));
    resp.status = status;
    resp.data_len = data_len;
    resp.total_size = total_size;
    send_msg(UTSM_MSG_FILE_RESPONSE, &resp, sizeof(resp));
}

/* FILE_LIST_REQUEST: list directory entries as "name\n" ("name/\n" for dirs) */
static void handle_file_list(const struct ipc_file_request *req)
{
    char path[UTSM_FILE_PATH_MAX + 1];
    memcpy(path, req->path, UTSM_FILE_PATH_MAX);
    path[UTSM_FILE_PATH_MAX] = '\0';

    if (req->pool_capacity == 0 || req->pool_offset >= UTSM_IPC_PAYLOAD_SIZE) {
        send_file_response(UTSM_FILE_ERR_INVAL, 0, 0);
        return;
    }

    DIR *d = opendir(path);
    if (!d) {
        send_file_response(errno_to_file_status(errno), 0, 0);
        return;
    }

    unsigned int cap = req->pool_capacity;
    if (cap > FT_STAGE_SIZE) cap = FT_STAGE_SIZE;

    unsigned int used = 0;
    struct dirent *de;
    while ((de = readdir(d)) != NULL) {
        if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
            continue;
        /* Determine directory flag: d_type if available, else stat */
        int is_dir = 0;
        if (de->d_type == DT_DIR) {
            is_dir = 1;
        } else if (de->d_type == DT_UNKNOWN || de->d_type == DT_LNK) {
            struct stat st;
            char full[512];
            snprintf(full, sizeof(full), "%s/%s", path, de->d_name);
            if (stat(full, &st) == 0 && S_ISDIR(st.st_mode))
                is_dir = 1;
        }
        int nl = snprintf((char *)g_ft_stage + used, cap - used,
                          "%s%s\n", de->d_name, is_dir ? "/" : "");
        if (nl < 0) break;
        if ((unsigned int)nl >= cap - used) {
            /* 缓冲已满：本条未完整写入，截断结束 */
            used = cap;
            break;
        }
        used += (unsigned int)nl;
    }
    closedir(d);

    if (used > 0 && pool_write(req->pool_offset, g_ft_stage, used) != 0) {
        send_file_response(UTSM_FILE_ERR_IO, 0, 0);
        return;
    }
    send_file_response(UTSM_FILE_OK, used, 0);
}

/* FILE_READ_REQUEST: read up to pool_capacity bytes at file_offset */
static void handle_file_read(const struct ipc_file_request *req)
{
    char path[UTSM_FILE_PATH_MAX + 1];
    memcpy(path, req->path, UTSM_FILE_PATH_MAX);
    path[UTSM_FILE_PATH_MAX] = '\0';

    if (req->pool_capacity == 0 || req->pool_offset >= UTSM_IPC_PAYLOAD_SIZE) {
        send_file_response(UTSM_FILE_ERR_INVAL, 0, 0);
        return;
    }

    struct stat st;
    if (stat(path, &st) != 0) {
        send_file_response(errno_to_file_status(errno), 0, 0);
        return;
    }
    if (S_ISDIR(st.st_mode)) {
        send_file_response(UTSM_FILE_ERR_ISDIR, 0, (unsigned long long)st.st_size);
        return;
    }

    int fd = open(path, O_RDONLY);
    if (fd < 0) {
        send_file_response(errno_to_file_status(errno), 0,
                           (unsigned long long)st.st_size);
        return;
    }

    unsigned int cap = req->pool_capacity;
    if (cap > FT_STAGE_SIZE) cap = FT_STAGE_SIZE;

    off_t off = (off_t)req->file_offset;
    ssize_t n = pread(fd, g_ft_stage, cap, off);
    int saved = errno;
    close(fd);

    if (n < 0) {
        send_file_response(errno_to_file_status(saved), 0,
                           (unsigned long long)st.st_size);
        return;
    }

    if (n > 0 && pool_write(req->pool_offset, g_ft_stage, (unsigned int)n) != 0) {
        send_file_response(UTSM_FILE_ERR_IO, 0, (unsigned long long)st.st_size);
        return;
    }
    send_file_response(UTSM_FILE_OK, (unsigned int)n,
                       (unsigned long long)st.st_size);
}

/* FILE_WRITE_REQUEST: write payload_pool data to file at file_offset.
 * UTSM pre-stages req->pool_capacity bytes at req->pool_offset in the pool.
 * Convention: file_offset == 0 truncates the file first (push = replace);
 * the file is created with mode 0644 if missing. Data is moved in
 * FT_STAGE_SIZE pieces so a full pool (~1MB) can be consumed per request. */
static void handle_file_write(const struct ipc_file_request *req)
{
    char path[UTSM_FILE_PATH_MAX + 1];
    memcpy(path, req->path, UTSM_FILE_PATH_MAX);
    path[UTSM_FILE_PATH_MAX] = '\0';

    if (req->pool_offset >= UTSM_IPC_PAYLOAD_SIZE ||
        req->pool_capacity > UTSM_IPC_PAYLOAD_SIZE - req->pool_offset) {
        send_file_response(UTSM_FILE_ERR_INVAL, 0, 0);
        return;
    }

    struct stat st;
    if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
        send_file_response(UTSM_FILE_ERR_ISDIR, 0, 0);
        return;
    }

    int flags = O_WRONLY | O_CREAT;
    if (req->file_offset == 0)
        flags |= O_TRUNC;
    int fd = open(path, flags, 0644);
    if (fd < 0) {
        send_file_response(errno_to_file_status(errno), 0, 0);
        return;
    }

    unsigned int remaining = req->pool_capacity;
    unsigned int done = 0;
    while (remaining > 0) {
        unsigned int chunk = remaining;
        if (chunk > FT_STAGE_SIZE) chunk = FT_STAGE_SIZE;

        if (pool_read(req->pool_offset + done, g_ft_stage, chunk) != 0) {
            close(fd);
            send_file_response(UTSM_FILE_ERR_IO, 0, 0);
            return;
        }
        ssize_t n = pwrite(fd, g_ft_stage, chunk,
                           (off_t)(req->file_offset + done));
        if (n < 0) {
            int saved = errno;
            close(fd);
            send_file_response(errno_to_file_status(saved), done, 0);
            return;
        }
        done += (unsigned int)n;
        remaining -= (unsigned int)n;
        if ((unsigned int)n < chunk)
            break;  /* short write (e.g. ENOSPC on next call would fail) */
    }

    unsigned long long total = 0;
    if (fstat(fd, &st) == 0)
        total = (unsigned long long)st.st_size;
    close(fd);
    send_file_response(UTSM_FILE_OK, done, total);
}

/* ===== Main loop ===== */

int main(void)
{
    /* ASYNC children (VSCode Phase 5: X server / VSCode) are never waitpid'd;
     * SIG_IGN lets the kernel reap them automatically so they don't zombie. */
    signal(SIGCHLD, SIG_IGN);

    g_utsm_fd = open("/dev/utsm", O_RDWR);
    if (g_utsm_fd < 0) {
        /* Cannot communicate with UTSM — exit */
        return 1;
    }

    /* Announce daemon ready. UTSM's linux_launch() will see the subsequent
     * HLT (via PARK ioctl) and return, marking the compat layer ready. */
    send_msg(UTSM_MSG_EXEC_READY, NULL, 0);

    /* First park: this is the HLT that causes linux_launch() to return. */
    park();

    /* Main loop: process exec requests */
    for (;;) {
        struct utsm_ioctl_msg umsg;

        /* Drain any pending messages (there may be multiple if UTSM
         * queued several before vmresume). */
        while (recv_msg(&umsg) == 0) {
            if (umsg.type == UTSM_MSG_EXEC_REQUEST &&
                umsg.data_len >= sizeof(struct ipc_exec_request)) {
                handle_exec_request((const struct ipc_exec_request *)umsg.data);
            } else if (umsg.type == UTSM_MSG_FILE_LIST_REQUEST &&
                       umsg.data_len >= sizeof(struct ipc_file_request)) {
                handle_file_list((const struct ipc_file_request *)umsg.data);
            } else if (umsg.type == UTSM_MSG_FILE_READ_REQUEST &&
                       umsg.data_len >= sizeof(struct ipc_file_request)) {
                handle_file_read((const struct ipc_file_request *)umsg.data);
            } else if (umsg.type == UTSM_MSG_FILE_WRITE_REQUEST &&
                       umsg.data_len >= sizeof(struct ipc_file_request)) {
                handle_file_write((const struct ipc_file_request *)umsg.data);
            }
            /* Ignore other message types (HELLO, PING, etc.) */
        }

        /* Single vCPU: PARK/HLT freezes the whole VM, including async
         * children and in-flight virtio-blk. Yields return immediately
         * when the child is in D-state, so a yield-then-HLT loop parks
         * before the virtio IRQ can be injected. Stay runnable; the
         * host returns from linux_resume() on a preemption timeslice. */
        if (g_async_live) {
            donate_cpu();
            continue;
        }

        /* Responses (if any) are already queued. Park to let UTSM read
         * them and return to the shell; a spurious wakeup with no
         * request simply parks again. */
        park();
    }

    close(g_utsm_fd);
    return 0;
}