virtio-console: Implement redirection for stdin/stdout/stderr

TODO: implement stderr here too!

This is done by creating a port for each of stdin/stdout/stderr,
Each of these ports is multidirectional but we only use one direction.
Port 0 must always be a console - this is implied by the specification.

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

Author: mtjhrc

init/init.c

@@ -756,6 +756,68 @@ void clock_worker()
 }
 #endif
 
+int reopen_fd(int fd, char *path, int flags)
+{
+    int newfd = open(path,flags);
+    if (newfd < 0) {
+        printf("Failed to open '%s': %s\n", path,strerror(errno));
+        return -1;
+    }
+
+    close(fd);
+    if (dup2(newfd, fd) < 0) {
+        perror("dup2");
+        close(newfd);
+        return -1;
+    }
+    close(newfd);
+    return 0;
+}
+
+int setup_redirects()
+{
+    DIR *ports_dir = opendir("/sys/class/virtio-ports");
+    if (ports_dir == NULL) {
+        printf("Unable to open ports directory!\n");
+        return -4;
+    }
+
+    char path[2048];
+    char name_buf[1024];
+
+    struct dirent *entry = NULL;
+    while ((entry=readdir(ports_dir))) {
+        char* port_identifier = entry->d_name;
+        int result_len = snprintf(path, sizeof(path), "/sys/class/virtio-ports/%s/name", port_identifier);
+
+        // result was truncated
+        if (result_len > sizeof(name_buf) - 1) {
+            printf("Path buffer too small");
+            return -1;
+        }
+
+        FILE *port_name_file = fopen(path, "r");
+        if (port_name_file == NULL) {
+            continue;
+        }
+
+        char *port_name = fgets(name_buf, sizeof(name_buf), port_name_file);
+        fclose(port_name_file);
+
+        if (port_name != NULL && strcmp(port_name, "krun-stdin\n") == 0) {
+            // if previous snprintf didn't fail, this one cannot fail either
+            snprintf(path, sizeof(path), "/dev/%s", port_identifier);
+            reopen_fd(STDIN_FILENO, path, O_RDONLY);
+        }else if (port_name != NULL && strcmp(port_name, "krun-stdout\n") == 0) {
+             snprintf(path, sizeof(path), "/dev/%s", port_identifier);
+             reopen_fd(STDOUT_FILENO, path, O_WRONLY);
+        }
+    }
+
+    closedir(ports_dir);
+    return 0;
+}
+
 int main(int argc, char **argv)
 {
 	struct ifreq ifr;
@@ -848,6 +910,10 @@ int main(int argc, char **argv)
 	}
 #endif
 
+    if (setup_redirects() < 0) {
+       exit(-4);
+    }
+
 	if (execvp(exec_argv[0], exec_argv) < 0) {
 		printf("Couldn't execute '%s' inside the vm: %s\n", exec_argv[0], strerror(errno));
 		exit(-3);

src/devices/src/virtio/console/device.rs

@@ -1,5 +1,6 @@
 use std::cmp;
 use std::io::Write;
+use std::iter::zip;
 use std::mem::{size_of, size_of_val};
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::sync::atomic::AtomicUsize;
@@ -206,7 +207,9 @@ impl Console {
                         "Device is ready: initialization {}",
                         if cmd.value == 1 { "ok" } else { "failed" }
                     );
-                    self.control.port_add(0);
+                    for port_id in 0..self.ports.len() {
+                        self.control.port_add(port_id as u32);
+                    }
                 }
                 control_event::VIRTIO_CONSOLE_PORT_READY => {
                     if cmd.value != 1 {

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

@@ -3,8 +3,9 @@ use std::os::unix::io::AsRawFd;
 use polly::event_manager::{EventManager, Subscriber};
 use utils::epoll::{EpollEvent, EventSet};
 
-use super::device::{get_win_size, Console, RXQ_INDEX, TXQ_INDEX};
+use super::device::{get_win_size, Console};
 use crate::virtio::console::device::{CONTROL_RXQ_INDEX, CONTROL_TXQ_INDEX};
+use crate::virtio::console::port_queue_mapping::{queue_idx_to_port_id, QueueDirection};
 use crate::virtio::device::VirtioDevice;
 
 impl Console {
@@ -92,8 +93,6 @@ impl Console {
 impl Subscriber for Console {
     fn process(&mut self, event: &EpollEvent, event_manager: &mut EventManager) {
         let source = event.fd();
-        let rxq = self.queue_events[RXQ_INDEX].as_raw_fd();
-        let txq = self.queue_events[TXQ_INDEX].as_raw_fd();
 
         let control_rxq = self.queue_events[CONTROL_RXQ_INDEX].as_raw_fd();
         let control_txq = self.queue_events[CONTROL_TXQ_INDEX].as_raw_fd();

src/devices/src/virtio/console/mod.rs

@@ -13,10 +13,7 @@ pub use self::port::PortDescription;
 
 mod defs {
     pub const CONSOLE_DEV_ID: &str = "virtio_console";
-    pub const NUM_PORTS: usize = 1;
-    // 2 control queues and then an rx and tx queue for each port
-    pub const NUM_QUEUES: usize = 2 + NUM_PORTS * 2;
-    pub const QUEUE_SIZES: &[u16] = &[256; NUM_QUEUES];
+    pub const QUEUE_SIZE: u16 = 32;
 
     pub mod uapi {
         /// The device conforms to the virtio spec version 1.0.

src/devices/src/virtio/console/port_queue_mapping.rs

@@ -0,0 +1,74 @@
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) enum QueueDirection {
+    Rx,
+    Tx,
+}
+
+#[must_use]
+pub(crate) fn port_id_to_queue_idx(queue_direction: QueueDirection, port_id: usize) -> usize {
+    match queue_direction {
+        QueueDirection::Rx if port_id == 0 => 0,
+        QueueDirection::Rx => 2 + 2 * port_id,
+        QueueDirection::Tx if port_id == 0 => 1,
+        QueueDirection::Tx => 2 + 2 * port_id + 1,
+    }
+}
+
+#[must_use]
+pub(crate) fn queue_idx_to_port_id(queue_index: usize) -> (QueueDirection, usize) {
+    let port_id = match queue_index {
+        0 | 1 => 0,
+        2 | 3 => {
+            panic!("Invalid argument: {queue_index} is not a valid receiveq nor transmitq index!")
+        }
+        _ => queue_index / 2 - 1,
+    };
+
+    let direction = if queue_index % 2 == 0 {
+        QueueDirection::Rx
+    } else {
+        QueueDirection::Tx
+    };
+
+    (direction, port_id)
+}
+
+pub(crate) fn num_queues(num_ports: usize) -> usize {
+    // 2 control queues and then an rx and tx queue for each port
+    2 + 2 * num_ports
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_port_id_to_queue_idx() {
+        assert_eq!(port_id_to_queue_idx(QueueDirection::Rx, 0), 0);
+        assert_eq!(port_id_to_queue_idx(QueueDirection::Tx, 0), 1);
+        assert_eq!(port_id_to_queue_idx(QueueDirection::Rx, 1), 4);
+        assert_eq!(port_id_to_queue_idx(QueueDirection::Tx, 1), 5);
+    }
+
+    #[test]
+    fn test_queue_idx_to_port_id_ok() {
+        assert_eq!(queue_idx_to_port_id(0), (QueueDirection::Rx, 0));
+        assert_eq!(queue_idx_to_port_id(1), (QueueDirection::Tx, 0));
+        assert_eq!(queue_idx_to_port_id(4), (QueueDirection::Rx, 1));
+        assert_eq!(queue_idx_to_port_id(5), (QueueDirection::Tx, 1));
+        assert_eq!(queue_idx_to_port_id(6), (QueueDirection::Rx, 2));
+        assert_eq!(queue_idx_to_port_id(7), (QueueDirection::Tx, 2));
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_queue_idx_to_port_id_panic_rx_control() {
+        let _ = queue_idx_to_port_id(2);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_queue_idx_to_port_id_panic_tx_control() {
+        let _ = queue_idx_to_port_id(3);
+    }
+}

src/vmm/src/builder.rs

@@ -48,6 +48,8 @@ use arch::ArchMemoryInfo;
 use arch::InitrdConfig;
 #[cfg(feature = "tee")]
 use kvm_bindings::KVM_MAX_CPUID_ENTRIES;
+use libc::{STDIN_FILENO, STDOUT_FILENO};
+use nix::unistd::isatty;
 use polly::event_manager::{Error as EventManagerError, EventManager};
 use utils::eventfd::EventFd;
 use utils::time::TimestampUs;