Struct RingConsumer 

pub struct RingConsumer<M> { /* private fields */ }

Consumer (device) side of a packed virtqueue.

The consumer polls for available buffer chains submitted by the driver, processes them, and marks them as used. This is typically used by the device/host side.

Lifecycle

1. Poll: Call poll_available to get buffers
2. Process: Read from readable buffers, write to writable buffers
3. Complete: Call submit_used to return buffers
4. Notify: If submit_used_with_notify returns true, signal the driver

Implementations

impl<M: MemOps> RingConsumer<M>

pub fn new(layout: Layout, mem: M) -> Self

pub fn poll_available(&mut self) -> Result<(u16, BufferChain), RingError>

Poll for an available buffer chain.

Returns the chain ID and a BufferChain containing all buffers. The chain ID must be passed to submit_used when processing is complete.

Returns

• Ok((id, chain)) - A buffer chain is available
• Err(RingError::WouldBlock) - No buffers available
• Err(RingError::BadChain) - Malformed chain (driver bug)

pub fn submit_used( &mut self, id: u16, written_len: u32, ) -> Result<(), RingError>

Publish a single used descriptor for the chain identified by id. written_len is the total bytes produced by the device (for writable part).

Arguments

• id - The chain ID from poll_available
• written_len - Total bytes written to writable buffers

Errors

• RingError::InvalidState - Unknown ID or already completed

pub fn peek_available(&self) -> Result<bool, RingError>

Try to peek whether the next chain is available without consuming it.

pub fn submit_used_with_notify( &mut self, id: u16, written_len: u32, ) -> Result<bool, RingError>

Submit a used descriptor and return whether to notify the driver.

pub fn num_free(&self) -> usize

Get number of free descriptors in the ring.

pub fn num_inflight(&self) -> usize

Get number of inflight (submitted but not yet used) descriptors.

pub fn is_full(&self) -> bool

Check if the ring is full (no free descriptors).

pub fn len(&self) -> usize

Get descriptor table length

pub fn mem(&self) -> &M

Get memory accessor reference

pub fn avail_cursor(&self) -> RingCursor

Get a snapshot of the current avail cursor position.

pub fn used_cursor(&self) -> RingCursor

Get a snapshot of the current used cursor position.

pub fn disable_avail_notifications(&mut self) -> Result<(), RingError>

Device disables available-buffer notifications from driver to device.

This is the device-side mirror of “disable callbacks” but for avail kicks.

pub fn enable_avail_notifications(&mut self) -> Result<(), RingError>

Device enables available-buffer notifications from driver to device.

pub fn enable_avail_notifications_desc( &mut self, off: u16, wrap: bool, ) -> Result<(), RingError>

Device enables descriptor-specific available notifications (EVENT_IDX / DESC mode).

This tells the driver: “Kick me when you reach avail index (off, wrap)”.

pub fn enable_avail_notifications_for_next(&mut self) -> Result<(), RingError>

Convenience: enable DESC mode for “next avail cursor” (device wants a kick when new buffers arrive at the next index it will poll).

pub fn reset(&mut self)

Reset to initial state matching a freshly zeroed ring. Does not reallocate internal buffers.

Trait Implementations

impl<M: Debug> Debug for RingConsumer<M>

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

Formats the value using the given formatter.