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 a diverses operations sur le descripteur de
       fichier fd. L'operation en question est determinee  par  la  valeur  de
       l'argument cmd.

       fcntl() prend un troisieme parametre optionnel. La necessite de fournir
       ce parametre depend de cmd. le parametre  doit  etre  du  type  indique
       entre parentheses apres chaque nom de commande cmd (dans la plupart des
       cas, le type requis est un long,  et  le  parametre  est  identifie  en
       utilisant  le  nom  arg), ou void est indique si le parametre n'est pas
       necessaire.

   Dupliquer un descripteur de fichier
       F_DUPFD (long)
              Trouver le plus petit numero de descripteur libre  superieur  ou
              egal  a arg et le transformer en copie de fd. Ceci est different
              de dup2(2), qui utilise exactement le descripteur transmis.

              En cas de reussite, le nouveau descripteur est renvoye.

              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 duplique. Specifier cet
              attribut  permet  d'eviter  une  operation  F_SETFD  de  fcntl()
              supplementaire  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  associes  a  un
       descripteur de fichier. Actuellement, un seul attribut est defini :  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 ferme.

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

       F_SETFD (long)
              Positionner  les  attributs  du  descripteur  de fichier avec la
              valeur precisee par arg.

   Attribut d''etat du fichier
       Un descripteur de fichier dispose de  certains  attributs,  initialises
       par  open(2) et eventuellement modifies par fcntl(). Les attributs sont
       partages  entre  les  copies  (obtenues  avec  dup(2),  fcntl(F_DUPFD),
       fork(2), etc.) du meme descripteur de fichier.

       Les attributs et leurs semantiques sont decrits dans la page open(2).

       F_GETFL (void)
              Lire les attributs d'etat du fichier ; arg est ignore.

       F_SETFL (long)
              Positionner  les  nouveaux  attributs  pour  le  descripteur  de
              fichier a la valeur indiquee par arg. Les bits de  mode  d'acces
              (O_RDONLY,  O_WRONLY,  O_RDWR)  et  les  attributs  de  creation
              (O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC) de arg sont  ignores.  Sous
              Linux,  cette  commande  ne  peut changer que O_APPEND, O_ASYNC,
              O_DIRECT, O_NOATIME et O_NONBLOCK.

   Verrouillages coop'eratifs
       F_GETLK,  F_SETLK  et  F_SETLKW  servent  a  gerer  les   verrouillages
       d'enregistrements (de segments ou de regions de fichiers). Le troisieme
       argument, lock, est un pointeur sur une structure qui a  au  moins  les
       champs suivants (dans un ordre non specifie).

           struct flock {
               ...
               short l_type;    /* Type de verrouillage : F_RDLCK,
                                   F_WRLCK, F_UNLCK */
               short l_whence;  /* Interpretation de l_start:
                                   SEEK_SET, SEEK_CUR, SEEK_END */
               off_t l_start;   /* Decalage de debut 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 a verrouiller. Des octets apres la fin du fichier
       peuvent etre verrouille, mais pas des octets avant le debut du fichier.

       l_start  est la position de debut du verrou, et est interprete de facon
       relative : au debut du fichier  (si  l_whence  vaut  SEEK_SET) ;  a  la
       position  actuelle  dans  le fichier (si l_whence vaut SEEK_CUR) ; a la
       fin du fichier (si l_whence vaut SEEK_END). Dans les deux derniers cas,
       l_start  peut etre un nombre negatif, a partir du moment ou la position
       fournie ne pointe pas avant le debut du fichier.

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

       POSIX.1-2001 permet (mais n'impose pas) a une implementation de prendre
       en charge des valeurs  de  l_len  negatives ;  si  l_len  est  negatif,
       l'intervalle  decrivant  le verrou lock couvre les octets l_start+l_len
       jusqu'a l_start-1 inclus.  Ceci  est  supporte  par  Linux  depuis  les
       versions 2.4.21 et 2.5.49.

       Le  champ l_type peut servir a placer un verrou en lecture (F_RDLCK) ou
       en ecriture (F_WRLCK) sur un fichier. Un nombre quelconque de processus
       peuvent  tenir  un  verrou  en  lecture  (partage), sur une region d'un
       fichier, mais un seul peut avoir un verrou en ecriture  (exclusif).  Un
       verrou  en  ecriture  exclut  tous  les  autres  verrous, aussi bien en
       lecture qu'en ecriture. Un processus donne ne  peut  tenir  qu'un  seul
       verrou  sur  une  region  d'un  fichier,  si  un  nouveau  verrou y est
       applique, alors le verrou precedent est  converti  suivant  le  nouveau
       type.  Ceci peut entrainer le decoupage, la reduction ou l'extension du
       verrou existant si le nombre d'octets du nouveau verrou ne coincide pas
       exactement avec celui de l'ancien.

       F_SETLK (struct flock *)
              Acquerir  (si  l_type  vaut  F_RDLCK  ou F_WRLCK) ou liberer (si
              l_type vaut F_UNLCK) le verrou sur les octets indiques  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 liberation du verrou au lieu de
              retourner une erreur.  Si  un  signal  a  intercepter  est  recu
              pendant   l'attente,   l'appel   est   interrompu   et  renverra
              immediatement (apres  retour  du  gestionnaire  de  signaux)  la
              valeur  -1.  errno sera remplie avec la valeur EINTR ; consultez
              signal(7).

       F_GETLK (struct flock *)
              En entree dans cette routine, lock decrit  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
              inchanges.  Si  un  ou  plusieurs  verrouillages   incompatibles
              empechaient 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 etre ouvert au  moins
       en  lecture.  Pour placer un verrou en ecriture, fd doit etre ouvert en
       ecriture. Pour placer les deux types de verrous, il faut une  ouverture
       en lecture/ecriture.

       Outre  la  suppression  par  un  F_UNLCK  explicite,  les  verrous sont
       automatiquement liberes lorsque le processus se termine, ou s'il  ferme
       l'un  des  descripteurs se referant au fichier sur lequel le verrou est
       place. 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 bibliotheque decide de l'ouvrir puis
       de le refermer.

       Les verrouillages d'enregistrements ne sont pas herites par les enfants
       lors d'un fork(2), mais sont conserves au travers d'un execve(2).

       A cause des tampons geres par la bibliotheque  stdio(3),  l'utilisation
       des  verrous  d'enregistrements  avec  les  routines  de  celle-ci  est
       deconseille. Utilisez plutot read(2) et write(2).

   Verrouillage obligatoire
       (Non POSIX) Les verrous  d'enregistrements  decrits  ci-dessus  peuvent
       etre cooperatifs ou imperatifs, et sont cooperatifs par defaut.

       Les  verrouillages  cooperatifs  ne  sont  pas  imposes,  donc  ils  ne
       fonctionnent qu'entre processus qui les utilisent.

       Les verrous imperatifs sont appliques  a  tous  les  processus.  Si  un
       processus  tente d'effectuer un acces incompatible (par exemple read(2)
       ou write(2)) sur une zone d'un fichier qui a un  verrou  imperatif,  le
       resultat  depend  de  l'attribut  O_NONBLOCK du descripteur de fichier.
       S'il n'est pas active, l'appel systeme est bloque  jusqu'a  ce  que  le
       verrou  soit  enleve  ou  converti  en  un mode compatible avec l'acces
       demande. Si l'attribut O_NONBLOCK est active,  l'appel  systeme  echoue
       avec l'erreur EAGAIN.

       Pour utiliser des verrous imperatifs, ce type de verrouillage doit etre
       active sur le systeme de fichiers contenant le  fichier  a  verrouiller
       (en  utilisant  l'option  << -o  mand >>  de  mount(8)),  ou l'attribut
       MS_MANDLOCK de mount(2). Le verrouillage imperatif est active  pour  un
       fichier  en  desactivant  la  permission  d'execution  du  groupe et en
       activant le bit de permission Set-GID (consultez chmod(1) et chmod(2)).

       L'implementation 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 a gerer les signaux de disponibilite d'entree-sortie :

       F_GETOWN (void)
              Renvoyer (comme resultat de la  fonction)  le  PID  ou  l'ID  du
              groupe  de processus qui recoit les signaux SIGIO et SIGURG pour
              les evenements concernant le  descripteur  de  fichier  fd.  Les
              groupes  de  processus  sont  renvoyes  sous  forme  de  valeurs
              negatives (consultez la  section  BOGUES  ci-dessous).  arg  est
              ignore.

       F_SETOWN (long)
              Fixer  le  PID  ou  l'identifiant  du  groupe  de  processus qui
              recevront les  signaux  SIGIO  et  SIGURG  pour  les  evenements
              concernant  le  descripteur  fd, a l'identifiant fourni par arg.
              Les groupes de processus  sont  formules  en  tant  que  valeurs
              negatives.  En general, 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
              envoye des que l'entree ou  la  sortie  sont  possibles  sur  ce
              descripteur.  F_SETSIG  peut etre utilise pour recevoir un autre
              signal que SIGIO. Si la verification de permissions  echoue,  le
              signal est ignore silencieusement.

              L'envoi  d'un  signal  au  processus  (ou  groupe  de processus)
              specifie  par   F_SETOWN   est   conditionne   par   les   memes
              verifications   de  permissions  que  l'envoi  d'un  signal  par
              kill(2), ou le  processus  envoyant  le  signal  est  celui  qui
              utilise  F_SETOWN  (consultez  la section BOGUES ci-dessous). Si
              cette verification echoue, le signal est ignore.

              Si le descripteur fd est une socket, F_SETOWN  permet  egalement
              la  reception  de  signaux SIGURG lorsque des donnees hors-bande
              arrivent sur  la  socket.  (SIGURG  est  emis  dans  toutes  les
              situations ou l'appel select(2) aurait indique que la socket est
              dans une << situation exceptionnelle >>.)

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

                     Si  une  valeur  non  nulle est passee a F_SETSIG dans un
                     processus  multithreade  utilisant  une  bibliotheque  de
                     threads gerant les groupes de threads (par exemple NPTL),
                     une valeur positive passee a F_SETOWN a une signification
                     differente :  au  lieu  d'etre un PID identifiant tout un
                     processus, il s'agit d'un identifiant de thread, referant
                     a un thread specifique dans un processus. Par consequent,
                     il peut etre necessaire de passer a  F_SETOWN  la  valeur
                     renvoyee  par  gettid(2)  plutot  que  celle renvoyee par
                     getpid(2)  pour  obtenir  les  resultats   souhaites   si
                     F_SETSIG est utilise. (Dans les implementations 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 indifferemment gettid(2) ou getpid(2).) Veuillez
                     toutefois noter que les remarques  de  ce  paragraphe  ne
                     s'appliquent  pas  au  signal  SIGURG  genere lorsque des
                     donnees hors-bande sont disponibles sur une  socket :  ce
                     signal est toujours envoye soit a un processus, soit a un
                     groupe de processus, selon la valeur donnee a F_SETOWN.

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

       F_GETOWN_EX (struct f_owner_ex *) (depuis Linux 2.6.32)
              Renvoyer  les  parametres  du  proprietaire  du  descripteur  de
              fichier actuel, tels que definis par une utilisation  anterieure
              de  F_SETOWN_EX.  L'information  est  renvoyee dans la structure
              pointee 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 representant un
              identifiant de thread, de processus ou de groupe  de  processus.
              Consultez F_SETOWN_EX pour plus de details.

       F_SETOWN_EX (struct f_owner_ex *) (depuis Linux 2.6.32)
              Cette  operation  effectue  une tache similaire a F_SETOWN. Elle
              autorise l'appelant  a  diriger  les  signaux  de  disponibilite
              d'entrees-sorties  vers  un thread, un processus ou un groupe de
              processus specifiques. L'appellant specifie le destinataire  des
              signaux  avec  arg,  qui  est  un  pointeur  vers  une structure
              f_owner_ex. Le champ type possede l'une des  valeurs  suivantes,
              qui definit comment pid est interprete :

              F_OWNER_TID
                     Envoyer le signal au thread dont l'identifiant (la valeur
                     renvoyee par  un  appel  a  clone(2)  ou  gettid(2))  est
                     indique par pid.

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

              F_OWNER_PGRP
                     Envoyer  le  signal   au   groupe   de   processus   dont
                     l'identifiant  est  indique  par  pid.  Notez  que,  a la
                     difference de F_SETOWN,  un  identifiant  de  groupe  est
                     indique ici avec une valeur positive.

       F_GETSIG (void)
              Renvoyer  (comme  resultat  de  la fonction) le numero du signal
              emis lorsque l'entree ou la  sortie  deviennent  possibles.  Une
              valeur nulle signifie l'emission de SIGIO. Toute autre valeur (y
              compris SIGIO) precise  le  signal  emis,  et  des  informations
              supplementaires seront disponibles pour le gestionnaire s'il est
              installe avec SA_SIGINFO. arg est ignore.

       F_SETSIG (long)
              Definir le signal  a  emettre  lorsque  l'entree  ou  la  sortie
              deviennent  possibles  a  la  valeur fournie par arg. Une valeur
              nulle signifie  l'emission  de  SIGIO.  Toute  autre  valeur  (y
              compris  SIGIO) precise le signal a emettre, et des informations
              supplementaires seront disponibles pour le gestionnaire s'il est
              installe 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   supplementaires   sur  les
              evenements d'entrees-sorties sont  fournies  au  gestionnaire  a
              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   concerne   par   l'evenement.   Sinon  il  n'y  a  pas
              d'indication du descripteur en attente, et il faut  utiliser  le
              mecanisme  habituel (select(2), poll(2), read(2) avec O_NONBLOCK
              configure  etc.)  pour  determiner   quels   descripteurs   sont
              disponibles pour les entrees-sorties.

              En  selectionnant  un signal temps reel (valeur >= SIGRTMIN), de
              multiples evenements d'entrees-sorties  peuvent  etre  memorises
              avec  le  meme  numero  (la  memorisation  depend  de la memoire
              disponible). Des informations supplementaires sont  disponibles,
              comme   ci-dessus,   si   SA_SIGINFO   est   configure  pour  le
              gestionnaire.

              Noter que Linux impose une limite sur le nombre de signaux temps
              reel   qui  peuvent  etre  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 delivre  au  processus  entier  plutot  qu'au  thread
              specifique.

       En   utilisant  ces  mecanismes,  un  programme  peut  implementer  des
       entrees-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 specifique BSD et
       Linux. F_GETOWN_EX, F_SETOWN_EX, F_GETSIG et F_SETSIG sont  specifiques
       a Linux. POSIX dispose d'entrees-sorties asynchrones et de la structure
       aio_sigevent  pour  effectuer  la  meme  chose.  Ceci   est   egalement
       disponible sous Linux dans la bibliotheque GNU C (Glibc).

   Baux
       F_SETLEASE  et  F_GETLEASE  (depuis Linux 2.4) servent respectivement a
       etablir  un  nouveau  bail  et  a  consulter  le  bail  actuel  sur  le
       descripteur  de  fichier  indique par fd. (NdT : je traduis << lease >>
       par << bail >>, faute de terme plus technique.) Le bail sur un  fichier
       fournit  un  mecanisme  par  lequel  un processus detenteur du bail est
       averti (par delivrance  d'un  signal)  lorsqu'un  autre  processus  (le
       << casseur  de  bail >>) essaye d'appeler open(2) ou truncate(2) sur le
       fichier pointe 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
                     prevenu lorsqu'un autre processus ouvrira le  fichier  en
                     ecriture ou le tronquera. Un bail en lecture ne peut etre
                     place que sur un descripteur de fichier ouvert en lecture
                     seule.

              F_WRLCK
                     Prendre  un  bail en ecriture. Le processus appelant sera
                     prevenu lorsqu'un autre processus ouvrira le fichier  (en
                     lecture ou ecriture) ou le tronquera. Un bail en ecriture
                     ne peut etre 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 associes a une description de fichier ouvert (consultez
       open(2)). Cela signifie que les descripteurs de fichier dupliques (cree
       par,  par  exemple,  fork(2) ou dup(2)) font reference au meme bail, et
       que ce bail peut etre modifie ou relache par n'importe  lequel  de  ces
       descripteurs.  De  plus,  le  bail  est  relache soit par une operation
       F_UNLCK explicite sur n'importe lequel de ces  descripteurs  dupliques,
       soit lorsque tous ces descripteurs ont ete fermes.

       Les  baux  ne  peuvent  etre  pris  que  sur  des  fichiers normaux. Un
       processus non privilegie ne peut prendre un bail  que  sur  un  fichier
       dont  l'UID  (le  proprietaire)  correspond  au FS-UID du processus. Un
       processus possedant la capacite CAP_LEASE  peut  prendre  un  bail  sur
       n'importe quel fichier.

       F_GETLEASE (void)
              Indique le type de bail possede 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,
              ecriture, ou pas de bail sur le fichier. arg est ignore.

       Lorsqu'un processus  (le  << casseur  de  bail >>  appelle  open(2)  ou
       truncate(2)  en  conflit  avec  un  bail etabli par F_SETLEASE, l'appel
       systeme est bloque par le noyau et le noyau avertit le processus tenant
       le  bail  par l'envoi d'un signal (SIGIO par defaut). Le tenant du bail
       doit repondre a ce signal en effectuant tout  le  nettoyage  necessaire
       pour que le fichier soit accessible par un autre processus (par exemple
       en vidant des tampons internes) et  en  supprimant  ou  declassant  son
       bail.  Un bail est supprime en appelant la commande F_SETLEASE avec arg
       valant F_UNLCK. Si le tenant du bail possede un bail en ecriture sur le
       fichier  et  que le casseur de bail ouvre le fichier en lecture, il est
       suffisant que le tenant du bail declasse le bail en un bail en lecture.
       Cela  est  effectue  en appelant la commande F_SETLEASE avec arg valant
       F_RDLCK.

       Si le detenteur du bail n'arrive pas a le  declasser  ou  le  supprimer
       avant  le nombre de secondes indique dans /proc/sys/fs/lease-break-time
       alors le noyau supprimera ou declassera de force le bail  du  processus
       qui le tient.

       Des  que  le  bail a ete, de gre ou de force, resilie ou declasse et en
       supposant que le casseur de bail n'a pas debloque son appel systeme, le
       noyau permet a ce dernier de se derouler.

       Si  l'appel  a open(2) ou truncate(2) du casseur de bail est interrompu
       par un gestionnaire de signal, l'appel  systeme  echoue  avec  l'erreur
       EINTR,   mais  les  autres  etapes  decrites  ci-dessous  se  deroulent
       normalement. Si le casseur de bail est tue par un  signal  pendant  que
       son  appel systeme open(2) ou truncate(2) bloque, tout se deroule comme
       decrit ci-dessus. De meme, si  le  casseur  de  bail  utilise  l'option
       O_NONBLOCK  de  open(2),  l'appel  retourne immediatement avec l'erreur
       EWOULDBLOCK, mais les autres  etapes  se  deroulent  comme  decrit  ci-
       dessus.

       Le  signal de notification par defaut 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 realisee (meme pour SIGIO), et si
       le gestionnaire de  signal  est  installe  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 ou il y a eu une tentative
       d'acces  par  un  autre processus. (Ceci sert si le processus tient des
       baux sur plusieurs fichiers.)

   Notification de modification de fichier et de r'epertoire (dnotify)
       F_NOTIFY (long)
              (Depuis  Linux  2.4)  Fournit  un   avertissement   lorsque   le
              repertoire  correspondant  a  fd  ou  l'un  des  fichiers  qu'il
              contient est modifie. Les evenements a  notifier  sont  precises
              dans  arg,  sous  forme  de  masque regroupant par un OU binaire
              zero, une ou plusieurs des constantes suivantes :

              DN_ACCESS   Acces a un fichier (read, pread, readv)
              DN_MODIFY   Modification d'un fichier (write, pwrite,  truncate,
                          ftruncate).
              DN_CREATE   Creation  d'un  fichier  (open, creat, mknod, mkdir,
                          link, symlink, rename).
              DN_DELETE   Suppression d'un fichier (unlink, renommage dans  un
                          autre repertoire, rmdir).
              DN_RENAME   Un  fichier  a  ete  renomme dans le meme repertoire
                          (nerame).
              DN_ATTRIB   Les attributs d'un fichier ont ete modifies  (chown,
                          chmod, utime[s]).

              (Afin  d'obtenir ces definitions, la macro _GNU_SOURCE doit etre
              definie avant d'inclure tout fichier d'en-tete).

              Les notifications de repertoire sont habituellement uniques,  et
              l'application   doit   reenregistrer   une   demande   pour  les
              notifications  ulterieures.  Inversement,  si  DN_MULTISHOT  est
              incluse  dans  arg, les notifications resteront en effet jusqu'a
              une demande explicite de suppression.

              Une serie de F_NOTIFY sont cumules, les evenements decrits  dans
              arg  etant  ajoutes a l'ensemble des evenements deja surveilles.
              Pour supprimer les notifications de tous les evenements, il faut
              invoquer F_NOTIFY avec arg valant 0.

              La  notification  se  produit  par  l'occurrence d'un signal. Le
              signal par defaut est SIGIO, mais on peut  le  changer  avec  la
              commande  F_SETSIG  de  fcntl(). Dans ce cas, le gestionnaire de
              signal recoit une structure siginfo_t en second argument (si  le
              gestionnaire a ete installe avec SA_SIGINFO) dont le champ si_fd
              contient  le  descripteur  du  fichier  qui   a   declenche   la
              notification (utile pour superviser plusieurs repertoires).

              En  outre,  avec DN_MULTISHOT, un signal temps-reel devrait etre
              utilise  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'evenements
              sur le systeme de fichiers. Consultez inotify(7).

   Changer la capacit'e d'un tube
       F_SETPIPE_SZ (long ; depuis Linux 2.6.35)
              Change la capacite du tube reference par  fd  pour  contenir  au
              moins  arg  octets.  Un processus non privilegie peut ajuster la
              capacite d'un tube a toute valeur comprise entre  la  taille  de
              page     du     systeme    et    la    limite    definie    dans
              /proc/sys/fs/pipe-size-max (consultez proc(5)).  Les  tentatives
              pour definir la capacite du tube en dessous de la taille de page
              sont  silencieusement  arrondies  a  la  taille  de  page.   Les
              tentatives   d'un  processus  non  privilegie  pour  definir  la
              capacite du tube au dessus de /proc/sys/fs/pipe-size-max renvoie
              l'erreur EPERM ; un processus privilegie (CAP_SYS_RESOURCE) peut
              passer outre cette limite. Quand il alloue  le  tampon  pour  le
              tube,  le  noyau peut utiliser une capacite superieure a arg, si
              cela  est  plus  pratique  pour  l'implementation.   L'operation
              F_GETPIPE_SZ   renvoie   la   taille  reellement  utilisee.  Les
              tentatives pour definir la capacite du tube  en  dessous  de  la
              capacite  du  tampon  actuellement  utilise pour sauvegarder les
              donnees produit l'erreur EBUSY.

       F_GETPIPE_SZ (void ; depuis Linux 2.6.35)
              Renvoie (comme resultat de la  fonction)  la  capacite  du  tube
              reference par fd.

VALEUR RENVOY'EE

       La valeur renvoyee par fcntl() varie suivant le type d'operation :

       F_DUPFD  Le nouveau descripteur.

       F_GETFD  Valeur des attributs du descripteur de fichier.

       F_GETFL  Valeur des attributs d'etat du fichier.

       F_GETLEASE
                Le type bail tenu sur le descripteur de fichier.

       F_GETOWN Le proprietaire du descripteur de fichier.

       F_GETSIG La  valeur  du  signal envoye lorsque la lecture ou l'ecriture
                deviennent possibles,  ou  zero  pour  le  comportement  SIGIO
                traditionnel.

       F_GETPIPE_SZ
                La capacite du tube.

       Toutes les autres commandes :
                Zero.

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

ERREURS

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

       EAGAIN L'operation  est  impossible a cause d'une projection en memoire
              effectuee par un autre processus.

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

       EDEADLK
              Le verrouillage F_SETLKW conduirait a un blocage.

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

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

       EINVAL Pour  F_DUPFD,  arg  est  soit  negatif,  soit  trop grand. Pour
              F_SETSIG, arg n'est pas un numero de signal correct.

       EMFILE Pour F_DUPFD, le processus a deja 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
              echoue.

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

CONFORMIT'E

       SVr4, BSD 4.3, POSIX.1-2001. Seules les  operations  F_DUPFD,  F_GETFD,
       F_SETFD, F_GETFL, F_SETFL, F_GETLK, F_SETLK et F_SETLKW sont specifiees
       dans POSIX.1-2001.

       F_GETOWN et F_SETOWN sont specifiees dans  POSIX.1-2001.  Pour  activer
       ces  definitions,  vous devez definir BSD_SOURCE, ou _XOPEN_SOURCE avec
       une valeur superieure ou egale  a  500,  ou  _POSIX_C_SOURCE  avec  une
       valeur superieure ou egale a 200809L.

       F_GETOWN   est   specifiee   dans   POSIX.1-2008.  Pour  activer  cette
       definition, vous devez  _POSIX_C_SOURCE avec une valeur  superieure  ou
       egale a 200809L, ou _XOPEN_SOURCE avec une valeur superieure ou egale a
       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 specifiques a Linux.
       (Definissez la macro _GNU_SOURCE pour avoir ces definitions).

NOTES

       L'appel systeme fcntl() original de Linux n'a pas ete concu pour  gerer
       les  positions  (dans  la  structure  flock)  dans des fichiers de tres
       grosse taille. En  consequence,  Linux 2.4  a  ajoute  l'appel  systeme
       fcntl64().  Ce nouvel appel systeme utilise une structure differente de
       verrouillage   de   fichier,   flock64,   ainsi   que   les   commandes
       correspondantes  F_GETLK64,  F_SETLK64  et  F_SETLKW64.  Cependant, ces
       details peuvent etre ignores par  les  applications  qui  utilisent  la
       glibc,  car  sa  fonction  fcntl()  encapsule  de  maniere transparente
       l'appel systeme le plus recent disponible.

       Les erreurs renvoyees par dup2(2) ne sont  pas  les  memes  que  celles
       renvoyees par F_DUPFD.

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

       Plusieurs systemes ont d'autres champs dans  struct  flock  comme,  par
       exemple,  l_sysid.  Clairement, l_pid seul ne sera pas tres utile si le
       processus tenant le verrou s'execute sur une autre machine.

BOGUES

       En  raison  d'une  limitation  des  conventions  d'appels  systeme  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  interpretee  par glibc comme une erreur ; la valeur de
       retour de fcntl() sera -1 et errno contiendra l'identifiant  du  groupe
       de  processus (positif). Les operations specifiques a Linux F_SETOWN_EX
       et F_GETOWN_EX evitent ce probleme. Depuis la glibc 2.11, glibc rend le
       probleme  avec  F_GETOWN  invisible en implementant F_GETOWN par-dessus
       F_GETOWN_EX.

       Sous Linux  2.4  et  precedents,  lorsqu'un  processus  non  privilegie
       utilise  F_SETOWN  pour  indiquer le proprietaire 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
       positionne a EPERM, meme si l'appelant a le droit d'envoyer un signal a
       ce  (groupe de) processus. En depit de cette erreur, le proprietaire du
       descripteur de fichier est positionne, et les signaux seront envoyes au
       proprietaire.

       L'implementation  du  verrouillage obligatoire dans toutes les versions
       connues de Linux est sujet a des conditions de concurrence qui la rende
       non  fiable : un appel a write(2) qui chevauche un verrou peut modifier
       les donnees apres que le verrouillage obligatoire  a  ete  acquis ;  un
       appel a read(2) qui chevauche un verrou peut detecter des modifications
       sur des donnees qui ont ete faites  seulement  apres  qu'un  verrou  en
       ecriture  a  ete  acquis.  Des  conditions  de  concurrence  similaires
       existent entre  les  verrous  obligatoires  et  mmap(2).  Il  est  donc
       deconseille 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
       repertoire   Documentation/filesystems   des   sources  du  noyau  (sur
       d'anciens  noyaux,  ces  fichiers  se  trouvent  dans   le   repertoire
       Documentation/ et mandatory-locking.txt est appele 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       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   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'equipe francophone de traduction de Debian (2006-2009).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.