allow redirecting guest serial output to a file

Add a new field, `serial_out_path`, to the logger configuration
(available both via API and CLI) which can be set to the path of a file
into which the output of the guest's serial console should be dumped.

Have the file behave identically to our log file (e.g. it must already
exist, Firecracker does not create it).

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/firecracker/src/api_server/request/logger.rs

@@ -36,6 +36,7 @@ mod tests {
 
         let expected_config = LoggerConfig {
             log_path: Some(PathBuf::from("log")),
+            serial_out_path: None,
             level: Some(LevelFilter::Warn),
             show_level: Some(false),
             show_log_origin: Some(false),
@@ -55,6 +56,7 @@ mod tests {
 
         let expected_config = LoggerConfig {
             log_path: Some(PathBuf::from("log")),
+            serial_out_path: None,
             level: Some(LevelFilter::Debug),
             show_level: Some(false),
             show_log_origin: Some(false),

src/firecracker/src/main.rs

@@ -208,6 +208,11 @@ fn main_exec() -> Result<(), MainError> {
                     .takes_value(true)
                     .help("Path to a fifo or a file used for configuring the logger on startup."),
             )
+            .arg(
+                Argument::new("serial-out-path")
+                    .takes_value(true)
+                    .help("Path to a fifo or a file used for serial output."),
+            )
             .arg(
                 Argument::new("level")
                     .takes_value(true)
@@ -295,6 +300,7 @@ fn main_exec() -> Result<(), MainError> {
         .set(String::from(instance_id))
         .unwrap();
     let log_path = arguments.single_value("log-path").map(PathBuf::from);
+    let serial_out_path = arguments.single_value("serial-out-path").map(PathBuf::from);
     let level = arguments
         .single_value("level")
         .map(|s| vmm::logger::LevelFilter::from_str(s))
@@ -306,6 +312,7 @@ fn main_exec() -> Result<(), MainError> {
     LOGGER
         .update(LoggerConfig {
             log_path,
+            serial_out_path,
             level,
             show_level,
             show_log_origin,

src/vmm/src/builder.rs

@@ -5,6 +5,7 @@
 
 use std::fmt::Debug;
 use std::io;
+use std::os::unix::fs::OpenOptionsExt;
 #[cfg(feature = "gdb")]
 use std::sync::mpsc;
 use std::sync::{Arc, Mutex};
@@ -51,7 +52,7 @@ use crate::devices::virtio::vsock::{Vsock, VsockUnixBackend};
 #[cfg(feature = "gdb")]
 use crate::gdb;
 use crate::initrd::{InitrdConfig, InitrdError};
-use crate::logger::{debug, error};
+use crate::logger::{LOGGER, debug, error};
 use crate::persist::{MicrovmState, MicrovmStateError};
 use crate::resources::VmResources;
 use crate::seccomp::BpfThreadMap;
@@ -551,7 +552,20 @@ pub fn build_microvm_from_snapshot(
 pub fn setup_serial_device(
     event_manager: &mut EventManager,
 ) -> Result<Arc<Mutex<BusDevice>>, VmmError> {
-    set_stdout_nonblocking();
+    let serial_out = match LOGGER.0.lock().expect("logger poisoned").serial_out_path {
+        Some(ref path) => std::fs::OpenOptions::new()
+            .custom_flags(libc::O_NONBLOCK)
+            .read(true)
+            .write(true)
+            .open(path)
+            .map_err(VmmError::Serial)
+            .map(SerialOut::File)?,
+        None => {
+            set_stdout_nonblocking();
+
+            SerialOut::Stdout(std::io::stdout())
+        }
+    };
 
     let interrupt_evt = EventFdTrigger::new(EventFd::new(EFD_NONBLOCK).map_err(VmmError::EventFd)?);
     let kick_stdin_read_evt =
@@ -562,7 +576,7 @@ pub fn setup_serial_device(
             SerialEventsWrapper {
                 buffer_ready_event_fd: Some(kick_stdin_read_evt),
             },
-            SerialOut::Stdout(std::io::stdout()),
+            serial_out,
         ),
         input: Some(std::io::stdin()),
     })));

src/vmm/src/devices/legacy/serial.rs

@@ -7,6 +7,7 @@
 
 //! Implements a wrapper over an UART serial device.
 use std::fmt::Debug;
+use std::fs::File;
 use std::io;
 use std::io::{Read, Write};
 use std::os::unix::io::{AsRawFd, RawFd};
@@ -127,18 +128,21 @@ impl SerialEvents for SerialEventsWrapper {
 pub enum SerialOut {
     Sink,
     Stdout(std::io::Stdout),
+    File(File),
 }
 impl std::io::Write for SerialOut {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         match self {
             Self::Sink => Ok(buf.len()),
             Self::Stdout(stdout) => stdout.write(buf),
+            Self::File(file) => file.write(buf),
         }
     }
     fn flush(&mut self) -> std::io::Result<()> {
         match self {
             Self::Sink => Ok(()),
             Self::Stdout(stdout) => stdout.flush(),
+            Self::File(file) => file.flush(),
         }
     }
 }

src/vmm/src/logger/logging.rs

@@ -28,6 +28,7 @@ pub static INSTANCE_ID: OnceLock<String> = OnceLock::new();
 /// Default values matching the swagger specification (`src/firecracker/swagger/firecracker.yaml`).
 pub static LOGGER: Logger = Logger(Mutex::new(LoggerConfiguration {
     target: None,
+    serial_out_path: None,
     filter: LogFilter { module: None },
     format: LogFormat {
         show_level: false,
@@ -72,6 +73,10 @@ impl Logger {
             guard.target = Some(file);
         };
 
+        if let Some(serial_out_path) = config.serial_out_path {
+            guard.serial_out_path = Some(serial_out_path);
+        }
+
         if let Some(show_level) = config.show_level {
             guard.format.show_level = show_level;
         }
@@ -104,6 +109,7 @@ pub struct LogFormat {
 #[derive(Debug)]
 pub struct LoggerConfiguration {
     pub target: Option<std::fs::File>,
+    pub serial_out_path: Option<PathBuf>,
     pub filter: LogFilter,
     pub format: LogFormat,
 }
@@ -186,6 +192,8 @@ impl Log for Logger {
 pub struct LoggerConfig {
     /// Named pipe or file used as output for logs.
     pub log_path: Option<PathBuf>,
+    /// Named pipe of file used as output for guest serial console.
+    pub serial_out_path: Option<PathBuf>,
     /// The level of the Logger.
     pub level: Option<LevelFilter>,
     /// Whether to show the log level in the log.
@@ -366,6 +374,7 @@ mod tests {
         // Create logger.
         let logger = Logger(Mutex::new(LoggerConfiguration {
             target: Some(target),
+            serial_out_path: None,
             filter: LogFilter {
                 module: Some(String::from("module")),
             },

src/vmm/src/rpc_interface.rs

@@ -1187,6 +1187,7 @@ mod tests {
         )));
         check_unsupported(runtime_request(VmmAction::ConfigureLogger(LoggerConfig {
             log_path: Some(PathBuf::new()),
+            serial_out_path: None,
             level: Some(crate::logger::LevelFilter::Debug),
             show_level: Some(false),
             show_log_origin: Some(false),