perkamon - en to fr translation catalogue (152 entries)

note: type: TH
en: 2014-04-01
fr: 1er avril 2014

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: inotify - monitoring filesystem events
fr: inotify - Surveiller les événements des systèmes de fichiers

note: type: Plain text
en: The I<inotify> API provides a mechanism for monitoring filesystem events.  Inotify can be used to monitor individual files, or to monitor directories.  When a directory is monitored, inotify will return events for the directory itself, and for files inside the directory.
fr: L'API I<inotify> fournit un mécanisme pour surveiller les événements au niveau des systèmes de fichiers. Inotify peut être utilisé pour surveiller des fichiers individuels ou des répertoires. Quand un répertoire est surveillé, inotify va signaler des événements pour le répertoire lui-même et pour les fichiers de ce répertoire.

note: type: Plain text
en: The following system calls are used with this API:
fr: Les appels système suivants sont utilisés avec cette interface de programmation :

note: type: IP
en: *
fr: -

note: type: Plain text
en: B<inotify_init>(2)  creates an inotify instance and returns a file descriptor referring to the inotify instance.  The more recent B<inotify_init1>(2)  is like B<inotify_init>(2), but has a I<flags> argument that provides access to some extra functionality.
fr: B<inotify_init>(2) crée une instance inotify et renvoie un descripteur de fichier se référant à cette instance inotify. L'appel système plus récent B<inotify_init1>(2) est comme B<inotify_init>(2), mais a un argument I<flags> qui fournit un accès à des fonctionnalités supplémentaires.

note: type: Plain text
en: B<inotify_add_watch>(2)  manipulates the "watch list" associated with an inotify instance.  Each item ("watch") in the watch list specifies the pathname of a file or directory, along with some set of events that the kernel should monitor for the file referred to by that pathname.  B<inotify_add_watch>(2)  either creates a new watch item, or modifies an existing watch.  Each watch has a unique "watch descriptor", an integer returned by B<inotify_add_watch>(2)  when the watch is created.
fr: B<inotify_add_watch>(2) manipule la «\ liste de surveillance\ » associée à une instance inotify. Chaque élément («\ watch\ ») de la liste de surveillance indique le chemin d'un fichier ou d'un répertoire, avec un ensemble d'événements que le noyau doit surveiller pour le fichier indiqué par ce chemin. B<inotify_add_watch>(2) crée un nouvel élément de surveillance ou modifie un élément existant. Chaque élément a un unique «\ descripteur de surveillance\ », un entier renvoyé par B<inotify_add_watch>(2) lorsque cet élément est créé.

note: type: Plain text
en: When events occur for monitored files and directories, those events are made available to the application as structured data that can be read from the inotify file descriptor using B<read>(2)  (see below).
fr: Quand les événements ont lieu pour des fichiers et répertoires surveillés, ces événements sont rendus disponibles à l’application comme des données structurées qui peuvent être lues depuis le descripteur de fichier inotify en utilisant B<read>(2) (voir plus bas).

note: type: Plain text
en: B<inotify_rm_watch>(2)  removes an item from an inotify watch list.
fr: B<inotify_rm_watch>(2) retire un élément d'une liste de surveillance inotify.

note: type: Plain text
en: When all file descriptors referring to an inotify instance have been closed (using B<close>(2)), the underlying object and its resources are freed for reuse by the kernel; all associated watches are automatically freed.
fr: Quand tous les descripteurs de fichier se référant à une instance inotify ont été fermés (en utilisant B<close>(2)), l'objet sous-jacent et ses ressources sont libérés pour être réutilisés par le noyau\ ; tous les éléments de surveillance associés sont automatiquement libérés.

note: type: Plain text
en: With careful programming, an application can use inotify to efficiently monitor and cache the state of a set of filesystem objects.  However, robust applications should allow for the fact that bugs in the monitoring logic or races of the kind described below may leave the cache inconsistent with the filesystem state.  It is probably wise to to do some consistency checking, and rebuild the cache when inconsistencies are detected.
fr: Avec une programmation prudente, une application peut utiliser inotify pour surveiller et mettre en cache efficacement l’état d’un ensemble d’objets de système de fichiers. Cependant, les applications robustes devraient prendre en compte que des bogues dans la logique de surveillance ou des situations de compétition du type décrit ci-dessous pourraient laisser le cache incohérent avec l’état du système de fichiers. Réaliser des vérifications de cohérence et reconstruire le cache en cas de détection d’incohérences serait sans doute sage.

note: type: SS
en: Reading events from an inotify file descriptor
fr: Lecture d’événements d’un descripteur de fichier inotify

note: type: Plain text
en: To determine what events have occurred, an application B<read>(2)s from the inotify file descriptor.  If no events have so far occurred, then, assuming a blocking file descriptor, B<read>(2)  will block until at least one event occurs (unless interrupted by a signal, in which case the call fails with the error B<EINTR>; see B<signal>(7)).
fr: Pour déterminer quels événements ont eu lieu, une application va lire avec B<read>(2) le descripteur de fichier inotify. Si aucun événement n'a eu lieu, alors, en supposant qu'il s'agisse d'un descripteur de fichier bloquant, B<read>(2) se bloquera jusqu'à ce qu'au moins un événement ait lieu (à moins qu'elle ne soit interrompue par un signal, auquel cas l'appel échouera avec l'erreur B<EINTR> ; consultez B<signal>(7)).

note: type: Plain text
en: Each successful B<read>(2)  returns a buffer containing one or more of the following structures:
fr: Chaque lecture (avec B<read>(2)) réussie renvoie un tampon contenant une ou plusieurs des structures suivantes\ :

note: FIXME . The type of the 'wd' field should probably be "int32_t". I submitted a patch to fix this.  See the LKML thread "[patch] Fix type errors in inotify interfaces", 18 Nov 2008 Glibc bug filed: http://sources.redhat.com/bugzilla/show_bug.cgi?id=7040 type: Plain text
en: struct inotify_event {
        int      wd;       /* Watch descriptor */
        uint32_t mask;     /* Mask of events */
        uint32_t cookie;   /* Unique cookie associating related
                              events (for rename(2)) */
        uint32_t len;      /* Size of I<name> field */
        char     name[];   /* Optional null-terminated name */
    };
fr: struct inotify_event {
        int      wd;       /* Descripteur de surveillance */
        uint32_t mask;     /* Masque d'événements */
        uint32_t cookie;   /* Cookie unique d'association des
                              événements (pour rename(2)) */
        uint32_t len;      /* Taille du champ I<name> */
        char     name[];   /* Nom optionnel terminé par un nul */
    };

note: type: Plain text
en: I<wd> identifies the watch for which this event occurs.  It is one of the watch descriptors returned by a previous call to B<inotify_add_watch>(2).
fr: I<wd> identifie l'élément de surveillance pour lequel cet événement a lieu. Il s'agit de l'un des descripteurs de surveillance renvoyés par un précédent appel à B<inotify_add_watch>(2).

note: type: Plain text
en: I<mask> contains bits that describe the event that occurred (see below).
fr: I<mask> contient des bits qui décrivent l'événement qui a eu lieu (voir ci-dessous).

note: type: Plain text
en: I<cookie> is a unique integer that connects related events.  Currently this is used only for rename events, and allows the resulting pair of B<IN_MOVED_FROM> and B<IN_MOVED_TO> events to be connected by the application.  For all other event types, I<cookie> is set to 0.
fr: I<cookie> est un entier unique qui relie les événements. Ce n'est actuellement utilisé que pour les événements de renommage, et permet à la paire d'événements B<IN_MOVED_FROM> et B<IN_MOVED_TO> en résultant d'être associés par l'application. Pour tous les autres types d'événements, I<cookie> est mis à 0.

note: type: Plain text
en: The I<name> field is present only when an event is returned for a file inside a watched directory; it identifies the file pathname relative to the watched directory.  This pathname is null-terminated, and may include further null bytes (\(aq\e0\(aq) to align subsequent reads to a suitable address boundary.
fr: Le champ I<name> n'est présent que lorsqu'un événement est renvoyé pour un fichier au sein d'un répertoire surveillé. Il identifie le chemin du fichier par rapport au répertoire surveillé. Ce chemin est terminé par un caractère nul et peut inclure d'autres octets nuls («\ \e0\ ») pour ajuster des lectures successives à une limite d'adressage convenable.

note: type: Plain text
en: The I<len> field counts all of the bytes in I<name>, including the null bytes; the length of each I<inotify_event> structure is thus I<sizeof(struct inotify_event)+len>.
fr: Le champ I<len> compte tous les octets de I<name>, incluant les caractères nuls. La longueur de chaque structure I<inotify_event> vaut donc I<sizeof(structinotify_event)+len>.

note: type: Plain text
en: The behavior when the buffer given to B<read>(2)  is too small to return information about the next event depends on the kernel version: in kernels before 2.6.21, B<read>(2)  returns 0; since kernel 2.6.21, B<read>(2)  fails with the error B<EINVAL>.  Specifying a buffer of size
fr: Le comportement lorsque le tampon donné à B<read>(2) est trop petit pour renvoyer l'information sur le prochain événement dépend de la version du noyau\ : avant 2.6.21, B<read>(2) renvoie 0\ ; depuis le noyau 2.6.21, B<read>(2) échoue avec l'erreur B<EINVAL>. Indiquer un tampon de taille

note: type: Plain text
en: will be sufficient to read at least one event.
fr: est suffisant pour lire au moins un événement.

note: type: SS
en: inotify events
fr: Événements inotify

note: type: Plain text
en: The B<inotify_add_watch>(2)  I<mask> argument and the I<mask> field of the I<inotify_event> structure returned when B<read>(2)ing an inotify file descriptor are both bit masks identifying inotify events.  The following bits can be specified in I<mask> when calling B<inotify_add_watch>(2)  and may be returned in the I<mask> field returned by B<read>(2):
fr: L'argument I<mask> passé à B<inotify_add_watch>(2) et le champ I<mask> de la structure I<inotify_event> renvoyés lors de la lecture avec B<read>(2) d'un descripteur de fichier inotify sont tous deux des masques binaires identifiant les événements inotify. Les bits suivants peuvent être définis dans l'argument I<mask> lors de l'appel à B<inotify_add_watch>(2) et peuvent être renvoyés dans le champ I<mask> renvoyé par B<read>(2)\ :

note: type: Plain text
en: File was accessed (e.g., B<read>(2), B<execve>(2)).
fr: Accès au fichier (par exemple B<read>(2), B<execve>(2)).

note: type: Plain text
en: Metadata changed\(emfor example, permissions (e.g., B<chmod>(2)), timestamps (e.g., B<utimensat>(2)), extended attributes (B<setxattr>(2)), link count (since Linux 2.6.25; e.g., for the target of B<link>(2)  and for B<unlink>(2)), and user/group ID (e.g., B<chown>(2)).
fr: Modification des métadonnées, par exemple, les permissions (par exemple B<chmod>(2)), les horodatages (par exemple B<utimensat>(2)), les attributs étendus (B<setxattr>(2)), le compteur de liens (depuis Linux 2.6.25 ; par exemple pour la cible de B<link>(2) et B<unlink>(2)) et les UID ou GID (par exemple B<chown>(2)).

note: type: Plain text
en: File opened for writing was closed.
fr: Fichier ouvert en écriture fermé.

note: type: Plain text
en: File not opened for writing was closed.
fr: Fichier non ouvert en écriture fermé.

note: type: Plain text
en: File/directory created in watched directory (e.g., B<open>(2)  B<O_CREAT>, B<mkdir>(2), B<link>(2), B<symlink>(2), B<bind>(2)  on a UNIX domain socket).
fr: Fichier ou répertoire créés dans le répertoire surveillé (par exemple B<open>(2) B<O_CREAT>, B<mkdir>(2), B<link>(2), B<symlink>(2), B<bind>(2) sur une socket de domaine UNIX).

note: type: Plain text
en: File/directory deleted from watched directory.
fr: Fichier ou répertoire supprimés dans le répertoire surveillé.

note: type: Plain text
en: Watched file/directory was itself deleted.  (This event also occurs if an object is moved to another filesystem, since B<mv>(1)  in effect copies the file to the other filesystem and then deletes it from the original filesystem.)  In addition, an B<IN_IGNORED> event will subsequently be generated for the watch descriptor.
fr: Fichier ou répertoire surveillés supprimés (cet événement se produit également si un objet est déplacé vers un autre système de fichiers, puisque B<mv>(1) copie effectivement le fichier vers l’autre système de fichiers puis le supprime du système de fichiers d’origine). De plus, un événement B<IN_IGNORED> sera ensuite généré pour le descripteur de surveillance.

note: type: Plain text
en: File was modified (e.g., B<write>(2), B<truncate>(2)).
fr: Fichier modifié (par exemple B<write>(2), B<truncate>(2)).

note: type: Plain text
en: Watched file/directory was itself moved.
fr: Fichier ou répertoire surveillés déplacés.

note: type: Plain text
en: Generated for the directory containing the old filename when a file is renamed.
fr: Généré pour le répertoire contenant l'ancien nom quand un fichier est renommé.

note: type: Plain text
en: Generated for the directory containing the new filename when a file is renamed.
fr: Généré pour le répertoire contenant le nouveau nom quand un fichier est renommé.

note: type: Plain text
en: File was opened.
fr: Fichier ouvert.

note: type: Plain text
en: When monitoring a directory, the events marked with an asterisk (*) above can occur for files in the directory, in which case the I<name> field in the returned I<inotify_event> structure identifies the name of the file within the directory.
fr: Lors de la surveillance d'un répertoire, les événements marqués par un astérisque (*) ci-dessus peuvent avoir lieu pour des fichiers du répertoire, auquel cas le champ I<name> dans la structure I<inotify_event> renvoyée identifie le nom du fichier dans ce répertoire.

note: type: Plain text
en: The B<IN_ALL_EVENTS> macro is defined as a bit mask of all of the above events.  This macro can be used as the I<mask> argument when calling B<inotify_add_watch>(2).
fr: La macro B<IN_ALL_EVENTS> est définie comme un masque binaire de tous les événements décrits ci-dessus. Cette macro peut être utilisée comme l'argument I<mask> lors de l'appel à B<inotify_add_watch>(2).

note: type: Plain text
en: Two additional convenience macros are defined:
fr: Deux macros supplémentaires de convenance sont définies :

note: type: Plain text
en: Equates to B<IN_MOVED_FROM | IN_MOVED_TO>.
fr: Équivalent à B<IN_MOVED_FROM | IN_MOVED_TO>.

note: type: Plain text
en: Equates to B<IN_CLOSE_WRITE | IN_CLOSE_NOWRITE>.
fr: Équivalent à B<IN_CLOSE_WRITE | IN_CLOSE_NOWRITE>.

note: type: Plain text
en: The following further bits can be specified in I<mask> when calling B<inotify_add_watch>(2):
fr: Les bits supplémentaires suivants peuvent être indiqués dans l'argument I<mask> lors de l'appel à B<inotify_add_watch>(2)\ :

note: type: TP
en: B<IN_DONT_FOLLOW> (since Linux 2.6.15)
fr: B<IN_DONT_FOLLOW> (depuis Linux 2.6.15)

note: type: Plain text
en: Don't dereference I<pathname> if it is a symbolic link.
fr: Ne pas déréférencer I<pathname> s'il s'agit d'un lien symbolique.

note: type: TP
en: B<IN_EXCL_UNLINK> (since Linux 2.6.36)
fr: B<IN_EXCL_UNLINK> (depuis Linux 2.6.36)

note: commit 8c1934c8d70b22ca8333b216aec6c7d09fdbd6a6 type: Plain text
en: By default, when watching events on the children of a directory, events are generated for children even after they have been unlinked from the directory.  This can result in large numbers of uninteresting events for some applications (e.g., if watching I</tmp>, in which many applications create temporary files whose names are immediately unlinked).  Specifying B<IN_EXCL_UNLINK> changes the default behavior, so that events are not generated for children after they have been unlinked from the watched directory.
fr: Par défaut, lors de la surveillance d'événements sur les entrées d'un répertoire, des événements sont créés pour ces entrées même après leur suppression du répertoire. De nombreux événements inintéressants pour certaines applications peuvent ainsi être créés (par exemple, lors de la surveillance de I</tmp>, où de nombreuses applications créent des fichiers temporaires donc les noms sont immédiatement supprimés). Indiquer B<IN_EXCL_UNLINK> modifie le comportement par défaut, de telle sorte qu'aucun événement n'est créé pour ces entrées après leur suppression du répertoire surveillé.

note: type: Plain text
en: Add (OR) events to watch mask for this pathname if it already exists (instead of replacing mask).
fr: Ajouter les événements au masque de surveillance de ce fichier s'il existe déjà (au lieu de remplacer le masque).

note: type: Plain text
en: Monitor I<pathname> for one event, then remove from watch list.
fr: Surveiller I<pathname> jusqu'au premier événement, puis le supprimer de la liste de surveillance

note: type: TP
en: B<IN_ONLYDIR> (since Linux 2.6.15)
fr: B<IN_ONLYDIR> (depuis Linux 2.6.15)

note: type: Plain text
en: Only watch I<pathname> if it is a directory.
fr: Ne surveiller I<pathname> que si c'est un répertoire.

note: type: Plain text
en: The following bits may be set in the I<mask> field returned by B<read>(2):
fr: Les bits suivants peuvent avoir été définis dans le champ I<mask> renvoyé par B<read>(2)\ :

note: type: Plain text
en: Watch was removed explicitly (B<inotify_rm_watch>(2))  or automatically (file was deleted, or filesystem was unmounted).  See also BUGS.
fr: Le surveillant a été retiré explicitement (B<inotify_rm_watch>(2)) ou automatiquement (le fichier a été effacé, ou le système de fichiers a été démonté). Consultez également B<BOGUES>.

note: type: Plain text
en: Subject of this event is a directory.
fr: Le sujet de cet événement est un répertoire.

note: type: Plain text
en: Event queue overflowed (I<wd> is -1 for this event).
fr: Queue des événements surchargée (I<wd> vaut alors -1).

note: type: Plain text
en: Filesystem containing watched object was unmounted.  In addition, an B<IN_IGNORED> event will subsequently be generated for the watch descriptor.
fr: Le système de fichiers contenant l'objet surveillé a été démonté. De plus, un événement B<IN_IGNORED> sera ensuite généré pour le descripteur de surveillance.

note: type: SS
en: Examples
fr: Exemples

note: type: Plain text
en: Suppose an application is watching the directory I<dir> and the file I<dir/myfile> for all events.  The examples below show some events that will be generated for these two objects.
fr: Soit une application surveillant le répertoire I<rép> et le fichier I<rép/monfichier> pour tous les événements. Les exemples ci-dessous montrent quelques événements qui seront générés pour ces deux objets.

note: type: TP
en: fd = open("dir/myfile", O_RDWR);
fr: fd = open("rép/monfichier", O_RDWR);

note: type: Plain text
en: Generates B<IN_OPEN> events for both I<dir> and I<dir/myfile>.
fr: Génère des événements B<IN_OPEN> à la fois pour I<rép> et I<rép/monfichier>.

note: type: Plain text
en: Generates B<IN_ACCESS> events for both I<dir> and I<dir/myfile>.
fr: Génère des événements B<IN_ACCESS> à la fois pour I<rép> et I<rép/monfichier>.

note: type: Plain text
en: Generates B<IN_MODIFY> events for both I<dir> and I<dir/myfile>.
fr: Génère des événements B<IN_MODIFY> à la fois pour I<rép> et I<rép/monfichier>.

note: type: Plain text
en: Generates B<IN_ATTRIB> events for both I<dir> and I<dir/myfile>.
fr: Génère des événements B<IN_ATTRIB> à la fois pour I<rép> et I<rép/monfichier>.

note: type: Plain text
en: Generates B<IN_CLOSE_WRITE> events for both I<dir> and I<dir/myfile>.
fr: Génère des événements B<IN_CLOSE_WRITE> à la fois pour I<rép> et I<rép/monfichier>.

note: type: Plain text
en: Suppose an application is watching the directories I<dir1> and I<dir2>, and the file I<dir1/myfile>.  The following examples show some events that may be generated.
fr: Soit une application surveillant les répertoires I<rép1> et I<rép2>, et le fichier I<rép1/monfichier>. Les exemples suivants montrent quelques événements qui pourraient être générés.

note: type: TP
en: link("dir1/myfile", "dir2/new");
fr: link("rép1/monfichier", "rép2/nouveau");

note: type: Plain text
en: Generates an B<IN_ATTRIB> event for I<myfile> and an B<IN_CREATE> event for I<dir2>.
fr: Génère un événement B<IN_ATTRIB> pour I<monfichier> et un événement B<IN_CREATE> pour I<rép2>.

note: type: TP
en: rename("dir1/myfile", "dir2/myfile");
fr: rename("rép1/monfichier", "rép2/monfichier");

note: type: Plain text
en: Generates an B<IN_MOVED_FROM> event for I<dir1>, an B<IN_MOVED_TO> event for I<dir2>, and an B<IN_MOVE_SELF> event for I<myfile>.  The B<IN_MOVED_FROM> and B<IN_MOVED_TO> events will have the same I<cookie> value.
fr: Génère un événement B<IN_MOVED_FROM> pour I<dir1>, un événement B<IN_MOVED_TO> pour I<rép2> et un événement B<IN_MOVE_SELF> pour I<monfichier>. Les événements B<IN_MOVED_FROM> et B<IN_MOVED_TO> auront la même valeur I<cookie>.

note: type: Plain text
en: Suppose that I<dir1/xx> and I<dir2/yy> are (the only) links to the same file, and an application is watching I<dir1>, I<dir2>, I<dir1/xx>, and I<dir2/yy>.  Executing the following calls in the order given below will generate the following events:
fr: Soient I<rép1/xx> et I<rép2/yy> les (seuls) liens vers le même ficher, et une application surveillant I<rép1>, I<rép2>, I<rép1/xx> et I<rép2/yy>. L’exécution des appels suivants dans l’ordre donné ci-dessous générera les événements suivants :

note: type: TP
en: unlink("dir2/yy");
fr: unlink("rép2/yy");

note: type: Plain text
en: Generates an B<IN_ATTRIB> event for I<xx> (because its link count changes)  and an B<IN_DELETE> event for I<dir2>.
fr: Génère un événement B<IN_ATTRIB> pour I<xx> (à cause du changement de son compteur de liens) et un événement B<IN_DELETE> pour I<rép2>.

note: type: TP
en: unlink("dir1/xx");
fr: unlink("rép1/xx");

note: type: Plain text
en: Generates B<IN_ATTRIB>, B<IN_DELETE_SELF>, and B<IN_IGNORED> events for I<xx>, and an B<IN_DELETE> event for I<dir1>.
fr: Génère des événements B<IN_ATTRIB>, B<IN_DELETE_SELF> et B<IN_IGNORED> pour I<xx> et un événement B<IN_DELETE> pour I<rép1>.

note: type: Plain text
en: Suppose an application is watching the directory I<dir> and (the empty) directory I<dir/subdir>.  The following examples show some events that may be generated.
fr: Soit une application surveillant le répertoire I<rép> et le répertoire (vide) I<rép/sousrép>. Les exemples suivants montrent quelques événements qui pourraient être générés.

note: type: TP
en: mkdir("dir/new", mode);
fr: mkdir("rép/nouveau", mode);

note: type: Plain text
en: Generates an B<IN_CREATE | IN_ISDIR> event for I<dir>.
fr: Génère un événement B<IN_CREATE | IN_ISDIR> pour I<rép>.

note: type: TP
en: rmdir("dir/subdir");
fr: rmdir("rép/sousrép");

note: type: Plain text
en: Generates B<IN_DELETE_SELF> and B<IN_IGNORED> events for I<subdir>, and an B<IN_DELETE | IN_ISDIR> event for I<dir>.
fr: Génère des événements B<IN_DELETE_SELF> et B<IN_IGNORED> pour I<sousrép> et un événement B<IN_DELETE | IN_ISDIR> pour I<rép>.

note: type: SS
en: /proc interfaces
fr: Interfaces /proc

note: type: Plain text
en: The following interfaces can be used to limit the amount of kernel memory consumed by inotify:
fr: Les interfaces suivantes peuvent être utilisées pour limiter la quantité de mémoire du noyau utilisée par inotify\ :

note: type: Plain text
en: The value in this file is used when an application calls B<inotify_init>(2)  to set an upper limit on the number of events that can be queued to the corresponding inotify instance.  Events in excess of this limit are dropped, but an B<IN_Q_OVERFLOW> event is always generated.
fr: La valeur dans ce fichier est utilisée lorsqu'une application appelle B<inotify_init>(2) pour définir la limite maximale du nombre des événements qui peuvent entrer dans la file d'attente de l'instance inotify correspondante. Les événements au-delà de cette limite sont annulés, mais un événement B<IN_Q_OVERFLOW> est systématiquement généré.

note: type: Plain text
en: This specifies an upper limit on the number of inotify instances that can be created per real user ID.
fr: Cela indique la limite maximale du nombre d'instances inotify qui peuvent être créées par identifiant utilisateur réel.

note: type: Plain text
en: This specifies an upper limit on the number of watches that can be created per real user ID.
fr: Cela indique la limite maximale du nombre de « watches » qui peuvent être créées par identifiant utilisateur réel.

note: type: Plain text
en: Inotify was merged into the 2.6.13 Linux kernel.  The required library interfaces were added to glibc in version 2.4.  (B<IN_DONT_FOLLOW>, B<IN_MASK_ADD>, and B<IN_ONLYDIR> were added in glibc version 2.5.)
fr: Inotify a été inclus dans le noyau Linux 2.6.13. Les interfaces bibliothèque nécessaires ont été ajoutées dans la version 2.4 de glibc (B<IN_DONT_FOLLOW>, B<IN_MASK_ADD> et B<IN_ONLYDIR> ont été ajoutées dans la version 2.5 de glibc).

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

note: type: Plain text
en: The inotify API is Linux-specific.
fr: L’interface de programmation inotify est spécifique à Linux.

note: type: Plain text
en: Inotify file descriptors can be monitored using B<select>(2), B<poll>(2), and B<epoll>(7).  When an event is available, the file descriptor indicates as readable.
fr: Les descripteurs de fichier inotify peuvent être surveillés en utilisant B<select>(2), B<poll>(2) et B<epoll>(7). Lorsqu'un événement est disponible, le descripteur de fichier indique qu'il est accessible en lecture.

note: type: Plain text
en: Since Linux 2.6.25, signal-driven I/O notification is available for inotify file descriptors; see the discussion of B<F_SETFL> (for setting the B<O_ASYNC> flag), B<F_SETOWN>, and B<F_SETSIG> in B<fcntl>(2).  The I<siginfo_t> structure (described in B<sigaction>(2))  that is passed to the signal handler has the following fields set: I<si_fd> is set to the inotify file descriptor number; I<si_signo> is set to the signal number; I<si_code> is set to B<POLL_IN>; and B<POLLIN> is set in I<si_band>.
fr: Depuis Linux 2.6.25, il est possible d'être notifié par des signaux pour des entrées-sorties des descripteurs de fichier inotify ; consultez la discussion de B<F_SETFL> (pour la configuration de l'attribut B<O_ASYNC>), B<F_SETOWN>, et B<F_SETSIG> dans B<fcntl>(2). La structure I<siginfo_t> (décrite dans B<sigaction>(2)) qui est passée au gestionnaire de signal a les champs suivants définis : I<si_fd> est défini avec le numéro de descripteur de fichiers inotify ; I<si_signo> est défini avec le numéro du signal ; I<si_code> est défini avec B<POLL_IN> ; et I<si_band> est défini avec B<POLLIN>.

note: type: Plain text
en: If successive output inotify events produced on the inotify file descriptor are identical (same I<wd>, I<mask>, I<cookie>, and I<name>), then they are coalesced into a single event if the older event has not yet been read (but see BUGS).  This reduces the amount of kernel memory required for the event queue, but also means that an application can't use inotify to reliably count file events.
fr: Si deux événements inotify de sortie successifs produits sur le descripteur de fichier inotify sont identiques (I<wd>, I<mask>, I<cookie>, et I<name> identiques), alors ils sont fusionnés en un seul événement si l'événement le plus ancien n'a toujours pas été lu (mais consultez la section BOGUES). Cela permet de réduire la quantité de mémoire en espace noyau nécessaire à la file d'événements, mais signifie également qu'une application ne peut utiliser inotify pour compter de manière fiable les événements liés à un fichier.

note: type: Plain text
en: The events returned by reading from an inotify file descriptor form an ordered queue.  Thus, for example, it is guaranteed that when renaming from one directory to another, events will be produced in the correct order on the inotify file descriptor.
fr: Les événements renvoyés lors de la lecture d'un descripteur de fichier inotify forment une file ordonnée. Ainsi, par exemple, il est garanti que lors du renommage d'un répertoire, les événements seront produits dans l'ordre convenable sur le descripteur de fichier inotify.

note: type: Plain text
en: The B<FIONREAD> B<ioctl>(2)  returns the number of bytes available to read from an inotify file descriptor.
fr: L'B<ioctl>(2) B<FIONREAD> renvoie le nombre d'octets disponibles pour la lecture d'un descripteur de fichier inotify.

note: type: SS
en: Limitations and caveats
fr: Limites et réserves

note: type: Plain text
en: The inotify API provides no information about the user or process that triggered the inotify event.  In particular, there is no easy way for a process that is monitoring events via inotify to distinguish events that it triggers itself from those that are triggered by other processes.
fr: L'interface inotify ne fournit aucun renseignement sur l'utilisateur ou le processus qui a déclenché l'événement inotify. En particulier, un processus en train de surveiller des événements à l'aide d'inotify ne dispose d'aucun moyen facile pour distinguer les événements qu'il déclenche lui-même de ceux qui ont été déclenchés par d'autres processus.

note: type: Plain text
en: Inotify reports only events that a user-space program triggers through the filesystem API.  As a result, it does not catch remote events that occur on network filesystems.  (Applications must fall back to polling the filesystem to catch such events.)  Furthermore, various pseudo-filesystems such as I</proc>, I</sys>, and I</dev/pts> are not monitorable with inotify.
fr: Inotify ne signale que les événements déclenchés par un programme en espace utilisateur à l’aide d’une interface de programmation de système de fichiers. Par conséquent, elle n’intercepte pas les événements qui surviennent sur les systèmes de fichiers en réseau (les applications doivent avoir recours à la scrutation (polling) pour intercepter ce type d’événements). De plus, divers pseudosystèmes de fichiers comme I</proc>, I</sys> et I</dev/pts> ne sont pas surveillables avec inotify.

note: type: Plain text
en: The inotify API does not report file accesses and modifications that may occur because of B<mmap>(2)  and B<msync>(2).
fr: L'interface inotify ne signale pas les accès ni les modifications de fichier qui pourraient survenir à cause de B<mmap>(2) ou B<msync>(2).

note: type: Plain text
en: The inotify API identifies affected files by filename.  However, by the time an application processes an inotify event, the filename may already have been deleted or renamed.
fr: L'interface inotify identifie les fichiers affectés par leur nom. Cependant, au moment où l'application traite un événement inotify, ce nom de fichier peut avoir déjà été supprimé ou renommé.

note: type: Plain text
en: The inotify API identifies events via watch descriptors.  It is the application's responsibility to cache a mapping (if one is needed) between watch descriptors and pathnames.  Be aware that directory renamings may affect multiple cached pathnames.
fr: L’interface inotify identifie les événements à l’aide de descripteurs de surveillance. L’application est responsable de mettre en cache une correspondance (si nécessaire) entre les descripteurs de fichier et les chemins. Soyez vigilants aux renommages de répertoire qui pourraient affecter plusieurs chemins en cache.

note: type: Plain text
en: Inotify monitoring of directories is not recursive: to monitor subdirectories under a directory, additional watches must be created.  This can take a significant amount time for large directory trees.
fr: La surveillance inotify des répertoires n'est pas récursive\ : pour surveiller les sous-répertoires, des éléments de surveillance supplémentaires doivent être créés. Cela peut être assez long pour les répertoires contenant une grande arborescence.

note: type: Plain text
en: If monitoring an entire directory subtree, and a new subdirectory is created in that tree or an existing directory is renamed into that tree, be aware that by the time you create a watch for the new subdirectory, new files (and subdirectories) may already exist inside the subdirectory.  Therefore, you may want to scan the contents of the subdirectory immediately after adding the watch (and, if desired, recursively add watches for any subdirectories that it contains).
fr: Si la surveillance concerne une arborescence dans son intégralité, et si un nouveau sous-répertoire est créé dans ce répertoire ou si un répertoire existant est renommé dans cette arborescence, soyez conscient qu'au moment où vous créez un élément de surveillance pour le nouveau sous-répertoire, de nouveaux fichiers (et sous-répertoires) peuvent déjà exister dans le sous-répertoire. Ainsi, vous devriez analyser le contenu du sous-répertoire immédiatement après avoir ajouté l'élément de surveillance (et, si nécessaire, ajouter des éléments de surveillance pour tous les sous-répertoires qu’il contient).

note: type: Plain text
en: Note that the event queue can overflow.  In this case, events are lost.  Robust applications should handle the possibility of lost events gracefully.  For example, it may be necessary to rebuild part or all of the application cache.  (One simple, but possibly expensive, approach is to close the inotify file descriptor, empty the cache, create a new inotify file descriptor, and then re-create watches and cache entries for the objects to be monitored.)
fr: Remarquez que la file d'événements peut déborder. Dans ce cas, des événements sont perdus. Les applications robustes devraient gérer correctement la possibilité de perdre des événements. Par exemple, la reconstruction de tout ou partie du cache de l’application pourrait être nécessaire (une approche simple, mais éventuellement coûteuse, est de fermer le descripteur de fichier inotify, vider le cache, créer un nouveau descripteur de fichier inotify et recréer les éléments de surveillance et les entrées du cache pour les objets à surveiller).

note: type: SS
en: Dealing with rename() events
fr: Traitement des événements rename()

note: type: Plain text
en: As noted above, the B<IN_MOVED_FROM> and B<IN_MOVED_TO> event pair that is generated by B<rename>(2)  can be matched up via their shared cookie value.  However, the task of matching has some challenges.
fr: Comme noté précédemment, la paire d’événements B<IN_MOVED_FROM> et B<IN_MOVED_TO> générés par B<rename>(2) peut être assemblée à l’aide de la valeur de cookie partagé. Cependant, la tâche d’assemblage peut poser quelques problèmes.

note: type: Plain text
en: These two events are usually consecutive in the event stream available when reading from the inotify file descriptor.  However, this is not guaranteed.  If multiple processes are triggering events for monitored objects, then (on rare occasions) an arbitrary number of other events may appear between the B<IN_MOVED_FROM> and B<IN_MOVED_TO> events.
fr: Ces deux événements sont normalement consécutifs dans le flux d’événements disponibles lors de la lecture depuis le descripteur de fichiers inotify. Cependant, ce n’est pas garanti. Si plusieurs processus déclenchent des événements pour des objets surveillés, alors (rarement) un nombre arbitraire d’autres événements pourrait apparaître entre les événements B<IN_MOVED_FROM> et B<IN_MOVED_TO>.

note: type: Plain text
en: Matching up the B<IN_MOVED_FROM> and B<IN_MOVED_TO> event pair generated by B<rename>(2)  is thus inherently racy.  (Don't forget that if an object is renamed outside of a monitored directory, there may not even be an B<IN_MOVED_TO> event.)  Heuristic approaches (e.g., assume the events are always consecutive)  can be used to ensure a match in most cases, but will inevitably miss some cases, causing the application to perceive the B<IN_MOVED_FROM> and B<IN_MOVED_TO> events as being unrelated.  If watch descriptors are destroyed and re-created as a result, then those watch descriptors will be inconsistent with the watch descriptors in any pending events.  (Re-creating the inotify file descriptor and rebuilding the cache may be useful to deal with this scenario.)
fr: L’assemblage de la paire d’événements B<IN_MOVED_FROM> et B<IN_MOVED_TO> générés par B<rename>(2) pose donc intrinsèquement un risque de situation de compétition (n’oubliez pas que si un objet est renommé en dehors d’un répertoire surveillé, un événement B<IN_MOVED_TO> pourrait ne même pas être envoyé). Des approches heuristiques (par exemple supposer que les événements sont toujours consécutifs) permettent d’assurer un assemblage dans la plupart des cas, mais manqueront forcément certains cas, forçant l’application à percevoir les événements B<IN_MOVED_FROM> et B<IN_MOVED_TO> comme indépendants. Si les descripteurs de surveillance sont détruits et recréés par conséquent, alors ces descripteurs de surveillance seront incohérents avec les descripteurs de surveillance dans tous les événements en attente (la recréation du descripteur de fichier inotify et la reconstruction du cache pourrait être utile dans ce cas).

note: type: Plain text
en: Applications should also allow for the possibility that the B<IN_MOVED_FROM> event was the last event that could fit in the buffer returned by the current call to B<read>(2), and the accompanying B<IN_MOVED_TO> event might be fetched only on the next B<read>(2).
fr: Les applications devraient aussi considérer la possibilité que l’événement B<IN_MOVED_FROM> soit le dernier événement ayant pu entrer dans le tampon renvoyé pour l’appel actuel de B<read>(2) et l’événement B<IN_MOVED_TO> accompagnant pourrait n’être récupéré que lors de l’appel B<read>(2) suivant.

note: type: SH
en: BUGS
fr: BOGUES

note: FIXME kernel commit 611da04f7a31b2208e838be55a42c7a1310ae321 implies that unmount events were buggy 2.6.11 to 2.6.36 type: Plain text
en: In kernels before 2.6.16, the B<IN_ONESHOT> I<mask> flag does not work.
fr: Dans les noyaux antérieurs à 2.6.16, l'attribut B<IN_ONESHOT> de I<mask> ne fonctionne pas.

note: type: Plain text
en: As originally designed and implemented, the B<IN_ONESHOT> flag did not cause an B<IN_IGNORED> event to be generated when the watch was dropped after one event.  However, as an unintended effect of other changes, since Linux 2.6.36, an B<IN_IGNORED> event is generated in this case.
fr: Tel que conçu et implémenté à l’origine, l’attribut B<IN_ONESHOT> ne forçait pas à générer un appel B<IN_IGNORED> lorsque la surveillance était supprimée après un événement. Cependant, en conséquence involontaire d’autres modifications, depuis Linux 2.6.36, un événement B<IN_IGNORED> est généré dans ce cas.

note: commit 1c17d18e3775485bf1e0ce79575eb637a94494a2 type: Plain text
en: Before kernel 2.6.25, the kernel code that was intended to coalesce successive identical events (i.e., the two most recent events could potentially be coalesced if the older had not yet been read)  instead checked if the most recent event could be coalesced with the I<oldest> unread event.
fr: Avant le noyau 2.6.25, le code du noyau qui était sensé regrouper deux événements successifs (c'est-à-dire que les deux événements les plus récents pouvaient être fusionnés si le plus ancien des deux n'avait toujours pas été lu) vérifiait à la place si l'événement le plus récent pouvait être fusionné à l'événement non lu I<le plus ancien>.

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

note: type: Plain text
en: I<Documentation/filesystems/inotify.txt> in the Linux kernel source tree
fr: I<Documentation/filesystems/inotify.txt> dans les sources du noyau Linux

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

note: type: TH
en: 2014-03-28
fr: 28 mars 2014

note: type: Plain text
en: inotify_add_watch - add a watch to an initialized inotify instance
fr: inotify_add_watch - Ajouter une surveillance à une instance inotify déjà initialisée

note: type: Plain text
en: B<inotify_add_watch>()  adds a new watch, or modifies an existing watch, for the file whose location is specified in I<pathname>; the caller must have read permission for this file.  The I<fd> argument is a file descriptor referring to the inotify instance whose watch list is to be modified.  The events to be monitored for I<pathname> are specified in the I<mask> bit-mask argument.  See B<inotify>(7)  for a description of the bits that can be set in I<mask>.
fr: B<inotify_add_watch>() ajoute un surveillant, ou en modifie un existant, sur le fichier dont le chemin est fournit dans I<pathname>\ ; l'appelant doit avoir la permission de lecture sur ce fichier. L'argument I<fd> est un descripteur de fichier référençant l'instance inotify dont la liste de surveillance doit être modifiée. Les événements à surveiller sur I<pathname> sont indiqués dans l'argument de masque binaire I<mask>. Consultez B<inotify>(7) pour une description des bits qui peuvent être positionnés dans I<mask>.

note: type: Plain text
en: A successful call to B<inotify_add_watch>()  returns the unique watch descriptor associated with I<pathname> for this inotify instance.  If I<pathname> was not previously being watched by this inotify instance, then the watch descriptor is newly allocated.  If I<pathname> was already being watched, then the descriptor for the existing watch is returned.
fr: Un appel réussi à B<inotify_add_watch>() renvoie un descripteur de surveillance unique, associé avec I<pathname>, pour cette instance inotify. Si I<pathname> n'était pas déjà surveillé par cette instance inotify, le descripteur de surveillance est alloué par le noyau. Si I<pathname> était déjà surveillé, le descripteur de la surveillance existante est renvoyé.

note: type: Plain text
en: The watch descriptor is returned by later B<read>(2)s from the inotify file descriptor.  These reads fetch I<inotify_event> structures (see B<inotify>(7))  indicating filesystem events; the watch descriptor inside this structure identifies the object for which the event occurred.
fr: Le descripteur de surveillance est renvoyé par des appels ultérieurs à B<read>(2) sur le descripteur de fichier inotify. Ces lectures renvoient des structures I<inotify_event> (consultez B<inotify>(7)) indiquant des événements sur le système de fichiers\ ; le descripteur de surveillance de cette structure identifie l'objet pour lequel cet événement a eu lieu.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: On success, B<inotify_add_watch>()  returns a nonnegative watch descriptor.  On error, -1 is returned and I<errno> is set appropriately.
fr: S'il réussit, B<inotify_add_watch>() renvoie un descripteur de surveillance positif. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Read access to the given file is not permitted.
fr: L'accès en lecture au fichier indiqué est interdit.

note: type: Plain text
en: The given file descriptor is not valid.
fr: Le descripteur de fichier est invalide.

note: type: Plain text
en: I<pathname> points outside of the process's accessible address space.
fr: I<pathname> pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: The given event mask contains no valid events; or I<fd> is not an inotify file descriptor.
fr: Le masque d'événements indiqué ne contient aucun événement valable, ou I<fd> n'est pas un descripteur inotify.

note: type: Plain text
en: I<pathname> is too long.
fr: I<pathname> est trop long.

note: type: Plain text
en: A directory component in I<pathname> does not exist or is a dangling symbolic link.
fr: Un des répertoires du chemin d'accès I<pathname> n'existe pas ou est un lien symbolique pointant nulle part.

note: type: Plain text
en: Insufficient kernel memory was available.
fr: Pas assez de mémoire pour le noyau.

note: type: Plain text
en: The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource.
fr: La limite sur le nombre total de surveillances inotify pour l'utilisateur est atteinte, ou le noyau n'a pas pu allouer une ressource système nécessaire.

note: type: Plain text
en: Inotify was merged into the 2.6.13 Linux kernel.
fr: Inotify a été intégré dans Linux 2.6.13.

note: type: Plain text
en: This system call is Linux-specific.
fr: Cet appel système est spécifique à Linux.

note: type: Plain text
en: inotify_init, inotify_init1 - initialize an inotify instance
fr: inotify_init, inotify_init1 - Initialiser une instance inotify

note: type: Plain text
en: For an overview of the inotify API, see B<inotify>(7).
fr: Pour un aperçu de l’interface de programmation inotify, consultez B<inotify>(7).

note: type: Plain text
en: B<inotify_init>()  initializes a new inotify instance and returns a file descriptor associated with a new inotify event queue.
fr: B<inotify_init>() initialise une nouvelle instance inotify et renvoie un descripteur de fichier associé à une nouvelle file d'événements inotify.

note: type: Plain text
en: If I<flags> is 0, then B<inotify_init1>()  is the same as B<inotify_init>().  The following values can be bitwise ORed in I<flags> to obtain different behavior:
fr: Si I<flags> vaut 0, alors B<inotify_init1>() est identique à B<inotify_init>(). Les valeurs suivantes peuvent être combinées avec un OU binaire dans le paramètre I<flags> pour obtenir différents comportements :

note: type: Plain text
en: Set the B<O_NONBLOCK> file status flag on the new open file description.  Using this flag saves extra calls to B<fcntl>(2)  to achieve the same result.
fr: Placer l'attribut d'état de fichier B<O_NONBLOCK> sur le nouveau descripteur de fichier ouvert. Utiliser cet attribut économise des appels supplémentaires à B<fcntl>(2) pour obtenir le même résultat.

note: type: Plain text
en: Set the close-on-exec (B<FD_CLOEXEC>)  flag on the new file descriptor.  See the description of the B<O_CLOEXEC> flag in B<open>(2)  for reasons why this may be useful.
fr: Placer l'attribut « close-on-exec » (B<FD_CLOEXEC>) sur le nouveau descripteur de fichier. Consultez la description de l'attribut B<O_CLOEXEC> dans B<open>(2) pour savoir pourquoi cela peut être utile.

note: type: Plain text
en: On success, these system calls return a new file descriptor.  On error, -1 is returned, and I<errno> is set to indicate the error.
fr: S'ils réussissent, ces appels système renvoient un nouveau descripteur de fichier. En cas d'erreur, ils renvoient -1 et remplissent I<errno> avec la valeur d'erreur.

note: type: Plain text
en: (B<inotify_init1>())  An invalid value was specified in I<flags>.
fr: (B<inotify_init1>()) Une valeur incorrecte a été indiquée dans I<flags>.

note: type: Plain text
en: The user limit on the total number of inotify instances has been reached.
fr: La limite du nombre total d'instances inotify par utilisateur a été atteinte.

note: type: Plain text
en: The system limit on the total number of file descriptors has been reached.
fr: La limite du nombre total de fichiers ouverts sur le système a été atteinte.

note: type: Plain text
en: Insufficient kernel memory is available.
fr: Pas assez de mémoire pour le noyau.

note: type: Plain text
en: B<inotify_init>()  first appeared in Linux 2.6.13; library support was added to glibc in version 2.4.  B<inotify_init1>()  was added in Linux 2.6.27; library support was added to glibc in version 2.9.
fr: B<inotify_init>() est apparu dans Linux 2.6.13 ; la glibc le gère depuis la version 2.4. B<inotify_init1>() a été ajouté dans Linux 2.6.27 ; la glibc le gère depuis la version 2.9.

note: type: Plain text
en: These system calls are Linux-specific.
fr: Ces appels système sont spécifiques à Linux.

note: type: TH
en: 2010-10-15
fr: 15 octobre 2010

note: type: Plain text
en: inotify_rm_watch - remove an existing watch from an inotify instance
fr: inotify_rm_watch - Supprimer une surveillance existante d'une instance inotify

note: type: Plain text
en: B<inotify_rm_watch>()  removes the watch associated with the watch descriptor I<wd> from the inotify instance associated with the file descriptor I<fd>.
fr: B<inotify_rm_watch>() supprime la surveillance associée au descripteur I<wd> de l'instance inotify associée au descripteur de fichier I<fd>.

note: type: Plain text
en: Removing a watch causes an B<IN_IGNORED> event to be generated for this watch descriptor.  (See B<inotify>(7).)
fr: La suppression d'une surveillance provoque la génération d'un événement B<IN_IGNORED> pour le descripteur. Consultez B<inotify>(7).

note: type: Plain text
en: On success, B<inotify_rm_watch>()  returns zero.  On error, -1 is returned and I<errno> is set to indicate the cause of the error.
fr: S'il réussit, B<inotify_rm_watch>() renvoie zéro. En cas d'erreur, il renvoie -1 et I<errno> est définie pour indiquer la cause de l’erreur.

note: type: Plain text
en: I<fd> is not a valid file descriptor.
fr: I<fd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: The watch descriptor I<wd> is not valid; or I<fd> is not an inotify file descriptor.
fr: Le descripteur de surveillance I<wd> est invalide, ou I<fd> n'est pas un descripteur inotify.
