fix(virtio): avoid panic on device activation failure

According to the VirtIO spec section 2.1.2, when we enter a failed state
we need to to set `DEVICE_NEEDS_RESET` status field and if `DRIVER_OK`
is set we need to must send a device configuration change interrupt to
the driver.

In MMIO code we were trying to follow this logic, but we were trying to
get the interrupt object from the device, which fails (and panics)
because interrupts are only set in the device upon successful
activation. In the PCI transport, instead, we were not doing this at
all.

The transport layers hold a reference to the interrupts at all times.
So, add the missing logic to the PCI transport and use the transport
layer reference in both transports to avoid panics.

Signed-off-by: Babis Chalios <[email protected]>

Author: bchalios

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

@@ -190,10 +190,7 @@ impl MmioTransport {
 
                         // Section 2.1.2 of the specification states that we need to send a device
                         // configuration change interrupt
-                        let _ = self
-                            .locked_device()
-                            .interrupt_trigger()
-                            .trigger(VirtioInterruptType::Config);
+                        let _ = self.interrupt.trigger(VirtioInterruptType::Config);
 
                         error!("Failed to activate virtio device: {}", err)
                     }

src/vmm/src/devices/virtio/transport/pci/device.rs

@@ -1029,15 +1029,22 @@ impl PciDevice for VirtioPciDevice {
         // Try and activate the device if the driver status has changed
         if self.needs_activation() {
             debug!("Activating device");
-            self.virtio_device()
+            let interrupt = Arc::clone(self.virtio_interrupt.as_ref().unwrap());
+            match self
+                .virtio_device()
                 .lock()
                 .unwrap()
-                .activate(
-                    self.memory.clone(),
-                    Arc::clone(self.virtio_interrupt.as_ref().unwrap()),
-                )
-                .unwrap_or_else(|err| error!("Error activating device: {err:?}"));
-            self.device_activated.store(true, Ordering::SeqCst);
+                .activate(self.memory.clone(), interrupt.clone())
+            {
+                Ok(()) => self.device_activated.store(true, Ordering::SeqCst),
+                Err(err) => {
+                    error!("Error activating device: {err:?}");
+
+                    // Section 2.1.2 of the specification states that we need to send a device
+                    // configuration change interrupt
+                    let _ = interrupt.trigger(VirtioInterruptType::Config);
+                }
+            }
         } else {
             debug!("Device doesn't need activation");
         }