FLOCK(2)                   Linux Programmer's Manual                  FLOCK(2)

       flock - apply or remove an advisory lock on an open file

       #include <sys/file.h>

       int flock(int fd, int operation);

       Apply or remove an advisory lock on the open file specified by fd.  The
       parameter operation is one of the following:

              LOCK_SH   Place a shared lock.  More than one process may hold a
                        shared lock for a given file at a given time.

              LOCK_EX   Place an exclusive lock.  Only one process may hold an
                        exclusive lock for a given file at a given time.

              LOCK_UN   Remove an existing lock held by this process.

       A call to flock() may block if an incompatible lock is held by  another
       process.   To  make  a non-blocking request, include LOCK_NB (by ORing)
       with any of the above operations.

       A single file may not simultaneously have  both  shared  and  exclusive

       Locks  created  by  flock()  are  associated with a file, or, more pre-
       cisely, an open file table  entry.   This  means  that  duplicate  file
       descriptors  (created  by, for example, fork(2) or dup(2)) refer to the
       same lock, and this lock may be modified or released using any of these
       descriptors.   Furthermore,  the lock is released either by an explicit
       LOCK_UN operation on any of these duplicate descriptors,  or  when  all
       such descriptors have been closed.

       A  process  may  only  hold one type of lock (shared or exclusive) on a
       file.  Subsequent flock() calls on an already locked file will  convert
       an existing lock to the new lock mode.

       Locks created by flock() are preserved across an execve(2).

       A  shared  or  exclusive lock can be placed on a file regardless of the
       mode in which the file was opened.

       On success, zero is returned.  On error, -1 is returned, and  errno  is
       set appropriately.

              The file is locked and the LOCK_NB flag was selected.

       EBADF  fd is not a not an open file descriptor.

       EINTR  While  waiting  to  acquire  a lock, the call was interrupted by
              delivery of a signal caught by a handler.

       EINVAL operation is invalid.

       ENOLCK The kernel ran out of memory for allocating lock records.

       4.4BSD (the flock(2) call first appeared  in  4.2BSD).   A  version  of
       flock(2),  possibly  implemented  in terms of fcntl(2), appears on most

       flock(2) does not lock files over NFS.  Use fcntl(2) instead: that does
       work  over  NFS,  given  a  sufficiently  recent version of Linux and a
       server which supports locking.

       Since kernel 2.0, flock(2) is implemented as a system call in  its  own
       right  rather  than  being  emulated  in the GNU C library as a call to
       fcntl(2).  This yields true BSD  semantics:  there  is  no  interaction
       between the types of lock placed by flock(2) and fcntl(2), and flock(2)
       does not detect deadlock.

       flock(2) places advisory locks only; given suitable  permissions  on  a
       file,  a  process is free to ignore the use of flock(2) and perform I/O
       on the file.

       flock(2) and fcntl(2) locks have different semantics  with  respect  to
       forked processes and dup(2).

       open(2), close(2), dup(2), execve(2), fcntl(2), fork(2), lockf(3)

       There are also locks.txt and mandatory.txt in /usr/src/linux/Documenta-

Linux                             2002-04-24                          FLOCK(2)