Provided by: manpages-fr-dev_3.65d1p1-1_all bug

NOM

       fcntl - Manipuler un descripteur de fichier

SYNOPSIS

       #include <unistd.h>
       #include <fcntl.h>

       int fcntl(int fd, int cmd, ... /* arg */ );

DESCRIPTION

       fcntl()  permet  de  se  livrer  à  diverses  opérations sur le descripteur de fichier fd.
       L'opération en question est déterminée par la valeur de l'argument cmd.

       fcntl() prend un troisième paramètre optionnel.  La  nécessité  de  fournir  ce  paramètre
       dépend  de  cmd. le paramètre doit être du type indiqué entre parenthèses après chaque nom
       de commande cmd (dans la plupart des cas, le type requis est un int, et le  paramètre  est
       identifié  en  utilisant  le  nom  arg),  ou  void  est  indiqué si le paramètre n'est pas
       nécessaire.

   Dupliquer un descripteur de fichier
       F_DUPFD (int)
              Trouver le plus petit numéro de descripteur libre supérieur ou égal  à  arg  et  le
              transformer  en  copie de fd. Ceci est différent de dup2(2), qui utilise exactement
              le descripteur transmis.

              En cas de réussite, le nouveau descripteur est renvoyé.

              Consultez dup(2) pour plus d'informations.

       F_DUPFD_CLOEXEC (int ; depuis Linux 2.6.24)
              Comme pour F_DUPFD, mais positionne en plus l'attribut  « close-on-exec »  pour  le
              descripteur  dupliqué.  Indiquer cet attribut permet d'éviter une opération F_SETFD
              de  fcntl()  supplémentaire  pour  positionner  l'attribut  FD_CLOEXEC.  Pour   une
              explication  sur  ce  en  quoi  cet attribut est utile, consultez la description de
              O_CLOEXEC dans open(2).

   Attributs du descripteur de fichier
       Les commandes suivantes manipulent les attributs associés à  un  descripteur  de  fichier.
       Actuellement,  un  seul attribut est défini : il s'agit de FD_CLOEXEC, l'attribut « close‐
       on‐exec ». Si le bit FD_CLOEXEC est 0, le descripteur de fichier reste ouvert  au  travers
       d'un execve(2), autrement il sera fermé.

       F_GETFD (void)
              Lire les attributs du descripteur de fichier ; arg est ignoré.

       F_SETFD (int)
              Positionner  les  attributs  du  descripteur de fichier avec la valeur précisée par
              arg.

       Dans un programme multithreadé, l'utilisation simultanée dans un thread  de  fcntl()  avec
       F_SETFD  afin de définir l'attribut « close-on-exec » (FD_CLOEXEC), et de fork(2) suivi de
       execve(2) dans un autre thread rend le programme vulnérable à une condition de concurrence
       pouvant  provoquer  la  fuite  du descripteur de fichier vers le programme exécuté dans le
       processus fils. Consultez les détails de l'attribut O_CLOEXEC dans open(2)  qui  décrivent
       une solution à ce problème.

   Attribut d'état du fichier
       Un  descripteur  de  fichier  dispose  de  certains  attributs, initialisés par open(2) et
       éventuellement modifiés  par  fcntl().  Les  attributs  sont  partagés  entre  les  copies
       (obtenues avec dup(2), fcntl(F_DUPFD), fork(2), etc.) du même descripteur de fichier.

       Les attributs et leurs sémantiques sont décrits dans la page open(2).

       F_GETFL (void)
              Obtenir le mode d'accès et les attributs d'état du fichier ; arg est ignoré.

       F_SETFL (int)
              Positionner  les  nouveaux  attributs  pour  le  descripteur de fichier à la valeur
              indiquée par arg. Les bits de mode d'accès  (O_RDONLY,  O_WRONLY,  O_RDWR)  et  les
              attributs  de  création  (O_CREAT,  O_EXCL, O_NOCTTY, O_TRUNC) de arg sont ignorés.
              Sous Linux, cette  commande  ne  peut  changer  que  O_APPEND,  O_ASYNC,  O_DIRECT,
              O_NOATIME  et  O_NONBLOCK. Modifier les attributs O_DSYNC et O_SYNC est impossible,
              consultez BOGUES ci-dessous.

   Verrouillages coopératifs
       F_SETLK, F_SETLKW et F_GETLK servent  à  gérer  les  verrouillages  d'enregistrements  (de
       segments  ou de régions de fichiers). Le troisième argument, lock, est un pointeur sur une
       structure qui a au moins les champs suivants (dans un ordre non indiqué).

           struct flock {
               ...
               short l_type;    /* Type de verrouillage : F_RDLCK,
                                   F_WRLCK, F_UNLCK */
               short l_whence;  /* Interprétation de l_start:
                                   SEEK_SET, SEEK_CUR, SEEK_END */
               off_t l_start;   /* Décalage de début du verrouillage */
               off_t l_len;     /* Nombre d'octets du verrouillage */
               pid_t l_pid;     /* PID du processus bloquant notre verrou
                                   (F_GETLK seulement) */
               ...
           };

       Les champs l_whence, l_start et l_len de cette structure indiquent l'intervalle d'octets à
       verrouiller.  Des  octets  après  la  fin du fichier peuvent être verrouillé, mais pas des
       octets avant le début du fichier.

       l_start est la position de début du verrou, et est interprété de façon relative : au début
       du  fichier  (si  l_whence  vaut  SEEK_SET) ;  à  la position actuelle dans le fichier (si
       l_whence vaut SEEK_CUR) ; à la fin du fichier (si l_whence vaut SEEK_END). Dans  les  deux
       derniers  cas,  l_start  peut  être  un  nombre négatif, à partir du moment où la position
       fournie ne pointe pas avant le début du fichier.

       l_len indique le nombre d'octets à verrouiller. Si l_len est positif, alors l'intervalle à
       verrouiller  couvre  les  octets  à  partir  de  l_start jusqu'à l_start+l_len-1 (inclus).
       Indiquer 0 dans l_len a une signification particulière : cela verrouille tous les octets à
       partir  de  la position indiquée par l_whence et l_start jusqu'à la fin du fichier, quelle
       que soit la taille que prendra la fichier.

       POSIX.1-2001 permet (mais n'impose pas) à une implémentation  de  prendre  en  charge  des
       valeurs  de  l_len négatives ; si l_len est négatif, l'intervalle décrivant le verrou lock
       couvre les octets l_start+l_len jusqu'à l_start-1 inclus.  Ceci  est  supporté  par  Linux
       depuis les versions 2.4.21 et 2.5.49.

       Le  champ  l_type  peut  servir  à  placer  un  verrou en lecture (F_RDLCK) ou en écriture
       (F_WRLCK) sur un fichier. Un nombre quelconque de processus peuvent  tenir  un  verrou  en
       lecture  (partagé),  sur  une  région  d'un  fichier, mais un seul peut avoir un verrou en
       écriture (exclusif). Un verrou en écriture exclut tous les autres verrous, aussi  bien  en
       lecture  qu'en écriture. Un processus donné ne peut tenir qu'un seul verrou sur une région
       d'un fichier, si un nouveau verrou y est appliqué, alors le verrou précédent est  converti
       suivant  le nouveau type. Ceci peut entraîner le découpage, la réduction ou l'extension du
       verrou existant si le nombre d'octets du nouveau verrou ne coïncide  pas  exactement  avec
       celui de l'ancien.

       F_SETLK (struct flock *)
              Acquérir (si l_type vaut F_RDLCK ou F_WRLCK) ou libérer (si l_type vaut F_UNLCK) le
              verrou sur les octets indiqués par les champs l_whence, l_start, et l_len de  lock.
              Si  un conflit avec un verrou tenu par un autre processus existe, cet appel renvoie
              -1 et positionne errno aux valeurs EACCES ou EAGAIN.

       F_SETLKW (struct flock *)
              Comme F_SETLK, mais attend la libération du verrou au lieu de retourner une erreur.
              Si  un  signal  à intercepter est reçu pendant l'attente, l'appel est interrompu et
              renverra immédiatement (après retour du gestionnaire  de  signaux)  la  valeur  -1.
              errno sera remplie avec la valeur EINTR ; consultez signal(7).

       F_GETLK (struct flock *)
              En  entrée  dans cette routine, lock décrit un verrou que nous aimerions placer sur
              le fichier. Si le verrouillage est possible, fcntl() ne le fait pas,  mais  renvoie
              F_UNLCK  dans  le  champ l_type de lock et laisse les autres champs de la structure
              inchangés. Si un ou plusieurs  verrouillages  incompatibles  empêchaient  l'action,
              alors  fcntl()  renvoie  des  informations  sur l'un de ces verrous dans les champs
              l_type, l_whence, l_start, et l_len de  lock  et  remplit  l_pid  avec  le  PID  du
              processus  tenant le verrou. Notez que l'information renvoyée par F_GETLK peut être
              devenue obsolète au moment où l'appelant l'examine.

       Pour pouvoir placer un verrou en lecture, fd doit être ouvert au moins  en  lecture.  Pour
       placer  un verrou en écriture, fd doit être ouvert en écriture. Pour placer les deux types
       de verrous, il faut une ouverture en lecture/écriture.

       Outre la suppression par un F_UNLCK explicite, les verrous  sont  automatiquement  libérés
       lorsque  le  processus  se  termine,  ou  s'il  ferme l'un des descripteurs se référant au
       fichier sur lequel le verrou est placé. C'est dangereux : cela  signifie  qu'un  processus
       peut  perdre  un  verrou sur un fichier comme /etc/passwd ou /etc/mtab si, pour une raison
       quelconque, une fonction de bibliothèque décide de l'ouvrir puis de le refermer.

       Les verrouillages d'enregistrements ne sont pas hérités par les enfants lors d'un fork(2),
       mais sont conservés au travers d'un execve(2).

       À  cause  des  tampons  gérés  par  la  bibliothèque  stdio(3),  l'utilisation des verrous
       d'enregistrements avec les routines de celle‐ci est déconseillé. Utilisez  plutôt  read(2)
       et write(2).

   Verrouillage obligatoire
       (Non  POSIX)  Les  verrous d'enregistrements décrits ci‐dessus peuvent être coopératifs ou
       impératifs, et sont coopératifs par défaut.

       Les verrouillages coopératifs ne sont pas  imposés,  donc  ils  ne  fonctionnent  qu'entre
       processus qui les utilisent.

       Les  verrous  impératifs  sont  appliqués  à  tous  les  processus.  Si un processus tente
       d'effectuer un accès incompatible (par exemple read(2) ou  write(2))  sur  une  zone  d'un
       fichier  qui  a  un  verrou  impératif,  le  résultat  dépend  de l'attribut O_NONBLOCK du
       descripteur de fichier. S'il n'est pas activé, l'appel système est bloqué jusqu'à  ce  que
       le  verrou  soit  enlevé  ou  converti  en  un  mode  compatible  avec l'accès demandé. Si
       l'attribut O_NONBLOCK est activé, l'appel système échoue avec l'erreur EAGAIN.

       Pour utiliser des verrous impératifs, ce type de verrouillage  doit  être  activé  sur  le
       système  de fichiers contenant le fichier à verrouiller (en utilisant l'option « -o mand »
       de mount(8)), ou l'attribut MS_MANDLOCK de mount(2). Le verrouillage impératif est  activé
       pour  un  fichier en désactivant la permission d'exécution du groupe et en activant le bit
       de permission Set-GID (consultez chmod(1) et chmod(2)).

       L'implémentation Linux des verrouillages  obligatoires  n'est  pas  fiable.  Consultez  la
       section BOGUES ci-dessous.

   Gestion des signaux
       F_GETOWN,  F_SETOWN,  F_GETOWN_EX,  F_SETOWN_EX,  F_GETSIG et F_SETSIG servent à gérer les
       signaux de disponibilité d'entrée-sortie :

       F_GETOWN (void)
              Renvoyer (comme résultat de la fonction) le PID ou l'ID du groupe de processus  qui
              reçoit les signaux SIGIO et SIGURG pour les événements concernant le descripteur de
              fichier fd. Les groupes de processus sont renvoyés sous forme de valeurs  négatives
              (consultez la section BOGUES ci‐dessous). arg est ignoré.

       F_SETOWN (int)
              Définir  le  PID  ou l'identifiant du groupe de processus qui recevront les signaux
              SIGIO et SIGURG pour les événements concernant le descripteur fd,  à  l'identifiant
              fourni  par  arg.  Les  groupes  de  processus  sont  formulés  en tant que valeurs
              négatives. En général, le processus appelant indique son propre PID comme  argument
              (arg est donc getpid(2)).

              Si vous définissez l'attribut O_ASYNC sur un descripteur de fichier en utilisant la
              commande F_SETFL de fcntl(), un signal SIGIO est envoyé  dès  que  l'entrée  ou  la
              sortie  sont possibles sur ce descripteur. F_SETSIG peut être utilisé pour recevoir
              un autre signal que SIGIO. Si la vérification de permissions échoue, le signal  est
              ignoré silencieusement.

              L'envoi  d'un signal au processus (ou groupe de processus) indiqué par F_SETOWN est
              conditionné par les mêmes vérifications de permissions que l'envoi d'un signal  par
              kill(2),  où  le  processus  envoyant  le  signal  est  celui  qui utilise F_SETOWN
              (consultez la section BOGUES ci‐dessous). Si cette vérification échoue,  le  signal
              est ignoré.

              Si  le  descripteur  fd  est  une socket, F_SETOWN permet également la réception de
              signaux SIGURG lorsque des données hors‐bande arrivent sur la socket.  (SIGURG  est
              émis  dans  toutes les situations où l'appel select(2) aurait indiqué que la socket
              est dans une « situation exceptionnelle ».)

              Le paragraphe ci-dessous était  valide  pour  les  noyaux  2.6.x,  jusqu'au  2.6.11
              inclus :

                     Si une valeur non nulle est passée à F_SETSIG dans un processus multithreadé
                     utilisant une bibliothèque de threads gérant les  groupes  de  threads  (par
                     exemple  NPTL),  une  valeur  positive passée à F_SETOWN a une signification
                     différente : au lieu d'être un PID identifiant tout un processus, il  s'agit
                     d'un  identifiant  de  thread,  référant  à  un  thread  spécifique  dans un
                     processus. Par conséquent, il peut être nécessaire de passer à  F_SETOWN  la
                     valeur  renvoyée  par gettid(2) plutôt que celle renvoyée par getpid(2) pour
                     obtenir  les  résultats  souhaités  si  F_SETSIG  est  utilisé.  (Dans   les
                     implémentations  actuelles  des  threads sous Linux, l'identifiant de thread
                     (TID) du thread principal est son identifiant de  processus.  Cela  signifie
                     qu'un  processus  avec un seul thread peut utiliser indifféremment gettid(2)
                     ou getpid(2).) Veuillez toutefois noter que les remarques de  ce  paragraphe
                     ne  s'appliquent  pas au signal SIGURG généré lorsque des données hors‐bande
                     sont disponibles sur une socket : ce signal est toujours envoyé  soit  à  un
                     processus, soit à un groupe de processus, selon la valeur donnée à F_SETOWN.

              Le comportement ci-dessus a été supprimé par accident dans Linux 2.6.12, et ne sera
              pas remis. À partir de Linux 2.6.32, utilisez F_SETOWN_EX pour envoyer les  signaux
              SIGIO et SIGURG à un thread en particulier.

       F_GETOWN_EX (struct f_owner_ex *) (depuis Linux 2.6.32)
              Renvoyer  les paramètres du propriétaire du descripteur de fichier actuel, tels que
              définis par une utilisation antérieure de F_SETOWN_EX. L'information  est  renvoyée
              dans la structure pointée par arg, qui a la forme suivante :

                  struct f_owner_ex {
                      int   type;
                      pid_t pid;
                  };

              Le  champ  type aura l'une des valeurs F_OWNER_TID, F_OWNER_PID ou F_OWNER_PGRP. Le
              champ pid est un entier positif représentant un identifiant de thread, de processus
              ou de groupe de processus. Consultez F_SETOWN_EX pour plus de détails.

       F_SETOWN_EX (struct f_owner_ex *) (depuis Linux 2.6.32)
              Cette opération effectue une tâche similaire à F_SETOWN. Elle autorise l'appelant à
              diriger les signaux de disponibilité d'entrées-sorties vers un thread, un processus
              ou  un  groupe  de  processus  spécifiques. L'appellant indique le destinataire des
              signaux avec arg, qui est un pointeur vers une structure f_owner_ex. Le champ  type
              possède l'une des valeurs suivantes, qui définit comment pid est interprété :

              F_OWNER_TID
                     Envoyer  le  signal  au thread dont l'identifiant (la valeur renvoyée par un
                     appel à clone(2) ou gettid(2)) est indiqué par pid.

              F_OWNER_PID
                     Envoyer le signal au processus dont l'identifiant est indiqué par pid.

              F_OWNER_PGRP
                     Envoyer le signal au groupe de processus dont l'identifiant est indiqué  par
                     pid.  Notez  que,  à la différence de F_SETOWN, un identifiant de groupe est
                     indiqué ici avec une valeur positive.

       F_GETSIG (void)
              Renvoyer (comme résultat de la fonction) le numéro du signal émis lorsque  l'entrée
              ou  la  sortie deviennent possibles. Une valeur nulle signifie l'émission de SIGIO.
              Toute autre valeur (y compris SIGIO) précise le signal émis,  et  des  informations
              supplémentaires  seront  disponibles  pour  le  gestionnaire s'il est installé avec
              SA_SIGINFO. arg est ignoré.

       F_SETSIG (int)
              Définir le signal à émettre lorsque l'entrée ou la sortie deviennent possibles à la
              valeur  fournie par arg. Une valeur nulle signifie l'émission de SIGIO. Toute autre
              valeur (y  compris  SIGIO)  précise  le  signal  à  émettre,  et  des  informations
              supplémentaires  seront  disponibles  pour  le  gestionnaire s'il est installé avec
              SA_SIGINFO.

              En utilisant F_SETSIG avec une valeur non nulle, et en configurant SA_SIGINFO  pour
              le  gestionnaire (consultez sigaction(2)), des informations supplémentaires sur les
              événements d'entrées-sorties sont fournies au gestionnaire à travers une  structure
              siginfo_t.  Si  le champ si_code indique que la source est SI_SIGIO, le champ si_fd
              fournit le descripteur du fichier concerné par l'événement.  Sinon  il  n'y  a  pas
              d'indication  du  descripteur en attente, et il faut utiliser le mécanisme habituel
              (select(2), poll(2), read(2) avec O_NONBLOCK configuré etc.) pour déterminer  quels
              descripteurs sont disponibles pour les entrées-sorties.

              En sélectionnant un signal temps réel (valeur >= SIGRTMIN), de multiples événements
              d'entrées-sorties peuvent être mémorisés  avec  le  même  numéro  (la  mémorisation
              dépend   de   la   mémoire   disponible).  Des  informations  supplémentaires  sont
              disponibles, comme ci‐dessus, si SA_SIGINFO est configuré pour le gestionnaire.

              Noter que Linux impose une limite sur le nombre de signaux temps réel  qui  peuvent
              être  mis en attente pour un processus (consultez getrlimit(2) et signal(7)), et si
              cette limite est atteinte, le noyau change de comportement et envoie SIGIO,  et  ce
              signal est délivré au processus entier plutôt qu'au thread spécifique.

       En  utilisant ces mécanismes, un programme peut implémenter des entrées-sorties totalement
       asynchrones, la plupart du temps sans avoir besoin d'invoquer select(2) ou poll(2).

       L'utilisation de O_ASYNC est spécifique à BSD et Linux. La seule utilisation  de  F_GETOWN
       et  F_SETOWN spécifiée dans POSIX.1 est en conjonction avec l’utilisation du signal SIGURG
       sur les sockets (POSIX  ne  spécifie  pas  le  signal  SIGIO).  F_GETOWN_EX,  F_SETOWN_EX,
       F_GETSIG et F_SETSIG sont spécifiques à Linux. POSIX dispose d'entrées-sorties asynchrones
       et de la  structure  aio_sigevent  pour  effectuer  la  même  chose.  Ceci  est  également
       disponible sous Linux dans la bibliothèque GNU C (Glibc).

   Baux
       F_SETLEASE  et  F_GETLEASE  (depuis Linux 2.4) servent respectivement à établir un nouveau
       bail et à consulter le bail actuel sur le descripteur de fichier indiqué par fd. (NdT : je
       traduis  « lease »  par  « bail »,  faute de terme plus technique.) Le bail sur un fichier
       fournit un mécanisme par lequel un processus détenteur du bail est averti (par  délivrance
       d'un  signal)  lorsqu'un autre processus (le « casseur de bail ») essaye d'appeler open(2)
       ou truncate(2) sur le fichier pointé par ce descripteur de fichier

       F_SETLEASE (int)
              Définit ou supprime un bail de fichier  en  fonction  de  la  valeur  fournie  dans
              l'entier arg :

              F_RDLCK
                     Prendre  un  bail  en  lecture. Le processus appelant sera prévenu lorsqu'un
                     autre processus ouvrira le fichier en écriture ou le tronquera. Un  bail  en
                     lecture  ne  peut  être  placé  que  sur un descripteur de fichier ouvert en
                     lecture seule.

              F_WRLCK
                     Prendre un bail en écriture. Le processus appelant  sera  prévenu  lorsqu'un
                     autre processus ouvrira le fichier (en lecture ou écriture) ou le tronquera.
                     Un bail en écriture ne peut être pris sur le fichier que s'il  n'y  a  aucun
                     autre descripteur de fichier ouvert pour le fichier.

              F_UNLCK
                     Supprimer le bail sur un fichier.

       Les  baux  sont  associés  à  une  description de fichier ouvert (consultez open(2)). Cela
       signifie que les descripteurs de fichier dupliqués (créé  par,  par  exemple,  fork(2)  ou
       dup(2))  font  référence  au  même  bail,  et que ce bail peut être modifié ou relâché par
       n'importe lequel de ces descripteurs. De plus, le bail est relâché soit par une  opération
       F_UNLCK  explicite  sur  n'importe lequel de ces descripteurs dupliqués, soit lorsque tous
       ces descripteurs ont été fermés.

       Les baux ne peuvent être pris que sur des fichiers normaux. Un processus non privilégié ne
       peut  prendre un bail que sur un fichier dont l'UID (le propriétaire) correspond au FS-UID
       du processus. Un processus possédant la  capacité  CAP_LEASE  peut  prendre  un  bail  sur
       n'importe quel fichier.

       F_GETLEASE (void)
              Indique  le  type  de  bail  possédé  sur le descripteur de fichier fd en renvoyant
              F_RDLCK, F_WRLCK, ou F_UNLCK, signifiant respectivement que le processus appelant a
              un bail en lecture, écriture, ou pas de bail sur le fichier. arg est ignoré.

       Lorsqu'un processus (le « casseur de bail » appelle open(2) ou truncate(2) en conflit avec
       un bail établi par F_SETLEASE, l'appel système est bloqué par le noyau et le noyau avertit
       le  processus tenant le bail par l'envoi d'un signal (SIGIO par défaut). Le tenant du bail
       doit répondre à ce signal en effectuant tout le nettoyage nécessaire pour que  le  fichier
       soit  accessible par un autre processus (par exemple en vidant des tampons internes) et en
       supprimant ou déclassant son bail. Un bail est supprimé en appelant la commande F_SETLEASE
       avec  arg  valant F_UNLCK. Si le tenant du bail possède un bail en écriture sur le fichier
       et que le casseur de bail ouvre le fichier en lecture, il est suffisant que le  tenant  du
       bail  déclasse  le  bail  en un bail en lecture. Cela est effectué en appelant la commande
       F_SETLEASE avec arg valant F_RDLCK.

       Si le détenteur du bail n'arrive pas à le déclasser ou le supprimer  avant  le  nombre  de
       secondes   indiqué   dans  /proc/sys/fs/lease-break-time  alors  le  noyau  supprimera  ou
       déclassera de force le bail du processus qui le tient.

       Dès qu'un cassage de bail a été  commencé,  F_GETLEASE  renvoie  le  type  de  bail  cible
       (F_RDLCK  ou  F_UNLCK,  en  fonction  de ce qui serait compatible avec le casseur de bail)
       jusqu'à ce que le détenteur du bail ne le déclasse ou le supprime volontairement,  ou  que
       le noyau force à le faire après expiration du délai de cassage de bail.

       Dès  que  le  bail  a  été, de gré ou de force, résilié ou déclassé et en supposant que le
       casseur de bail n'a pas débloqué son appel système, le noyau permet à  ce  dernier  de  se
       dérouler.

       Si  l'appel à open(2) ou truncate(2) du casseur de bail est interrompu par un gestionnaire
       de signal, l'appel système échoue avec l'erreur EINTR, mais les autres étapes décrites ci‐
       dessous  se déroulent normalement. Si le casseur de bail est tué par un signal pendant que
       son appel système open(2) ou truncate(2) bloque, tout se déroule comme  décrit  ci‐dessus.
       De  même,  si  le casseur de bail utilise l'option O_NONBLOCK de open(2), l'appel retourne
       immédiatement avec l'erreur EWOULDBLOCK, mais les autres étapes se déroulent comme  décrit
       ci‐dessus.

       Le  signal  de  notification  par défaut pour le tenant du bail est SIGIO, mais on peut le
       modifier avec la commande F_SETSIG de la fonction fcntl(). Si une  commande  F_SETSIG  est
       réalisée  (même pour SIGIO), et si le gestionnaire de signal est installé avec SA_SIGINFO,
       alors il recevra une structure siginfo_t en second argument, et le champ si_fd  contiendra
       le  descripteur  de  fichier  du  bail  où  il  y  a eu une tentative d'accès par un autre
       processus. (Ceci sert si le processus tient des baux sur plusieurs fichiers.)

   Notification de modification de fichier et de répertoire (dnotify)
       F_NOTIFY (int)
              (Depuis Linux 2.4) Fournit un avertissement lorsque le répertoire  correspondant  à
              fd  ou l'un des fichiers qu'il contient est modifié. Les événements à notifier sont
              précisés dans arg, sous forme de masque regroupant par un OU binaire zéro,  une  ou
              plusieurs des constantes suivantes :

              DN_ACCESS   Accès à un fichier (read, pread, readv)
              DN_MODIFY   Modification d'un fichier (write, pwrite, truncate, ftruncate).
              DN_CREATE   Création  d'un  fichier  (open,  creat,  mknod,  mkdir,  link, symlink,
                          rename).
              DN_DELETE   Suppression d'un fichier (unlink, renommage dans un  autre  répertoire,
                          rmdir).
              DN_RENAME   Un fichier a été renommé dans le même répertoire (nerame).
              DN_ATTRIB   Les attributs d'un fichier ont été modifiés (chown, chmod, utime[s]).

              (Afin  d'obtenir  ces  définitions,  la  macro  _GNU_SOURCE doit être définie avant
              d'inclure tout fichier d'en‐tête).

              Les notifications de répertoire sont habituellement uniques, et l'application  doit
              réenregistrer  une  demande  pour  les  notifications  ultérieures. Inversement, si
              DN_MULTISHOT est incluse dans arg, les notifications resteront en effet jusqu'à une
              demande explicite de suppression.

              Une série de F_NOTIFY sont cumulés, les événements décrits dans arg étant ajoutés à
              l'ensemble des événements déjà surveillés. Pour supprimer les notifications de tous
              les événements, il faut invoquer F_NOTIFY avec arg valant 0.

              La  notification  se produit par l'occurrence d'un signal. Le signal par défaut est
              SIGIO, mais on peut le changer avec la commande F_SETSIG de fcntl(). Dans  ce  cas,
              le  gestionnaire de signal reçoit une structure siginfo_t en second argument (si le
              gestionnaire a été installé avec  SA_SIGINFO)  dont  le  champ  si_fd  contient  le
              descripteur  du  fichier  qui  a  déclenché  la notification (utile pour superviser
              plusieurs répertoires).

              En outre, avec DN_MULTISHOT, un signal temps‐réel  devrait  être  utilisé  pour  la
              notification pour pouvoir empiler les notifications successives.

              NOTE :   Les   nouvelles   applications   devraient  utiliser  l'interface  inotify
              (disponible depuis Linux 2.6.13), qui fournit une  bien  meilleure  interface  pour
              obtenir  des  notifications  d'événements  sur  le  système  de fichiers. Consultez
              inotify(7).

   Changer la capacité d'un tube
       F_SETPIPE_SZ (int ; depuis Linux 2.6.35)
              Change la capacité du tube référencé par fd pour contenir au moins arg  octets.  Un
              processus non privilégié peut ajuster la capacité d'un tube à toute valeur comprise
              entre   la   taille   de   page   du   système   et   la   limite   définie    dans
              /proc/sys/fs/pipe-max-size  (consultez  proc(5)).  Les  tentatives  pour définir la
              capacité du tube en dessous de la taille de page sont silencieusement  arrondies  à
              la  taille  de  page.  Les tentatives d'un processus non privilégié pour définir la
              capacité du tube au dessus de /proc/sys/fs/pipe-max-size renvoie  l'erreur  EPERM ;
              un processus privilégié (CAP_SYS_RESOURCE) peut passer outre cette limite. Quand il
              alloue le tampon pour le tube, le noyau peut utiliser  une  capacité  supérieure  à
              arg,  si  cela  est  plus  pratique pour l'implémentation. L'opération F_GETPIPE_SZ
              renvoie la taille réellement utilisée. Les tentatives pour définir la  capacité  du
              tube  en dessous de la capacité du tampon actuellement utilisé pour sauvegarder les
              données produit l'erreur EBUSY.

       F_GETPIPE_SZ (void ; depuis Linux 2.6.35)
              Renvoie (comme résultat de la fonction) la capacité du tube référencé par fd.

VALEUR RENVOYÉE

       La valeur renvoyée par fcntl() varie suivant le type d'opération :

       F_DUPFD  Le nouveau descripteur.

       F_GETFD  Valeur des attributs du descripteur de fichier.

       F_GETFL  Valeur des attributs d'état du fichier.

       F_GETLEASE
                Le type bail tenu sur le descripteur de fichier.

       F_GETOWN Le propriétaire du descripteur de fichier.

       F_GETSIG La valeur du signal envoyé lorsque la lecture ou l'écriture deviennent possibles,
                ou zéro pour le comportement SIGIO traditionnel.

       F_GETPIPE_SZ
                La capacité du tube.

       Toutes les autres commandes :
                Zéro.

       En cas d'erreur, la valeur de retour est -1, et errno contient le code d'erreur.

ERREURS

       EACCES ou EAGAIN
              L'opération est interdire en raison de verrous tenus par d'autres processus.

       EAGAIN L'opération  est  impossible  à  cause d'une projection en mémoire effectuée par un
              autre processus.

       EBADF  fd n'est pas un descripteur de fichier ouvert, ou  la  commande  était  F_SETLK  ou
              F_SETLKW et le mode d'ouverture du descripteur de fichier ne correspond pas au type
              de verrou demandé.

       EDEADLK
              Le verrouillage F_SETLKW conduirait à un blocage.

       EFAULT lock se trouve en dehors de l'espace d'adressage.

       EINTR  Pour F_SETLKW, la commande a été interrompue par un signal ;  consultez  signal(7).
              Pour  F_GETLK  et  F_SETLK,  la  commande  a été interrompue par un signal avant la
              vérification ou l'acquisition du verrou. Se produit surtout lors d'un  verrouillage
              distant (par exemple à travers NFS), mais peut également arriver localement.

       EINVAL Pour  F_DUPFD,  arg est soit négatif, soit trop grand. Pour F_SETSIG, arg n'est pas
              un numéro de signal correct.

       EMFILE Pour F_DUPFD, le processus a déjà ouvert  le  nombre  maximal  de  descripteurs  de
              fichier.

       ENOLCK Trop  de  verrous  sont  ouverts,  ou  la  table  des  verrous  est  pleine,  ou le
              verrouillage distant (par exemple par NFS) a échoué.

       EPERM  Essai d'effacement de l'attribut O_APPEND sur un fichier,  mais  il  est  considéré
              comme en-ajout-seulement.

CONFORMITÉ

       SVr4,  BSD 4.3,  POSIX.1-2001.  Seules  les opérations F_DUPFD, F_GETFD, F_SETFD, F_GETFL,
       F_SETFL, F_GETLK, F_SETLK et F_SETLKW sont spécifiées dans POSIX.1-2001.

       F_GETOWN et F_SETOWN sont spécifiées dans POSIX.1-2001. Pour activer ces définitions, vous
       devez  définir _BSD_SOURCE, ou _XOPEN_SOURCE avec une valeur supérieure ou égale à 500, ou
       _POSIX_C_SOURCE avec une valeur supérieure ou égale à 200809L.

       F_GETOWN est spécifiée dans  POSIX.1-2008.  Pour  activer  cette  définition,  vous  devez
       _POSIX_C_SOURCE  avec  une valeur supérieure ou égale à 200809L, ou _XOPEN_SOURCE avec une
       valeur supérieure ou égale à 700.

       F_GETOWN_EX,  F_SETOWN_EX,  F_SETPIPE_SZ,  F_GETPIPE_SZ,  F_GETSIG,  F_SETSIG,   F_NOTIFY,
       F_GETLEASE  et  F_SETLEASE sont spécifiques à Linux. (Définissez la macro _GNU_SOURCE pour
       avoir ces définitions).

NOTES

       L'appel système fcntl() original de Linux n'a pas été conçu pour gérer les positions (dans
       la  structure  flock) dans des fichiers de très grosse taille. En conséquence, Linux 2.4 a
       ajouté l'appel système fcntl64(). Ce nouvel appel système utilise une structure différente
       de  verrouillage  de  fichier, flock64, ainsi que les commandes correspondantes F_GETLK64,
       F_SETLK64 et F_SETLKW64. Cependant, ces détails peuvent être ignorés par les  applications
       qui  utilisent la glibc, car sa fonction fcntl() encapsule de manière transparente l'appel
       système le plus récent disponible.

       Les erreurs renvoyées par dup2(2) ne sont pas les mêmes que celles renvoyées par F_DUPFD.

       Depuis le noyau 2.0, il n'y a pas d'interaction entre les verrous placés par  flock(2)  et
       ceux de fcntl().

       Plusieurs  systèmes  ont  d'autres  champs  dans struct flock comme, par exemple, l_sysid.
       Clairement, l_pid seul ne sera pas très utile si le processus tenant le  verrou  s'exécute
       sur une autre machine.

BOGUES

   F_SETFL
       Il  n'est  pas  possible  d'utiliser F_SETFL pour modifier l'état des attributs O_DSYNC et
       O_SYNC. Une tentative de modification de ces attributs sera simplement ignorée.

   F_GETOWN
       En raison d'une limitation des conventions d'appels système  sur  certaines  architectures
       (en  particulier  i386), si F_GETOWN renvoie un identifiant de groupe de processus compris
       entre -1 et -4095, la valeur de retour est interprétée par glibc  comme  une  erreur ;  la
       valeur  de  retour  de  fcntl()  sera  -1  et  errno contiendra l'identifiant du groupe de
       processus (positif). Les opérations spécifiques à Linux F_SETOWN_EX et F_GETOWN_EX évitent
       ce  problème.  Depuis  la  glibc  2.11,  glibc rend le problème avec F_GETOWN invisible en
       implémentant F_GETOWN par-dessus F_GETOWN_EX.

   F_SETOWN
       Sous Linux 2.4 et précédents, lorsqu'un processus non  privilégié  utilise  F_SETOWN  pour
       indiquer  le propriétaire d'une socket, avec un identifiant de (groupe de) processus autre
       que celui de l'appelant, un bogue peut survenir. Dans ce cas, fcntl()  peut  renvoyer  -1,
       avec  errno  positionné  à  EPERM,  même si l'appelant a le droit d'envoyer un signal à ce
       (groupe de) processus. En dépit de cette erreur, le propriétaire du descripteur de fichier
       est positionné, et les signaux seront envoyés au propriétaire.

   Verrouillage obligatoire
       L'implémentation du verrouillage obligatoire dans toutes les versions connues de Linux est
       sujet à des conditions de concurrence qui la rende non fiable : un appel  à  write(2)  qui
       chevauche  un verrou peut modifier les données après que le verrouillage obligatoire a été
       acquis ; un appel à read(2) qui chevauche un verrou peut détecter  des  modifications  sur
       des  données qui ont été faites seulement après qu'un verrou en écriture a été acquis. Des
       conditions de concurrence similaires existent entre les verrous obligatoires  et  mmap(2).
       Il est donc déconseillé de faire confiance au verrouillage obligatoire.

VOIR AUSSI

       dup2(2), flock(2), open(2), socket(2), lockf(3), capabilities(7), feature_test_macros(7)

       locks.txt,     mandatory-locking.txt     et     dnotify.txt     dans     le     répertoire
       Documentation/filesystems/ des sources du noyau Linux. (Sur d'anciens noyaux, ces fichiers
       se  trouvent  dans  le  répertoire  Documentation/  et  mandatory-locking.txt  est  appelé
       mandatory.txt.)

COLOPHON

       Cette page fait partie de la publication 3.65 du projet man-pages Linux.  Une  description
       du  projet  et  des  instructions  pour  signaler  des  anomalies  peuvent être trouvées à
       l'adresse http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Depuis   2010,   cette   traduction   est   maintenue   à   l'aide   de    l'outil    po4a
       <http://po4a.alioth.debian.org/>  par l'équipe de traduction francophone au sein du projet
       perkamon <http://perkamon.alioth.debian.org/>.

       Christophe   Blaess   <http://www.blaess.fr/christophe/>   (1996-2003),    Alain    Portal
       <http://manpagesfr.free.fr/>  (2003-2006).  Julien  Cristau  et  l'équipe  francophone  de
       traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>   ou   par   un  rapport  de  bogue  sur  le  paquet
       manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document  en  utilisant  la
       commande « man -L C <section> <page_de_man> ».