vcontainer: add host-side idle timeout with QMP shutdown

Implement reliable idle timeout for vmemres daemon mode using
host-side monitoring with QMP-based shutdown, and container-aware
idle detection via virtio-9p shared file.

Host-side changes (vrunner.sh):
  - Add -no-reboot flag to QEMU for clean exit semantics
  - Spawn background watchdog when daemon starts
  - Watchdog monitors activity file timestamp
  - Check interval scales to idle timeout (timeout/5, clamped 10-60s)
  - Read container status from shared file (guest writes via virtio-9p)
  - Only shutdown if no containers are running
  - Send QMP "quit" command for graceful shutdown
  - Watchdog auto-exits if QEMU dies (no zombie processes)
  - Touch activity file in daemon_send() for user activity tracking

Config changes (vcontainer-common.sh):
  - Add idle-timeout to build_runner_args() so it's always passed

Guest-side changes (vcontainer-init-common.sh):
  - Add watchdog that writes container status to /mnt/share/.containers_running
  - Host reads this file instead of socket commands (avoids output corruption)
  - Close inherited virtio-serial fd 3 in watchdog subshell to prevent leaks
  - Guest-side shutdown logic preserved but disabled (QMP more reliable)
  - Handle Yocto read-only-rootfs volatile directories (/var/volatile)

The shared file approach avoids sending container check commands through
the daemon socket, which previously caused output corruption on the
single-stream virtio-serial channel.

The idle timeout is configurable via: vdkr vconfig idle-timeout <secs>
Default: 1800 seconds (30 minutes)

Signed-off-by: Bruce Ashfield <bruce.ashfield@gmail.com>

3 files changed, 154 insertions, 20 deletions

diff --git a/recipes-containers/vcontainer/files/vcontainer-common.sh b/recipes-containers/vcontainer/files/vcontainer-common.sh
index 39e57b13..792bd7a2 100755
--- a/recipes-containers/vcontainer/files/vcontainer-common.sh
+++ b/recipes-containers/vcontainer/files/vcontainer-common.sh
@@ -737,6 +737,10 @@ build_runner_args() {
     [ -n "$INPUT_STORAGE" ] && args+=("--input-storage" "$INPUT_STORAGE")
     [ "$DISABLE_KVM" = "true" ] && args+=("--no-kvm")
 
+    # Add idle timeout from config
+    local idle_timeout=$(config_get "idle-timeout" "1800")
+    args+=("--idle-timeout" "$idle_timeout")
+
     # Add port forwards (each -p adds a --port-forward)
     for pf in "${PORT_FORWARDS[@]}"; do
         args+=("--port-forward" "$pf")
@@ -1088,10 +1092,9 @@ run_runtime_command() {
         # Check if auto-daemon is enabled
         local auto_daemon=$(config_get "auto-daemon" "true")
         if [ "$auto_daemon" = "true" ]; then
-            # Auto-start daemon
+            # Auto-start daemon (idle-timeout is included in runner_args)
             echo -e "${CYAN}[$VCONTAINER_RUNTIME_NAME]${NC} Starting daemon..." >&2
-            local idle_timeout=$(config_get "idle-timeout" "1800")
-            "$RUNNER" $runner_args --idle-timeout "$idle_timeout" --daemon-start
+            "$RUNNER" $runner_args --daemon-start
 
             if daemon_is_running; then
                 # Fresh daemon has no port forwards - clear stale registry
@@ -1136,10 +1139,9 @@ run_runtime_command_with_input() {
         # Check if auto-daemon is enabled
         local auto_daemon=$(config_get "auto-daemon" "true")
         if [ "$auto_daemon" = "true" ]; then
-            # Auto-start daemon
+            # Auto-start daemon (idle-timeout is included in runner_args)
             echo -e "${CYAN}[$VCONTAINER_RUNTIME_NAME]${NC} Starting daemon..." >&2
-            local idle_timeout=$(config_get "idle-timeout" "1800")
-            "$RUNNER" $runner_args --idle-timeout "$idle_timeout" --daemon-start
+            "$RUNNER" $runner_args --daemon-start
 
             if daemon_is_running; then
                 # Fresh daemon has no port forwards - clear stale registry
diff --git a/recipes-containers/vcontainer/files/vcontainer-init-common.sh b/recipes-containers/vcontainer/files/vcontainer-init-common.sh
index 619e334a..fe488ae2 100755
--- a/recipes-containers/vcontainer/files/vcontainer-init-common.sh
+++ b/recipes-containers/vcontainer/files/vcontainer-init-common.sh
@@ -53,6 +53,15 @@ mount_tmpfs_dirs() {
     mount -t tmpfs tmpfs /tmp
     mount -t tmpfs tmpfs /run
     mount -t tmpfs tmpfs /mnt
+
+    # Handle Yocto read-only-rootfs volatile directories
+    # /var/log and /var/tmp are symlinks to volatile/log and volatile/tmp
+    if [ -d /var/volatile ]; then
+        mount -t tmpfs tmpfs /var/volatile
+        mkdir -p /var/volatile/log /var/volatile/tmp
+    fi
+
+    # Fallback for non-volatile layouts
     mount -t tmpfs tmpfs /var/run 2>/dev/null || true
     mount -t tmpfs tmpfs /var/tmp 2>/dev/null || true
 
@@ -330,13 +339,81 @@ run_daemon_mode() {
 
     log "Daemon ready, waiting for commands..."
 
-    # Command loop with idle timeout
+    # Start idle timeout watchdog
+    # Note: 'read -t' doesn't work reliably on non-terminal fds (like virtio-serial),
+    # so we use a background watchdog that tracks activity via a timestamp file.
+    ACTIVITY_FILE="/tmp/.daemon_activity"
+    touch "$ACTIVITY_FILE"
+    DAEMON_PID=$$
+
+    # Watchdog process - writes container status to shared directory for host-side
+    # Host-side handles shutdown via QMP; guest-side shutdown is disabled but preserved
+    CONTAINER_STATUS_FILE="/mnt/share/.containers_running"
+
+    # Scale check interval to idle timeout (check ~5 times before timeout)
+    CHECK_INTERVAL=$((RUNTIME_IDLE_TIMEOUT / 5))
+    [ "$CHECK_INTERVAL" -lt 10 ] && CHECK_INTERVAL=10
+    [ "$CHECK_INTERVAL" -gt 60 ] && CHECK_INTERVAL=60
+
+    (
+        # Close inherited virtio-serial fd to prevent output leaking to host
+        exec 3>&-
+
+        while true; do
+            sleep "$CHECK_INTERVAL"
+            if [ ! -f "$ACTIVITY_FILE" ]; then
+                # Activity file removed = clean shutdown in progress
+                rm -f "$CONTAINER_STATUS_FILE" 2>/dev/null
+                exit 0
+            fi
+
+            # Check for running containers and write status to shared file
+            # Host-side reads this file instead of sending socket commands
+            RUNNING=$("$VCONTAINER_RUNTIME_CMD" ps -q 2>/dev/null)
+            if [ -n "$RUNNING" ]; then
+                echo "$RUNNING" > "$CONTAINER_STATUS_FILE" 2>/dev/null || true
+            else
+                rm -f "$CONTAINER_STATUS_FILE" 2>/dev/null || true
+            fi
+
+            # Guest-side shutdown logic - DISABLED, host-side QMP is more reliable
+            # Kept for potential future use if host-side becomes unavailable
+            : << 'DISABLED_GUEST_SHUTDOWN'
+            LAST_ACTIVITY=$(stat -c %Y "$ACTIVITY_FILE" 2>/dev/null || echo 0)
+            NOW=$(date +%s)
+            IDLE_SECONDS=$((NOW - LAST_ACTIVITY))
+            if [ "$IDLE_SECONDS" -ge "$RUNTIME_IDLE_TIMEOUT" ]; then
+                if [ -n "$RUNNING" ]; then
+                    # Containers are running - reset activity and skip shutdown
+                    echo "[watchdog] Containers still running, resetting idle timer" >> /dev/kmsg 2>/dev/null || true
+                    touch "$ACTIVITY_FILE"
+                    continue
+                fi
+                echo "[watchdog] Idle timeout (${IDLE_SECONDS}s >= ${RUNTIME_IDLE_TIMEOUT}s), no containers running, shutting down..." >> /dev/kmsg 2>/dev/null || true
+                rm -f "$CONTAINER_STATUS_FILE" 2>/dev/null
+                kill -TERM "$DAEMON_PID" 2>/dev/null
+                exit 0
+            fi
+DISABLED_GUEST_SHUTDOWN
+        done
+    ) &
+    WATCHDOG_PID=$!
+    log "Started idle watchdog (PID: $WATCHDOG_PID, timeout: ${RUNTIME_IDLE_TIMEOUT}s)"
+
+    # Trap to clean up watchdog on exit and power off VM
+    # Use reboot -f which works with QEMU's -no-reboot flag to exit cleanly
+    trap 'log "Idle timeout triggered by watchdog"; log "Calling reboot -f"; sync; /usr/sbin/reboot -f' TERM
+    trap 'rm -f "$ACTIVITY_FILE"; kill $WATCHDOG_PID 2>/dev/null; exit' INT
+
+    # Command loop
     while true; do
         CMD_B64=""
-        read -t "$RUNTIME_IDLE_TIMEOUT" -r CMD_B64 <&3
+        read -r CMD_B64 <&3
         READ_EXIT=$?
 
-        if [ $READ_EXIT -eq 0 ]; then
+        if [ $READ_EXIT -eq 0 ] && [ -n "$CMD_B64" ]; then
+            # Update activity timestamp
+            touch "$ACTIVITY_FILE"
             log "Received: '$CMD_B64'"
             # Handle special commands
             case "$CMD_B64" in
@@ -450,19 +527,15 @@ run_daemon_mode() {
 
             log "Command completed (exit code: $EXEC_EXIT_CODE)"
         else
-            # Read returned non-zero: either timeout or EOF
-            # Timeout returns >128 (typically 142), EOF returns 1
-            if [ $READ_EXIT -gt 128 ]; then
-                # Actual timeout - shut down
-                log "Idle timeout (${RUNTIME_IDLE_TIMEOUT}s), shutting down..."
-                echo "===IDLE_SHUTDOWN===" | cat >&3
-                break
-            fi
-            # EOF or empty line - host closed connection, wait for reconnect
+            # Read returned non-zero or empty - host closed connection or EOF
+            # Idle timeout is handled by the watchdog process
             sleep 0.1
         fi
     done
 
+    # Clean shutdown
+    rm -f "$ACTIVITY_FILE"
+    kill $WATCHDOG_PID 2>/dev/null
     exec 3>&-
     log "Daemon shutting down..."
 }
@@ -578,5 +651,6 @@ graceful_shutdown() {
     sleep 2
 
     log "=== ${VCONTAINER_RUNTIME_NAME} Complete ==="
-    poweroff -f
+    # Use reboot -f which works with QEMU's -no-reboot flag to exit cleanly
+    reboot -f
 }
diff --git a/recipes-containers/vcontainer/files/vrunner.sh b/recipes-containers/vcontainer/files/vrunner.sh
index 5d824ba5..4e99cba7 100755
--- a/recipes-containers/vcontainer/files/vrunner.sh
+++ b/recipes-containers/vcontainer/files/vrunner.sh
@@ -546,6 +546,9 @@ daemon_send() {
         exit 1
     fi
 
+    # Update activity timestamp for idle timeout tracking
+    touch "$DAEMON_SOCKET_DIR/activity" 2>/dev/null || true
+
     # Encode command in base64 and send
     local cmd_b64=$(echo -n "$cmd" | base64 -w0)
 
@@ -603,6 +606,9 @@ daemon_send_with_input() {
         exit 1
     fi
 
+    # Update activity timestamp for idle timeout tracking
+    touch "$DAEMON_SOCKET_DIR/activity" 2>/dev/null || true
+
     # Shared directory for virtio-9p
     local share_dir="$DAEMON_SOCKET_DIR/share"
     if [ ! -d "$share_dir" ]; then
@@ -1159,7 +1165,7 @@ fi
 #   /dev/vdc = state disk (if any)
 # The preinit script in initramfs mounts /dev/vda and does switch_root
 # Build QEMU options
-QEMU_OPTS="$QEMU_MACHINE -nographic -smp 2 -m 2048"
+QEMU_OPTS="$QEMU_MACHINE -nographic -smp 2 -m 2048 -no-reboot"
 if [ "$USE_KVM" = "true" ]; then
     QEMU_OPTS="$QEMU_OPTS -enable-kvm"
 fi
@@ -1336,6 +1342,58 @@ if [ "$DAEMON_MODE" = "start" ]; then
 
     if [ "$READY" = "true" ]; then
         log "INFO" "Daemon is ready!"
+
+        # Start host-side idle watchdog if timeout is set
+        if [ "$IDLE_TIMEOUT" -gt 0 ] 2>/dev/null; then
+            ACTIVITY_FILE="$DAEMON_SOCKET_DIR/activity"
+            touch "$ACTIVITY_FILE"
+
+            # Spawn background watchdog
+            (
+                # Container status file - guest writes this via virtio-9p share
+                # This avoids sending commands through daemon socket which corrupts output
+                CONTAINER_STATUS_FILE="$DAEMON_SHARE_DIR/.containers_running"
+
+                # Scale check interval to idle timeout (check ~5 times before timeout)
+                CHECK_INTERVAL=$((IDLE_TIMEOUT / 5))
+                [ "$CHECK_INTERVAL" -lt 10 ] && CHECK_INTERVAL=10
+                [ "$CHECK_INTERVAL" -gt 60 ] && CHECK_INTERVAL=60
+
+                while true; do
+                    sleep "$CHECK_INTERVAL"
+                    [ -f "$ACTIVITY_FILE" ] || exit 0  # Clean exit if file removed
+                    [ -f "$DAEMON_PID_FILE" ] || exit 0  # PID file gone
+
+                    # Check if QEMU process is still running
+                    QEMU_PID=$(cat "$DAEMON_PID_FILE" 2>/dev/null)
+                    [ -n "$QEMU_PID" ] && kill -0 "$QEMU_PID" 2>/dev/null || exit 0
+
+                    LAST_ACTIVITY=$(stat -c %Y "$ACTIVITY_FILE" 2>/dev/null || echo 0)
+                    NOW=$(date +%s)
+                    IDLE_SECONDS=$((NOW - LAST_ACTIVITY))
+
+                    if [ "$IDLE_SECONDS" -ge "$IDLE_TIMEOUT" ]; then
+                        # Check if any containers are running via shared file
+                        # Guest-side watchdog writes container IDs to this file
+                        if [ -f "$CONTAINER_STATUS_FILE" ] && [ -s "$CONTAINER_STATUS_FILE" ]; then
+                            # Containers are running - reset activity and skip shutdown
+                            touch "$ACTIVITY_FILE"
+                            continue
+                        fi
+
+                        # No containers running - send QMP quit to gracefully stop QEMU
+                        if [ -S "$QMP_SOCKET" ]; then
+                            echo '{"execute":"qmp_capabilities"}{"execute":"quit"}' | \
+                                socat - "UNIX-CONNECT:$QMP_SOCKET" >/dev/null 2>&1 || true
+                        fi
+                        rm -f "$ACTIVITY_FILE"
+                        exit 0
+                    fi
+                done
+            ) &
+            log "DEBUG" "Started host-side idle watchdog (timeout: ${IDLE_TIMEOUT}s)"
+        fi
+
         echo "Daemon running (PID: $QEMU_PID)"
         echo "Socket: $DAEMON_SOCKET"
         exit 0