You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2026/10/26 09:06:20 UTC

(opendal-yinyang) 02/02: fix(fuse): reclaim stale clean nodes before opening

This is an automated email from the ASF dual-hosted git repository.

Xuanwo pushed a commit to branch xuanwo/linux-fuse-writable
in repository https://gitbox.apache.org/repos/asf/opendal-yinyang.git

commit f9a9470862ae4f5d932f3c9a2eb8eed9a88b1bc3
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Mon Oct 26 17:06:12 2026 +0800

    fix(fuse): reclaim stale clean nodes before opening
    
    A release that observes Busy may be followed by the last in-flight reference dropping without another cleanup. Every adapter open now retries reclaim first: clean unreferenced state is removed so the next open observes latest, while Busy preserves pinned, dirty, frozen and failed state. Add a transient-Busy regression.
    
    Co-authored-by: Chojan Shang <ps...@apache.org>
---
 specs/linux-fuse.md  |  5 +++-
 src/fuse/frontend.rs | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 1 deletion(-)

diff --git a/specs/linux-fuse.md b/specs/linux-fuse.md
index 3cfa7fd..f6e7524 100644
--- a/specs/linux-fuse.md
+++ b/specs/linux-fuse.md
@@ -88,7 +88,10 @@ version remains coherent until a later release becomes the final reference;
 that open's metadata and content never disagree. The frontend does not call
 `Mount::refresh` while references exist, because refresh rebases live handles;
 a writable layer that in-place refreshes must first define its open-fd and
-kernel-cache invalidation policy.
+kernel-cache invalidation policy. Before a new open, the adapter retries
+reclaiming a clean unreferenced NodeId; a successful reclaim makes that open
+materialize the latest remote version, while Busy retains all still-pinned or
+dirty/frozen/error state.
 
 ## Writable callbacks
 
diff --git a/src/fuse/frontend.rs b/src/fuse/frontend.rs
index 9da3473..be648c3 100644
--- a/src/fuse/frontend.rs
+++ b/src/fuse/frontend.rs
@@ -187,6 +187,17 @@ impl Inner {
             .map_err(|e| core_errno(&e))
     }
 
+    /// Drop a stale clean version before opening. Busy means another reference
+    /// still pins the shared version, or the node retains dirty/frozen/error
+    /// state; both must be reused rather than reset.
+    async fn reclaim_clean_before_open(&self, id: NodeId) -> Result<(), fuser::Errno> {
+        match self.mount.reclaim(id).await {
+            Ok(()) => Ok(()),
+            Err(error) if error.kind() == crate::runtime::ErrorKind::Busy => Ok(()),
+            Err(error) => Err(runtime_errno(&error)),
+        }
+    }
+
     /// Attributes and size from one pinned observation.
     async fn snapshot_attr(
         &self,
@@ -331,6 +342,9 @@ impl Inner {
         if truncate && !writable {
             return reply.error(fuser::Errno::EINVAL);
         }
+        if let Err(errno) = self.reclaim_clean_before_open(id).await {
+            return reply.error(errno);
+        }
         match self.mount.open_node(id, writable).await {
             Ok(file) => {
                 if truncate && let Err(error) = file.truncate(0).await {
@@ -468,6 +482,9 @@ impl Inner {
                     Err(errno) => return reply.error(errno),
                 }
             } else {
+                if let Err(errno) = self.reclaim_clean_before_open(id).await {
+                    return reply.error(errno);
+                }
                 let file = match self.mount.open_node(id, true).await {
                     Ok(file) => file,
                     Err(error) => return reply.error(runtime_errno(&error)),
@@ -520,6 +537,9 @@ impl Inner {
                     };
                     open.file.set_executable(executable).await
                 } else {
+                    if let Err(errno) = self.reclaim_clean_before_open(id).await {
+                        return reply.error(errno);
+                    }
                     let file = match self.mount.open_node(id, true).await {
                         Ok(file) => file,
                         Err(error) => return reply.error(runtime_errno(&error)),
@@ -596,6 +616,9 @@ impl Inner {
             Err(error) => return reply.error(runtime_errno(&error)),
         };
         let node = node.expect("create resolved a node id");
+        if let Err(errno) = self.reclaim_clean_before_open(node).await {
+            return reply.error(errno);
+        }
         let open = match self
             .mount
             .open_node(node, writable_open(OpenFlags(flags)))
@@ -1346,6 +1369,7 @@ impl Filesystem for FuseFrontend {
 mod tests {
     use super::*;
     use crate::core::{BackendProfile, Fs};
+    use crate::runtime::Runtime;
     use crate::support::TestBackend;
     use std::sync::Arc;
     use yinyang_core::Authority;
@@ -1380,4 +1404,52 @@ mod tests {
         assert_eq!(attr.size, 5);
         assert_eq!(attr.ino, inner.inode_for(id, None).unwrap());
     }
+
+    #[tokio::test]
+    async fn open_reclaims_stale_clean_version_after_transient_busy() {
+        let temp = tempfile::tempdir().unwrap();
+        let backend = TestBackend::default();
+        let authority: Arc<dyn Authority> = Arc::new(
+            Fs::create(backend.operator(), BackendProfile::Minio)
+                .await
+                .unwrap(),
+        );
+        let writer = Runtime::open(authority.clone(), temp.path().join("writer"))
+            .await
+            .unwrap();
+        writer.create_file(authority.root(), "file").await.unwrap();
+        let mut file = writer.open_file("file", true).await.unwrap();
+        file.write(0, b"first").await.unwrap();
+        file.close().await.unwrap();
+        drop(writer);
+        let id = authority
+            .observe_latest()
+            .await
+            .unwrap()
+            .resolve("file")
+            .await
+            .unwrap()
+            .unwrap()
+            .id();
+
+        let mount = Mount::open(authority.clone(), temp.path().join("mount"), false)
+            .await
+            .unwrap();
+        let inner = Inner::with_read_only(mount, tokio::runtime::Handle::current(), false);
+        let pinned = inner.mount.open_node(id, false).await.unwrap();
+        inner.reclaim_clean_before_open(id).await.unwrap();
+        assert!(inner.mount.node_status(id).await.unwrap().is_some());
+        drop(pinned);
+        inner.reclaim_clean_before_open(id).await.unwrap();
+        assert!(inner.mount.node_status(id).await.unwrap().is_none());
+
+        let writer = Runtime::open(authority.clone(), temp.path().join("writer2"))
+            .await
+            .unwrap();
+        let mut file = writer.open_node(id, true).await.unwrap();
+        file.write(0, b"second").await.unwrap();
+        file.close().await.unwrap();
+        let fresh = inner.mount.open_node(id, false).await.unwrap();
+        assert_eq!(fresh.read(0, 6).await.unwrap(), b"second");
+    }
 }