diff --git a/virtio-devices/src/rng.rs b/virtio-devices/src/rng.rs index 7b522f750..79f4daf6a 100644 --- a/virtio-devices/src/rng.rs +++ b/virtio-devices/src/rng.rs @@ -11,13 +11,12 @@ use super::{ use crate::seccomp_filters::{get_seccomp_filter, Thread}; use crate::{VirtioInterrupt, VirtioInterruptType}; use anyhow::anyhow; -use libc::EFD_NONBLOCK; use seccomp::{SeccompAction, SeccompFilter}; use std::fs::File; use std::io; 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}; use std::thread; use vm_memory::{Bytes, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap}; @@ -28,7 +27,6 @@ use vm_migration::{ use vmm_sys_util::eventfd::EventFd; const QUEUE_SIZE: u16 = 256; -const NUM_QUEUES: usize = 1; const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE]; // New descriptors are pending on the virtio queue. @@ -129,14 +127,7 @@ impl EpollHelperHandler for RngEpollHandler { pub struct Rng { common: VirtioCommon, id: String, - kill_evt: Option, - pause_evt: Option, random_file: Option, - queue_evts: Option>, - interrupt_cb: Option>, - epoll_threads: Option>>, - paused: Arc, - paused_sync: Arc, seccomp_action: SeccompAction, } @@ -144,7 +135,6 @@ pub struct Rng { pub struct RngState { pub avail_features: u64, pub acked_features: u64, - pub paused: Arc, } impl Rng { @@ -164,18 +154,14 @@ impl Rng { Ok(Rng { common: VirtioCommon { + device_type: VirtioDeviceType::TYPE_RNG as u32, + queue_sizes: QUEUE_SIZES.to_vec(), + paused_sync: Some(Arc::new(Barrier::new(2))), avail_features, ..Default::default() }, id, - kill_evt: None, - pause_evt: None, random_file: Some(random_file), - queue_evts: None, - interrupt_cb: None, - epoll_threads: None, - paused: Arc::new(AtomicBool::new(false)), - paused_sync: Arc::new(Barrier::new(2)), seccomp_action, }) } @@ -184,22 +170,19 @@ impl Rng { RngState { avail_features: self.common.avail_features, acked_features: self.common.acked_features, - paused: self.paused.clone(), } } fn set_state(&mut self, state: &RngState) -> io::Result<()> { self.common.avail_features = state.avail_features; self.common.acked_features = state.acked_features; - self.paused = state.paused.clone(); - Ok(()) } } impl Drop for Rng { 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); } @@ -208,11 +191,11 @@ impl Drop for Rng { impl VirtioDevice for Rng { fn device_type(&self) -> u32 { - VirtioDeviceType::TYPE_RNG as u32 + self.common.device_type } fn queue_max_sizes(&self) -> &[u16] { - QUEUE_SIZES + &self.common.queue_sizes } fn features(&self) -> u64 { @@ -230,45 +213,27 @@ impl VirtioDevice for Rng { queues: Vec, mut 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); if let Some(file) = self.random_file.as_ref() { let random_file = file.try_clone().map_err(|e| { @@ -285,8 +250,8 @@ impl VirtioDevice for Rng { pause_evt, }; - 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_rng thread let virtio_rng_seccomp_filter = @@ -297,7 +262,7 @@ impl VirtioDevice for Rng { .spawn(move || { if let Err(e) = SeccompFilter::apply(virtio_rng_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); } }) @@ -307,7 +272,7 @@ impl VirtioDevice for Rng { ActivateError::BadActivate })?; - self.epoll_threads = Some(epoll_threads); + self.common.epoll_threads = Some(epoll_threads); return Ok(()); } @@ -315,26 +280,20 @@ impl VirtioDevice for Rng { } 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()?; - } - - // Then kill it. - 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 Rng { + fn pause(&mut self) -> result::Result<(), MigratableError> { + self.common.pause() + } + + fn resume(&mut self) -> result::Result<(), MigratableError> { + self.common.resume() } } -virtio_pausable!(Rng); impl Snapshottable for Rng { fn id(&self) -> String { self.id.clone()