fix(box): container logs show only container output (not runtime internals)

`a3s-box logs` was polluted with runtime boot/exec chatter — guest-init's own
INFO tracing (Spawning process, exec/pty server listening, Waiting for
container process, ...) plus libkrun's C-init preamble — because the container
inherits PID1's serial console and guest-init logged to that same console.
Docker `logs` must show ONLY the container process's stdout/stderr.

- guest-init: route its OWN tracing to the kernel log (/dev/kmsg) instead of the
  console, with a <7> debug-priority prefix that stays below the guest kernel's
  console loglevel (4) so it never echoes back. The fd is opened once before any
  chroot/pivot and reused (an open fd survives pivot_root), avoiding a mid-boot
  gap where the new root has no /dev/kmsg. Falls back to stdout if unavailable.
  with_ansi(false) keeps the kernel log clean.
- runtime/log.rs: drop libkrun's `init.krun: ...` preamble (printed before
  /sbin/init starts) from the json-file and syslog log streams.

Verified on KVM: `run -d alpine -- sh -c 'echo HELLO1; echo HELLO2'` then
`logs` yields exactly HELLO1/HELLO2 (guestinit=0, krun=0; was ~10 polluting
lines). Foreground run + exec + container output unaffected. Bug remaining
(separate): --timestamps still shows processing time, needs guest stamp-at-source.

Author: Roy Lin

src/guest/init/src/main.rs

@@ -164,13 +164,83 @@ fn is_tee_environment() -> bool {
     a3s_box_core::tee::is_tee_available()
 }
 
+/// Raw fd of `/dev/kmsg`, opened ONCE before any chroot/pivot and kept open for
+/// the process lifetime. An open file description survives `pivot_root`/`chroot`
+/// (it is independent of the path), so reusing this fd avoids the gap where the
+/// new root has no `/dev/kmsg` yet — which would otherwise leak a few lines back
+/// to the console mid-boot.
+static KMSG_FD: std::sync::OnceLock<Option<std::os::unix::io::RawFd>> = std::sync::OnceLock::new();
+
+/// Writer for guest-init's OWN tracing. Routes it to the kernel log
+/// (`/dev/kmsg`) instead of the VM console so it never pollutes container logs:
+/// the container inherits the console for its stdout/stderr, and Docker-style
+/// `logs` must show only that, not runtime internals (init/exec/pty chatter).
+/// A `<7>` (debug) priority prefix keeps these lines below the guest kernel's
+/// console loglevel (4), so they never echo back to the console. Falls back to
+/// stdout when `/dev/kmsg` is unavailable (e.g. non-Linux), preserving the old
+/// behavior rather than dropping logs.
+enum InitLogWriter {
+    Kmsg(std::os::unix::io::RawFd),
+    Stdout(std::io::Stdout),
+}
+
+impl std::io::Write for InitLogWriter {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match self {
+            InitLogWriter::Kmsg(fd) => {
+                // /dev/kmsg treats each write() as one record: prefix the
+                // priority and flatten embedded newlines so a formatted event
+                // stays a single kernel-log record.
+                let mut record = Vec::with_capacity(buf.len() + 13);
+                record.extend_from_slice(b"<7>a3s-init: ");
+                record.extend(buf.iter().map(|&b| if b == b'\n' { b' ' } else { b }));
+                // SAFETY: *fd is a valid, process-lifetime fd to /dev/kmsg; a
+                // failed write is intentionally ignored (logging must never panic).
+                unsafe {
+                    libc::write(*fd, record.as_ptr() as *const libc::c_void, record.len());
+                }
+                Ok(buf.len())
+            }
+            InitLogWriter::Stdout(out) => out.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        match self {
+            InitLogWriter::Kmsg(_) => Ok(()),
+            InitLogWriter::Stdout(out) => out.flush(),
+        }
+    }
+}
+
+fn make_init_log_writer() -> InitLogWriter {
+    match KMSG_FD.get().copied().flatten() {
+        Some(fd) => InitLogWriter::Kmsg(fd),
+        None => InitLogWriter::Stdout(std::io::stdout()),
+    }
+}
+
 fn main() {
-    // Initialize logging
+    // Open /dev/kmsg once (before any chroot) and keep it open for the whole
+    // process via into_raw_fd, so guest-init's logs reach the kernel log
+    // reliably across the pivot. Container logs stay clean (see InitLogWriter).
+    use std::os::unix::io::IntoRawFd;
+    let kmsg_fd = std::fs::OpenOptions::new()
+        .write(true)
+        .open("/dev/kmsg")
+        .ok()
+        .map(|file| file.into_raw_fd());
+    let _ = KMSG_FD.set(kmsg_fd);
+
+    // Initialize logging. guest-init's own logs go to the kernel log, NOT the
+    // console, to keep container logs clean.
     tracing_subscriber::fmt()
         .with_env_filter(
             tracing_subscriber::EnvFilter::try_from_default_env()
                 .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
         )
+        .with_ansi(false)
+        .with_writer(make_init_log_writer)
         .init();
 
     info!("a3s-box guest init starting (PID {})", process::id());

src/runtime/src/log.rs

@@ -39,6 +39,15 @@ pub fn json_log_path(log_dir: &Path) -> PathBuf {
     log_dir.join("container.json")
 }
 
+/// True for console lines that are VM/runtime boot internals, not container
+/// output. Currently libkrun's C-init preamble (`init.krun: ...`), emitted to
+/// the console before `/sbin/init` (guest-init) takes over. guest-init's own
+/// tracing is routed to `/dev/kmsg` and never reaches the console, so this is
+/// the only remaining non-container source on it.
+fn is_runtime_console_noise(line: &str) -> bool {
+    line.starts_with("init.krun:")
+}
+
 /// Tail console.log and write Docker-compatible JSON lines to container.json.
 fn run_json_file_processor(console_log: &Path, log_dir: &Path, max_size: u64, max_file: u32) {
     // Wait for console.log to appear
@@ -71,6 +80,14 @@ fn run_json_file_processor(console_log: &Path, log_dir: &Path, max_size: u64, ma
             }
         };
 
+        // Drop libkrun's C-init boot preamble (`init.krun: ...`) printed to the
+        // console before /sbin/init starts. It is runtime internals, not
+        // container output — Docker `logs` must show only the latter. (guest-init's
+        // own tracing already goes to /dev/kmsg, not the console.)
+        if is_runtime_console_noise(&line) {
+            continue;
+        }
+
         let entry = LogEntry {
             log: format!("{}\n", line),
             stream: "stdout".to_string(),
@@ -128,6 +145,9 @@ fn run_syslog_processor(console_log: &Path, address: &str, _facility: &str, tag:
                         continue;
                     }
                 };
+                if is_runtime_console_noise(&line) {
+                    continue;
+                }
                 // RFC 3164 format: <priority>tag: message
                 // facility=daemon(3), severity=info(6) → priority = 3*8+6 = 30
                 let msg = format!("<30>{}: {}", tag, line);
@@ -148,6 +168,9 @@ fn run_syslog_processor(console_log: &Path, address: &str, _facility: &str, tag:
                         continue;
                     }
                 };
+                if is_runtime_console_noise(&line) {
+                    continue;
+                }
                 let msg = format!("<30>{}: {}\n", tag, line);
                 if stream.write_all(msg.as_bytes()).is_err() {
                     // Connection lost — try to reconnect once
@@ -265,6 +288,16 @@ mod tests {
     use std::io::Read;
     use tempfile::TempDir;
 
+    #[test]
+    fn test_is_runtime_console_noise() {
+        assert!(is_runtime_console_noise("init.krun: mount_filesystems ok"));
+        assert!(is_runtime_console_noise("init.krun: execvp(/sbin/init) starting"));
+        // Real container output must pass through, even if it mentions krun.
+        assert!(!is_runtime_console_noise("L1"));
+        assert!(!is_runtime_console_noise("starting app (init.krun: ignored)"));
+        assert!(!is_runtime_console_noise(""));
+    }
+
     #[test]
     fn test_rotating_writer_basic() {
         let dir = TempDir::new().unwrap();