Introduce explict APIs for adding custom multiport virtio consoles

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

Author: mtjhrc

include/libkrun.h

@@ -985,6 +985,78 @@ 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.
+ * Each device appears in the guest with port 0 accessible as /dev/hvcN (hvc0, hvc1, etc.) in the order
+ * devices are added. If the implicit console is not disabled via `krun_disable_implicit_console`,
+ * the first explicitly added device will occupy the "hvc1" ID. Additional ports within each device
+ * (port 1, 2, ...) appear as /dev/vportNpM character devices.
+ *
+ * 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 TTY port to a multi-port virtio-console device.
+ *
+ * The TTY file descriptor is used for both input and output. This port will be marked with the
+ * VIRTIO_CONSOLE_CONSOLE_PORT flag, enabling console-specific features like window resize signals.
+ * In the guest, port 0 of each device appears as /dev/hvcN, while subsequent ports appear as
+ * /dev/vportNpM character devices (regardless of whether they are TTY or generic I/O ports).
+ *
+ * This port type supports terminal features including window size detection and resize signals,
+ * making it suitable 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 for identifying the port in the guest, can be empty ("")
+ *  "tty_fd"     - file descriptor for the TTY to use for both input, output, and determining terminal size
+ *
+ * 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 generic I/O port to a multi-port virtio-console device, suitable for arbitrary bidirectional 
+ * data streams that don't require terminal functionality.
+ *
+ * This port will NOT be marked with the VIRTIO_CONSOLE_CONSOLE_PORT flag, meaning it won't support
+ * console-specific features like window resize signals. Like all ports, if this is port 0 of
+ * the device, it will appear as /dev/hvcN in the guest; otherwise it only appears as /dev/vportNpM
+ * (also accessible via /sys/class/virtio-ports/).
+ *
+ *
+ * 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 for identifying the port in the guest, can be empty ("")
+ *  "input_fd"   - file descriptor to use for input (host writes, guest reads)
+ *  "output_fd"  - file descriptor to use for output (guest writes, host reads)
+ *
+ * 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/devices/src/virtio/console/device.rs

@@ -116,11 +116,10 @@ impl Console {
         self.sigwinch_evt.as_raw_fd()
     }
 
-    pub fn update_console_size(&mut self, cols: u16, rows: u16) {
-        log::debug!("update_console_size: {cols} {rows}");
-        // Note that we currently only support resizing on the first/main console
+    pub fn update_console_size(&mut self, port_id: u32, cols: u16, rows: u16) {
+        log::debug!("update_console_size {port_id}: {cols} {rows}");
         self.control
-            .console_resize(0, VirtioConsoleResize { rows, cols });
+            .console_resize(port_id, VirtioConsoleResize { rows, cols });
     }
 
     pub(crate) fn process_control_rx(&mut self) -> bool {

src/devices/src/virtio/console/event_handler.rs

@@ -88,9 +88,11 @@ impl Console {
             error!("Failed to read the sigwinch event: {e:?}");
         }
 
-        if let Some(term) = self.ports[0].terminal() {
-            let (cols, rows) = term.get_win_size();
-            self.update_console_size(cols, rows);
+        for i in 0..self.ports.len() {
+            if let Some(term) = self.ports[i].terminal() {
+                let (cols, rows) = term.get_win_size();
+                self.update_console_size(i as u32, cols, rows);
+            }
         }
     }
 

src/libkrun/src/lib.rs

@@ -13,10 +13,7 @@ use devices::virtio::CacheType;
 use env_logger::{Env, Target};
 #[cfg(feature = "gpu")]
 use krun_display::DisplayBackend;
-use libc::c_char;
-#[cfg(feature = "net")]
-use libc::c_int;
-use libc::size_t;
+use libc::{c_char, c_int, size_t};
 use once_cell::sync::Lazy;
 use polly::event_manager::EventManager;
 #[cfg(all(feature = "blk", not(feature = "tee")))]
@@ -29,16 +26,20 @@ use std::env;
 use std::ffi::CString;
 use std::ffi::{c_void, CStr};
 use std::fs::File;
+use std::io::IsTerminal;
 #[cfg(target_os = "linux")]
 use std::os::fd::AsRawFd;
-use std::os::fd::{FromRawFd, RawFd};
+use std::os::fd::{BorrowedFd, FromRawFd, RawFd};
 use std::path::PathBuf;
 use std::slice;
 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,24 +2119,128 @@ 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 tty_fd < 0 {
+        return -libc::EINVAL;
+    }
+
+    let name_str = if name.is_null() {
+        String::new()
+    } else {
+        match CStr::from_ptr(name).to_str() {
+            Ok(s) => s.to_string(),
+            Err(_) => return -libc::EINVAL,
+        }
+    };
+
+    if !BorrowedFd::borrow_raw(tty_fd).is_terminal() {
+        return -libc::ENOTTY;
+    }
+
+    match CTX_MAP.lock().unwrap().entry(ctx_id) {
+        Entry::Occupied(mut ctx_cfg) => {
+            let cfg = ctx_cfg.get_mut();
+
+            match cfg.vmr.virtio_consoles.get_mut(console_id as usize) {
+                Some(VirtioConsoleConfigMode::Explicit(ports)) => {
+                    ports.push(PortConfig::Tty {
+                        name: name_str,
+                        tty_fd,
+                    });
+                    KRUN_SUCCESS
+                }
+                _ => -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 c_char,
+    input_fd: c_int,
+    output_fd: c_int,
+) -> i32 {
+    let name_str = if name.is_null() {
+        String::new()
+    } else {
+        match 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();
+
+            match cfg.vmr.virtio_consoles.get_mut(console_id as usize) {
+                Some(VirtioConsoleConfigMode::Explicit(ports)) => {
+                    ports.push(PortConfig::InOut {
+                        name: name_str,
+                        input_fd,
+                        output_fd,
+                    });
+                    KRUN_SUCCESS
+                }
+                _ => -libc::EINVAL,
+            }
+        }
+        Entry::Vacant(_) => -libc::ENOENT,
+    }
+}
+
 #[allow(clippy::missing_safety_doc)]
 #[no_mangle]
 pub unsafe extern "C" fn krun_add_serial_console_default(
     ctx_id: u32,
-    input_fd: libc::c_int,
-    output_fd: libc::c_int,
+    input_fd: c_int,
+    output_fd: c_int,
 ) -> i32 {
     match CTX_MAP.lock().unwrap().entry(ctx_id) {
         Entry::Occupied(mut ctx_cfg) => {