fix: Update Arm logging

For Arm specific code, adds additional `std::fmt::Debug`
implementations, these require removing some dynamic dispatch which
involves removing the `GICDevice` trait.

Signed-off-by: Jonathan Woollett-Light <[email protected]>

Author: JonathanWoollett-Light

src/logger/src/metrics.rs

@@ -894,6 +894,17 @@ impl RtcEvents for RTCDeviceMetrics {
     }
 }
 
+#[cfg(target_arch = "aarch64")]
+impl RtcEvents for &'static RTCDeviceMetrics {
+    fn invalid_read(&self) {
+        RTCDeviceMetrics::invalid_read(self);
+    }
+
+    fn invalid_write(&self) {
+        RTCDeviceMetrics::invalid_write(self);
+    }
+}
+
 /// Metrics for the seccomp filtering.
 #[derive(Debug, Default, Serialize)]
 pub struct SeccompMetrics {

src/vmm/src/arch/aarch64/fdt.rs

@@ -71,7 +71,7 @@ pub fn create_fdt<T: DeviceInfoForFDT + Clone + Debug, S: std::hash::BuildHasher
     vcpu_mpidr: Vec<u64>,
     cmdline: CString,
     device_info: &HashMap<(DeviceType, String), T, S>,
-    gic_device: &dyn GICDevice,
+    gic_device: &GICDevice,
     initrd: &Option<InitrdConfig>,
 ) -> Result<Vec<u8>> {
     // Allocate stuff necessary for storing the blob.
@@ -257,7 +257,7 @@ fn create_chosen_node(
     Ok(())
 }
 
-fn create_gic_node(fdt: &mut FdtWriter, gic_device: &dyn GICDevice) -> Result<()> {
+fn create_gic_node(fdt: &mut FdtWriter, gic_device: &GICDevice) -> Result<()> {
     let interrupt = fdt.begin_node("intc")?;
     fdt.property_string("compatible", gic_device.fdt_compatibility())?;
     fdt.property_null("interrupt-controller")?;
@@ -490,7 +490,7 @@ mod tests {
             vec![0],
             CString::new("console=tty0").unwrap(),
             &dev_info,
-            gic.as_ref(),
+            &gic,
             &None,
         )
         .is_ok())
@@ -516,7 +516,7 @@ mod tests {
             vec![0],
             CString::new("console=tty0").unwrap(),
             &HashMap::<(DeviceType, std::string::String), MMIODeviceInfo>::new(),
-            gic.as_ref(),
+            &gic,
             &None,
         )
         .unwrap();
@@ -579,7 +579,7 @@ mod tests {
             vec![0],
             CString::new("console=tty0").unwrap(),
             &HashMap::<(DeviceType, std::string::String), MMIODeviceInfo>::new(),
-            gic.as_ref(),
+            &gic,
             &Some(initrd),
         )
         .unwrap();

src/vmm/src/arch/aarch64/gic/gicv2/mod.rs

@@ -3,25 +3,24 @@
 
 mod regs;
 
-use std::boxed::Box;
 use std::result;
 
-use kvm_ioctls::DeviceFd;
+use kvm_ioctls::{DeviceFd, VmFd};
 
-use crate::arch::aarch64::gic::{Error, GICDevice, GicState};
+use crate::arch::aarch64::gic::{Error, GicState};
 
 type Result<T> = result::Result<T, Error>;
 
 /// Represent a GIC v2 device
-pub struct GICv2 {
-    /// The file descriptor for the KVM device
-    fd: DeviceFd,
+#[derive(Debug)]
+pub struct GICv2(super::GIC);
 
-    /// GIC device properties, to be used for setting up the fdt entry
-    properties: [u64; 4],
+impl std::ops::Deref for GICv2 {
+    type Target = super::GIC;
 
-    /// Number of CPUs handled by the device
-    vcpu_count: u64,
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
 impl GICv2 {
@@ -52,35 +51,20 @@ impl GICv2 {
     const fn get_cpu_size() -> u64 {
         GICv2::KVM_VGIC_V2_CPU_SIZE
     }
-}
-
-impl GICDevice for GICv2 {
-    fn version() -> u32 {
-        kvm_bindings::kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V2
-    }
-
-    fn device_fd(&self) -> &DeviceFd {
-        &self.fd
-    }
 
-    fn device_properties(&self) -> &[u64] {
-        &self.properties
-    }
+    pub const VERSION: u32 = kvm_bindings::kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V2;
 
-    fn vcpu_count(&self) -> u64 {
-        self.vcpu_count
-    }
-
-    fn fdt_compatibility(&self) -> &str {
+    pub fn fdt_compatibility(&self) -> &str {
         "arm,gic-400"
     }
 
-    fn fdt_maint_irq(&self) -> u32 {
+    pub fn fdt_maint_irq(&self) -> u32 {
         GICv2::ARCH_GIC_V2_MAINT_IRQ
     }
 
-    fn create_device(fd: DeviceFd, vcpu_count: u64) -> Box<dyn GICDevice> {
-        Box::new(GICv2 {
+    /// Create the GIC device object
+    pub fn create_device(fd: DeviceFd, vcpu_count: u64) -> Self {
+        GICv2(super::GIC {
             fd,
             properties: [
                 GICv2::get_dist_addr(),
@@ -92,15 +76,15 @@ impl GICDevice for GICv2 {
         })
     }
 
-    fn save_device(&self, mpidrs: &[u64]) -> Result<GicState> {
+    pub fn save_device(&self, mpidrs: &[u64]) -> Result<GicState> {
         regs::save_state(&self.fd, mpidrs)
     }
 
-    fn restore_device(&self, mpidrs: &[u64], state: &GicState) -> Result<()> {
+    pub fn restore_device(&self, mpidrs: &[u64], state: &GicState) -> Result<()> {
         regs::restore_state(&self.fd, mpidrs, state)
     }
 
-    fn init_device_attributes(gic_device: &dyn GICDevice) -> Result<()> {
+    pub fn init_device_attributes(gic_device: &Self) -> Result<()> {
         // Setting up the distributor attribute.
         // We are placing the GIC below 1GB so we need to substract the size of the distributor.
         Self::set_device_attribute(
@@ -122,4 +106,78 @@ impl GICDevice for GICv2 {
 
         Ok(())
     }
+
+    /// Initialize a GIC device
+    pub fn init_device(vm: &VmFd) -> Result<DeviceFd> {
+        let mut gic_device = kvm_bindings::kvm_create_device {
+            type_: Self::VERSION,
+            fd: 0,
+            flags: 0,
+        };
+
+        vm.create_device(&mut gic_device).map_err(Error::CreateGIC)
+    }
+
+    /// Method to initialize the GIC device
+    pub fn create(vm: &VmFd, vcpu_count: u64) -> Result<Self> {
+        let vgic_fd = Self::init_device(vm)?;
+
+        let device = Self::create_device(vgic_fd, vcpu_count);
+
+        Self::init_device_attributes(&device)?;
+
+        Self::finalize_device(&device)?;
+
+        Ok(device)
+    }
+
+    /// Finalize the setup of a GIC device
+    pub fn finalize_device(gic_device: &Self) -> Result<()> {
+        // On arm there are 3 types of interrupts: SGI (0-15), PPI (16-31), SPI (32-1020).
+        // SPIs are used to signal interrupts from various peripherals accessible across
+        // the whole system so these are the ones that we increment when adding a new virtio device.
+        // KVM_DEV_ARM_VGIC_GRP_NR_IRQS sets the highest SPI number. Consequently, we will have a
+        // total of `super::layout::IRQ_MAX - 32` usable SPIs in our microVM.
+        let nr_irqs: u32 = super::layout::IRQ_MAX;
+        let nr_irqs_ptr = &nr_irqs as *const u32;
+        Self::set_device_attribute(
+            gic_device.device_fd(),
+            kvm_bindings::KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
+            0,
+            nr_irqs_ptr as u64,
+            0,
+        )?;
+
+        // Finalize the GIC.
+        // See https://code.woboq.org/linux/linux/virt/kvm/arm/vgic/vgic-kvm-device.c.html#211.
+        Self::set_device_attribute(
+            gic_device.device_fd(),
+            kvm_bindings::KVM_DEV_ARM_VGIC_GRP_CTRL,
+            u64::from(kvm_bindings::KVM_DEV_ARM_VGIC_CTRL_INIT),
+            0,
+            0,
+        )?;
+
+        Ok(())
+    }
+
+    /// Set a GIC device attribute
+    pub fn set_device_attribute(
+        fd: &DeviceFd,
+        group: u32,
+        attr: u64,
+        addr: u64,
+        flags: u32,
+    ) -> Result<()> {
+        let attr = kvm_bindings::kvm_device_attr {
+            flags,
+            group,
+            attr,
+            addr,
+        };
+        fd.set_device_attr(&attr)
+            .map_err(|err| Error::DeviceAttribute(err, true, group))?;
+
+        Ok(())
+    }
 }