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");
+ }
}