refactor: use VirtioInterrupt in VirtIO devices

VirtIO devices assume they're operating under an MMIO transport and as a
consequence they use IrqTrigger as interrupts. Switch that to using
VirtioInterrupt for all VirtIO device objects. Only assume a
VirtioInterrupt is an IrqTrigger in MMIO specific code.

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

Author: bchalios

src/vmm/src/device_manager/mmio.rs

@@ -505,7 +505,7 @@ impl MMIODeviceManager {
                             .unwrap();
                         if vsock.is_activated() {
                             info!("kick vsock {id}.");
-                            vsock.signal_used_queue().unwrap();
+                            vsock.signal_used_queue(0).unwrap();
                         }
                     }
                     TYPE_RNG => {
@@ -534,6 +534,7 @@ mod tests {
     use crate::devices::virtio::ActivateError;
     use crate::devices::virtio::device::VirtioDevice;
     use crate::devices::virtio::queue::Queue;
+    use crate::devices::virtio::transport::VirtioInterrupt;
     use crate::devices::virtio::transport::mmio::IrqTrigger;
     use crate::test_utils::multi_region_mem_raw;
     use crate::vstate::kvm::Kvm;
@@ -620,7 +621,7 @@ mod tests {
             &self.queue_evts
         }
 
-        fn interrupt_trigger(&self) -> Arc<IrqTrigger> {
+        fn interrupt_trigger(&self) -> Arc<dyn VirtioInterrupt> {
             self.interrupt_trigger
                 .as_ref()
                 .expect("Device is not activated")
@@ -645,7 +646,7 @@ mod tests {
         fn activate(
             &mut self,
             _: GuestMemoryMmap,
-            _: Arc<IrqTrigger>,
+            _: Arc<dyn VirtioInterrupt>,
         ) -> Result<(), ActivateError> {
             Ok(())
         }

src/vmm/src/devices/virtio/balloon/device.rs

@@ -25,7 +25,7 @@ use super::{
 };
 use crate::devices::virtio::balloon::BalloonError;
 use crate::devices::virtio::generated::virtio_config::VIRTIO_F_VERSION_1;
-use crate::devices::virtio::transport::mmio::{IrqTrigger, IrqType};
+use crate::devices::virtio::transport::{VirtioInterrupt, VirtioInterruptType};
 use crate::logger::IncMetric;
 use crate::utils::u64_to_usize;
 use crate::vstate::memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemoryMmap};
@@ -339,7 +339,7 @@ impl Balloon {
         }
 
         if needs_interrupt {
-            self.signal_used_queue()?;
+            self.signal_used_queue(INFLATE_INDEX)?;
         }
 
         Ok(())
@@ -357,7 +357,7 @@ impl Balloon {
         }
 
         if needs_interrupt {
-            self.signal_used_queue()
+            self.signal_used_queue(DEFLATE_INDEX)
         } else {
             Ok(())
         }
@@ -401,9 +401,12 @@ impl Balloon {
         Ok(())
     }
 
-    pub(crate) fn signal_used_queue(&self) -> Result<(), BalloonError> {
+    pub(crate) fn signal_used_queue(&self, qidx: usize) -> Result<(), BalloonError> {
         self.interrupt_trigger()
-            .trigger_irq(IrqType::Vring)
+            .trigger(VirtioInterruptType::Queue(
+                qidx.try_into()
+                    .unwrap_or_else(|_| panic!("balloon: invalid queue id: {qidx}")),
+            ))
             .map_err(|err| {
                 METRICS.event_fails.inc();
                 BalloonError::InterruptError(err)
@@ -428,7 +431,7 @@ impl Balloon {
             self.queues[STATS_INDEX]
                 .add_used(index, 0)
                 .map_err(BalloonError::Queue)?;
-            self.signal_used_queue()
+            self.signal_used_queue(STATS_INDEX)
         } else {
             error!("Failed to update balloon stats, missing descriptor.");
             Ok(())
@@ -440,7 +443,7 @@ impl Balloon {
         if self.is_activated() {
             self.config_space.num_pages = mib_to_pages(amount_mib)?;
             self.interrupt_trigger()
-                .trigger_irq(IrqType::Config)
+                .trigger(VirtioInterruptType::Config)
                 .map_err(BalloonError::InterruptError)
         } else {
             Err(BalloonError::DeviceNotActive)
@@ -551,7 +554,7 @@ impl VirtioDevice for Balloon {
         &self.queue_evts
     }
 
-    fn interrupt_trigger(&self) -> Arc<IrqTrigger> {
+    fn interrupt_trigger(&self) -> Arc<dyn VirtioInterrupt> {
         self.device_state
             .active_state()
             .expect("Device is not activated")
@@ -585,7 +588,7 @@ impl VirtioDevice for Balloon {
     fn activate(
         &mut self,
         mem: GuestMemoryMmap,
-        interrupt: Arc<IrqTrigger>,
+        interrupt: Arc<dyn VirtioInterrupt>,
     ) -> Result<(), ActivateError> {
         for q in self.queues.iter_mut() {
             q.initialize(&mem)
@@ -621,7 +624,7 @@ pub(crate) mod tests {
         check_request_completion, invoke_handler_for_queue_event, set_request,
     };
     use crate::devices::virtio::queue::{VIRTQ_DESC_F_NEXT, VIRTQ_DESC_F_WRITE};
-    use crate::devices::virtio::test_utils::{VirtQueue, default_mem};
+    use crate::devices::virtio::test_utils::{VirtQueue, default_interrupt, default_mem};
     use crate::test_utils::single_region_mem;
     use crate::vstate::memory::GuestAddress;
 
@@ -798,11 +801,10 @@ pub(crate) mod tests {
     fn test_invalid_request() {
         let mut balloon = Balloon::new(0, true, 0, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
         // Only initialize the inflate queue to demonstrate invalid request handling.
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(INFLATE_INDEX, infq.create_queue());
-        balloon.activate(mem.clone(), interrupt).unwrap();
+        balloon.activate(mem.clone(), default_interrupt()).unwrap();
 
         // Fill the second page with non-zero bytes.
         for i in 0..0x1000 {
@@ -858,10 +860,9 @@ pub(crate) mod tests {
     fn test_inflate() {
         let mut balloon = Balloon::new(0, true, 0, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(INFLATE_INDEX, infq.create_queue());
-        balloon.activate(mem.clone(), interrupt).unwrap();
+        balloon.activate(mem.clone(), default_interrupt()).unwrap();
 
         // Fill the third page with non-zero bytes.
         for i in 0..0x1000 {
@@ -929,10 +930,9 @@ pub(crate) mod tests {
     fn test_deflate() {
         let mut balloon = Balloon::new(0, true, 0, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
         let defq = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(DEFLATE_INDEX, defq.create_queue());
-        balloon.activate(mem.clone(), interrupt).unwrap();
+        balloon.activate(mem.clone(), default_interrupt()).unwrap();
 
         let page_addr = 0x10;
 
@@ -978,10 +978,9 @@ pub(crate) mod tests {
     fn test_stats() {
         let mut balloon = Balloon::new(0, true, 1, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
         let statsq = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(STATS_INDEX, statsq.create_queue());
-        balloon.activate(mem.clone(), interrupt).unwrap();
+        balloon.activate(mem.clone(), default_interrupt()).unwrap();
 
         let page_addr = 0x100;
 
@@ -1057,7 +1056,9 @@ pub(crate) mod tests {
                 assert!(balloon.stats_desc_index.is_some());
                 balloon.process_stats_timer_event().unwrap();
                 assert!(balloon.stats_desc_index.is_none());
-                assert!(balloon.interrupt_trigger().has_pending_irq(IrqType::Vring));
+                assert!(balloon.interrupt_trigger().has_pending_interrupt(
+                    VirtioInterruptType::Queue(STATS_INDEX.try_into().unwrap())
+                ));
             });
         }
     }
@@ -1066,23 +1067,21 @@ pub(crate) mod tests {
     fn test_process_balloon_queues() {
         let mut balloon = Balloon::new(0x10, true, 0, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);
         let defq = VirtQueue::new(GuestAddress(0), &mem, 16);
 
         balloon.set_queue(INFLATE_INDEX, infq.create_queue());
         balloon.set_queue(DEFLATE_INDEX, defq.create_queue());
 
-        balloon.activate(mem, interrupt).unwrap();
+        balloon.activate(mem, default_interrupt()).unwrap();
         balloon.process_virtio_queues()
     }
 
     #[test]
     fn test_update_stats_interval() {
         let mut balloon = Balloon::new(0, true, 0, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
-        balloon.activate(mem, interrupt).unwrap();
+        balloon.activate(mem, default_interrupt()).unwrap();
         assert_eq!(
             format!("{:?}", balloon.update_stats_polling_interval(1)),
             "Err(StatisticsStateChange)"
@@ -1091,8 +1090,7 @@ pub(crate) mod tests {
 
         let mut balloon = Balloon::new(0, true, 1, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
-        balloon.activate(mem, interrupt).unwrap();
+        balloon.activate(mem, default_interrupt()).unwrap();
         assert_eq!(
             format!("{:?}", balloon.update_stats_polling_interval(0)),
             "Err(StatisticsStateChange)"
@@ -1113,7 +1111,7 @@ pub(crate) mod tests {
         let mut balloon = Balloon::new(0, true, 0, false).unwrap();
         // Switch the state to active.
         balloon.device_state =
-            DeviceState::Activated((single_region_mem(0x1), Arc::new(IrqTrigger::new().unwrap())));
+            DeviceState::Activated((single_region_mem(0x1), default_interrupt()));
 
         assert_eq!(balloon.num_pages(), 0);
         assert_eq!(balloon.actual_pages(), 0);

src/vmm/src/devices/virtio/balloon/event_handler.rs

@@ -136,16 +136,15 @@ pub mod tests {
 
     use super::*;
     use crate::devices::virtio::balloon::test_utils::set_request;
-    use crate::devices::virtio::test_utils::{VirtQueue, default_mem};
-    use crate::devices::virtio::transport::mmio::IrqTrigger;
+    use crate::devices::virtio::test_utils::{VirtQueue, default_interrupt, default_mem};
     use crate::vstate::memory::GuestAddress;
 
     #[test]
     fn test_event_handler() {
         let mut event_manager = EventManager::new().unwrap();
         let mut balloon = Balloon::new(0, true, 10, false).unwrap();
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = default_interrupt();
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(INFLATE_INDEX, infq.create_queue());
 

src/vmm/src/devices/virtio/balloon/persist.rs

@@ -15,7 +15,7 @@ use crate::devices::virtio::balloon::device::{BalloonStats, ConfigSpace};
 use crate::devices::virtio::device::DeviceState;
 use crate::devices::virtio::persist::VirtioDeviceState;
 use crate::devices::virtio::queue::FIRECRACKER_MAX_QUEUE_SIZE;
-use crate::devices::virtio::transport::mmio::IrqTrigger;
+use crate::devices::virtio::transport::VirtioInterrupt;
 use crate::snapshot::Persist;
 use crate::vstate::memory::GuestMemoryMmap;
 
@@ -96,7 +96,7 @@ pub struct BalloonConstructorArgs {
     /// Pointer to guest memory.
     pub mem: GuestMemoryMmap,
     /// Interrupt used from the device.
-    pub interrupt: Arc<IrqTrigger>,
+    pub interrupt: Arc<dyn VirtioInterrupt>,
     pub restored_from_file: bool,
 }
 

src/vmm/src/devices/virtio/balloon/test_utils.rs

@@ -10,7 +10,7 @@ use crate::devices::virtio::{balloon::BALLOON_NUM_QUEUES, balloon::Balloon};
 #[cfg(test)]
 pub fn invoke_handler_for_queue_event(b: &mut Balloon, queue_index: usize) {
     use crate::devices::virtio::balloon::{DEFLATE_INDEX, INFLATE_INDEX, STATS_INDEX};
-    use crate::devices::virtio::transport::mmio::IrqType;
+    use crate::devices::virtio::transport::VirtioInterruptType;
 
     assert!(queue_index < BALLOON_NUM_QUEUES);
     // Trigger the queue event.
@@ -24,7 +24,10 @@ pub fn invoke_handler_for_queue_event(b: &mut Balloon, queue_index: usize) {
     };
     // Validate the queue operation finished successfully.
     let (_, interrupt) = b.device_state.active_state().unwrap();
-    assert!(interrupt.has_pending_irq(IrqType::Vring));
+    assert!(
+        interrupt
+            .has_pending_interrupt(VirtioInterruptType::Queue(queue_index.try_into().unwrap()))
+    );
 }
 
 pub fn set_request(queue: &VirtQueue, idx: u16, addr: u64, len: u32, flags: u16) {

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

@@ -12,7 +12,7 @@ use super::vhost_user::device::{VhostUserBlock, VhostUserBlockConfig};
 use super::virtio::device::{VirtioBlock, VirtioBlockConfig};
 use crate::devices::virtio::device::VirtioDevice;
 use crate::devices::virtio::queue::Queue;
-use crate::devices::virtio::transport::mmio::IrqTrigger;
+use crate::devices::virtio::transport::VirtioInterrupt;
 use crate::devices::virtio::{ActivateError, TYPE_BLOCK};
 use crate::rate_limiter::BucketUpdate;
 use crate::snapshot::Persist;
@@ -176,7 +176,7 @@ impl VirtioDevice for Block {
         }
     }
 
-    fn interrupt_trigger(&self) -> Arc<IrqTrigger> {
+    fn interrupt_trigger(&self) -> Arc<dyn VirtioInterrupt> {
         match self {
             Self::Virtio(b) => {
                 b.device_state
@@ -210,7 +210,7 @@ impl VirtioDevice for Block {
     fn activate(
         &mut self,
         mem: GuestMemoryMmap,
-        interrupt: Arc<IrqTrigger>,
+        interrupt: Arc<dyn VirtioInterrupt>,
     ) -> Result<(), ActivateError> {
         match self {
             Self::Virtio(b) => b.activate(mem, interrupt),

src/vmm/src/devices/virtio/block/persist.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 
 use super::vhost_user::persist::VhostUserBlockState;
 use super::virtio::persist::VirtioBlockState;
-use crate::devices::virtio::transport::mmio::IrqTrigger;
+use crate::devices::virtio::transport::VirtioInterrupt;
 use crate::vstate::memory::GuestMemoryMmap;
 
 /// Block device state.
@@ -21,5 +21,5 @@ pub enum BlockState {
 #[derive(Debug)]
 pub struct BlockConstructorArgs {
     pub mem: GuestMemoryMmap,
-    pub interrupt: Arc<IrqTrigger>,
+    pub interrupt: Arc<dyn VirtioInterrupt>,
 }