`File::lock` does not work on Android

[RalfJung]

Currently, our lock method just always errors on Android.

However, the libc crate does expose flock on Android, and cargo-bins/cargo-binstall#2330 sounds like there is support for flock on Android with fs4, at least for some Android versions.

We should figure out which Android versions have flock, and whether we can use that for the standard library API.

(Also see #146312 which is a similar issue for Illumos.)

Cc @chriswailes @maurer @mgeisler @tgross35

[Jisu-Woniu]

From my post at https://internals.rust-lang.org/t/is-file-lock-really-unsupported-on-android/23711:

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, just like the one for Solaris. As in etcd-io/bbolt#558 and etcd-io/bbolt#571, although this is a Golang library using syscall package.

[rammaruboina-rgb]

Proposed Implementation: Android File Lock Support using fcntl

I'd like to contribute a solution for this issue. After analyzing the problem and reviewing @Jisu-Woniu's findings, I propose implementing file locking on Android using fcntl() with F_SETLKW, which provides reliable cross-version support.

Implementation Approach

Option 1: Use fcntl() for Android (Recommended)

Similar to the Solaris implementation, we can use fcntl() which works reliably across Android versions, including Android 14+ where flock() syscall support is inconsistent.

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

// Around line 1302 - Add Android to fcntl-based implementation
pub fn lock(&self) -> io::Result<()> {
    #[cfg(not(any(
        target_os = "android",  // Add Android here
        target_os = "solaris",
        target_os = "illumos",
    )))]
    {
        cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX) })?;
    }
    
    #[cfg(any(
        target_os = "android",  // Add Android here
        target_os = "solaris",
        target_os = "illumos",
    ))]
    {
        // Use fcntl-based locking for Android
        let mut flock = libc::flock {
            l_type: libc::F_WRLCK as libc::c_short,
            l_whence: libc::SEEK_SET as libc::c_short,
            l_start: 0,
            l_len: 0,
            l_pid: 0,
        };
        cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLKW, &flock) })?;
    }
    
    return Ok(());
}

pub fn try_lock(&self) -> Result<(), TryLockError> {
    #[cfg(not(any(
        target_os = "android",
        target_os = "solaris",
        target_os = "illumos",
    )))]
    {
        let ret = cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) });
        // ... rest of implementation
    }
    
    #[cfg(any(
        target_os = "android",
        target_os = "solaris",
        target_os = "illumos",
    ))]
    {
        let mut flock = libc::flock {
            l_type: libc::F_WRLCK as libc::c_short,
            l_whence: libc::SEEK_SET as libc::c_short,
            l_start: 0,
            l_len: 0,
            l_pid: 0,
        };
        let ret = cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLK, &flock) });
        match ret {
            Ok(_) => Ok(()),
            Err(e) if e.raw_os_error() == Some(libc::EACCES) || 
                      e.raw_os_error() == Some(libc::EAGAIN) => {
                Err(TryLockError::WouldBlock)
            }
            Err(e) => Err(TryLockError::Error(e)),
        }
    }
}

pub fn lock_shared(&self) -> io::Result<()> {
    #[cfg(not(any(
        target_os = "android",
        target_os = "solaris",
        target_os = "illumos",
    )))]
    {
        cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_SH) })?;
    }
    
    #[cfg(any(
        target_os = "android",
        target_os = "solaris",
        target_os = "illumos",
    ))]
    {
        let mut flock = libc::flock {
            l_type: libc::F_RDLCK as libc::c_short,
            l_whence: libc::SEEK_SET as libc::c_short,
            l_start: 0,
            l_len: 0,
            l_pid: 0,
        };
        cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLKW, &flock) })?;
    }
    
    return Ok(());
}

pub fn unlock(&self) -> io::Result<()> {
    #[cfg(not(any(
        target_os = "android",
        target_os = "solaris",
        target_os = "illumos",
    )))]
    {
        cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_UN) })?;
    }
    
    #[cfg(any(
        target_os = "android",
        target_os = "solaris",
        target_os = "illumos",
    ))]
    {
        let mut flock = libc::flock {
            l_type: libc::F_UNLCK as libc::c_short,
            l_whence: libc::SEEK_SET as libc::c_short,
            l_start: 0,
            l_len: 0,
            l_pid: 0,
        };
        cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLK, &flock) })?;
    }
    
    return Ok(());
}

Why fcntl() over flock()?

1. Reliability: As noted by @Jisu-Woniu, fcntl with F_SETLKW works consistently across Android versions
2. Android 14+ compatibility: Some Android 14+ devices don't support flock() syscall
3. POSIX compliance: fcntl() is more portable and follows POSIX standards
4. Proven approach: Already working in Go's bbolt library and similar projects

Testing Plan

1. Test on Android API levels 21-34 (covers Android 5.0 to Android 14)
2. Test both exclusive and shared locks
3. Test try_lock variants
4. Verify unlock behavior
5. Test cross-process locking scenarios

Benefits

• Fixes cargo-binstall, uv, termux-packages, and other affected projects
• Aligns with Google's Rust adoption in Android
• Provides consistent behavior across Android versions
• No external dependencies needed

Next Steps

I'm happy to:

1. Implement this solution in a PR
2. Add comprehensive tests for Android
3. Update documentation

Let me know if this approach looks good, or if you'd prefer alternative implementation! I can start working on the PR immediately.

cc @chriswailes @maurer @mgeisler @tgross35

[tgross35]

Yes I think it is fine to use fnctl, though we will need to double check with the maintainers before merging (we'll ping them on the PR). Please don't use AI-generated reports to ask simple things, it's so time consuming to read through the fluff to find what is a yes-or-no question.

[maurer]

As far as I can tell, we have supported flock forever in Android. However, it appears that the emulated filesystem used by MediaProvider does not.

For regular files (e.g. ones that don't have /emulated/ in their path), flock should work fine.

For files which have /emulated/ I think but have not verified that fcntl is not actually working either, as setlk and getlk are not implemented. fcntl is just failing to emit an error in that case.

Basically, my current unsatisfying answer is:

1. I think flock works in most places, but not in some places that an app might want to try it (namely a media directory).
2. I think that fcntl when routed through FUSE is giving you a false success - it'll tell you the file is locked, but I don't think it's locking anyone else out.

I need to double check that point 2 is true, but based on that, I think we ought to use flock, with the unfortunate situation that /emulated/ paths can't be locked, as it's worse to tell someone something is locked when it isn't than to fail the call.