External/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2024-10-01 11:05:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

virtio-devices: rng: Port to VirtioCommon

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

Signed-off-by: Rob Bradford <robert.bradford@intel.com>
This commit is contained in:
Rob Bradford 2020-09-04 09:37:37 +01:00
parent d5d0b8566b
commit c37fb5b602
1 changed files with 37 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
virtio-devices/src/rng.rs
View File

@ -11,13 +11,12 @@ use super::{
use crate::seccomp_filters::{get_seccomp_filter, Thread}; use crate::seccomp_filters::{get_seccomp_filter, Thread};
use crate::{VirtioInterrupt, VirtioInterruptType}; use crate::{VirtioInterrupt, VirtioInterruptType};
use anyhow::anyhow; use anyhow::anyhow;
use libc::EFD_NONBLOCK;
use seccomp::{SeccompAction, SeccompFilter}; use seccomp::{SeccompAction, SeccompFilter};
use std::fs::File; use std::fs::File;
use std::io; use std::io;
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
use std::result; use std::result;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::AtomicBool;
use std::sync::{Arc, Barrier}; use std::sync::{Arc, Barrier};
use std::thread; use std::thread;
use vm_memory::{Bytes, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap}; use vm_memory::{Bytes, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap};
@ -28,7 +27,6 @@ use vm_migration::{
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
const QUEUE_SIZE: u16 = 256; const QUEUE_SIZE: u16 = 256;
const NUM_QUEUES: usize = 1;
const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE]; const QUEUE_SIZES: &[u16] = &[QUEUE_SIZE];
// New descriptors are pending on the virtio queue. // New descriptors are pending on the virtio queue.
@ -129,14 +127,7 @@ impl EpollHelperHandler for RngEpollHandler {
pub struct Rng { pub struct Rng {
common: VirtioCommon, common: VirtioCommon,
id: String, id: String,
kill_evt: Option<EventFd>,
pause_evt: Option<EventFd>,
random_file: Option<File>, random_file: Option<File>,
queue_evts: Option<Vec<EventFd>>,
interrupt_cb: Option<Arc<dyn VirtioInterrupt>>,
epoll_threads: Option<Vec<thread::JoinHandle<()>>>,
paused: Arc<AtomicBool>,
paused_sync: Arc<Barrier>,
seccomp_action: SeccompAction, seccomp_action: SeccompAction,
} }
@ -144,7 +135,6 @@ pub struct Rng {
pub struct RngState { pub struct RngState {
pub avail_features: u64, pub avail_features: u64,
pub acked_features: u64, pub acked_features: u64,
pub paused: Arc<AtomicBool>,
} }
impl Rng { impl Rng {
@ -164,18 +154,14 @@ impl Rng {
Ok(Rng { Ok(Rng {
common: VirtioCommon { 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, avail_features,
..Default::default() ..Default::default()
}, },
id, id,
kill_evt: None,
pause_evt: None,
random_file: Some(random_file), 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, seccomp_action,
}) })
} }
@ -184,22 +170,19 @@ impl Rng {
RngState { RngState {
avail_features: self.common.avail_features, avail_features: self.common.avail_features,
acked_features: self.common.acked_features, acked_features: self.common.acked_features,
paused: self.paused.clone(),
} }
} }
fn set_state(&mut self, state: &RngState) -> io::Result<()> { fn set_state(&mut self, state: &RngState) -> io::Result<()> {
self.common.avail_features = state.avail_features; self.common.avail_features = state.avail_features;
self.common.acked_features = state.acked_features; self.common.acked_features = state.acked_features;
self.paused = state.paused.clone();
Ok(()) Ok(())
} }
} }
impl Drop for Rng { impl Drop for Rng {
fn drop(&mut self) { 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. // Ignore the result because there is nothing we can do about it.
let _ = kill_evt.write(1); let _ = kill_evt.write(1);
} }
@ -208,11 +191,11 @@ impl Drop for Rng {
impl VirtioDevice for Rng { impl VirtioDevice for Rng {
fn device_type(&self) -> u32 { fn device_type(&self) -> u32 {
VirtioDeviceType::TYPE_RNG as u32 self.common.device_type
} }
fn queue_max_sizes(&self) -> &[u16] { fn queue_max_sizes(&self) -> &[u16] {
QUEUE_SIZES &self.common.queue_sizes
} }
fn features(&self) -> u64 { fn features(&self) -> u64 {
@ -230,45 +213,27 @@ impl VirtioDevice for Rng {
queues: Vec<Queue>, queues: Vec<Queue>,
mut queue_evts: Vec<EventFd>, mut queue_evts: Vec<EventFd>,
) -> ActivateResult { ) -> 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| { .map_err(|e| {
error!("failed creating kill EventFd pair: {}", e); error!("failed to clone kill_evt eventfd: {}", e);
ActivateError::BadActivate 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| { .map_err(|e| {
error!("failed creating pause EventFd pair: {}", e); error!("failed to clone pause_evt eventfd: {}", e);
ActivateError::BadActivate 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);
if let Some(file) = self.random_file.as_ref() { if let Some(file) = self.random_file.as_ref() {
let random_file = file.try_clone().map_err(|e| { let random_file = file.try_clone().map_err(|e| {
@ -285,8 +250,8 @@ impl VirtioDevice for Rng {
pause_evt, pause_evt,
}; };
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(); let mut epoll_threads = Vec::new();
// Retrieve seccomp filter for virtio_rng thread // Retrieve seccomp filter for virtio_rng thread
let virtio_rng_seccomp_filter = let virtio_rng_seccomp_filter =
@ -297,7 +262,7 @@ impl VirtioDevice for Rng {
.spawn(move || { .spawn(move || {
if let Err(e) = SeccompFilter::apply(virtio_rng_seccomp_filter) { if let Err(e) = SeccompFilter::apply(virtio_rng_seccomp_filter) {
error!("Error applying seccomp filter: {:?}", e); 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); error!("Error running worker: {:?}", e);
} }
}) })
@ -307,7 +272,7 @@ impl VirtioDevice for Rng {
ActivateError::BadActivate ActivateError::BadActivate
})?; })?;
self.epoll_threads = Some(epoll_threads); self.common.epoll_threads = Some(epoll_threads);
return Ok(()); return Ok(());
} }
@ -315,26 +280,20 @@ impl VirtioDevice for Rng {
} }
fn reset(&mut self) -> Option<(Arc<dyn VirtioInterrupt>, Vec<EventFd>)> { 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()?; }
}
impl Pausable for Rng {
// Then kill it. fn pause(&mut self) -> result::Result<(), MigratableError> {
if let Some(kill_evt) = self.kill_evt.take() { self.common.pause()
// Ignore the result because there is nothing we can do about it. }
let _ = kill_evt.write(1);
} fn resume(&mut self) -> result::Result<(), MigratableError> {
self.common.resume()
// Return the interrupt and queue EventFDs
Some((
self.interrupt_cb.take().unwrap(),
self.queue_evts.take().unwrap(),
))
} }
} }
virtio_pausable!(Rng);
impl Snapshottable for Rng { impl Snapshottable for Rng {
fn id(&self) -> String { fn id(&self) -> String {
self.id.clone() self.id.clone()