--- /dev/null
+Index: server/gam_debugging.h
+===================================================================
+RCS file: /cvs/gnome/gamin/server/gam_debugging.h,v
+retrieving revision 1.2
+diff -u -r1.2 gam_debugging.h
+--- server/gam_debugging.h 23 Mar 2005 09:50:11 -0000 1.2
++++ server/gam_debugging.h 14 Apr 2005 16:44:34 -0000
+@@ -12,7 +12,12 @@
+ GAMDnotifyDelete=2,
+ GAMDnotifyChange=3,
+ GAMDnotifyFlowOn=4,
+- GAMDnotifyFlowOff=5
++ GAMDnotifyFlowOff=5,
++ GAMinotifyCreate=6,
++ GAMinotifyDelete=7,
++ GAMinotifyChange=8,
++ GAMinotifyFlowOn=9,
++ GAMinotifyFlowOff=10
+ } GAMDebugEvent;
+
+ void gam_debug_add(GamConnDataPtr conn, const char *value, int options);
+Index: server/gam_inotify.c
+===================================================================
+RCS file: /cvs/gnome/gamin/server/gam_inotify.c,v
+retrieving revision 1.17
+diff -u -r1.17 gam_inotify.c
+--- server/gam_inotify.c 7 Apr 2005 09:11:17 -0000 1.17
++++ server/gam_inotify.c 14 Apr 2005 16:44:34 -0000
+@@ -1,5 +1,8 @@
+-/*
+- * Copyright (C) 2004 John McCutchan, James Willcox, Corey Bowers
++/* gamin inotify backend
++ * Copyright (C) 2005 John McCutchan
++ *
++ * Based off of code,
++ * Copyright (C) 2003 James Willcox, Corey Bowers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+@@ -14,261 +17,404 @@
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+- * TODO:
+- * - *properly* Handle removal of subscriptions when we get IGNORE event
+- * - this backend does not produce the same events as the dnotify/poll backend.
+- * for example, the dp backend allows for watching non-exist files/folders,
+- * and be notified when they are created. there are more places where
+- * the events are not consistent.
+ */
+
+
+ #include <config.h>
+ #define _GNU_SOURCE
+ #include <fcntl.h>
+-#include <sys/ioctl.h>
+ #include <signal.h>
+ #include <unistd.h>
++#include <sys/ioctl.h>
+ #include <stdio.h>
+-#include <string.h>
+ #include <glib.h>
++#include "gam_error.h"
++#include "gam_poll.h"
+ #ifdef HAVE_LINUX_INOTIFY_H
+ #include <linux/inotify.h>
+ #else
+ #include "local_inotify.h"
+ #endif
+-#include "gam_error.h"
+ #include "gam_inotify.h"
+ #include "gam_tree.h"
+ #include "gam_event.h"
+ #include "gam_server.h"
+ #include "gam_event.h"
++#ifdef GAMIN_DEBUG_API
++#include "gam_debugging.h"
++#endif
++
++#define MIN_POLL_TIME 1.0
+
+ typedef struct {
+ char *path;
+- char *path_file;
+ int wd;
+ int refcount;
+ GList *subs;
+-} INotifyData;
++ int busy;
++
++ gboolean dirty;
++ GTimer *poll_timer;
++} inotify_data_t;
+
+ static GHashTable *path_hash = NULL;
+ static GHashTable *wd_hash = NULL;
+-
+-static GList *new_subs = NULL;
+-
+-G_LOCK_DEFINE_STATIC(new_subs);
+-static GList *removed_subs = NULL;
+-
+-G_LOCK_DEFINE_STATIC(removed_subs);
++static GList *dirty_list = NULL;
+
+ G_LOCK_DEFINE_STATIC(inotify);
++
+ static GIOChannel *inotify_read_ioc = NULL;
+
+ static gboolean have_consume_idler = FALSE;
+
+-int fd = -1; // the device fd
++static int inotify_device_fd = -1;
++
++static guint should_poll_mask = IN_MODIFY|IN_ATTRIB|IN_CLOSE_WRITE|IN_MOVED_FROM|IN_MOVED_TO|IN_DELETE_SUBDIR|IN_DELETE_FILE|IN_CREATE_SUBDIR|IN_CREATE_FILE|IN_DELETE_SELF|IN_UNMOUNT;
++
++static void print_mask(int mask)
++{
++ if (mask & IN_ACCESS)
++ {
++ GAM_DEBUG(DEBUG_INFO, "ACCESS\n");
++ }
++ if (mask & IN_MODIFY)
++ {
++ GAM_DEBUG(DEBUG_INFO, "MODIFY\n");
++ }
++ if (mask & IN_ATTRIB)
++ {
++ GAM_DEBUG(DEBUG_INFO, "ATTRIB\n");
++ }
++ if (mask & IN_CLOSE_WRITE)
++ {
++ GAM_DEBUG(DEBUG_INFO, "CLOSE_WRITE\n");
++ }
++ if (mask & IN_CLOSE_NOWRITE)
++ {
++ GAM_DEBUG(DEBUG_INFO, "CLOSE_WRITE\n");
++ }
++ if (mask & IN_OPEN)
++ {
++ GAM_DEBUG(DEBUG_INFO, "OPEN\n");
++ }
++ if (mask & IN_MOVED_FROM)
++ {
++ GAM_DEBUG(DEBUG_INFO, "MOVE_FROM\n");
++ }
++ if (mask & IN_MOVED_TO)
++ {
++ GAM_DEBUG(DEBUG_INFO, "MOVE_TO\n");
++ }
++ if (mask & IN_DELETE_SUBDIR)
++ {
++ GAM_DEBUG(DEBUG_INFO, "DELETE_SUBDIR\n");
++ }
++ if (mask & IN_DELETE_FILE)
++ {
++ GAM_DEBUG(DEBUG_INFO, "DELETE_FILE\n");
++ }
++ if (mask & IN_CREATE_SUBDIR)
++ {
++ GAM_DEBUG(DEBUG_INFO, "CREATE_SUBDIR\n");
++ }
++ if (mask & IN_CREATE_FILE)
++ {
++ GAM_DEBUG(DEBUG_INFO, "CREATE_FILE\n");
++ }
++ if (mask & IN_DELETE_SELF)
++ {
++ GAM_DEBUG(DEBUG_INFO, "DELETE_SELF\n");
++ }
++ if (mask & IN_UNMOUNT)
++ {
++ GAM_DEBUG(DEBUG_INFO, "UNMOUNT\n");
++ }
++ if (mask & IN_Q_OVERFLOW)
++ {
++ GAM_DEBUG(DEBUG_INFO, "Q_OVERFLOW\n");
++ }
++ if (mask & IN_IGNORED)
++ {
++ GAM_DEBUG(DEBUG_INFO, "IGNORED\n");
++ }
++}
+
+-static INotifyData *
+-gam_inotify_data_new(const char *path, char *path_file, int wd)
++static inotify_data_t *
++gam_inotify_data_new(const char *path, int wd)
+ {
+- INotifyData *data;
++ inotify_data_t *data;
+
+- data = g_new0(INotifyData, 1);
++ data = g_new0(inotify_data_t, 1);
+ data->path = g_strdup(path);
+- data->path_file = path_file;
+ data->wd = wd;
++ data->busy = 0;
+ data->refcount = 1;
+- data->subs = NULL;
++ data->dirty = FALSE;
++ data->poll_timer = g_timer_new ();
+
+ return data;
+ }
+
+ static void
+-gam_inotify_data_free(INotifyData * data)
++gam_inotify_data_free(inotify_data_t * data)
+ {
++ if (data->refcount != 0)
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_data_free called with reffed data.\n");
+ g_free(data->path);
+- g_free(data->path_file);
++ g_timer_destroy (data->poll_timer);
+ g_free(data);
+ }
+
+ static void
+-gam_inotify_add_rm_handler(const char *path, GamSubscription * sub,
+- pollHandlerMode mode)
++gam_inotify_directory_handler_internal(const char *path, pollHandlerMode mode)
+ {
+- INotifyData *data;
++ inotify_data_t *data;
++ int path_fd;
++ int path_wd;
+ struct inotify_watch_request iwr;
+- struct stat st;
+- char *path_file;
+- char *path_t;
+- int wd, r;
+
++
++ switch (mode) {
++ case GAMIN_ACTIVATE:
++ GAM_DEBUG(DEBUG_INFO, "Adding %s to inotify\n", path);
++ break;
++ case GAMIN_DESACTIVATE:
++ GAM_DEBUG(DEBUG_INFO, "Removing %s from inotify\n", path);
++ break;
++ case GAMIN_FLOWCONTROLSTART:
++ GAM_DEBUG(DEBUG_INFO, "Start flow control for %s\n", path);
++ break;
++ case GAMIN_FLOWCONTROLSTOP:
++ GAM_DEBUG(DEBUG_INFO, "Stop flow control for %s\n", path);
++ break;
++ default:
++ gam_error(DEBUG_INFO, "Unknown inotify operation %d for %s\n",
++ mode, path);
++ return;
++ }
+ G_LOCK(inotify);
+
+ if (mode == GAMIN_ACTIVATE) {
+- GList *subs;
+-
+- subs = NULL;
+- subs = g_list_append(subs, sub);
+-
+ if ((data = g_hash_table_lookup(path_hash, path)) != NULL) {
+ data->refcount++;
+- data->subs = g_list_prepend(data->subs, sub);
++ GAM_DEBUG(DEBUG_INFO, " found incremented refcount: %d\n",
++ data->refcount);
+ G_UNLOCK(inotify);
++#ifdef GAMIN_DEBUG_API
++ gam_debug_report(GAMinotifyChange, path, data->refcount);
++#endif
+ GAM_DEBUG(DEBUG_INFO, "inotify updated refcount\n");
+- /*
+- * hum might need some work to check if the path is a dir,
+- * setting 0 and forcing to bypass checks right now.
+- */
+- gam_server_emit_event(path, 0, GAMIN_EVENT_EXISTS, subs, 1);
+- gam_server_emit_event(path, 0, GAMIN_EVENT_ENDEXISTS, subs, 1);
+ return;
+ }
+
+- {
+- if (stat(path, &st)) {
+- G_UNLOCK(inotify);
+- return;
+- }
+-
+- path_t = g_strdup(path);
+- path_file = NULL;
+-
+- if (S_ISREG(st.st_mode)) {
+- char *ch;
+-
+- ch = strrchr(path_t, '/');
+- if (!ch) {
+- g_free(path_t);
+- G_UNLOCK(inotify);
+- return;
+- }
+- path_file = g_strdup(++ch);
+- *ch = '\0';
+- }
+-
+-
+- int file_fd = open(path_t, O_RDONLY);
++ path_fd = open(path, O_RDONLY);
+
+- g_free(path_t);
+- if (file_fd < 0) {
+- G_UNLOCK(inotify);
+- return;
+- }
+-
+- iwr.fd = file_fd;
+- iwr.mask = 0xffffffff; // all events
+- wd = ioctl(fd, INOTIFY_WATCH, &iwr);
+- close(file_fd);
+- }
+-
+- if (wd < 0) {
++ if (path_fd < 0) {
+ G_UNLOCK(inotify);
+ return;
+ }
+
+- data = gam_inotify_data_new(path, path_file, wd);
+- path_file = NULL;
+- data->subs = g_list_prepend(data->subs, sub);
++ iwr.fd = path_fd;
++ iwr.mask = should_poll_mask;
++ path_wd = ioctl (inotify_device_fd, INOTIFY_WATCH, &iwr);
++ close (path_fd);
++
++ data = gam_inotify_data_new(path, path_wd);
+ g_hash_table_insert(wd_hash, GINT_TO_POINTER(data->wd), data);
+ g_hash_table_insert(path_hash, data->path, data);
+
+- GAM_DEBUG(DEBUG_INFO, "added inotify watch for %s\n", path);
+-
+- gam_server_emit_event(path, 0, GAMIN_EVENT_EXISTS, subs, 1);
+- gam_server_emit_event(path, 0, GAMIN_EVENT_ENDEXISTS, subs, 1);
++ GAM_DEBUG(DEBUG_INFO, "activated inotify for %s\n", path);
++#ifdef GAMIN_DEBUG_API
++ gam_debug_report(GAMinotifyCreate, path, 0);
++#endif
+ } else if (mode == GAMIN_DESACTIVATE) {
+- data = g_hash_table_lookup(path_hash, path);
++ char *dir = (char *) path;
+
+- if (!data) {
+- G_UNLOCK(inotify);
+- return;
+- }
++ data = g_hash_table_lookup(path_hash, path);
++
++ if (!data) {
++ dir = g_path_get_dirname(path);
++ data = g_hash_table_lookup(path_hash, dir);
++
++ if (!data) {
++ GAM_DEBUG(DEBUG_INFO, " not found !!!\n");
++
++ if (dir != NULL)
++ g_free(dir);
++
++ G_UNLOCK(inotify);
++ return;
++ }
++ GAM_DEBUG(DEBUG_INFO, " not found using parent\n");
++ }
+
+- if (g_list_find(data->subs, sub)) {
+- data->subs = g_list_remove_all(data->subs, sub);
+- }
+ data->refcount--;
+ GAM_DEBUG(DEBUG_INFO, "inotify decremeneted refcount for %s\n",
+ path);
+
+ if (data->refcount == 0) {
+- r = ioctl(fd, INOTIFY_IGNORE, &data->wd);
+- if (r < 0) {
+- GAM_DEBUG(DEBUG_INFO,
+- "INOTIFY_IGNORE failed for %s (wd = %d)\n",
+- data->path, data->wd);
++ int wd = data->wd;
++
++ GAM_DEBUG(DEBUG_INFO, "removed inotify watch for %s\n", data->path);
++
++ g_hash_table_remove(path_hash, data->path);
++ g_hash_table_remove(wd_hash, GINT_TO_POINTER(data->wd));
++ gam_inotify_data_free(data);
++
++ if (ioctl (inotify_device_fd, INOTIFY_IGNORE, &wd) < 0) {
++ GAM_DEBUG (DEBUG_INFO, "INOTIFY_IGNORE failed for %s (wd = %d)\n", data->path, data->wd);
++ }
++#ifdef GAMIN_DEBUG_API
++ gam_debug_report(GAMinotifyDelete, dir, 0);
++#endif
++ } else {
++ GAM_DEBUG(DEBUG_INFO, " found decremented refcount: %d\n",
++ data->refcount);
++#ifdef GAMIN_DEBUG_API
++ gam_debug_report(GAMinotifyChange, dir, data->refcount);
++#endif
++ }
++ if ((dir != path) && (dir != NULL))
++ g_free(dir);
++ } else if ((mode == GAMIN_FLOWCONTROLSTART) ||
++ (mode == GAMIN_FLOWCONTROLSTOP)) {
++ char *dir = (char *) path;
++
++ data = g_hash_table_lookup(path_hash, path);
++ if (!data) {
++ dir = g_path_get_dirname(path);
++ data = g_hash_table_lookup(path_hash, dir);
++
++ if (!data) {
++ GAM_DEBUG(DEBUG_INFO, " not found !!!\n");
++
++ if (dir != NULL)
++ g_free(dir);
++ G_UNLOCK(inotify);
++ return;
+ }
+- GAM_DEBUG(DEBUG_INFO, "removed inotify watch for %s\n",
+- data->path);
+- g_hash_table_remove(path_hash, data->path);
+- g_hash_table_remove(wd_hash, GINT_TO_POINTER(data->wd));
+- gam_inotify_data_free(data);
++ GAM_DEBUG(DEBUG_INFO, " not found using parent\n");
+ }
++ if (data != NULL) {
++ if (mode == GAMIN_FLOWCONTROLSTART) {
++ if (data->wd >= 0) {
++ if (ioctl (inotify_device_fd, INOTIFY_IGNORE, &data->wd) < 0) {
++ GAM_DEBUG (DEBUG_INFO, "INOTIFY_IGNORE failed for %s (wd = %d)\n", data->path, data->wd);
++ }
++ g_hash_table_remove(wd_hash, GINT_TO_POINTER(data->wd));
++ data->wd = -1;
++ GAM_DEBUG(DEBUG_INFO, "deactivated inotify for %s\n",
++ data->path);
++#ifdef GAMIN_DEBUG_API
++ gam_debug_report(GAMinotifyFlowOn, dir, 0);
++#endif
++ }
++ data->busy++;
++ } else {
++ if (data->busy > 0) {
++ data->busy--;
++ if (data->busy == 0) {
++ path_fd = open(data->path, O_RDONLY);
++ if (path_fd < 0) {
++ G_UNLOCK(inotify);
++ GAM_DEBUG(DEBUG_INFO,
++ "Failed to reactivate inotify for %s\n",
++ data->path);
++
++ if ((dir != path) && (dir != NULL))
++ g_free(dir);
++ return;
++ }
++
++ iwr.fd = path_fd;
++ iwr.mask = 0xffffffff;
++ path_wd = ioctl (inotify_device_fd, INOTIFY_WATCH, &iwr);
++ close (path_fd);
++
++ data->wd = path_wd;
++
++ g_hash_table_insert(wd_hash, GINT_TO_POINTER(data->wd),
++ data);
++ GAM_DEBUG(DEBUG_INFO, "Reactivated inotify for %s\n",
++ data->path);
++#ifdef GAMIN_DEBUG_API
++ gam_debug_report(GAMinotifyFlowOff, path, 0);
++#endif
++ }
++ }
++ }
++ }
++ if ((dir != path) && (dir != NULL))
++ g_free(dir);
+ } else {
+- GAM_DEBUG(DEBUG_INFO, "Inotify: unimplemented mode request %d\n",
+- mode);
++ GAM_DEBUG(DEBUG_INFO, "Unimplemented operation\n");
+ }
++
+ G_UNLOCK(inotify);
+ }
+
+-static GaminEventType
+-inotify_event_to_gamin_event(int mask)
++static void
++gam_inotify_directory_handler(const char *path, pollHandlerMode mode)
+ {
+- switch (mask) {
+- case IN_ATTRIB:
+- case IN_MODIFY:
+- return GAMIN_EVENT_CHANGED;
+- break;
+- case IN_MOVED_TO:
+- case IN_CREATE_SUBDIR:
+- case IN_CREATE_FILE:
+- return GAMIN_EVENT_CREATED;
+- break;
+- case IN_MOVED_FROM:
+- case IN_DELETE_SUBDIR:
+- case IN_DELETE_FILE:
+- return GAMIN_EVENT_DELETED;
+- break;
+- default:
+- return GAMIN_EVENT_UNKNOWN;
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_directory_handler %s : %d\n",
++ path, mode);
++
++ if ((mode == GAMIN_DESACTIVATE) ||
++ (g_file_test(path, G_FILE_TEST_IS_DIR))) {
++ gam_inotify_directory_handler_internal(path, mode);
++ } else {
++ char *dir;
++
++ dir = g_path_get_dirname(path);
++ GAM_DEBUG(DEBUG_INFO, " not a dir using parent %s\n", dir);
++ gam_inotify_directory_handler_internal(dir, mode);
++ g_free(dir);
+ }
+ }
+
+ static void
+-gam_inotify_emit_event(INotifyData * data, struct inotify_event *event)
++gam_inotify_file_handler(const char *path, pollHandlerMode mode)
+ {
+- GaminEventType gevent;
+- char *event_path;
+-
+- if (!data || !event)
+- return;
+- gevent = inotify_event_to_gamin_event(event->mask);
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_file_handler %s : %d\n", path, mode);
++
++ if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
++ gam_inotify_directory_handler_internal(path, mode);
++ } else {
++ char *dir;
+
+- // gamins event vocabulary is very small compared to inotify
+- // so we often will receieve events that have no equivelant
+- // in gamin
+- if (gevent == GAMIN_EVENT_UNKNOWN) {
+- return;
++ dir = g_path_get_dirname(path);
++ GAM_DEBUG(DEBUG_INFO, " not a dir using parent %s\n", dir);
++ gam_inotify_directory_handler_internal(dir, mode);
++ g_free(dir);
+ }
+- if (event->name[0] != '\0' && !data->path_file) {
+- int pathlen = strlen(data->path);
++}
+
+- if (data->path[pathlen - 1] == '/') {
+- event_path = g_strconcat(data->path, event->name, NULL);
+- } else {
+- event_path = g_strconcat(data->path, "/", event->name, NULL);
+- }
+- } else {
+- event_path = g_strdup(data->path);
+- }
++/* Must be called with inotify lock locked */
++static void
++gam_inotify_dirty_list_cleaner ()
++{
++ GList *l;
++
++ /* Here we walk the old dirty list and create a new one.
++ * if we don't poll a node on the old list, we add it to the new one */
++
++ l = dirty_list;
++ dirty_list = NULL;
+
+- GAM_DEBUG(DEBUG_INFO, "inotify emitting event %s for %s\n",
+- gam_event_to_string(gevent), event_path);
++ for (l = l; l; l = l->next) {
++ inotify_data_t *data = l->data;
+
+- gam_server_emit_event(event_path, 0, gevent, data->subs, 1);
++ g_assert (data->dirty);
++
++ if (g_timer_elapsed (data->poll_timer, NULL) >= MIN_POLL_TIME) {
++ data->dirty = FALSE;
++ gam_poll_scan_directory (data->path);
++ } else {
++ dirty_list = g_list_append (dirty_list, data);
++ }
++ }
+
+- g_free(event_path);
++ g_list_free (l);
+ }
+
+ static gboolean
+@@ -276,71 +422,76 @@
+ {
+ char *buffer;
+ int buffer_size;
++ int events;
+ gsize buffer_i, read_size;
+
+ G_LOCK(inotify);
+
+- if (ioctl(fd, FIONREAD, &buffer_size) < 0) {
+- G_UNLOCK(inotify);
+- GAM_DEBUG(DEBUG_INFO, "inotify FIONREAD < 0. kaboom!\n");
+- return FALSE;
++#if 0
++ gam_inotify_dirty_list_cleaner ();
++#endif
++
++ if (ioctl(inotify_device_fd, FIONREAD, &buffer_size) < 0) {
++ G_UNLOCK(inotify);
++ GAM_DEBUG(DEBUG_INFO, "inotify FIONREAD < 0. kaboom!\n");
++ return FALSE;
+ }
+
+ buffer = g_malloc(buffer_size);
+
+- if (g_io_channel_read_chars
+- (inotify_read_ioc, (char *) buffer, buffer_size, &read_size,
+- NULL) != G_IO_STATUS_NORMAL) {
+- G_UNLOCK(inotify);
+- GAM_DEBUG(DEBUG_INFO,
+- "inotify failed to read events from inotify fd.\n");
+- g_free(buffer);
+- return FALSE;
++ if (g_io_channel_read_chars(inotify_read_ioc, (char *)buffer, buffer_size, &read_size, NULL) != G_IO_STATUS_NORMAL) {
++ G_UNLOCK(inotify);
++ GAM_DEBUG(DEBUG_INFO, "inotify failed to read events from inotify fd.\n");
++ g_free (buffer);
++ return FALSE;
+ }
+
+ buffer_i = 0;
++ events = 0;
+ while (buffer_i < read_size) {
+- struct inotify_event *event;
+- gsize event_size;
+- INotifyData *data;
+-
+- event = (struct inotify_event *) &buffer[buffer_i];
+- event_size = sizeof(struct inotify_event) + event->len;
+-
+- data = g_hash_table_lookup(wd_hash, GINT_TO_POINTER(event->wd));
+- if (!data) {
+- GAM_DEBUG(DEBUG_INFO, "inotify can't find wd %d\n", event->wd);
+- GAM_DEBUG(DEBUG_INFO,
+- "weird things have happened to inotify.\n");
+- } else {
+- /* Do the shit with the event */
+- if (event->mask == IN_IGNORED) {
+- GList *l;
+-
+- l = data->subs;
+- data->subs = NULL;
+- for (l = l; l; l = l->next) {
+- GamSubscription *sub = l->data;
+-
+- gam_inotify_remove_subscription(sub);
+- }
+- } else {
+- if (data->path_file) {
+- if (event->name[0] != '\0') {
+- int pathlen = strlen(data->path_file);
+-
+- if (strcmp(data->path_file, event->name)) {
+- buffer_i += event_size;
+- continue;
+- }
+- }
+- }
+- gam_inotify_emit_event(data, event);
+- }
+- }
++ struct inotify_event *event;
++ gsize event_size;
++ inotify_data_t *data;
++
++ event = (struct inotify_event *)&buffer[buffer_i];
++ event_size = sizeof(struct inotify_event) + event->len;
++
++ data = g_hash_table_lookup (wd_hash, GINT_TO_POINTER(event->wd));
++ if (!data) {
++ GAM_DEBUG(DEBUG_INFO, "inotify can't find wd %d\n", event->wd);
++ } else {
++ if (event->mask == IN_IGNORED || event->mask == IN_UNMOUNT) {
++ GList *l;
++
++ l = data->subs;
++ data->subs = NULL;
++ for (l = l; l; l = l->next) {
++ GamSubscription *sub = l->data;
++ gam_inotify_remove_subscription (sub);
++ }
++ } else if (event->mask != IN_Q_OVERFLOW) {
++ if (event->mask & should_poll_mask) {
++ GAM_DEBUG(DEBUG_INFO, "inotify requesting poll for %s\n", data->path);
++ GAM_DEBUG(DEBUG_INFO, "poll was requested for event = ");
++ print_mask (event->mask);
++ gam_poll_scan_directory (data->path);
++#if 0
++ /* if node isn't dirty */
++ if (!data->dirty) {
++ /* Put this node on the dirty list */
++ data->dirty = TRUE;
++ g_timer_start(data->poll_timer);
++ dirty_list = g_list_append (dirty_list, data);
++ }
++#endif
++ }
++ }
++ }
+
+ buffer_i += event_size;
++ events++;
+ }
++ GAM_DEBUG(DEBUG_INFO, "inotify recieved %d events\n", events);
+
+ g_free(buffer);
+ G_UNLOCK(inotify);
+@@ -348,48 +499,12 @@
+ return TRUE;
+ }
+
++
+ static gboolean
+ gam_inotify_consume_subscriptions_real(gpointer data)
+ {
+- GList *subs, *l;
+-
+- G_LOCK(new_subs);
+- if (new_subs) {
+- subs = new_subs;
+- new_subs = NULL;
+- G_UNLOCK(new_subs);
+-
+- for (l = subs; l; l = l->next) {
+- GamSubscription *sub = l->data;
+-
+- GAM_DEBUG(DEBUG_INFO, "called gam_inotify_add_handler()\n");
+- gam_inotify_add_rm_handler(gam_subscription_get_path(sub), sub,
+- TRUE);
+- }
+-
+- } else {
+- G_UNLOCK(new_subs);
+- }
+-
+- G_LOCK(removed_subs);
+- if (removed_subs) {
+- subs = removed_subs;
+- removed_subs = NULL;
+- G_UNLOCK(removed_subs);
+-
+- for (l = subs; l; l = l->next) {
+- GamSubscription *sub = l->data;
+-
+- GAM_DEBUG(DEBUG_INFO, "called gam_inotify_rm_handler()\n");
+- gam_inotify_add_rm_handler(gam_subscription_get_path(sub), sub,
+- FALSE);
+- }
+- } else {
+- G_UNLOCK(removed_subs);
+- }
+-
+- GAM_DEBUG(DEBUG_INFO, "gam_inotify_consume_subscriptions()\n");
+-
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_consume_subscriptions_real()\n");
++ gam_poll_consume_subscriptions();
+ have_consume_idler = FALSE;
+ return FALSE;
+ }
+@@ -402,30 +517,31 @@
+ if (have_consume_idler)
+ return;
+
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_consume_subscriptions()\n");
+ have_consume_idler = TRUE;
+-
+ source = g_idle_source_new();
+ g_source_set_callback(source, gam_inotify_consume_subscriptions_real,
+ NULL, NULL);
+-
+ g_source_attach(source, NULL);
+ }
+
+ /**
+- * @defgroup inotify inotify backend
++ * @defgroup inotify inotify Backend
+ * @ingroup Backends
+ * @brief inotify backend API
+ *
+ * Since version 2.6.X, Linux kernels have included the Linux Inode
+ * Notification system (inotify). This backend uses inotify to know when
+- * files are changed/created/deleted.
++ * files are changed/created/deleted. Since inotify can't watch files/dirs that
++ * don't exist we still have to cache stat() information. For this,
++ * we can just use the code in the polling backend.
+ *
+ * @{
+ */
+
+
+ /**
+- * Initializes the inotify system. This must be called before
++ * Initializes the inotify backend. This must be called before
+ * any other functions in this module.
+ *
+ * @returns TRUE if initialization succeeded, FALSE otherwise
+@@ -435,14 +551,16 @@
+ {
+ GSource *source;
+
+- fd = open("/dev/inotify", O_RDONLY);
++ inotify_device_fd = open("/dev/inotify", O_RDONLY);
+
+- if (fd < 0) {
+- GAM_DEBUG(DEBUG_INFO, "Could not open /dev/inotify\n");
+- return FALSE;
++ if (inotify_device_fd < 0) {
++ GAM_DEBUG(DEBUG_INFO, "Could not open /dev/inotify\n");
++ return FALSE;
+ }
+
+- inotify_read_ioc = g_io_channel_unix_new(fd);
++ g_return_val_if_fail(gam_poll_init_full(FALSE), FALSE);
++
++ inotify_read_ioc = g_io_channel_unix_new(inotify_device_fd);
+
+ /* For binary data */
+ g_io_channel_set_encoding(inotify_read_ioc, NULL, NULL);
+@@ -450,13 +568,15 @@
+ g_io_channel_set_flags(inotify_read_ioc, G_IO_FLAG_NONBLOCK, NULL);
+
+ source = g_io_create_watch(inotify_read_ioc,
+- G_IO_IN | G_IO_HUP | G_IO_ERR);
++ G_IO_IN | G_IO_HUP | G_IO_ERR);
+ g_source_set_callback(source, gam_inotify_read_handler, NULL, NULL);
+
+ g_source_attach(source, NULL);
+
+ path_hash = g_hash_table_new(g_str_hash, g_str_equal);
+ wd_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
++ gam_poll_set_directory_handler(gam_inotify_directory_handler);
++ gam_poll_set_file_handler(gam_inotify_file_handler);
+
+ GAM_DEBUG(DEBUG_INFO, "inotify initialized\n");
+
+@@ -476,15 +596,14 @@
+ gboolean
+ gam_inotify_add_subscription(GamSubscription * sub)
+ {
+- gam_listener_add_subscription(gam_subscription_get_listener(sub), sub);
+-
+- G_LOCK(new_subs);
+- new_subs = g_list_prepend(new_subs, sub);
+- G_UNLOCK(new_subs);
+-
+- GAM_DEBUG(DEBUG_INFO, "inotify_add_sub\n");
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_add_subscription\n");
++ if (!gam_poll_add_subscription(sub)) {
++ return FALSE;
++ }
+
+ gam_inotify_consume_subscriptions();
++
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_add_subscription: done\n");
+ return TRUE;
+ }
+
+@@ -497,26 +616,15 @@
+ gboolean
+ gam_inotify_remove_subscription(GamSubscription * sub)
+ {
+- G_LOCK(new_subs);
+- if (g_list_find(new_subs, sub)) {
+- GAM_DEBUG(DEBUG_INFO, "removed sub found on new_subs\n");
+- new_subs = g_list_remove_all(new_subs, sub);
+- G_UNLOCK(new_subs);
+- return TRUE;
+- }
+- G_UNLOCK(new_subs);
+-
+- gam_subscription_cancel(sub);
+- gam_listener_remove_subscription(gam_subscription_get_listener(sub),
+- sub);
+-
+- G_LOCK(removed_subs);
+- removed_subs = g_list_prepend(removed_subs, sub);
+- G_UNLOCK(removed_subs);
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_remove_subscription\n");
++
++ if (!gam_poll_remove_subscription(sub)) {
++ return FALSE;
++ }
+
+- GAM_DEBUG(DEBUG_INFO, "inotify_remove_sub\n");
+ gam_inotify_consume_subscriptions();
+
++ GAM_DEBUG(DEBUG_INFO, "gam_inotify_remove_subscription: done\n");
+ return TRUE;
+ }
+
+@@ -529,26 +637,13 @@
+ gboolean
+ gam_inotify_remove_all_for(GamListener * listener)
+ {
+- GList *subs, *l = NULL;
+-
+- subs = gam_listener_get_subscriptions(listener);
+-
+- for (l = subs; l; l = l->next) {
+- GamSubscription *sub = l->data;
+-
+- g_assert(sub != NULL);
+-
+- gam_inotify_remove_subscription(sub);
+-
+- }
+-
+- if (subs) {
+- g_list_free(subs);
+- gam_inotify_consume_subscriptions();
+- return TRUE;
+- } else {
++ if (!gam_poll_remove_all_for(listener)) {
+ return FALSE;
+ }
++
++ gam_inotify_consume_subscriptions();
++
++ return TRUE;
+ }
+
+ /** @} */
+Index: server/gam_inotify.h
+===================================================================
+RCS file: /cvs/gnome/gamin/server/gam_inotify.h,v
+retrieving revision 1.1
+diff -u -r1.1 gam_inotify.h
+--- server/gam_inotify.h 27 Jul 2004 10:24:43 -0000 1.1
++++ server/gam_inotify.h 14 Apr 2005 16:44:34 -0000
+@@ -1,6 +1,5 @@
+-
+-#ifndef __MD_INOTIFY_H__
+-#define __MD_INOTIFY_H__
++#ifndef __GAM_INOTIFY_H__
++#define __GAM_INOTIFY_H__
+
+ #include <glib.h>
+ #include "gam_poll.h"
+@@ -15,4 +14,4 @@
+
+ G_END_DECLS
+
+-#endif /* __MD_INOTIFY_H__ */
++#endif /* __GAM_INOTIFY_H__ */
+
projects / packages / gamin.git / commitdiff