Struct Virtqueue 

pub struct Virtqueue {

    queue_size: u16,
    _ring_area: PhysFrame,
    desc_area: u64,
    avail_area: u64,
    used_area: u64,
    desc_ptr: *mut VirtqDesc,
    avail_ptr: *mut VirtqAvail,
    avail_ring_ptr: *mut u16,
    used_ptr: *mut VirtqUsed,
    used_ring_ptr: *mut VirtqUsedElem,
    free_descriptors: Vec<u16>,
    last_used_idx: u16,
    next_avail_idx: u16,
}

A VirtIO virtqueue

This structure manages the split virtqueue format as described in VirtIO spec section 2.6 (Split Virtqueues).

Fields

queue_size: u16

Queue size (must be power of 2)

_ring_area: PhysFrame

Contiguous legacy vring allocation backing desc+avail+used

desc_area: u64

Physical address of descriptor table

avail_area: u64

Physical address of available ring

used_area: u64

Physical address of used ring

desc_ptr: *mut VirtqDesc

Virtual address of descriptor table

avail_ptr: *mut VirtqAvail

Virtual address of available ring

avail_ring_ptr: *mut u16

Virtual address of available ring entries

used_ptr: *mut VirtqUsed

Virtual address of used ring

used_ring_ptr: *mut VirtqUsedElem

Virtual address of used ring entries

free_descriptors: Vec<u16>

Free descriptor list (indices of free descriptors)

last_used_idx: u16

Last seen used index

next_avail_idx: u16

Next available index

Implementations

impl Virtqueue

fn align_up(value: usize, align: usize) -> usize

pub unsafe fn new(queue_size: u16) -> Result<Self, &'static str>

Create a new virtqueue with the specified size

Safety

The caller must ensure that the allocated memory is properly mapped and accessible.

pub fn desc_area(&self) -> u64

Get the physical address of the descriptor table

pub fn avail_area(&self) -> u64

Get the physical address of the available ring

pub fn used_area(&self) -> u64

Get the physical address of the used ring

pub fn queue_size(&self) -> usize

Get the queue size (number of descriptors)

pub fn size(&self) -> u16

Get the queue size

pub fn alloc_descriptor(&mut self) -> Option<u16>

Allocate a descriptor chain

Returns the head descriptor index

pub fn free_descriptor(&mut self, head: u16)

Free a descriptor chain

Walks the chain following NEXT flags and frees all descriptors

pub fn add_buffer( &mut self, buffers: &[(u64, u32, bool)], ) -> Result<u16, &'static str>

Add a buffer to the virtqueue

Returns the descriptor index (token) that can be used to track completion

Arguments

• buffers: A list of (physical_address, length, is_write_only)

pub fn has_used(&self) -> bool

Check if there are any used buffers

pub fn used_indices(&self) -> (u16, u16)

Return a snapshot of (device_used_idx, driver_last_used_idx) for diagnostics.

pub fn get_used(&mut self) -> Option<(u16, u32)>

Get the next used buffer

Returns (descriptor_index, length_written)

pub fn should_notify(&self) -> bool

Notify the device (should write to queue_notify register)

Trait Implementations

impl Send for Virtqueue