chore: avoid IrqTrigger::new().unwrap()

`IrqTrigger::new()` returns a `Result` because creating an `EventFd`
might fail with an `std::io::Error` error. All users of `IrqTrigger`
create the object and directly unwrap the error.

To avoid unwraps all over the place, change `IrqTrigger::new()` to
unwrap a potential error while creating the EventFd internally and just
return `Self`.

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

Author: bchalios

src/vmm/src/builder.rs

@@ -597,7 +597,7 @@ fn attach_virtio_device<T: 'static + VirtioDevice + MutEventSubscriber + Debug>(
 ) -> Result<(), MmioError> {
     event_manager.add_subscriber(device.clone());
 
-    let interrupt = Arc::new(IrqTrigger::new()?);
+    let interrupt = Arc::new(IrqTrigger::new());
     // The device mutex mustn't be locked here otherwise it will deadlock.
     let device = MmioTransport::new(
         vmm.vm.guest_memory().clone(),

src/vmm/src/device_manager/mmio.rs

@@ -552,7 +552,7 @@ mod tests {
             cmdline: &mut kernel_cmdline::Cmdline,
             dev_id: &str,
         ) -> Result<u64, MmioError> {
-            let interrupt = Arc::new(IrqTrigger::new().unwrap());
+            let interrupt = Arc::new(IrqTrigger::new());
             let mmio_device = MmioTransport::new(guest_mem, interrupt, device, false);
             let device_info = self.register_mmio_virtio_for_boot(
                 vm,

src/vmm/src/device_manager/persist.rs

@@ -514,8 +514,7 @@ impl<'a> Persist<'a> for MMIODeviceManager {
         };
 
         if let Some(balloon_state) = &state.balloon_device {
-            let interrupt =
-                Arc::new(IrqTrigger::new().expect("Could not create interrupt for MMIO device"));
+            let interrupt = Arc::new(IrqTrigger::new());
             let device = Arc::new(Mutex::new(Balloon::restore(
                 BalloonConstructorArgs {
                     mem: mem.clone(),
@@ -542,8 +541,7 @@ impl<'a> Persist<'a> for MMIODeviceManager {
         }
 
         for block_state in &state.block_devices {
-            let interrupt =
-                Arc::new(IrqTrigger::new().expect("Could not create interrupt for MMIO device"));
+            let interrupt = Arc::new(IrqTrigger::new());
             let device = Arc::new(Mutex::new(Block::restore(
                 BlockConstructorArgs {
                     mem: mem.clone(),
@@ -585,8 +583,7 @@ impl<'a> Persist<'a> for MMIODeviceManager {
         }
 
         for net_state in &state.net_devices {
-            let interrupt =
-                Arc::new(IrqTrigger::new().expect("Could not create interrupt for MMIO device"));
+            let interrupt = Arc::new(IrqTrigger::new());
             let device = Arc::new(Mutex::new(Net::restore(
                 NetConstructorArgs {
                     mem: mem.clone(),
@@ -622,8 +619,7 @@ impl<'a> Persist<'a> for MMIODeviceManager {
                 cid: vsock_state.device_state.frontend.cid,
             };
             let backend = VsockUnixBackend::restore(ctor_args, &vsock_state.device_state.backend)?;
-            let interrupt =
-                Arc::new(IrqTrigger::new().expect("Could not create interrupt for MMIO device"));
+            let interrupt = Arc::new(IrqTrigger::new());
             let device = Arc::new(Mutex::new(Vsock::restore(
                 VsockConstructorArgs {
                     mem: mem.clone(),
@@ -650,8 +646,7 @@ impl<'a> Persist<'a> for MMIODeviceManager {
         }
 
         if let Some(entropy_state) = &state.entropy_device {
-            let interrupt =
-                Arc::new(IrqTrigger::new().expect("Could not create interrupt for MMIO device"));
+            let interrupt = Arc::new(IrqTrigger::new());
             let ctor_args = EntropyConstructorArgs::new(mem.clone(), interrupt.clone());
 
             let device = Arc::new(Mutex::new(Entropy::restore(

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

@@ -431,7 +431,7 @@ mod tests {
         Arc<Mutex<VirtioBlock>>,
     ) {
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
 
         // Create backing file.
         let f = TempFile::new().unwrap();
@@ -454,7 +454,7 @@ mod tests {
         Arc<Mutex<Net>>,
     ) {
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let net = Arc::new(Mutex::new(default_net()));
         let mmio_transport = MmioTransport::new(mem.clone(), interrupt.clone(), net.clone(), false);
 
@@ -468,7 +468,7 @@ mod tests {
         Arc<Mutex<Vsock<VsockUnixBackend>>>,
     ) {
         let mem = default_mem();
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
 
         let guest_cid = 52;
         let mut temp_uds_path = TempFile::new().unwrap();

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

@@ -33,7 +33,7 @@ pub fn default_mem() -> GuestMemoryMmap {
 
 /// Creates a default ['IrqTrigger'] interrupt for a VirtIO device.
 pub fn default_interrupt() -> Arc<dyn VirtioInterrupt> {
-    Arc::new(IrqTrigger::new().unwrap())
+    Arc::new(IrqTrigger::new())
 }
 
 #[derive(Debug)]

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

@@ -426,12 +426,19 @@ impl VirtioInterrupt for IrqTrigger {
     }
 }
 
+impl Default for IrqTrigger {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl IrqTrigger {
-    pub fn new() -> std::io::Result<Self> {
-        Ok(Self {
+    pub fn new() -> Self {
+        Self {
             irq_status: Arc::new(AtomicU32::new(0)),
-            irq_evt: EventFd::new(libc::EFD_NONBLOCK)?,
-        })
+            irq_evt: EventFd::new(libc::EFD_NONBLOCK)
+                .expect("Could not create EventFd for IrqTrigger"),
+        }
     }
 
     pub fn trigger_irq(&self, irq_type: IrqType) -> Result<(), std::io::Error> {
@@ -570,7 +577,7 @@ pub(crate) mod tests {
     #[test]
     fn test_new() {
         let m = single_region_mem(0x1000);
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let mut dummy = DummyDevice::new();
         // Validate reset is no-op.
         assert!(dummy.reset().is_none());
@@ -603,7 +610,7 @@ pub(crate) mod tests {
     #[test]
     fn test_bus_device_read() {
         let m = single_region_mem(0x1000);
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let mut d = MmioTransport::new(
             m,
             interrupt,
@@ -699,7 +706,7 @@ pub(crate) mod tests {
     #[allow(clippy::cognitive_complexity)]
     fn test_bus_device_write() {
         let m = single_region_mem(0x1000);
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let dummy_dev = Arc::new(Mutex::new(DummyDevice::new()));
         let mut d = MmioTransport::new(m, interrupt, dummy_dev.clone(), false);
         let mut buf = vec![0; 5];
@@ -862,7 +869,7 @@ pub(crate) mod tests {
     #[test]
     fn test_bus_device_activate() {
         let m = single_region_mem(0x1000);
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let mut d = MmioTransport::new(
             m,
             interrupt,
@@ -947,7 +954,7 @@ pub(crate) mod tests {
     #[test]
     fn test_bus_device_activate_failure() {
         let m = single_region_mem(0x1000);
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let device = DummyDevice {
             activate_should_error: true,
             ..DummyDevice::new()
@@ -1060,7 +1067,7 @@ pub(crate) mod tests {
     #[test]
     fn test_bus_device_reset() {
         let m = single_region_mem(0x1000);
-        let interrupt = Arc::new(IrqTrigger::new().unwrap());
+        let interrupt = Arc::new(IrqTrigger::new());
         let mut d = MmioTransport::new(
             m,
             interrupt,
@@ -1119,7 +1126,7 @@ pub(crate) mod tests {
 
     #[test]
     fn irq_trigger() {
-        let irq_trigger = IrqTrigger::new().unwrap();
+        let irq_trigger = IrqTrigger::new();
         assert_eq!(irq_trigger.irq_status.load(Ordering::SeqCst), 0);
 
         // Check that there are no pending irqs.