virtio-console: Basic support for passign SIGINT to guest

This works by writing ascii 'ETX' into the guest console on SIGINT.
This curently only works when the guest input is redirected (otherwise
pressing ^C should work, but SIGINT to the host libkrun process
won't work.

Furthermore init process needs to fork itself, because pid 1
cannot receive SIGINT signal, unless it instals a handler, but we cannot
expect all programs to do that.

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

Author: mtjhrc

init/init.c

@@ -8,6 +8,7 @@
 #include <string.h>
 #include <time.h>
 #include <dirent.h>
+#include <termios.h>
 
 #include <net/if.h>
 #include <sys/ioctl.h>
@@ -913,15 +914,23 @@ int main(int argc, char **argv)
 	}
 #endif
 
-    if (setup_redirects() < 0) {
-       exit(-4);
+    // We need to fork ourselves, because pid 1 cannot doesn't receive SIGINT signal
+    int pid = fork();
+    if (pid < 0) {
+        perror("fork");
+        exit(-3);
+    } if (pid == 0) { // child
+        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);
+        }
+    } else { // parent
+        // wait for children since we can't exit init
+        waitpid(pid, NULL, 0);
     }
 
-	if (execvp(exec_argv[0], exec_argv) < 0) {
-		//TODO: maybe print this msg to the console not redirected stdout?
-		printf("Couldn't execute '%s' inside the vm: %s\n", exec_argv[0], strerror(errno));
-		exit(-3);
-	}
-
 	return 0;
 }

src/devices/src/virtio/console/port_io.rs

@@ -1,11 +1,14 @@
 use std::io::{self, ErrorKind};
 use std::os::fd::{AsRawFd, FromRawFd, OwnedFd, RawFd};
 
-use libc::{fcntl, F_GETFL, F_SETFL, O_NONBLOCK, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO};
+use libc::{
+    fcntl, EFD_NONBLOCK, F_GETFL, F_SETFL, O_NONBLOCK, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO,
+};
 use log::Level;
 use nix::errno::Errno;
 use nix::poll::{poll, PollFd, PollFlags};
 use nix::unistd::dup;
+use utils::eventfd::EventFd;
 use vm_memory::bitmap::Bitmap;
 use vm_memory::{VolatileMemoryError, VolatileSlice, WriteVolatile};
 
@@ -179,3 +182,40 @@ impl PortOutput for PortOutputLog {
 
     fn wait_until_writable(&self) {}
 }
+
+pub struct PortInputSigInt {
+    sigint_evt: EventFd,
+}
+
+impl PortInputSigInt {
+    pub fn new() -> Self {
+        PortInputSigInt {
+            sigint_evt: EventFd::new(EFD_NONBLOCK)
+                .expect("Failed to create EventFd for SIGINT signaling"),
+        }
+    }
+
+    pub fn sigint_evt(&self) -> &EventFd {
+        &self.sigint_evt
+    }
+}
+
+impl Default for PortInputSigInt {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PortInput for PortInputSigInt {
+    fn read_volatile(&mut self, buf: &mut VolatileSlice) -> Result<usize, io::Error> {
+        self.sigint_evt.read()?;
+        log::trace!("SIGINT received");
+        buf.copy_from(&[3u8]); //ASCII 'ETX' -> generates SIGINIT in a terminal
+        Ok(1)
+    }
+
+    fn wait_until_readable(&self) {
+        let mut poll_fds = [PollFd::new(self.sigint_evt.as_raw_fd(), PollFlags::POLLIN)];
+        poll(&mut poll_fds, -1).expect("Failed to poll");
+    }
+}

src/vmm/src/builder.rs

@@ -7,6 +7,7 @@
 use crossbeam_channel::unbounded;
 use std::fmt::{Display, Formatter};
 use std::io;
+use std::os::fd::AsRawFd;
 use std::sync::{Arc, Mutex};
 
 use super::{Error, Vmm};
@@ -28,6 +29,7 @@ use kbs_types::Tee;
 use crate::device_manager;
 #[cfg(feature = "tee")]
 use crate::resources::TeeConfig;
+use crate::signal_handler::register_sigint_handler;
 #[cfg(target_os = "linux")]
 use crate::signal_handler::register_sigwinch_handler;
 use crate::terminal::term_set_raw_mode;
@@ -1040,9 +1042,6 @@ fn attach_console_devices(
     intc: Option<Arc<Mutex<Gic>>>,
 ) -> std::result::Result<(), StartMicrovmError> {
     use self::StartMicrovmError::*;
-    if let Err(e) = term_set_raw_mode(false) {
-        log::error!("Failed to set terminal to raw mode: {e}")
-    }
 
     let stdin_is_terminal = isatty(STDIN_FILENO).unwrap_or(false);
     let stdout_is_terminal = isatty(STDOUT_FILENO).unwrap_or(false);
@@ -1052,17 +1051,26 @@ fn attach_console_devices(
         log::error!("Failed to set terminal to raw mode: {e}")
     }
 
+    let console_input = if stdin_is_terminal {
+        Some(port_io::stdin().unwrap())
+    } else {
+        let sigint_input = port_io::PortInputSigInt::new();
+        let sigint_input_fd = sigint_input.sigint_evt().as_raw_fd();
+
+        register_sigint_handler(sigint_input_fd).map_err(RegisterFsSigwinch)?;
+
+        Some(Box::new(sigint_input) as _)
+    };
+
+    let console_output = if stdout_is_terminal {
+        Some(port_io::stdout().unwrap())
+    } else {
+        Some(port_io::output_to_log_as_err())
+    };
+
     let mut ports = vec![PortDescription::Console {
-        input: if stdin_is_terminal {
-            Some(port_io::stdin().unwrap())
-        } else {
-            None
-        },
-        output: if stdout_is_terminal {
-            Some(port_io::stdout().unwrap())
-        } else {
-            Some(port_io::output_to_log_as_err())
-        },
+        input: console_input,
+        output: console_output,
     }];
 
     if !stdin_is_terminal {

src/vmm/src/signal_handler.rs

@@ -4,7 +4,7 @@
 use std::os::unix::io::RawFd;
 use std::sync::atomic::{AtomicI32, Ordering};
 
-use libc::{_exit, c_int, c_void, siginfo_t, SIGBUS, SIGSEGV, SIGSYS, SIGWINCH};
+use libc::{_exit, c_int, c_void, siginfo_t, SIGBUS, SIGINT, SIGSEGV, SIGSYS, SIGWINCH};
 use utils::signal::register_signal_handler;
 
 // The offset of `si_syscall` (offending syscall identifier) within the siginfo structure
@@ -17,6 +17,7 @@ const SI_OFF_SYSCALL: isize = 6;
 const SYS_SECCOMP_CODE: i32 = 1;
 
 static CONSOLE_SIGWINCH_FD: AtomicI32 = AtomicI32::new(-1);
+static CONSOLE_SIGINT_FD: AtomicI32 = AtomicI32::new(-1);
 
 /// Signal handler for `SIGSYS`.
 ///
@@ -94,6 +95,21 @@ extern "C" fn sigwinch_handler(num: c_int, info: *mut siginfo_t, _unused: *mut c
     let _ = unsafe { libc::write(console_fd, &val as *const _ as *const c_void, 8) };
 }
 
+extern "C" fn sigint_handler(num: c_int, info: *mut siginfo_t, _unused: *mut c_void) {
+    // Safe because we're just reading some fields from a supposedly valid argument.
+    let si_signo = unsafe { (*info).si_signo };
+
+    // Sanity check. The condition should never be true.
+    if num != si_signo || num != SIGINT {
+        // Safe because we're terminating the process anyway.
+        unsafe { _exit(i32::from(super::FC_EXIT_CODE_UNEXPECTED_ERROR)) };
+    }
+
+    let val: u64 = 1;
+    let console_fd = CONSOLE_SIGINT_FD.load(Ordering::Relaxed);
+    let _ = unsafe { libc::write(console_fd, &val as *const _ as *const c_void, 8) };
+}
+
 pub fn register_sigwinch_handler(console_fd: RawFd) -> utils::errno::Result<()> {
     CONSOLE_SIGWINCH_FD.store(console_fd, Ordering::Relaxed);
 
@@ -102,6 +118,14 @@ pub fn register_sigwinch_handler(console_fd: RawFd) -> utils::errno::Result<()>
     Ok(())
 }
 
+pub fn register_sigint_handler(sigint_fd: RawFd) -> utils::errno::Result<()> {
+    CONSOLE_SIGINT_FD.store(sigint_fd, Ordering::Relaxed);
+
+    register_signal_handler(SIGINT, sigint_handler)?;
+
+    Ok(())
+}
+
 /// Registers all the required signal handlers.
 ///
 /// Custom handlers are installed for: `SIGBUS`, `SIGSEGV`, `SIGSYS`.

src/vmm/src/terminal.rs

@@ -26,7 +26,7 @@ pub fn term_fd_set_raw_mode(
     let mut termios = tcgetattr(term)?;
 
     let mut mask = LocalFlags::ECHO | LocalFlags::ICANON;
-    if handle_signals_by_terminal {
+    if !handle_signals_by_terminal {
         mask |= LocalFlags::ISIG
     }