Provided by: manpages-fr-dev_3.32d0.2p4-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 long,  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 (long)
              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 (long ; depuis Linux 2.6.24)
              Comme  pour  F_DUPFD,  mais  positionne   en   plus   l'attribut
              « close-on-exec »  pour  le  descripteur dupliqué. Spécifier 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 (long)
              Positionner  les  attributs  du  descripteur  de fichier avec la
              valeur précisée par arg.

   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)
              Lire les attributs d'état du fichier ; arg est ignoré.

       F_SETFL (long)
              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.

   Verrouillages coopératifs
       F_GETLK,  F_SETLK  et  F_SETLKW  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 spécifié).

           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.

       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 (long)
              Fixer  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 fixez 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)
              spécifié  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 spécifie 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 (long)
              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,  F_GETOWN,  F_SETOWN  est spécifique BSD et
       Linux. 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 (long)
              Fixe 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  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 (long)
              (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 (long ; 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-size-max (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-size-max 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  via  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

       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.

       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.

       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)

       Consultez aussi locks.txt, mandatory-locking.txt et dnotify.txt dans le
       répertoire   Documentation/filesystems   des   sources  du  noyau  (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.32 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       être       trouvées      à      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

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

       Christophe  Blaess  <URL:http://www.blaess.fr/christophe/> (1996-2003),
       Alain  Portal  <URL: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> ».