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/device_manager/mmio.rs

@@ -585,7 +585,7 @@ mod tests {
                 dummy: 0,
                 queues: QUEUE_SIZES.iter().map(|&s| Queue::new(s)).collect(),
                 queue_evts: [EventFd::new(libc::EFD_NONBLOCK).expect("cannot create eventFD")],
-                interrupt_trigger: IrqTrigger::new().expect("cannot create eventFD"),
+                interrupt_trigger: IrqTrigger::new(),
             }
         }
     }

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

@@ -242,7 +242,7 @@ impl Balloon {
             },
             queue_evts,
             queues,
-            irq_trigger: IrqTrigger::new().map_err(BalloonError::EventFd)?,
+            irq_trigger: IrqTrigger::new(),
             device_state: DeviceState::Inactive,
             activate_evt: EventFd::new(libc::EFD_NONBLOCK).map_err(BalloonError::EventFd)?,
             restored_from_file,

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

@@ -204,7 +204,7 @@ impl<T: VhostUserHandleBackend> VhostUserBlockImpl<T> {
         let queue_evts = [EventFd::new(libc::EFD_NONBLOCK).map_err(VhostUserBlockError::EventFd)?;
             u64_to_usize(NUM_QUEUES)];
         let device_state = DeviceState::Inactive;
-        let irq_trigger = IrqTrigger::new().map_err(VhostUserBlockError::IrqTrigger)?;
+        let irq_trigger = IrqTrigger::new();
 
         // We negotiated features with backend. Now these acked_features
         // are available for guest driver to choose from.

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

@@ -323,7 +323,7 @@ impl VirtioBlock {
             queues,
             queue_evts,
             device_state: DeviceState::Inactive,
-            irq_trigger: IrqTrigger::new().map_err(VirtioBlockError::IrqTrigger)?,
+            irq_trigger: IrqTrigger::new(),
 
             id: config.drive_id.clone(),
             partuuid: config.partuuid,

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

@@ -112,7 +112,7 @@ impl Persist<'_> for VirtioBlock {
             )
             .map_err(VirtioBlockError::Persist)?;
 
-        let mut irq_trigger = IrqTrigger::new().map_err(VirtioBlockError::IrqTrigger)?;
+        let mut irq_trigger = IrqTrigger::new();
         irq_trigger.irq_status = Arc::new(AtomicU32::new(state.virtio_state.interrupt_status));
 
         let avail_features = state.virtio_state.avail_features;

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

@@ -314,7 +314,7 @@ impl Net {
             tx_rate_limiter,
             rx_frame_buf: [0u8; MAX_BUFFER_SIZE],
             tx_frame_headers: [0u8; frame_hdr_len()],
-            irq_trigger: IrqTrigger::new().map_err(NetError::EventFd)?,
+            irq_trigger: IrqTrigger::new(),
             config_space,
             guest_mac,
             device_state: DeviceState::Inactive,

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

@@ -70,7 +70,7 @@ impl Entropy {
         let queue_events = (0..RNG_NUM_QUEUES)
             .map(|_| EventFd::new(libc::EFD_NONBLOCK))
             .collect::<Result<Vec<EventFd>, io::Error>>()?;
-        let irq_trigger = IrqTrigger::new()?;
+        let irq_trigger = IrqTrigger::new();
 
         Ok(Self {
             avail_features: 1 << VIRTIO_F_VERSION_1,

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

@@ -381,12 +381,19 @@ pub struct IrqTrigger {
     pub(crate) irq_evt: EventFd,
 }
 
+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> {
@@ -434,7 +441,7 @@ pub(crate) mod tests {
             DummyDevice {
                 acked_features: 0,
                 avail_features: 0,
-                interrupt_trigger: IrqTrigger::new().unwrap(),
+                interrupt_trigger: IrqTrigger::new(),
                 queue_evts: vec![
                     EventFd::new(libc::EFD_NONBLOCK).unwrap(),
                     EventFd::new(libc::EFD_NONBLOCK).unwrap(),
@@ -1047,7 +1054,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.

src/vmm/src/devices/virtio/vhost_user.rs

@@ -899,7 +899,7 @@ pub(crate) mod tests {
         queue.initialize(&guest_memory).unwrap();
 
         let event_fd = EventFd::new(0).unwrap();
-        let irq_trigger = IrqTrigger::new().unwrap();
+        let irq_trigger = IrqTrigger::new();
 
         let queues = [(0, &queue, &event_fd)];
 

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

@@ -103,7 +103,7 @@ where
             backend,
             avail_features: AVAIL_FEATURES,
             acked_features: 0,
-            irq_trigger: IrqTrigger::new().map_err(VsockError::EventFd)?,
+            irq_trigger: IrqTrigger::new(),
             activate_evt: EventFd::new(libc::EFD_NONBLOCK).map_err(VsockError::EventFd)?,
             device_state: DeviceState::Inactive,
             rx_packet: VsockPacketRx::new()?,