implement flock

Author: vgough

Cargo.lock

@@ -40,12 +40,19 @@ reference workload that fails.
   RMW in `write_impl`, `do_truncate`, `truncate_expand`, `truncate_shrink`, and
   `copy_file_with_header_rewrite` (read lock for `read_impl`).
 
-- [ ] **2. POSIX/BSD locks don't actually lock.**
-  `flock(2)` is never forwarded (typed-fuse leaves `ops.flock` unset), so `flock()`
-  is a no-op success and two cargos can hold the registry cache lock
-  "simultaneously". `fcntl` locks are forwarded (src/fs.rs:1670-1691) but each
-  `open` creates a new backing fd. Fix: implement `flock` in the typed-fuse fork and
-  pass through to the backing fd.
+- [x] **2. POSIX/BSD locks don't actually lock.**
+  Fixed: the typed-fuse fork now has an opt-in `flock` callback, wired through
+  its session, runtime, node trait, and path adapter. `EncFs` opts in and passes
+  each operation through to `flock(2)` on that open handle's backing fd, so the
+  backing filesystem preserves BSD open-file-description lock semantics.
+
+  POSIX record locks remain kernel-managed: EncFS deliberately does not enable
+  `FUSE_POSIX_LOCKS`, because forwarding every client's `fcntl` locks from the
+  daemon process would merge their process identities and produce incorrect
+  close/unlock behavior.
+
+  Regression coverage includes a mountless two-handle test and a live,
+  cross-process FUSE test in `tests/flock_test.rs` and `tests/live_mount.rs`.
 
 - [ ] **3. `fsync`/`flush`/`fdatasync` are silent no-ops.**
   The `PathFilesystem` defaults return `Ok(())` and `EncFs` doesn't override

TODO.md

@@ -1710,6 +1710,7 @@ impl PathFilesystem for EncFs {
     // of the INIT reply, so the kernel enforces locks locally with the right
     // per-process semantics.
     const SUPPORTS_POSIX_LOCKS: bool = false;
+    const SUPPORTS_FLOCK: bool = true;
     const SUPPORTS_READDIRPLUS: bool = true;
 
     fn init(&self, _conn: &mut typed_fuse::ConnInfo) {
@@ -1917,6 +1918,21 @@ impl PathFilesystem for EncFs {
         Ok(self.write_impl(handle, offset, data)? as usize)
     }
 
+    fn flock(
+        &self,
+        _path: Option<&Path>,
+        handle: &FileHandle,
+        operation: i32,
+        _caller: &Request,
+    ) -> Result<(), Errno> {
+        let result = unsafe { libc::flock(handle.file.as_raw_fd(), operation) };
+        if result == 0 {
+            Ok(())
+        } else {
+            Err(std::io::Error::last_os_error().into())
+        }
+    }
+
     fn create(
         &self,
         parent: &Path,

src/fs.rs

@@ -0,0 +1,70 @@
+use encfs::config::Interface;
+use encfs::crypto::ssl::SslCipher;
+use encfs::fs::EncFs;
+use std::ffi::OsStr;
+use std::path::Path;
+use tempfile::TempDir;
+use typed_fuse::{Caller, Errno, PathFilesystem};
+
+fn caller() -> Caller {
+    Caller {
+        pid: 1,
+        gid: 0,
+        uid: 0,
+        umask: 0,
+    }
+}
+
+fn make_fs(root: &Path) -> EncFs {
+    let iface = Interface {
+        name: "ssl/aes".to_string(),
+        major: 3,
+        minor: 0,
+        age: 0,
+    };
+    let mut cipher = SslCipher::new(&iface, 192).unwrap();
+    cipher.set_key(&[1u8; 24], &[2u8; 16]);
+    EncFs::new(
+        root.to_path_buf(),
+        Box::new(cipher),
+        encfs::config::EncfsConfig::test_default(),
+    )
+}
+
+#[test]
+fn flock_is_forwarded_to_each_backing_file_description() {
+    let tmp = TempDir::new().unwrap();
+    let fs = make_fs(tmp.path());
+    let caller = caller();
+    let parent = Path::new("");
+    let name = OsStr::new("locked");
+    let path = parent.join(name);
+
+    let (_, created) = fs
+        .create(parent, name, 0o644, 0, libc::O_RDWR, &caller)
+        .unwrap();
+    fs.release(Some(&path), created.handle, &caller).unwrap();
+
+    let first = fs.open(&path, libc::O_RDWR, &caller).unwrap().handle;
+    let second = fs.open(&path, libc::O_RDWR, &caller).unwrap().handle;
+
+    fs.flock(Some(&path), &first, libc::LOCK_EX | libc::LOCK_NB, &caller)
+        .unwrap();
+    let error = fs
+        .flock(Some(&path), &second, libc::LOCK_EX | libc::LOCK_NB, &caller)
+        .unwrap_err();
+    assert!(
+        error == Errno::from_raw(libc::EAGAIN) || error == Errno::from_raw(libc::EWOULDBLOCK),
+        "second open unexpectedly acquired the lock: {error}"
+    );
+
+    fs.flock(Some(&path), &first, libc::LOCK_UN, &caller)
+        .unwrap();
+    fs.flock(Some(&path), &second, libc::LOCK_EX | libc::LOCK_NB, &caller)
+        .unwrap();
+    fs.flock(Some(&path), &second, libc::LOCK_UN, &caller)
+        .unwrap();
+
+    fs.release(Some(&path), first, &caller).unwrap();
+    fs.release(Some(&path), second, &caller).unwrap();
+}

tests/flock_test.rs

@@ -835,6 +835,82 @@ fn live_cross_process_posix_locks() -> Result<()> {
     Ok(())
 }
 
+#[test]
+#[ignore]
+fn live_flock_child() -> Result<()> {
+    let Some(path) = std::env::var_os("ENCFS_FLOCK_CHILD_PATH") else {
+        return Ok(());
+    };
+    let expect_blocked = std::env::var_os("ENCFS_FLOCK_EXPECT_BLOCKED").is_some();
+    let file = OpenOptions::new().read(true).write(true).open(path)?;
+    let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
+    let result = if result == 0 {
+        Ok(())
+    } else {
+        Err(std::io::Error::last_os_error())
+    };
+    match (result, expect_blocked) {
+        (Err(error), true)
+            if error.raw_os_error() == Some(libc::EAGAIN)
+                || error.raw_os_error() == Some(libc::EWOULDBLOCK) =>
+        {
+            Ok(())
+        }
+        (Ok(()), false) => Ok(()),
+        (result, expected) => {
+            anyhow::bail!("unexpected child flock result {result:?}; expected blocked={expected}")
+        }
+    }
+}
+
+#[test]
+#[ignore]
+fn live_cross_process_flock() -> Result<()> {
+    require_live();
+    if !live_enabled() {
+        return Ok(());
+    }
+    let cfg = load_live_config(live::LiveConfigKind::Standard)?;
+    let mount = MountGuard::mount(cfg, false)?;
+    let path = mount.mount_point.join("flocked.txt");
+    fs::write(&path, b"locked")?;
+    let file = OpenOptions::new().read(true).write(true).open(&path)?;
+    let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
+    if result == -1 {
+        return Err(std::io::Error::last_os_error()).context("parent flock failed");
+    }
+
+    let child = |expect_blocked: bool| -> Result<()> {
+        let mut command = Command::new(std::env::current_exe()?);
+        command
+            .arg("--exact")
+            .arg("live_flock_child")
+            .arg("--ignored")
+            .arg("--test-threads=1")
+            .env("ENCFS_FLOCK_CHILD_PATH", &path);
+        if expect_blocked {
+            command.env("ENCFS_FLOCK_EXPECT_BLOCKED", "1");
+        }
+        let output = command.output()?;
+        anyhow::ensure!(
+            output.status.success(),
+            "flock-check child failed (expect_blocked={expect_blocked}): {}\nstdout:\n{}\nstderr:\n{}",
+            output.status,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+        Ok(())
+    };
+
+    child(true)?;
+    let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_UN) };
+    if result == -1 {
+        return Err(std::io::Error::last_os_error()).context("parent flock unlock failed");
+    }
+    child(false)?;
+    Ok(())
+}
+
 #[test]
 #[ignore]
 fn live_chmod_utimens_statfs() -> Result<()> {