riscv64: add interrupt support for serial device

Implement interrupt support for the legacy serial console device on
riscv64, following the same logic as the VirtIO device implementation.
Replace the `EventFdTrigger` structure, which triggers IRQFD-related
interrupts on x86_64 and aarch64, with a new `IrqLineTrigger` type. This
type encapsulates the two required pieces of information to fire a
`KVM_IRQ_LINE` interrupt: the raw file descriptor behind the `VmFd`
type and the corresponding GSI number.

This change is necessary because the `VmFd` structure does not implement
`Clone`, preventing it from being carried into the `trigger()` function
when injecting an interrupt from the serial device.

Additionally, make the `allocate_mmio_resources()` method of
`MMIODeviceManager` public. This is required to allocate an IRQ number
*before* setting up the serial device, since `setup_serial_device()`
builds the `IrqLineTrigger` and needs to know the IRQ number associated
with the serial device at that point.

Signed-off-by: Dimitris Charisis <dchar@cslab.ece.ntua.gr>

Author: Dimitris Charisis

src/vmm/src/builder.rs

@@ -5,6 +5,8 @@
 
 use std::fmt::Debug;
 use std::io;
+#[cfg(target_arch = "riscv64")]
+use std::os::fd::AsRawFd;
 #[cfg(feature = "gdb")]
 use std::sync::mpsc;
 use std::sync::{Arc, Mutex};
@@ -31,6 +33,8 @@ use crate::cpu_config::templates::{
 use crate::device_manager::acpi::ACPIDeviceManager;
 #[cfg(target_arch = "x86_64")]
 use crate::device_manager::legacy::PortIODeviceManager;
+#[cfg(target_arch = "riscv64")]
+use crate::device_manager::mmio::MMIODeviceInfo;
 use crate::device_manager::mmio::{MMIODeviceManager, MmioError};
 use crate::device_manager::persist::{
     ACPIDeviceManagerConstructorArgs, ACPIDeviceManagerRestoreError, MMIODevManagerConstructorArgs,
@@ -39,6 +43,8 @@ use crate::device_manager::resources::ResourceAllocator;
 use crate::devices::BusDevice;
 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
 use crate::devices::acpi::vmgenid::{VmGenId, VmGenIdError};
+#[cfg(target_arch = "riscv64")]
+use crate::devices::legacy::IrqLineTrigger;
 #[cfg(target_arch = "aarch64")]
 use crate::devices::legacy::RTCDevice;
 use crate::devices::legacy::serial::SerialOut;
@@ -306,6 +312,9 @@ pub fn build_microvm_for_boot(
     #[cfg(target_arch = "aarch64")]
     attach_legacy_devices_aarch64(event_manager, &mut vmm, &mut boot_cmdline)?;
 
+    #[cfg(target_arch = "riscv64")]
+    attach_legacy_devices_riscv64(event_manager, &mut vmm, &mut boot_cmdline)?;
+
     #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
     attach_vmgenid_device(&mut vmm)?;
 
@@ -566,6 +575,7 @@ pub fn build_microvm_from_snapshot(
     Ok(vmm)
 }
 
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
 /// Sets up the serial device.
 pub fn setup_serial_device(
     event_manager: &mut EventManager,
@@ -589,6 +599,35 @@ pub fn setup_serial_device(
     Ok(serial)
 }
 
+#[cfg(target_arch = "riscv64")]
+/// Sets up the serial device.
+pub fn setup_serial_device(
+    event_manager: &mut EventManager,
+    vmfd: &kvm_ioctls::VmFd,
+    input: std::io::Stdin,
+    out: std::io::Stdout,
+    device_info: &Option<MMIODeviceInfo>,
+) -> Result<Arc<Mutex<BusDevice>>, VmmError> {
+    let interrupt_evt = IrqLineTrigger::new(
+        vmfd.as_raw_fd(),
+        device_info.as_ref().unwrap().irq.unwrap().get(),
+    );
+    let kick_stdin_read_evt =
+        EventFdTrigger::new(EventFd::new(EFD_NONBLOCK).map_err(VmmError::EventFd)?);
+    let serial = Arc::new(Mutex::new(BusDevice::Serial(SerialWrapper {
+        serial: Serial::with_events(
+            interrupt_evt,
+            SerialEventsWrapper {
+                buffer_ready_event_fd: Some(kick_stdin_read_evt),
+            },
+            SerialOut::Stdout(out),
+        ),
+        input: Some(input),
+    })));
+    event_manager.add_subscriber(serial.clone());
+    Ok(serial)
+}
+
 /// 64 bytes due to alignment requirement in 3.1 of https://www.kernel.org/doc/html/v5.8/virt/kvm/devices/vcpu.html#attribute-kvm-arm-vcpu-pvtime-ipa
 #[cfg(target_arch = "aarch64")]
 const STEALTIME_STRUCT_MEM_SIZE: u64 = 64;
@@ -661,6 +700,47 @@ fn attach_legacy_devices_aarch64(
         .map_err(VmmError::RegisterMMIODevice)
 }
 
+#[cfg(target_arch = "riscv64")]
+fn attach_legacy_devices_riscv64(
+    event_manager: &mut EventManager,
+    vmm: &mut Vmm,
+    cmdline: &mut LoaderKernelCmdline,
+) -> Result<(), VmmError> {
+    // Serial device setup.
+    let cmdline_contains_console = cmdline
+        .as_cstring()
+        .map_err(|_| VmmError::Cmdline)?
+        .into_string()
+        .map_err(|_| VmmError::Cmdline)?
+        .contains("console=");
+
+    if cmdline_contains_console {
+        // Make stdout non-blocking.
+        set_stdout_nonblocking();
+        let device_info = vmm
+            .mmio_device_manager
+            .allocate_mmio_resources(&mut vmm.resource_allocator, 1)
+            .map_err(|err| VmmError::DeviceManager(err))?;
+
+        let serial = setup_serial_device(
+            event_manager,
+            vmm.vm.fd(),
+            std::io::stdin(),
+            std::io::stdout(),
+            &Some(device_info.clone()),
+        )?;
+
+        vmm.mmio_device_manager
+            .register_mmio_serial(&mut vmm.resource_allocator, serial, Some(device_info))
+            .map_err(VmmError::RegisterMMIODevice)?;
+        vmm.mmio_device_manager
+            .add_mmio_serial_to_cmdline(cmdline)
+            .map_err(VmmError::RegisterMMIODevice)?;
+    }
+
+    Ok(())
+}
+
 /// Attaches a VirtioDevice device to the device manager and event manager.
 fn attach_virtio_device<T: 'static + VirtioDevice + MutEventSubscriber + Debug>(
     event_manager: &mut EventManager,

src/vmm/src/device_manager/mmio.rs

@@ -147,7 +147,7 @@ impl MMIODeviceManager {
     }
 
     /// Allocates resources for a new device to be added.
-    fn allocate_mmio_resources(
+    pub fn allocate_mmio_resources(
         &mut self,
         resource_allocator: &mut ResourceAllocator,
         irq_count: u32,
@@ -312,7 +312,29 @@ impl MMIODeviceManager {
         self.register_mmio_device(identifier, device_info, serial)
     }
 
-    #[cfg(target_arch = "aarch64")]
+    #[cfg(target_arch = "riscv64")]
+    /// Register an early console at the specified MMIO configuration if given as parameter,
+    /// otherwise allocate a new MMIO resources for it.
+    pub fn register_mmio_serial(
+        &mut self,
+        resource_allocator: &mut ResourceAllocator,
+        serial: Arc<Mutex<BusDevice>>,
+        device_info_opt: Option<MMIODeviceInfo>,
+    ) -> Result<(), MmioError> {
+        // Create a new MMIODeviceInfo object on boot path or unwrap the
+        // existing object on restore path.
+        let device_info = if let Some(device_info) = device_info_opt {
+            device_info
+        } else {
+            self.allocate_mmio_resources(resource_allocator, 1)?
+        };
+
+        let identifier = (DeviceType::Serial, DeviceType::Serial.to_string());
+        // Register the newly created Serial object.
+        self.register_mmio_device(identifier, device_info, serial)
+    }
+
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     /// Append the registered early console to the kernel cmdline.
     pub fn add_mmio_serial_to_cmdline(
         &self,

src/vmm/src/devices/legacy/mod.rs

@@ -13,18 +13,24 @@ pub mod serial;
 
 use std::io;
 use std::ops::Deref;
+#[cfg(target_arch = "riscv64")]
+use std::os::fd::AsRawFd;
 
 use serde::Serializer;
 use serde::ser::SerializeMap;
 use vm_superio::Trigger;
 use vmm_sys_util::eventfd::EventFd;
+#[cfg(target_arch = "riscv64")]
+use vmm_sys_util::{errno, ioctl::ioctl_with_ref, ioctl_ioc_nr, ioctl_iow_nr};
 
 pub use self::i8042::{I8042Device, I8042Error as I8042DeviceError};
 #[cfg(target_arch = "aarch64")]
 pub use self::rtc_pl031::RTCDevice;
 pub use self::serial::{
     IER_RDA_BIT, IER_RDA_OFFSET, SerialDevice, SerialEventsWrapper, SerialWrapper,
 };
+#[cfg(target_arch = "riscv64")]
+use crate::logger::error;
 
 /// Wrapper for implementing the trigger functionality for `EventFd`.
 ///
@@ -64,6 +70,74 @@ impl EventFdTrigger {
     }
 }
 
+// TODO: raw_vmfd and gsi are actually never None.
+#[cfg(target_arch = "riscv64")]
+#[derive(Debug)]
+pub struct IrqLineTrigger {
+    raw_vmfd: Option<i32>,
+    gsi: Option<u32>,
+}
+
+#[cfg(target_arch = "riscv64")]
+impl IrqLineTrigger {
+    pub fn new(raw_vmfd: i32, gsi: u32) -> Self {
+        Self {
+            raw_vmfd: Some(raw_vmfd),
+            gsi: Some(gsi),
+        }
+    }
+
+    // This function is taken from kvm-ioctls because it requires VmFd, which we don't
+    // have at this point. However, it only uses the raw file descriptor, which is just
+    // an i32. So, we copy it here and use it directly with the raw fd.
+    fn set_irq_line<F: AsRawFd>(fd: F, irq: u32, active: bool) -> Result<(), kvm_ioctls::Error> {
+        let mut irq_level = kvm_bindings::kvm_irq_level::default();
+        irq_level.__bindgen_anon_1.irq = irq;
+        irq_level.level = u32::from(active);
+
+        // SAFETY: Safe because we know that our file is a VM fd, we know the kernel will only read
+        // the correct amount of memory from our pointer, and we verify the return result.
+        let ret = unsafe { ioctl_with_ref(&fd, IrqLineTrigger::KVM_IRQ_LINE(), &irq_level) };
+        if ret == 0 {
+            Ok(())
+        } else {
+            Err(errno::Error::last())
+        }
+    }
+
+    ioctl_iow_nr!(
+        KVM_IRQ_LINE,
+        kvm_bindings::KVMIO,
+        0x61,
+        kvm_bindings::kvm_irq_level
+    );
+}
+
+#[cfg(target_arch = "riscv64")]
+impl Trigger for IrqLineTrigger {
+    type E = ::std::io::Error;
+
+    fn trigger(&self) -> ::std::io::Result<()> {
+        // Safe to unwrap since `gsi` and `vmfd` have been set
+        let gsi = self.gsi.unwrap();
+
+        IrqLineTrigger::set_irq_line(self.raw_vmfd.unwrap().as_raw_fd(), gsi, true).map_err(
+            |err| {
+                error!("set_irq_line() failed: {err:?}");
+                std::io::Error::last_os_error()
+            },
+        )?;
+        IrqLineTrigger::set_irq_line(self.raw_vmfd.unwrap().as_raw_fd(), gsi, false).map_err(
+            |err| {
+                error!("set_irq_line() failed: {err:?}");
+                std::io::Error::last_os_error()
+            },
+        )?;
+
+        Ok(())
+    }
+}
+
 /// Called by METRICS.flush(), this function facilitates serialization of aggregated metrics.
 pub fn flush_metrics<S: Serializer>(serializer: S) -> Result<S::Ok, S::Error> {
     let mut seq = serializer.serialize_map(Some(1))?;