Struct AvailableRing 

pub struct AvailableRing<T: GuestMemoryAccessor + Clone> {
    pub base_addr: GuestPhysAddr,
    pub size: u16,
    pub last_avail_idx: u16,
    /* private fields */
}

Available ring management structure.

This structure provides a high-level interface for managing the VirtIO available ring in guest memory. It wraps the guest memory accessor and provides methods to read/write various parts of the available ring:

• The header (VirtQueueAvail structure)
• The ring array of descriptor indices
• The used_event field (if VIRTIO_F_EVENT_IDX is negotiated)

Relationship with VirtQueueAvail:

• VirtQueueAvail defines the memory layout of the available ring header
• AvailableRing uses VirtQueueAvail to access the header in guest memory
• AvailableRing manages the entire available ring structure, not just the header

Memory Layout:

base_addr -> +-------------------+
             | VirtQueueAvail    |  (flags + idx)
             +-------------------+
             | ring[0]           |  (descriptor index)
             | ring[1]           |
             | ...               |
             | ring[queue_size-1]|
             +-------------------+
             | used_event        |  (optional, if event_idx enabled)
             +-------------------+

Fields

base_addr: GuestPhysAddr

Base address of the available ring

size: u16

Queue size

last_avail_idx: u16

Last seen available index

Implementations

impl<T: GuestMemoryAccessor + Clone> AvailableRing<T>

pub fn new(base_addr: GuestPhysAddr, size: u16, accessor: Arc<T>) -> Self

Create a new available ring

pub fn header_addr(&self) -> GuestPhysAddr

Get the address of the available ring header

pub fn ring_addr(&self) -> GuestPhysAddr

Get the address of the ring array

pub fn ring_entry_addr(&self, index: u16) -> Option<GuestPhysAddr>

Get the address of a specific ring entry

pub fn used_event_addr(&self) -> GuestPhysAddr

Get the address of the used event field (if event_idx is enabled)

pub fn total_size(&self) -> usize

Calculate the total size of the available ring

pub fn is_valid(&self) -> bool

Check if the available ring is valid

pub fn has_new_avail(&self, current_idx: u16) -> bool

Check if there are new available descriptors

pub fn update_last_avail_idx(&mut self, idx: u16)

Update the last seen available index

pub fn read_avail_header(&self) -> VirtioResult<VirtQueueAvail>

Read the available ring header

pub fn write_avail_header(&self, header: &VirtQueueAvail) -> VirtioResult<()>

Write the available ring header

pub fn read_avail_idx(&self) -> VirtioResult<u16>

Read the current available index from guest memory

pub fn get_avail_idx(&self) -> VirtioResult<u16>

Get the available index for external access

pub fn read_avail_ring_entry(&self, ring_index: u16) -> VirtioResult<u16>

Read a descriptor index from the available ring

pub fn write_avail_ring_entry( &self, ring_index: u16, desc_index: u16, ) -> VirtioResult<()>

Write a descriptor index to the available ring

pub fn get_available_count(&self) -> VirtioResult<u16>

Get the number of available descriptors since last check

pub fn interrupts_suppressed(&self) -> VirtioResult<bool>

Check if interrupts are suppressed

pub fn set_interrupt_suppression(&self, suppress: bool) -> VirtioResult<()>

Set interrupt suppression

pub fn read_used_event(&self) -> VirtioResult<u16>

Read the used event field (for event_idx feature)

pub fn write_used_event(&self, event: u16) -> VirtioResult<()>

Write the used event field (for event_idx feature)

Trait Implementations

impl<T: Clone + GuestMemoryAccessor + Clone> Clone for AvailableRing<T>

fn clone(&self) -> AvailableRing<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + GuestMemoryAccessor + Clone> Debug for AvailableRing<T>

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

Formats the value using the given formatter.