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/console_control.rs

@@ -7,8 +7,8 @@ use utils::eventfd::EventFd;
 use vm_memory::{ByteValued, GuestMemoryMmap};
 
 use crate::virtio::console::defs::control_event::{
-    VIRTIO_CONSOLE_CONSOLE_PORT, VIRTIO_CONSOLE_PORT_ADD, VIRTIO_CONSOLE_PORT_OPEN,
-    VIRTIO_CONSOLE_RESIZE,
+    VIRTIO_CONSOLE_CONSOLE_PORT, VIRTIO_CONSOLE_PORT_ADD, VIRTIO_CONSOLE_PORT_NAME,
+    VIRTIO_CONSOLE_PORT_OPEN, VIRTIO_CONSOLE_RESIZE,
 };
 
 #[derive(Copy, Clone, Debug, Default)]
@@ -108,6 +108,23 @@ impl ConsoleControl {
         })
     }
 
+    pub fn port_name(&self, port_id: u32, name: &str) {
+        let mut buf: Vec<u8> = Vec::new();
+
+        buf.extend_from_slice(
+            VirtioConsoleControl {
+                id: port_id,
+                event: VIRTIO_CONSOLE_PORT_NAME,
+                value: 1, // Unspecified/unused in the spec, lets use the same value as QEMU.
+            }
+            .as_slice(),
+        );
+
+        // The spec says the name shouldn't be NUL terminated.
+        buf.extend(name.as_bytes());
+        self.push_vec(buf)
+    }
+
     pub fn queue_pop(&self) -> Option<Payload> {
         let mut queue = self.queue.lock().expect("Poisoned lock");
         queue.pop_front()

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;
@@ -17,13 +18,14 @@ use crate::legacy::Gic;
 use crate::virtio::console::console_control::{
     ConsoleControl, VirtioConsoleControl, VirtioConsoleResize,
 };
-use crate::virtio::console::defs::NUM_PORTS;
+use crate::virtio::console::defs::QUEUE_SIZE;
 use crate::virtio::console::irq_signaler::IRQSignaler;
 use crate::virtio::console::port::Port;
+use crate::virtio::console::port_queue_mapping::{
+    num_queues, port_id_to_queue_idx, QueueDirection,
+};
 use crate::virtio::PortDescription;
 
-pub(crate) const RXQ_INDEX: usize = 0;
-pub(crate) const TXQ_INDEX: usize = 1;
 pub(crate) const CONTROL_RXQ_INDEX: usize = 2;
 pub(crate) const CONTROL_TXQ_INDEX: usize = 3;
 
@@ -76,7 +78,7 @@ pub struct Console {
     pub(crate) device_state: DeviceState,
     pub(crate) irq: IRQSignaler,
     pub(crate) control: Arc<ConsoleControl>,
-    pub(crate) port: Port,
+    pub(crate) ports: Vec<Port>,
 
     pub(crate) queues: Vec<VirtQueue>,
     pub(crate) queue_events: Vec<EventFd>,
@@ -91,11 +93,15 @@ pub struct Console {
 }
 
 impl Console {
-    pub fn new(port: PortDescription) -> super::Result<Console> {
-        let queues: Vec<VirtQueue> = defs::QUEUE_SIZES
-            .iter()
-            .map(|&max_size| VirtQueue::new(max_size))
-            .collect();
+    pub fn new(ports: Vec<PortDescription>) -> super::Result<Console> {
+        assert!(!ports.is_empty(), "Expected at least 1 port");
+        assert!(
+            matches!(ports[0], PortDescription::Console { .. }),
+            "First port must be a console"
+        );
+
+        let num_queues = num_queues(ports.len());
+        let queues = vec![VirtQueue::new(QUEUE_SIZE); num_queues];
 
         let mut queue_events = Vec::new();
         for _ in 0..queues.len() {
@@ -104,12 +110,15 @@ impl Console {
         }
 
         let (cols, rows) = get_win_size();
-        let config = VirtioConsoleConfig::new(cols, rows, NUM_PORTS as u32);
+        let config = VirtioConsoleConfig::new(cols, rows, ports.len() as u32);
+        let ports = zip(0u32.., ports)
+            .map(|(port_id, description)| Port::new(port_id, description))
+            .collect();
 
         Ok(Console {
             irq: IRQSignaler::new(),
             control: ConsoleControl::new(),
-            port: Port::new(0, port),
+            ports,
             queues,
             queue_events,
             avail_features: AVAIL_FEATURES,
@@ -181,7 +190,7 @@ impl Console {
         let tx_queue = &mut self.queues[CONTROL_TXQ_INDEX];
         let mut raise_irq = false;
 
-        let mut start_port = false;
+        let mut ports_to_start = Vec::new();
 
         while let Some(head) = tx_queue.pop(mem) {
             raise_irq = true;
@@ -206,14 +215,28 @@ 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 {
                         log::error!("Port initialization failed: {:?}", cmd);
                         continue;
                     }
-                    self.control.mark_console_port(mem, cmd.id);
+
+                    if self.ports[cmd.id as usize].is_console() {
+                        self.control.mark_console_port(mem, cmd.id);
+                    } else {
+                        // We start with all ports open, this makes sense for now,
+                        // because underlying file descriptors STDIN, STDOUT, STDERR are always open too
+                        self.control.port_open(cmd.id, true)
+                    }
+
+                    let name = self.ports[cmd.id as usize].name();
+                    if !name.is_empty() {
+                        self.control.port_name(cmd.id, name)
+                    }
                 }
                 control_event::VIRTIO_CONSOLE_PORT_OPEN => {
                     let opened = match cmd.value {
@@ -234,18 +257,18 @@ impl Console {
                         continue;
                     }
 
-                    start_port = true;
+                    ports_to_start.push(cmd.id as usize);
                 }
                 _ => log::warn!("Unknown console control event {:x}", cmd.event),
             }
         }
 
-        if start_port {
-            log::trace!("Starting port");
-            self.port.start(
+        for port_id in ports_to_start {
+            log::trace!("Starting port io for port {}", port_id);
+            self.ports[port_id].start(
                 mem.clone(),
-                self.queues[RXQ_INDEX].clone(),
-                self.queues[TXQ_INDEX].clone(),
+                self.queues[port_id_to_queue_idx(QueueDirection::Rx, port_id)].clone(),
+                self.queues[port_id_to_queue_idx(QueueDirection::Tx, port_id)].clone(),
                 self.irq.clone(),
                 self.control.clone(),
             );

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 {
@@ -25,6 +26,20 @@ impl Console {
         true
     }
 
+    fn notify_port_queue_event(&mut self, queue_index: usize) {
+        let (direction, port_id) = queue_idx_to_port_id(queue_index);
+        match direction {
+            QueueDirection::Rx => {
+                log::trace!("Notify rx (queue event)");
+                self.ports[port_id].notify_rx()
+            }
+            QueueDirection::Tx => {
+                log::trace!("Notify tx (queue event)");
+                self.ports[port_id].notify_tx()
+            }
+        }
+    }
+
     fn handle_activate_event(&self, event_manager: &mut EventManager) {
         debug!("console: activate event");
         if let Err(e) = self.activate_evt.read() {
@@ -92,8 +107,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();
@@ -114,12 +127,14 @@ impl Subscriber for Console {
             } else if source == control_rxq {
                 raise_irq |= self.read_queue_event(CONTROL_RXQ_INDEX, event)
             }
-            else if source == rxq {
-                self.read_queue_event(RXQ_INDEX, event);
-                self.port.notify_rx();
-            } else if source == txq {
-                self.read_queue_event(TXQ_INDEX, event);
-                self.port.notify_tx()
+            /* Guest signaled input/output on port */
+            else if let Some(queue_index) = self
+                .queue_events
+                .iter()
+                .position(|fd| fd.as_raw_fd() == source)
+            {
+                raise_irq |= self.read_queue_event(queue_index, event);
+                self.notify_port_queue_event(queue_index);
             } else if source == activate_evt {
                 self.handle_activate_event(event_manager);
             } else if source == sigwinch_evt {

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

@@ -4,6 +4,7 @@ mod event_handler;
 mod irq_signaler;
 mod port;
 pub mod port_io;
+mod port_queue_mapping;
 mod process_rx;
 mod process_tx;
 
@@ -13,10 +14,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.