feat(driver): force OpCode support (#690)

Author: George-Miao

compio-driver/Cargo.toml

@@ -28,6 +28,7 @@ pin-project-lite = { workspace = true }
 thin-cell = { version = "0.1.1" }
 smallvec = { workspace = true, optional = true, features = ["union"] }
 synchrony = { workspace = true, features = ["waker_slot"] }
+bitflags = { version = "2.11.0" }
 
 # Windows specific dependencies
 [target.'cfg(windows)'.dependencies]

compio-driver/src/driver_type.rs

@@ -11,28 +11,17 @@ pub enum DriverType {
 }
 
 impl DriverType {
-    /// Get the underlying driver type
+    /// Suggest the driver type base on OpCode availability.
+    ///
+    /// This is used when the user doesn't specify a driver type, and the driver
+    /// will choose the best one based on the supported OpCodes.
     #[cfg(fusion)]
-    pub(crate) fn suggest() -> DriverType {
-        use io_uring::opcode::*;
+    pub(crate) fn suggest(additional: crate::op::OpCodeFlag) -> DriverType {
+        use crate::op::OpCodeFlag;
 
-        // Add more opcodes here if used
-        const USED_OP: &[u8] = &[
-            Read::CODE,
-            Readv::CODE,
-            Write::CODE,
-            Writev::CODE,
-            Fsync::CODE,
-            Accept::CODE,
-            Connect::CODE,
-            Recv::CODE,
-            Send::CODE,
-            RecvMsg::CODE,
-            SendMsg::CODE,
-            PollAdd::CODE,
-        ];
+        let flags = additional | OpCodeFlag::basic();
 
-        if USED_OP.iter().all(|op| crate::sys::is_op_supported(*op)) {
+        if flags.get_codes().all(crate::sys::is_op_supported) {
             DriverType::IoUring
         } else {
             DriverType::Poll

compio-driver/src/lib.rs

@@ -47,7 +47,7 @@ pub use sys::*;
 mod cancel;
 pub use cancel::*;
 
-use crate::key::ErasedKey;
+use crate::{key::ErasedKey, op::OpCodeFlag};
 
 mod sys_slice;
 
@@ -450,6 +450,7 @@ pub struct ProactorBuilder {
     taskrun_flag: bool,
     eventfd: Option<RawFd>,
     driver_type: Option<DriverType>,
+    op_flags: OpCodeFlag,
 }
 
 // SAFETY: `RawFd` is thread safe.
@@ -473,6 +474,7 @@ impl ProactorBuilder {
             taskrun_flag: false,
             eventfd: None,
             driver_type: None,
+            op_flags: OpCodeFlag::empty(),
         }
     }
 
@@ -580,6 +582,27 @@ impl ProactorBuilder {
         self
     }
 
+    /// Set which io-uring [`OpCode`] must be supported by the driver.
+    ///
+    /// Support for io-uring opcodes varies by kernel version. Setting this
+    /// will force the driver to check for support of the specified opcodes, and
+    /// when any of them are not supported:
+    /// - Fallback to `polling` driver if `fusion` driver is enabled,
+    /// - Return an [`Unsupported`] error when building the proactor otherwise.
+    ///
+    /// # Notes
+    ///
+    /// - Only effective when the `io-uring` feature is enabled
+    /// - [`OpCodeFlag`] is a bitflag struct, you can combine multiple opcodes
+    ///   with bitwise OR or use [`OpCodeFlag::all`] to require all opcodes to
+    ///   be supported.
+    ///
+    /// [`Unsupported`]: std::io::ErrorKind::Unsupported
+    pub fn detect_opcode_support(&mut self, flags: OpCodeFlag) -> &mut Self {
+        self.op_flags = flags;
+        self
+    }
+
     /// Force a driver type to use.
     ///
     /// It is ignored if the fusion driver is disabled.

compio-driver/src/op.rs

@@ -572,3 +572,91 @@ pub(crate) mod managed {
 
 #[cfg(not(io_uring))]
 pub use managed::*;
+
+bitflags::bitflags! {
+    /// Flags for operations.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+    pub struct OpCodeFlag: u32 {
+        /// Detect `Read` OpCode
+        const Read = 1 << 0;
+        /// Detect `Readv` OpCode
+        const Readv = 1 << 1;
+        /// Detect `Write` OpCode
+        const Write = 1 << 2;
+        /// Detect `Writev` OpCode
+        const Writev = 1 << 3;
+        /// Detect `Fsync` OpCode
+        const Fsync = 1 << 4;
+        /// Detect `Accept` OpCode
+        const Accept = 1 << 5;
+        /// Detect `Connect` OpCode
+        const Connect = 1 << 6;
+        /// Detect `Recv` OpCode
+        const Recv = 1 << 7;
+        /// Detect `Send` OpCode
+        const Send = 1 << 8;
+        /// Detect `RecvMsg` OpCode
+        const RecvMsg = 1 << 9;
+        /// Detect `SendMsg` OpCode
+        const SendMsg = 1 << 10;
+        /// Detect `AsyncCancel` OpCode
+        const AsyncCancel = 1 << 11;
+        /// Detect `OpenAt` OpCode
+        const OpenAt = 1 << 12;
+        /// Detect `Close` OpCode
+        const Close = 1 << 13;
+        /// Detect `Splice` OpCode
+        const Splice = 1 << 14;
+        /// Detect `Shutdown` OpCode
+        const Shutdown = 1 << 15;
+        /// Detect `PollAdd` OpCode
+        const PollAdd = 1 << 16;
+    }
+}
+
+impl OpCodeFlag {
+    /// Get the [`OpCodeFlag`] corresponds to basic OpCodes that are commonly
+    /// used.
+    pub fn basic() -> Self {
+        OpCodeFlag::Read
+            | OpCodeFlag::Readv
+            | OpCodeFlag::Write
+            | OpCodeFlag::Writev
+            | OpCodeFlag::Fsync
+            | OpCodeFlag::Accept
+            | OpCodeFlag::Connect
+            | OpCodeFlag::Recv
+            | OpCodeFlag::Send
+            | OpCodeFlag::RecvMsg
+            | OpCodeFlag::SendMsg
+            | OpCodeFlag::PollAdd
+    }
+}
+
+#[cfg(io_uring)]
+impl OpCodeFlag {
+    pub(crate) fn get_codes(self) -> impl Iterator<Item = u8> {
+        use io_uring::opcode::*;
+
+        self.iter().map(|flag| match flag {
+            OpCodeFlag::Read => Read::CODE,
+            OpCodeFlag::Readv => Readv::CODE,
+            OpCodeFlag::Write => Write::CODE,
+            OpCodeFlag::Writev => Writev::CODE,
+            OpCodeFlag::Fsync => Fsync::CODE,
+            OpCodeFlag::Accept => Accept::CODE,
+            OpCodeFlag::Connect => Connect::CODE,
+            OpCodeFlag::Recv => Recv::CODE,
+            OpCodeFlag::Send => Send::CODE,
+            OpCodeFlag::RecvMsg => RecvMsg::CODE,
+            OpCodeFlag::SendMsg => SendMsg::CODE,
+            OpCodeFlag::AsyncCancel => AsyncCancel::CODE,
+            OpCodeFlag::OpenAt => OpenAt::CODE,
+            OpCodeFlag::Close => Close::CODE,
+            OpCodeFlag::Splice => Splice::CODE,
+            OpCodeFlag::Shutdown => Shutdown::CODE,
+            OpCodeFlag::PollAdd => PollAdd::CODE,
+            unknown => unreachable!("Unknown OpCodeFlag specified: {unknown:?}"),
+        })
+    }
+}

compio-driver/src/sys/fusion/mod.rs

@@ -96,7 +96,7 @@ impl Driver {
     pub fn new(builder: &ProactorBuilder) -> io::Result<Self> {
         let (ty, fallback) = match &builder.driver_type {
             Some(t) => (*t, false),
-            None => (DriverType::suggest(), true),
+            None => (DriverType::suggest(builder.op_flags), true),
         };
         match ty {
             DriverType::Poll => Ok(Self {

compio-driver/src/sys/iour/mod.rs

@@ -154,6 +154,15 @@ impl Driver {
     pub fn new(builder: &ProactorBuilder) -> io::Result<Self> {
         instrument!(compio_log::Level::TRACE, "new", ?builder);
         trace!("new iour driver");
+        // if op_flags is empty, this loop will not run
+        for code in builder.op_flags.get_codes() {
+            if !is_op_supported(code) {
+                return Err(io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    format!("io-uring does not support opcode {code:?}({code})"),
+                ));
+            }
+        }
         let notifier = Notifier::new()?;
         let mut io_uring_builder = IoUring::builder();
         if let Some(sqpoll_idle) = builder.sqpoll_idle {