riscv: vmm-reference first support to RISC-V

This commit implements a first support to the RISC-V architecture. Major
changes are related to interrupts handling:
- use of in-kernel IRQCHIP (APLIC)
- interrupt injection from userspace through kvm ioctl
  (KVM_SET_IRQ_LINE)

Signed-off-by: Samuele Paone <[email protected]>

Author: samvosys

src/arch/src/riscv_regs.rs

@@ -0,0 +1,74 @@
+#[cfg(target_arch = "riscv64")]
+#[macro_export]
+macro_rules! kvm_reg_riscv_core_reg {
+    ($name:ident) => {
+        offset_of!(kvm_bindings::user_regs_struct, $name) / std::mem::size_of::<u64>()
+    };
+}
+#[macro_export]
+macro_rules! riscv_core_reg {
+    ($name:ident) => {
+        kvm_reg_id!(
+            KVM_REG_RISCV_CORE as u64,
+            0,
+            kvm_reg_riscv_core_reg!($name) as u64,
+            KVM_REG_SIZE_U64
+        )
+    };
+}
+
+// Registers configuration macros
+#[macro_export]
+macro_rules! kvm_reg_riscv_config_reg {
+    ($name:ident) => {
+        offset_of!(kvm_bindings::kvm_riscv_config, $name) / std::mem::size_of::<u64>()
+    };
+}
+#[macro_export]
+macro_rules! riscv_config_reg {
+    ($name:ident) => {
+        kvm_reg_id!(
+            KVM_REG_RISCV_CONFIG as u64,
+            0,
+            kvm_reg_riscv_config_reg!($name) as u64,
+            KVM_REG_SIZE_U64
+        )
+    };
+}
+
+// Timer-related macros
+#[macro_export]
+macro_rules! kvm_reg_riscv_timer_reg {
+    ($name:ident) => {
+        offset_of!(kvm_riscv_timer, $name) / std::mem::size_of::<u64>()
+    };
+}
+#[macro_export]
+macro_rules! riscv_timer_reg {
+    ($name:ident) => {
+        kvm_reg_id!(
+            KVM_REG_RISCV_TIMER as u64,
+            0,
+            kvm_reg_riscv_timer_reg!($name) as u64,
+            KVM_REG_SIZE_U64
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! riscv_isa_ext_reg {
+    ($id:expr) => {
+        kvm_reg_id!(KVM_REG_RISCV_ISA_EXT as u64, 0, $id, KVM_REG_SIZE_U64)
+    };
+}
+
+#[macro_export]
+macro_rules! kvm_reg_id {
+    ($stype:expr, $subtype:expr, $idx:expr, $size:expr) => {
+        (KVM_REG_RISCV as u64)
+            | ($stype as u64)
+            | ($subtype as u64)
+            | ($idx as u64)
+            | ($size as u64)
+    };
+}

src/devices/src/intc/mod.rs

@@ -0,0 +1,30 @@
+use kvm_ioctls::VmFd;
+use std::io;
+use std::sync::Arc;
+use vm_superio::Trigger;
+
+#[derive(Clone)]
+pub struct APlicTrigger {
+    pub gsi: u32,
+    pub vm: Arc<VmFd>,
+}
+
+impl APlicTrigger {
+    pub fn try_clone(&self) -> io::Result<Self> {
+        Ok(APlicTrigger {
+            gsi: self.gsi,
+            vm: self.vm.clone(),
+        })
+    }
+}
+
+impl Trigger for APlicTrigger {
+    type E = io::Error;
+
+    fn trigger(&self) -> io::Result<()> {
+        self.vm.set_irq_line(self.gsi, true)?;
+        self.vm.set_irq_line(self.gsi, false)?;
+
+        Ok(())
+    }
+}

src/devices/src/legacy/mod.rs

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
 #[cfg(target_arch = "x86_64")]
 mod i8042;
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 mod rtc;
 mod serial;
 #[cfg(target_arch = "x86_64")]
 pub use i8042::I8042Wrapper;
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 pub use rtc::RtcWrapper;
 pub use serial::Error as SerialError;
 pub use serial::SerialWrapper;

src/devices/src/legacy/serial.rs

@@ -5,7 +5,7 @@ use std::convert::TryInto;
 use std::io::{self, stdin, Read, Write};
 
 use event_manager::{EventOps, Events, MutEventSubscriber};
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 use vm_device::{bus::MmioAddress, MutDeviceMmio};
 #[cfg(target_arch = "x86_64")]
 use vm_device::{
@@ -106,7 +106,7 @@ impl<T: Trigger<E = io::Error>, W: Write> MutDevicePio for SerialWrapper<T, NoEv
     }
 }
 
-#[cfg(target_arch = "aarch64")]
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
 impl<T: Trigger<E = io::Error>, W: Write> MutDeviceMmio for SerialWrapper<T, NoEvents, W> {
     fn mmio_read(&mut self, _base: MmioAddress, offset: u64, data: &mut [u8]) {
         // TODO: this function can't return an Err, so we'll mark error conditions
@@ -150,13 +150,13 @@ mod tests {
         // Check that passing invalid data does not result in a crash.
         #[cfg(target_arch = "x86_64")]
         serial_console.pio_read(PioAddress(0), valid_iir_offset, invalid_data);
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         serial_console.mmio_read(MmioAddress(0), valid_iir_offset, invalid_data);
 
         // The same scenario happens for writes.
         #[cfg(target_arch = "x86_64")]
         serial_console.pio_write(PioAddress(0), valid_iir_offset, invalid_data);
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         serial_console.mmio_write(MmioAddress(0), valid_iir_offset, invalid_data);
     }
 
@@ -182,7 +182,7 @@ mod tests {
             let invalid_offset = PioAddressOffset::MAX;
             serial_console.pio_write(PioAddress(0), invalid_offset, &data);
         }
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         {
             let invalid_offset = u64::MAX;
             serial_console.mmio_write(MmioAddress(0), invalid_offset, &data);
@@ -203,7 +203,7 @@ mod tests {
             serial_console.pio_write(PioAddress(0), offset, &write_data);
             serial_console.pio_read(PioAddress(0), offset, read_data.as_mut());
         }
-        #[cfg(target_arch = "aarch64")]
+        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
         {
             serial_console.mmio_write(MmioAddress(0), offset, &write_data);
             serial_console.mmio_read(MmioAddress(0), offset, read_data.as_mut());

src/devices/src/lib.rs

@@ -5,5 +5,6 @@
 // we are striving to turn as much of the local code as possible into reusable building blocks
 // going forward.
 
+pub mod intc;
 pub mod legacy;
 pub mod virtio;

src/devices/src/virtio/block/device.rs

@@ -16,12 +16,14 @@ use vm_device::{DeviceMmio, MutDeviceMmio};
 use vm_memory::{GuestAddressSpace, GuestMemoryMmap};
 
 use crate::virtio::block::{BLOCK_DEVICE_ID, VIRTIO_BLK_F_RO};
-use crate::virtio::{CommonConfig, Env, SingleFdSignalQueue, QUEUE_MAX_SIZE};
+use crate::virtio::{CommonConfig, Env, IrqTrigger, SingleFdSignalQueue, QUEUE_MAX_SIZE};
 
 use super::inorder_handler::InOrderQueueHandler;
 use super::queue_handler::QueueHandler;
 use super::{build_config_space, BlockArgs, Error, Result};
 
+use crate::intc::APlicTrigger;
+
 // This Block device can only use the MMIO transport for now, but we plan to reuse large parts of
 // the functionality when we implement virtio PCI as well, for example by having a base generic
 // type, and then separate concrete instantiations for `MmioConfig` and `PciConfig`.
@@ -33,6 +35,7 @@ pub struct Block<M: GuestAddressSpace + Clone + Send + 'static> {
     // the outside.
     _root_device: bool,
     mem: Arc<GuestMemoryMmap>,
+    aplic_trigger: Option<APlicTrigger>,
 }
 
 impl<M: GuestAddressSpace + Clone + Send + Sync + 'static> Block<M> {
@@ -41,6 +44,7 @@ impl<M: GuestAddressSpace + Clone + Send + Sync + 'static> Block<M> {
         mem: Arc<GuestMemoryMmap>,
         env: &mut Env<M, B>,
         args: &BlockArgs,
+        aplic_trigger: Option<APlicTrigger>,
     ) -> Result<Self> {
         let device_features = args.device_features();
 
@@ -57,6 +61,7 @@ impl<M: GuestAddressSpace + Clone + Send + Sync + 'static> Block<M> {
             file_path: args.file_path.clone(),
             read_only: args.read_only,
             _root_device: args.root_device,
+            aplic_trigger,
         })
     }
 
@@ -66,14 +71,20 @@ impl<M: GuestAddressSpace + Clone + Send + Sync + 'static> Block<M> {
         mem: Arc<GuestMemoryMmap>,
         env: &mut Env<M, B>,
         args: &BlockArgs,
+        aplic_trigger: Option<APlicTrigger>,
     ) -> Result<Arc<Mutex<Self>>>
     where
         // We're using this (more convoluted) bound so we can pass both references and smart
         // pointers such as mutex guards here.
         B: DerefMut,
         B::Target: MmioManager<D = Arc<dyn DeviceMmio + Send + Sync>>,
     {
-        let block = Arc::new(Mutex::new(Self::create_block(mem, env, args)?));
+        let block = Arc::new(Mutex::new(Self::create_block(
+            mem,
+            env,
+            args,
+            aplic_trigger,
+        )?));
 
         // Register the device on the MMIO bus.
         env.register_mmio_device(block.clone())
@@ -123,9 +134,14 @@ impl<M: GuestAddressSpace + Clone + Send + 'static> VirtioDeviceActions for Bloc
 
         // TODO: Create the backend earlier (as part of `Block::new`)?
         let disk = StdIoBackend::new(file, features).map_err(Error::Backend)?;
+        let irq_trigger = if cfg!(target_arch = "riscv64") {
+            IrqTrigger::APlicTrigger(Some(self.aplic_trigger.clone().unwrap()))
+        } else {
+            IrqTrigger::IrqFd(self.cfg.irqfd.clone())
+        };
 
         let driver_notify = SingleFdSignalQueue {
-            irqfd: self.cfg.irqfd.clone(),
+            irq_trigger,
             interrupt_status: self.cfg.virtio.interrupt_status.clone(),
         };
 
@@ -185,7 +201,16 @@ mod tests {
             advertise_flush: true,
         };
 
-        let block_mutex = Block::new(env.mem.clone(), &mut env, &args).unwrap();
+        let aplic_trigger = if cfg!(target_arch = "riscv64") {
+            Some(APlicTrigger {
+                gsi: 5,
+                vm: env.vm_fd.clone(),
+            })
+        } else {
+            None
+        };
+
+        let block_mutex = Block::new(env.mem.clone(), &mut env, &args, aplic_trigger).unwrap();
         let block = block_mutex.lock().unwrap();
 
         assert_eq!(block.device_type(), BLOCK_DEVICE_ID);

src/devices/src/virtio/mod.rs

@@ -12,6 +12,7 @@ use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{AtomicU8, Ordering};
 use std::sync::{Arc, Mutex};
 
+use crate::intc::APlicTrigger;
 use event_manager::{
     Error as EvmgrError, EventManager, MutEventSubscriber, RemoteEndpoint, Result as EvmgrResult,
     SubscriberId,
@@ -24,6 +25,7 @@ use vm_device::bus::{self, MmioAddress, MmioRange};
 use vm_device::device_manager::MmioManager;
 use vm_device::DeviceMmio;
 use vm_memory::{GuestAddress, GuestAddressSpace};
+use vm_superio::Trigger;
 use vmm_sys_util::errno;
 use vmm_sys_util::eventfd::{EventFd, EFD_NONBLOCK};
 
@@ -66,6 +68,28 @@ pub enum Error {
     RegisterIrqfd(errno::Error),
 }
 
+// Enum that abstracts the way in which IRQs are triggered
+pub enum IrqTrigger {
+    IrqFd(Arc<EventFd>),
+    APlicTrigger(Option<APlicTrigger>),
+}
+
+impl IrqTrigger {
+    fn trigger(&self) {
+        match self {
+            IrqTrigger::IrqFd(irqfd) => {
+                irqfd
+                    .write(1)
+                    .expect("Failed write to eventfd when signaling queue");
+            }
+            IrqTrigger::APlicTrigger(aplic_trigger) => aplic_trigger
+                .clone()
+                .unwrap()
+                .trigger()
+                .expect("Failed write to aplic trigger when signaling queue"),
+        }
+    }
+}
 type Result<T> = std::result::Result<T, Error>;
 pub type Subscriber = Arc<Mutex<dyn MutEventSubscriber + Send>>;
 
@@ -168,6 +192,7 @@ impl<M: GuestAddressSpace + Clone + Send + 'static> CommonConfig<M> {
     pub fn new<B>(virtio_cfg: VirtioConfig<Queue>, env: &Env<M, B>) -> Result<Self> {
         let irqfd = Arc::new(EventFd::new(EFD_NONBLOCK).map_err(Error::EventFd)?);
 
+        #[cfg(not(target_arch = "riscv64"))]
         env.vm_fd
             .register_irqfd(&irqfd, env.mmio_cfg.gsi)
             .map_err(Error::RegisterIrqfd)?;
@@ -264,17 +289,15 @@ pub trait SignalUsedQueue {
 /// Uses a single irqfd as the basis of signalling any queue (useful for the MMIO transport,
 /// where a single interrupt is shared for everything).
 pub struct SingleFdSignalQueue {
-    pub irqfd: Arc<EventFd>,
+    pub irq_trigger: IrqTrigger,
     pub interrupt_status: Arc<AtomicU8>,
 }
 
 impl SignalUsedQueue for SingleFdSignalQueue {
     fn signal_used_queue(&self, _index: u16) {
         self.interrupt_status
             .fetch_or(VIRTIO_MMIO_INT_VRING, Ordering::SeqCst);
-        self.irqfd
-            .write(1)
-            .expect("Failed write to eventfd when signalling queue");
+        self.irq_trigger.trigger();
     }
 }