Struct Vsock 

pub struct Vsock<B> {
    pub rx_packet: VsockPacketRx,
    pub tx_packet: VsockPacketTx,
    /* private fields */
}

Structure representing the vsock device.

Fields

rx_packet: VsockPacketRx

tx_packet: VsockPacketTx

Implementations

impl<B> Vsock<B>

where B: VsockBackend + Debug,

pub fn with_queues( cid: u64, backend: B, queues: Vec<VirtQueue>, ) -> Result<Vsock<B>, VsockError>

Auxiliary function for creating a new virtio-vsock device with the given VM CID, vsock backend and empty virtio queues.

pub fn new(cid: u64, backend: B) -> Result<Vsock<B>, VsockError>

Create a new virtio-vsock device with the given VM CID and vsock backend.

pub fn id(&self) -> &str

Provides the ID of this vsock device as used in MMIO device identification.

pub fn cid(&self) -> u64

Retrieve the cid associated with this vsock device.

pub fn backend(&self) -> &B

Access the backend behind the device.

pub fn signal_used_queue(&self, qidx: usize) -> Result<(), DeviceError>

Signal the guest driver that we’ve used some virtio buffers that it had previously made available.

pub fn signal_used_queues(&self, used_queues: &[u16]) -> Result<(), DeviceError>

Signal the guest which queues are ready to be consumed

pub fn process_rx(&mut self) -> Result<bool, InvalidAvailIdx>

Walk the driver-provided RX queue buffers and attempt to fill them up with any data that we have pending. Return true if descriptors have been added to the used ring, and false otherwise.

pub fn process_tx(&mut self) -> Result<bool, InvalidAvailIdx>

Walk the driver-provided TX queue buffers, package them up as vsock packets, and send them to the backend for processing. Return true if descriptors have been added to the used ring, and false otherwise.

pub fn send_transport_reset_event(&mut self) -> Result<(), DeviceError>

impl<B> Vsock<B>

where B: Debug + VsockBackend + 'static,

pub fn handle_rxq_event(&mut self, evset: EventSet) -> Vec<u16>

pub fn handle_txq_event(&mut self, evset: EventSet) -> Vec<u16>

pub fn handle_evq_event(&mut self, evset: EventSet)

pub fn notify_backend( &mut self, evset: EventSet, ) -> Result<Vec<u16>, InvalidAvailIdx>

Notify backend of new events.

Trait Implementations

impl<B: Debug> Debug for Vsock<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B> MutEventSubscriber for Vsock<B>

where B: Debug + VsockBackend + 'static,

fn process(&mut self, event: Events, ops: &mut EventOps<'_>)

Process events triggered in the event manager loop.

fn init(&mut self, ops: &mut EventOps<'_>)

Initialization called by the EventManager when the subscriber is registered.

impl<B> Persist<'_> for Vsock<B>

where B: VsockBackend + 'static + Debug,

type State = VsockFrontendState

The type of the object representing the state of the component.

type ConstructorArgs = VsockConstructorArgs<B>

The type of the object holding the constructor arguments.

type Error = VsockError

The type of the error that can occur while constructing the object.

fn save(&self) -> Self::State

Returns the current state of the component.

fn restore( constructor_args: Self::ConstructorArgs, state: &Self::State, ) -> Result<Self, Self::Error>

Constructs a component from a specified state.

impl<B> VirtioDevice for Vsock<B>

where B: VsockBackend + Debug + 'static,

fn const_device_type() -> u32

The virtio device type (as a constant of the struct).

fn device_type(&self) -> u32

The virtio device type.

fn avail_features(&self) -> u64

Get the available features offered by device.

fn acked_features(&self) -> u64

Get acknowledged features of the driver.

fn set_acked_features(&mut self, acked_features: u64)

Set acknowledged features of the driver. This function must maintain the following invariant:

fn queues(&self) -> &[VirtQueue]

Returns the device queues.

fn queues_mut(&mut self) -> &mut [VirtQueue]

Returns a mutable reference to the device queues.

fn queue_events(&self) -> &[EventFd]

Returns the device queues event fds.

fn interrupt_trigger(&self) -> &dyn VirtioInterrupt

fn read_config(&self, offset: u64, data: &mut [u8])

Reads this device configuration space at offset.

fn write_config(&mut self, offset: u64, data: &[u8])

Writes to this device configuration space at offset.

fn activate( &mut self, mem: GuestMemoryMmap, interrupt: Arc<dyn VirtioInterrupt>, ) -> Result<(), ActivateError>

Performs the formal activation for a device, which can be verified also with is_activated.

fn is_activated(&self) -> bool

Checks if the resources of this device are activated.

fn kick(&mut self)

Kick the device, as if it had received external events.

fn has_feature(&self, feature: u64) -> bool

Check if virtio device has negotiated given feature.

fn interrupt_status(&self) -> Arc<AtomicU32>

Returns the current device interrupt status.

fn avail_features_by_page(&self, page: u32) -> u32

The set of feature bits shifted by page * 32.

fn ack_features_by_page(&mut self, page: u32, value: u32)

Acknowledges that this set of features should be enabled.

fn reset(&mut self) -> Option<(Arc<dyn VirtioInterrupt>, Vec<EventFd>)>

Optionally deactivates this device and returns ownership of the guest memory map, interrupt event, and queue events.

fn mark_queue_memory_dirty( &mut self, mem: &GuestMemoryMmap, ) -> Result<(), QueueError>

Mark pages used by queues as dirty.

fn as_cow_file_engine(&self) -> Option<&CowFileEngine>

Returns a COW file engine if the device exposes one (NYX extension).

fn nyx_handle_queue_event(&mut self, _queue_index: u16)

Handle a queue notification from an MMIO write (NYX extension).