async_runtime: add probe of io_uring support

Signed-off-by: wanglei01 <[email protected]>

Author: wllenyj

Cargo.toml

@@ -20,6 +20,7 @@ build = "build.rs"
 arc-swap = "1.5"
 async-trait = { version = "0.1.42", optional = true }
 bitflags = "1.1"
+io-uring = { version = "0.5.8", optional = true }
 libc = "0.2.68"
 log = "0.4.6"
 mio = { version = "0.8", features = ["os-poll", "os-ext"]}
@@ -46,7 +47,7 @@ vm-memory = { version = "0.9", features = ["backend-mmap", "backend-bitmap"] }
 
 [features]
 default = ["fusedev"]
-async-io = ["async-trait", "tokio-uring", "tokio/fs", "tokio/net", "tokio/sync", "tokio/rt", "tokio/macros"]
+async-io = ["async-trait", "tokio-uring", "tokio/fs", "tokio/net", "tokio/sync", "tokio/rt", "tokio/macros", "io-uring"]
 fusedev = ["vmm-sys-util", "caps", "core-foundation-sys"]
 virtiofs = ["virtio-queue", "caps"]
 vhost-user-fs = ["virtiofs", "vhost", "caps"]

src/common/async_file.rs

@@ -9,7 +9,7 @@ use std::io::{ErrorKind, IoSlice, IoSliceMut};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::path::Path;
 
-use crate::async_runtime::{Runtime, CURRENT_RUNTIME};
+use crate::async_runtime::{RuntimeType, RUNTIME_TYPE};
 use crate::file_buf::FileVolatileBuf;
 use crate::{off64_t, preadv64, pwritev64};
 
@@ -29,22 +29,16 @@ impl File {
         write: bool,
         create: bool,
     ) -> std::io::Result<Self> {
-        let ty = CURRENT_RUNTIME.with(|rt| match rt {
-            Runtime::Tokio(_) => 1,
-            #[cfg(target_os = "linux")]
-            Runtime::Uring(_) => 2,
-        });
-
-        match ty {
-            1 => tokio::fs::OpenOptions::new()
+        match *RUNTIME_TYPE {
+            RuntimeType::Tokio => tokio::fs::OpenOptions::new()
                 .read(true)
                 .write(write)
                 .create(create)
                 .open(path)
                 .await
                 .map(File::Tokio),
             #[cfg(target_os = "linux")]
-            2 => tokio_uring::fs::OpenOptions::new()
+            RuntimeType::Uring => tokio_uring::fs::OpenOptions::new()
                 .read(true)
                 .write(write)
                 .create(create)

src/common/async_runtime.rs

@@ -6,6 +6,66 @@
 
 use std::future::Future;
 
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub(crate) static ref RUNTIME_TYPE: RuntimeType = RuntimeType::new();
+}
+
+pub(crate) enum RuntimeType {
+    Tokio,
+    #[cfg(target_os = "linux")]
+    Uring,
+}
+
+impl RuntimeType {
+    fn new() -> Self {
+        #[cfg(target_os = "linux")]
+        {
+            if Self::probe_io_uring() {
+                return Self::Uring;
+            }
+        }
+        Self::Tokio
+    }
+
+    #[cfg(target_os = "linux")]
+    fn probe_io_uring() -> bool {
+        use io_uring::{opcode, IoUring, Probe};
+
+        let io_uring = match IoUring::new(1) {
+            Ok(io_uring) => io_uring,
+            Err(_) => {
+                return false;
+            }
+        };
+        let submitter = io_uring.submitter();
+
+        let mut probe = Probe::new();
+
+        // Check we can register a probe to validate supported operations.
+        if let Err(_) = submitter.register_probe(&mut probe) {
+            return false;
+        }
+
+        // Check IORING_OP_FSYNC is supported
+        if !probe.is_supported(opcode::Fsync::CODE) {
+            return false;
+        }
+
+        // Check IORING_OP_READ is supported
+        if !probe.is_supported(opcode::Read::CODE) {
+            return false;
+        }
+
+        // Check IORING_OP_WRITE is supported
+        if !probe.is_supported(opcode::Write::CODE) {
+            return false;
+        }
+        return true;
+    }
+}
+
 /// An adapter enum to support both tokio current-thread Runtime and tokio-uring Runtime.
 pub enum Runtime {
     /// Tokio current thread Runtime.
@@ -26,8 +86,7 @@ impl Runtime {
     pub fn new() -> Self {
         // Check whether io-uring is available.
         #[cfg(target_os = "linux")]
-        {
-            // TODO: use io-uring probe to detect supported operations.
+        if matches!(*RUNTIME_TYPE, RuntimeType::Uring) {
             if let Ok(rt) = tokio_uring::Runtime::new(&tokio_uring::builder()) {
                 return Runtime::Uring(std::sync::Mutex::new(rt));
             }