kata-containers/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2026-08-05 02:19:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

virtio-devices: net: Remove unnecessary Option<> around tap

Browse Source 
This doesn't serve any benefit and just makes the code more complex.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>
This commit is contained in:
Rob Bradford
2021-04-28 15:34:44 +01:00
committed by Sebastien Boeuf
parent fbc7011346
commit 9ef1a68539
1 changed files with 161 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
virtio-devices/src/net.rs
View File

@@ -285,7 +285,7 @@ impl EpollHelperHandler for NetEpollHandler {
pub struct Net { pub struct Net {
common: VirtioCommon, common: VirtioCommon,
id: String, id: String,
taps: Option<Vec<Tap>>, taps: Vec<Tap>,
config: VirtioNetConfig, config: VirtioNetConfig,
ctrl_queue_epoll_thread: Option<thread::JoinHandle<()>>, ctrl_queue_epoll_thread: Option<thread::JoinHandle<()>>,
counters: NetCounters, counters: NetCounters,
@@ -351,7 +351,7 @@ impl Net {
..Default::default() ..Default::default()
}, },
id, id,
taps: Some(taps), taps,
config, config,
ctrl_queue_epoll_thread: None, ctrl_queue_epoll_thread: None,
counters: NetCounters::default(), counters: NetCounters::default(),
@@ -479,173 +479,171 @@ impl VirtioDevice for Net {
mut queues: Vec<Queue>, mut queues: Vec<Queue>,
mut queue_evts: Vec<EventFd>, mut queue_evts: Vec<EventFd>,
) -> ActivateResult { ) -> ActivateResult {
if let Some(mut taps) = self.taps.clone() { self.common.activate(&queues, &queue_evts, &interrupt_cb)?;
self.common.activate(&queues, &queue_evts, &interrupt_cb)?;
let queue_num = queues.len(); let queue_num = queues.len();
if self.common.feature_acked(VIRTIO_NET_F_CTRL_VQ.into()) && queue_num % 2 != 0 { if self.common.feature_acked(VIRTIO_NET_F_CTRL_VQ.into()) && queue_num % 2 != 0 {
let cvq_queue = queues.remove(queue_num - 1); let cvq_queue = queues.remove(queue_num - 1);
let cvq_queue_evt = queue_evts.remove(queue_num - 1); let cvq_queue_evt = queue_evts.remove(queue_num - 1);
let kill_evt = self let kill_evt = self
.common .common
.kill_evt .kill_evt
.as_ref() .as_ref()
.unwrap() .unwrap()
.try_clone() .try_clone()
.map_err(|e| { .map_err(|e| {
error!("failed to clone kill_evt eventfd: {}", e); error!("failed to clone kill_evt eventfd: {}", e);
ActivateError::BadActivate ActivateError::BadActivate
})?; })?;
let pause_evt = self let pause_evt = self
.common .common
.pause_evt .pause_evt
.as_ref() .as_ref()
.unwrap() .unwrap()
.try_clone() .try_clone()
.map_err(|e| { .map_err(|e| {
error!("failed to clone pause_evt eventfd: {}", e); error!("failed to clone pause_evt eventfd: {}", e);
ActivateError::BadActivate ActivateError::BadActivate
})?; })?;
let mut ctrl_handler = NetCtrlEpollHandler { let mut ctrl_handler = NetCtrlEpollHandler {
mem: mem.clone(), mem: mem.clone(),
kill_evt, kill_evt,
pause_evt, pause_evt,
ctrl_q: NetCtrl::new(cvq_queue, cvq_queue_evt), ctrl_q: NetCtrl::new(cvq_queue, cvq_queue_evt),
}; };
let paused = self.common.paused.clone(); let paused = self.common.paused.clone();
// Let's update the barrier as we need 1 for each RX/TX pair + // 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 // 1 for the control queue + 1 for the main thread signalling
// the pause. // the pause.
self.common.paused_sync = Some(Arc::new(Barrier::new(taps.len() + 2))); self.common.paused_sync = Some(Arc::new(Barrier::new(self.taps.len() + 2)));
let paused_sync = self.common.paused_sync.clone(); let paused_sync = self.common.paused_sync.clone();
// Retrieve seccomp filter for virtio_net_ctl thread // Retrieve seccomp filter for virtio_net_ctl thread
let virtio_net_ctl_seccomp_filter = let virtio_net_ctl_seccomp_filter =
get_seccomp_filter(&self.seccomp_action, Thread::VirtioNetCtl) get_seccomp_filter(&self.seccomp_action, Thread::VirtioNetCtl)
.map_err(ActivateError::CreateSeccompFilter)?; .map_err(ActivateError::CreateSeccompFilter)?;
thread::Builder::new() thread::Builder::new()
.name(format!("{}_ctrl", self.id)) .name(format!("{}_ctrl", self.id))
.spawn(move || { .spawn(move || {
if let Err(e) = SeccompFilter::apply(virtio_net_ctl_seccomp_filter) { if let Err(e) = SeccompFilter::apply(virtio_net_ctl_seccomp_filter) {
error!("Error applying seccomp filter: {:?}", e); error!("Error applying seccomp filter: {:?}", e);
} else if let Err(e) = ctrl_handler.run_ctrl(paused, paused_sync.unwrap()) { } else if let Err(e) = ctrl_handler.run_ctrl(paused, paused_sync.unwrap()) {
error!("Error running worker: {:?}", e); error!("Error running worker: {:?}", e);
} }
}) })
.map(|thread| self.ctrl_queue_epoll_thread = Some(thread)) .map(|thread| self.ctrl_queue_epoll_thread = Some(thread))
.map_err(|e| { .map_err(|e| {
error!("failed to clone queue EventFd: {}", e); error!("failed to clone queue EventFd: {}", e);
ActivateError::BadActivate ActivateError::BadActivate
})?; })?;
}
let event_idx = self.common.feature_acked(VIRTIO_RING_F_EVENT_IDX.into());
let mut epoll_threads = Vec::new();
for i in 0..taps.len() {
let rx = RxVirtio::new();
let tx = TxVirtio::new();
let rx_tap_listening = false;
let mut queue_pair = vec![queues.remove(0), queues.remove(0)];
queue_pair[0].set_event_idx(event_idx);
queue_pair[1].set_event_idx(event_idx);
let queue_evt_pair = vec![queue_evts.remove(0), queue_evts.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 rx_rate_limiter: Option<rate_limiter::RateLimiter> = self
.rate_limiter_config
.map(RateLimiterConfig::try_into)
.transpose()
.map_err(ActivateError::CreateRateLimiter)?;
let tx_rate_limiter: Option<rate_limiter::RateLimiter> = self
.rate_limiter_config
.map(RateLimiterConfig::try_into)
.transpose()
.map_err(ActivateError::CreateRateLimiter)?;
let tap = taps.remove(0);
tap.set_offload(virtio_features_to_tap_offload(self.common.acked_features))
.map_err(|e| {
error!("Error programming tap offload: {:?}", e);
ActivateError::BadActivate
})?;
let mut handler = NetEpollHandler {
net: NetQueuePair {
mem: Some(mem.clone()),
tap,
rx,
tx,
epoll_fd: None,
rx_tap_listening,
counters: self.counters.clone(),
tap_event_id: RX_TAP_EVENT,
rx_desc_avail: false,
rx_rate_limiter,
tx_rate_limiter,
},
queue_pair,
queue_evt_pair,
interrupt_cb: interrupt_cb.clone(),
kill_evt,
pause_evt,
driver_awake: false,
};
let paused = self.common.paused.clone();
let paused_sync = self.common.paused_sync.clone();
// Retrieve seccomp filter for virtio_net thread
let virtio_net_seccomp_filter =
get_seccomp_filter(&self.seccomp_action, Thread::VirtioNet)
.map_err(ActivateError::CreateSeccompFilter)?;
thread::Builder::new()
.name(format!("{}_qp{}", self.id.clone(), i))
.spawn(move || {
if let Err(e) = SeccompFilter::apply(virtio_net_seccomp_filter) {
error!("Error applying seccomp filter: {:?}", e);
} else if let Err(e) = handler.run(paused, paused_sync.unwrap()) {
error!("Error running worker: {:?}", e);
}
})
.map(|thread| epoll_threads.push(thread))
.map_err(|e| {
error!("failed to clone queue EventFd: {}", e);
ActivateError::BadActivate
})?;
}
self.common.epoll_threads = Some(epoll_threads);
event!("virtio-device", "activated", "id", &self.id);
return Ok(());
} }
Err(ActivateError::BadActivate)
let event_idx = self.common.feature_acked(VIRTIO_RING_F_EVENT_IDX.into());
let mut epoll_threads = Vec::new();
let mut taps = self.taps.clone();
for i in 0..taps.len() {
let rx = RxVirtio::new();
let tx = TxVirtio::new();
let rx_tap_listening = false;
let mut queue_pair = vec![queues.remove(0), queues.remove(0)];
queue_pair[0].set_event_idx(event_idx);
queue_pair[1].set_event_idx(event_idx);
let queue_evt_pair = vec![queue_evts.remove(0), queue_evts.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 rx_rate_limiter: Option<rate_limiter::RateLimiter> = self
.rate_limiter_config
.map(RateLimiterConfig::try_into)
.transpose()
.map_err(ActivateError::CreateRateLimiter)?;
let tx_rate_limiter: Option<rate_limiter::RateLimiter> = self
.rate_limiter_config
.map(RateLimiterConfig::try_into)
.transpose()
.map_err(ActivateError::CreateRateLimiter)?;
let tap = taps.remove(0);
tap.set_offload(virtio_features_to_tap_offload(self.common.acked_features))
.map_err(|e| {
error!("Error programming tap offload: {:?}", e);
ActivateError::BadActivate
})?;
let mut handler = NetEpollHandler {
net: NetQueuePair {
mem: Some(mem.clone()),
tap,
rx,
tx,
epoll_fd: None,
rx_tap_listening,
counters: self.counters.clone(),
tap_event_id: RX_TAP_EVENT,
rx_desc_avail: false,
rx_rate_limiter,
tx_rate_limiter,
},
queue_pair,
queue_evt_pair,
interrupt_cb: interrupt_cb.clone(),
kill_evt,
pause_evt,
driver_awake: false,
};
let paused = self.common.paused.clone();
let paused_sync = self.common.paused_sync.clone();
// Retrieve seccomp filter for virtio_net thread
let virtio_net_seccomp_filter =
get_seccomp_filter(&self.seccomp_action, Thread::VirtioNet)
.map_err(ActivateError::CreateSeccompFilter)?;
thread::Builder::new()
.name(format!("{}_qp{}", self.id.clone(), i))
.spawn(move || {
if let Err(e) = SeccompFilter::apply(virtio_net_seccomp_filter) {
error!("Error applying seccomp filter: {:?}", e);
} else if let Err(e) = handler.run(paused, paused_sync.unwrap()) {
error!("Error running worker: {:?}", e);
}
})
.map(|thread| epoll_threads.push(thread))
.map_err(|e| {
error!("failed to clone queue EventFd: {}", e);
ActivateError::BadActivate
})?;
}
self.common.epoll_threads = Some(epoll_threads);
event!("virtio-device", "activated", "id", &self.id);
Ok(())
} }
fn reset(&mut self) -> Option<Arc<dyn VirtioInterrupt>> { fn reset(&mut self) -> Option<Arc<dyn VirtioInterrupt>> {