perf(virtiofs): reuse create handles for atomic open (#2120)

fslongjin · web-flow · commit d5440446f343 · 2026-07-15T00:40:21.000+08:00
FUSE_CREATE already returns an opened file handle, but the VFS create path discarded it with FUSE_RELEASE and constructed the file through a second FUSE_OPEN. This added two protocol requests for every created file and amplified metadata-heavy container workloads.

Add an optional VFS create-and-open operation backed by an RAII preopened-file guard. Carry the returned FUSE handle through MountFS wrapping and File construction, skip the redundant open request, and close the handle on every intermediate failure path.

Cache FUSE_CREATE ENOSYS at the connection level and preserve the Linux-compatible MKNOD plus OPEN fallback. Forward Linux-compatible create flags while keeping close, cache-state, writeback, and file-mode initialization consistent with normal FUSE opens.

Extend FuseExtended coverage for handle reuse, CREATE flag filtering, ENOSYS fallback caching, and RELEASE/FORGET cleanup of invalid replies.

Signed-off-by: longjin &lt;longjin@dragonos.org&gt;
diff --git a/kernel/src/filesystem/fuse/conn.rs b/kernel/src/filesystem/fuse/conn.rs
@@ -732,6 +732,7 @@ struct FuseConnInner {
     init: FuseInitNegotiated,
     no_open: bool,
     no_opendir: bool,
+    no_create: bool,
     no_readdirplus: bool,
     no_fallocate: bool,
     no_flush: bool,
@@ -892,6 +893,7 @@ impl FuseConn {
                 init: FuseInitNegotiated::default(),
                 no_open: false,
                 no_opendir: false,
+                no_create: false,
                 no_readdirplus: false,
                 no_fallocate: false,
                 no_flush: false,
@@ -1347,6 +1349,14 @@ impl FuseConn {
         }
     }
 
+    pub fn no_create(&self) -> bool {
+        self.inner.lock().no_create
+    }
+
+    pub fn mark_no_create(&self) {
+        self.inner.lock().no_create = true;
+    }
+
     pub fn use_readdirplus(&self) -> bool {
         let g = self.inner.lock();
         !g.no_readdirplus && (g.init.flags & FUSE_DO_READDIRPLUS) != 0
diff --git a/kernel/src/filesystem/fuse/inode/file.rs b/kernel/src/filesystem/fuse/inode/file.rs
@@ -931,7 +931,7 @@ impl FuseNode {
         Ok(total)
     }
 
-    fn set_open_private_data(
+    pub(super) fn set_open_private_data(
         &self,
         data: &mut FilePrivateData,
         opcode: u32,
@@ -1000,7 +1000,7 @@ impl FuseNode {
         Ok(())
     }
 
-    fn finish_open_cache_state(
+    pub(super) fn finish_open_cache_state(
         &self,
         opcode: u32,
         flags: &FileFlags,
diff --git a/kernel/src/filesystem/fuse/inode/vfs.rs b/kernel/src/filesystem/fuse/inode/vfs.rs
@@ -8,7 +8,7 @@ use crate::{
     filesystem::{
         page_cache::PageCache,
         vfs::{
-            file::{FileFlags, FileMode},
+            file::{FileFlags, FileMode, PreopenedFile},
             permission::PermissionMask,
             syscall::RenameFlags,
             utils::DName,
@@ -1093,6 +1093,10 @@ impl IndexNode for FuseNode {
             return self.create_with_data(name, file_type, mode, 0);
         }
 
+        if self.conn().no_create() {
+            return self.create_with_data(name, file_type, mode, 0);
+        }
+
         let inarg = FuseCreateIn {
             flags: FileFlags::O_RDONLY.bits(),
             mode: (InodeMode::S_IFREG | mode).bits(),
@@ -1103,7 +1107,10 @@ impl IndexNode for FuseNode {
 
         let payload = match self.conn().request(FUSE_CREATE, self.nodeid, &payload_in) {
             Ok(v) => v,
-            Err(SystemError::ENOSYS) => return self.create_with_data(name, file_type, mode, 0),
+            Err(SystemError::ENOSYS) => {
+                self.conn().mark_no_create();
+                return self.create_with_data(name, file_type, mode, 0);
+            }
             Err(e) => return Err(e),
         };
         let (entry, open_out) = Self::parse_create_reply(&payload)?;
@@ -1119,6 +1126,86 @@ impl IndexNode for FuseNode {
         self.create_node_from_entry(&entry, Some(name), FileType::File)
     }
 
+    fn create_and_open(
+        &self,
+        name: &str,
+        mode: InodeMode,
+        flags: &FileFlags,
+    ) -> Result<PreopenedFile, SystemError> {
+        self.check_not_stale()?;
+        self.ensure_dir()?;
+        if self.conn().no_create() {
+            return Err(SystemError::ENOSYS);
+        }
+
+        // Linux fuse_create_open() forwards creation flags, excluding the
+        // tty-only flag. O_CLOEXEC is per-fd state and must not reach FUSE.
+        let file_flags = flags.bits() & !FileFlags::O_CLOEXEC.bits();
+        let create_flags = file_flags & !FileFlags::O_NOCTTY.bits();
+        let inarg = FuseCreateIn {
+            flags: create_flags,
+            mode: (InodeMode::S_IFREG | mode).bits(),
+            umask: 0,
+            open_flags: 0,
+        };
+        let payload_in = Self::pack_struct_and_name_payload(&inarg, name);
+        let payload = match self.conn().request(FUSE_CREATE, self.nodeid, &payload_in) {
+            Ok(payload) => payload,
+            Err(SystemError::ENOSYS) => {
+                self.conn().mark_no_create();
+                return Err(SystemError::ENOSYS);
+            }
+            Err(err) => return Err(err),
+        };
+        let (entry, open_out) = Self::parse_create_reply(&payload)?;
+
+        let inode = match self.create_node_from_entry(&entry, Some(name), FileType::File) {
+            Ok(inode) => inode,
+            Err(err) => {
+                if entry.nodeid != 0 {
+                    self.release_common_for_node(
+                        FUSE_RELEASE,
+                        entry.nodeid,
+                        open_out.fh,
+                        file_flags,
+                        0,
+                    );
+                }
+                return Err(err);
+            }
+        };
+        let fuse_inode = match inode.clone().downcast_arc::<FuseNode>() {
+            Some(inode) => inode,
+            None => {
+                self.release_common_for_node(
+                    FUSE_RELEASE,
+                    entry.nodeid,
+                    open_out.fh,
+                    file_flags,
+                    0,
+                );
+                return Err(SystemError::EIO);
+            }
+        };
+
+        let mut private_data = FilePrivateData::default();
+        if let Err(err) = fuse_inode.set_open_private_data(
+            &mut private_data,
+            FUSE_OPEN,
+            open_out.fh,
+            file_flags,
+            open_out.open_flags,
+            false,
+        ) {
+            self.release_common_for_node(FUSE_RELEASE, entry.nodeid, open_out.fh, file_flags, 0);
+            return Err(err);
+        }
+
+        let preopened = PreopenedFile::new(inode, private_data);
+        fuse_inode.finish_open_cache_state(FUSE_OPEN, flags, open_out.open_flags)?;
+        Ok(preopened)
+    }
+
     fn create_with_data(
         &self,
         name: &str,
diff --git a/kernel/src/filesystem/vfs/file.rs b/kernel/src/filesystem/vfs/file.rs
@@ -284,6 +284,47 @@ impl Default for FilePrivateData {
     }
 }
 
+/// Owns filesystem private data for an inode that has already been opened.
+///
+/// The guard stays armed until a [`File`] takes ownership.  This closes the
+/// filesystem handle on every error path between an atomic create/open and
+/// construction of the open file description.
+pub struct PreopenedFile {
+    inode: Arc<dyn IndexNode>,
+    private_data: Option<FilePrivateData>,
+}
+
+impl PreopenedFile {
+    pub fn new(inode: Arc<dyn IndexNode>, private_data: FilePrivateData) -> Self {
+        Self {
+            inode,
+            private_data: Some(private_data),
+        }
+    }
+
+    pub fn inode(&self) -> Arc<dyn IndexNode> {
+        self.inode.clone()
+    }
+
+    pub fn replace_inode(&mut self, inode: Arc<dyn IndexNode>) {
+        self.inode = inode;
+    }
+
+    fn take_private_data(&mut self) -> FilePrivateData {
+        self.private_data
+            .take()
+            .expect("preopened file private data already consumed")
+    }
+}
+
+impl Drop for PreopenedFile {
+    fn drop(&mut self) {
+        if let Some(data) = self.private_data.take() {
+            let _ = self.inode.close(Mutex::new(data).lock());
+        }
+    }
+}
+
 impl FilePrivateData {
     pub fn update_flags(&mut self, flags: FileFlags) -> Result<(), SystemError> {
         match self {
@@ -831,7 +872,13 @@ impl File {
             .downcast_arc::<MountFSInode>()
             .map(|inode| inode.mount_fs().try_pin_external())
             .transpose()?;
-        Self::new_with_private_data_and_mount_guard(inode, flags, private_data_init, mount_guard)
+        Self::new_with_private_data_and_mount_guard(
+            inode,
+            flags,
+            private_data_init,
+            mount_guard,
+            None,
+        )
     }
 
     /// Construct a pathname-backed file by consuming the mount pin acquired
@@ -847,6 +894,26 @@ impl File {
             flags,
             FilePrivateData::default(),
             mount_guard,
+            None,
+        );
+        drop(operation_guard);
+        file
+    }
+
+    /// Construct a pathname-backed file from an already-opened inode.
+    pub fn new_preopened_with_mount_guard(
+        preopened: PreopenedFile,
+        flags: FileFlags,
+        mount_guard: Option<MountExternalGuard>,
+        operation_guard: InodeRetentionGuard,
+    ) -> Result<Self, SystemError> {
+        let inode = preopened.inode();
+        let file = Self::new_with_private_data_and_mount_guard(
+            inode,
+            flags,
+            FilePrivateData::default(),
+            mount_guard,
+            Some(preopened),
         );
         drop(operation_guard);
         file
@@ -857,6 +924,7 @@ impl File {
         mut flags: FileFlags,
         private_data_init: FilePrivateData,
         mount_guard: Option<MountExternalGuard>,
+        mut preopened: Option<PreopenedFile>,
     ) -> Result<Self, SystemError> {
         let mut inode = inode;
         let mut file_type = inode.metadata()?.file_type;
@@ -912,11 +980,20 @@ impl File {
         let inode_retention =
             InodeRetentionGuard::new(inode.clone(), InodeRetentionKind::OpenFileDescription)?;
 
-        let private_data = Mutex::new(private_data_init);
+        if is_path && preopened.is_some() {
+            return Err(SystemError::EINVAL);
+        }
+        let already_open = preopened.is_some();
+        let private_data = Mutex::new(match preopened.as_mut() {
+            Some(preopened) => preopened.take_private_data(),
+            None => private_data_init,
+        });
         if is_path {
             mode = FileMode::FMODE_PATH | FileMode::FMODE_OPENED;
         } else {
-            inode.open(private_data.lock(), &flags)?;
+            if !already_open {
+                inode.open(private_data.lock(), &flags)?;
+            }
 
             // 设置默认能力（由 inode 能力接口统一决定；避免 syscall 层/字符串特判）
             if inode.is_stream() {
diff --git a/kernel/src/filesystem/vfs/mod.rs b/kernel/src/filesystem/vfs/mod.rs
@@ -49,7 +49,7 @@ use crate::{
 pub use self::inode_lifecycle::{EvictionEpoch, InodeRetentionKind, InodeRetentionState};
 pub use self::{file::FilePrivateData, mount::MountFS};
 use self::{
-    file::{FileFlags, FileMode},
+    file::{FileFlags, FileMode, PreopenedFile},
     utils::DName,
     vcore::generate_inode_id,
 };
@@ -794,6 +794,18 @@ pub trait IndexNode: Any + Sync + Send + Debug + CastFromSync {
         return self.create_with_data(name, file_type, mode, 0);
     }
 
+    /// Atomically create and open a regular file when supported by the
+    /// filesystem.  The returned guard owns the open handle until VFS builds
+    /// the corresponding open file description.
+    fn create_and_open(
+        &self,
+        _name: &str,
+        _mode: InodeMode,
+        _flags: &FileFlags,
+    ) -> Result<PreopenedFile, SystemError> {
+        Err(SystemError::ENOSYS)
+    }
+
     /// @brief 在当前目录下创建一个新的inode，并传入一个简单的data字段，方便进行初始化。
     ///
     /// @param name 目录项的名字
diff --git a/kernel/src/filesystem/vfs/mount/mod.rs b/kernel/src/filesystem/vfs/mount/mod.rs
@@ -1,5 +1,5 @@
 use super::{
-    file::{File, FileFlags, FileMode},
+    file::{File, FileFlags, FileMode, PreopenedFile},
     utils::DName,
     FilePrivateData, FileSystem, FileType, IndexNode, InodeId, InodeMode, InodeRetentionKind,
     PollableInode, SetMetadataMask, SuperBlock, XattrFlags,
@@ -3301,6 +3301,38 @@ impl IndexNode for MountFSInode {
         )?);
     }
 
+    fn create_and_open(
+        &self,
+        name: &str,
+        mode: InodeMode,
+        flags: &FileFlags,
+    ) -> Result<PreopenedFile, SystemError> {
+        self.ensure_mount_writable()?;
+        let children_guard = self.dentry.children_gate.lock();
+        let mut preopened = self.dentry.inode.create_and_open(name, mode, flags)?;
+        let wrapped = {
+            let _namespace_guard = self
+                .mount_fs
+                .super_block_state
+                .dentry_namespace_lock
+                .write();
+            self.self_ref
+                .upgrade()
+                .ok_or(SystemError::ENOENT)
+                .and_then(|parent| {
+                    MountFSInode::new_child(
+                        preopened.inode(),
+                        self.mount_fs.clone(),
+                        &parent,
+                        DName::from(name),
+                    )
+                })
+        };
+        drop(children_guard);
+        preopened.replace_inode(wrapped?);
+        Ok(preopened)
+    }
+
     fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
         self.ensure_mount_writable()?;
         let _children_guard = self.dentry.children_gate.lock();
diff --git a/kernel/src/filesystem/vfs/open.rs b/kernel/src/filesystem/vfs/open.rs
diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc b/user/apps/tests/dunitest/suites/fuse/fuse_extended.cc
diff --git a/user/apps/tests/dunitest/suites/fuse/fuse_test_simplefs_local.h b/user/apps/tests/dunitest/suites/fuse/fuse_test_simplefs_local.h
