Simplify trait/impl bound declarations

Currently trait bound declarations is a little over complex when
defines traits or implements traits/structs. Let's simplfy it.

Signed-off-by: Liu Jiang <gerry@linux.alibaba.com>

Author: jiangliu

src/backend.rs

@@ -33,9 +33,8 @@ use super::GM;
 
 /// Trait with interior mutability for vhost user backend servers to implement concrete services.
 ///
-/// To support multi-threading and asynchronous IO, we enforce `the Send + Sync + 'static`.
-/// So there's no plan for support of "Rc<T>" and "RefCell<T>".
-pub trait VhostUserBackend<V, B = ()>: Send + Sync + 'static
+/// To support multi-threading and asynchronous IO, we enforce `Send + Sync` bound.
+pub trait VhostUserBackend<V, B = ()>: Send + Sync
 where
     V: VringT<GM<B>>,
     B: Bitmap + 'static,
@@ -118,7 +117,7 @@ where
 }
 
 /// Trait without interior mutability for vhost user backend servers to implement concrete services.
-pub trait VhostUserBackendMut<V, B = ()>: Send + Sync + 'static
+pub trait VhostUserBackendMut<V, B = ()>: Send + Sync
 where
     V: VringT<GM<B>>,
     B: Bitmap + 'static,

src/event_loop.rs

@@ -58,12 +58,7 @@ pub type VringEpollResult<T> = std::result::Result<T, VringEpollError>;
 /// - add file descriptors to be monitored by the epoll fd
 /// - remove registered file descriptors from the epoll fd
 /// - run the event loop to handle pending events on the epoll fd
-pub struct VringEpollHandler<S, V, B>
-where
-    S: VhostUserBackend<V, B>,
-    V: VringT<GM<B>>,
-    B: Bitmap + 'static,
-{
+pub struct VringEpollHandler<S, V, B> {
     epoll: Epoll,
     backend: S,
     vrings: Vec<V>,
@@ -72,6 +67,15 @@ where
     phantom: PhantomData<B>,
 }
 
+impl<S, V, B> VringEpollHandler<S, V, B> {
+    /// Send `exit event` to break the event loop.
+    pub fn send_exit_event(&self) {
+        if let Some(eventfd) = self.exit_event_fd.as_ref() {
+            let _ = eventfd.write(1);
+        }
+    }
+}
+
 impl<S, V, B> VringEpollHandler<S, V, B>
 where
     S: VhostUserBackend<V, B>,
@@ -115,13 +119,6 @@ where
         Ok(handler)
     }
 
-    /// Send `exit event` to break the event loop.
-    pub fn send_exit_event(&self) {
-        if let Some(eventfd) = self.exit_event_fd.as_ref() {
-            let _ = eventfd.write(1);
-        }
-    }
-
     /// Register an event into the epoll fd.
     ///
     /// When this event is later triggered, the backend implementation of `handle_event` will be

src/handler.rs

@@ -71,12 +71,7 @@ struct AddrMapping {
     gpa_base: u64,
 }
 
-pub struct VhostUserHandler<S, V, B>
-where
-    S: VhostUserBackend<V, B>,
-    V: VringT<GM<B>>,
-    B: Bitmap + 'static,
-{
+pub struct VhostUserHandler<S, V, B: Bitmap + 'static> {
     backend: S,
     handlers: Vec<Arc<VringEpollHandler<S, V, B>>>,
     owned: bool,
@@ -92,11 +87,12 @@ where
     worker_threads: Vec<thread::JoinHandle<VringEpollResult<()>>>,
 }
 
+// Ensure VhostUserHandler: Clone + Send + Sync + 'static.
 impl<S, V, B> VhostUserHandler<S, V, B>
 where
-    S: VhostUserBackend<V, B> + Clone,
+    S: VhostUserBackend<V, B> + Clone + 'static,
     V: VringT<GM<B>> + Clone + Send + Sync + 'static,
-    B: Bitmap + Clone + Send + Sync,
+    B: Bitmap + Clone + Send + Sync + 'static,
 {
     pub(crate) fn new(backend: S, atomic_mem: GM<B>) -> VhostUserHandlerResult<Self> {
         let num_queues = backend.num_queues();
@@ -151,16 +147,7 @@ where
     }
 }
 
-impl<S, V, B> VhostUserHandler<S, V, B>
-where
-    S: VhostUserBackend<V, B>,
-    V: VringT<GM<B>>,
-    B: Bitmap,
-{
-    pub(crate) fn get_epoll_handlers(&self) -> Vec<Arc<VringEpollHandler<S, V, B>>> {
-        self.handlers.clone()
-    }
-
+impl<S, V, B: Bitmap> VhostUserHandler<S, V, B> {
     pub(crate) fn send_exit_event(&self) {
         for handler in self.handlers.iter() {
             handler.send_exit_event();
@@ -176,6 +163,17 @@ where
 
         Err(VhostUserHandlerError::MissingMemoryMapping)
     }
+}
+
+impl<S, V, B> VhostUserHandler<S, V, B>
+where
+    S: VhostUserBackend<V, B>,
+    V: VringT<GM<B>>,
+    B: Bitmap,
+{
+    pub(crate) fn get_epoll_handlers(&self) -> Vec<Arc<VringEpollHandler<S, V, B>>> {
+        self.handlers.clone()
+    }
 
     fn vring_needs_init(&self, vring: &V) -> bool {
         let vring_state = vring.get_ref();
@@ -581,12 +579,7 @@ where
     }
 }
 
-impl<S, V, B> Drop for VhostUserHandler<S, V, B>
-where
-    S: VhostUserBackend<V, B>,
-    V: VringT<GM<B>>,
-    B: Bitmap,
-{
+impl<S, V, B: Bitmap> Drop for VhostUserHandler<S, V, B> {
     fn drop(&mut self) {
         // Signal all working threads to exit.
         self.send_exit_event();

src/lib.rs

@@ -73,20 +73,15 @@ pub type Result<T> = std::result::Result<T, Error>;
 ///
 /// This structure is the public API the backend is allowed to interact with in order to run
 /// a fully functional vhost-user daemon.
-pub struct VhostUserDaemon<S, V, B = ()>
-where
-    S: VhostUserBackend<V, B>,
-    V: VringT<GM<B>> + Clone + Send + Sync + 'static,
-    B: Bitmap + 'static,
-{
+pub struct VhostUserDaemon<S, V, B: Bitmap + 'static = ()> {
     name: String,
     handler: Arc<Mutex<VhostUserHandler<S, V, B>>>,
     main_thread: Option<thread::JoinHandle<Result<()>>>,
 }
 
 impl<S, V, B> VhostUserDaemon<S, V, B>
 where
-    S: VhostUserBackend<V, B> + Clone,
+    S: VhostUserBackend<V, B> + Clone + 'static,
     V: VringT<GM<B>> + Clone + Send + Sync + 'static,
     B: NewBitmap + Clone + Send + Sync,
 {
@@ -167,6 +162,7 @@ where
     /// This is necessary to perform further actions like registering and unregistering some extra
     /// event file descriptors.
     pub fn get_epoll_handlers(&self) -> Vec<Arc<VringEpollHandler<S, V, B>>> {
+        // Do not expect poisoned lock.
         self.handler.lock().unwrap().get_epoll_handlers()
     }
 }