Add SubmissionQueue::push_opcode()/push_multiple_opcode()

Add SubmissionQueue::push_opcode()/push_multiple_opcode() to generate
SQE in place.

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

src/squeue.rs

@@ -5,6 +5,7 @@ use std::error::Error;
 use std::fmt::{self, Display, Formatter};
 use std::sync::atomic;
 
+use crate::opcode::PrepareSQE;
 use crate::sys;
 use crate::util::{unsync_load, Mmap};
 
@@ -43,6 +44,14 @@ pub struct SubmissionQueue<'a> {
 #[derive(Clone)]
 pub struct Entry(pub(crate) sys::io_uring_sqe);
 
+/// Common options for Submission Queue Entry.
+#[derive(Clone, Copy, Default, Debug)]
+pub struct OptionValues {
+    user_data: u64,
+    personality: u16,
+    flags: u8,
+}
+
 bitflags! {
     /// Submission flags
     pub struct Flags: u8 {
@@ -269,6 +278,64 @@ impl SubmissionQueue<'_> {
         Ok(())
     }
 
+    /// Attempts to push an opcode into the submission queue.
+    /// If the queue is full, an error is returned.
+    ///
+    /// # Safety
+    ///
+    /// Developers must ensure that parameters of the opcode (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_opcode<'a, T: PrepareSQE>(
+        &'a mut self,
+        opcode: &T,
+        options: Option<&OptionValues>,
+    ) -> Result<(), PushError> {
+        if !self.is_full() {
+            let sqe = self.next_sqe();
+            opcode.prepare(sqe);
+            options.map(|o| Self::set_sqe_options(sqe, o));
+            Ok(())
+        } else {
+            Err(PushError)
+        }
+    }
+
+    /// Attempts to push several opcodes 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.
+    #[cfg(feature = "unstable")]
+    #[inline]
+    pub unsafe fn push_multiple_opcode<'a, T: PrepareSQE>(
+        &'a mut self,
+        ops: &[(T, Option<&OptionValues>)],
+    ) -> Result<(), PushError> {
+        if self.capacity() - self.len() < ops.len() {
+            return Err(PushError);
+        }
+
+        for (opcode, options) in ops {
+            let sqe = self.next_sqe();
+            opcode.prepare(sqe);
+            options.map(|o| Self::set_sqe_options(sqe, o));
+            self.move_forward();
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn set_sqe_options(sqe: &mut sys::io_uring_sqe, options: &OptionValues) {
+        sqe.user_data = options.user_data;
+        sqe.personality = options.personality;
+        sqe.flags = options.flags;
+    }
+
     #[inline]
     fn next_sqe(&mut self) -> &mut sys::io_uring_sqe {
         // Safe because we are accessing an entry in the allocated submission queue.
@@ -320,6 +387,44 @@ impl Entry {
     }
 }
 
+impl OptionValues {
+    /// Create a new instance of `OptionValues`.
+    pub fn new(user_data: u64, personality: u16, flags: Flags) -> Self {
+        OptionValues {
+            user_data,
+            personality,
+            flags: flags.bits(),
+        }
+    }
+
+    /// Set the user data.
+    ///
+    /// This is an application-supplied value that will be passed straight through into the
+    /// [completion queue entry](crate::cqueue::Entry::user_data).
+    #[inline]
+    pub fn user_data(mut self, user_data: u64) -> Self {
+        self.user_data = user_data;
+        self
+    }
+
+    /// Set the personality of this event.
+    ///
+    /// You can obtain a personality using
+    /// [`Submitter::register_personality`](crate::Submitter::register_personality).
+    #[inline]
+    pub fn personality(mut self, personality: u16) -> Self {
+        self.personality = personality;
+        self
+    }
+
+    /// Set the submission event's [flags](Flags).
+    #[inline]
+    pub fn flags(mut self, flags: Flags) -> Self {
+        self.flags |= flags.bits();
+        self
+    }
+}
+
 /// An error pushing to the submission queue due to it being full.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]