同一inotify fd注册多watch时，如何实现单事件逐个读取？

嘿，这个问题确实挺棘手的——inotify的read行为在不同内核版本有差异，而且默认会一次返回多个事件，但咱们可以用几个更优雅高效的方案来实现逐个读取的需求：

方案一：用户态缓存（最优解） #

这个方案的核心思路是尽量减少系统调用次数，一次读取所有可用事件到用户态缓冲区，然后手动拆分出单个事件逐个处理，剩余未处理的事件存在缓存里供后续使用。

原理： #

单个inotify事件的最大长度是固定的：sizeof(struct inotify_event) + NAME_MAX + 1（NAME_MAX通常是255，所以总大小是sizeof(inotify_event) + 256）。我们可以预先分配一个至少这么大的缓冲区，每次调用read时用它读取所有排队的事件，然后：

1. 从缓冲区中提取第一个事件，交给应用处理；
2. 将缓冲区中剩下的事件数据复制到缓存区（比如一个动态数组或环形缓冲区）；
3. 下次需要读取事件时，先检查缓存区是否有剩余事件，有则直接提取第一个，没有再调用read。

代码示例思路： #

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/inotify.h>
#include <string.h>

#define MAX_EVENT_SIZE (sizeof(struct inotify_event) + NAME_MAX + 1)
#define BUF_SIZE (MAX_EVENT_SIZE * 10) // 一次最多读10个事件，可调整

static char cache[BUF_SIZE];
static size_t cache_len = 0;

struct inotify_event *get_single_inotify_event(int fd) {
    ssize_t ret;
    struct inotify_event *event;

    // 先检查缓存中是否有剩余事件
    if (cache_len >= sizeof(struct inotify_event)) {
        event = (struct inotify_event *)cache;
        // 计算当前事件的总长度
        size_t event_len = sizeof(struct inotify_event) + event->len;
        if (cache_len >= event_len) {
            // 提取事件，然后更新缓存
            struct inotify_event *result = malloc(event_len);
            memcpy(result, event, event_len);
            // 移动缓存中剩余的数据到开头
            memmove(cache, cache + event_len, cache_len - event_len);
            cache_len -= event_len;
            return result;
        }
    }

    // 缓存为空或不完整，调用read读取新事件
    cache_len = read(fd, cache, BUF_SIZE);
    if (cache_len == -1) {
        perror("read");
        return NULL;
    } else if (cache_len == 0) {
        // 2.6.21之前内核的特殊情况，缓冲区不够时返回0
        // 尝试用最大单个事件大小读取
        cache_len = read(fd, cache, MAX_EVENT_SIZE);
        if (cache_len == -1) {
            perror("read (fallback)");
            return NULL;
        }
    }

    // 递归调用，提取第一个事件
    return get_single_inotify_event(fd);
}

这个方案的优势是系统调用次数最少，效率最高，同时完美兼容不同内核版本的read行为。

方案二：直接使用最大单个事件缓冲区 #

如果你不想维护用户态缓存，可以直接使用单个事件的最大可能大小作为缓冲区，这样每次read只会返回一个事件（因为内核不会拆分单个事件，只要缓冲区足够容纳一个事件，就会返回它，即使还有其他事件排队）。

代码示例： #

#include <stdio.h>
#include <unistd.h>
#include <sys/inotify.h>
#include <errno.h>

#define MAX_EVENT_SIZE (sizeof(struct inotify_event) + NAME_MAX + 1)

int read_single_inotify_event(int fd, struct inotify_event *event) {
    ssize_t ret;
    char buf[MAX_EVENT_SIZE];

    ret = read(fd, buf, MAX_EVENT_SIZE);
    if (ret == -1) {
        if (errno == EINVAL) {
            // 理论上不会走到这里，因为缓冲区已经足够大
            perror("read");
            return -1;
        } else {
            perror("read");
            return -1;
        }
    } else if (ret == 0) {
        // 兼容2.6.21之前的内核，再次尝试读取
        ret = read(fd, buf, MAX_EVENT_SIZE);
        if (ret == -1) {
            perror("read (fallback)");
            return -1;
        }
    }

    memcpy(event, buf, ret);
    return 0;
}

这个方案的优势是实现简单，但缺点是每次read只能读取一个事件，系统调用次数会比方案一多，不过对于大部分场景来说已经足够用。

为什么你的递增缓冲区方案不是最优？ #

你之前尝试的递增缓冲区方案，每次遇到EINVAL就增大缓冲区，会导致多次系统调用（比如一个带长文件名的事件可能需要2-3次调用），而系统调用本身是有开销的，所以相比上面两个方案，效率会低一些。

内容的提问来源于stack exchange，提问作者Jong