Is `File::lock` really unsupported on Android?

Jisu-Woniu · November 13, 2025, 5:13am

I was gathering information for an error in uv on Termux, Android (as in astral-sh/uv#16707):

error: failed to lock `/data/data/com.termux/file/home/.local/share/uv/tools/.lock`: lock() not supported

I think it may rise from this function call in uv:

github.com/astral-sh/uv

crates/uv-fs/src/lib.rs

88811553e


      
                  }
                  Err(err) => {
                      // Log error code and enum kind to help debugging more exotic failures.
                      if !is_known_already_locked_error(&err) {
                          debug!("Try lock error: {err:?}");
                      }
                      info!(
                          "Waiting to acquire lock for `{resource}` at `{}`",
                          file.path().user_display(),
                      );
                      file.lock()?;
                      debug!("Acquired lock for `{resource}`");
                      Ok(Self(file))
                  }
              }
          }
          
          /// Inner implementation for [`LockedFile::acquire_no_wait`].
          fn lock_file_no_wait(file: fs_err::File, resource: &str) -> Option<Self> {
              trace!(
                  "Checking lock for `{resource}` at `{}`",

However, it is surprising to me that Android has no support for File::lock.

github.com/rust-lang/rust

library/std/src/sys/fs/unix.rs

01867557c


      
          #[cfg(any(
              target_os = "freebsd",
              target_os = "fuchsia",
              target_os = "linux",
              target_os = "netbsd",
              target_os = "openbsd",
              target_os = "cygwin",
              target_os = "illumos",
              target_os = "aix",
              target_vendor = "apple",
          ))]
          pub fn lock(&self) -> io::Result<()> {
              cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX) })?;
              return Ok(());
          }
          
          #[cfg(target_os = "solaris")]
          pub fn lock(&self) -> io::Result<()> {
              let mut flock: libc::flock = unsafe { mem::zeroed() };
              flock.l_type = libc::F_WRLCK as libc::c_short;

This file has been truncated. show original

There are reports that some Android 14 or above doesn't support flock syscall (however all my devices support it), but a fcntl with param F_SETLKW seems work. As in etcd-io/bbolt#558 and etcd-io/bbolt#571, although this is a Golang library using syscall package.

Just a question, why is Android considered unsupported in File::lock implementation? Is it possible to support it in the future?

kornel · November 13, 2025, 11:24am

It's a relatively new function, so the implementation is probably just unfinished.

You could help by submitting a PR to the standard library.

chrisd · November 13, 2025, 2:56pm

In short it's unsupported because nobody has added support for it yet. If you'd like to help then there's an issue open: `File::lock` does not work on Android · Issue #148325 · rust-lang/rust · GitHub

Topic		Replies	Views
No longer possible to exercise system call failure due to EBADF libs	14	784	September 21, 2024
`lock_api::RawMutex` implementation based on `std` libs	5	210	November 25, 2025
Expose path in File libs	14	766	October 4, 2024
`fs::read_dir` can't read directory entries with very long names libs	18	3834	January 23, 2022
Where to include "access" unix function in Rust API libs	6	2066	March 25, 2019

Is `File::lock` really unsupported on Android?

Related topics