linux中的inotify

文件系统事件监控对于从文件管理器到安全工具的各种程序都是必要的，但是 dnotify（早期内核中的标准）存在一些局限性，这使我们期待出现一种更加完善的机制。抱着这种期待，我们发现了 inotify，一种更加现代化的文件系统事件监控替代品。

使用 inotify 取代 dnotify 的原因有很多。第一个原因是，dnotify 需要您为每个打算监控是否发生改变的目录打开一个文件描述符。当同时监控多个目录时，这会消耗大量的资源，因为有可能达到每个进程的文件描述符限制。

除此之外，文件描述符会锁定目录，不允许卸载（unmount）支持的设备，这在存在可移动介质的环境中会引发问题。在使用 inotify 时，如果正在监控被卸载的文件系统上的文件，那么监控会被自动移除并且您会接收到一个卸载事件。

dnotify 不如 inotify 的第二个原因是 dnotify 有点复杂。注意，使用 dnotify 基础设施的简单文件系统监控粒度只停留于目录级别。为了使用 dnotify 进行更细粒度的监控，应用程序编程人员必须为每个受监控的目录保留一个 stat 结构的缓存。该用户空间的 stat 结构缓存需要用来明确确定当接收到通知信号时目录发生了什么变化。当获得通知信号时，生成 stat 结构列表并与最新的状态相比较。显而易见，这种技术是不理想的。

inotify 的另一个优点是它使用文件描述符作为基本接口，使应用程序开发者使用 select 和 poll 来监控设备。这允许有效的多路 I/O 和与 Glib 的 mainloop 的集成。相反，dnotify 所使用的信号常常使程序员头疼并且感觉不太优雅。

inotify 通过提供一个更优雅的 API 解决了这些问题，该 API 使用最少的文件描述符，并确保更细粒度的监控。与 inotify 的通信是通过设备节点提供的。基于以上原因，对于监控 Linux 2.6 平台上的文件，inotify 是您最明智的选择。

安装 inotify 的第一步是确定您使用的 Linux 内核是否支持它。检查发行版的最简单方法是，寻找是否存在 /dev/inotify 设备。如果存在该设备，您可以跳到 在简单应用程序中使用 inotify 一节。

在撰写本文时，inotify 包含在 Andrew Morton 的 Linux 2.6-mm 目录树中，而且一些 Linux 发行版正在提供支持 inotify 的内核（包括 Gentoo 和 Ubuntu）或者具有提供支持的补充内核包（例如 Fedora 和 SuSE）。因为 Andrew 可能会根据需要从目录树删除对 inotify 的支持，并且 inotify 版本还处于频繁的开发阶段，所以强烈建议您从头开始打补丁。

如果缺少该设备，您可能需要对内核打补丁并创建该设备。

可以从 Linux Kernel Archives 获得 inotify 补丁（请参阅 参考资料 一节的链接）。

您应该为特定的内核应用最高版本编号的补丁。每个发行版处理内核的安装都有所不同，但以下介绍的是一个通用指导。注意：从 Linux Kernel Archives 获取发行版 2.6 Linux 内核源文件，如果合适，请获取最新的稳定版本。

从进入内核源文件目录开始：

bash:~$ cd /usr/src

因为您早先安装了内核源文件，现在需要将它解压缩：

bash:~$ sudo tar jxvf linux-source-2.6.8.1.tar.bz2

现在，使您的 symlink 指向新的源文件目录树：

bash:~$ sudo ln -sf linux-source-2.6.8.1 linux

改变当前目录到刚才创建的内核源文件目录：

bash:~$ cd linux

拷贝 inotify 补丁：

bash:~$ sudo cp ~/inotify* /usr/src

将内核打补丁：

bash:~$ sudo patch -p1 < ../inotify*.patch

构建内核：

bash:~$ sudo make menuconfig

像平时一样配置您的内核，确保 inotify 工作正常。如果必要，请将新内核添加到引导加载程序中，但是一定要记住维护旧内核的映像和引导加载程序选项。这一步对于不同引导加载程序有所不同（请参阅 参考资料 了解关于特定引导加载程序的更多信息）。重新引导计算机并选择启用 inotify 的新内核。在继续往下操作前，测试您的新内核以确保它工作正常。

接下来，您需要确保创建 /dev/inotify 设备。以下步骤带领您完成这个过程。重要注意：次设备编号可能会发生改变，所以您需要多加注意以确保它随时更新！如果 Linux 安装支持 udev 功能，它将会自动保持更新。

在重新引导到新内核后，您必须获取次设备编号：

bash:~$ dmesg | grep ^inotify

返回结果示例如下：

inotify device minor=63

因为 inotify 是 misc 设备，所以主设备编号是 10。要创建设备节点作为根用户，请执行以下命令：

bash:~$ mknod /dev/inotify c 10 63

注意：如有必要，请使用合适的次设备编号替换“63”。

您可以随意设置您想要的权限。一个示例权限设置如下所示：

bash:~$ chown root:root /dev/inotify
bash:~$ chmod 666 /dev/inotify

现在准备使用 inotify 设备进行文件系统监控。

为演示 inotify 的使用，我将展示如何为文件系统事件构造一个监控任意目录（或单个文件）的示例程序。我将站在一个较高的层次上来展示 inotify 使文件系统监控变得多么容易。

这个简单的示例向我们展示 inotify 在任意目录上设置监控是多么容易。稍后我们将看到主要的帮助器例程。您可以在本文的 下载 一节获取这些例子中使用的示例代码。

				
/* This program will take as argument a directory name and monitor it,printing event notifications to the console.
*/
int main (int argc, char **argv)
{/* This is the file descriptor for the inotify device */int inotify_fd;/* First we open the inotify dev entry */inotify_fd = open_inotify_dev();if (inotify_fd < 0){return 0;}/* We will need a place to enqueue inotify events,this is needed because if you do not read eventsfast enough, you will miss them.*/queue_t q;q = queue_create (128);/* Watch the directory passed in as argumentRead on for why you might want to alter this formore efficient inotify use in your app.*/watch_dir (inotify_fd, argv[1], ALL_MASK);process_inotify_events (q, inotify_fd);/* Finish up by destroying the queue, closing the fd,and returning a proper code*/queue_destroy (q);close_inotify_dev (inotify_fd);return 0;
}

以下是每个基于 inotify 的应用程序共同的最重要的帮助器例程：

• 为读取而打开 inotify 设备。
• 对从该设备读取的事件进行排队。
• 允许应用程序对事件通知进行有用处理的实际的每事件处理器。

我不会深入钻研事件排队的细节，因为我们能够使用一些策略来避免排队。提供的代码中就展示了一个这样的方法；更先进的多线程方法可以并且已经在其他地方实现。在那些实现中，读者线程简单地在 inotify 设备上执行 select()，然后将事件拷贝到一些线程共享的存储空间（或者一些像 Glib 的异步消息队列的东西），以后处理器线程会处理这里的事件。

				
/* This simply opens the inotify node in dev (read only) */
int open_inotify_dev ()
{int fd;fd = open("/dev/inotify", O_RDONLY);if (fd < 0){perror ("open(\"/dev/inotify\", O_RDONLY) = ");}return fd;
}

这对任何一个在 Linux 系统上进行过文件编程的人来说都应该是熟悉的。

				
/* This method does the dirty work of determining what happened,then allows us to act appropriately
*/
void handle_event (struct inotify_event *event)
{/* If the event was associated with a filename, we will store it here */char * cur_event_filename = NULL;/* This is the watch descriptor the event occurred on */int cur_event_wd = event->wd;if (event->len){cur_event_filename = event->filename;}printf("FILENAME=%s\n", cur_event_filename);printf("\n");/* Perform event dependent handler routines *//* The mask is the magic that tells us what file operation occurred */switch (event->mask){/* File was accessed */case IN_ACCESS:printf("ACCESS EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was modified */case IN_MODIFY:printf("MODIFY EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File changed attributes */case IN_ATTRIB:printf("ATTRIB EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was closed */case IN_CLOSE:printf("CLOSE EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was opened */case IN_OPEN:printf("OPEN EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was moved from X */case IN_MOVED_FROM:printf("MOVE_FROM EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was moved to X */case IN_MOVED_TO:printf("MOVE_TO EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* Subdir was deleted */case IN_DELETE_SUBDIR:printf("DELETE_SUBDIR EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was deleted */case IN_DELETE_FILE:printf("DELETE_FILE EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* Subdir was created */case IN_CREATE_SUBDIR:printf("CREATE_SUBDIR EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* File was created */case IN_CREATE_FILE:printf("CREATE_FILE EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* Watched entry was deleted */case IN_DELETE_SELF:printf("DELETE_SELF EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* Backing FS was unmounted */case IN_UNMOUNT:printf("UNMOUNT EVENT OCCURRED: File \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;/* Too many FS events were received without reading themsome event notifications were potentially lost.  */case IN_Q_OVERFLOW:printf("Warning: AN OVERFLOW EVENT OCCURRED: \n");break;case IN_IGNORED:printf("IGNORED EVENT OCCURRED: \n");break;/* Some unknown message received */default:printf ("UNKNOWN EVENT OCCURRED for file \"%s\" on WD #%i\n",cur_event_filename, cur_event_wd);break;}
}

在每一条 case 语句中，您可以随意执行任意已实现并且满足需要的方法。

至于性能监控，您可以确定哪些文件是最经常被读取的和它们打开的持续时间。这种监控非常方便，因为在某些情况下，如果文件在短时间内被应用程序重复地读取，它会将文件缓存在内存中而不用返回磁盘去读取，从而提高性能。

很容易举出一些执行有趣操作的特定于事件的处理器的例子。比如，如果您是在为底层文件系统实现一个元数据存储索引，您可能会寻找文件创建事件，不久还会在该文件上触发一个元数据挖掘操作。在安全环境中，如果文件被写入一个无人可以写入的目录，您会触发某些形式的系统警报。

请注意，inotify 支持许多非常细粒度的事件 —— 例如 CLOSE 与 CLOSE_WRITE。

****************************************************************************************************************************************************************************

众所周知，Linux 桌面系统与 MAC 或 Windows 相比有许多不如人意的地方，为了改善这种状况，开源社区提出用户态需要内核提供一些机制，以便用户态能够及时地得知内核或底层硬件设备发生了什么，从而能够更好地管理设备，给用户提供更好的服务，如 hotplug、udev 和 inotify 就是这种需求催生的。Hotplug 是一种内核向用户态应用通报关于热插拔设备一些事件发生的机制，桌面系统能够利用它对设备进行有效的管理，udev 动态地维护 /dev 下的设备文件，inotify 是一种文件系统的变化通知机制，如文件增加、删除等事件可以立刻让用户态得知，该机制是著名的桌面搜索引擎项目 beagle 引入的，并在 Gamin 等项目中被应用。

事实上，在 inotify 之前已经存在一种类似的机制叫 dnotify，但是它存在许多缺陷：

1． 对于想监视的每一个目录，用户都需要打开一个文件描述符，因此如果需要监视的目录较多，将导致打开许多文件描述符，特别是，如果被监视目录在移动介质上（如光盘和 USB 盘），将导致无法 umount 这些文件系统，因为使用 dnotify 的应用打开的文件描述符在使用该文件系统。

2． dnotify 是基于目录的，它只能得到目录变化事件，当然在目录内的文件的变化会影响到其所在目录从而引发目录变化事件，但是要想通过目录事件来得知哪个文件变化，需要缓存许多 stat 结构的数据。

3． Dnotify 的接口非常不友好，它使用 signal。

Inotify 是为替代 dnotify 而设计的，它克服了 dnotify 的缺陷，提供了更好用的，简洁而强大的文件变化通知机制：

1． Inotify 不需要对被监视的目标打开文件描述符，而且如果被监视目标在可移动介质上，那么在 umount 该介质上的文件系统后，被监视目标对应的 watch 将被自动删除，并且会产生一个 umount 事件。

2． Inotify 既可以监视文件，也可以监视目录。

3． Inotify 使用系统调用而非 SIGIO 来通知文件系统事件。

4． Inotify 使用文件描述符作为接口，因而可以使用通常的文件 I/O 操作select 和 poll 来监视文件系统的变化。

Inotify 可以监视的文件系统事件包括：

• IN_ACCESS，即文件被访问
• IN_MODIFY，文件被 write
• IN_ATTRIB，文件属性被修改，如 chmod、chown、touch 等
• IN_CLOSE_WRITE，可写文件被 close
• IN_CLOSE_NOWRITE，不可写文件被 close
• IN_OPEN，文件被 open
• IN_MOVED_FROM，文件被移走,如 mv
• IN_MOVED_TO，文件被移来，如 mv、cp
• IN_CREATE，创建新文件
• IN_DELETE，文件被删除，如 rm
• IN_DELETE_SELF，自删除，即一个可执行文件在执行时删除自己
• IN_MOVE_SELF，自移动，即一个可执行文件在执行时移动自己
• IN_UNMOUNT，宿主文件系统被 umount
• IN_CLOSE，文件被关闭，等同于(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
• IN_MOVE，文件被移动，等同于(IN_MOVED_FROM | IN_MOVED_TO)

注：上面所说的文件也包括目录。

在用户态，inotify 通过三个系统调用和在返回的文件描述符上的文件 I/ 操作来使用，使用 inotify 的第一步是创建 inotify 实例：

                int fd = inotify_init ();

每一个 inotify 实例对应一个独立的排序的队列。

文件系统的变化事件被称做 watches 的一个对象管理，每一个 watch 是一个二元组（目标，事件掩码），目标可以是文件或目录，事件掩码表示应用希望关注的 inotify 事件，每一个位对应一个 inotify 事件。Watch 对象通过 watch描述符引用，watches 通过文件或目录的路径名来添加。目录 watches 将返回在该目录下的所有文件上面发生的事件。

下面函数用于添加一个 watch：

                int wd = inotify_add_watch (fd, path, mask);

fd 是 inotify_init() 返回的文件描述符，path 是被监视的目标的路径名（即文件名或目录名），mask 是事件掩码, 在头文件 linux/inotify.h 中定义了每一位代表的事件。可以使用同样的方式来修改事件掩码，即改变希望被通知的inotify 事件。Wd 是 watch 描述符。

下面的函数用于删除一个 watch：

        int ret = inotify_rm_watch (fd, wd);

fd 是 inotify_init() 返回的文件描述符，wd 是 inotify_add_watch() 返回的 watch 描述符。Ret 是函数的返回值。

文件事件用一个 inotify_event 结构表示，它通过由 inotify_init() 返回的文件描述符使用通常文件读取函数 read 来获得

：

struct inotify_event {__s32           wd;             /* watch descriptor */__u32           mask;           /* watch mask */__u32           cookie;         /* cookie to synchronize two events */__u32           len;            /* length (including nulls) of name */char            name[0];        /* stub for possible name */
};

结构中的 wd 为被监视目标的 watch 描述符，mask 为事件掩码，len 为 name字符串的长度，name 为被监视目标的路径名，该结构的 name 字段为一个桩，它只是为了用户方面引用文件名，文件名是变长的，它实际紧跟在该结构的后面，文件名将被 0 填充以使下一个事件结构能够 4 字节对齐。注意，len 也把填充字节数统计在内。

通过 read 调用可以一次获得多个事件，只要提供的 buf 足够大。

                size_t len = read (fd, buf, BUF_LEN);

buf 是一个 inotify_event 结构的数组指针，BUF_LEN 指定要读取的总长度，buf 大小至少要不小于 BUF_LEN，该调用返回的事件数取决于 BUF_LEN 以及事件中文件名的长度。Len 为实际读去的字节数，即获得的事件的总长度。

可以在函数 inotify_init() 返回的文件描述符 fd 上使用 select() 或poll(), 也可以在 fd 上使用 ioctl 命令 FIONREAD 来得到当前队列的长度。close(fd)将删除所有添加到 fd 中的 watch 并做必要的清理。

                int inotify_init (void);int inotify_add_watch (int fd, const char *path, __u32 mask);int inotify_rm_watch (int fd, __u32 mask);

在内核中，每一个 inotify 实例对应一个 inotify_device 结构：

struct inotify_device {wait_queue_head_t       wq;             /* wait queue for i/o */struct idr              idr;            /* idr mapping wd -> watch */struct semaphore        sem;            /* protects this bad boy */struct list_head        events;         /* list of queued events */struct list_head        watches;        /* list of watches */atomic_t                count;          /* reference count */struct user_struct      *user;          /* user who opened this dev */unsigned int            queue_size;     /* size of the queue (bytes) */unsigned int            event_count;    /* number of pending events */unsigned int            max_events;     /* maximum number of events */u32                     last_wd;        /* the last wd allocated */
};

wq 是等待队列，被 read 调用阻塞的进程将挂在该等待队列上，idr 用于把 watch 描述符映射到对应的 inotify_watch，sem 用于同步对该结构的访问，events 为该 inotify 实例上发生的事件的列表，被该 inotify 实例监视的所有事件在发生后都将插入到这个列表，watches 是给 inotify 实例监视的 watch 列表，inotify_add_watch 将把新添加的 watch 插入到该列表，count 是引用计数，user 用于描述创建该 inotify 实例的用户，queue_size 表示该 inotify 实例的事件队列的字节数，event_count 是 events 列表的事件数，max_events 为最大允许的事件数，last_wd 是上次分配的 watch 描述符。

每一个 watch 对应一个 inotify_watch 结构：

struct inotify_watch {struct list_head        d_list; /* entry in inotify_device's list */struct list_head        i_list; /* entry in inode's list */atomic_t                count;  /* reference count */struct inotify_device   *dev;   /* associated device */struct inode            *inode; /* associated inode */s32                     wd;     /* watch descriptor */u32                     mask;   /* event mask for this watch */
};

d_list 指向所有 inotify_device 组成的列表的，i_list 指向所有被监视 inode 组成的列表，count 是引用计数，dev 指向该 watch 所在的 inotify 实例对应的 inotify_device 结构，inode 指向该 watch 要监视的 inode，wd 是分配给该 watch 的描述符，mask 是该 watch 的事件掩码，表示它对哪些文件系统事件感兴趣。

结构 inotify_device 在用户态调用 inotify_init() 时创建，当关闭 inotify_init()返回的文件描述符时将被释放。结构 inotify_watch 在用户态调用 inotify_add_watch()时创建，在用户态调用 inotify_rm_watch() 或 close(fd) 时被释放。

无论是目录还是文件，在内核中都对应一个 inode 结构，inotify 系统在 inode 结构中增加了两个字段：

#ifdef CONFIG_INOTIFYstruct list_head	inotify_watches; /* watches on this inode */struct semaphore	inotify_sem;	/* protects the watches list */
#endif

inotify_watches 是在被监视目标上的 watch 列表，每当用户调用 inotify_add_watch()时，内核就为添加的 watch 创建一个 inotify_watch 结构，并把它插入到被监视目标对应的 inode 的 inotify_watches 列表。inotify_sem 用于同步对 inotify_watches 列表的访问。当文件系统发生第一部分提到的事件之一时，相应的文件系统代码将显示调用fsnotify_* 来把相应的事件报告给 inotify 系统，其中*号就是相应的事件名，目前实现包括：

• fsnotify_move，文件从一个目录移动到另一个目录
• fsnotify_nameremove，文件从目录中删除
• fsnotify_inoderemove，自删除
• fsnotify_create，创建新文件
• fsnotify_mkdir，创建新目录
• fsnotify_access，文件被读
• fsnotify_modify，文件被写
• fsnotify_open，文件被打开
• fsnotify_close，文件被关闭
• fsnotify_xattr，文件的扩展属性被修改
• fsnotify_change，文件被修改或原数据被修改

有一个例外情况，就是 inotify_unmount_inodes，它会在文件系统被 umount 时调用来通知 umount 事件给 inotify 系统。

以上提到的通知函数最后都调用 inotify_inode_queue_event（inotify_unmount_inodes直接调用 inotify_dev_queue_event ），该函数首先判断对应的inode是否被监视，这通过查看 inotify_watches 列表是否为空来实现，如果发现 inode 没有被监视，什么也不做，立刻返回，反之，遍历 inotify_watches 列表，看是否当前的文件操作事件被某个 watch 监视，如果是，调用 inotify_dev_queue_event，否则，返回。函数inotify_dev_queue_event 首先判断该事件是否是上一个事件的重复，如果是就丢弃该事件并返回，否则，它判断是否 inotify 实例即 inotify_device 的事件队列是否溢出，如果溢出，产生一个溢出事件，否则产生一个当前的文件操作事件，这些事件通过kernel_event 构建，kernel_event 将创建一个 inotify_kernel_event 结构，然后把该结构插入到对应的 inotify_device 的 events 事件列表，然后唤醒等待在inotify_device 结构中的 wq 指向的等待队列。想监视文件系统事件的用户态进程在inotify 实例（即 inotify_init() 返回的文件描述符）上调用 read 时但没有事件时就挂在等待队列 wq 上。

下面是一个使用 inotify 来监视文件系统事件的例子：

#include 
#include 
#include 
_syscall0(int, inotify_init)
_syscall3(int, inotify_add_watch, int, fd, const char *, path, __u32, mask)
_syscall2(int, inotify_rm_watch, int, fd, __u32, mask)
char * monitored_files[] = {"./tmp_file","./tmp_dir","/mnt/sda3/windows_file"
};
struct wd_name {int wd;char * name;
};
#define WD_NUM 3
struct wd_name wd_array[WD_NUM];
char * event_array[] = {"File was accessed","File was modified","File attributes were changed","writtable file closed","Unwrittable file closed","File was opened","File was moved from X","File was moved to Y","Subfile was created","Subfile was deleted","Self was deleted","Self was moved","","Backing fs was unmounted","Event queued overflowed","File was ignored"
};
#define EVENT_NUM 16
#define MAX_BUF_SIZE 1024int main(void)
{int fd;int wd;char buffer[1024];char * offset = NULL;struct inotify_event * event;int len, tmp_len;char strbuf[16];int i = 0;fd = inotify_init();if (fd < 0) {printf("Fail to initialize inotify.\n");exit(-1);}for (i=0; imask & IN_ISDIR) {memcpy(strbuf, "Direcotory", 11);}else {memcpy(strbuf, "File", 5);}printf("Object type: %s\n", strbuf);for (i=0; iwd != wd_array[i].wd) continue;printf("Object name: %s\n", wd_array[i].name);break;}printf("Event mask: %08X\n", event->mask);for (i=0; imask & (1<len;event = (struct inotify_event *)(offset + tmp_len); offset += tmp_len;}}
}

该程序将监视发生在当前目录下的文件 tmp_file 与当前目录下的目录 tmp_dir 上的所有文件系统事件， 同时它也将监视发生在文件 /mnt/sda3/windows_file 上的文件系统事件，注意，/mnt/sda3 是 SATA 硬盘分区 3 的挂接点。

细心的读者可能注意到，该程序首部使用 _syscallN 来声明 inotify 系统调用，原因是这些系统调用是在最新的稳定内核 2.6.13 中引入的，glibc 并没有实现这些系统调用的库函数版本，因此，为了能在程序中使用这些系统调用，必须通过 _syscallN 来声明这些新的系统，其中的 N 为要声明的系统调用实际的参数数。还有需要注意的地方是系统的头文件必须与被启动的内核匹配，为了让上面的程序能够成功编译，必须让 2.6.13 的内核头文件（包括 include/linux/*, include/asm/* 和 include/asm-generic/*）在头文件搜索路径内，并且是第一优先搜索的头文件路径，因为 _syscallN 需要用到这些头文件中的 linux/unistd.h 和 asm/unistd.h，它们包含了 inotify 的三个系统调用的系统调用号 __NR_inotify_init、__NR_inotify_add_watch 和 __NR_inotify_rm_watch。

因此，要想成功编译此程序，只要把用户编译好的内核的头文件拷贝到该程序所在的路径，并使用如下命令编译即可：

$gcc -o inotify_example  -I. inotify_example.c

注意：当前目录下应当包含 linux、asm 和 asm-generic 三个已编译好的 2.6.13 内核的有文件目录，asm 是一个链接，因此拷贝 asm 头文件的时候需要拷贝 asm 与 asm-ARCH（对于 x86 平台应当是 asm-i386）。 然后，为了运行该程序，需要在当前目录下创建文件 tmp_file 和目录 tmp_dir，对于/mnt/sda3/windows_file 文件，用户需要依自己的实际情况而定，可能是/mnt/dosc/windows_file，即 /mnt/dosc 是一个 FAT32 的 windows 硬盘，因此用户在编译该程序时需要根据自己的实际情况来修改 /mnt/sda3。Windows_file 是在被 mount 硬盘上创建的一个文件，为了运行该程序，它必须被创建。

以下是作者在 redhat 9.0 上运行此程序得到的一些结果：

当运行此程序的时候在另一个虚拟终端执行 cat ./tmp_file，此程序的输出为：

Some event happens, len = 48.
Object type: File
Object name: ./tmp_file
Event mask: 00000020
Event: File was opened
Object type: File
Object name: ./tmp_file
Event mask: 00000001
Event: File was accessed
Object type: File
Object name: ./tmp_file
Event mask: 00000010
Event: Unwrittable file closed

以上事件清楚地说明了 cat 指令执行了文件 open 和 close 操作，当然 open 和 close操作都属于 access 操作，任何对文件的操作都是 access 操作。

此外，运行 vi ./tmp_file，发现 vi实际在编辑文件时复制了一个副本，在未保存之前是对副本进行操作。 运行 vi ./tmp_file, 修改并保存退出时，发现 vi 实际在保存修改时删除了最初的文件并把那个副本文件名更改为最初的文件的名称。注意，事件"File was ignored"表示系统把该文件对应的 watch 从 inotify 实例的 watch 列表中删除，因为文件已经被删除。 读者可以自己分别执行命令：echo "abc" > ./tmp_file 、rm -f tmp_file、 ls tmp_dir、 cd tmp_dir;touch c.txt、 rm c.txt 、 umount /mnt/sda3（实际用户需要使用自己当时的 mount 点路径名），然后分析一下结果。Umount 触发两个事件，一个表示文件已经被删除或不在存在，另一个表示该文件的 watch被从 watch 列表中删除。

beagle 是 GNOME 的桌面搜索引擎项目，inotify 的引入就是完全受它的驱动而做的。对于桌面搜索引擎，它一般作为一个优先级很低的后台进程运行， 只有在系统没有其他任务可运行时才被调度执行，桌面搜索引擎的主要用途就是为系统的文件系统的文件建立索引数据库，以便用户在需要某文件但又想不起存放在哪里时能够根据某些关键字或特征快速地搜索到需要的文件，就象使用网络搜索引擎 google 一样便捷。文件系统有个特点就是只有某些文件会变化，因此桌面搜索引擎在第一次建立完索引数据库后，没必要重复遍历所有的文件建立新的索引，它只需要更新修改了的文件的索引，建立新增加的文件的索引，删除已经删除的文件的索引就足够了，这样桌面搜索引擎需要做的工作就大大地减少。Inotify 就是为这一意图专门设计的，beagle 为需要监视的目录或文件创建了inotify 实例，然后它就等待该 inotify 上发生文件系统事件，如果没有任何文件变化，beagle 将不需要任何开销，只有在有被监视的事件发生时，beagle 才被唤醒并根据实际事件来更新对应的文件的索引，然后继续睡眠等待下一个文件系统事件发生。在 SuSe 9.3 和即将发布的 10.0 中就包含了该桌面搜索引擎，它能够为文档、email、音乐、图象和应用等建立索引。使用过 windows 下的桌面搜索引擎的读者对 google 和 yahoo 以及 Microsoft 的桌面搜索引擎有深刻的体会，感兴趣读者可以安装 SuSe 使用一下。

原文地址：http://www.ibm.com/developerworks/cn/linux/l-inotify.html

http://www.ibm.com/developerworks/cn/linux/l-inotifynew/

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！