NAME<\/a> fanotify \u2212 monitoring filesystem events<\/p>\n The fanotify API provides notification and interception of filesystem events. Use cases include virus scanning and hierarchical storage management. In the original fanotify API, only a limited set of events was supported. In particular, there was no support for create, delete, and move events. The support for those events was added in Linux 5.1. (See inotify<\/b>(7) for details of an API that did notify those events pre Linux 5.1.)<\/p>\n Additional capabilities compared to the inotify<\/b>(7) API include the ability to monitor all of the objects in a mounted filesystem, the ability to make access permission decisions, and the possibility to read or modify files before access by other applications.<\/p>\n The following system calls are used with this API: fanotify_init<\/b>(2), fanotify_mark<\/b>(2), read<\/b>(2), write<\/b>(2), and close<\/b>(2).<\/p>\n fanotify_init(), fanotify_mark(), and notification groups<\/b> An fanotify notification group is a kernel-internal object that holds a list of files, directories, filesystems, and mount points for which events shall be created.<\/p>\n For each entry in an fanotify notification group, two bit masks exist: the mark<\/i> mask and the ignore<\/i> mask. The mark mask defines file activities for which an event shall be created. The ignore mask defines activities for which no event shall be generated. Having these two types of masks permits a filesystem, mount point, or directory to be marked for receiving events, while at the same time ignoring events for specific objects under a mount point or directory.<\/p>\n The fanotify_mark<\/b>(2) system call adds a file, directory, filesystem or mount point to a notification group and specifies which events shall be reported (or ignored), or removes or modifies such an entry.<\/p>\n A possible usage of the ignore mask is for a file cache. Events of interest for a file cache are modification of a file and closing of the same. Hence, the cached directory or mount point is to be marked to receive these events. After receiving the first event informing that a file has been modified, the corresponding cache entry will be invalidated. No further modification events for this file are of interest until the file is closed. Hence, the modify event can be added to the ignore mask. Upon receiving the close event, the modify event can be removed from the ignore mask and the file cache entry can be updated.<\/p>\n The entries in the fanotify notification groups refer to files and directories via their inode number and to mounts via their mount ID. If files or directories are renamed or moved within the same mount, the respective entries survive. If files or directories are deleted or moved to another mount or if filesystems or mounts are unmounted, the corresponding entries are deleted.<\/p>\n The event queue<\/b> Two types of events are generated: notification<\/i> events and permission<\/i> events. Notification events are merely informative and require no action to be taken by the receiving application with one exception: if a valid file descriptor is provided within a generic event, the file descriptor must be closed. Permission events are requests to the receiving application to decide whether permission for a file access shall be granted. For these events, the recipient must write a response which decides whether access is granted or not.<\/p>\n An event is removed from the event queue of the fanotify group when it has been read. Permission events that have been read are kept in an internal list of the fanotify group until either a permission decision has been taken by writing to the fanotify file descriptor or the fanotify file descriptor is closed.<\/p>\n Reading fanotify events<\/b> The use of one of the flags FAN_REPORT_FID<\/b>, FAN_REPORT_DIR_FID<\/b> in fanotify_init<\/b>(2) influences what data structures are returned to the event listener for each event. Events reported to a group initialized with one of these flags will use file handles to identify filesystem objects instead of file descriptors. read<\/b>(2), the read buffer contains one or more of the following structures:<\/p>\n struct fanotify_event_metadata { In case of an fanotify group that identifies filesystem objects by file handles, you should also expect to receive one or more additional information records of the structure detailed below following the generic fanotify_event_metadata<\/i> structure within the read buffer:<\/p>\n struct fanotify_event_info_header { struct fanotify_event_info_fid { For performance reasons, it is recommended to use a large buffer size (for example, 4096 bytes), so that multiple events can be retrieved by a single read<\/b>(2).<\/p>\n The return value of read<\/b>(2) is the number of bytes placed in the buffer, or \u22121 in case of an error (but see BUGS).<\/p>\n The fields of the fanotify_event_metadata<\/i> structure are as follows: This is the length of the data for the current event and the offset to the next event in the buffer. Unless the group identifies filesystem objects by file handles, the value of event_len<\/i> is always FAN_EVENT_METADATA_LEN<\/b>. For a group that identifies filesystem objects by file handles, event_len<\/i> also includes the variable length file identifier records.<\/p>\n
DESCRIPTION<\/a>
ERRORS<\/a>
VERSIONS<\/a>
CONFORMING TO<\/a>
NOTES<\/a>
BUGS<\/a>
EXAMPLES<\/a>
SEE ALSO<\/a>
COLOPHON<\/a> <\/p>\n
\nNAME <\/a> <\/h2>\n
DESCRIPTION <\/a> <\/h2>\n
The fanotify_init<\/b>(2) system call creates and initializes an fanotify notification group and returns a file descriptor referring to it.<\/p>\n
As events occur on the filesystem objects monitored by a notification group, the fanotify system generates events that are collected in a queue. These events can then be read (using read<\/b>(2) or similar) from the fanotify file descriptor returned by fanotify_init<\/b>(2).<\/p>\n
Calling read<\/b>(2) for the file descriptor returned by fanotify_init<\/b>(2) blocks (if the flag FAN_NONBLOCK<\/b> is not specified in the call to fanotify_init<\/b>(2)) until either a file event occurs or the call is interrupted by a signal (see signal<\/b>(7)).<\/p>\n
After a successful<\/p>\n
__u32 event_len;
__u8 vers;
__u8 reserved;
__u16 metadata_len;
__aligned_u64 mask;
__s32 fd;
__s32 pid;
};<\/p>\n
__u8 info_type;
__u8 pad;
__u16 len;
};<\/p>\n
struct fanotify_event_info_header hdr;
__kernel_fsid_t fsid;
unsigned char file_handle[0];
};<\/p>\n
event_len<\/i><\/p>\n