NOMBRE

       flock - impone o elimina un bloqueo de recomendación en un archivo abierto.

BIBLIOTECA

       Biblioteca Estándar C (libc, -lc)

SINOPSIS

       #include <sys/file.h>

       int flock(int fd, int operation);

DESCRIPCIÓN

       Impone  o  elimina  un  bloqueo  de recomendación (advisory lock) sobre el fichero abierto
       especificado por fd.  El parámetro operation puede tener uno de los siguientes valores:

           LOCK_SH  Pone un bloqueo compartido.   Más  de  un  proceso  puede  tener  un  bloqueo
                    compartido para un fichero en un momento dado.

           LOCK_EX  Pone  un  bloqueo  exclusivo.   Solamente  un  proceso puede tener un bloqueo
                    exclusivo para un fichero en un momento dado.

           LOCK_UN  Elimina un bloqueo existente mantenido por este proceso.

       Una llamada a flock()  puede bloquearse si otro proceso mantiene un bloqueo  incompatible.
       Para  hacer  una  solicitud  no  bloqueante, incluya LOCK_NB (mediante operaciones OR) con
       cualquiera de las operaciones de arriba.

       Un fichero no puede tener simultaneamente bloqueo compartido y exclusivo.

       Locks created by flock()  are associated with an  open  file  description  (see  open(2)).
       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  file
       descriptors.  Furthermore, the lock is released either by an explicit LOCK_UN operation on
       any of these duplicate file descriptors, or when  all  such  file  descriptors  have  been
       closed.

       If  a  process  uses open(2)  (or similar) to obtain more than one file descriptor for the
       same file, these file descriptors are treated independently by  flock().   An  attempt  to
       lock the file using one of these file descriptors may be denied by a lock that the calling
       process has already placed via another file descriptor.

       Un proceso puede tener solamente un tipo de bloqueo  (compartido  o  exclusivo)  sobre  un
       fichero.  Las llamadas posteriores a flock()  sobre un fichero ya bloqueado convertirán un
       bloqueo existente al nuevo modo de bloqueo.

       Los bloqueos creados con flock()  se preservan tras un execve(2).

       Un bloqueo compartido o exclusivo puede ponerse sobre un fichero sin importar el  modo  en
       el que fue abierto dicho fichero.

VALOR DEVUELTO

       En  caso  de éxito se devuelve cero. En caso de error se devuelve -1, y errno se configura
       para indicar el error.

ERRORES

       EBADF  fd no es un descriptor de archivos abiertos.

       EINTR  Mientras se esperaba por adquirir un bloqueo, la llamada fue  interrumpida  por  la
              notificación de una señal atrapada por un manejador; vea signal(7).

       EINVAL operation no es válido.

       ENOLCK El núcleo se quedó sin memoria para almacenar registros de bloqueos.

       EWOULDBLOCK
              El fichero está encadenado y la bandera LOCK_NB ha sido elegida.  TP EBADF fd no es
              un descriptor de fichero abierto.

ESTÁNDARES

       4.4BSD (la llamada al sistema flock()  apareció por primera vez en 4.2BSD).   Una  versión
       de  flock(),  posiblemente  implementada en términos de fcntl(2), aparece en la mayoría de
       UNIX's.

NOTAS

       Since Linux 2.0, flock()  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).  With this implementation,
       there is no interaction between the types of lock placed by  flock()   and  fcntl(2),  and
       flock()   does  not  detect  deadlock.   (Note, however, that on some systems, such as the
       modern BSDs, flock()  and fcntl(2)  locks do interact with one another.)

       flock()  coloca bloqueos de recomendación solamente; con los permisos adecuados  sobre  un
       fichero,  un  proceso  es  libre  de  ignorar  el  uso de flock()  y realizar E/S sobre el
       fichero.

       flock()  and fcntl(2)  locks have different semantics with respect to forked processes and
       dup(2).  On systems that implement flock()  using fcntl(2), the semantics of flock()  will
       be different from those described in this manual page.

       Converting a lock (shared to exclusive, or vice versa) is not guaranteed to be atomic: the
       existing  lock  is  first  removed, and then a new lock is established.  Between these two
       steps, a pending lock request by another process may be granted, with the result that  the
       conversion  either  blocks,  or fails if LOCK_NB was specified.  (This is the original BSD
       behavior, and occurs on many other implementations.)

   Detalles de NFS
       Up to Linux 2.6.11, flock()  does not lock files over NFS (i.e., the scope  of  locks  was
       limited  to the local system).  Instead, one could use fcntl(2)  byte-range locking, which
       does work over NFS, given a sufficiently recent  version  of  Linux  and  a  server  which
       supports locking.

       Since  Linux  2.6.12,  NFS  clients  support  flock()  locks by emulating them as fcntl(2)
       byte-range locks on the entire file.  This means that  fcntl(2)   and  flock()   locks  do
       interact  with  one  another  over NFS.  It also means that in order to place an exclusive
       lock, the file must be opened for writing.

       Since Linux 2.6.37, the kernel supports a compatibility mode that  allows  flock()   locks
       (and  also  fcntl(2)  byte region locks) to be treated as local; see the discussion of the
       local_lock option in nfs(5).

   Detalles de CIFS
       A partir de la versión 5.4, flock() no se  despliega  sobre  SMB.  Un  archivo  con  estos
       bloqueos, no aparecerá bloqueado para usuarios remotos.

       Since Linux 5.5, flock()  locks are emulated with SMB byte-range locks on the entire file.
       Similarly to NFS, this means that fcntl(2)  and flock()  locks interact with one  another.
       Another  important  side-effect  is  that  the locks are not advisory anymore: any IO on a
       locked file will always fail with EACCES when done from a separate file descriptor.   This
       difference  originates  from  the  design  of  locks  in  the SMB protocol, which provides
       mandatory locking semantics.

       Remote and mandatory locking semantics may vary  with  SMB  protocol,  mount  options  and
       server type.  See mount.cifs(8)  for additional information.

VÉASE TAMBIÉN

       flock(1), close(2), dup(2), execve(2), fcntl(2), fork(2), open(2), lockf(3), lslocks(8)

       Documentation/filesystems/locks.txt     in     the     Linux     kernel     source    tree
       (Documentation/locks.txt in older kernels)

TRADUCCIÓN

       La traducción al español de esta página del  manual  fue  creada  por  Gerardo  Aburruzaga
       García <gerardo.aburruzaga@uca.es>, Juan Piernas <piernas@ditec.um.es>, Miguel Pérez Ibars
       <mpi79470@alu.um.es> y Marcos Fouces <marcos@debian.org>

       Esta traducción es documentación libre; lea  la  GNU  General  Public  License  Version  3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  o posterior con respecto a las condiciones de
       copyright.  No existe NINGUNA RESPONSABILIDAD.

       Si encuentra algún error en la traducción de esta  página  del  manual,  envíe  un  correo
       electrónico a ⟨debian-l10n-spanish@lists.debian.org⟩.