From 376babb21ee916dd81bc2801c031db424250dc72 Mon Sep 17 00:00:00 2001 From: Rob Bradford Date: Fri, 4 Sep 2020 09:37:37 +0100 Subject: [PATCH] virtio-devices: iommu: Port to VirtioCommon Use VirtioCommon to handle activate() preparation, reset() and Pausable. Signed-off-by: Rob Bradford --- virtio-devices/src/iommu.rs | 110 ++++++++++++------------------------ 1 file changed, 37 insertions(+), 73 deletions(-) diff --git a/virtio-devices/src/iommu.rs b/virtio-devices/src/iommu.rs index bd1eb61a3..28b6c26ce 100644 --- a/virtio-devices/src/iommu.rs +++ b/virtio-devices/src/iommu.rs @@ -11,7 +11,6 @@ use super::{ use crate::seccomp_filters::{get_seccomp_filter, Thread}; use crate::{DmaRemapping, VirtioInterrupt, VirtioInterruptType}; use anyhow::anyhow; -use libc::EFD_NONBLOCK; use seccomp::{SeccompAction, SeccompFilter}; use std::collections::BTreeMap; use std::fmt::{self, Display}; @@ -20,7 +19,7 @@ use std::mem::size_of; use std::ops::Bound::Included; use std::os::unix::io::AsRawFd; use std::result; -use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::atomic::AtomicBool; use std::sync::{Arc, Barrier, RwLock}; use std::thread; use vfio_ioctls::ExternalDmaMapping; @@ -738,17 +737,10 @@ impl DmaRemapping for IommuMapping { pub struct Iommu { common: VirtioCommon, id: String, - kill_evt: Option, - pause_evt: Option, config: VirtioIommuConfig, config_topo_pci_ranges: Vec, mapping: Arc, ext_mapping: BTreeMap>, - queue_evts: Option>, - interrupt_cb: Option>, - epoll_threads: Option>>, - paused: Arc, - paused_sync: Arc, seccomp_action: SeccompAction, } @@ -776,23 +768,19 @@ impl Iommu { Ok(( Iommu { id, - kill_evt: None, - pause_evt: None, common: VirtioCommon { + device_type: VirtioDeviceType::TYPE_IOMMU as u32, + queue_sizes: QUEUE_SIZES.to_vec(), avail_features: 1u64 << VIRTIO_F_VERSION_1 | 1u64 << VIRTIO_IOMMU_F_MAP_UNMAP | 1u64 << VIRTIO_IOMMU_F_PROBE, + paused_sync: Some(Arc::new(Barrier::new(2))), ..Default::default() }, config, config_topo_pci_ranges: Vec::new(), mapping: mapping.clone(), ext_mapping: BTreeMap::new(), - queue_evts: None, - interrupt_cb: None, - epoll_threads: None, - paused: Arc::new(AtomicBool::new(false)), - paused_sync: Arc::new(Barrier::new(2)), seccomp_action, }, mapping, @@ -863,7 +851,7 @@ impl Iommu { impl Drop for Iommu { 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); } @@ -872,11 +860,11 @@ impl Drop for Iommu { impl VirtioDevice for Iommu { fn device_type(&self) -> u32 { - VirtioDeviceType::TYPE_IOMMU as u32 + self.common.device_type } fn queue_max_sizes(&self) -> &[u16] { - QUEUE_SIZES + &self.common.queue_sizes } fn features(&self) -> u64 { @@ -904,46 +892,27 @@ impl VirtioDevice for Iommu { queues: Vec, queue_evts: Vec, ) -> ActivateResult { - if queues.len() != NUM_QUEUES || queue_evts.len() != NUM_QUEUES { - error!( - "Cannot perform activate. Expected {} queue(s), got {}", - NUM_QUEUES, - queues.len() - ); - return Err(ActivateError::BadActivate); - } - - let (self_kill_evt, kill_evt) = EventFd::new(EFD_NONBLOCK) - .and_then(|e| Ok((e.try_clone()?, e))) + self.common.activate(&queues, &queue_evts, &interrupt_cb)?; + let kill_evt = self + .common + .kill_evt + .as_ref() + .unwrap() + .try_clone() .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 (self_pause_evt, pause_evt) = EventFd::new(EFD_NONBLOCK) - .and_then(|e| Ok((e.try_clone()?, e))) + let pause_evt = self + .common + .pause_evt + .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 = 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 = IommuEpollHandler { queues, mem, @@ -956,8 +925,8 @@ impl VirtioDevice for Iommu { ext_domain_mapping: BTreeMap::new(), }; - 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 mut epoll_threads = Vec::new(); // Retrieve seccomp filter for virtio_iommu thread let virtio_iommu_seccomp_filter = @@ -968,7 +937,7 @@ impl VirtioDevice for Iommu { .spawn(move || { if let Err(e) = SeccompFilter::apply(virtio_iommu_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); } }) @@ -978,31 +947,26 @@ impl VirtioDevice for Iommu { ActivateError::BadActivate })?; - 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 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(), - )) + self.common.reset() + } +} + +impl Pausable for Iommu { + fn pause(&mut self) -> result::Result<(), MigratableError> { + self.common.pause() + } + + fn resume(&mut self) -> result::Result<(), MigratableError> { + self.common.resume() } } -virtio_pausable!(Iommu); impl Snapshottable for Iommu { fn id(&self) -> String { self.id.clone()