virtio-devices: virtio-vsock: Port to VirtioCommon

Use VirtioCommon to handle activate() preparation, reset() and Pausable.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>

virtio-devices/src/vsock/device.rs

@@ -37,12 +37,11 @@ use anyhow::anyhow;
 /// - a backend FD.
 ///
 use byteorder::{ByteOrder, LittleEndian};
-use libc::EFD_NONBLOCK;
 use std::io;
 use std::os::unix::io::AsRawFd;
 use std::path::PathBuf;
 use std::result;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Barrier, RwLock};
 use std::thread;
 use vm_memory::{GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap};
@@ -300,13 +299,6 @@ pub struct Vsock<B: VsockBackend> {
     id: String,
     cid: u64,
     backend: Arc<RwLock<B>>,
-    kill_evt: Option<EventFd>,
-    pause_evt: Option<EventFd>,
-    queue_evts: Option<Vec<EventFd>>,
-    interrupt_cb: Option<Arc<dyn VirtioInterrupt>>,
-    epoll_threads: Option<Vec<thread::JoinHandle<()>>>,
-    paused: Arc<AtomicBool>,
-    paused_sync: Arc<Barrier>,
     path: PathBuf,
 }
 
@@ -337,19 +329,15 @@ where
 
         Ok(Vsock {
             common: VirtioCommon {
+                device_type: VirtioDeviceType::TYPE_VSOCK as u32,
                 avail_features,
+                paused_sync: Some(Arc::new(Barrier::new(2))),
+                queue_sizes: QUEUE_SIZES.to_vec(),
                 ..Default::default()
             },
             id,
             cid,
             backend: Arc::new(RwLock::new(backend)),
-            kill_evt: None,
-            pause_evt: None,
-            queue_evts: None,
-            interrupt_cb: None,
-            epoll_threads: None,
-            paused: Arc::new(AtomicBool::new(false)),
-            paused_sync: Arc::new(Barrier::new(2)),
             path,
         })
     }
@@ -374,7 +362,7 @@ where
     B: VsockBackend,
 {
     fn drop(&mut self) {
-        if let Some(kill_evt) = self.kill_evt.take() {
+        if let Some(kill_evt) = self.common.kill_evt.take() {
             // Ignore the result because there is nothing we can do about it.
             let _ = kill_evt.write(1);
         }
@@ -386,11 +374,11 @@ where
     B: VsockBackend + Sync + 'static,
 {
     fn device_type(&self) -> u32 {
-        VirtioDeviceType::TYPE_VSOCK as u32
+        self.common.device_type
     }
 
     fn queue_max_sizes(&self) -> &[u16] {
-        QUEUE_SIZES
+        &self.common.queue_sizes
     }
 
     fn features(&self) -> u64 {
@@ -423,45 +411,27 @@ where
         queues: Vec<Queue>,
         queue_evts: Vec<EventFd>,
     ) -> ActivateResult {
-        if queues.len() != NUM_QUEUES || queue_evts.len() != NUM_QUEUES {
+        self.common.activate(&queues, &queue_evts, &interrupt_cb)?;
-            error!(
+        let kill_evt = self
-                "Cannot perform activate. Expected {} queue(s), got {}",
+            .common
-                NUM_QUEUES,
+            .kill_evt
-                queues.len()
+            .as_ref()
-            );
+            .unwrap()
-            return Err(ActivateError::BadActivate);
+            .try_clone()
-        }
-
-        let (self_kill_evt, kill_evt) = EventFd::new(EFD_NONBLOCK)
-            .and_then(|e| Ok((e.try_clone()?, e)))
             .map_err(|e| {
-                error!("failed creating kill EventFd pair: {}", e);
+                error!("failed to clone kill_evt eventfd: {}", e);
                 ActivateError::BadActivate
             })?;
-        self.kill_evt = Some(self_kill_evt);
+        let pause_evt = self
-
+            .common
-        let (self_pause_evt, pause_evt) = EventFd::new(EFD_NONBLOCK)
+            .pause_evt
-            .and_then(|e| Ok((e.try_clone()?, e)))
+            .as_ref()
+            .unwrap()
+            .try_clone()
             .map_err(|e| {
-                error!("failed creating pause EventFd pair: {}", e);
+                error!("failed to clone pause_evt eventfd: {}", e);
                 ActivateError::BadActivate
             })?;
-        self.pause_evt = Some(self_pause_evt);
-
-        // Save the interrupt EventFD as we need to return it on reset
-        // but clone it to pass into the thread.
-        self.interrupt_cb = Some(interrupt_cb.clone());
-
-        let mut tmp_queue_evts: Vec<EventFd> = Vec::new();
-        for queue_evt in queue_evts.iter() {
-            // Save the queue EventFD as we need to return it on reset
-            // but clone it to pass into the thread.
-            tmp_queue_evts.push(queue_evt.try_clone().map_err(|e| {
-                error!("failed to clone queue EventFd: {}", e);
-                ActivateError::BadActivate
-            })?);
-        }
-        self.queue_evts = Some(tmp_queue_evts);
 
         let mut handler = VsockEpollHandler {
             mem,
@@ -473,13 +443,13 @@ where
             backend: self.backend.clone(),
         };
 
-        let paused = self.paused.clone();
+        let paused = self.common.paused.clone();
-        let paused_sync = self.paused_sync.clone();
+        let paused_sync = self.common.paused_sync.clone();
         let mut epoll_threads = Vec::new();
         thread::Builder::new()
             .name("virtio_vsock".to_string())
             .spawn(move || {
-                if let Err(e) = handler.run(paused, paused_sync) {
+                if let Err(e) = handler.run(paused, paused_sync.unwrap()) {
                     error!("Error running worker: {:?}", e);
                 }
             })
@@ -489,27 +459,13 @@ where
                 ActivateError::BadActivate
             })?;
 
-        self.epoll_threads = Some(epoll_threads);
+        self.common.epoll_threads = Some(epoll_threads);
 
         Ok(())
     }
 
     fn reset(&mut self) -> Option<(Arc<dyn VirtioInterrupt>, Vec<EventFd>)> {
-        // We first must resume the virtio thread if it was paused.
+        self.common.reset()
-        if self.pause_evt.take().is_some() {
-            self.resume().ok()?;
-        }
-
-        if let Some(kill_evt) = self.kill_evt.take() {
-            // Ignore the result because there is nothing we can do about it.
-            let _ = kill_evt.write(1);
-        }
-
-        // Return the interrupt and queue EventFDs
-        Some((
-            self.interrupt_cb.take().unwrap(),
-            self.queue_evts.take().unwrap(),
-        ))
     }
 
     fn shutdown(&mut self) {
@@ -517,7 +473,18 @@ where
     }
 }
 
-virtio_pausable!(Vsock, T: 'static + VsockBackend + Sync);
+impl<B> Pausable for Vsock<B>
+where
+    B: VsockBackend + Sync + 'static,
+{
+    fn pause(&mut self) -> result::Result<(), MigratableError> {
+        self.common.pause()
+    }
+
+    fn resume(&mut self) -> result::Result<(), MigratableError> {
+        self.common.resume()
+    }
+}
 
 impl<B> Snapshottable for Vsock<B>
 where
@@ -571,6 +538,7 @@ mod tests {
     use super::super::*;
     use super::*;
     use crate::vsock::device::{BACKEND_EVENT, EVT_QUEUE_EVENT, RX_QUEUE_EVENT, TX_QUEUE_EVENT};
+    use libc::EFD_NONBLOCK;
 
     #[test]
     fn test_virtio_device() {