使用epoll监控inotify事件

如何解决使用epoll监控inotify事件

我想使用inotify来观察一些文件的变化，并使用epoll来监控是否有任何inotify事件发生。但是，我在接收 inotify 事件时遇到了一些麻烦。比如说，我怎么知道我是否得到了所有发生的事件。

如果 inotify fd 设置为 NON_BLOCK 模式，EAGAIN 将在 read() 时返回，表明没有其他内容可供阅读，这很好。但是如果 inotify fd 设置为 BLOCKING 模式，read() 会无限阻塞。

例如，如果您 通过要求读取一定数量的数据来调用 read(2) 并 read(2) 返回较少的字节数，您可以确定 已耗尽文件描述符的读取 I/O 空间。

参考：epoll(7)

根据epoll(7)，如果read() 返回的字节数较少，我可以保证彻底阅读。但是我应该如何处理返回相同字节数的 read() ？

这是我试过的代码。

func main() {
    fd,_ := unix.InotifyInit()
    epollfd,_ := unix.EpollCreate(1)
    unix.EpollCtl(epollfd,unix.EPOLL_CTL_ADD,fd,&unix.EpollEvent{
        Fd:     int32(fd),Events: unix.EPOLLIN,})
    unix.InotifyAddWatch(fd,os.Args[1],unix.IN_ALL_EVENTS)
    epollevents := make([]unix.EpollEvent,8)
    for {
        // epoll wait
        var nepoll int
        if nepoll,err = unix.EpollWait(epollfd,epollevents,-1); err == nil {
            // nothing happens
        } else if errors.Is(err,unix.EINTR) {
            continue // ignore interrupt
        } else {
            log.Fatal(err.Error())
        }
        // process inotify events
        for i := 0; i < nepoll; i += 1 {
            var nr int
            // buff for receiving
            // eventBuf for processing
            // two buff to prevent a large amount of data
            eventBuff := make([]byte,(unix.SizeofInotifyEvent+unix.PathMax)*2)
            buff := make([]byte,unix.SizeofInotifyEvent+unix.PathMax)
            offset,nr,lastUnread := 0,0
            for {
                // read loop in case of a large amount of data
                if nr,err = unix.Read(int(epollevents[i].Fd),buff); err == nil {
                    // nothing happens
                } else if errors.Is(err,unix.EAGAIN) {
                    println("exhaust")
                    break
                } else {
                    log.Fatal(err.Error())
                }
                copy(eventBuff[lastUnread:lastUnread+nr],buff[:nr])
                lastUnread += nr
                for offset < lastUnread &&
                    (nr < len(buff) || lastUnread-offset >= unix.PathMax+unix.SizeofInotifyEvent) {
                    event := (*unix.InotifyEvent)(unsafe.Pointer(&eventBuff[offset]))
                    switch event.Mask {
                    case unix.IN_ACCESS:
                        // ...
                    case unix.IN_OPEN:
                        // ...
                    case unix.IN_CLOSE_WRITE:
                        // ...
                    case unix.IN_CLOSE_NowRITE:
                        // ...
                    }
                    offset += unix.SizeofInotifyEvent + int(event.Len)
                }
                copy(eventBuff[offset:lastUnread],eventBuff[:lastUnread-offset])
                lastUnread -= offset
                offset = 0
            }
        }
        fmt.Println("Over") // NEVER got print out in BLOCKING mode
    }
}