Struct virtio_queue::QueueStateSync

pub struct QueueStateSync { /* private fields */ }

Struct to maintain information and manipulate state of a virtio queue for multi-threaded context.

Example

use virtio_queue::{Queue, QueueState, QueueStateSync, QueueStateT};
use vm_memory::{Bytes, GuestAddress, GuestAddressSpace, GuestMemoryMmap};

let m = &GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
let mut queue = QueueStateSync::new(1024);

// First, the driver sets up the queue; this set up is done via writes on the bus (PCI, MMIO).
queue.set_size(8);
queue.set_desc_table_address(Some(0x1000), None);
queue.set_avail_ring_address(Some(0x2000), None);
queue.set_used_ring_address(Some(0x3000), None);
queue.set_ready(true);
// The user should check if the queue is valid before starting to use it.
assert!(queue.is_valid(m.memory()));

// The memory object is not embedded in the `QueueStateSync`, so we have to pass it as a
// parameter to the methods that access the guest memory. Examples would be:
queue.add_used(m.memory(), 1, 0x100).unwrap();
queue.needs_notification(m.memory()).unwrap();

Trait Implementations

impl Clone for QueueStateSync

fn clone(&self) -> QueueStateSync

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueueStateSync

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

Formats the value using the given formatter.

impl<'a> QueueStateGuard<'a> for QueueStateSync

type G = MutexGuard<'a, QueueState>

Type for guard returned by Self::lock().

impl QueueStateT for QueueStateSync

fn new(max_size: u16) -> Self

Construct an empty virtio queue state object with the given max_size.

fn is_valid<M: GuestMemory>(&self, mem: &M) -> bool

Check whether the queue configuration is valid.

fn reset(&mut self)

Reset the queue to the initial state.

fn lock(&mut self) -> <Self as QueueStateGuard<'_>>::G

Get an exclusive reference to the underlying QueueState object.

fn max_size(&self) -> u16

Get the maximum size of the virtio queue.

fn set_size(&mut self, size: u16)

Configure the queue size for the virtio queue.

fn ready(&self) -> bool

Check whether the queue is ready to be processed.

fn set_ready(&mut self, ready: bool)

Configure the queue to ready for processing state.

fn set_desc_table_address(&mut self, low: Option<u32>, high: Option<u32>)

Set the descriptor table address for the queue.

fn set_avail_ring_address(&mut self, low: Option<u32>, high: Option<u32>)

Set the available ring address for the queue.

fn set_used_ring_address(&mut self, low: Option<u32>, high: Option<u32>)

Set the used ring address for the queue.

fn set_event_idx(&mut self, enabled: bool)

Enable/disable the VIRTIO_F_RING_EVENT_IDX feature for interrupt coalescing.

fn avail_idx<M: GuestMemory>(
    &self,
    mem: &M,
    order: Ordering
) -> Result<Wrapping<u16>, Error>

Read the idx field from the available ring.

fn used_idx<M: GuestMemory>(
    &self,
    mem: &M,
    order: Ordering
) -> Result<Wrapping<u16>, Error>

Read the idx field from the used ring.

fn add_used<M: GuestMemory>(
    &mut self,
    mem: &M,
    head_index: u16,
    len: u32
) -> Result<(), Error>

Put a used descriptor head into the used ring.

fn enable_notification<M: GuestMemory>(
    &mut self,
    mem: &M
) -> Result<bool, Error>

Enable notification events from the guest driver.

fn disable_notification<M: GuestMemory>(&mut self, mem: &M) -> Result<(), Error>

Disable notification events from the guest driver.

fn needs_notification<M: GuestMemory>(&mut self, mem: &M) -> Result<bool, Error>

Check whether a notification to the guest is needed.

fn next_avail(&self) -> u16

Return the index of the next entry in the available ring.

fn next_used(&self) -> u16

Return the index for the next descriptor in the used ring.

fn set_next_avail(&mut self, next_avail: u16)

Set the index of the next entry in the available ring.

fn set_next_used(&mut self, next_used: u16)

Set the index for the next descriptor in the used ring.

fn lock_with_memory<M>(
    &mut self,
    mem: M
) -> QueueGuard<M, <Self as QueueStateGuard<'_>>::G> where
    M: Deref + Clone,
    M::Target: GuestMemory + Sized, 

Get an exclusive reference to the underlying QueueState object with an associated GuestMemory object.