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,168 @@
+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};
+
+    fn spawn_ping_pong_responder(stream: UnixStream) {
+        thread::spawn(move || {
+            let mut reader = BufReader::new(stream.try_clone().unwrap());
+            let mut writer = stream;
+            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();
+            }
+        });
+    }
+
+    fn add_console_port(
+        ctx: u32,
+        console_id: u32,
+        name: &str,
+    ) -> anyhow::Result<(UnixStream, UnixStream)> {
+        let (guest, host) = UnixStream::pair()?;
+        let name_cstring = CString::new(name)?;
+        unsafe {
+            krun_call!(krun_add_console_port_inout(
+                ctx,
+                console_id,
+                name_cstring.as_ptr(),
+                guest.as_raw_fd(),
+                guest.as_raw_fd()
+            ))?;
+        }
+        Ok((guest, host))
+    }
+
+    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))?;
+
+                // Add 3 inout ports with different names
+                let (port1_guest, port1_host) =
+                    add_console_port(ctx, console_id, "test-port-alpha")?;
+                let (port2_guest, port2_host) =
+                    add_console_port(ctx, console_id, "test-port-beta")?;
+                let (port3_guest, port3_host) =
+                    add_console_port(ctx, console_id, "test-port-gamma")?;
+
+                spawn_ping_pong_responder(port1_host);
+                spawn_ping_pong_responder(port2_host);
+                spawn_ping_pong_responder(port3_host);
+
+                // 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};
+
+    fn test_port(port_map: &std::collections::HashMap<String, String>, name: &str, message: &str) {
+        let device_path = format!("/dev/{}", port_map.get(name).unwrap());
+        let mut port = fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(&device_path)
+            .unwrap();
+
+        port.write_all(message.as_bytes()).unwrap();
+        port.flush().unwrap();
+
+        let mut reader = BufReader::new(port);
+        let mut response = String::new();
+        reader.read_line(&mut response).unwrap();
+
+        let expected = message.replace("PING", "PONG").trim().to_string();
+        assert_eq!(response.trim(), expected, "{}: wrong response", name);
+    }
+
+    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_port(&port_map, "test-port-alpha", "PING-ALPHA\n");
+            test_port(&port_map, "test-port-beta", "PING-BETA\n");
+            test_port(&port_map, "test-port-gamma", "PING-GAMMA\n");
+
+            println!("OK");
+        }
+    }
+}