inotify 是一次性解决方案吗

Question

I have a program whiuch utilizes inotify.

What it does is it start watching the directory for the file being created. When it happens the program reads the content then deletes the file.

Then the user initiates an action which will create the same file again. However, inotify does not see that the file has been created a second time and the file is not processed.

Code is as follows:

fileCreated = false;
m_wd1 = inotify_add_watch( m_fd, "/tmp", IN_CREATE );
if( m_wd1 == -1 )
{
}
else
{
    while( true )
    {
        poll_num = poll( &fds, nfds, -1 );
        if( poll_num == -1 )
        {
            if( errno == EINTR )
                continue;
            syslog( LOG_ERR, "Fail to run poll" );
            result = 1;
        }
        else if( poll_num > 0 && ( fds.revents & POLLIN ) )
        {
            syslog( LOG_DEBUG, "Polling is successful" );
            for( ;; )
            {
                len = read( m_fd, buf, sizeof( buf ) );
                if( len == -1 && errno != EAGAIN )
                {
                    syslog( LOG_ERR, "Failure to read the inotify event" );
                    result = 1;
                    break;
                }
                for( ptr = buf; ptr < buf + len; ptr += sizeof( struct inotify_event ) + event->len )
                {
                    event = (const struct inotify_event *) ptr;
                    if( event->mask & IN_CREATE )
                    {
                        std::string name( event->name );
                        if( name == "scan_results" )
                        {
                            fileCreated = true;
                            break;
                        }
                    }
                }
                if( fileCreated || result )
                    break;
            }
        }
        if( fileCreated )
        {
            std::ifstream log( "scan_results" );
            if( log.rdstate()  & std::ifstream::failbit ) != 0 )
            {
            }
            else
            {
            }
            log.close();
            if( remove( "scan_results" ) != 0 )
            {
                syslog( LOG_ERR, "Failed to remove the file" );
            }
            else
            {
                syslog( LOG_DEBUG, "File deleted successfully" );
            }
        }
        fileCreated = false;

The while() loop runs only once. When the action happens second time I see a message "Polling is successful".

Should I add IN_MODIFY as a mask for inotify?

If it matters - this code is running inside std::thread.

Answer 1

Turns out that polling plus reading inotify is not thread-safe.

So to overcome this I had to add inotify_init() to every thread. So now every thread have its own inotify file descriptor. And now it looks like program works.

Thank you everybody for reading and trying to help.

Answer 2

Well, I have an answer, it's not a short one and it's directly from the man 7 inotify page in linked above in the comments. Your two pending questions from the narrowing of your questions in the comments are:

1. if I call remove() on the file - does this mean that the watch in the directory for file creation will be removed?; and
2. if it is true can you give me some pseudocode for the workaround?

The answer to (1) is Yes , but the watch may be recycled causing the next file/dir to which it is assigned to potentially read the pending requests for the file/dir that was closed/deleted:

 When a watch descriptor is removed by calling inotify_rm_watch(2) (or because a watch file is deleted or the filesystem that contains it is unmounted), ...

(caveat to be aware of)

 ... any pending unread events for that watch descriptor remain available to read. As watch descriptors are subsequently allocated with inotify_add_watch(2), the kernel cycles through the range of possible watch descriptors (0 to INT_MAX) incrementally. When allocating a free watch descriptor, no check is made to see whether that watch descriptor number has any pending unread events in the inotify queue. Thus, it can happen that a watch descriptor is reallocated even when pending unread events exist for a previous incarnation of that watch descriptor number, with the result that the application might then read those events and interpret them as belonging to the file associated with the newly recycled watch descriptor. In practice, the likelihood of hitting this bug may be extremely low, since it requires that an application cycle through INT_MAX watch descriptors, release a watch descriptor while leaving unread events for that watch descriptor in the queue, and then recycle that watch descriptor. For this reason, and because there have been no reports of the bug occurring in real-world applications, as of Linux 3.15, no kernel changes have yet been made to eliminate this possible bug.

(I doubt you will ever have that many watches open)

In answer to the second question, the pseudo code would simply be to check the mask for:

 IN_DELETE_SELF Watched file/directory was itself deleted. (This event also occurs if an object is moved to another filesystem, since mv(1) in effect copies the file to the other filesystem and then deletes it from the original filesys‐ tem.) In addition, an IN_IGNORED event will subsequently be generated for the watch descriptor.

So you can check with either the mask IN_DELETE_SELF or IN_IGNORED if the file/directory being watched is deleted.

Answer 3

I can't see exactly what is wrong with your code since you haven't provided an mcve , but watching a directory should give you all of the subscribed events for the directory until you stop reading them.

Here's an example of using inotify to watch a directory...

#include <iostream>

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

int main(int argc, char *argv[]) {

  const int ifd = inotify_init();
  const int iwd = inotify_add_watch(ifd, "/tmp/inotify", IN_CREATE);

  char buf[4096];

  while (read(ifd, buf, sizeof(buf)) > 0) {

    const struct inotify_event* ie = (const struct inotify_event*) buf;

    std::cout << ie->name << std::endl;
  }

  return 0;
}

---

(jason@pi) [4868] ~/tmp touch /tmp/inotify/foo
(jason@pi) [4880] ~/tmp touch /tmp/inotify/bar
(jason@pi) [4881] ~/tmp rm /tmp/inotify/foo
(jason@pi) [4882] ~/tmp touch /tmp/inotify/foo

---

(jason@pi) [4879] ~/tmp ./so
foo
bar
foo