Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Prepare to support libkrunfw 4.x #141

Merged
merged 3 commits into from
Aug 10, 2023
Merged

Prepare to support libkrunfw 4.x #141

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
2886fdc
devices/vsock: accommodate the latest patch series
slp Aug 2, 2023
4c6395a
libkrun/vmm: split up kernel load and entry addr
slp Aug 3, 2023
7ff56bd
Bump version to v1.6.0
slp Aug 3, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion Cargo.lock
View file
Open in desktop

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion Makefile
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@ LIBRARY_HEADER = include/libkrun.h
INIT_BINARY = init/init

ABI_VERSION=1
FULL_VERSION=1.5.1
FULL_VERSION=1.6.0

INIT_SRC = init/init.c
SNP_INIT_SRC = init/tee/snp_attest.c \
Expand Down
102 changes: 14 additions & 88 deletions src/devices/src/virtio/vsock/device.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,9 +26,7 @@ use crate::legacy::Gic;

pub(crate) const RXQ_INDEX: usize = 0;
pub(crate) const TXQ_INDEX: usize = 1;
pub(crate) const DRQ_INDEX: usize = 2;
pub(crate) const DTQ_INDEX: usize = 3;
pub(crate) const EVQ_INDEX: usize = 4;
pub(crate) const EVQ_INDEX: usize = 2;

/// The virtio features supported by our vsock device:
/// - VIRTIO_F_VERSION_1: the device conforms to at least version 1.0 of the VirtIO spec.
Expand All @@ -43,8 +41,6 @@ pub struct Vsock {
pub(crate) muxer: VsockMuxer,
pub(crate) queue_rx: Arc<Mutex<VirtQueue>>,
pub(crate) queue_tx: Arc<Mutex<VirtQueue>>,
pub(crate) queue_dr: Arc<Mutex<VirtQueue>>,
//pub(crate) queue_ev: Arc<Mutex<VirtQueue>>,
pub(crate) queues: Vec<VirtQueue>,
pub(crate) queue_events: Vec<EventFd>,
pub(crate) avail_features: u64,
Expand All @@ -69,10 +65,8 @@ impl Vsock {
.push(EventFd::new(utils::eventfd::EFD_NONBLOCK).map_err(VsockError::EventFd)?);
}

//let queue_ev = Arc::new(Mutex::new(queues[EVQ_INDEX].clone()));
let queue_tx = Arc::new(Mutex::new(queues[TXQ_INDEX].clone()));
let queue_rx = Arc::new(Mutex::new(queues[RXQ_INDEX].clone()));
let queue_dr = Arc::new(Mutex::new(queues[DRQ_INDEX].clone()));

let interrupt_evt =
EventFd::new(utils::eventfd::EFD_NONBLOCK).map_err(VsockError::EventFd)?;
Expand All @@ -88,8 +82,6 @@ impl Vsock {
),
queue_rx,
queue_tx,
queue_dr,
//queue_ev,
queues,
queue_events,
avail_features: AVAIL_FEATURES,
Expand Down Expand Up @@ -161,7 +153,7 @@ impl Vsock {
debug!("vsock: process_rx inside while");
let used_len = match VsockPacket::from_rx_virtq_head(&head) {
Ok(mut pkt) => {
if self.muxer.recv_stream_pkt(&mut pkt).is_ok() {
if self.muxer.recv_pkt(&mut pkt).is_ok() {
pkt.hdr().len() as u32 + pkt.len()
} else {
// We are using a consuming iterator over the virtio buffers, so, if we can't
Expand All @@ -184,45 +176,6 @@ impl Vsock {
have_used
}

pub fn process_dgram_rx(&mut self) -> bool {
debug!("vsock: process_dgram_rx()");
let mem = match self.device_state {
DeviceState::Activated(ref mem) => mem,
// This should never happen, it's been already validated in the event handler.
DeviceState::Inactive => unreachable!(),
};

let mut have_used = false;

debug!("vsock: process_rx before while");
let mut queue_dr = self.queue_dr.lock().unwrap();
while let Some(head) = queue_dr.pop(mem) {
debug!("vsock: process_rx inside while");
let used_len = match VsockPacket::from_rx_virtq_head(&head) {
Ok(mut pkt) => {
if self.muxer.recv_dgram_pkt(&mut pkt).is_ok() {
pkt.hdr().len() as u32 + pkt.len()
} else {
// We are using a consuming iterator over the virtio buffers, so, if we can't
// fill in this buffer, we'll need to undo the last iterator step.
queue_dr.undo_pop();
break;
}
}
Err(e) => {
warn!("vsock: RX queue error: {:?}", e);
0
}
};

debug!("vsock: process_rx: something to queue");
have_used = true;
queue_dr.add_used(mem, head.index, used_len);
}

have_used
}

/// Walk the driver-provided TX queue buffers, package them up as vsock packets, and process
/// them. Return `true` if descriptors have been added to the used ring, and `false` otherwise.
pub fn process_stream_tx(&mut self) -> bool {
Expand All @@ -247,47 +200,22 @@ impl Vsock {
}
};

if self.muxer.send_stream_pkt(&pkt).is_err() {
queue_tx.undo_pop();
break;
}

have_used = true;
queue_tx.add_used(mem, head.index, 0);
}

have_used
}

pub fn process_dgram_tx(&mut self) -> bool {
debug!("vsock::process_dgram_tx()");
let mem = match self.device_state {
DeviceState::Activated(ref mem) => mem,
// This should never happen, it's been already validated in the event handler.
DeviceState::Inactive => unreachable!(),
};

let mut have_used = false;

//let mut queue_tx = self.queue_tx.lock().unwrap();
while let Some(head) = self.queues[DTQ_INDEX].pop(mem) {
let pkt = match VsockPacket::from_tx_virtq_head(&head) {
Ok(pkt) => pkt,
Err(e) => {
error!("vsock: error reading TX packet: {:?}", e);
have_used = true;
self.queues[DTQ_INDEX].add_used(mem, head.index, 0);
continue;
if pkt.type_() == uapi::VSOCK_TYPE_DGRAM {
debug!("vsock::process_stream_tx() is DGRAM");
if self.muxer.send_dgram_pkt(&pkt).is_err() {
queue_tx.undo_pop();
break;
}
} else {
debug!("vsock::process_stream_tx() is STREAM");
if self.muxer.send_stream_pkt(&pkt).is_err() {
queue_tx.undo_pop();
break;
}
};

if self.muxer.send_dgram_pkt(&pkt).is_err() {
self.queues[DTQ_INDEX].undo_pop();
break;
}

have_used = true;
self.queues[DTQ_INDEX].add_used(mem, head.index, 0);
queue_tx.add_used(mem, head.index, 0);
}

have_used
Expand Down Expand Up @@ -377,11 +305,9 @@ impl VirtioDevice for Vsock {

self.queue_tx = Arc::new(Mutex::new(self.queues[TXQ_INDEX].clone()));
self.queue_rx = Arc::new(Mutex::new(self.queues[RXQ_INDEX].clone()));
self.queue_dr = Arc::new(Mutex::new(self.queues[DRQ_INDEX].clone()));
self.muxer.activate(
mem.clone(),
self.queue_rx.clone(),
self.queue_dr.clone(),
self.intc.clone(),
self.irq_line,
);
Expand Down
105 changes: 2 additions & 103 deletions src/devices/src/virtio/vsock/event_handler.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ use std::os::unix::io::AsRawFd;
use polly::event_manager::{EventManager, Subscriber};
use utils::epoll::{EpollEvent, EventSet};

use super::device::{Vsock, DRQ_INDEX, DTQ_INDEX, EVQ_INDEX, RXQ_INDEX, TXQ_INDEX};
use super::device::{Vsock, EVQ_INDEX, RXQ_INDEX, TXQ_INDEX};
use crate::virtio::VirtioDevice;

impl Vsock {
Expand Down Expand Up @@ -49,56 +49,13 @@ impl Vsock {
// The backend may have queued up responses to the packets we sent during
// TX queue processing. If that happened, we need to fetch those responses
// and place them into RX buffers.
if self.muxer.has_pending_stream_rx() {
if self.muxer.has_pending_rx() {
raise_irq |= self.process_stream_rx();
}
}
raise_irq
}

pub(crate) fn handle_drq_event(&mut self, event: &EpollEvent) -> bool {
debug!("vsock: DR queue event");

let event_set = event.event_set();
if event_set != EventSet::IN {
warn!("vsock: drq unexpected event {:?}", event_set);
return false;
}

let mut raise_irq = false;
if let Err(e) = self.queue_events[DRQ_INDEX].read() {
error!("Failed to get vsock dr queue event: {:?}", e);
} else {
raise_irq |= self.process_dgram_rx();
}
raise_irq
}

pub(crate) fn handle_dtq_event(&mut self, event: &EpollEvent) -> bool {
debug!("vsock: DT queue event");

let event_set = event.event_set();
if event_set != EventSet::IN {
warn!("vsock: dtq unexpected event {:?}", event_set);
return false;
}

let mut raise_irq = false;
if let Err(e) = self.queue_events[DTQ_INDEX].read() {
error!("Failed to get vsock DT queue event: {:?}", e);
} else {
raise_irq |= self.process_dgram_tx();
// The backend may have queued up responses to the packets we sent during
// TX queue processing. If that happened, we need to fetch those responses
// and place them into RX buffers.
if self.muxer.has_pending_dgram_rx() {
debug!("vsock: DT something pending");
raise_irq |= self.process_dgram_rx();
}
}
raise_irq
}

fn handle_evq_event(&mut self, event: &EpollEvent) -> bool {
debug!("vsock: event queue event");

Expand Down Expand Up @@ -152,60 +109,6 @@ impl Vsock {
error!("Failed to register vsock txq with event manager: {:?}", e);
});

event_manager
.register(
self.queue_events[DRQ_INDEX].as_raw_fd(),
EpollEvent::new(
EventSet::IN,
self.queue_events[DRQ_INDEX].as_raw_fd() as u64,
),
self_subscriber.clone(),
)
.unwrap_or_else(|e| {
error!("Failed to register vsock rxq with event manager: {:?}", e);
});

event_manager
.register(
self.queue_events[DTQ_INDEX].as_raw_fd(),
EpollEvent::new(
EventSet::IN,
self.queue_events[DTQ_INDEX].as_raw_fd() as u64,
),
self_subscriber.clone(),
)
.unwrap_or_else(|e| {
error!("Failed to register vsock txq with event manager: {:?}", e);
});

event_manager
.register(
self.queue_events[EVQ_INDEX].as_raw_fd(),
EpollEvent::new(
EventSet::IN,
self.queue_events[EVQ_INDEX].as_raw_fd() as u64,
),
self_subscriber.clone(),
)
.unwrap_or_else(|e| {
error!("Failed to register vsock evq with event manager: {:?}", e);
});

/*
event_manager
.register(
self.backend.as_raw_fd(),
EpollEvent::new(
self.backend.get_polled_evset(),
self.backend.as_raw_fd() as u64,
),
self_subscriber,
)
.unwrap_or_else(|e| {
error!("Failed to register vsock backend events: {:?}", e);
});
*/

event_manager
.unregister(self.activate_evt.as_raw_fd())
.unwrap_or_else(|e| {
Expand All @@ -219,8 +122,6 @@ impl Subscriber for Vsock {
let source = event.fd();
let rxq = self.queue_events[RXQ_INDEX].as_raw_fd();
let txq = self.queue_events[TXQ_INDEX].as_raw_fd();
let drq = self.queue_events[DRQ_INDEX].as_raw_fd();
let dtq = self.queue_events[DTQ_INDEX].as_raw_fd();
let evq = self.queue_events[EVQ_INDEX].as_raw_fd();
//let backend = self.backend.as_raw_fd();
let activate_evt = self.activate_evt.as_raw_fd();
Expand All @@ -230,8 +131,6 @@ impl Subscriber for Vsock {
match source {
_ if source == rxq => raise_irq = self.handle_rxq_event(event),
_ if source == txq => raise_irq = self.handle_txq_event(event),
_ if source == drq => raise_irq = self.handle_drq_event(event),
_ if source == dtq => raise_irq = self.handle_dtq_event(event),
_ if source == evq => raise_irq = self.handle_evq_event(event),
/*
_ if source == backend => {
Expand Down
4 changes: 2 additions & 2 deletions src/devices/src/virtio/vsock/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ mod defs {
pub const VSOCK_DEV_ID: &str = "vsock";

/// Number of virtio queues.
pub const NUM_QUEUES: usize = 5;
pub const NUM_QUEUES: usize = 3;
/// Virtio queue sizes, in number of descriptor chain heads.
/// There are 3 queues for a virtio device (in this order): RX, TX, Event
pub const QUEUE_SIZES: &[u16] = &[256; NUM_QUEUES];
Expand Down Expand Up @@ -69,7 +69,7 @@ mod defs {
/// The device conforms to the virtio spec version 1.0.
pub const VIRTIO_F_VERSION_1: u32 = 32;
/// The device supports DGRAM.
pub const VIRTIO_VSOCK_F_DGRAM: u32 = 0;
pub const VIRTIO_VSOCK_F_DGRAM: u32 = 3;

/// Virtio vsock device ID.
/// Defined in `include/uapi/linux/virtio_ids.h`.
Expand Down
Loading
Loading