flock vs lockf on Linux

by

The practical difference between flock() and lockf() is in the semantics (behaviour with respect to closing and passing), applicability over NFS and other shared filesystems, and whether the advisory locks are visible to other processes using fcntl() locks or not.

The library you’re using simply has logic to pick the desired semantics based on the current platform.

If the semantics (behaviour over descriptor passing, forking, etc.) is acceptable, you should prefer lockf()/fcntl() locks over flock() locks in Linux, simply because the former works on NFS etc. filesystems, whereas the latter does not. (On BSDs and Mac OS X, I believe you need to explicitly use fcntl(), instead.)

In Linux, lockf() is just a wrapper around fcntl(), while flock() locks are separate (and will only work on local filesystems, not on e.g. NFS mounts on kernels prior to 2.6.12). That is, one process can have an advisory exclusive flock() lock on a file, while another process has an advisory exclusive fcntl() lock on that same file. Both are advisory locks, but they do not interact.

On Mac OS X and FreeBSD, lockf()/flock()/fcntl() locks all interact, although developers are recommended to use only one of the interfaces in an application. However, only fcntl() locks work on NFS mounts (and, obviously, only if both NFS client and server have been configured to support record locks, which is surprisingly rare in e.g. web hosting environments; a huge cause of headaches for some web (framework) developers).

POSIX does not explicitly specify how lockf()/flock()/fcntl() locks should interact, and there have been differences in the past. Now, the situation has calmed down a bit, and one can approximately say that

  1. fcntl() locks are the most reliable

    Across architectures, they have the best chance of working right on e.g. shared filesystems — NFS and CIFS mounts, for example.

  2. Most often, lockf() is implemented as “shorthand” for fcntl()

    The other alternative, as “shorthand” for flock(), is possible, but nowadays rare.

  3. fcntl() and flock() have different semantics wrt. inheritance and automatic releases

    fcntl() locks are preserved across an exec(), but not inherited across a fork(). The locks are released when the owning process closes any descriptor referring to the same file.

    In Linux, FreeBSD, and MAc OS X, flock() locks are coupled with the open file descriptor: passing the descriptor also passes the lock. (The man pages state that “the lock is on the file, not on the file descriptor”. This is not a contradiction. It just means that the lock applies to the file. It is still coupled to the descriptor, in such a way that duplicating the descriptor also passes the same lock, too.) Therefore, it is possible that multiple processes have the same exclusive advisory flock() lock on the same file at the same time, if they obtained the descriptor from the originator after the flock() call.

File locking is surprisingly complicated issue. I have personally had best results by simply sticking to fcntl() locking. The semantics wrt. fcntl() locks are not the easiest to work with, and in certain cases can be frankly infuriating; it’s just that I’ve found it to yield the best — most reliable, most portable, least surprising — results.

More Related Contents:

  1. fcntl, lockf, which is better to use for file locking?
  2. what the output of this code and why?
  3. printf anomaly after “fork()”
  4. How to make child process die after parent exits?
  5. What is time_t ultimately a typedef to?
  6. How to calculate the CPU usage of a process by PID in Linux from C?
  7. What is the equivalent to Posix popen() in the Win32 API?
  8. How do I execute an external program within C code in Linux with arguments?
  9. Measure time in Linux – time vs clock vs getrusage vs clock_gettime vs gettimeofday vs timespec_get?
  10. stdout thread-safe in C on Linux?
  11. Is malloc/free a syscall or a library routine provided by libc?
  12. Building a kernel module from several source files which one of them has the same name as the module
  13. What parts of this HelloWorld assembly code are essential if I were to write the program in assembly?
  14. Are file descriptors shared when fork()ing?
  15. Detecting 64bit compile in C
  16. how to call function in executable from my library?
  17. How does sig_atomic_t actually work?
  18. Interprocess mutex with pthreads
  19. How to make backtrace()/backtrace_symbols() print the function names?
  20. Write to .txt file?
  21. Do forked child processes use the same semaphore?
  22. Implementation of multiple pipes in C
  23. Force free() to return malloc memory back to OS
  24. Sharing memory between processes through the use of mmap()
  25. In C, what’s the size of stdout buffer?
  26. What API do I call to get the system uptime?
  27. Where are syscalls located in glibc source
  28. Linux function to get mount points
  29. multiple threads able to get flock at the same time
  30. How to know if a Linux system call is restartable or not?

Leave a Comment