Thread: Inotify problem

I wrote this little example program just to start using inotify. The program adds a watch on a file, looking for the event of closing the file after having opened it for writing. When the even fires, I remove the watch, write something different on the file which the event was fired for and then I add again the watch on the same event on that file. All this in a cycle. The problem is that when I do any kind of writes on the file, even simple ones like this "echo 0 > file_watched", the watching program receives an unending series of events. What am I doing wrong?

Code:

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

#define FILE_CONTENTS "\
irrelevant contents\n"

#define EVENT_SIZE  (sizeof(struct inotify_event))

int main(int argc, char **argv)
{
	if (argc < 2) {
		printf("not enough arguments.\n");
		exit(1);
	}
	char event[EVENT_SIZE];
	int wd;
	char *path_name = argv[1];
	int ifd = inotify_init();
	if (ifd == -1) {
		printf("inotify_init() problem.\n");
		exit(1);
	}

	while (true) {
		wd = inotify_add_watch(ifd, path_name, IN_CLOSE_WRITE);
		if (wd == -1) {
			printf("inotify_add_watch() problem.\n");
			exit(1);
		}
		if (read(ifd, event, EVENT_SIZE) != EVENT_SIZE) {
			printf("read() problem.\n");
			exit(1);
		}
		if(inotify_rm_watch(ifd, wd) == -1) {
			perror("inotify_rm_watch()");
			exit(1);
		}
		printf("%s modified. now working on it\n", path_name);
		fflush(stdout);
		FILE *file = fopen(path_name, "w");
		fprintf(file, "%s", FILE_CONTENTS);
		fflush(file);
		fclose(file);
		printf("%s restored\n", path_name);
		fflush(stdout);
	}
	return (EXIT_SUCCESS);
}

Originally Posted by matsp

Are you sure that your own program isn't affecting the watch by writing to the file?

--
Mats

I remove the watch before writing to the file.

I've just tried to comment the part of the code where I write new values to the file, after having removed the watch, but it doesn't change anything, I still receive all those events.

Edit : I wasn't answering to your last post. Now I'm looking into that.

Originally Posted by matsp

I have no idea - Maybe, for the way that you use it, you want use the IN_ONESHOT modifier?

--
Mats

Yes, that solves the problem. It's not entirely clear why do I need it, because it actually should do what I was doing by hand, that is it removes the watch. As a consequence now clearly I don't need to use inotify_rm_watch and if I use it, it returns an error. To understand that, I should probably go looking into kernel code, but it seems at least a strange behaviour.

P.S. Thanks a lot for the help!

Originally Posted by matsp

When looking at this problem I found quite a few hits on "inotify example" - perhaps such a search and a read of the links that comes up would help. Reading kernel code is all well and good, but often examples will show more useful hints than trying to find why you are doing something wrong from reading the kernel code (I'm not saying for sure that you are doing anything wrong, but I would expect that the API itself isn't completely b0rked).

--
Mats

Yeah, I looked at many examples on the net, but I didn't find one which resembled my case. Instead, searching for a solution, I found this interesting site, so I scored bigger than if I had found a good example.

This is the working version of the code :

Code:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/inotify.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define FILE_CONTENTS "\
irrelevant contents\n"

int main(int argc, char **argv)
{
	if (argc < 2) {
		printf("not enough arguments.\n");
		exit(1);
	}
	struct inotify_event event;
	int wd;
	char *path_name = argv[1];
	int ifd = inotify_init();
	if (ifd == -1) {
		printf("inotify_init() problem.\n");
		exit(1);
	}

	while (true) {
		wd = inotify_add_watch(ifd, path_name, IN_CLOSE_WRITE | IN_ONESHOT);
		if (wd == -1) {
			printf("inotify_add_watch() problem.\n");
			exit(1);
		}
		if (read(ifd, &event, sizeof(event)) != sizeof(event)) {
			printf("read() problem.\n");
			exit(1);
		}
		printf("&#37;s modified. now working on it\n", path_name);
		fflush(stdout);
		int fd = open(path_name, O_WRONLY);
		write(fd, FILE_CONTENTS, strlen(FILE_CONTENTS));
		close(fd);
		printf("%s restored\n", path_name);
		fflush(stdout);
	}
	return (EXIT_SUCCESS);
}

Many calls don't have proper error checks, but it's just an exercise.