From 12f90569e25446183687d7584f13893f2b088796 Mon Sep 17 00:00:00 2001 From: Rob Bradford Date: Fri, 4 Sep 2020 09:37:37 +0100 Subject: [PATCH] virtio-devices: vhost-user-net: Port to VirtioCommon Use VirtioCommon to handle activate() preparation, reset() and Pausable. Signed-off-by: Rob Bradford --- virtio-devices/src/vhost_user/net.rs | 158 +++++++++++++-------------- 1 file changed, 78 insertions(+), 80 deletions(-) diff --git a/virtio-devices/src/vhost_user/net.rs b/virtio-devices/src/vhost_user/net.rs index 4f1e92a94..ba985b2b0 100644 --- a/virtio-devices/src/vhost_user/net.rs +++ b/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, - pause_evt: Option, backend_features: u64, config: VirtioNetConfig, - queue_sizes: Vec, - queue_evts: Option>, - interrupt_cb: Option>, - epoll_threads: Option>>, ctrl_queue_epoll_thread: Option>, - paused: Arc, - paused_sync: Arc, 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, mut queue_evts: Vec, ) -> 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 = 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::::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, Vec)> { // 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()