Struct Ring 

pub struct Ring<T, E: RingOp<T>> { /* private fields */ }

An io_uring instance.

Implementations

impl<T, E: RingOp<T>> Ring<T, E>

pub fn new(ring: IoUring, ctx: T) -> Self

Creates a new ring with the provided io_uring instance and context.

The context T is a user defined value that will be passed to entries E once they complete. This value can be used to update state or perform additional actions as operations complete asynchronously.

pub fn context(&self) -> &T

Returns a reference to the context value.

pub fn context_mut(&mut self) -> &mut T

Returns a mutable reference to the context value.

pub unsafe fn register_buffers(&self, iovecs: &[iovec]) -> Result<()>

Registers in-memory fixed buffers for I/O with the kernel.

Safety

Callers must ensure that the iov_base and iov_len values are valid and will be valid until buffers are unregistered or the ring destroyed, otherwise undefined behaviour may occur.

See Submitter::register_buffers.

pub fn push(&mut self, op: E) -> Result<()>

Pushes an operation to the submission queue.

Once completed, RingOp::complete will be called with the result.

Note that the operation is not submitted to the kernel until Ring::submit is called. If the submission queue is full, submit will be called internally to make room for the new operation.

See also Ring::submit.

pub fn submit(&mut self) -> Result<()>

Submits all pending operations to the kernel.

If the ring can’t accept any more submissions because the completion queue is full, this will process completions and retry until the submissions are accepted.

See also Ring::process_completions.

pub fn submit_and_wait( &mut self, want: usize, timeout: Option<Duration>, ) -> Result<usize>

Submits all pending operations to the kernel and waits for completions.

If no timeout is passed this will block until want completions are available. If a timeout is passed, this will block until want completions are available or the timeout is reached.

Returns the number of completions received.

pub fn process_completions(&mut self) -> Result<()>

Processes completions from the kernel.

This will process all completions currently available in the completion queue and invoke RingOp::complete for each completed operation.

pub fn drain(&mut self) -> Result<()>

Drains the ring.

This will submit all pending operations to the kernel and process all completions until the ring is empty.