Introduce explict APIs for adding custom multiport virtio consoles

Signed-off-by: Matej Hrica <[email protected]>

Author: mtjhrc

include/libkrun.h

@@ -985,6 +985,69 @@ int32_t krun_add_serial_console_default(uint32_t ctx_id,
                                       int input_fd,
                                       int output_fd);
 
+/*
+ * Adds a multi-port virtio-console device to the guest with explicitly configured ports.
+ *
+ * This function creates a new virtio-console device that can have multiple ports added to it
+ * via krun_add_console_port_tty() and krun_add_console_port_inout(). Unlike krun_add_virtio_console_default(),
+ * this does not do any automatic detections to configure ports based on the file descriptors.
+ *
+ * The function can be called multiple times for adding multiple virtio-console devices.
+ * In the guest, the consoles will appear in the same order as they are added (that is,
+ * the first added console will be "hvc0", the second "hvc1", ...). However, if the
+ * implicit console is not disabled via `krun_disable_implicit_console`, the first
+ * console created with the function will occupy the "hvc1" ID.
+ *
+ * Arguments:
+ *  "ctx_id" - the configuration context ID.
+ *
+ * Returns:
+ *  The console_id (>= 0) on success or a negative error number on failure.
+ */
+int32_t krun_add_virtio_console_multiport(uint32_t ctx_id);
+
+/*
+ * Adds a console port to a multi-port virtio-console device using a TTY file descriptor.
+ *
+ * The TTY file descriptor is used for both input and output. This is typically used for
+ * interactive terminal sessions.
+ *
+ * Arguments:
+ *  "ctx_id"     - the configuration context ID.
+ *  "console_id" - the console ID returned by krun_add_virtio_console_multiport().
+ *  "name"       - the name of the port. Use empty string "" for the console port (port 0).
+ *  "tty_fd"     - file descriptor for the TTY to use for both input and output.
+ *
+ * Returns:
+ *  Zero on success or a negative error number on failure.
+ */
+int32_t krun_add_console_port_tty(uint32_t ctx_id,
+                                   uint32_t console_id,
+                                   const char *name,
+                                   int tty_fd);
+
+/*
+ * Adds a console port to a multi-port virtio-console device using separate input/output file descriptors.
+ *
+ * This function allows specifying separate file descriptors for input and output, which is useful
+ * for non-interactive scenarios such as piping data in/out of the guest.
+ *
+ * Arguments:
+ *  "ctx_id"     - the configuration context ID.
+ *  "console_id" - the console ID returned by krun_add_virtio_console_multiport().
+ *  "name"       - the name of the port. Use empty string "" for the console port (port 0).
+ *  "input_fd"   - file descriptor to use for input.
+ *  "output_fd"  - file descriptor to use for output.
+ *
+ * Returns:
+ *  Zero on success or a negative error number on failure.
+ */
+int32_t krun_add_console_port_inout(uint32_t ctx_id,
+                                     uint32_t console_id,
+                                     const char *name,
+                                     int input_fd,
+                                     int output_fd);
+
 /**
  * Configure block device to be used as root filesystem.
  *

src/libkrun/src/lib.rs

@@ -38,7 +38,10 @@ use std::sync::atomic::{AtomicI32, Ordering};
 use std::sync::LazyLock;
 use std::sync::Mutex;
 use utils::eventfd::EventFd;
-use vmm::resources::{DefaultVirtioConsoleConfig, SerialConsoleConfig, VmResources};
+use vmm::resources::{
+    DefaultVirtioConsoleConfig, PortConfig, SerialConsoleConfig, VirtioConsoleConfigMode,
+    VmResources,
+};
 #[cfg(feature = "blk")]
 use vmm::vmm_config::block::{BlockDeviceConfig, BlockRootConfig};
 #[cfg(not(feature = "tee"))]
@@ -2118,18 +2121,122 @@ pub unsafe extern "C" fn krun_add_virtio_console_default(
         Entry::Occupied(mut ctx_cfg) => {
             let cfg = ctx_cfg.get_mut();
 
-            cfg.vmr.virtio_consoles.push(DefaultVirtioConsoleConfig {
-                input_fd,
-                output_fd,
-                err_fd,
-            });
+            cfg.vmr
+                .virtio_consoles
+                .push(VirtioConsoleConfigMode::Autoconfigure(
+                    DefaultVirtioConsoleConfig {
+                        input_fd,
+                        output_fd,
+                        err_fd,
+                    },
+                ));
         }
         Entry::Vacant(_) => return -libc::ENOENT,
     }
 
     KRUN_SUCCESS
 }
 
+#[allow(clippy::missing_safety_doc)]
+#[no_mangle]
+pub unsafe extern "C" fn krun_add_virtio_console_multiport(ctx_id: u32) -> i32 {
+    match CTX_MAP.lock().unwrap().entry(ctx_id) {
+        Entry::Occupied(mut ctx_cfg) => {
+            let cfg = ctx_cfg.get_mut();
+            let console_id = cfg.vmr.virtio_consoles.len() as i32;
+
+            cfg.vmr
+                .virtio_consoles
+                .push(VirtioConsoleConfigMode::Explicit(Vec::new()));
+
+            console_id
+        }
+        Entry::Vacant(_) => -libc::ENOENT,
+    }
+}
+
+#[allow(clippy::missing_safety_doc)]
+#[no_mangle]
+pub unsafe extern "C" fn krun_add_console_port_tty(
+    ctx_id: u32,
+    console_id: u32,
+    name: *const libc::c_char,
+    tty_fd: libc::c_int,
+) -> i32 {
+    if name.is_null() {
+        return -libc::EINVAL;
+    }
+
+    let name_str = match std::ffi::CStr::from_ptr(name).to_str() {
+        Ok(s) => s.to_string(),
+        Err(_) => return -libc::EINVAL,
+    };
+
+    match CTX_MAP.lock().unwrap().entry(ctx_id) {
+        Entry::Occupied(mut ctx_cfg) => {
+            let cfg = ctx_cfg.get_mut();
+
+            if (console_id as usize) >= cfg.vmr.virtio_consoles.len() {
+                return -libc::ENOENT;
+            }
+
+            match &mut cfg.vmr.virtio_consoles[console_id as usize] {
+                VirtioConsoleConfigMode::Explicit(ports) => {
+                    ports.push(PortConfig::Tty {
+                        name: name_str,
+                        tty_fd,
+                    });
+                    KRUN_SUCCESS
+                }
+                VirtioConsoleConfigMode::Autoconfigure(_) => -libc::EINVAL,
+            }
+        }
+        Entry::Vacant(_) => -libc::ENOENT,
+    }
+}
+
+#[allow(clippy::missing_safety_doc)]
+#[no_mangle]
+pub unsafe extern "C" fn krun_add_console_port_inout(
+    ctx_id: u32,
+    console_id: u32,
+    name: *const libc::c_char,
+    input_fd: libc::c_int,
+    output_fd: libc::c_int,
+) -> i32 {
+    if name.is_null() {
+        return -libc::EINVAL;
+    }
+
+    let name_str = match std::ffi::CStr::from_ptr(name).to_str() {
+        Ok(s) => s.to_string(),
+        Err(_) => return -libc::EINVAL,
+    };
+
+    match CTX_MAP.lock().unwrap().entry(ctx_id) {
+        Entry::Occupied(mut ctx_cfg) => {
+            let cfg = ctx_cfg.get_mut();
+
+            if (console_id as usize) >= cfg.vmr.virtio_consoles.len() {
+                return -libc::ENOENT;
+            }
+
+            match &mut cfg.vmr.virtio_consoles[console_id as usize] {
+                VirtioConsoleConfigMode::Explicit(ports) => {
+                    ports.push(PortConfig::InOut {
+                        name: name_str,
+                        input_fd,
+                        output_fd,
+                    });
+                    KRUN_SUCCESS
+                }
+                VirtioConsoleConfigMode::Autoconfigure(_) => -libc::EINVAL,
+            }
+        }
+        Entry::Vacant(_) => -libc::ENOENT,
+    }
+}
+
 #[allow(clippy::missing_safety_doc)]
 #[no_mangle]
 pub unsafe extern "C" fn krun_add_serial_console_default(

src/vmm/src/builder.rs

@@ -24,7 +24,9 @@ use super::{Error, Vmm};
 #[cfg(target_arch = "x86_64")]
 use crate::device_manager::legacy::PortIODeviceManager;
 use crate::device_manager::mmio::MMIODeviceManager;
-use crate::resources::{DefaultVirtioConsoleConfig, VmResources};
+use crate::resources::{
+    DefaultVirtioConsoleConfig, PortConfig, VirtioConsoleConfigMode, VmResources,
+};
 use crate::vmm_config::external_kernel::{ExternalKernel, KernelFormat};
 #[cfg(feature = "net")]
 use crate::vmm_config::net::NetBuilder;
@@ -937,13 +939,13 @@ pub fn build_microvm(
         console_id += 1;
     }
 
-    for console in vm_resources.virtio_consoles.iter() {
+    for console_cfg in vm_resources.virtio_consoles.iter() {
         attach_console_devices(
             &mut vmm,
             event_manager,
             intc.clone(),
             vm_resources,
-            Some(console),
+            Some(console_cfg),
             console_id,
         )?;
         console_id += 1;
@@ -1982,19 +1984,88 @@ fn autoconfigure_console_ports(
     }
 }
 
+/// Creates explicit ports from configuration
+fn create_explicit_ports(
+    port_configs: &[PortConfig],
+) -> std::result::Result<Vec<PortDescription>, StartMicrovmError> {
+    let mut ports = Vec::with_capacity(port_configs.len());
+
+    for port_cfg in port_configs {
+        let port_desc = match port_cfg {
+            PortConfig::Tty { name, tty_fd } => {
+                let input = port_io::input_to_raw_fd_dup(*tty_fd).unwrap();
+                let output = port_io::output_to_raw_fd_dup(*tty_fd).unwrap();
+                let terminal = {
+                    let term_fd = unsafe { BorrowedFd::borrow_raw(*tty_fd) };
+                    if isatty(term_fd).unwrap_or(false) {
+                        Some(port_io::term_fd(*tty_fd).unwrap()
+                            as Box<dyn port_io::PortTerminalProperties>)
+                    } else {
+                        None
+                    }
+                };
+
+                PortDescription {
+                    name: name.clone().into(),
+                    input: Some(input),
+                    output: Some(output),
+                    terminal,
+                }
+            }
+            PortConfig::InOut {
+                name,
+                input_fd,
+                output_fd,
+            } => {
+                let input = port_io::input_to_raw_fd_dup(*input_fd).unwrap();
+                let output = port_io::output_to_raw_fd_dup(*output_fd).unwrap();
+
+                PortDescription {
+                    name: name.clone().into(),
+                    input: Some(input),
+                    output: Some(output),
+                    terminal: None,
+                }
+            }
+        };
+
+        ports.push(port_desc);
+    }
+
+    Ok(ports)
+}
+
 fn attach_console_devices(
     vmm: &mut Vmm,
     event_manager: &mut EventManager,
     intc: IrqChip,
     vm_resources: &VmResources,
-    cfg: Option<&DefaultVirtioConsoleConfig>,
+    cfg: Option<&VirtioConsoleConfigMode>,
     id_number: u32,
 ) -> std::result::Result<(), StartMicrovmError> {
     use self::StartMicrovmError::*;
 
     let creating_implicit_console = cfg.is_none();
 
-    let ports = autoconfigure_console_ports(vmm, vm_resources, cfg, creating_implicit_console)?;
+    let ports = match cfg {
+        None => {
+            // Implicit console - autoconfigure
+            autoconfigure_console_ports(vmm, vm_resources, None, creating_implicit_console)?
+        }
+        Some(VirtioConsoleConfigMode::Autoconfigure(autocfg)) => {
+            // Explicit autoconfigure mode
+            autoconfigure_console_ports(
+                vmm,
+                vm_resources,
+                Some(autocfg),
+                creating_implicit_console,
+            )?
+        }
+        Some(VirtioConsoleConfigMode::Explicit(ports)) => {
+            // Explicit ports mode - convert ExplicitPortConfig to PortDescription
+            create_explicit_ports(ports)?
+        }
+    };
 
     let console = Arc::new(Mutex::new(devices::virtio::Console::new(ports).unwrap()));
 

src/vmm/src/resources.rs

@@ -92,6 +92,23 @@ pub struct DefaultVirtioConsoleConfig {
     pub err_fd: RawFd,
 }
 
+pub enum VirtioConsoleConfigMode {
+    Autoconfigure(DefaultVirtioConsoleConfig),
+    Explicit(Vec<PortConfig>),
+}
+
+pub enum PortConfig {
+    Tty {
+        name: String,
+        tty_fd: RawFd,
+    },
+    InOut {
+        name: String,
+        input_fd: RawFd,
+        output_fd: RawFd,
+    },
+}
+
 /// A data structure that encapsulates the device configurations
 /// held in the Vmm.
 #[derive(Default)]
@@ -151,7 +168,7 @@ pub struct VmResources {
     /// Serial consoles to attach to the guest
     pub serial_consoles: Vec<SerialConsoleConfig>,
     /// Virtio consoles to attach to the guest
-    pub virtio_consoles: Vec<DefaultVirtioConsoleConfig>,
+    pub virtio_consoles: Vec<VirtioConsoleConfigMode>,
 }
 
 impl VmResources {