virtio-devices: vhost-user-net: Port to VirtioCommon

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

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

virtio-devices/src/vhost_user/net.rs

@@ -12,12 +12,10 @@ use super::vu_common_ctrl::*;
 use super::{Error, Result};
 use crate::seccomp_filters::{get_seccomp_filter, Thread};
 use crate::VirtioInterrupt;
-use libc::EFD_NONBLOCK;
 use net_util::MacAddr;
 use seccomp::{SeccompAction, SeccompFilter};
 use std::os::unix::io::AsRawFd;
 use std::result;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Barrier};
 use std::thread;
 use std::vec::Vec;
@@ -39,17 +37,9 @@ pub struct Net {
     common: VirtioCommon,
     id: String,
     vhost_user_net: Master,
-    kill_evt: Option<EventFd>,
-    pause_evt: Option<EventFd>,
     backend_features: u64,
     config: VirtioNetConfig,
-    queue_sizes: Vec<u16>,
-    queue_evts: Option<Vec<EventFd>>,
-    interrupt_cb: Option<Arc<dyn VirtioInterrupt>>,
-    epoll_threads: Option<Vec<thread::JoinHandle<()>>>,
     ctrl_queue_epoll_thread: Option<thread::JoinHandle<()>>,
-    paused: Arc<AtomicBool>,
-    paused_sync: Arc<Barrier>,
     seccomp_action: SeccompAction,
 }
 
@@ -149,22 +139,17 @@ impl Net {
         Ok(Net {
             id,
             common: VirtioCommon {
+                device_type: VirtioDeviceType::TYPE_NET as u32,
+                queue_sizes: vec![vu_cfg.queue_size; queue_num],
                 avail_features,
                 acked_features,
+                paused_sync: Some(Arc::new(Barrier::new((vu_cfg.num_queues / 2) + 1))),
                 ..Default::default()
             },
             vhost_user_net,
-            kill_evt: None,
-            pause_evt: None,
             backend_features,
             config,
-            queue_sizes: vec![vu_cfg.queue_size; queue_num],
-            queue_evts: None,
-            interrupt_cb: None,
-            epoll_threads: None,
             ctrl_queue_epoll_thread: None,
-            paused: Arc::new(AtomicBool::new(false)),
-            paused_sync: Arc::new(Barrier::new((vu_cfg.num_queues / 2) + 1)),
             seccomp_action,
         })
     }
@@ -172,7 +157,7 @@ impl Net {
 
 impl Drop for Net {
     fn drop(&mut self) {
-        if let Some(kill_evt) = self.kill_evt.take() {
+        if let Some(kill_evt) = self.common.kill_evt.take() {
             if let Err(e) = kill_evt.write(1) {
                 error!("failed to kill vhost-user-net: {:?}", e);
             }
@@ -182,11 +167,11 @@ impl Drop for Net {
 
 impl VirtioDevice for Net {
     fn device_type(&self) -> u32 {
-        VirtioDeviceType::TYPE_NET as u32
+        self.common.device_type
     }
 
     fn queue_max_sizes(&self) -> &[u16] {
-        &self.queue_sizes
+        &self.common.queue_sizes
     }
 
     fn features(&self) -> u64 {
@@ -208,47 +193,9 @@ impl VirtioDevice for Net {
         mut queues: Vec<Queue>,
         mut queue_evts: Vec<EventFd>,
     ) -> ActivateResult {
-        if queues.len() != self.queue_sizes.len() || queue_evts.len() != self.queue_sizes.len() {
-            error!(
-                "Cannot perform activate. Expected {} queue(s), got {}",
-                self.queue_sizes.len(),
-                queues.len()
-            );
-            return Err(ActivateError::BadActivate);
-        }
+        self.common.activate(&queues, &queue_evts, &interrupt_cb)?;
 
-        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);
-                ActivateError::BadActivate
-            })?;
-        self.kill_evt = Some(self_kill_evt);
-
-        let (self_pause_evt, pause_evt) = EventFd::new(EFD_NONBLOCK)
-            .and_then(|e| Ok((e.try_clone()?, e)))
-            .map_err(|e| {
-                error!("failed creating pause EventFd pair: {}", 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 queue_num = queue_evts.len();
+        let queue_num = self.common.queue_evts.as_ref().unwrap().len();
 
         if self
             .common
@@ -258,20 +205,41 @@ impl VirtioDevice for Net {
             let cvq_queue = queues.remove(queue_num - 1);
             let cvq_queue_evt = queue_evts.remove(queue_num - 1);
 
+            let kill_evt = self
+                .common
+                .kill_evt
+                .as_ref()
+                .unwrap()
+                .try_clone()
+                .map_err(|e| {
+                    error!("failed to clone kill_evt eventfd: {}", e);
+                    ActivateError::BadActivate
+                })?;
+            let pause_evt = self
+                .common
+                .pause_evt
+                .as_ref()
+                .unwrap()
+                .try_clone()
+                .map_err(|e| {
+                    error!("failed to clone pause_evt eventfd: {}", e);
+                    ActivateError::BadActivate
+                })?;
+
             let mut ctrl_handler = NetCtrlEpollHandler {
                 mem: mem.clone(),
-                kill_evt: kill_evt.try_clone().unwrap(),
-                pause_evt: pause_evt.try_clone().unwrap(),
+                kill_evt,
+                pause_evt,
                 ctrl_q: CtrlVirtio::new(cvq_queue, cvq_queue_evt),
                 epoll_fd: 0,
             };
 
-            let paused = self.paused.clone();
+            let paused = self.common.paused.clone();
             // Let's update the barrier as we need 1 for each RX/TX pair +
             // 1 for the control queue + 1 for the main thread signalling
             // the pause.
-            self.paused_sync = Arc::new(Barrier::new((queue_num / 2) + 2));
-            let paused_sync = self.paused_sync.clone();
+            self.common.paused_sync = Some(Arc::new(Barrier::new((queue_num / 2) + 2)));
+            let paused_sync = self.common.paused_sync.clone();
             let virtio_vhost_net_ctl_seccomp_filter =
                 get_seccomp_filter(&self.seccomp_action, Thread::VirtioVhostNetCtl)
                     .map_err(ActivateError::CreateSeccompFilter)?;
@@ -280,7 +248,7 @@ impl VirtioDevice for Net {
                 .spawn(move || {
                     if let Err(e) = SeccompFilter::apply(virtio_vhost_net_ctl_seccomp_filter) {
                         error!("Error applying seccomp filter: {:?}", e);
-                    } else if let Err(e) = ctrl_handler.run_ctrl(paused, paused_sync) {
+                    } else if let Err(e) = ctrl_handler.run_ctrl(paused, paused_sync.unwrap()) {
                         error!("Error running worker: {:?}", e);
                     }
                 })
@@ -307,16 +275,37 @@ impl VirtioDevice for Net {
             interrupt_list_sub.push(vu_interrupt_list.remove(0));
             interrupt_list_sub.push(vu_interrupt_list.remove(0));
 
+            let kill_evt = self
+                .common
+                .kill_evt
+                .as_ref()
+                .unwrap()
+                .try_clone()
+                .map_err(|e| {
+                    error!("failed to clone kill_evt eventfd: {}", e);
+                    ActivateError::BadActivate
+                })?;
+            let pause_evt = self
+                .common
+                .pause_evt
+                .as_ref()
+                .unwrap()
+                .try_clone()
+                .map_err(|e| {
+                    error!("failed to clone pause_evt eventfd: {}", e);
+                    ActivateError::BadActivate
+                })?;
+
             let mut handler = VhostUserEpollHandler::<SlaveReqHandler>::new(VhostUserEpollConfig {
                 interrupt_cb: interrupt_cb.clone(),
-                kill_evt: kill_evt.try_clone().unwrap(),
-                pause_evt: pause_evt.try_clone().unwrap(),
+                kill_evt,
+                pause_evt,
                 vu_interrupt_list: interrupt_list_sub,
                 slave_req_handler: None,
             });
 
-            let paused = self.paused.clone();
-            let paused_sync = self.paused_sync.clone();
+            let paused = self.common.paused.clone();
+            let paused_sync = self.common.paused_sync.clone();
             let virtio_vhost_net_seccomp_filter =
                 get_seccomp_filter(&self.seccomp_action, Thread::VirtioVhostNet)
                     .map_err(ActivateError::CreateSeccompFilter)?;
@@ -325,7 +314,7 @@ impl VirtioDevice for Net {
                 .spawn(move || {
                     if let Err(e) = SeccompFilter::apply(virtio_vhost_net_seccomp_filter) {
                         error!("Error applying seccomp filter: {:?}", e);
-                    } else if let Err(e) = handler.run(paused, paused_sync) {
+                    } else if let Err(e) = handler.run(paused, paused_sync.unwrap()) {
                         error!("Error running worker: {:?}", e);
                     }
                 })
@@ -336,31 +325,31 @@ impl VirtioDevice for Net {
                 })?;
         }
 
-        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.
-        if self.pause_evt.take().is_some() {
-            self.resume().ok()?;
+        if self.common.pause_evt.take().is_some() {
+            self.common.resume().ok()?;
         }
 
-        if let Err(e) = reset_vhost_user(&mut self.vhost_user_net, self.queue_sizes.len()) {
+        if let Err(e) = reset_vhost_user(&mut self.vhost_user_net, self.common.queue_sizes.len()) {
             error!("Failed to reset vhost-user daemon: {:?}", e);
             return None;
         }
 
-        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);
         }
 
         // Return the interrupt and queue EventFDs
         Some((
-            self.interrupt_cb.take().unwrap(),
-            self.queue_evts.take().unwrap(),
+            self.common.interrupt_cb.take().unwrap(),
+            self.common.queue_evts.take().unwrap(),
         ))
     }
 
@@ -373,7 +362,16 @@ impl VirtioDevice for Net {
     }
 }
 
-virtio_ctrl_q_pausable!(Net);
+impl Pausable for Net {
+    fn pause(&mut self) -> result::Result<(), MigratableError> {
+        self.common.pause()
+    }
+
+    fn resume(&mut self) -> result::Result<(), MigratableError> {
+        self.common.resume()
+    }
+}
+
 impl Snapshottable for Net {
     fn id(&self) -> String {
         self.id.clone()