Struct io_uring::squeue::SubmissionQueue

pub struct SubmissionQueue<'a, E: EntryMarker = Entry> { /* private fields */ }

An io_uring instance’s submission queue. This is used to send I/O requests to the kernel.

Implementations

impl<E: EntryMarker> SubmissionQueue<'_, E>

pub fn sync(&mut self)

Synchronize this type with the real submission queue.

This will flush any entries added by push or push_multiple and will update the queue’s length if the kernel has consumed some entries in the meantime.

pub fn need_wakeup(&self) -> bool

When is_setup_sqpoll is set, whether the kernel threads has gone to sleep and requires a system call to wake it up.

pub fn dropped(&self) -> u32

The number of invalid submission queue entries that have been encountered in the ring buffer.

pub fn cq_overflow(&self) -> bool

Returns true if the completion queue ring is overflown.

pub fn capacity(&self) -> usize

Get the total number of entries in the submission queue ring buffer.

Examples found in repository

src/squeue.rs (line 230)

    pub fn is_full(&self) -> bool {
        self.len() == self.capacity()
    }

    /// Attempts to push an entry into the queue.
    /// If the queue is full, an error is returned.
    ///
    /// # Safety
    ///
    /// Developers must ensure that parameters of the entry (such as buffer) are valid and will
    /// be valid for the entire duration of the operation, otherwise it may cause memory problems.
    #[inline]
    pub unsafe fn push(&mut self, entry: &E) -> Result<(), PushError> {
        if !self.is_full() {
            self.push_unchecked(entry);
            Ok(())
        } else {
            Err(PushError)
        }
    }

    /// Attempts to push several entries into the queue.
    /// If the queue does not have space for all of the entries, an error is returned.
    ///
    /// # Safety
    ///
    /// Developers must ensure that parameters of all the entries (such as buffer) are valid and
    /// will be valid for the entire duration of the operation, otherwise it may cause memory
    /// problems.
    #[inline]
    pub unsafe fn push_multiple(&mut self, entries: &[E]) -> Result<(), PushError> {
        if self.capacity() - self.len() < entries.len() {
            return Err(PushError);
        }

        for entry in entries {
            self.push_unchecked(entry);
        }

        Ok(())
    }

pub fn len(&self) -> usize

Get the number of submission queue events in the ring buffer.

Examples found in repository

src/squeue.rs (line 223)

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Returns `true` if the submission queue ring buffer has reached capacity, and no more events
    /// can be added before the kernel consumes some.
    #[inline]
    pub fn is_full(&self) -> bool {
        self.len() == self.capacity()
    }

    /// Attempts to push an entry into the queue.
    /// If the queue is full, an error is returned.
    ///
    /// # Safety
    ///
    /// Developers must ensure that parameters of the entry (such as buffer) are valid and will
    /// be valid for the entire duration of the operation, otherwise it may cause memory problems.
    #[inline]
    pub unsafe fn push(&mut self, entry: &E) -> Result<(), PushError> {
        if !self.is_full() {
            self.push_unchecked(entry);
            Ok(())
        } else {
            Err(PushError)
        }
    }

    /// Attempts to push several entries into the queue.
    /// If the queue does not have space for all of the entries, an error is returned.
    ///
    /// # Safety
    ///
    /// Developers must ensure that parameters of all the entries (such as buffer) are valid and
    /// will be valid for the entire duration of the operation, otherwise it may cause memory
    /// problems.
    #[inline]
    pub unsafe fn push_multiple(&mut self, entries: &[E]) -> Result<(), PushError> {
        if self.capacity() - self.len() < entries.len() {
            return Err(PushError);
        }

        for entry in entries {
            self.push_unchecked(entry);
        }

        Ok(())
    }

pub fn is_empty(&self) -> bool

Returns true if the submission queue ring buffer is empty.

pub fn is_full(&self) -> bool

Returns true if the submission queue ring buffer has reached capacity, and no more events can be added before the kernel consumes some.

Examples found in repository

src/squeue.rs (line 242)

    pub unsafe fn push(&mut self, entry: &E) -> Result<(), PushError> {
        if !self.is_full() {
            self.push_unchecked(entry);
            Ok(())
        } else {
            Err(PushError)
        }
    }

pub unsafe fn push(&mut self, entry: &E) -> Result<(), PushError>

Attempts to push an entry into the queue. If the queue is full, an error is returned.

Safety

Developers must ensure that parameters of the entry (such as buffer) are valid and will be valid for the entire duration of the operation, otherwise it may cause memory problems.

pub unsafe fn push_multiple(&mut self, entries: &[E]) -> Result<(), PushError>

Attempts to push several entries into the queue. If the queue does not have space for all of the entries, an error is returned.

Safety

Developers must ensure that parameters of all the entries (such as buffer) are valid and will be valid for the entire duration of the operation, otherwise it may cause memory problems.

Trait Implementations

impl<E: EntryMarker> Debug for SubmissionQueue<'_, E>

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

Formats the value using the given formatter.

impl<E: EntryMarker> Drop for SubmissionQueue<'_, E>

fn drop(&mut self)

Executes the destructor for this type.