api: enable io-uring based asynchronous IO

Enalbe io-uring based asynchronous IO.

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

Author: jiangliu

Cargo.toml

@@ -46,7 +46,6 @@ vm-memory = { version = "0.7", features = ["backend-mmap", "backend-bitmap"] }
 
 [features]
 default = ["fusedev"]
-#async-io = ["async-trait", "futures", "caps]
 async-io = ["async-trait", "futures", "tokio-uring"]
 fusedev = ["vmm-sys-util", "caps", "core-foundation-sys"]
 virtiofs = ["virtio-queue", "caps"]

src/api/filesystem/async_io.rs

@@ -1,26 +1,24 @@
-// Copyright (C) 2021 Alibaba Cloud. All rights reserved.
+// Copyright (C) 2021-2022 Alibaba Cloud. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
 use std::ffi::CStr;
 use std::future::Future;
 use std::io;
 use std::ops::Deref;
-use std::os::unix::io::RawFd;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
 
 use async_trait::async_trait;
 
 use super::{Context, Entry, FileSystem, ZeroCopyReader, ZeroCopyWriter};
-use crate::abi::fuse_abi::{stat64, OpenOptions, SetattrValid};
-use crate::api::CreateIn;
-use crate::async_util::{AsyncDrive, AsyncDriver};
+use crate::abi::fuse_abi::{stat64, CreateIn, OpenOptions, SetattrValid};
+use crate::transport::AsyncFileReadWriteVolatile;
 
 /// A trait for directly copying data from the fuse transport into a `File` without first storing it
 /// in an intermediate buffer in asynchronous mode.
-#[async_trait]
-pub trait AsyncZeroCopyReader<D: AsyncDrive = AsyncDriver>: ZeroCopyReader {
+#[async_trait(?Send)]
+pub trait AsyncZeroCopyReader: ZeroCopyReader {
     /// Copies at most `count` bytes from `self` directly into `f` at offset `off` without storing
     /// it in any intermediate buffers. If the return value is `Ok(n)` then it must be guaranteed
     /// that `0 <= n <= count`. If `n` is `0`, then it can indicate one of 3 possibilities:
@@ -36,17 +34,16 @@ pub trait AsyncZeroCopyReader<D: AsyncDrive = AsyncDriver>: ZeroCopyReader {
     /// an error of the kind `io::ErrorKind::WriteZero`.
     async fn async_read_to(
         &mut self,
-        drive: D,
-        f: RawFd,
+        f: Arc<dyn AsyncFileReadWriteVolatile>,
         count: usize,
         off: u64,
     ) -> io::Result<usize>;
 }
 
 /// A trait for directly copying data from a `RawFd` into the fuse transport without first storing
 /// it in an intermediate buffer in asynchronous mode.
-#[async_trait]
-pub trait AsyncZeroCopyWriter<D: AsyncDrive = AsyncDriver>: ZeroCopyWriter {
+#[async_trait(?Send)]
+pub trait AsyncZeroCopyWriter: ZeroCopyWriter {
     /// Copies at most `count` bytes from `f` at offset `off` directly into `self` without storing
     /// it in any intermediate buffers. If the return value is `Ok(n)` then it must be guaranteed
     /// that `0 <= n <= count`. If `n` is `0`, then it can indicate one of 3 possibilities:
@@ -62,8 +59,7 @@ pub trait AsyncZeroCopyWriter<D: AsyncDrive = AsyncDriver>: ZeroCopyWriter {
     /// error of the kind `io::ErrorKind::UnexpectedEof`.
     async fn async_write_from(
         &mut self,
-        drive: D,
-        f: RawFd,
+        f: Arc<dyn AsyncFileReadWriteVolatile>,
         count: usize,
         off: u64,
     ) -> io::Result<usize>;
@@ -72,7 +68,7 @@ pub trait AsyncZeroCopyWriter<D: AsyncDrive = AsyncDriver>: ZeroCopyWriter {
 /// The main trait that connects a file system with a transport with asynchronous IO.
 #[allow(unused_variables)]
 #[async_trait]
-pub trait AsyncFileSystem<D: AsyncDrive = AsyncDriver>: FileSystem {
+pub trait AsyncFileSystem: FileSystem {
     /// Look up a directory entry by name and get its attributes.
     ///
     /// If this call is successful then the lookup count of the `Inode` associated with the returned
@@ -362,7 +358,7 @@ pub trait AsyncFileSystem<D: AsyncDrive = AsyncDriver>: FileSystem {
         ctx: &Context,
         inode: Self::Inode,
         handle: Self::Handle,
-        w: &mut (dyn AsyncZeroCopyWriter<D> + Send),
+        w: &mut (dyn AsyncZeroCopyWriter + Send),
         size: u32,
         offset: u64,
         lock_owner: Option<u64>,
@@ -394,7 +390,7 @@ pub trait AsyncFileSystem<D: AsyncDrive = AsyncDriver>: FileSystem {
         ctx: &Context,
         inode: Self::Inode,
         handle: Self::Handle,
-        r: &mut (dyn AsyncZeroCopyReader<D> + Send),
+        r: &mut (dyn AsyncZeroCopyReader + Send),
         size: u32,
         offset: u64,
         lock_owner: Option<u64>,
@@ -845,7 +841,7 @@ type OpenFuture<'async_trait, H> =
 type CreateFuture<'async_trait, H> =
     Box<dyn Future<Output = io::Result<(Entry, Option<H>, OpenOptions)>> + Send + 'async_trait>;
 
-impl<FS: AsyncFileSystem<D>, D: AsyncDrive> AsyncFileSystem<D> for Arc<FS> {
+impl<FS: AsyncFileSystem> AsyncFileSystem for Arc<FS> {
     fn async_lookup<'a, 'b, 'c, 'async_trait>(
         &'a self,
         ctx: &'b Context,
@@ -927,7 +923,7 @@ impl<FS: AsyncFileSystem<D>, D: AsyncDrive> AsyncFileSystem<D> for Arc<FS> {
         ctx: &'b Context,
         inode: Self::Inode,
         handle: Self::Handle,
-        w: &'c mut (dyn AsyncZeroCopyWriter<D> + Send),
+        w: &'c mut (dyn AsyncZeroCopyWriter + Send),
         size: u32,
         offset: u64,
         lock_owner: Option<u64>,
@@ -948,7 +944,7 @@ impl<FS: AsyncFileSystem<D>, D: AsyncDrive> AsyncFileSystem<D> for Arc<FS> {
         ctx: &'b Context,
         inode: Self::Inode,
         handle: Self::Handle,
-        r: &'c mut (dyn AsyncZeroCopyReader<D> + Send),
+        r: &'c mut (dyn AsyncZeroCopyReader + Send),
         size: u32,
         offset: u64,
         lock_owner: Option<u64>,

src/api/filesystem/mod.rs

@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Alibaba Cloud. All rights reserved.
+// Copyright (C) 2020-2022 Alibaba Cloud. All rights reserved.
 // Copyright 2019 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
@@ -22,9 +22,9 @@ pub use fuse::ROOT_ID;
 
 use crate::abi::fuse_abi::{ino64_t, stat64};
 
-#[cfg(feature = "async_io")]
+#[cfg(feature = "async-io")]
 mod async_io;
-#[cfg(feature = "async_io")]
+#[cfg(feature = "async-io")]
 pub use async_io::{AsyncFileSystem, AsyncZeroCopyReader, AsyncZeroCopyWriter};
 
 mod sync_io;
@@ -383,10 +383,6 @@ pub struct Context {
 
     /// The thread group ID of the calling process.
     pub pid: libc::pid_t,
-
-    #[cfg(feature = "async_io")]
-    /// Asynchronous event drive
-    pub drive: usize,
 }
 
 impl Context {
@@ -402,38 +398,6 @@ impl From<&fuse::InHeader> for Context {
             uid: source.uid,
             gid: source.gid,
             pid: source.pid as i32,
-            #[cfg(feature = "async_io")]
-            drive: 0,
-        }
-    }
-}
-
-// The design is very ugly, but it helps to avoid adding a generic type parameter "D: AsyncDrive"
-// to the FileSystem trait.
-#[cfg(feature = "async_io")]
-impl Context {
-    /// Set the asynchronous event drive.
-    ///
-    /// ## Safety
-    /// The caller must ensure that the the referenced `drive` has a longer lifetime than the
-    /// `Context` object.
-    pub(crate) unsafe fn set_drive<D: crate::async_util::AsyncDrive>(&mut self, drive: &D) {
-        // The generic type `D` has bound as "Clone + Send". `D` is Send, then `&D` is Sync,
-        // so it's safe to call drive.clone() in get_drive() only if the caller ensures `drive`
-        // has longer lifetime than this `Context` object.
-        self.drive = drive as *const D as *const u8 as usize;
-    }
-
-    /// Get an asynchronous event drive.
-    ///
-    /// If `get_drive()` returns None, it means async io has been disabled for the associated
-    /// fuse request.
-    pub fn get_drive<D: crate::async_util::AsyncDrive>(&self) -> Option<D> {
-        if self.drive == 0 {
-            None
-        } else {
-            let drive = unsafe { &*(self.drive as *const u8 as *const D) };
-            Some(drive.clone())
         }
     }
 }

src/api/filesystem/sync_io.rs

@@ -1,8 +1,15 @@
-// Copyright (C) 2021 Alibaba Cloud. All rights reserved.
+// Copyright (C) 2021-2022 Alibaba Cloud. All rights reserved.
 // Copyright 2019 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
 
+use std::ffi::CStr;
+use std::io;
+use std::mem;
+use std::ops::Deref;
+use std::sync::Arc;
+use std::time::Duration;
+
 use super::{
     Context, DirEntry, Entry, FileLock, GetxattrReply, IoctlData, ListxattrReply, ZeroCopyReader,
     ZeroCopyWriter,
@@ -12,12 +19,6 @@ use crate::abi::fuse_abi::{stat64, statvfs64, CreateIn, FsOptions, OpenOptions,
 pub use crate::abi::virtio_fs::RemovemappingOne;
 #[cfg(feature = "virtiofs")]
 use crate::transport::FsCacheReqHandler;
-use std::ffi::CStr;
-use std::io;
-use std::mem;
-use std::ops::Deref;
-use std::sync::Arc;
-use std::time::Duration;
 
 /// The main trait that connects a file system with a transport.
 #[allow(unused_variables)]
@@ -1336,7 +1337,7 @@ impl<FS: FileSystem> FileSystem for Arc<FS> {
             .poll(ctx, inode, handle, khandle, flags, events)
     }
 
-    /// TODO: support this
+    /// Send notify reply.
     fn notify_reply(&self) -> io::Result<()> {
         self.deref().notify_reply()
     }

src/api/mod.rs

@@ -12,8 +12,6 @@
 //! - [struct Vfs](vfs/struct.Vfs.html), a simple union file system to help organize multiple
 //!   backend file systems.
 
-pub use super::abi::fuse_abi::CreateIn;
-
 mod pseudo_fs;
 
 pub mod vfs;