.\" -*- coding: UTF-8 -*- .\" Copyright (C) 2013, Heinrich Schuchardt .\" and Copyright (C) 2014, Michael Kerrisk .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH fanotify 7 "5 février 2023" "Pages du manuel de Linux 6.03" .SH NOM fanotify – Surveiller les événements des systèmes de fichiers .SH DESCRIPTION L’interface de programmation fanotify permet la notification et l’interception des événements du système de fichiers. La recherche de virus et la gestion de stockage hiérarchisé font partie des cas d’utilisation. Dans l’interface originelle seul un ensemble limité d’événements était pris en charge. En particulier, les événements de création, de suppression ou de déplacement n’étaient pas pris en charge. La prise en charge de ces évènements a été ajoutée dans Linux\ 5.1. Consultez \fBinotify\fP(7) pour plus de précisions sur l’interface qui ne notifiait pas ces évènements avant Linux\ 5.1. .PP La capacité de surveiller tous les objets d’un système de fichiers monté, la capacité de décider des droits d’accès et la possibilité de lire ou modifier les fichiers avant qu’ils ne soient accédés par d’autres applications font partie des capacités supplémentaires à celles de l’interface de programmation \fBinotify\fP(7). .PP Les appels système suivants sont utilisés avec cette interface de programmation\ : \fBfanotify_init\fP(2), \fBfanotify_mark\fP(2), \fBread\fP(2), \fBwrite\fP(2) et \fBclose\fP(2). .SS "fanotify_init(), fanotify_mark() et groupes de notification" L’appel système \fBfanotify_init\fP(2) crée et initialise un groupe de notifications fanotify et renvoie un descripteur de fichier le référençant. .PP Un groupe de notifications fanotify est un objet interne au noyau qui contient une liste de fichiers, répertoires et points de montage pour lesquels des événements seront créés. .PP Pour chaque entrée dans un groupe de notifications fanotify, deux masques binaires sont présents\ : le masque \fImark\fP et le masque \fIignore\fP. Le masque \fImark\fP définit les activités de fichier pour lesquelles un événement doit être créé. Le masque \fIignore\fP définit les activités pour lesquelles aucun événement ne doit être créé. Avoir ces deux types de masque permet à un point de montage ou à un répertoire d’être marqué pour recevoir des événements, tout en ignorant en même temps les événements pour des objets spécifiques dans ce point de montage ou répertoire. .PP L’appel système \fBfanotify_mark\fP(2) ajoute un fichier, répertoire ou point de montage à un groupe de notifications et indique les événements qui doivent être signalés (ou ignorés), ou supprime ou modifie une telle entrée. .PP Le masque \fIignore\fP peut servir pour un cache de fichier. Les événements intéressants pour un cache de fichier sont la modification et la fermeture d’un fichier. Ainsi, le répertoire ou point de montage en cache va être marqué pour recevoir ces événements. Après la réception du premier événement informant qu’un fichier a été modifié, l’entrée correspondante du cache sera désactivée. Aucun autre événement de modification pour ce fichier ne sera utile jusqu’à sa fermeture. Ainsi, l’événement de modification peut être ajouté au masque ignore. Lors de la réception d’un événement de fermeture, l’événement de modification peut être supprimé du masque \fIignore\fP et l’entrée de cache de fichier peut être mise à jour. .PP Les entrées des groupes de notification fanotify font référence aux fichiers et répertoires à l’aide de leur numéro d’inœud et aux montages à l’aide de leur identifiant de montage. Si les fichiers ou répertoires sont renommés ou déplacés dans le même montage, les entrées correspondantes survivent. Si les fichiers ou répertoires sont supprimés ou déplacés dans un autre montage ou si les montages sont démontés, les entrées correspondantes sont supprimées. .SS "La file d’événements" Comme les événements surviennent sur les objets de système de fichiers surveillés par un groupe de notifications, le système fanotify génère les événements qui sont collectés dans une file. Ces événements peuvent être lus (en utilisant \fBread\fP(2) ou similaire) à partir du descripteur de fichier fanotify renvoyé par \fBfanotify_init\fP(2). .PP Deux types d’événements sont créés\ : les événements de \fInotification\fP et les événements de \fIpermission\fP. Les événements de notification sont surtout informatifs et ne nécessitent pas d’action à prendre par l’application qui les reçoit à part pour la fermeture du descripteur de fichier valable passé dans l’événement (voir ci\-dessous). Les événements de permission sont des demandes à l’application qui les reçoit pour décider si les droits d’accès à un fichier doivent être attribués. Pour ces événements, le destinataire doit écrire une réponse qui décide d’attribuer l’accès ou non. .PP Un événement est supprimé de la file d’événements du groupe fanotify quand il a été lu. Les événements de permission qui ont été lus sont gardés dans une liste interne du groupe fanotify jusqu’à ce qu’une décision d’attribution de droits ait été prise en écrivant dans le descripteur de fichier fanotify ou que le descripteur de fichier fanotify soit fermé. .SS "Lecture d’événements fanotify" Appeler \fBread\fP(2) pour le descripteur de fichier renvoyé par \fBfanotify_init\fP(2) bloque (si l’attribut \fBFAN_NONBLOCK\fP n’est pas indiqué dans l’appel de \fBfanotify_init\fP(2)) jusqu’à ce qu’un événement de fichier survienne ou que l’appel soit interrompu par un signal (consultez \fBsignal\fP(7)). .PP Après un \fBread\fP(2) réussi, le tampon de lecture contient une ou plus des structures suivantes\ : .PP .in +4n .EX struct fanotify_event_metadata { __u32 event_len; __u8 vers; __u8 reserved; __u16 metadata_len; __aligned_u64 mask; __s32 fd; __s32 pid; }; .EE .in .PP Information records are supplemental pieces of information that may be provided alongside the generic \fIfanotify_event_metadata\fP structure. The \fIflags\fP passed to \fBfanotify_init\fP(2) have influence over the type of information records that may be returned for an event. For example, if a notification group is initialized with \fBFAN_REPORT_FID\fP or \fBFAN_REPORT_DIR_FID\fP, then event listeners should also expect to receive a \fIfanotify_event_info_fid\fP structure alongside the \fIfanotify_event_metadata\fP structure, whereby file handles are used to identify filesystem objects rather than file descriptors. Information records may also be stacked, meaning that using the various \fBFAN_REPORT_*\fP flags in conjunction with one another is supported. In such cases, multiple information records can be returned for an event alongside the generic \fIfanotify_event_metadata\fP structure. For example, if a notification group is initialized with \fBFAN_REPORT_TARGET_FID\fP and \fBFAN_REPORT_PIDFD\fP, then an event listener should expect to receive up to two \fIfanotify_event_info_fid\fP information records and one \fIfanotify_event_info_pidfd\fP information record alongside the generic \fIfanotify_event_metadata\fP structure. Importantly, fanotify provides no guarantee around the ordering of information records when a notification group is initialized with a stacked based configuration. Each information record has a nested structure of type \fIfanotify_event_info_header\fP. It is imperative for event listeners to inspect the \fIinfo_type\fP field of this structure in order to determine the type of information record that had been received for a given event. .PP In cases where an fanotify group identifies filesystem objects by file handles, event listeners should also expect to receive one or more of the below information record objects alongside the generic \fIfanotify_event_metadata\fP structure within the read buffer: .PP .in +4n .EX struct fanotify_event_info_fid { struct fanotify_event_info_header hdr; __kernel_fsid_t fsid; unsigned char file_handle[0]; }; .EE .in .PP In cases where an fanotify group is initialized with \fBFAN_REPORT_PIDFD\fP, event listeners should expect to receive the below information record object alongside the generic \fIfanotify_event_metadata\fP structure within the read buffer: .PP .in +4n .EX struct fanotify_event_info_pidfd { struct fanotify_event_info_header hdr; __s32 pidfd; }; .EE .in .PP In case of a \fBFAN_FS_ERROR\fP event, an additional information record describing the error that occurred is returned alongside the generic \fIfanotify_event_metadata\fP structure within the read buffer. This structure is defined as follows: .PP .in +4n .EX struct fanotify_event_info_error { struct fanotify_event_info_header hdr; __s32 error; __u32 error_count; }; .EE .in .PP All information records contain a nested structure of type \fIfanotify_event_info_header\fP. This structure holds meta\-information about the information record that may have been returned alongside the generic \fIfanotify_event_metadata\fP structure. This structure is defined as follows: .PP .in +4n .EX struct fanotify_event_info_header { __u8 info_type; __u8 pad; __u16 len; }; .EE .in .PP Pour des raisons de performances, une grande taille de tampon (par exemple 4096\ octets) est conseillée pour que plusieurs événements puissent être récupérés en une seule lecture. .PP La valeur de retour de \fBread\fP(2) est le nombre d’octets placés dans le tampon, ou\ \fB\-1\fP en cas d’erreur (mais consultez \fBBOGUES\fP). .PP Les champs de la structure \fIfanotify_event_metadata\fP sont les suivants. .TP \fIevent_len\fP C’est la taille des données pour l’événement actuel et la position du prochain événement dans le tampon. À moins que le groupe identifie des objets du système de fichiers par des gestionnaires de fichiers, la valeur d’\fIevent_len\fP est toujours \fBFAN_EVENT_METADATA_LEN\fP. Pour un groupe qui identifie les objets du système de fichiers par des gestionnaires de fichiers, \fIevent_len\fP inclut aussi des enregistrements d’identificateur de fichier de taille variable. .TP \fIvers\fP Ce champ contient un numéro de version pour la structure. Il doit être comparé à \fBFANOTIFY_METADATA_VERSION\fP pour vérifier que les structures renvoyées pendant l’exécution correspondent aux structures définies à la compilation. En cas d’erreur de correspondance, l’application devrait arrêter d’essayer d’utiliser le descripteur de fichier fanotify. .TP \fIreserved\fP Ce champ n’est pas utilisé. .TP \fImetadata_len\fP C’est la taille de la structure. Le champ a été introduit pour faciliter l’implémentation d’en\-têtes facultatifs par type d’événement. Aucun en\-tête facultatif n’existe dans l’implémentation actuelle. .TP \fImask\fP C’est un masque binaire décrivant l’événement (voir ci\-dessous). .TP \fIfd\fP C’est un descripteur de fichier ouvert pour l’objet actuellement accédé ou \fBFAN_NOFD\fP si un dépassement de file est survenu. Avec un groupe fanotify qui identifie les objets de système d’exploitation par des gestionnaires de fichiers, les applications doivent escompter que cette valeur soit \fBFAN_NOFD\fP pour chaque évènement qu’elles reçoivent. Le descripteur de fichier peut être utilisé pour accéder au contenu du fichier ou répertoire surveillé. L’application qui lit est responsable de la fermeture de ce descripteur de fichier. .IP Lors d’un appel de \fBfanotify_init\fP(2), l’appelant pourrait indiquer (à l’aide de l’argument \fIevent_f_flags\fP) plusieurs attributs d’état de fichier à définir dans la description de fichier ouverte qui correspond à ce descripteur de fichier. De plus, l’attribut d’état de fichier \fBFMODE_NONOTIFY\fP (interne au noyau) est défini dans la description de fichier ouverte. L’attribut supprime la création d’événement fanotify. Ainsi, quand le destinataire de l’événement fanotify accède au fichier ou répertoire notifié en utilisant ce descripteur de fichier, aucun événement supplémentaire n’est créé. .TP \fIpid\fP Si l’attribut \fBFAN_REPORT_TID\fP était réglé dans \fBfanotify_init\fP(2), c’est l’identifiant (TID) du thread qui a provoqué cet évènement. Sinon, c’est le PID du processus qui a provoqué cet évènement. .PP Un programme écoutant les événements fanotify peut comparer ce PID au PID renvoyé par \fBgetpid\fP(2) pour déterminer si l’événement est provoqué par l’écoutant lui\-même ou par un autre processus accédant au fichier. .PP Le masque binaire \fImask\fP indique les événements survenus pour un seul objet de système de fichiers. Plusieurs bits pourraient être définis dans ce masque si plus d’un événement est survenu pour l’objet de système de fichiers surveillé. En particulier, les événements consécutifs pour le même objet de système de fichiers et originaires du même processus pourraient être fusionnés dans un seul événement, mais deux événements de permission ne sont jamais fusionnés dans une entrée de file. .PP Les bits pouvant apparaître dans \fImask\fP sont les suivants. .TP \fBFAN_ACCESS\fP Un fichier ou un répertoire (mais consultez \fBBOGUES\fP) a été accédé (en lecture). .TP \fBFAN_OPEN\fP Un fichier ou un répertoire a été ouvert. .TP \fBFAN_OPEN_EXEC\fP Un fichier a été ouvert dans le but d’être exécuté. Consultez NOTES dans \fBfanotify_mark\fP(2) pour plus de détails. .TP \fBFAN_ATTRIB\fP Une métadonnée de fichier ou d’un répertoire a été modifiée. .TP \fBFAN_CREATE\fP Un fichier enfant ou un répertoire a été créé dans le répertoire surveillé. .TP \fBFAN_DELETE\fP Un fichier enfant ou un répertoire a été supprimé dans le répertoire surveillé. .TP \fBFAN_DELETE_SELF\fP Un fichier ou un répertoire a été supprimé. .TP \fBFAN_FS_ERROR\fP A filesystem error was detected. .TP \fBFAN_RENAME\fP A file or directory has been moved to or from a watched parent directory. .TP \fBFAN_MOVED_FROM\fP Un fichier ou un répertoire a été déplacé du répertoire surveillé. .TP \fBFAN_MOVED_TO\fP Un fichier ou un répertoire a été déplacé du répertoire parent surveillé. .TP \fBIN_MOVE_SELF\fP Un fichier ou un répertoire surveillé a été déplacé. .TP \fBFAN_MODIFY\fP Un fichier a été modifié. .TP \fBFAN_CLOSE_WRITE\fP Un fichier qui était ouvert en écriture (\fBO_WRONLY\fP ou \fBO_RDWR\fP) a été fermé. .TP \fBFAN_CLOSE_NOWRITE\fP Un fichier ou un répertoire, qui était ouvert en lecture seule (\fBO_RDONLY\fP), a été fermé. .TP \fBFAN_Q_OVERFLOW\fP The event queue exceeded the limit on number of events. This limit can be overridden by specifying the \fBFAN_UNLIMITED_QUEUE\fP flag when calling \fBfanotify_init\fP(2). .TP \fBFAN_ACCESS_PERM\fP Une application veut lire un fichier ou répertoire, par exemple en utilisant \fBread\fP(2) ou \fBreaddir\fP(2). Le lecteur doit écrire une réponse (telle que décrite ci\-dessous) qui détermine si le droit d’accès à l’objet de système de fichiers sera attribué. .TP \fBFAN_OPEN_PERM\fP Une application veut ouvrir un fichier ou un répertoire. Le lecteur doit écrire une réponse qui détermine si le droit d’ouvrir l’objet de système de fichiers sera attribué. .TP \fBFAN_OPEN_PERM\fP Une application veut ouvrir un fichier pour une exécution. Le lecteur doit écrire une réponse qui détermine si le droit d’ouvrir l’objet de système de fichiers sera attribué. Consultez NOTES dans \fBfanotify_mark\fP(2) pour plus de détails. .PP Pour vérifier tous les événements fermés, le masque binaire suivant pourrait être utilisé\ : .TP \fBFAN_CLOSE\fP Un fichier a été fermé. C’est un synonyme de\ : .IP .in +4n .EX FAN_CLOSE_WRITE | FAN_CLOSE_NOWRITE .EE .in .PP Pour vérifier tous les événements de déplacement, le masque binaire suivant pourrait être utilisé\ : .TP \fBFAN_MOVE\fP Un fichier ou un répertoire a été déplacé. C’est un synonyme de\ : .IP .in +4n .EX FAN_MOVED_FROM | FAN_MOVED_TO .EE .in .PP Les bits suivants peuvent apparaître dans \fImask\fP seulement conjointement avec d’autres bits de type d’évènement\ : .TP \fBFAN_ONDIR\fP Les évènements décrits dans le \fImask\fP se sont déroulés dans un objet de répertoire. Le rapport d’évènements dans des répertoires requiert le réglage de cet attribut dans le masque \fImark\fP. Consultez \fBfanotify_mark\fP(2) pour plus de détails. L’attribut \fBFAN_ONDIR\fP est rapporté dans un masque d’évènement seulement si le groupe fanotify identifie les objets de système d’exploitation avec des gestionnaires de fichiers. .PP Information records that are supplied alongside the generic \fIfanotify_event_metadata\fP structure will always contain a nested structure of type \fIfanotify_event_info_header\fP. The fields of the \fIfanotify_event_info_header\fP are as follows: .TP \fIinfo_type\fP A unique integer value representing the type of information record object received for an event. The value of this field can be set to one of the following: \fBFAN_EVENT_INFO_TYPE_FID\fP, \fBFAN_EVENT_INFO_TYPE_DFID\fP, \fBFAN_EVENT_INFO_TYPE_DFID_NAME\fP, or \fBFAN_EVENT_INFO_TYPE_PIDFD\fP. The value set for this field is dependent on the flags that have been supplied to \fBfanotify_init\fP(2). Refer to the field details of each information record object type below to understand the different cases in which the \fIinfo_type\fP values can be set. .TP \fIpad\fP This field is currently not used by any information record object type and therefore is set to zero. .TP \fIlen\fP The value of \fIlen\fP is set to the size of the information record object, including the \fIfanotify_event_info_header\fP. The total size of all additional information records is not expected to be larger than (\fIevent_len\fP \- \fImetadata_len\fP). .PP Les champs de la structure \fIfanotify_event_info_fid\fP sont les suivants. .TP \fIhdr\fP This is a structure of type \fIfanotify_event_info_header\fP. For example, when an fanotify file descriptor is created using \fBFAN_REPORT_FID\fP, a single information record is expected to be attached to the event with \fIinfo_type\fP field value of \fBFAN_EVENT_INFO_TYPE_FID\fP. When an fanotify file descriptor is created using the combination of \fBFAN_REPORT_FID\fP and \fBFAN_REPORT_DIR_FID\fP, there may be two information records attached to the event: one with \fIinfo_type\fP field value of \fBFAN_EVENT_INFO_TYPE_DFID\fP, identifying a parent directory object, and one with \fIinfo_type\fP field value of \fBFAN_EVENT_INFO_TYPE_FID\fP, identifying a child object. Note that for the directory entry modification events \fBFAN_CREATE\fP, \fBFAN_DELETE\fP, \fBFAN_MOVE\fP, and \fBFAN_RENAME\fP, an information record identifying the created/deleted/moved child object is reported only if an fanotify group was initialized with the flag \fBFAN_REPORT_TARGET_FID\fP. .TP \fIfsid\fP C’est un identifiant unique du système de fichiers contenant l’objet associé avec l’évènement. C’est une structure de type \fI__kernel_fsid_t\fP et elle contient la même valeur que \fIf_fsid\fP lors de l’appel \fBstatfs\fP(2). .TP \fIfile_handle\fP This is a variable length structure of type struct file_handle. It is an opaque handle that corresponds to a specified object on a filesystem as returned by \fBname_to_handle_at\fP(2). It can be used to uniquely identify a file on a filesystem and can be passed as an argument to \fBopen_by_handle_at\fP(2). If the value of \fIinfo_type\fP field is \fBFAN_EVENT_INFO_TYPE_DFID_NAME\fP, the file handle is followed by a null terminated string that identifies the created/deleted/moved directory entry name. For other events such as \fBFAN_OPEN\fP, \fBFAN_ATTRIB\fP, \fBFAN_DELETE_SELF\fP, and \fBFAN_MOVE_SELF\fP, if the value of \fIinfo_type\fP field is \fBFAN_EVENT_INFO_TYPE_FID\fP, the \fIfile_handle\fP identifies the object correlated to the event. If the value of \fIinfo_type\fP field is \fBFAN_EVENT_INFO_TYPE_DFID\fP, the \fIfile_handle\fP identifies the directory object correlated to the event or the parent directory of a non\-directory object correlated to the event. If the value of \fIinfo_type\fP field is \fBFAN_EVENT_INFO_TYPE_DFID_NAME\fP, the \fIfile_handle\fP identifies the same directory object that would be reported with \fBFAN_EVENT_INFO_TYPE_DFID\fP and the file handle is followed by a null terminated string that identifies the name of a directory entry in that directory, or '.' to identify the directory object itself. .PP The fields of the \fIfanotify_event_info_pidfd\fP structure are as follows: .TP \fIhdr\fP This is a structure of type \fIfanotify_event_info_header\fP. When an fanotify group is initialized using \fBFAN_REPORT_PIDFD\fP, the \fIinfo_type\fP field value of the \fIfanotify_event_info_header\fP is set to \fBFAN_EVENT_INFO_TYPE_PIDFD\fP. .TP \fIpidfd\fP This is a process file descriptor that refers to the process responsible for generating the event. The returned process file descriptor is no different from one which could be obtained manually if \fBpidfd_open\fP(2) were to be called on \fIfanotify_event_metadata.pid\fP. In the instance that an error is encountered during pidfd creation, one of two possible error types represented by a negative integer value may be returned in this \fIpidfd\fP field. In cases where the process responsible for generating the event has terminated prior to the event listener being able to read events from the notification queue, \fBFAN_NOPIDFD\fP is returned. The pidfd creation for an event is only performed at the time the events are read from the notification queue. All other possible pidfd creation failures are represented by \fBFAN_EPIDFD\fP. Once the event listener has dealt with an event and the pidfd is no longer required, the pidfd should be closed via \fBclose\fP(2). .PP The fields of the \fIfanotify_event_info_error\fP structure are as follows: .TP \fIhdr\fP This is a structure of type \fIfanotify_event_info_header\fP. The \fIinfo_type\fP field is set to \fBFAN_EVENT_INFO_TYPE_ERROR\fP. .TP \fIerror\fP Identifies the type of error that occurred. .TP \fIerror_count\fP This is a counter of the number of errors suppressed since the last error was read. .PP Les macros suivantes sont fournies pour itérer sur un tampon contenant les métadonnées d’événement fanotify renvoyées par \fBread\fP(2) à partir d’un descripteur de fichier fanotify. .TP \fBFAN_EVENT_OK(meta, len)\fP Cette macro compare la taille restante \fIlen\fP du tampon \fImeta\fP à la taille de la structure de métadonnées et au champ \fIevent_len\fP de la première structure de métadonnées du tampon. .TP \fBFAN_EVENT_NEXT(meta, len)\fP Cette macro utilise la taille indiquée dans le champ \fIevent_len\fP de la structure de métadonnées pointée par \fImeta\fP pour calculer l’adresse de la prochaine structure de métadonnées qui suit \fImeta\fP. \fIlen\fP est le nombre d’octets de métadonnées qui restent actuellement dans le tampon. La macro renvoie un pointeur vers la prochaine structure de métadonnées qui suit \fImeta\fP et réduit \fIlen\fP du nombre d’octets dans la structure de métadonnées qui a été sautée (c’est\-à\-dire qu’elle soustrait \fImeta\->event_len\fP de \fIlen\fP). .PP De plus, il existe\ : .TP \fBFAN_EVENT_METADATA_LEN\fP .\" Cette macro renvoie la taille (en octet) de la structure \fIfanotify_event_metadata\fP. C’est la taille minimale (et actuellement la seule taille) de métadonnées d’événements. .SS "Surveiller un descripteur de fichier fanotify pour les événements" Quand un événement fanotify survient, le descripteur de fichier fanotify est indiqué comme lisible lorsque passé à \fBepoll\fP(7), \fBpoll\fP(2) ou \fBselect\fP(2). .SS "Traitement des événements de permission" Pour les événements de permission, l’application doit écrire (avec \fBwrite\fP(2)) une structure de la forme suivante sur le descripteur de fichier fanotify\ : .PP .in +4n .EX struct fanotify_response { __s32 fd; __u32 response; }; .EE .in .PP Les membres de cette structure sont les suivants\ : .TP \fIfd\fP C’est le descripteur de fichier de la structure \fIfanotify_event_metadata\fP. .TP \fIresponse\fP Ce champ indique si les droits doivent être attribués ou non. Cette valeur doit être soit \fBFAN_ALLOW\fP pour permettre l’opération de fichier, soit \fBFAN_DENY\fP pour refuser l’opération de fichier. .PP .\" Si l’accès est refusé, l’appel de l’application requérante recevra une erreur \fBEPERM\fP. De plus, si le groupe de notifications a été créé avec l’attribut \fBFAN_ENABLE_AUDIT\fP, alors l’attribut \fBFAN_AUDIT\fP peut être défini dans le champ \fIresponse\fP. Dans ce cas, le sous\-système d’audit journalisera l’information à propos de la décision d’accès aux journaux d’audit. .SS "Monitoring filesystems for errors" A single \fBFAN_FS_ERROR\fP event is stored per filesystem at once. Extra error messages are suppressed and accounted for in the \fIerror_count\fP field of the existing \fBFAN_FS_ERROR\fP event record, but details about the errors are lost. .PP Errors reported by \fBFAN_FS_ERROR\fP are generic \fIerrno\fP values, but not all kinds of error types are reported by all filesystems. .PP .\" Errors not directly related to a file (i.e. super block corruption) are reported with an invalid \fIfile_handle\fP. For these errors, the \fIfile_handle\fP will have the field \fIhandle_type\fP set to \fBFILEID_INVALID\fP, and the handle buffer size set to \fB0\fP. .SS "Fermeture du descripteur de fichier fanotify" Quand tous les descripteurs de fichier se référant au groupe de notifications fanotify sont fermés, le groupe fanotify est libéré et ses ressources sont libérées pour être réutilisées par le noyau. Lors de l’appel de \fBclose\fP(2), les événements de permission restants seront définis à permis. .SS "Interfaces /proc" Le fichier \fI/proc/[pid]/fdinfo/[fd]\fP contient des renseignements sur les marques fanotify pour le descripteur de fichier \fIfd\fP du processus \fIpid\fP. Consultez \fBproc\fP(5) pour plus de précisions. .PP .\" commit 5b8fea65d197f408bb00b251c70d842826d6b70b Since Linux 5.13, the following interfaces can be used to control the amount of kernel resources consumed by fanotify: .TP \fI/proc/sys/fs/fanotify/max_queued_events\fP .\" commit 5b8fea65d197f408bb00b251c70d842826d6b70b The value in this file is used when an application calls \fBfanotify_init\fP(2) to set an upper limit on the number of events that can be queued to the corresponding fanotify group. Events in excess of this limit are dropped, but an \fBFAN_Q_OVERFLOW\fP event is always generated. Prior to Linux kernel 5.13, the hardcoded limit was 16384 events. .TP \fI/proc/sys/fs/fanotify/max_user_group\fP .\" commit 5b8fea65d197f408bb00b251c70d842826d6b70b This specifies an upper limit on the number of fanotify groups that can be created per real user ID. Prior to Linux kernel 5.13, the hardcoded limit was 128 groups per user. .TP \fI/proc/sys/fs/fanotify/max_user_marks\fP .\" commit 5b8fea65d197f408bb00b251c70d842826d6b70b This specifies an upper limit on the number of fanotify marks that can be created per real user ID. Prior to Linux kernel 5.13, the hardcoded limit was 8192 marks per group (not per user). .SH ERREURS En plus des erreurs habituelles de \fBread\fP(2), les erreurs suivantes peuvent survenir lors de la lecture d’un descripteur de fichier fanotify. .TP \fBEINVAL\fP Le tampon est trop petit pour contenir l’événement. .TP \fBEMFILE\fP La limite par processus du nombre de fichiers ouverts a été atteinte. Consultez la description de \fBRLIMIT_NOFILE\fP dans \fBgetrlimit\fP(2). .TP \fBENFILE\fP La limite du nombre de fichiers ouverts sur le système a été atteinte. Consultez \fI/proc/sys/fs/file\-max\fP dans \fBproc\fP(5). .TP \fBETXTBSY\fP Cette erreur est renvoyée par \fBread\fP(2) si \fBO_RDWR\fP ou \fBO_WRONLY\fP ont été indiqués dans l’argument \fIevent_f_flags\fP lors de l’appel \fBfanotify_init\fP(2) et qu’un événement est survenu pour un fichier surveillé actuellement en cours d’exécution. .PP En plus des erreurs habituelles de \fBwrite\fP(2), les erreurs suivantes peuvent survenir lors de l’écriture sur un descripteur de fichier fanotify. .TP \fBEINVAL\fP Les droits d’accès fanotify ne sont pas activés dans la configuration du noyau ou la valeur de \fIresponse\fP dans la structure de réponse n’est pas valable. .TP \fBENOENT\fP Le descripteur de fichier \fIfd\fP dans la structure de réponse n’est pas valable. Cela pourrait survenir quand une réponse pour l’événement de permission a déjà été écrite. .SH VERSIONS The fanotify API was introduced in Linux 2.6.36 and enabled in Linux 2.6.37. Fdinfo support was added in Linux 3.8. .SH STANDARDS L’interface de programmation fanotify est spécifique à Linux. .SH NOTES L’interface de programmation fanotify n’est disponible que si le noyau a été construit avec l’option de configuration \fBCONFIG_FANOTIFY\fP activée. De plus, le traitement de permission fanotify n’est disponible que si l’option de configuration \fBCONFIG_FANOTIFY_ACCESS_PERMISSIONS\fP est activée. .SS "Limites et réserves" Fanotify 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. .PP L'interface fanotify ne signale pas les accès ni les modifications de fichier qui pourraient survenir à cause de \fBmmap\fP(2), \fBmsync\fP(2) ou \fBmunmap\fP(2). .PP Les événements pour répertoire ne sont créés que si le répertoire lui\-même est ouvert, lu et fermé. Ajouter, supprimer ou modifier les enfants d’un répertoire marqué ne crée pas d’événement pour le répertoire surveillé lui\-même. .PP La surveillance fanotify des répertoires n'est pas récursive\ : pour surveiller les sous\-répertoires, des marques supplémentaires doivent être créées. L’évènement \fBFAN_CREATE\fP peut être utilisé pour détecter quand un sous\-répertoire a été créé dans un répertoire marqué. Une marque supplémentaire doit être définie dans le sous\-répertoire nouvellement créé. Cette approche crée une situation de compétition, parce qu’elle peut perdre les évènements qui se produisent dans le nouveau sous\-répertoire avant qu’une marque soit ajoutée dans ce sous\-répertoire. La surveillance des montages offre la capacité de surveiller un arbre entier de répertoires sans ce problème de chronologie. La surveillance de système de fichiers offre la capacité de surveiller tout montage d’une instance de système de fichiers sans situation de compétition. .PP La file d'événements peut déborder. Dans ce cas, les événements sont perdus. .SH BOGUES .\" commit 820c12d5d6c0890bc93dd63893924a13041fdc35 Avant Linux\ 3.19, \fBfallocate\fP(2) ne créait pas d'événement fanotify. Depuis Linux\ 3.19, les appels à \fBfallocate\fP(2) créent des événements \fBFAN_MODIFY\fP. .PP Dans Linux\ 3.17, les bogues suivants existent\ : .IP \- 3 Dans Linux, un objet du système de fichiers pourrait être accessible par de multiples chemins. Par exemple, une partie d'un système de fichiers pourrait être remontée avec l'option \fI\-\-bind\fP de \fBmount\fP(8). Un écoutant ayant marqué un montage ne sera notifié que des événements déclenchés pour un objet du système de fichiers utilisant le même montage. Tout autre événement passera inaperçu. .IP \- .\" FIXME . A patch was proposed. Quand un événement est créé, aucune vérification n’est effectuée pour voir si l’identifiant utilisateur du processus recevant a le droit de lire ou écrire le fichier avant de passer un descripteur de fichier pour ce fichier. Cela pose un risque de sécurité quand la capacité \fBCAP_SYS_ADMIN\fP est définie pour un programme exécuté par les utilisateurs ordinaires. .IP \- Si un appel de \fBread\fP(2) traite plusieurs événements de la file fanotify et qu’une erreur survient, la valeur de retour sera la taille totale des événements copiés correctement dans le tampon d’espace utilisateur avant que l’erreur ne survienne. La valeur de retour ne sera pas\ \fB\-1\fP et \fIerrno\fP ne sera pas définie. Ainsi, l’application lisant n’a aucun moyen de détecter l’erreur. .SH EXEMPLES Les deux programmes ci\-dessous montrent l’utilisation de l’API de fanotify. .SS "Exemple de programme : fanotify_example.c" Le programme suivant montre l’utilisation de l’interface de programmation fanotify avec les informations d’évènements d’objet passées sous la forme d’un descripteur de fichier. Il marque le point de montage passé en argument de ligne de commande et attend les événements de type \fBFAN_OPEN_PERM\fP et \fBFAN_CLOSE_WRITE\fP. Quand un événement de permission survient, une réponse \fBFAN_ALLOW\fP est donnée. .PP La sortie suivante de session d’interpréteur de commande montre un exemple de l’exécution de ce programme. Cette session concerne l’édition du fichier \fI/home/utilisateur/temp/notes\fP. Avant d’ouvrir le fichier, un événement \fBFAN_OPEN_PERM\fP est survenu. Après la fermeture du fichier, un événement \fBFAN_CLOSE_WRITE\fP est survenu. L’exécution du programme se termine quand l’utilisateur appuie sur la touche Entrée. .PP .in +4n .EX # \fB./fanotify_exemple /home\fP Appuyer sur la touche Entrée pour quitter. En écoute d’événements. FAN_OPEN_PERM : Fichier /home/utilisateur/temp/notes FAN_CLOSE_WRITE : Fichier /home/utilisateur/temp/notes Arrêt de l’écoute d’événements. .EE .in .SS "Source du programme : fanotify_example.c" \& .EX #define _GNU_SOURCE /* Nécessaire pour obtenir la définition de O_LARGEFILE */ #include #include #include #include #include #include #include #include /* Read all available fanotify events from the file descriptor \[aq]fd\[aq]. */ static void handle_events(int fd) { const struct fanotify_event_metadata *metadata; struct fanotify_event_metadata buf[200]; ssize_t len; char path[PATH_MAX]; ssize_t path_len; char procfd_path[PATH_MAX]; struct fanotify_response response; /* Boucler tant que les événements peuvent être lus à partir du descripteur de fichier fanotify */ for (;;) { /* Lire certains événements */ len = read(fd, buf, sizeof(buf)); if (len == \-1 && errno != EAGAIN) { perror("read"); exit(EXIT_FAILURE); } /* Vérifier si la fin des données disponibles est atteinte */ if (len <= 0) break; /* Pointer vers le premier événement du tampon */ metadata = buf; /* Boucler sur tous les événements du tampon */ while (FAN_EVENT_OK(metadata, len)) { /* Vérifier que les structures au moment de l’exécution et de la compilation correspondent */ if (metadata\->vers != FANOTIFY_METADATA_VERSION) { fprintf(stderr, "Non correspondance de version de métadonnées fanotify.\en"); exit(EXIT_FAILURE); } /* metadata\->fd contient soit FAN_NOFD, indiquant un dépassement de file, soit un descripteur de fichier (un entier positif). Ici, le dépassement de file est simplement ignoré. */ if (metadata\->fd >= 0) { /* Traiter l’événement de permission d’ouverture */ if (metadata\->mask & FAN_OPEN_PERM) { printf("FAN_OPEN_PERM\ : "); /* Permettre d’ouvrir le fichier */ response.fd = metadata\->fd; response.response = FAN_ALLOW; write(fd, &response, sizeof(response)); } /* Traiter l’événement de fermeture de fichier ouvert en écriture */ if (metadata\->mask & FAN_CLOSE_WRITE) printf("FAN_CLOSE_WRITE\ : "); /* Récupérer et afficher le chemin du fichier accédé */ snprintf(procfd_path, sizeof(procfd_path), "/proc/self/fd/%d", metadata\->fd); path_len = readlink(procfd_path, path, sizeof(path) \- 1); if (path_len == \-1) { perror("readlink"); exit(EXIT_FAILURE); } path[path_len] = \[aq]\e0\[aq]; printf("File %s\en", path); /* Fermer le descripteur de fichier de l’événement */ close(metadata\->fd); } /* Avancer au prochain événement */ metadata = FAN_EVENT_NEXT(metadata, len); } } } int main(int argc, char *argv[]) { char buf; int fd, poll_num; nfds_t nfds; struct pollfd fds[2]; /* Vérifier qu’un point de montage est fourni */ if (argc != 2) { fprintf(stderr, "Utilisation\ : %s MONTAGE\en", argv[0]); exit(EXIT_FAILURE); } printf("Appuyer sur la touche Entrée pour quitter.\en"); /* Créer le descripteur de fichier pour accéder à l’interface de programmation fanotify */ fd = fanotify_init(FAN_CLOEXEC | FAN_CLASS_CONTENT | FAN_NONBLOCK, O_RDONLY | O_LARGEFILE); if (fd == \-1) { perror("fanotify_init"); exit(EXIT_FAILURE); } /* Marquer le montage pour : — les événements de permission avant d’ouvrir les fichiers — les événements de notification après fermeture de descripteur de fichier ouvert en écriture */ if (fanotify_mark(fd, FAN_MARK_ADD | FAN_MARK_MOUNT, FAN_OPEN_PERM | FAN_CLOSE_WRITE, AT_FDCWD, argv[1]) == \-1) { perror("fanotify_mark"); exit(EXIT_FAILURE); } /* Préparer pour la scrutation (polling) */ nfds = 2; fds[0].fd = STDIN_FILENO; /* Entrée de console */ fds[0].events = POLLIN; fds[1].fd = fd; /* Entrée fanotify */ fds[1].events = POLLIN; /* Boucle en attente d’arrivée d’événements */ printf("En écoute d’événements.\en"); while (1) { poll_num = poll(fds, nfds, \-1); if (poll_num == \-1) { if (errno == EINTR) /* Interrompu par un signal */ continue; /* Redémarrage de poll() */ perror("poll"); /* Erreur inattendue */ exit(EXIT_FAILURE); } if (poll_num > 0) { if (fds[0].revents & POLLIN) { /* Entrée de console disponible : effacer l’entrée standard et quitter */ while (read(STDIN_FILENO, &buf, 1) > 0 && buf != \[aq]\en\[aq]) continue; break; } if (fds[1].revents & POLLIN) { /* Des événements fanotify sont disponibles */ handle_events(fd); } } } printf("Arrêt de l’écoute d’événements.\en"); exit(EXIT_SUCCESS); } .EE .\" .SS "Exemple de programme : fanotify_fid.c" The second program is an example of fanotify being used with a group that identifies objects by file handles. The program marks the filesystem object that is passed as a command\-line argument and waits until an event of type \fBFAN_CREATE\fP has occurred. The event mask indicates which type of filesystem object\[em]either a file or a directory\[em]was created. Once all events have been read from the buffer and processed accordingly, the program simply terminates. .PP Les sessions d’interpréteur de commande suivantes montrent deux invocations différentes avec des actions différentes réalisées sur l’objet désiré. .PP La première session montre une marque placée sur \fI/home/utilisateur\fP. Cela est suivi par la création d’un fichier normal, \fI/home/utilisateur/fichiertest.txt\fP. Cela aboutit à un évènement \fBFAN_CREATE\fP généré et rapporté à l’objet de répertoire surveillé parent du fichier et à la création du nom de fichier. L’exécution du programme se termine une fois que tous les évènements capturés du tampon ont été traités. .PP .in +4n .EX # \fB./fanotify_fid /home/user\fP Listening for events. FAN_CREATE (file created): Directory /home/user has been modified. Entry \[aq]testfile.txt\[aq] is not a subdirectory. All events processed successfully. Program exiting. $ \fBtouch /home/utilisateur/fichiertest.txt\fP # Dans un autre terminal .EE .in .PP La première session montre une marque placée sur \fI/home/utilisateur\fP. C’est suivi par la création d’un répertoire, \fI/home/utilisateur/réptest\fP. Cette action spécifique aboutit à la génération d’un évènement \fBFAN_CREATE\fP et est rapporté avec l’attribut \fBFAN_ONDIR\fP défini et avec la création du nom de répertoire. .PP .in +4n .EX # \fB./fanotify_fid /home/user\fP Listening for events. FAN_CREATE | FAN_ONDIR (subdirectory created): Directory /home/user has been modified. Entry \[aq]testdir\[aq] is a subdirectory. All events processed successfully. Program exiting. $ \fBmkdir \-p /home/utilisateur/réptest\fP # Dans un autre terminal .EE .in .SS "Source du programme : fanotify_fid.c" \& .EX #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #define BUF_SIZE 256 int main(int argc, char *argv[]) { int fd, ret, event_fd, mount_fd; ssize_t len, path_len; char path[PATH_MAX]; char procfd_path[PATH_MAX]; char events_buf[BUF_SIZE]; struct file_handle *file_handle; struct fanotify_event_metadata *metadata; struct fanotify_event_info_fid *fid; const char *file_name; struct stat sb; if (argc != 2) { fprintf(stderr, "nb d’arguments de ligne de commande non valable.\en"); exit(EXIT_FAILURE); } mount_fd = open(argv[1], O_DIRECTORY | O_RDONLY); if (mount_fd == \-1) { perror(argv[1]); exit(EXIT_FAILURE); } /* Créer un descripteur de fichier avec FAN_REPORT_DFID_NAME sous forme d’attribut de façon que le programme puisse recevoir des évènements fid avec des noms de répertoire d’entrée */ fd = fanotify_init(FAN_CLASS_NOTIF | FAN_REPORT_DFID_NAME, 0); if (fd == \-1) { perror("fanotify_init"); exit(EXIT_FAILURE); } /* Placer une marque sur un objet de système de fichiers fourni dans argv[1]. */ ret = fanotify_mark(fd, FAN_MARK_ADD | FAN_MARK_ONLYDIR, FAN_CREATE | FAN_ONDIR, AT_FDCWD, argv[1]); if (ret == \-1) { perror("fanotify_mark"); exit(EXIT_FAILURE); } printf("En écoute d’événements.\en"); /* Lire les évènements dans la file dans le tampon */ len = read(fd, events_buf, sizeof(events_buf)); if (len == \-1 && errno != EAGAIN) { perror("read"); exit(EXIT_FAILURE); } /* Traiter tous les événements du tampon */ for (metadata = (struct fanotify_event_metadata *) events_buf; FAN_EVENT_OK(metadata, len); metadata = FAN_EVENT_NEXT(metadata, len)) { fid = (struct fanotify_event_info_fid *) (metadata + 1); file_handle = (struct file_handle *) fid\->handle; /* Assurer que l’info d’évènement soit du type correct */ if (fid\->hdr.info_type == FAN_EVENT_INFO_TYPE_FID || fid\->hdr.info_type == FAN_EVENT_INFO_TYPE_DFID) { file_name = NULL; } else if (fid\->hdr.info_type == FAN_EVENT_INFO_TYPE_DFID_NAME) { file_name = file_handle\->f_handle + file_handle\->handle_bytes; } else { fprintf(stderr, "Type inattendu d’évènement reçu.\en"); exit(EXIT_FAILURE); } if (metadata\->mask == FAN_CREATE) printf("FAN_CREATE (file created):\en"); if (metadata\->mask == (FAN_CREATE | FAN_ONDIR)) printf("FAN_CREATE | FAN_ONDIR (sous_répertoire créé) :\en"); /* metadata\->fd is set to FAN_NOFD when the group identifies objects by file handles. To obtain a file descriptor for the file object corresponding to an event you can use the struct file_handle that\[aq]s provided within the fanotify_event_info_fid in conjunction with the open_by_handle_at(2) system call. A check for ESTALE is done to accommodate for the situation where the file handle for the object was deleted prior to this system call. */ event_fd = open_by_handle_at(mount_fd, file_handle, O_RDONLY); if (event_fd == \-1) { if (errno == ESTALE) { printf("Le gestionnaire de fichiers n’est plus valable, " "le fichier a été supprimé\en"); continue; } else { perror("open_by_handle_at"); exit(EXIT_FAILURE); } } snprintf(procfd_path, sizeof(procfd_path), "/proc/self/fd/%d", event_fd); /* Retrouver et afficher le chemin de l’entrée modifiée */ path_len = readlink(procfd_path, path, sizeof(path) \- 1); if (path_len == \-1) { perror("readlink"); exit(EXIT_FAILURE); } path[path_len] = \[aq]\e0\[aq]; printf("\etDirectory \[aq]%s\[aq] has been modified.\en", path); if (file_name) { ret = fstatat(event_fd, file_name, &sb, 0); if (ret == \-1) { if (errno != ENOENT) { perror("fstatat"); exit(EXIT_FAILURE); } printf("\etEntry \[aq]%s\[aq] does not exist.\en", file_name); } else if ((sb.st_mode & S_IFMT) == S_IFDIR) { printf("\etEntry \[aq]%s\[aq] is a subdirectory.\en", file_name); } else { printf("\etEntry \[aq]%s\[aq] is not a subdirectory.\en", file_name); } } /* Fermer le descripteur de fichier de l’événement */ close(event_fd); } printf("Tous les évènements traités avec succès, fin du programme.\en"); exit(EXIT_SUCCESS); } .EE .SH "VOIR AUSSI" .ad l \fBfanotify_init\fP(2), \fBfanotify_mark\fP(2), \fBinotify\fP(7) .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot et Jean-Paul Guillonneau . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .