virt_kvm: add aarch64 irqfd routing

vmm_core/virt_kvm/src/arch/aarch64/mod.rs

@@ -14,7 +14,11 @@ use crate::KvmError;
 use crate::KvmPartition;
 use crate::KvmPartitionInner;
 use crate::KvmRunVpError;
+use crate::gsi::GsiRouting;
+use crate::gsi::KvmIrqFdState;
+use crate::gsi::MsiRouteBuilder;
 use aarch64defs::SystemReg;
+use aarch64defs::gic::GicV2mRegister;
 use bitfield_struct::bitfield;
 use core::panic;
 use hvdef::Vtl;
@@ -33,6 +37,7 @@ use kvm::kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V2;
 use kvm::kvm_device_type_KVM_DEV_TYPE_ARM_VGIC_V3;
 use kvm::kvm_regs;
 use kvm::user_pt_regs;
+use parking_lot::Mutex;
 use std::convert::Infallible;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
@@ -779,6 +784,7 @@ impl virt::ProtoPartition for KvmProtoPartition<'_> {
                     eval: false.into(),
                 })
                 .collect(),
+            gsi_routing: Mutex::new(GsiRouting::new()),
             caps,
             _gic_device: gic_device,
             gic_v2m: self.config.processor_topology.gic_v2m(),
@@ -788,6 +794,7 @@ impl virt::ProtoPartition for KvmProtoPartition<'_> {
 
         let partition = KvmPartition {
             synic_ports: Arc::new(virt::synic::SynicPorts::new(partition.clone())),
+            irqfd_state: Arc::new(KvmIrqFdState::new(partition.clone())),
             inner: partition,
         };
 
@@ -834,6 +841,12 @@ impl virt::Partition for KvmPartition {
         )))
     }
 
+    fn irqfd(&self) -> Option<Arc<dyn virt::irqfd::IrqFd>> {
+        // The irqfd implementation requires a GICv2m frame to be present.
+        self.inner.gic_v2m?;
+        Some(self.irqfd_state.clone())
+    }
+
     fn request_yield(&self, vp_index: VpIndex) {
         let vp = &self.inner.vps[vp_index.index() as usize];
         if vp.needs_yield.request_yield() {
@@ -902,6 +915,42 @@ impl virt::Aarch64Partition for KvmPartition {
     }
 }
 
+struct KvmGicV2mRouteBuilder;
+
+impl MsiRouteBuilder for KvmGicV2mRouteBuilder {
+    fn routing_entry(
+        &self,
+        partition: &KvmPartitionInner,
+        address: u64,
+        data: u32,
+    ) -> Option<kvm::RoutingEntry> {
+        let v2m = partition
+            .gic_v2m
+            .as_ref()
+            .expect("partition does not expose a GICv2m MSI frame");
+        let setspi_addr = v2m.frame_base + GicV2mRegister::SETSPI_NS.0 as u64;
+        if address != setspi_addr {
+            return None;
+        }
+        if !(v2m.spi_base..v2m.spi_base + v2m.spi_count).contains(&data) {
+            return None;
+        }
+        // KVM expects the data to be the GIC SPI number, not the interrupt ID.
+        // TODO: centralize this constant.
+        Some(kvm::RoutingEntry::Irqchip { pin: data - 32 })
+    }
+}
+
+impl virt::irqfd::IrqFd for KvmIrqFdState {
+    fn new_irqfd_route(&self) -> anyhow::Result<Box<dyn virt::irqfd::IrqFdRoute>> {
+        assert!(
+            self.partition.gic_v2m.is_some(),
+            "GICv2m is required for irqfd support"
+        );
+        Ok(Box::new(self.new_irqfd_route(KvmGicV2mRouteBuilder)?))
+    }
+}
+
 impl virt::PartitionAccessState for KvmPartition {
     type StateAccess<'a> = &'a KvmPartition;
 

vmm_core/virt_kvm/src/arch/x86_64/mod.rs

@@ -15,6 +15,8 @@ use crate::KvmPartitionInner;
 use crate::KvmProcessorBinder;
 use crate::KvmRunVpError;
 use crate::gsi::GsiRouting;
+use crate::gsi::KvmIrqFdState;
+use crate::gsi::MsiRouteBuilder;
 use guestmem::DoorbellRegistration;
 use guestmem::GuestMemory;
 use guestmem::GuestMemoryError;
@@ -459,7 +461,7 @@ impl ProtoPartition for KvmProtoPartition<'_> {
 
         let partition = KvmPartition {
             synic_ports: Arc::new(virt::synic::SynicPorts::new(partition.clone())),
-            irqfd_state: Arc::new(crate::gsi::KvmIrqFdState::new(partition.clone())),
+            irqfd_state: Arc::new(KvmIrqFdState::new(partition.clone())),
             inner: partition,
         };
 
@@ -772,8 +774,12 @@ pub(crate) struct KvmMsi {
 }
 
 impl KvmMsi {
-    pub(crate) fn new(request: MsiRequest) -> Self {
+    pub(crate) fn new(request: MsiRequest) -> Option<Self> {
+        // TODO: validate the high bits of the request as well, across the codebase.
         let request_address = MsiAddress::from(request.address as u32);
+        if request_address.address() != x86defs::msi::MSI_ADDRESS {
+            return None;
+        }
         let request_data = MsiData::from(request.data);
 
         // Although architecturally the destination mode bit is only supposed to
@@ -796,21 +802,29 @@ impl KvmMsi {
             .with_vector(request_data.vector())
             .into();
 
-        Self {
+        Some(Self {
             address_lo,
             address_hi,
             data,
-        }
+        })
     }
 }
 
 impl KvmPartitionInner {
     fn request_msi(&self, request: MsiRequest) {
-        let KvmMsi {
+        let Some(KvmMsi {
             address_lo,
             address_hi,
             data,
-        } = KvmMsi::new(request);
+        }) = KvmMsi::new(request)
+        else {
+            tracelimit::warn_ratelimited!(
+                address = request.address,
+                data = request.data,
+                "invalid MSI address"
+            );
+            return;
+        };
         if let Err(err) = self.kvm.request_msi(&kvm::kvm_msi {
             address_lo,
             address_hi,
@@ -829,20 +843,59 @@ impl KvmPartitionInner {
     }
 }
 
+struct KvmX86MsiRouteBuilder;
+
+impl MsiRouteBuilder for KvmX86MsiRouteBuilder {
+    fn routing_entry(
+        &self,
+        _partition: &KvmPartitionInner,
+        address: u64,
+        data: u32,
+    ) -> Option<kvm::RoutingEntry> {
+        let KvmMsi {
+            address_lo,
+            address_hi,
+            data,
+        } = KvmMsi::new(MsiRequest { address, data })?;
+        Some(kvm::RoutingEntry::Msi {
+            address_lo,
+            address_hi,
+            data,
+        })
+    }
+}
+
+impl virt::irqfd::IrqFd for KvmIrqFdState {
+    fn new_irqfd_route(&self) -> anyhow::Result<Box<dyn virt::irqfd::IrqFdRoute>> {
+        Ok(Box::new(self.new_irqfd_route(KvmX86MsiRouteBuilder)?))
+    }
+}
+
 impl IoApicRouting for KvmPartitionInner {
     fn set_irq_route(&self, irq: u8, request: Option<MsiRequest>) {
-        let entry = request.map(|request| {
-            let KvmMsi {
-                address_lo,
-                address_hi,
-                data,
-            } = KvmMsi::new(request);
-            kvm::RoutingEntry::Msi {
-                address_lo,
-                address_hi,
-                data,
-            }
-        });
+        let entry = match request {
+            Some(request) => match KvmMsi::new(request) {
+                Some(KvmMsi {
+                    address_lo,
+                    address_hi,
+                    data,
+                }) => Some(kvm::RoutingEntry::Msi {
+                    address_lo,
+                    address_hi,
+                    data,
+                }),
+                None => {
+                    tracelimit::warn_ratelimited!(
+                        irq,
+                        address = request.address,
+                        data = request.data,
+                        "invalid MSI address for IO-APIC route"
+                    );
+                    None
+                }
+            },
+            None => None,
+        };
         let mut gsi_routing = self.gsi_routing.lock();
         if gsi_routing.set(irq as u32, entry) {
             gsi_routing.update_routes(&self.kvm);