tests: Add a simple test for custom multiport virtio console config

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

Author: mtjhrc

tests/test_cases/src/lib.rs

@@ -10,6 +10,9 @@ use test_tsi_tcp_guest_connect::TestTsiTcpGuestConnect;
 mod test_tsi_tcp_guest_listen;
 use test_tsi_tcp_guest_listen::TestTsiTcpGuestListen;
 
+mod test_multiport_console;
+use test_multiport_console::TestMultiportConsole;
+
 pub fn test_cases() -> Vec<TestCase> {
     // Register your test here:
     vec![
@@ -36,6 +39,7 @@ pub fn test_cases() -> Vec<TestCase> {
             "tsi-tcp-guest-listen",
             Box::new(TestTsiTcpGuestListen::new()),
         ),
+        TestCase::new("multiport-console", Box::new(TestMultiportConsole)),
     ]
 }
 

tests/test_cases/src/test_multiport_console.rs

@@ -0,0 +1,215 @@
+use macros::{guest, host};
+
+pub struct TestMultiportConsole;
+
+#[host]
+mod host {
+    use super::*;
+
+    use crate::common::setup_fs_and_enter;
+    use crate::{krun_call, krun_call_u32};
+    use crate::{Test, TestSetup};
+    use krun_sys::*;
+    use std::ffi::CString;
+    use std::io::{BufRead, BufReader, Write};
+    use std::os::fd::AsRawFd;
+    use std::os::unix::net::UnixStream;
+    use std::{mem, thread};
+
+    impl Test for TestMultiportConsole {
+        fn start_vm(self: Box<Self>, test_setup: TestSetup) -> anyhow::Result<()> {
+            unsafe {
+                krun_call!(krun_set_log_level(KRUN_LOG_LEVEL_WARN))?;
+                let ctx = krun_call_u32!(krun_create_ctx())?;
+
+                // Disable implicit console
+                krun_call!(krun_disable_implicit_console(ctx))?;
+
+                // Add a default console with STDIN/STDOUT/STDERR
+                krun_call!(krun_add_virtio_console_default(
+                    ctx,
+                    std::io::stdin().as_raw_fd(),
+                    std::io::stdout().as_raw_fd(),
+                    std::io::stderr().as_raw_fd()
+                ))?;
+
+                // Create a multiport console
+                let console_id = krun_call_u32!(krun_add_virtio_console_multiport(ctx))?;
+
+                let (port1_guest, port1_host) = UnixStream::pair()?;
+                let (port2_guest, port2_host) = UnixStream::pair()?;
+                let (port3_guest, port3_host) = UnixStream::pair()?;
+
+                // Add 3 inout ports with different names
+                let port1_name = CString::new("test-port-alpha")?;
+                krun_call!(krun_add_console_port_inout(
+                    ctx,
+                    console_id,
+                    port1_name.as_ptr(),
+                    port1_guest.as_raw_fd(),
+                    port1_guest.as_raw_fd()
+                ))?;
+
+                let port2_name = CString::new("test-port-beta")?;
+                krun_call!(krun_add_console_port_inout(
+                    ctx,
+                    console_id,
+                    port2_name.as_ptr(),
+                    port2_guest.as_raw_fd(),
+                    port2_guest.as_raw_fd()
+                ))?;
+
+                let port3_name = CString::new("test-port-gamma")?;
+                krun_call!(krun_add_console_port_inout(
+                    ctx,
+                    console_id,
+                    port3_name.as_ptr(),
+                    port3_guest.as_raw_fd(),
+                    port3_guest.as_raw_fd()
+                ))?;
+
+                // Spawn handler threads for each port that echo back
+                thread::spawn(move || {
+                    let mut reader = BufReader::new(port1_host.try_clone().unwrap());
+                    let mut writer = port1_host;
+                    let mut line = String::new();
+                    while reader.read_line(&mut line).is_ok() && !line.is_empty() {
+                        let response = line.replace("PING", "PONG");
+                        writer.write_all(response.as_bytes()).unwrap();
+                        writer.flush().unwrap();
+                        line.clear();
+                    }
+                });
+
+                thread::spawn(move || {
+                    let mut reader = BufReader::new(port2_host.try_clone().unwrap());
+                    let mut writer = port2_host;
+                    let mut line = String::new();
+                    while reader.read_line(&mut line).is_ok() && !line.is_empty() {
+                        let response = line.replace("PING", "PONG");
+                        writer.write_all(response.as_bytes()).unwrap();
+                        writer.flush().unwrap();
+                        line.clear();
+                    }
+                });
+
+                thread::spawn(move || {
+                    let mut reader = BufReader::new(port3_host.try_clone().unwrap());
+                    let mut writer = port3_host;
+                    let mut line = String::new();
+                    while reader.read_line(&mut line).is_ok() && !line.is_empty() {
+                        let response = line.replace("PING", "PONG");
+                        writer.write_all(response.as_bytes()).unwrap();
+                        writer.flush().unwrap();
+                        line.clear();
+                    }
+                });
+
+                // Keep the guest-side streams open for the VM
+                mem::forget(port1_guest);
+                mem::forget(port2_guest);
+                mem::forget(port3_guest);
+
+                krun_call!(krun_set_vm_config(ctx, 1, 1024))?;
+                setup_fs_and_enter(ctx, test_setup)?;
+            }
+            Ok(())
+        }
+    }
+}
+
+#[guest]
+mod guest {
+    use super::*;
+    use crate::Test;
+    use std::fs;
+    use std::io::{BufRead, BufReader, Write};
+
+    impl Test for TestMultiportConsole {
+        fn in_guest(self: Box<Self>) {
+            // List all virtio ports to find our named ports
+            let ports_dir = "/sys/class/virtio-ports";
+
+            let mut port_map = std::collections::HashMap::new();
+
+            for entry in fs::read_dir(ports_dir).unwrap() {
+                let entry = entry.unwrap();
+                let port_name_path = entry.path().join("name");
+
+                if port_name_path.exists() {
+                    let port_name = fs::read_to_string(&port_name_path)
+                        .unwrap()
+                        .trim()
+                        .to_string();
+
+                    if !port_name.is_empty() {
+                        let device_name = entry.file_name().to_string_lossy().to_string();
+                        port_map.insert(port_name, device_name);
+                    }
+                }
+            }
+
+            // Verify we have all three ports
+            assert!(
+                port_map.contains_key("test-port-alpha"),
+                "test-port-alpha not found"
+            );
+            assert!(
+                port_map.contains_key("test-port-beta"),
+                "test-port-beta not found"
+            );
+            assert!(
+                port_map.contains_key("test-port-gamma"),
+                "test-port-gamma not found"
+            );
+
+            // Test alpha port: write PING, read PONG
+            let alpha_path = format!("/dev/{}", port_map.get("test-port-alpha").unwrap());
+            let mut alpha_port = fs::OpenOptions::new()
+                .read(true)
+                .write(true)
+                .open(&alpha_path)
+                .unwrap();
+            alpha_port.write_all(b"PING-ALPHA\n").unwrap();
+            alpha_port.flush().unwrap();
+            let mut reader = BufReader::new(alpha_port);
+            let mut response = String::new();
+            reader.read_line(&mut response).unwrap();
+            assert_eq!(response.trim(), "PONG-ALPHA", "Alpha port: wrong response");
+
+            // Test beta port: write PING, read PONG
+            let beta_path = format!("/dev/{}", port_map.get("test-port-beta").unwrap());
+            let mut beta_port = fs::OpenOptions::new()
+                .read(true)
+                .write(true)
+                .open(&beta_path)
+                .unwrap();
+            beta_port.write_all(b"PING-BETA\n").unwrap();
+            beta_port.flush().unwrap();
+            let mut reader = BufReader::new(beta_port);
+            let mut response = String::new();
+            reader.read_line(&mut response).unwrap();
+            assert_eq!(response.trim(), "PONG-BETA", "Beta port: wrong response");
+
+            // Test gamma port: write PING, read PONG
+            let gamma_path = format!("/dev/{}", port_map.get("test-port-gamma").unwrap());
+            let mut gamma_port = fs::OpenOptions::new()
+                .read(true)
+                .write(true)
+                .open(&gamma_path)
+                .unwrap();
+            gamma_port.write_all(b"PING-GAMMA\n").unwrap();
+            gamma_port.flush().unwrap();
+            let mut reader = BufReader::new(gamma_port);
+            let mut response = String::new();
+            reader.read_line(&mut response).unwrap();
+            assert_eq!(
+                response.trim(),
+                "PONG-GAMMA",
+                "Gamma port: wrong response"
+            );
+
+            println!("OK");
+        }
+    }
+}