Full multiport console (missing blocking shutdown)

console: Introduce port abstraction and use VolatileRead/Write

Curently only 1 (console) port is supported.

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

console: Re-implement console resize for multiport console

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

All the cleanups

squashme: process_tx no log

virtio-console: prepare device to handle more ports

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

virtio-console: Make redirected stdin go through a pipe (not console)

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

virtio-net: Handle input EOF and pending input before guest is ready

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

virtio-console: Make output non-blocking

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

virtio-console: Make stdout a pipe if !isatty

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

Multithreaded virtio-console with eof handling

suboptimal but working

suboptimal but working

poll inside the rx/tx thread instead of global event_manager

try to write the descriptor chains, but doesn't really help :(

tweaks and logging stuff, importantly we crash when input is EOF, so handle that ASAP

move process_tx to the main thread a have a queue in front of it

propage ConsoleControl into PortRX/portTx

wip

hardcoded pipe input works

refactor cleanup Port

abstract PortOutput/PortInput as traits

close eof on the correct port number

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

Author: mtjhrc

Cargo.lock

@@ -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);

init/init.c

@@ -15,7 +15,7 @@ crossbeam-channel = "0.5"
 env_logger = "0.9.0"
 libc = ">=0.2.39"
 log = "0.4.0"
-nix = "0.24.1"
+nix = { version = "0.24.1", features = ["poll"] }
 rand = "0.8.5"
 vm-memory = { version = ">=0.13", features = ["backend-mmap"] }
 

src/devices/Cargo.toml

@@ -1,8 +1,15 @@
+use std::collections::VecDeque;
+use std::ops::Deref;
+use std::sync::{Arc, Mutex};
+
+use libc::EFD_NONBLOCK;
+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_CONSOLE_PORT, VIRTIO_CONSOLE_PORT_ADD, VIRTIO_CONSOLE_PORT_NAME,
+    VIRTIO_CONSOLE_PORT_OPEN, VIRTIO_CONSOLE_RESIZE,
 };
-use crate::virtio::Queue as VirtQueue;
-use vm_memory::{ByteValued, Bytes, GuestMemoryMmap};
 
 #[derive(Copy, Clone, Debug, Default)]
 #[repr(C, packed(4))]
@@ -19,53 +26,127 @@ pub struct VirtioConsoleControl {
 // But NOTE that this relies on CPU being little endian, to have correct semantics
 unsafe impl ByteValued for VirtioConsoleControl {}
 
+#[derive(Copy, Clone, Debug, Default)]
+#[repr(C, packed)]
+pub struct VirtioConsoleResize {
+    // NOTE: the order of these fields in the actual kernel implementation and in the spec are swapped,
+    // we follow the order in the kernel to get it working correctly
+    pub rows: u16,
+    pub cols: u16,
+}
+
+// Safe because it only has data and has no implicit padding.
+// but NOTE, that we rely on CPU being little endian, for the values to be correct
+unsafe impl ByteValued for VirtioConsoleResize {}
+
+pub enum Payload {
+    ConsoleControl(VirtioConsoleControl),
+    Bytes(Vec<u8>),
+}
+
+impl Deref for Payload {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Payload::ConsoleControl(b) => b.as_slice(),
+            Payload::Bytes(b) => b.as_slice(),
+        }
+    }
+}
+
 // Utility for sending commands into control rx queue
-pub struct ConsoleControlSender<'a> {
-    queue: &'a mut VirtQueue,
+pub struct ConsoleControl {
+    queue: Mutex<VecDeque<Payload>>,
+    queue_evt: EventFd,
 }
 
-impl<'a> ConsoleControlSender<'a> {
-    pub fn new(control_rx_queue: &'a mut VirtQueue) -> Self {
-        return ConsoleControlSender {
-            queue: control_rx_queue,
-        };
+impl ConsoleControl {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            queue: Default::default(),
+            queue_evt: EventFd::new(EFD_NONBLOCK).unwrap(),
+        })
     }
 
-    pub fn send_mark_console_port(&mut self, mem: &GuestMemoryMmap, port_id: u32) {
-        self.send_cmd(
-            mem,
-            &VirtioConsoleControl {
-                id: port_id,
-                event: VIRTIO_CONSOLE_CONSOLE_PORT,
-                value: 1,
-            },
-        )
+    pub fn mark_console_port(&self, _mem: &GuestMemoryMmap, port_id: u32) {
+        self.push_msg(VirtioConsoleControl {
+            id: port_id,
+            event: VIRTIO_CONSOLE_CONSOLE_PORT,
+            value: 1,
+        })
     }
 
-    /// Adds another port with the specified port_id
-    pub fn send_port_add(&mut self, mem: &GuestMemoryMmap, port_id: u32) {
-        self.send_cmd(
-            mem,
-            &VirtioConsoleControl {
+    pub fn console_resize(&self, port_id: u32, new_size: VirtioConsoleResize) {
+        let mut buf = Vec::new();
+        buf.extend(
+            VirtioConsoleControl {
                 id: port_id,
-                event: VIRTIO_CONSOLE_PORT_ADD,
+                event: VIRTIO_CONSOLE_RESIZE,
                 value: 0,
-            },
-        )
+            }
+            .as_slice(),
+        );
+        buf.extend(new_size.as_slice());
+        self.push_vec(buf)
+    }
+
+    /// Adds another port with the specified port_id
+    pub fn port_add(&self, port_id: u32) {
+        self.push_msg(VirtioConsoleControl {
+            id: port_id,
+            event: VIRTIO_CONSOLE_PORT_ADD,
+            value: 0,
+        })
     }
 
-    fn send_bytes(&mut self, mem: &GuestMemoryMmap, data: &[u8]) {
-        if let Some(head) = self.queue.pop(mem) {
-            if let Err(e) = mem.write_slice(data, head.addr) {
-                log::error!("Failed to write to tx_control_queue: {e:?}");
+    pub fn port_open(&self, port_id: u32, open: bool) {
+        self.push_msg(VirtioConsoleControl {
+            id: port_id,
+            event: VIRTIO_CONSOLE_PORT_OPEN,
+            value: open as u16,
+        })
+    }
+
+    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.
             }
-            self.queue.add_used(mem, head.index, data.len() as u32);
-        } else {
-            log::error!("Failed to write to tx_control_queue: no space in queue");
+            .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()
+    }
+
+    pub fn queue_evt(&self) -> &EventFd {
+        &self.queue_evt
+    }
+
+    fn push_msg(&self, msg: VirtioConsoleControl) {
+        let mut queue = self.queue.lock().expect("Poisoned lock");
+        queue.push_back(Payload::ConsoleControl(msg));
+        if let Err(e) = self.queue_evt.write(1) {
+            log::trace!("ConsoleControl failed to write to notify {e}")
         }
     }
 
-    fn send_cmd(&mut self, mem: &GuestMemoryMmap, cmd: &VirtioConsoleControl) {
-        self.send_bytes(mem, cmd.as_slice())
+    fn push_vec(&self, buf: Vec<u8>) {
+        let mut queue = self.queue.lock().expect("Poisoned lock");
+        queue.push_back(Payload::Bytes(buf));
+        if let Err(e) = self.queue_evt.write(1) {
+            log::trace!("ConsoleControl failed to write to notify {e}")
+        }
     }
 }