Basic usage and precautions of inotify under Linux

Recently writing a cloud backup project, one of the modules is to monitor the computer's local files, so I turned over the Linux/unix system Programming manual found INotify this framework for file monitoring

1. Overview

1) The inotify mechanism can be used to monitor files or directories. When the directory is monitored, the directory itself and the files below it are monitored and notified to the application when an event occurs.

2) inotify Monitoring mechanism is non-recursive, if the application intentionally monitors events within the entire directory subtree, it is necessary to initiate a inotify_add_watch () call to each directory in the tree

3) Monitor inotify file descriptors using Select (), poll (), Epoll (), and signal-driven I/O

2.inotify API

1) inotify_init () system call to create a new inotify instance

[CPP]View PlainCopy

1. #include <sys/inotify.h>
2. int inotify_init (void);

The return value of the function is a file descriptor, and we can simply understand that the file descriptor will save the set of events that occur in a directory similar to the one being monitored.

2) for the monitoring list of inotify instances referred to by FD, the system call Inotify_add_watch () can append new monitoring items

[CPP]View PlainCopy

1. #include <sys/inotify.h>
2. int inotify_add_watch (int fd,const char *pathname,uint32_t mask);

The parameter pathname is the file for the monitor item that you want to create, paying particular attention to the need to have read access to the file, which checks the file only once, and if the monitored file Read permission is modified at the time of monitoring, it will not affect the continued monitoring of this file

The parameter mask is a mask that defines the event that you want to monitor for pathname, and the return value of this function is a descriptor that uniquely refers to this monitoring item

3.inotify Events

In_access file is accessed

In_attrib file meta data changes

In_close_write closed file opened in order to write

In_create Creating a file or directory under the monitored directory

In_delete deleted files or directories within the monitored directory

in_delete_self deleted the monitored directory/file itself

In_modify file is modified

in_modify_self Mobile Monitored directory or file itself

In_moved_from files removed from monitored directory

In_moved_to moving files to a monitored directory

In_open file is open

In_all_events All of the output events above

In_moveIn_moved_from | The In_moved_to event is collectively

In_oneshot only monitors an event in pathname

In_onlydirpathname will fail when not in the directory

For a description of some of these events:

1) In_attrib event occurs when file metadata (for example, permissions, ownership, link count, extended attribute, user ID, or group ID, etc.) changes

2) in_delete_self occurs when a monitored object is deleted

3) In_more_self event occurs when renaming objects

4) One_shot allows only one event of the pathname to be monitored, and the monitoring item will automatically disappear from the watch list after the event occurs

4. Read the INotify Event

After registering the monitoring item in the monitoring list, the should be shipped program can read the event from the INotify file descriptor using read () to determine which events occurred. If no events have occurred at the time of reading, then read () blocks until an event occurs, and each call to read () returns a buffer containing one or more of the following types of struct

[CPP]View PlainCopy

1. struct inotify_event
2. {
3. <span style="White-space:pre" > </span>int wd;

[CPP]View PlainCopy

1. <span style="White-space:pre" > </span>uint32_t mask;

[CPP]View PlainCopy

1. <span style="White-space:pre" > </span>uint32_t cookies;

[CPP]View PlainCopy

1. <span style="White-space:pre" > </span>uint32_t len;

[CPP]View PlainCopy

1. <span style="White-space:pre" > </span>char name[];
2. }

The. Field WD named the monitor descriptor for the event, which was returned by a previous call to Inotify_add_watch (). Because read () reads all the events in the INotify file, but how should we differentiate what we read when inotify simultaneously monitor multiple directories or files, which WD has come to use, we can differentiate it with WD

The. Mask field returns a bitmask that describes the event

The. Cookie field ties related events together and is currently only used when renaming

The. Len field represents the number of bytes actually assigned to the name field

The. Name field is the file that is marked

5. Examples of simple procedures [CPP]View PlainCopy

2. #include <stdio.h>
4. #include <assert.h>
6. #include <unistd.h>
8. #include <stdlib.h>
10. #include <errno.h>
12. #include <string.h>
14. #include <sys/types.h>
16. #include <sys/inotify.h>
18. #include <limits.h>
20. #include <fcntl.h>
26. #define Buf_len 1000
30. void Displayinotifyevent (struct inotify_event *i)
32. {
34. printf ("WD =%2d;", I->WD);
38. if (I->cookie > 0)
40. {
42. printf ("Cokkie =%4d;", I->cookie);
44. }
48. printf ("mask =");
52. if (I->mask & in_access) printf ("in_access\n");
54. if (I->mask & in_delete_self) printf ("in_delete_self\n");
56. if (I->mask & in_modify) printf ("in_modify\n");
58. if (I->mask & In_open) printf ("in_open\n");
64. if (len > 0)
66. {
68. printf ("name =%s\n", i->name);
70. }
76. }
80. int main (int argc,char **argv)
82. {
84. int inotifyfd,wd,j;
86. Char Buf[buf_len];
88. ssize_t Numread;
90. Char *p;
92. struct inotify_event *event;
94. int flags;
102. if (argc < 2)
104. {
106. printf ("error\n");
108. }
112. INOTIFYFD = Inotify_init ();
114. if (INOTIFYFD = =-1)
116. {
118. printf ("initialization failed");
120. }
124. WD = Inotify_add_watch (inotifyfd,argv[1],in_all_events);
126. if (wd = =-1)
128. {
130. printf ("error\n");
132. }
136. printf ("watching%s using WD%d\n", ARGV[1],WD);
144. While (1)
146. {
148. Numread = Read (Inotifyfd,buf,buf_len);
150. if (Numread = =-1)
152. {
154. printf ("read error\n");
156. }
160. printf ("Read%ldbytes from INotify fd\n", (long) numread);
162. For (P=buf;p < buf+numread;)
164. {
166. event = (struct inotify_event *) p;
168. Displayinotifyevent (event);
170. p+=sizeof (struct inotify_event) + event->len;
172. }
174. }
178. return 0;
182. }

Basic usage and precautions of inotify under Linux