Struct Ring 

pub struct Ring {

    pub id: u64,
    pub owner_pid: u32,
    pub sq_mapping_cap_id: CapId,
    pub sq_frame: PhysFrame,
    pub sq_virt: u64,
    pub cq_mapping_cap_id: CapId,
    pub cq_frame: PhysFrame,
    pub cq_virt: u64,
    pub entries: u32,
    pub in_flight: AtomicU32,
    pub destroyed: AtomicU32,
    pub cq_lock: SpinLock<()>,
    pub completion_backlog: SpinLock<Vec<AsyncCqe>>,
    pub sq_order: u8,
    pub cq_order: u8,
    pub wq: WaitQueue,
}

A shared submission/completion ring for a single process.

Fields

id: u64

Opaque handle returned to userspace.

owner_pid: u32

Process that owns this ring (by PID).

sq_mapping_cap_id: CapId

Stable mapping capability for the SQ pages.

sq_frame: PhysFrame

Physical frame backing the SQ page.

sq_virt: u64

Kernel virtual address of the SQ metadata header.

cq_mapping_cap_id: CapId

Stable mapping capability for the CQ pages.

cq_frame: PhysFrame

Physical frame backing the CQ page.

cq_virt: u64

Kernel virtual address of the CQ metadata header.

entries: u32

Number of entries (power of two, min 2, max MAX_IN_FLIGHT).

in_flight: AtomicU32

Number of in-flight operations (not yet completed).

destroyed: AtomicU32

Whether this ring has been destroyed (no new ops accepted).

cq_lock: SpinLock<()>

Lock for pushing completions.

completion_backlog: SpinLock<Vec<AsyncCqe>>

Completions retained temporarily when the visible CQ is full.

sq_order: u8

Order used for SQ allocation.

cq_order: u8

Order used for CQ allocation.

wq: WaitQueue

Wait queue for tasks blocked on this ring.

Implementations

impl Ring

pub fn create(pid: u32, entries: u32) -> Result<u64, RingError>

Create a new ring and map it into the calling process’s address space.

pub fn map_into_process( &self, addr_space: &AddressSpace, ) -> Result<AsyncRingMapping, &'static str>

Map the SQ and CQ buffers into the provided address space.

fn contiguous_phys_addrs(&self, frame: PhysFrame, page_count: usize) -> Vec<u64>

pub fn sq_tail(&self) -> u32

Read the SQ tail (written by userspace, read by kernel).

pub fn sq_head(&self) -> u32

Read the SQ head (written by kernel, read by userspace).

pub fn sq_advance_head(&self, count: u32)

Advance the SQ head after processing submissions.

pub fn cq_advance_tail(&self, count: u32)

Advance the CQ tail after pushing completions.

pub fn cq_head(&self) -> u32

Read the CQ head (written by userspace after consuming).

pub unsafe fn sqe_at(&self, index: u32) -> *const AsyncSqe

Get a pointer to the SQE at the given index.

pub unsafe fn cqe_at(&self, index: u32) -> *mut AsyncCqe

Get a mutable pointer to the CQE at the given index.

pub fn destroy(&self)

Mark the ring as destroyed (no new submissions accepted).

pub(crate) fn sq_meta(&self) -> &RingMeta

pub(crate) fn cq_meta(&self) -> &RingMeta

Trait Implementations

impl Drop for Ring

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.