Struct Descriptor 

#[repr(C)]
pub struct Descriptor {
    pub addr: u64,
    pub len: u32,
    pub id: u16,
    pub flags: u16,
}

Fields

addr: u64

Physical address of the buffer.

len: u32

Length of the buffer in bytes. For used descriptors, this contains bytes written by device.

id: u16

Buffer ID - used to correlate completions with submissions. All descriptors in a chain share the same ID.

flags: u16

Flags (NEXT, WRITE, INDIRECT, AVAIL, USED).

Implementations

impl Descriptor

pub const ALIGN: usize = 16

pub const SIZE: usize

pub const ADDR_OFFSET: usize

pub const LEN_OFFSET: usize

pub const ID_OFFSET: usize

pub const FLAGS_OFFSET: usize

pub fn new(addr: u64, len: u32, id: u16, flags: DescFlags) -> Self

pub fn flags(&self) -> DescFlags

Get flags as a DescFlags bitfield.

pub fn is_avail(&self, wrap: bool) -> bool

Did the driver make this descriptor available in the current driver round?

pub fn is_used(&self, wrap: bool) -> bool

Did the device mark this descriptor used in the current device round?

pub fn is_writable(&self) -> bool

Is this descriptor writable by the device?

pub fn is_next(&self) -> bool

Does this descriptor point to a next descriptor in the chain?

pub fn mark_avail(&mut self, wrap: bool)

Mark descriptor as available according to the driver’s wrap bit. As per the packed-virtqueue description:

• set AVAIL bit to driver_wrap
• set USED bit to !driver_wrap (inverse)

pub fn mark_used(&mut self, wrap: bool)

Mark descriptor as used according to the device’s wrap bit. As per spec: set both USED and AVAIL bits to match device_wrap

pub fn write_release<M: MemOps>( &self, mem: &M, addr: u64, ) -> Result<(), M::Error>

Write a descriptor to memory with release semantics for flags at the given base pointer

This is the primary synchronization point for publishing descriptors.

Invariant

The caller must ensure that addr is valid for writes of Descriptor

pub fn read_flags_acquire<M: MemOps>( mem: &M, addr: u64, ) -> Result<DescFlags, M::Error>

Acquire-load only the flags word - the packed-ring publish point - without reading the descriptor body.

pub fn read_body<M: MemOps>( mem: &M, addr: u64, flags: DescFlags, ) -> Result<Self, M::Error>

Read the descriptor body (addr/len/id) and combine it with flags already obtained from read_flags_acquire.

Trait Implementations

impl Clone for Descriptor

fn clone(&self) -> Descriptor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Descriptor

impl Debug for Descriptor

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

Formats the value using the given formatter.

impl Eq for Descriptor

impl From<&Descriptor> for BufferElement

fn from(desc: &Descriptor) -> Self

Converts to this type from the input type.

impl Hash for Descriptor

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Descriptor

fn eq(&self, other: &Descriptor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Pod for Descriptor

impl StructuralPartialEq for Descriptor

impl Zeroable for Descriptor

fn zeroed() -> Self

Calls zeroed.