virtio: add generic interrupt trait

Describing the APIs that need to implement types that are used as
interrupts for VirtIO devices. Currently, we only use `IrqInterrupt`
interrupts, but this will change once we have MSI-X with PCIe devices.

Signed-off-by: Babis Chalios <bchalios@amazon.es>

Author: bchalios

src/vmm/src/devices/virtio/transport/mmio.rs

@@ -11,6 +11,7 @@ use std::sync::{Arc, Mutex, MutexGuard};
 
 use vmm_sys_util::eventfd::EventFd;
 
+use super::{VirtioInterrupt, VirtioInterruptType};
 use crate::devices::virtio::device::VirtioDevice;
 use crate::devices::virtio::device_status;
 use crate::devices::virtio::queue::Queue;
@@ -375,6 +376,15 @@ pub enum IrqType {
     Vring,
 }
 
+impl From<VirtioInterruptType> for IrqType {
+    fn from(interrupt_type: VirtioInterruptType) -> Self {
+        match interrupt_type {
+            VirtioInterruptType::Config => IrqType::Config,
+            VirtioInterruptType::Queue(_) => IrqType::Vring,
+        }
+    }
+}
+
 /// Helper struct that is responsible for triggering guest IRQs
 #[derive(Debug)]
 pub struct IrqTrigger {
@@ -388,6 +398,40 @@ impl Default for IrqTrigger {
     }
 }
 
+impl VirtioInterrupt for IrqTrigger {
+    fn trigger(&self, interrupt_type: VirtioInterruptType) -> Result<(), std::io::Error> {
+        match interrupt_type {
+            VirtioInterruptType::Config => self.trigger_irq(IrqType::Config),
+            VirtioInterruptType::Queue(_) => self.trigger_irq(IrqType::Vring),
+        }
+    }
+
+    fn notifier(&self, _interrupt_type: VirtioInterruptType) -> Option<&EventFd> {
+        Some(&self.irq_evt)
+    }
+
+    fn status(&self) -> Arc<AtomicU32> {
+        self.irq_status.clone()
+    }
+
+    #[cfg(test)]
+    fn has_pending_interrupt(&self, interrupt_type: VirtioInterruptType) -> bool {
+        if let Ok(num_irqs) = self.irq_evt.read() {
+            if num_irqs == 0 {
+                return false;
+            }
+
+            let irq_status = self.irq_status.load(Ordering::SeqCst);
+            return matches!(
+                (irq_status, interrupt_type.into()),
+                (VIRTIO_MMIO_INT_CONFIG, IrqType::Config) | (VIRTIO_MMIO_INT_VRING, IrqType::Vring)
+            );
+        }
+
+        false
+    }
+}
+
 impl IrqTrigger {
     pub fn new() -> Self {
         Self {
@@ -1060,44 +1104,29 @@ pub(crate) mod tests {
         assert_eq!(dummy_dev.acked_features(), 24);
     }
 
-    impl IrqTrigger {
-        pub fn has_pending_irq(&self, irq_type: IrqType) -> bool {
-            if let Ok(num_irqs) = self.irq_evt.read() {
-                if num_irqs == 0 {
-                    return false;
-                }
-
-                let irq_status = self.irq_status.load(Ordering::SeqCst);
-                return matches!(
-                    (irq_status, irq_type),
-                    (VIRTIO_MMIO_INT_CONFIG, IrqType::Config)
-                        | (VIRTIO_MMIO_INT_VRING, IrqType::Vring)
-                );
-            }
-
-            false
-        }
-    }
-
     #[test]
     fn irq_trigger() {
         let irq_trigger = IrqTrigger::new();
         assert_eq!(irq_trigger.irq_status.load(Ordering::SeqCst), 0);
 
         // Check that there are no pending irqs.
-        assert!(!irq_trigger.has_pending_irq(IrqType::Config));
-        assert!(!irq_trigger.has_pending_irq(IrqType::Vring));
+        assert!(!irq_trigger.has_pending_interrupt(VirtioInterruptType::Config));
+        assert!(!irq_trigger.has_pending_interrupt(VirtioInterruptType::Queue(0)));
 
         // Check that trigger_irq() correctly generates irqs.
-        irq_trigger.trigger_irq(IrqType::Config).unwrap();
-        assert!(irq_trigger.has_pending_irq(IrqType::Config));
+        irq_trigger.trigger(VirtioInterruptType::Config).unwrap();
+        assert!(irq_trigger.has_pending_interrupt(VirtioInterruptType::Config));
         irq_trigger.irq_status.store(0, Ordering::SeqCst);
-        irq_trigger.trigger_irq(IrqType::Vring).unwrap();
-        assert!(irq_trigger.has_pending_irq(IrqType::Vring));
+        irq_trigger.trigger(VirtioInterruptType::Queue(0)).unwrap();
+        assert!(irq_trigger.has_pending_interrupt(VirtioInterruptType::Queue(0)));
 
         // Check trigger_irq() failure case (irq_evt is full).
         irq_trigger.irq_evt.write(u64::MAX - 1).unwrap();
-        irq_trigger.trigger_irq(IrqType::Config).unwrap_err();
-        irq_trigger.trigger_irq(IrqType::Vring).unwrap_err();
+        irq_trigger
+            .trigger(VirtioInterruptType::Config)
+            .unwrap_err();
+        irq_trigger
+            .trigger(VirtioInterruptType::Queue(0))
+            .unwrap_err();
     }
 }

src/vmm/src/devices/virtio/transport/mod.rs

@@ -1,5 +1,37 @@
 // Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::sync::Arc;
+use std::sync::atomic::AtomicU32;
+
+use vmm_sys_util::eventfd::EventFd;
+
 /// MMIO transport for VirtIO devices
 pub mod mmio;
+
+/// Represents the types of interrupts used by VirtIO devices
+#[derive(Debug, Clone)]
+pub enum VirtioInterruptType {
+    /// Interrupt for VirtIO configuration changes
+    Config,
+    /// Interrupts for new events in a queue.
+    Queue(u16),
+}
+
+/// API of interrupt types used by VirtIO devices
+pub trait VirtioInterrupt: std::fmt::Debug + Send + Sync {
+    /// Trigger a VirtIO interrupt.
+    fn trigger(&self, interrupt_type: VirtioInterruptType) -> Result<(), std::io::Error>;
+
+    /// Get the `EventFd` (if any) that backs the underlying interrupt.
+    fn notifier(&self, _interrupt_type: VirtioInterruptType) -> Option<&EventFd> {
+        None
+    }
+
+    /// Get the current device interrupt status.
+    fn status(&self) -> Arc<AtomicU32>;
+
+    /// Returns true if there is any pending interrupt
+    #[cfg(test)]
+    fn has_pending_interrupt(&self, interrupt_type: VirtioInterruptType) -> bool;
+}