perkamon - en to fr translation catalogue (146 entries)

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: fcntl - manipulate file descriptor
fr: fcntl - Manipuler un descripteur de fichier

note: type: Plain text
en: B<fcntl>()  performs one of the operations described below on the open file descriptor I<fd>.  The operation is determined by I<cmd>.
fr: B<fcntl>() permet de se livrer à diverses opérations sur le descripteur de fichier I<fd>. L'opération en question est déterminée par la valeur de l'argument I<cmd>.

note: type: Plain text
en: B<fcntl>()  can take an optional third argument.  Whether or not this argument is required is determined by I<cmd>.  The required argument type is indicated in parentheses after each I<cmd> name (in most cases, the required type is I<int>, and we identify the argument using the name I<arg>), or I<void> is specified if the argument is not required.
fr: B<fcntl>() accepte un troisième paramètre optionnel. La nécessité de fournir ce paramètre dépend de I<cmd>. Le paramètre doit être du type indiqué entre parenthèses après chaque nom de commande I<cmd> (dans la plupart des cas, le type requis est un I<int>, et le paramètre est identifié en utilisant le nom I<arg>), ou I<void> est indiqué si le paramètre n'est pas nécessaire.

note: type: Plain text
en: Certain of the operations below are supported only since a particular Linux kernel version.  The preferred method of checking whether the host kernel supports a particular operation is to invoke B<fcntl>()  with the desired I<cmd> value and then test whether the call failed with B<EINVAL>, indicating that the kernel does not recognize this value.
fr: Certaines des opérations suivantes ne sont prises en charge qu’à partir d’une version donnée du noyau Linux. La méthode préférée pour vérifier si le noyau hôte prend en charge une certaine opération est d’invoquer B<fcntl>() avec la valeur de I<cmd> voulue et ensuite de tester si l’appel a échoué avec B<EINVAL>, indiquant que le noyau ne reconnaît pas cette valeur.

note: type: SS
en: Duplicating a file descriptor
fr: Dupliquer un descripteur de fichier

note: type: Plain text
en: See B<dup>(2)  for further details.
fr: Consultez B<dup>(2) pour plus d'informations.

note: type: TP
en: B<F_DUPFD_CLOEXEC> (I<int>; since Linux 2.6.24)
fr: B<F_DUPFD_CLOEXEC> (I<int> ; depuis Linux 2.6.24)

note: type: SS
en: File descriptor flags
fr: Attributs du descripteur de fichier

note: type: Plain text
en: Set the file descriptor flags to the value specified by I<arg>.
fr: Positionner les attributs du descripteur de fichier avec la valeur précisée par I<arg>.

note: type: Plain text
en: In multithreaded programs, using B<fcntl>()  B<F_SETFD> to set the close-on-exec flag at the same time as another thread performs a B<fork>(2)  plus B<execve>(2)  is vulnerable to a race condition that may unintentionally leak the file descriptor to the program executed in the child process.  See the discussion of the B<O_CLOEXEC> flag in B<open>(2)  for details and a remedy to the problem.
fr: Dans un programme multithreadé, l'utilisation simultanée dans un thread de B<fcntl>() avec B<F_SETFD> afin de définir l'attribut « close-on-exec » (B<FD_CLOEXEC>), et de B<fork>(2) suivi de B<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 B<O_CLOEXEC> dans B<open>(2) qui décrivent une solution à ce problème.

note: type: SS
en: File status flags
fr: Attribut d'état du fichier

note: or .BR creat (2), type: Plain text
en: Each open file description has certain associated status flags, initialized by B<open>(2)  and possibly modified by B<fcntl>().  Duplicated file descriptors (made with B<dup>(2), B<fcntl>(F_DUPFD), B<fork>(2), etc.) refer to the same open file description, and thus share the same file status flags.
fr: Un descripteur de fichier dispose de certains attributs, initialisés par B<open>(2) et éventuellement modifiés par B<fcntl>(). Les attributs sont partagés entre les copies (obtenues avec B<dup>(2), B<fcntl>(F_DUPFD), B<fork>(2), etc.) du même descripteur de fichier.

note: type: Plain text
en: The file status flags and their semantics are described in B<open>(2).
fr: Les attributs et leurs sémantiques sont décrits dans la page B<open>(2).

note: type: SS
en: Advisory record locking
fr: Verrouillages d’enregistrements coopératifs

note: type: Plain text
en: Linux implements traditional ("process-associated") UNIX record locks, as standardized by POSIX.  For a Linux-specific alternative with better semantics, see the discussion of open file description locks below.
fr: Linux implémente les verrouillages d’enregistrements UNIX traditionnels (« associés au processus »), tel que normalisé par POSIX. Pour une alternative spécifique à Linux avec de meilleures sémantiques, consultez la discussion suivante sur les verrouillages de description de fichier ouvert.

note: type: Plain text
en: B<F_SETLK>, B<F_SETLKW>, and B<F_GETLK> are used to acquire, release, and test for the existence of record locks (also known as byte-range, file-segment, or file-region locks).  The third argument, I<lock>, is a pointer to a structure that has at least the following fields (in unspecified order).
fr: B<F_SETLK>, B<F_SETLKW> et B<F_GETLK> servent à gérer les verrouillages d'enregistrements (d’intervalle d’octets, de segments de fichiers ou de zones de fichiers). Le troisième argument, I<lock>, est un pointeur sur une structure qui a au moins les champs suivants (dans un ordre non indiqué).

note: type: Plain text
en: struct flock {
        ...
        short l_type;    /* Type of lock: F_RDLCK,
                            F_WRLCK, F_UNLCK */
        short l_whence;  /* How to interpret l_start:
                            SEEK_SET, SEEK_CUR, SEEK_END */
        off_t l_start;   /* Starting offset for lock */
        off_t l_len;     /* Number of bytes to lock */
        pid_t l_pid;     /* PID of process blocking our lock
                            (set by F_GETLK and F_OFD_GETLK) */
        ...
    };
fr: 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
                            (mis par F_GETLK et F_OFD_GETLK seulement) */
        ...
    };

note: type: Plain text
en: The I<l_whence>, I<l_start>, and I<l_len> fields of this structure specify the range of bytes we wish to lock.  Bytes past the end of the file may be locked, but not bytes before the start of the file.
fr: Les champs I<l_whence>, I<l_start> et I<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.

note: type: Plain text
en: I<l_start> is the starting offset for the lock, and is interpreted relative to either: the start of the file (if I<l_whence> is B<SEEK_SET>); the current file offset (if I<l_whence> is B<SEEK_CUR>); or the end of the file (if I<l_whence> is B<SEEK_END>).  In the final two cases, I<l_start> can be a negative number provided the offset does not lie before the start of the file.
fr: I<l_start> est la position de début du verrou, et est interprété de façon relative : au début du fichier (si I<l_whence> vaut B<SEEK_SET>) ; à la position actuelle dans le fichier (si I<l_whence> vaut B<SEEK_CUR>) ; à la fin du fichier (si I<l_whence> vaut B<SEEK_END>). Dans les deux derniers cas, I<l_start> peut être un nombre négatif, à partir du moment où la position fournie ne pointe pas avant le début du fichier.

note: type: Plain text
en: I<l_len> specifies the number of bytes to be locked.  If I<l_len> is positive, then the range to be locked covers bytes I<l_start> up to and including I<l_start>+I<l_len>-1.  Specifying 0 for I<l_len> has the special meaning: lock all bytes starting at the location specified by I<l_whence> and I<l_start> through to the end of file, no matter how large the file grows.
fr: I<l_len> indique le nombre d'octets à verrouiller. Si I<l_len> est positif, alors l'intervalle à verrouiller couvre les octets à partir de I<l_start> jusqu'à I<l_start>+I<l_len>-1 (inclus). Indiquer 0 dans I<l_len> a une signification particulière : cela verrouille tous les octets à partir de la position indiquée par I<l_whence> et I<l_start> jusqu'à la fin du fichier, quelle que soit la taille que prendra la fichier.

note: type: Plain text
en: POSIX.1-2001 allows (but does not require)  an implementation to support a negative I<l_len> value; if I<l_len> is negative, the interval described by I<lock> covers bytes I<l_start>+I<l_len> up to and including I<l_start>-1.  This is supported by Linux since kernel versions 2.4.21 and 2.5.49.
fr: POSIX.1-2001 permet (mais n'impose pas) à une implémentation de prendre en charge des valeurs de I<l_len> négatives ; si I<l_len> est négatif, l'intervalle décrivant le verrou I<lock> couvre les octets I<l_start>+I<l_len> jusqu'à I<l_start>-1 inclus. Ceci est supporté par Linux depuis les versions 2.4.21 et 2.5.49.

note: type: Plain text
en: The I<l_type> field can be used to place a read (B<F_RDLCK>)  or a write (B<F_WRLCK>)  lock on a file.  Any number of processes may hold a read lock (shared lock)  on a file region, but only one process may hold a write lock (exclusive lock).  An exclusive lock excludes all other locks, both shared and exclusive.  A single process can hold only one type of lock on a file region; if a new lock is applied to an already-locked region, then the existing lock is converted to the new lock type.  (Such conversions may involve splitting, shrinking, or coalescing with an existing lock if the byte range specified by the new lock does not precisely coincide with the range of the existing lock.)
fr: Le champ I<l_type> peut servir à placer un verrou en lecture (B<F_RDLCK>) ou en écriture (B<F_WRLCK>) sur un fichier. Un nombre quelconque de processus peuvent tenir un verrou en lecture (partagé), sur une zone 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 zone d'un fichier ; si un nouveau verrou est appliqué sur une zone déjà verrouillée, alors le verrou précédent est converti suivant le nouveau type. Ces conversions pourraient 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.

note: type: Plain text
en: Acquire a lock (when I<l_type> is B<F_RDLCK> or B<F_WRLCK>)  or release a lock (when I<l_type> is B<F_UNLCK>)  on the bytes specified by the I<l_whence>, I<l_start>, and I<l_len> fields of I<lock>.  If a conflicting lock is held by another process, this call returns -1 and sets I<errno> to B<EACCES> or B<EAGAIN>.  (The error returned in this case differs across implementations, so POSIX requires a portable application to check for both errors.)
fr: Acquérir (si I<l_type> vaut B<F_RDLCK> ou B<F_WRLCK>) ou libérer (si I<l_type> vaut B<F_UNLCK>) le verrou sur les octets indiqués par les champs I<l_whence>, I<l_start>, et I<l_len> de I<lock>. Si un conflit avec un verrou tenu par un autre processus existe, cet appel renvoie -1 et positionne I<errno> aux valeurs B<EACCES> ou B<EAGAIN> (l’erreur renvoyée dans ce cas dépend des implémentations, donc POSIX impose aux applications portables de vérifier les deux erreurs).

note: type: Plain text
en: As for B<F_SETLK>, but if a conflicting lock is held on the file, then wait for that lock to be released.  If a signal is caught while waiting, then the call is interrupted and (after the signal handler has returned)  returns immediately (with return value -1 and I<errno> set to B<EINTR>; see B<signal>(7)).
fr: Comme B<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. I<errno> sera remplie avec la valeur B<EINTR> ; consultez B<signal>(7).

note: type: Plain text
en: On input to this call, I<lock> describes a lock we would like to place on the file.  If the lock could be placed, B<fcntl>()  does not actually place it, but returns B<F_UNLCK> in the I<l_type> field of I<lock> and leaves the other fields of the structure unchanged.
fr: En entrée dans cette routine, I<lock> décrit un verrou que nous aimerions placer sur le fichier. Si le verrouillage est possible, B<fcntl>() ne le fait pas, mais renvoie B<F_UNLCK> dans le champ I<l_type> de I<lock> et laisse les autres champs de la structure inchangés.

note: type: Plain text
en: If one or more incompatible locks would prevent this lock being placed, then B<fcntl>()  returns details about one of those locks in the I<l_type>, I<l_whence>, I<l_start>, and I<l_len> fields of I<lock>.  If the conflicting lock is a traditional (process-associated) record lock, then the I<l_pid> field is set to the PID of the process holding that lock.  If the conflicting lock is an open file description lock, then I<l_pid> is set to -1.  Note that the returned information may already be out of date by the time the caller inspects it.
fr: Si un ou plusieurs verrouillages incompatibles empêchaient l'action, alors B<fcntl>() renvoie des informations sur l'un de ces verrous dans les champs I<l_type>, I<l_whence>, I<l_start>, et I<l_len> de I<lock>. Si le verrouillage en conflit est un verrouillage d’enregistrements UNIX traditionnels (« associé au processus »), alors le champ I<l_pid> est défini avec le PID du processus détenant ce verrou. Si le verrouillage en conflit est un verrouillage de description de fichier ouvert, alors I<l_pid> est défini à -1. Remarquez que les renseignements renvoyés pourraient déjà être périmés au moment ou l’appelant les inspecte.

note: type: Plain text
en: In order to place a read lock, I<fd> must be open for reading.  In order to place a write lock, I<fd> must be open for writing.  To place both types of lock, open a file read-write.
fr: Pour pouvoir placer un verrou en lecture, I<fd> doit être ouvert au moins en lecture. Pour placer un verrou en écriture, I<fd> doit être ouvert en écriture. Pour placer les deux types de verrous, il faut une ouverture en lecture/écriture.

note: type: Plain text
en: When placing locks with B<F_SETLKW>, the kernel detects I<deadlocks>, whereby two or more processes have their lock requests mutually blocked by locks held by the other processes.  For example, suppose process A holds a write lock on byte 100 of a file, and process B holds a write lock on byte 200.  If each process then attempts to lock the byte already locked by the other process using B<F_SETLKW>, then, without deadlock detection, both processes would remain blocked indefinitely.  When the kernel detects such deadlocks, it causes one of the blocking lock requests to immediately fail with the error B<EDEADLK>; an application that encounters such an error should release some of its locks to allow other applications to proceed before attempting regain the locks that it requires.  Circular deadlocks involving more than two processes are also detected.  Note, however, that there are limitations to the kernel's deadlock-detection algorithm; see BUGS.
fr: Lors du placement de verrous avec B<F_SETLKW>, le noyau détecte les interblocages (I<deadlocks>), au moyen desquels au moins deux processus ont leurs demandes de verrouillage réciproquement bloquées par des verrous détenus par d’autres processus. Par exemple, supposons qu’un processus A détient un verrou d’écriture sur l’octet 100 d’un fichier et qu’un processus B détient un verrou d’écriture sur l’octet 200. Si les deux processus tentent alors de verrouiller l’octet déjà verrouillé par l’autre processus en utilisant B<F_SETLKW>, alors, sans détection d’interblocage, les deux processus resteront bloqués indéfiniment. Quand le noyau détecte ce type d’interblocages, il force l’une des demandes bloquantes de verrouillage à échouer immédiatement avec l’erreur B<EDEADLK> ; une application qui rencontre ce type d’erreur devrait libérer certains de ses verrous pour permettre à d’autres applications de continuer avant de tenter d’obtenir de nouveau les verrous dont elle a besoin. Les interblocages circulaires, impliquant plus de deux processus, sont également détectés. Remarquez, cependant, que l’algorithme de détection d’interblocages du noyau a ses limites, consultez B<BOGUES>.

note: type: Plain text
en: As well as being removed by an explicit B<F_UNLCK>, record locks are automatically released when the process terminates.
fr: Outre la suppression par un B<F_UNLCK> explicite, les verrous sont automatiquement libérés lorsque le processus se termine.

note: type: Plain text
en: Record locks are not inherited by a child created via B<fork>(2), but are preserved across an B<execve>(2).
fr: Les verrouillages d'enregistrements ne sont pas hérités par les enfants lors d'un B<fork>(2), mais sont conservés au travers d'un B<execve>(2).

note: type: Plain text
en: Because of the buffering performed by the B<stdio>(3)  library, the use of record locking with routines in that package should be avoided; use B<read>(2)  and B<write>(2)  instead.
fr: À cause des tampons gérés par la bibliothèque B<stdio>(3), l'utilisation des verrous d'enregistrements avec les routines de celle\(hyci est déconseillé. Utilisez plutôt B<read>(2) et B<write>(2).

note: type: Plain text
en: The record locks described above are associated with the process (unlike the open file description locks described below).  This has some unfortunate consequences:
fr: Les verrouillages d'enregistrements décrits précédemment sont associés au processus (contrairement aux verrouillages de description de fichier ouvert décrits ci-dessous). Cela a quelques conséquences malheureuses.

note: (Additional file descriptors referring to the same file may have been obtained by calls to .BR open "(2), " dup "(2), " dup2 "(2), or " fcntl ().) type: Plain text
en: If a process closes I<any> file descriptor referring to a file, then all of the process's locks on that file are released, regardless of the file descriptor(s) on which the locks were obtained.  This is bad: it means that a process can lose its locks on a file such as I</etc/passwd> or I</etc/mtab> when for some reason a library function decides to open, read, and close the same file.
fr: Si le processus ferme I<l'un> des descripteurs se référant à un fichier, alors tous les verrous du processus sur ce fichier sont libérés, quels que soient le ou les descripteurs de fichier sur lesquels les verrous avaient été obtenus. C'est dangereux\ : cela signifie qu'un processus peut perdre ses verrous sur un fichier comme I</etc/passwd> ou I</etc/mtab> si, pour une raison quelconque, une fonction de bibliothèque décide d’ouvrir, lire, puis refermer le même fichier.

note: type: Plain text
en: The threads in a process share locks.  In other words, a multithreaded program can't use record locking to ensure that threads don't simultaneously access the same region of a file.
fr: Les processus légers d’un processus partagent les verrous. Autrement dit, un programme multithreadé ne pas pas utiliser de verrouillage d’enregistrement pour s’assurer que les processus légers ne vont pas accéder simultanément à la même zone d’un fichier.

note: type: Plain text
en: Open file description locks solve both of these problems.
fr: Les verrouillages de description de fichier ouvert apportent une solution à ces deux problèmes.

note: type: SS
en: Open file description locks (non-POSIX)
fr: Verrouillages de description de fichier ouvert (non POSIX)

note: type: Plain text
en: The principal difference between the two lock types is that whereas traditional record locks are associated with a process, open file description locks are associated with the open file description on which they are acquired, much like locks acquired with B<flock>(2).  Consequently (and unlike traditional advisory record locks), open file description locks are inherited across B<fork>(2)  (and B<clone>(2)  with B<CLONE_FILES>), and are only automatically released on the last close of the open file description, instead of being released on any close of the file.
fr: La principale différence entre les deux types de verrouillage est que les verrouillages d’enregistrements traditionnels sont associés à un processus, alors que les verrouillages de description de fichier ouvert sont associés à la description de fichier ouvert sur laquelle ils sont obtenus, tout comme les verrous obtenus avec B<flock>(2). Par conséquent (et contrairement aux verrouillages d’enregistrements coopératifs traditionnels), les verrouillages de description de fichier ouvert sont hérités entre B<fork>(2) (et B<clone>(2) avec B<CLONE_FILES>) et ne sont automatiquement libérés que lors de la dernière fermeture de la description de fichier ouvert, au lieu d’être libérés lors de n’importe quelle fermeture du fichier.

note: type: Plain text
en: On the other hand, open file description locks may conflict with each other when they are acquired via different open file descriptions.  Thus, the threads in a multithreaded program can use open file description locks to synchronize access to a file region by having each thread perform its own B<open>(2)  on the file and applying locks via the resulting file descriptor.
fr: En revanche, les verrouillages de description de fichier ouvert peuvent être en conflit entre eux quand ils sont obtenus à l’aide de descriptions de fichier ouvert différentes. Ainsi, les processus légers dans un programme multithreadé peuvent utiliser des verrouillages de description de fichier ouvert pour synchroniser l’accès à une zone de fichier si tous les processus légers réalisent leur propre appel d’B<open>(2) sur le fichier et utilisent les verrouillages à l’aide du descripteur de fichier qui en résulte.

note: type: Plain text
en: As with traditional advisory locks, the third argument to B<fcntl>(), I<lock>, is a pointer to an I<flock> structure.  By contrast with traditional record locks, the I<l_pid> field of that structure must be set to zero when using the commands described below.
fr: Comme avec les verrouillages coopératifs traditionnels, le troisième argument de B<fcntl>(), I<lock>, est un pointeur vers une structure I<flock>. Contrairement aux verrouillages d’enregistrements traditionnels, le champ I<l_pid> de cette structure doit être mis à zéro lors de l’utilisation des commandes décrites ci-dessous.

note: type: Plain text
en: The commands for working with open file description locks are analogous to those used with traditional locks:
fr: Les commandes permettant d’interagir avec les verrouillages de description de fichier ouvert sont similaires à celles utilisées avec les verrouillages traditionnels.

note: type: Plain text
en: Acquire an open file description lock (when I<l_type> is B<F_RDLCK> or B<F_WRLCK>)  or release an open file description lock (when I<l_type> is B<F_UNLCK>)  on the bytes specified by the I<l_whence>, I<l_start>, and I<l_len> fields of I<lock>.  If a conflicting lock is held by another process, this call returns -1 and sets I<errno> to B<EAGAIN>.
fr: Acquérir (si I<l_type> vaut B<F_RDLCK> ou B<F_WRLCK>) ou libérer (si I<l_type> vaut B<F_UNLCK>) un verrou de description de fichier ouvert sur les octets indiqués par les champs I<l_whence>, I<l_start> et I<l_len> de I<lock>. Si un conflit avec un verrou détenu par un autre processus existe, cet appel renvoie -1 et définit I<errno> à B<EAGAIN>.

note: type: Plain text
en: As for B<F_OFD_SETLK>, but if a conflicting lock is held on the file, then wait for that lock to be released.  If a signal is caught while waiting, then the call is interrupted and (after the signal handler has returned) returns immediately (with return value -1 and I<errno> set to B<EINTR>; see B<signal>(7)).
fr: Comme B<F_OFD_SETLK>, mais attend la libération du verrou au lieu de renvoyer 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. I<errno> sera définie B<EINTR> ; consultez B<signal>(7).

note: type: Plain text
en: On input to this call, I<lock> describes an open file description lock we would like to place on the file.  If the lock could be placed, B<fcntl>()  does not actually place it, but returns B<F_UNLCK> in the I<l_type> field of I<lock> and leaves the other fields of the structure unchanged.  If one or more incompatible locks would prevent this lock being placed, then details about one of these locks are returned via I<lock>, as described above for B<F_GETLK>.
fr: En entrée dans cette routine, I<lock> décrit un verrou de description de fichier ouvert que nous aimerions placer sur le fichier. Si le verrouillage est possible, B<fcntl>() ne le fait pas, mais renvoie B<F_UNLCK> dans le champ I<l_type> de I<lock> et laisse les autres champs de la structure inchangés. Si un ou plusieurs verrouillages incompatibles empêchaient l'action, alors des informations sur l'un de ces verrous sont renvoyés à l’aide de I<lock>, comme décrit précédemment pour B<F_GETLK>.

note: commit 57b65325fe34ec4c917bc4e555144b4a94d9e1f7 type: Plain text
en: In the current implementation, no deadlock detection is performed for open file description locks.  (This contrasts with process-associated record locks, for which the kernel does perform deadlock detection.)
fr: Dans l’implémentation actuelle, aucune détection d’interblocage n’est réalisée pour les verrouillages de description de fichier ouvert (contrairement aux verrouillages d’enregistrements associés au processus, pour lesquels le noyau réalise une détection d’interblocage).

note: type: SS
en: Mandatory locking
fr: Verrouillage impératif

note: type: Plain text
en: By default, both traditional (process-associated) and open file description record locks are advisory.  Advisory locks are not enforced and are useful only between cooperating processes.
fr: Par défaut, à la fois les verrouillages d’enregistrements traditionnels (associés au processus) et ceux de description de fichier ouvert sont coopératifs. Les verrouillages coopératifs ne sont pas imposés, donc ils ne fonctionnent qu'entre processus qui les utilisent.

note: type: Plain text
en: Both lock types can also be mandatory.  Mandatory locks are enforced for all processes.  If a process tries to perform an incompatible access (e.g., B<read>(2)  or B<write>(2))  on a file region that has an incompatible mandatory lock, then the result depends upon whether the B<O_NONBLOCK> flag is enabled for its open file description.  If the B<O_NONBLOCK> flag is not enabled, then the system call is blocked until the lock is removed or converted to a mode that is compatible with the access.  If the B<O_NONBLOCK> flag is enabled, then the system call fails with the error B<EAGAIN>.
fr: Les deux types de verrouillages peuvent aussi être impératifs. Les verrous impératifs sont appliqués à tous les processus. Si un processus tente d'effectuer un accès incompatible (par exemple B<read>(2) ou B<write>(2)) sur une zone d'un fichier qui a un verrou impératif, le résultat dépend de l'attribut B<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 B<O_NONBLOCK> est activé, l'appel système échoue avec l'erreur B<EAGAIN>.

note: type: Plain text
en: To make use of mandatory locks, mandatory locking must be enabled both on the filesystem that contains the file to be locked, and on the file itself.  Mandatory locking is enabled on a filesystem using the "-o mand" option to B<mount>(8), or the B<MS_MANDLOCK> flag for B<mount>(2).  Mandatory locking is enabled on a file by disabling group execute permission on the file and enabling the set-group-ID permission bit (see B<chmod>(1)  and B<chmod>(2)).
fr: 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 B<mount>(8)), ou l'attribut B<MS_MANDLOCK> de B<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 B<chmod>(1) et B<chmod>(2)).

note: type: Plain text
en: Mandatory locking is not specified by POSIX.  Some other systems also support mandatory locking, although the details of how to enable it vary across systems.
fr: Le verrouillage impératif n’est pas défini par POSIX. Certains autres systèmes permettent également d’utiliser le verrouillage impératif, mais la façon de l’activer dépend des systèmes.

note: type: SS
en: Managing signals
fr: Gestion des signaux

note: type: Plain text
en: B<F_GETOWN>, B<F_SETOWN>, B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG> and B<F_SETSIG> are used to manage I/O availability signals:
fr: B<F_GETOWN>, B<F_SETOWN>, B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG> et B<F_SETSIG> servent à gérer les signaux de disponibilité d'entrée-sortie\ :

note: type: Plain text
en: Return (as the function result)  the process ID or process group currently receiving B<SIGIO> and B<SIGURG> signals for events on file descriptor I<fd>.  Process IDs are returned as positive values; process group IDs are returned as negative values (but see BUGS below).  I<arg> is ignored.
fr: Renvoyer (comme résultat de la fonction) le PID ou l'ID du groupe de processus qui reçoit les signaux B<SIGIO> et B<SIGURG> pour les événements concernant le descripteur de fichier I<fd>. Les groupes de processus sont renvoyés sous forme de valeurs négatives (consultez la section BOGUES ci\(hydessous). I<arg> est ignoré.

note: The following appears to be rubbish.  It doesn't seem to be true according to the kernel source, and I can write a program that gets a terminal-generated SIGIO even though it is not the foreground process group of the terminal. -- MTK, 8 Apr 05 If the file descriptor .I fd refers to a terminal devic
en: If the file descriptor I<fd> refers to a socket, B<F_SETOWN> also selects the recipient of B<SIGURG> signals that are delivered when out-of-band data arrives on that socket.  (B<SIGURG> is sent in any situation where B<select>(2)  would report the socket as having an "exceptional condition".)
fr: Si le descripteur I<fd> est une socket, B<F_SETOWN> permet également la réception de signaux B<SIGURG> lorsque des données hors\(hybande arrivent sur la socket. (B<SIGURG> est émis dans toutes les situations où l'appel B<select>(2) aurait indiqué que la socket est dans une «\ situation exceptionnelle\ ».)

note: type: Plain text
en: The following was true in 2.6.x kernels up to and including kernel 2.6.11:
fr: Le paragraphe ci-dessous était valide pour les noyaux 2.6.x, jusqu'au 2.6.11 inclus\ :

note: The relevant place in the (2.6) kernel source is the 'switch' in fs/fcntl.c::send_sigio_to_task() -- MTK, Apr 2005 send_sigurg()/send_sigurg_to_task() bypasses kill_fasync()/send_sigio()/send_sigio_to_task() to directly call send_group_sig_info() -- MTK, Apr 2005 (kernel 2.6.11) type: Plain text
en: If a nonzero value is given to B<F_SETSIG> in a multithreaded process running with a threading library that supports thread groups (e.g., NPTL), then a positive value given to B<F_SETOWN> has a different meaning: instead of being a process ID identifying a whole process, it is a thread ID identifying a specific thread within a process.  Consequently, it may be necessary to pass B<F_SETOWN> the result of B<gettid>(2)  instead of B<getpid>(2)  to get sensible results when B<F_SETSIG> is used.  (In current Linux threading implementations, a main thread's thread ID is the same as its process ID.  This means that a single-threaded program can equally use B<gettid>(2)  or B<getpid>(2)  in this scenario.)  Note, however, that the statements in this paragraph do not apply to the B<SIGURG> signal generated for out-of-band data on a socket: this signal is always sent to either a process or a process group, depending on the value given to B<F_SETOWN>.
fr: Si une valeur non nulle est passée à B<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 à B<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 à B<F_SETOWN> la valeur renvoyée par B<gettid>(2) plutôt que celle renvoyée par B<getpid>(2) pour obtenir les résultats souhaités si B<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 B<gettid>(2) ou B<getpid>(2).) Veuillez toutefois noter que les remarques de ce paragraphe ne s'appliquent pas au signal B<SIGURG> généré lorsque des données hors\(hybande sont disponibles sur une socket\ : ce signal est toujours envoyé soit à un processus, soit à un groupe de processus, selon la valeur donnée à B<F_SETOWN>.

note: type: Plain text
en: The above behavior was accidentally dropped in Linux 2.6.12, and won't be restored.  From Linux 2.6.32 onward, use B<F_SETOWN_EX> to target B<SIGIO> and B<SIGURG> signals at a particular thread.
fr: 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 B<F_SETOWN_EX> pour envoyer les signaux B<SIGIO> et B<SIGURG> à un thread en particulier.

note: type: Plain text
en: Return the current file descriptor owner settings as defined by a previous B<F_SETOWN_EX> operation.  The information is returned in the structure pointed to by I<arg>, which has the following form:
fr: Renvoyer les paramètres du propriétaire du descripteur de fichier actuel, tels que définis par une utilisation antérieure de B<F_SETOWN_EX>. L'information est renvoyée dans la structure pointée par I<arg>, qui a la forme suivante\ :

note: type: Plain text
en: The I<type> field will have one of the values B<F_OWNER_TID>, B<F_OWNER_PID>, or B<F_OWNER_PGRP>.  The I<pid> field is a positive integer representing a thread ID, process ID, or process group ID.  See B<F_SETOWN_EX> for more details.
fr: Le champ I<type> aura l'une des valeurs B<F_OWNER_TID>, B<F_OWNER_PID> ou B<F_OWNER_PGRP>. Le champ I<pid> est un entier positif représentant un identifiant de thread, de processus ou de groupe de processus. Consultez B<F_SETOWN_EX> pour plus de détails.

note: type: Plain text
en: This operation performs a similar task to B<F_SETOWN>.  It allows the caller to direct I/O availability signals to a specific thread, process, or process group.  The caller specifies the target of signals via I<arg>, which is a pointer to a I<f_owner_ex> structure.  The I<type> field has one of the following values, which define how I<pid> is interpreted:
fr: Cette opération effectue une tâche similaire à B<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 I<arg>, qui est un pointeur vers une structure I<f_owner_ex>. Le champ I<type> possède l'une des valeurs suivantes, qui définit comment I<pid> est interprété\ :

note: type: Plain text
en: Send the signal to the thread whose thread ID (the value returned by a call to B<clone>(2)  or B<gettid>(2))  is specified in I<pid>.
fr: Envoyer le signal au thread dont l'identifiant (la valeur renvoyée par un appel à B<clone>(2) ou B<gettid>(2)) est indiqué par I<pid>.

note: type: Plain text
en: Send the signal to the process whose ID is specified in I<pid>.
fr: Envoyer le signal au processus dont l'identifiant est indiqué par I<pid>.

note: type: Plain text
en: Send the signal to the process group whose ID is specified in I<pid>.  (Note that, unlike with B<F_SETOWN>, a process group ID is specified as a positive value here.)
fr: Envoyer le signal au groupe de processus dont l'identifiant est indiqué par I<pid>. Notez que, à la différence de B<F_SETOWN>, un identifiant de groupe est indiqué ici avec une valeur positive.

note: type: Plain text
en: Return (as the function result)  the signal sent when input or output becomes possible.  A value of zero means B<SIGIO> is sent.  Any other value (including B<SIGIO>)  is the signal sent instead, and in this case additional info is available to the signal handler if installed with B<SA_SIGINFO>.  I<arg> is ignored.
fr: 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 B<SIGIO>. Toute autre valeur (y compris B<SIGIO>) précise le signal émis, et des informations supplémentaires seront disponibles pour le gestionnaire s'il est installé avec B<SA_SIGINFO>. I<arg> est ignoré.

note: The following was true only up until 2.6.11: Additionally, passing a nonzero value to .B F_SETSIG changes the signal recipient from a whole process to a specific thread within a process. See the description of .B F_SETOWN for more details. type: Plain text
en: Set the signal sent when input or output becomes possible to the value given in I<arg>.  A value of zero means to send the default B<SIGIO> signal.  Any other value (including B<SIGIO>)  is the signal to send instead, and in this case additional info is available to the signal handler if installed with B<SA_SIGINFO>.
fr: Définir le signal à émettre lorsque l'entrée ou la sortie deviennent possibles à la valeur fournie par I<arg>. Une valeur nulle signifie l'émission de B<SIGIO>. Toute autre valeur (y compris B<SIGIO>) précise le signal à émettre, et des informations supplémentaires seront disponibles pour le gestionnaire s'il est installé avec B<SA_SIGINFO>.

note: type: Plain text
en: By using B<F_SETSIG> with a nonzero value, and setting B<SA_SIGINFO> for the signal handler (see B<sigaction>(2)), extra information about I/O events is passed to the handler in a I<siginfo_t> structure.  If the I<si_code> field indicates the source is B<SI_SIGIO>, the I<si_fd> field gives the file descriptor associated with the event.  Otherwise, there is no indication which file descriptors are pending, and you should use the usual mechanisms (B<select>(2), B<poll>(2), B<read>(2)  with B<O_NONBLOCK> set etc.) to determine which file descriptors are available for I/O.
fr: En utilisant B<F_SETSIG> avec une valeur non nulle, et en configurant B<SA_SIGINFO> pour le gestionnaire (consultez B<sigaction>(2)), des informations supplémentaires sur les événements d'entrées-sorties sont fournies au gestionnaire à travers une structure I<siginfo_t>. Si le champ I<si_code> indique que la source est B<SI_SIGIO>, le champ I<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 (B<select>(2), B<poll>(2), B<read>(2) avec B<O_NONBLOCK> configuré etc.) pour déterminer quels descripteurs sont disponibles pour les entrées-sorties.

note: See fs/fcntl.c::send_sigio_to_task() (2.4/2.6) sources -- MTK, Apr 05 type: Plain text
en: Note that Linux imposes a limit on the number of real-time signals that may be queued to a process (see B<getrlimit>(2)  and B<signal>(7))  and if this limit is reached, then the kernel reverts to delivering B<SIGIO>, and this signal is delivered to the entire process rather than to a specific thread.
fr: Noter que Linux impose une limite sur le nombre de signaux temps réel qui peuvent être mis en attente pour un processus (consultez B<getrlimit>(2) et B<signal>(7)), et si cette limite est atteinte, le noyau change de comportement et envoie B<SIGIO>, et ce signal est délivré au processus entier plutôt qu'au thread spécifique.

note: type: Plain text
en: Using these mechanisms, a program can implement fully asynchronous I/O without using B<select>(2)  or B<poll>(2)  most of the time.
fr: 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 B<select>(2) ou B<poll>(2).

note: type: Plain text
en: The use of B<O_ASYNC> is specific to BSD and Linux.  The only use of B<F_GETOWN> and B<F_SETOWN> specified in POSIX.1 is in conjunction with the use of the B<SIGURG> signal on sockets.  (POSIX does not specify the B<SIGIO> signal.)  B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG>, and B<F_SETSIG> are Linux-specific.  POSIX has asynchronous I/O and the I<aio_sigevent> structure to achieve similar things; these are also available in Linux as part of the GNU C Library (Glibc).
fr: L'utilisation de B<O_ASYNC> est spécifique à BSD et Linux. La seule utilisation de B<F_GETOWN> et B<F_SETOWN> spécifiée dans POSIX.1 est en conjonction avec l’utilisation du signal B<SIGURG> sur les sockets (POSIX ne spécifie pas le signal B<SIGIO>). B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG> et B<F_SETSIG> sont spécifiques à Linux. POSIX dispose d'entrées-sorties asynchrones et de la structure I<aio_sigevent> pour effectuer la même chose. Ceci est également disponible sous Linux dans la bibliothèque GNU C (Glibc).

note: type: SS
en: Leases
fr: Baux

note: type: Plain text
en: Set or remove a file lease according to which of the following values is specified in the integer I<arg>:
fr: Définit ou supprime un bail de fichier en fonction de la valeur fournie dans l'entier I<arg>\ :

note: The following became true in kernel 2.6.10: See the man-pages-2.09 Changelog for further info. type: Plain text
en: Take out a read lease.  This will cause the calling process to be notified when the file is opened for writing or is truncated.  A read lease can be placed only on a file descriptor that is opened read-only.
fr: 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.

note: type: Plain text
en: Take out a write lease.  This will cause the caller to be notified when the file is opened for reading or writing or is truncated.  A write lease may be placed on a file only if there are no other open file descriptors for the file.
fr: 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.

note: type: Plain text
en: Remove our lease from the file.
fr: Supprimer le bail sur un fichier.

note: type: Plain text
en: Leases may be taken out only on regular files.  An unprivileged process may take out a lease only on a file whose UID (owner) matches the filesystem UID of the process.  A process with the B<CAP_LEASE> capability may take out leases on arbitrary files.
fr: 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é B<CAP_LEASE> peut prendre un bail sur n'importe quel fichier.

note: type: Plain text
en: Indicates what type of lease is associated with the file descriptor I<fd> by returning either B<F_RDLCK>, B<F_WRLCK>, or B<F_UNLCK>, indicating, respectively, a read lease , a write lease, or no lease.  I<arg> is ignored.
fr: Indique le type de bail possédé sur le descripteur de fichier I<fd> en renvoyant B<F_RDLCK>, B<F_WRLCK>, ou B<F_UNLCK>, signifiant respectivement que le processus appelant a un bail en lecture, écriture, ou pas de bail sur le fichier. I<arg> est ignoré.

note: type: Plain text
en: When a process (the "lease breaker") performs an B<open>(2)  or B<truncate>(2)  that conflicts with a lease established via B<F_SETLEASE>, the system call is blocked by the kernel and the kernel notifies the lease holder by sending it a signal (B<SIGIO> by default).  The lease holder should respond to receipt of this signal by doing whatever cleanup is required in preparation for the file to be accessed by another process (e.g., flushing cached buffers) and then either remove or downgrade its lease.  A lease is removed by performing an B<F_SETLEASE> command specifying I<arg> as B<F_UNLCK>.  If the lease holder currently holds a write lease on the file, and the lease breaker is opening the file for reading, then it is sufficient for the lease holder to downgrade the lease to a read lease.  This is done by performing an B<F_SETLEASE> command specifying I<arg> as B<F_RDLCK>.
fr: Lorsqu'un processus (le «\ casseur de bail\ » appelle B<open>(2) ou B<truncate>(2) en conflit avec un bail établi par B<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 (B<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 B<F_SETLEASE> avec I<arg> valant B<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 B<F_SETLEASE> avec I<arg> valant B<F_RDLCK>.

note: type: Plain text
en: If the lease holder fails to downgrade or remove the lease within the number of seconds specified in I</proc/sys/fs/lease-break-time>, then the kernel forcibly removes or downgrades the lease holder's lease.
fr: Si le détenteur du bail n'arrive pas à le déclasser ou le supprimer avant le nombre de secondes indiqué dans I</proc/sys/fs/lease-break-time> alors le noyau supprimera ou déclassera de force le bail du processus qui le tient.

note: type: Plain text
en: Once a lease break has been initiated, B<F_GETLEASE> returns the target lease type (either B<F_RDLCK> or B<F_UNLCK>, depending on what would be compatible with the lease breaker)  until the lease holder voluntarily downgrades or removes the lease or the kernel forcibly does so after the lease break timer expires.
fr: Dès qu'un cassage de bail a été commencé, B<F_GETLEASE> renvoie le type de bail cible (B<F_RDLCK> ou B<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.

note: type: Plain text
en: Once the lease has been voluntarily or forcibly removed or downgraded, and assuming the lease breaker has not unblocked its system call, the kernel permits the lease breaker's system call to proceed.
fr: 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.

note: type: Plain text
en: If the lease breaker's blocked B<open>(2)  or B<truncate>(2)  is interrupted by a signal handler, then the system call fails with the error B<EINTR>, but the other steps still occur as described above.  If the lease breaker is killed by a signal while blocked in B<open>(2)  or B<truncate>(2), then the other steps still occur as described above.  If the lease breaker specifies the B<O_NONBLOCK> flag when calling B<open>(2), then the call immediately fails with the error B<EWOULDBLOCK>, but the other steps still occur as described above.
fr: Si l'appel à B<open>(2) ou B<truncate>(2) du casseur de bail est interrompu par un gestionnaire de signal, l'appel système échoue avec l'erreur B<EINTR>, mais les autres étapes décrites ci\(hydessous se déroulent normalement. Si le casseur de bail est tué par un signal pendant que son appel système B<open>(2) ou B<truncate>(2) bloque, tout se déroule comme décrit ci\(hydessus. De même, si le casseur de bail utilise l'option B<O_NONBLOCK> de B<open>(2), l'appel retourne immédiatement avec l'erreur B<EWOULDBLOCK>, mais les autres étapes se déroulent comme décrit ci\(hydessus.

note: type: SS
en: File and directory change notification (dnotify)
fr: Notification de modification de fichier et de répertoire (dnotify)

note: type: Plain text
en: (Linux 2.4 onward)  Provide notification when the directory referred to by I<fd> or any of the files that it contains is changed.  The events to be notified are specified in I<arg>, which is a bit mask specified by ORing together zero or more of the following bits:
fr: (Depuis Linux 2.4) Fournit un avertissement lorsque le répertoire correspondant à I<fd> ou l'un des fichiers qu'il contient est modifié. Les événements à notifier sont précisés dans I<arg>, sous forme de masque regroupant par un OU binaire zéro, une ou plusieurs des constantes suivantes\ :

note: type: Plain text
en: A file was accessed (B<read>(2), B<pread>(2), B<readv>(2), and similar)
fr: Accès à un fichier (iB<read>(2), B<pread>(2), B<readv>(2) et similaires)

note: type: Plain text
en: A file was modified (B<write>(2), B<pwrite>(2), B<writev>(2), B<truncate>(2), B<ftruncate>(2), and similar).
fr: Modification d'un fichier (B<write>(2), B<pwrite>(2), B<writev>(2), B<truncate>(2), B<ftruncate>(2) et similaires).

note: type: Plain text
en: A file was created (B<open>(2), B<creat>(2), B<mknod>(2), B<mkdir>(2), B<link>(2), B<symlink>(2), B<rename>(2)  into this directory).
fr: Création d'un fichier (B<open>(2), B<creat>(2), B<mknod>(2), B<mkdir>(2), B<link>(2), B<symlink>(2), B<rename>(2) dans ce répertoire).

note: type: Plain text
en: A file was unlinked (B<unlink>(2), B<rename>(2)  to another directory, B<rmdir>(2)).
fr: Suppression d'un fichier (B<unlink>(2), B<rename>(2) dans un autre répertoire, B<rmdir>(2)).

note: type: Plain text
en: A file was renamed within this directory (B<rename>(2)).
fr: Un fichier a été renommé dans le même répertoire (B<rename>(2)).

note: type: Plain text
en: The attributes of a file were changed (B<chown>(2), B<chmod>(2), B<utime>(2), B<utimensat>(2), and similar).
fr: Les attributs d'un fichier ont été modifiés (B<chown>(2), B<chmod>(2), B<utime>(2), B<utimensat>(2) et similaires).

note: type: Plain text
en: (In order to obtain these definitions, the B<_GNU_SOURCE> feature test macro must be defined before including I<any> header files.)
fr: (Afin d'obtenir ces définitions, la macro B<_GNU_SOURCE> doit être définie avant d'inclure I<tout> fichier d'en\(hytête).

note: type: Plain text
en: Directory notifications are normally "one-shot", and the application must reregister to receive further notifications.  Alternatively, if B<DN_MULTISHOT> is included in I<arg>, then notification will remain in effect until explicitly removed.
fr: Les notifications de répertoire sont habituellement uniques, et l'application doit réenregistrer une demande pour les notifications ultérieures. Inversement, si B<DN_MULTISHOT> est incluse dans I<arg>, les notifications resteront en effet jusqu'à une demande explicite de suppression.

note: The following does seem a poor API-design choice... type: Plain text
en: A series of B<F_NOTIFY> requests is cumulative, with the events in I<arg> being added to the set already monitored.  To disable notification of all events, make an B<F_NOTIFY> call specifying I<arg> as 0.
fr: Une série de B<F_NOTIFY> sont cumulés, les événements décrits dans I<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 B<F_NOTIFY> avec I<arg> valant 0.

note: type: Plain text
en: Notification occurs via delivery of a signal.  The default signal is B<SIGIO>, but this can be changed using the B<F_SETSIG> command to B<fcntl>().  (Note that B<SIGIO> is one of the nonqueuing standard signals; switching to the use of a real-time signal means that multiple notifications can be queued to the process.)  In the latter case, the signal handler receives a I<siginfo_t> structure as its second argument (if the handler was established using B<SA_SIGINFO>)  and the I<si_fd> field of this structure contains the file descriptor which generated the notification (useful when establishing notification on multiple directories).
fr: La notification se produit par l'occurrence d'un signal. Le signal par défaut est B<SIGIO>, mais on peut le changer avec la commande B<F_SETSIG> de B<fcntl>() (remarquez que B<SIGIO> est un des signaux standards sans file d’attente ; basculer vers l’utilisation d’un signal temps réel signifie que plusieurs notifications peuvent être mises en attente dans le processus). Dans ce cas, le gestionnaire de signal reçoit une structure I<siginfo_t> en second argument (si le gestionnaire a été installé avec B<SA_SIGINFO>) dont le champ I<si_fd> contient le descripteur du fichier qui a déclenché la notification (utile pour superviser plusieurs répertoires).

note: type: Plain text
en: Especially when using B<DN_MULTISHOT>, a real time signal should be used for notification, so that multiple notifications can be queued.
fr: En outre, avec B<DN_MULTISHOT>, un signal temps réel devrait être utilisé pour la notification pour pouvoir empiler les notifications successives.

note: type: Plain text
en: B<NOTE:> New applications should use the I<inotify> interface (available since kernel 2.6.13), which provides a much superior interface for obtaining notifications of filesystem events.  See B<inotify>(7).
fr: B<Remarque>\ : les nouvelles applications devraient utiliser l'interface I<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 B<inotify>(7).

note: type: SS
en: Changing the capacity of a pipe
fr: Changer la capacité d'un tube

note: type: TP
en: B<F_SETPIPE_SZ> (I<int>; since Linux 2.6.35)
fr: B<F_SETPIPE_SZ> (I<int> ; depuis Linux 2.6.35)

note: type: TP
en: B<F_GETPIPE_SZ> (I<void>; since Linux 2.6.35)
fr: B<F_GETPIPE_SZ> (I<void> ; depuis Linux 2.6.35)

note: type: Plain text
en: Return (as the function result) the capacity of the pipe referred to by I<fd>.
fr: Renvoie (comme résultat de la fonction) la capacité du tube référencé par I<fd>.

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: Plain text
en: For a successful call, the return value depends on the operation:
fr: La valeur renvoyée par B<fcntl>() varie suivant le type d'opération\ :

note: type: Plain text
en: Value of file descriptor flags.
fr: Valeur des attributs du descripteur de fichier.

note: type: Plain text
en: Value of file status flags.
fr: Valeur des attributs d'état du fichier.

note: type: Plain text
en: Type of lease held on file descriptor.
fr: Le type bail tenu sur le descripteur de fichier.

note: type: Plain text
en: Value of signal sent when read or write becomes possible, or zero for traditional B<SIGIO> behavior.
fr: La valeur du signal envoyé lorsque la lecture ou l'écriture deviennent possibles, ou zéro pour le comportement B<SIGIO> traditionnel.

note: type: Plain text
en: The pipe capacity.
fr: La capacité du tube.

note: type: TP
en: All other commands
fr: Toutes les autres commandes\ :

note: type: Plain text
en: Zero.
fr: Zéro.

note: type: Plain text
en: On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas d'erreur, la valeur de retour est -1, et I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: TP
en: B<EACCES> or B<EAGAIN>
fr: B<EACCES> ou B<EAGAIN>

note: type: Plain text
en: Operation is prohibited by locks held by other processes.
fr: L'opération est interdire en raison de verrous tenus par d'autres processus.

note: type: Plain text
en: The operation is prohibited because the file has been memory-mapped by another process.
fr: L'opération est impossible à cause d'une projection en mémoire effectuée par un autre processus.

note: type: Plain text
en: It was detected that the specified B<F_SETLKW> command would cause a deadlock.
fr: Le verrouillage B<F_SETLKW> conduirait à un interblocage.

note: type: Plain text
en: I<lock> is outside your accessible address space.
fr: I<lock> se trouve en dehors de l'espace d'adressage.

note: type: Plain text
en: The value specified in I<cmd> is not recognized by this kernel.
fr: La valeur indiquée dans I<cmd> n'est pas reconnue par ce noyau.

note: type: Plain text
en: I<cmd> is B<F_OFD_SETLK>, B<F_OFD_SETLKW>, or B<F_OFD_GETLK>, and I<l_pid> was not specified as zero.
fr: I<cmd> est B<F_OFD_SETLK>, B<F_OFD_SETLKW> ou B<F_OFD_GETLK>, et I<l_pid> n’a pas été défini comme nul.

note: type: Plain text
en: Too many segment locks open, lock table is full, or a remote locking protocol failed (e.g., locking over NFS).
fr: Trop de verrous sont ouverts, ou la table des verrous est pleine, ou le verrouillage distant (par exemple par NFS) a échoué.

note: type: Plain text
en: B<F_NOTIFY> was specified in I<cmd>, but I<fd> does not refer to a directory.
fr: B<F_NOTIFY> a été indiqué dans I<cmd>, mais I<fd> ne fait pas référence à un répertoire.

note: type: Plain text
en: Attempted to clear the B<O_APPEND> flag on a file that has the append-only attribute set.
fr: Essai d'effacement de l'attribut B<O_APPEND> sur un fichier, mais il est considéré comme en-ajout-seulement.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.  Only the operations B<F_DUPFD>, B<F_GETFD>, B<F_SETFD>, B<F_GETFL>, B<F_SETFL>, B<F_GETLK>, B<F_SETLK>, and B<F_SETLKW> are specified in POSIX.1-2001.
fr: SVr4, BSD\ 4.3, POSIX.1-2001. Seules les opérations B<F_DUPFD>, B<F_GETFD>, B<F_SETFD>, B<F_GETFL>, B<F_SETFL>, B<F_GETLK>, B<F_SETLK> et B<F_SETLKW> sont spécifiées dans POSIX.1-2001.

note: type: Plain text
en: B<F_DUPFD_CLOEXEC> is specified in POSIX.1-2008.  (To get this definition, define B<_POSIX_C_SOURCE> with the value 200809L or greater, or B<_XOPEN_SOURCE> with the value 700 or greater.)
fr: B<F_GETOWN> est spécifiée dans POSIX.1-2008. Pour activer cette définition, vous devez  B<_POSIX_C_SOURCE> avec une valeur supérieure ou égale à 200809L, ou B<_XOPEN_SOURCE> avec une valeur supérieure ou égale à 700.

note: .PP SVr4 documents additional EIO, ENOLINK and EOVERFLOW error conditions. type: Plain text
en: B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_SETPIPE_SZ>, B<F_GETPIPE_SZ>, B<F_GETSIG>, B<F_SETSIG>, B<F_NOTIFY>, B<F_GETLEASE>, and B<F_SETLEASE> are Linux-specific.  (Define the B<_GNU_SOURCE> macro to obtain these definitions.)
fr: B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_SETPIPE_SZ>, B<F_GETPIPE_SZ>, B<F_GETSIG>, B<F_SETSIG>, B<F_NOTIFY>, B<F_GETLEASE> et B<F_SETLEASE> sont spécifiques à Linux. (Définissez la macro B<_GNU_SOURCE> pour avoir ces définitions).

note: type: Plain text
en: The errors returned by B<dup2>(2)  are different from those returned by B<F_DUPFD>.
fr: Les erreurs renvoyées par B<dup2>(2) ne sont pas les mêmes que celles renvoyées par B<F_DUPFD>.

note: type: SS
en: File locking
fr: Verrouillages de fichier

note: type: Plain text
en: The original Linux B<fcntl>()  system call was not designed to handle large file offsets (in the I<flock> structure).  Consequently, an B<fcntl64>()  system call was added in Linux 2.4.  The newer system call employs a different structure for file locking, I<flock64>, and corresponding commands, B<F_GETLK64>, B<F_SETLK64>, and B<F_SETLKW64>.  However, these details can be ignored by applications using glibc, whose B<fcntl>()  wrapper function transparently employs the more recent system call where it is available.
fr: L'appel système B<fcntl>() original de Linux n'a pas été conçu pour gérer les positions (dans la structure I<flock>) dans des fichiers de très grosse taille. En conséquence, Linux 2.4 a ajouté l'appel système B<fcntl64>(). Ce nouvel appel système utilise une structure différente de verrouillage de fichier, I<flock64>, ainsi que les commandes correspondantes B<F_GETLK64>, B<F_SETLK64> et B<F_SETLKW64>. Cependant, ces détails peuvent être ignorés par les applications qui utilisent la glibc, car sa fonction B<fcntl>() encapsule de manière transparente l'appel système le plus récent disponible.

note: type: SS
en: Record locks
fr: Verrouillages d’enregistrements

note: type: Plain text
en: Since kernel 2.0, there is no interaction between the types of lock placed by B<flock>(2)  and B<fcntl>().
fr: Depuis le noyau 2.0, il n'y a pas d'interaction entre les verrous placés par B<flock>(2) et ceux de B<fcntl>().

note: type: SS
en: Record locking and NFS
fr: Verrouillages d’enregistrements et NFS

note: Neil Brown: With NFSv3 the failure mode is the reverse.  If the server loses contact with a client then any lock stays in place indefinitely ("why can't I read my mail"... I remember it well). Jeff Layton: Note that this is not a firm timeout. The server runs a job periodically to clean out expired 
en: Before Linux 3.12, if an NFSv4 client loses contact with the server for a period of time (defined as more than 90 seconds with no communication), it might lose and regain a lock without ever being aware of the fact.  (The period of time after which contact is assumed lost is known as the NFSv4 leasetime.  On a Linux NFS server, this can be determined by looking at I</proc/fs/nfsd/nfsv4leasetime>, which expresses the period in seconds.  The default value for this file is 90.)  This scenario potentially risks data corruption, since another process might acquire a lock in the intervening period and perform file I/O.
fr: Avant Linux 3.12, si un client NFSv4 perd le contact avec le serveur pendant un certain temps (défini à plus de 90 secondes sans communication), il pourrait perdre puis obtenir un nouveau verrou sans même en être informé. (La période au bout de laquelle le contact est assumé perdu est connue sous le nom de période de bail (« leasetime ») NFSv4. Sur un serveur NFS Linux, elle peut être déterminée en regardant I</proc/fs/nfsd/nfsv4leasetime>, qui exprime la période en seconde. La valeur par défaut pour ce fichier est 90.) Ce scénario a pour risque potentiel la corruption de données, puisqu’un autre processus pourrait obtenir un verrou pendant la période intermédiaire et réaliser des entrées et sorties de fichier.

note: commit ef1820f9be27b6ad158f433ab38002ab8131db4d commit f6de7a39c181dfb8a2c534661a53c73afb3081cd type: Plain text
en: Since Linux 3.12, if an NFSv4 client loses contact with the server, any I/O to the file by a process which "thinks" it holds a lock will fail until that process closes and reopens the file.  A kernel parameter, I<nfs.recover_lost_locks>, can be set to 1 to obtain the pre-3.12 behavior, whereby the client will attempt to recover lost locks when contact is reestablished with the server.  Because of the attendant risk of data corruption, this parameter defaults to 0 (disabled).
fr: Depuis Linux 3.12, si un client NFSv4 perd le contact avec le serveur, toutes les entrées et sorties du fichier par un processus qui « pense » détenir un verrou échoueront avant que le processus ne ferme et rouvre le fichier. Un paramètre du noyau, I<nfs.recover_lost_locks>, peut être défini à 1 pour obtenir le comportement précédant (avant Linux 3.12), où le client essayera de récupérer les verrous perdus quand le contact avec le serveur est rétabli. À cause du risque associé de corruption de données, la valeur par défaut de ce paramètre est 0 (désactivé).

note: type: SH
en: BUGS
fr: BOGUES

note: FIXME . According to POSIX.1-2001, O_SYNC should also be modifiable via fcntl(2), but currently Linux does not permit this See http://bugzilla.kernel.org/show_bug.cgi?id=5994 type: Plain text
en: It is not possible to use B<F_SETFL> to change the state of the B<O_DSYNC> and B<O_SYNC> flags.  Attempts to change the state of these flags are silently ignored.
fr: Il n'est pas possible d'utiliser B<F_SETFL> pour modifier l'état des attributs B<O_DSYNC> et B<O_SYNC>. Une tentative de modification de ces attributs sera simplement ignorée.

note: glibc source: sysdeps/unix/sysv/linux/i386/sysdep.h mtk, Dec 04: some limited testing on alpha and ia64 seems to indicate that ANY negative PGID value will cause F_GETOWN to misinterpret the return as an error. Some other architectures seem to have the same range check as i386. type: Plain text
en: A limitation of the Linux system call conventions on some architectures (notably i386) means that if a (negative)  process group ID to be returned by B<F_GETOWN> falls in the range -1 to -4095, then the return value is wrongly interpreted by glibc as an error in the system call; that is, the return value of B<fcntl>()  will be -1, and I<errno> will contain the (positive) process group ID.  The Linux-specific B<F_GETOWN_EX> operation avoids this problem.  Since glibc version 2.11, glibc makes the kernel B<F_GETOWN> problem invisible by implementing B<F_GETOWN> using B<F_GETOWN_EX>.
fr: En raison d'une limitation des conventions d'appels système sur certaines architectures (en particulier i386), si B<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 B<fcntl>() sera -1 et I<errno> contiendra l'identifiant du groupe de processus (positif). Les opérations spécifiques à Linux B<F_SETOWN_EX> et B<F_GETOWN_EX> évitent ce problème. Depuis la glibc 2.11, glibc rend le problème avec B<F_GETOWN> invisible en implémentant B<F_GETOWN> par-dessus B<F_GETOWN_EX>.

note: type: Plain text
en: In Linux 2.4 and earlier, there is bug that can occur when an unprivileged process uses B<F_SETOWN> to specify the owner of a socket file descriptor as a process (group) other than the caller.  In this case, B<fcntl>()  can return -1 with I<errno> set to B<EPERM>, even when the owner process (group) is one that the caller has permission to send signals to.  Despite this error return, the file descriptor owner is set, and signals will be sent to the owner.
fr: Sous Linux 2.4 et précédents, lorsqu'un processus non privilégié utilise B<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, B<fcntl>() peut renvoyer -1, avec I<errno> positionné à B<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.

note: type: SS
en: Deadlock detection
fr: Détection d’interblocage

note: type: Plain text
en: The deadlock-detection algorithm employed by the kernel when dealing with B<F_SETLKW> requests can yield both false negatives (failures to detect deadlocks, leaving a set of deadlocked processes blocked indefinitely)  and false positives (B<EDEADLK> errors when there is no deadlock).  For example, the kernel limits the lock depth of its dependency search to 10 steps, meaning that circular deadlock chains that exceed that size will not be detected.  In addition, the kernel may falsely indicate a deadlock when two or more processes created using the B<clone>(2)  B<CLONE_FILES> flag place locks that appear (to the kernel) to conflict.
fr: L’algorithme de détection d’interblocage utilisé par le noyau lors du traitement de demandes B<F_SETLKW> peut produire à la fois des faux négatifs (échec de détection d’interblocages, laissant un ensemble de processus interbloqués se bloquer indéfiniment) et des faux positifs (erreurs B<EDEADLK> alors qu’aucun interblocage n’existe). Par exemple, le noyau limite la profondeur de verrouillage lors de sa recherche de dépendances à dix étapes, ce qui signifie que les chaînes d’interblocages circulaires dépassant cette taille ne seront pas détectées. De plus, le noyau pourrait faussement indiquer un interblocage lorsqu’au moins deux processus créés en utilisant l’attribut B<CLONE_FILES> de B<clone>(2) placent des verrous qui semblent (au noyau) en conflit.

note: http://marc.info/?l=linux-kernel&m=119013491707153&w=2 Reconfirmed by Jeff Layton From: Jeff Layton <jlayton <at> redhat.com> Subject: Re: Status of fcntl() mandatory locking Newsgroups: gmane.linux.file-systems Date: 2014-04-28 10:07:57 GMT http://thread.gmane.org/gmane.linux.file-systems/84481/foc
en: The Linux implementation of mandatory locking is subject to race conditions which render it unreliable: a B<write>(2)  call that overlaps with a lock may modify data after the mandatory lock is acquired; a B<read>(2)  call that overlaps with a lock may detect changes to data that were made only after a write lock was acquired.  Similar races exist between mandatory locks and B<mmap>(2).  It is therefore inadvisable to rely on mandatory locking.
fr: L'implémentation Linux du verrouillage impératif est sujette à des conditions de concurrence qui la rende non fiable : un appel à B<write>(2) qui chevauche un verrou peut modifier les données après que le verrouillage impératif a été acquis ; un appel à B<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 impératifs et B<mmap>(2). Il est donc déconseillé de faire confiance au verrouillage impératif.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: I<locks.txt>, I<mandatory-locking.txt>, and I<dnotify.txt> in the Linux kernel source directory I<Documentation/filesystems/> (on older kernels, these files are directly under the I<Documentation/> directory, and I<mandatory-locking.txt> is called I<mandatory.txt>)
fr: I<locks.txt>, I<mandatory-locking.txt> et I<dnotify.txt> dans le répertoire I<Documentation/filesystems/> des sources du noyau Linux. (Sur d'anciens noyaux, ces fichiers se trouvent dans le répertoire I<Documentation/> et I<mandatory-locking.txt> est appelé I<mandatory.txt>.)

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
