interrupt: add common triggers

Add a triggers module containing common implementations for triggers.
Add EventFdTrigger which is a Trigger that uses an underlying EventFd.
EventFds are commonly used with KVM based VMMs.

Signed-off-by: Alexandru-Cezar Sardan <alsardan@amazon.com>

Author: Alexandru-Cezar Sardan

Cargo.toml

@@ -9,3 +9,4 @@ repository = "https://github.com/rust-vmm/vm-device"
 license = "Apache-2.0 OR BSD-3-Clause"
 
 [dependencies]
+vmm-sys-util = { version = "0.8.0" }

src/interrupt/mod.rs

@@ -44,25 +44,13 @@
 pub mod legacy;
 pub mod msi;
 
+pub mod trigger;
+
 use std::fmt::{self, Display};
 use std::io;
 use std::ops::Deref;
 
-/// Abstraction for a simple, push-button like interrupt mechanism.
-/// This helps in abstracting away how events/interrupts are generated when
-/// working with the emulated devices.
-///
-/// The user has to provide a `Trigger` object to the device's constructor when
-/// initializing that device. The generic type `T: Trigger` is used in the
-/// device's structure definition to mark the fact that the events notification
-/// mechanism is done via the Trigger interface.
-pub trait Trigger {
-    /// Underlying type for the potential error conditions returned by `Self::trigger`.
-    type E: std::fmt::Debug;
-
-    /// Trigger an event.
-    fn trigger(&self) -> std::result::Result<(), Self::E>;
-}
+use crate::interrupt::trigger::Trigger;
 
 /// Errors associated with handling interrupts
 #[derive(Debug)]

src/interrupt/trigger/eventfd.rs

@@ -0,0 +1,59 @@
+// Copyright (C) 2021 Amazon.com, Inc. or its affiliates.
+// All Rights Reserved.
+
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+//! Implementation for a Trigger based on EventFd.
+
+use std::io;
+use std::ops::Deref;
+use vmm_sys_util::eventfd::EventFd;
+
+use crate::interrupt::trigger::Trigger;
+
+/// Trait used for creating an EventFd from an object.
+pub trait AsEventFd {
+    /// Convert this object to an EventFd.
+    fn as_event_fd(&self) -> io::Result<EventFd>;
+}
+
+/// Newtype for implementing the trigger functionality for `EventFd`.
+pub struct EventFdTrigger(EventFd);
+
+impl Trigger for EventFdTrigger {
+    type E = io::Error;
+
+    fn trigger(&self) -> io::Result<()> {
+        self.write(1)
+    }
+}
+impl Deref for EventFdTrigger {
+    type Target = EventFd;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl EventFdTrigger {
+    /// Try to clone this EventFdTrigger into a new object.
+    /// Returns an error if the underlying EventFd cannot be cloned.
+    pub fn try_clone(&self) -> io::Result<Self> {
+        Ok(EventFdTrigger((**self).try_clone()?))
+    }
+
+    /// Construct a new EventFdTrigger using the EventFd passed as parameter.
+    pub fn new(evt: EventFd) -> Self {
+        Self(evt)
+    }
+
+    /// Get a clone of the underlying EventFd of this Trigger.
+    pub fn get_event(&self) -> io::Result<EventFd> {
+        self.0.try_clone()
+    }
+}
+
+impl AsEventFd for EventFdTrigger {
+    fn as_event_fd(&self) -> io::Result<EventFd> {
+        self.get_event()
+    }
+}

src/interrupt/trigger/mod.rs

@@ -0,0 +1,25 @@
+// Copyright (C) 2021 Amazon.com, Inc. or its affiliates.
+// All Rights Reserved.
+
+// SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
+
+//! Triggers that are commonly used by multiple VMMs.
+
+#[cfg(target_os = "linux")]
+pub mod eventfd;
+
+/// Abstraction for a simple, push-button like interrupt mechanism.
+/// This helps in abstracting away how events/interrupts are generated when
+/// working with the emulated devices.
+///
+/// The user has to provide a `Trigger` object to the device's constructor when
+/// initializing that device. The generic type `T: Trigger` is used in the
+/// device's structure definition to mark the fact that the events notification
+/// mechanism is done via the Trigger interface.
+pub trait Trigger {
+    /// Underlying type for the potential error conditions returned by `Self::trigger`.
+    type E: std::fmt::Debug;
+
+    /// Trigger an event.
+    fn trigger(&self) -> std::result::Result<(), Self::E>;
+}