diff options
Diffstat (limited to 'app-admin/gamin/files/gamin-new-inotify-backend.patch')
| -rw-r--r-- | app-admin/gamin/files/gamin-new-inotify-backend.patch | 3643 |
1 files changed, 3643 insertions, 0 deletions
diff --git a/app-admin/gamin/files/gamin-new-inotify-backend.patch b/app-admin/gamin/files/gamin-new-inotify-backend.patch new file mode 100644 index 0000000..5917559 --- /dev/null +++ b/app-admin/gamin/files/gamin-new-inotify-backend.patch @@ -0,0 +1,3643 @@ +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-missing.h 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,34 @@ ++/* inotify-helper.h - GNOME VFS Monitor using inotify ++ ++ Copyright (C) 2006 John McCutchan <john@johnmccutchan.com> ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Author: John McCutchan <ttb@tentacle.dhs.org> ++*/ ++ ++ ++#ifndef __INOTIFY_MISSING_H ++#define __INOTIFY_MISSING_H ++ ++#include "inotify-sub.h" ++ ++void im_startup (void (*missing_cb)(ih_sub_t *sub)); ++void im_add (ih_sub_t *sub); ++void im_rm (ih_sub_t *sub); ++void im_diag_dump (GIOChannel *ioc); ++ ++#endif /* __INOTIFY_MISSING_H */ +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-kernel.h 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,40 @@ ++/* ++ Copyright (C) 2006 John McCutchan <john@johnmccutchan.com> ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; version 2. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License version 2 for more details. ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++*/ ++ ++#ifndef __INOTIFY_KERNEL_H ++#define __INOTIFY_KERNEL_H ++ ++typedef struct ik_event_s { ++ gint32 wd; ++ guint32 mask; ++ guint32 cookie; ++ guint32 len; ++ char * name; ++ struct ik_event_s *pair; ++} ik_event_t; ++ ++gboolean ik_startup (void (*cb)(ik_event_t *event)); ++ik_event_t *ik_event_new_dummy (const char *name, gint32 wd, guint32 mask); ++void ik_event_free (ik_event_t *event); ++ ++gint32 ik_watch(const char *path, guint32 mask, int *err); ++int ik_ignore(const char *path, gint32 wd); ++ ++/* The miss count will probably be enflated */ ++void ik_move_stats (guint32 *matches, guint32 *misses); ++const char *ik_mask_to_string (guint32 mask); ++ ++#endif +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-diag.h 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,30 @@ ++/* inotify-helper.h - GNOME VFS Monitor using inotify ++ ++ Copyright (C) 2006 John McCutchan <john@johnmccutchan.com> ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Author: John McCutchan <ttb@tentacle.dhs.org> ++*/ ++ ++ ++#ifndef __INOTIFY_DIAG_H ++#define __INOTIFY_DIAG_H ++ ++void id_startup (void); ++gboolean id_dump (gpointer userdata); ++ ++#endif /* __INOTIFY_DIAG_H */ +--- gamin-0.1.7/server/Makefile.am.new-inotify-backend 2005-08-26 13:52:19.000000000 +0200 ++++ gamin-0.1.7/server/Makefile.am 2006-09-05 11:01:21.000000000 +0200 +@@ -51,6 +51,12 @@ + + if ENABLE_INOTIFY + gam_server_SOURCES += gam_inotify.c gam_inotify.h \ ++ inotify-helper.c inotify-helper.h \ ++ inotify-kernel.c inotify-kernel.h \ ++ inotify-missing.c inotify-missing.h \ ++ inotify-path.c inotify-path.h \ ++ inotify-sub.c inotify-sub.h \ ++ inotify-diag.c inotify-diag.h \ + local_inotify.h local_inotify_syscalls.h + endif + +--- gamin-0.1.7/server/local_inotify_syscalls.h.new-inotify-backend 2005-08-17 15:50:04.000000000 +0200 ++++ gamin-0.1.7/server/local_inotify_syscalls.h 2006-09-05 11:01:21.000000000 +0200 +@@ -1,7 +1,9 @@ + #ifndef _LINUX_INOTIFY_SYSCALLS_H + #define _LINUX_INOTIFY_SYSCALLS_H + ++#include <asm/types.h> + #include <sys/syscall.h> ++#include <unistd.h> + + #if defined(__i386__) + # define __NR_inotify_init 291 +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-kernel.c 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,685 @@ ++/* ++ Copyright (C) 2006 John McCutchan <john@johnmccutchan.com> ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; version 2. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License version 2 for more details. ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++*/ ++ ++#include "config.h" ++ ++#include <stdio.h> ++#include <sys/ioctl.h> ++#include <unistd.h> ++#include <errno.h> ++#include <string.h> ++#include <glib.h> ++#include "inotify-kernel.h" ++ ++/* Just include the local headers to stop all the pain */ ++#include "local_inotify.h" ++#include "local_inotify_syscalls.h" ++#if 0 ++#ifdef HAVE_SYS_INOTIFY_H ++/* We don't actually include the libc header, because there has been ++ * problems with libc versions that was built without inotify support. ++ * Instead we use the local version. ++ */ ++#include "local_inotify.h" ++#include "local_inotify_syscalls.h" ++#elif defined (HAVE_LINUX_INOTIFY_H) ++#include <linux/inotify.h> ++#include "local_inotify_syscalls.h" ++#endif ++#endif ++ ++/* Timings for pairing MOVED_TO / MOVED_FROM events */ ++#define PROCESS_EVENTS_TIME 1000 /* milliseconds (1 hz) */ ++#define DEFAULT_HOLD_UNTIL_TIME 0 /* 0 millisecond */ ++#define MOVE_HOLD_UNTIL_TIME 0 /* 0 milliseconds */ ++ ++static int inotify_instance_fd = -1; ++static GQueue *events_to_process = NULL; ++static GQueue *event_queue = NULL; ++static GHashTable * cookie_hash = NULL; ++static GIOChannel *inotify_read_ioc; ++static GPollFD ik_poll_fd; ++static gboolean ik_poll_fd_enabled = TRUE; ++static void (*user_cb)(ik_event_t *event); ++ ++static gboolean ik_read_callback (gpointer user_data); ++static gboolean ik_process_eq_callback (gpointer user_data); ++ ++static guint32 ik_move_matches = 0; ++static guint32 ik_move_misses = 0; ++ ++static gboolean process_eq_running = FALSE; ++ ++/* We use the lock from inotify-helper.c ++ * ++ * There are two places that we take this lock ++ * ++ * 1) In ik_read_callback ++ * ++ * 2) ik_process_eq_callback. ++ * ++ * ++ * The rest of locking is taken care of in inotify-helper.c ++ */ ++G_LOCK_EXTERN (inotify_lock); ++ ++typedef struct ik_event_internal { ++ ik_event_t *event; ++ gboolean seen; ++ gboolean sent; ++ GTimeVal hold_until; ++ struct ik_event_internal *pair; ++} ik_event_internal_t; ++ ++/* In order to perform non-sleeping inotify event chunking we need ++ * a custom GSource ++ */ ++static gboolean ++ik_source_prepare (GSource *source, ++ gint *timeout) ++{ ++ return FALSE; ++} ++ ++static gboolean ++ik_source_timeout (gpointer data) ++{ ++ GSource *source = (GSource *)data; ++ ++ /* Re-active the PollFD */ ++ g_source_add_poll (source, &ik_poll_fd); ++ g_source_unref (source); ++ ik_poll_fd_enabled = TRUE; ++ ++ return FALSE; ++} ++ ++#define MAX_PENDING_COUNT 2 ++#define PENDING_THRESHOLD(qsize) ((qsize) >> 1) ++#define PENDING_MARGINAL_COST(p) ((unsigned int)(1 << (p))) ++#define MAX_QUEUED_EVENTS 2048 ++#define AVERAGE_EVENT_SIZE sizeof (struct inotify_event) + 16 ++#define TIMEOUT_MILLISECONDS 10 ++static gboolean ++ik_source_check (GSource *source) ++{ ++ static int prev_pending = 0, pending_count = 0; ++ ++ /* We already disabled the PollFD or ++ * nothing to be read from inotify */ ++ if (!ik_poll_fd_enabled || !(ik_poll_fd.revents & G_IO_IN)) ++ { ++ return FALSE; ++ } ++ ++ if (pending_count < MAX_PENDING_COUNT) { ++ unsigned int pending; ++ ++ if (ioctl (inotify_instance_fd, FIONREAD, &pending) == -1) ++ goto do_read; ++ ++ pending /= AVERAGE_EVENT_SIZE; ++ ++ /* Don't wait if the number of pending events is too close ++ * to the maximum queue size. ++ */ ++ if (pending > PENDING_THRESHOLD (MAX_QUEUED_EVENTS)) ++ goto do_read; ++ ++ /* With each successive iteration, the minimum rate for ++ * further sleep doubles. */ ++ if (pending-prev_pending < PENDING_MARGINAL_COST(pending_count)) ++ goto do_read; ++ ++ prev_pending = pending; ++ pending_count++; ++ ++ /* We are going to wait to read the events: */ ++ ++ /* Remove the PollFD from the source */ ++ g_source_remove_poll (source, &ik_poll_fd); ++ /* To avoid threading issues we need to flag that we've done that */ ++ ik_poll_fd_enabled = FALSE; ++ /* Set a timeout to re-add the PollFD to the source */ ++ g_source_ref (source); ++ g_timeout_add (TIMEOUT_MILLISECONDS, ik_source_timeout, source); ++ ++ return FALSE; ++ } ++ ++do_read: ++ /* We are ready to read events from inotify */ ++ ++ prev_pending = 0; ++ pending_count = 0; ++ ++ return TRUE; ++} ++ ++static gboolean ++ik_source_dispatch (GSource *source, ++ GSourceFunc callback, ++ gpointer user_data) ++{ ++ if (callback) ++ { ++ return callback(user_data); ++ } ++ return TRUE; ++} ++ ++GSourceFuncs ik_source_funcs = ++{ ++ ik_source_prepare, ++ ik_source_check, ++ ik_source_dispatch, ++ NULL ++}; ++ ++gboolean ik_startup (void (*cb)(ik_event_t *event)) ++{ ++ static gboolean initialized = FALSE; ++ GSource *source; ++ ++ user_cb = cb; ++ /* Ignore multi-calls */ ++ if (initialized) { ++ return inotify_instance_fd >= 0; ++ } ++ ++ initialized = TRUE; ++ inotify_instance_fd = inotify_init (); ++ ++ if (inotify_instance_fd < 0) { ++ return FALSE; ++ } ++ ++ inotify_read_ioc = g_io_channel_unix_new(inotify_instance_fd); ++ ik_poll_fd.fd = inotify_instance_fd; ++ ik_poll_fd.events = G_IO_IN | G_IO_HUP | G_IO_ERR; ++ g_io_channel_set_encoding(inotify_read_ioc, NULL, NULL); ++ g_io_channel_set_flags(inotify_read_ioc, G_IO_FLAG_NONBLOCK, NULL); ++ ++ source = g_source_new (&ik_source_funcs, sizeof(GSource)); ++ g_source_add_poll (source, &ik_poll_fd); ++ g_source_set_callback(source, ik_read_callback, NULL, NULL); ++ g_source_attach(source, NULL); ++ g_source_unref (source); ++ ++ cookie_hash = g_hash_table_new(g_direct_hash, g_direct_equal); ++ event_queue = g_queue_new (); ++ events_to_process = g_queue_new (); ++ ++ return TRUE; ++} ++ ++static ik_event_internal_t *ik_event_internal_new (ik_event_t *event) ++{ ++ ik_event_internal_t *internal_event = g_new0(ik_event_internal_t, 1); ++ GTimeVal tv; ++ ++ g_assert (event); ++ ++ g_get_current_time (&tv); ++ g_time_val_add (&tv, DEFAULT_HOLD_UNTIL_TIME); ++ internal_event->event = event; ++ internal_event->hold_until = tv; ++ ++ return internal_event; ++} ++ ++static ik_event_t *ik_event_new (char *buffer) ++{ ++ struct inotify_event *kevent = (struct inotify_event *)buffer; ++ g_assert (buffer); ++ ik_event_t *event = g_new0(ik_event_t,1); ++ event->wd = kevent->wd; ++ event->mask = kevent->mask; ++ event->cookie = kevent->cookie; ++ event->len = kevent->len; ++ if (event->len) ++ event->name = g_strdup(kevent->name); ++ else ++ event->name = g_strdup(""); ++ ++ return event; ++} ++ ++ik_event_t *ik_event_new_dummy (const char *name, gint32 wd, guint32 mask) ++{ ++ ik_event_t *event = g_new0(ik_event_t,1); ++ event->wd = wd; ++ event->mask = mask; ++ event->cookie = 0; ++ if (name) ++ event->name = g_strdup(name); ++ else ++ event->name = g_strdup(""); ++ ++ event->len = strlen (event->name); ++ ++ return event; ++} ++ ++void ik_event_free (ik_event_t *event) ++{ ++ if (event->pair) ++ ik_event_free (event->pair); ++ g_free(event->name); ++ g_free(event); ++} ++ ++gint32 ik_watch (const char *path, guint32 mask, int *err) ++{ ++ gint32 wd = -1; ++ ++ g_assert (path != NULL); ++ g_assert (inotify_instance_fd >= 0); ++ ++ wd = inotify_add_watch (inotify_instance_fd, path, mask); ++ ++ if (wd < 0) ++ { ++ int e = errno; ++ // FIXME: debug msg failed to add watch ++ if (err) ++ *err = e; ++ return wd; ++ } ++ ++ g_assert (wd >= 0); ++ return wd; ++} ++ ++int ik_ignore(const char *path, gint32 wd) ++{ ++ g_assert (wd >= 0); ++ g_assert (inotify_instance_fd >= 0); ++ ++ if (inotify_rm_watch (inotify_instance_fd, wd) < 0) ++ { ++ //int e = errno; ++ // failed to rm watch ++ return -1; ++ } ++ ++ return 0; ++} ++ ++void ik_move_stats (guint32 *matches, guint32 *misses) ++{ ++ if (matches) ++ *matches = ik_move_matches; ++ ++ if (misses) ++ *misses = ik_move_misses; ++} ++ ++const char *ik_mask_to_string (guint32 mask) ++{ ++ gboolean is_dir = mask & IN_ISDIR; ++ mask &= ~IN_ISDIR; ++ ++ if (is_dir) ++ { ++ switch (mask) ++ { ++ case IN_ACCESS: ++ return "ACCESS (dir)"; ++ break; ++ case IN_MODIFY: ++ return "MODIFY (dir)"; ++ break; ++ case IN_ATTRIB: ++ return "ATTRIB (dir)"; ++ break; ++ case IN_CLOSE_WRITE: ++ return "CLOSE_WRITE (dir)"; ++ break; ++ case IN_CLOSE_NOWRITE: ++ return "CLOSE_NOWRITE (dir)"; ++ break; ++ case IN_OPEN: ++ return "OPEN (dir)"; ++ break; ++ case IN_MOVED_FROM: ++ return "MOVED_FROM (dir)"; ++ break; ++ case IN_MOVED_TO: ++ return "MOVED_TO (dir)"; ++ break; ++ case IN_DELETE: ++ return "DELETE (dir)"; ++ break; ++ case IN_CREATE: ++ return "CREATE (dir)"; ++ break; ++ case IN_DELETE_SELF: ++ return "DELETE_SELF (dir)"; ++ break; ++ case IN_UNMOUNT: ++ return "UNMOUNT (dir)"; ++ break; ++ case IN_Q_OVERFLOW: ++ return "Q_OVERFLOW (dir)"; ++ break; ++ case IN_IGNORED: ++ return "IGNORED (dir)"; ++ break; ++ default: ++ return "UNKNOWN_EVENT (dir)"; ++ break; ++ ++ } ++ } else { ++ switch (mask) ++ { ++ case IN_ACCESS: ++ return "ACCESS"; ++ break; ++ case IN_MODIFY: ++ return "MODIFY"; ++ break; ++ case IN_ATTRIB: ++ return "ATTRIB"; ++ break; ++ case IN_CLOSE_WRITE: ++ return "CLOSE_WRITE"; ++ break; ++ case IN_CLOSE_NOWRITE: ++ return "CLOSE_NOWRITE"; ++ break; ++ case IN_OPEN: ++ return "OPEN"; ++ break; ++ case IN_MOVED_FROM: ++ return "MOVED_FROM"; ++ break; ++ case IN_MOVED_TO: ++ return "MOVED_TO"; ++ break; ++ case IN_DELETE: ++ return "DELETE"; ++ break; ++ case IN_CREATE: ++ return "CREATE"; ++ break; ++ case IN_DELETE_SELF: ++ return "DELETE_SELF"; ++ break; ++ case IN_UNMOUNT: ++ return "UNMOUNT"; ++ break; ++ case IN_Q_OVERFLOW: ++ return "Q_OVERFLOW"; ++ break; ++ case IN_IGNORED: ++ return "IGNORED"; ++ break; ++ default: ++ return "UNKNOWN_EVENT"; ++ break; ++ ++ } ++ } ++} ++ ++ ++static void ik_read_events (gsize *buffer_size_out, gchar **buffer_out) ++{ ++ static gchar *buffer = NULL; ++ static gsize buffer_size; ++ ++ /* Initialize the buffer on our first call */ ++ if (buffer == NULL) ++ { ++ buffer_size = AVERAGE_EVENT_SIZE; ++ buffer_size *= MAX_QUEUED_EVENTS; ++ buffer = g_malloc (buffer_size); ++ ++ if (!buffer) { ++ *buffer_size_out = 0; ++ *buffer_out = NULL; ++ return; ++ } ++ } ++ ++ *buffer_size_out = 0; ++ *buffer_out = NULL; ++ ++ memset(buffer, 0, buffer_size); ++ ++ if (g_io_channel_read_chars (inotify_read_ioc, (char *)buffer, buffer_size, buffer_size_out, NULL) != G_IO_STATUS_NORMAL) { ++ // error reading ++ } ++ *buffer_out = buffer; ++} ++ ++static gboolean ik_read_callback(gpointer user_data) ++{ ++ gchar *buffer; ++ gsize buffer_size, buffer_i, events; ++ ++ G_LOCK(inotify_lock); ++ ik_read_events (&buffer_size, &buffer); ++ ++ buffer_i = 0; ++ events = 0; ++ while (buffer_i < buffer_size) ++ { ++ struct inotify_event *event; ++ gsize event_size; ++ event = (struct inotify_event *)&buffer[buffer_i]; ++ event_size = sizeof(struct inotify_event) + event->len; ++ g_queue_push_tail (events_to_process, ik_event_internal_new (ik_event_new (&buffer[buffer_i]))); ++ buffer_i += event_size; ++ events++; ++ } ++ ++ /* If the event process callback is off, turn it back on */ ++ if (!process_eq_running && events) ++ { ++ process_eq_running = TRUE; ++ g_timeout_add (PROCESS_EVENTS_TIME, ik_process_eq_callback, NULL); ++ } ++ ++ G_UNLOCK(inotify_lock); ++ return TRUE; ++} ++ ++static gboolean ++g_timeval_lt(GTimeVal *val1, GTimeVal *val2) ++{ ++ if (val1->tv_sec < val2->tv_sec) ++ return TRUE; ++ ++ if (val1->tv_sec > val2->tv_sec) ++ return FALSE; ++ ++ /* val1->tv_sec == val2->tv_sec */ ++ if (val1->tv_usec < val2->tv_usec) ++ return TRUE; ++ ++ return FALSE; ++} ++ ++static gboolean ++g_timeval_eq(GTimeVal *val1, GTimeVal *val2) ++{ ++ return (val1->tv_sec == val2->tv_sec) && (val1->tv_usec == val2->tv_usec); ++} ++ ++static void ++ik_pair_events (ik_event_internal_t *event1, ik_event_internal_t *event2) ++{ ++ g_assert (event1 && event2); ++ /* We should only be pairing events that have the same cookie */ ++ g_assert (event1->event->cookie == event2->event->cookie); ++ /* We shouldn't pair an event that already is paired */ ++ g_assert (event1->pair == NULL && event2->pair == NULL); ++ ++ /* Pair the internal structures and the ik_event_t structures */ ++ event1->pair = event2; ++ event1->event->pair = event2->event; ++ ++ if (g_timeval_lt (&event1->hold_until, &event2->hold_until)) ++ event1->hold_until = event2->hold_until; ++ ++ event2->hold_until = event1->hold_until; ++} ++ ++static void ++ik_event_add_microseconds (ik_event_internal_t *event, glong ms) ++{ ++ g_assert (event); ++ g_time_val_add (&event->hold_until, ms); ++} ++ ++static gboolean ++ik_event_ready (ik_event_internal_t *event) ++{ ++ GTimeVal tv; ++ g_assert (event); ++ ++ g_get_current_time (&tv); ++ ++ /* An event is ready if, ++ * ++ * it has no cookie -- there is nothing to be gained by holding it ++ * or, it is already paired -- we don't need to hold it anymore ++ * or, we have held it long enough ++ */ ++ return event->event->cookie == 0 || ++ event->pair != NULL || ++ g_timeval_lt(&event->hold_until, &tv) || g_timeval_eq(&event->hold_until, &tv); ++} ++ ++static void ++ik_pair_moves (gpointer data, gpointer user_data) ++{ ++ ik_event_internal_t *event = (ik_event_internal_t *)data; ++ ++ if (event->seen == TRUE || event->sent == TRUE) ++ return; ++ ++ if (event->event->cookie != 0) ++ { ++ /* When we get a MOVED_FROM event we delay sending the event by ++ * MOVE_HOLD_UNTIL_TIME microseconds. We need to do this because a ++ * MOVED_TO pair _might_ be coming in the near future */ ++ if (event->event->mask & IN_MOVED_FROM) { ++ g_hash_table_insert (cookie_hash, GINT_TO_POINTER(event->event->cookie), event); ++ // because we don't deliver move events there is no point in waiting for the match right now. ++ ik_event_add_microseconds (event, MOVE_HOLD_UNTIL_TIME); ++ } else if (event->event->mask & IN_MOVED_TO) { ++ /* We need to check if we are waiting for this MOVED_TO events cookie to pair it with ++ * a MOVED_FROM */ ++ ik_event_internal_t *match = NULL; ++ match = g_hash_table_lookup (cookie_hash, GINT_TO_POINTER(event->event->cookie)); ++ if (match) { ++ g_hash_table_remove (cookie_hash, GINT_TO_POINTER(event->event->cookie)); ++ ik_pair_events (match, event); ++ } ++ } ++ } ++ event->seen = TRUE; ++} ++ ++static void ++ik_process_events () ++{ ++ g_queue_foreach (events_to_process, ik_pair_moves, NULL); ++ ++ while (!g_queue_is_empty (events_to_process)) ++ { ++ ik_event_internal_t *event = g_queue_peek_head (events_to_process); ++ ++ /* This must have been sent as part of a MOVED_TO/MOVED_FROM */ ++ if (event->sent) ++ { ++ /* Pop event */ ++ g_queue_pop_head (events_to_process); ++ /* Free the internal event structure */ ++ g_free (event); ++ continue; ++ } ++ ++ /* The event isn't ready yet */ ++ if (!ik_event_ready (event)) { ++ break; ++ } ++ ++ /* Pop it */ ++ event = g_queue_pop_head (events_to_process); ++ ++ /* Check if this is a MOVED_FROM that is also sitting in the cookie_hash */ ++ if (event->event->cookie && event->pair == NULL && ++ g_hash_table_lookup (cookie_hash, GINT_TO_POINTER(event->event->cookie))) ++ { ++ g_hash_table_remove (cookie_hash, GINT_TO_POINTER(event->event->cookie)); ++ } ++ ++ if (event->pair) { ++ /* We send out paired MOVED_FROM/MOVED_TO events in the same event buffer */ ++ //g_assert (event->event->mask == IN_MOVED_FROM && event->pair->event->mask == IN_MOVED_TO); ++ /* Copy the paired data */ ++ event->pair->sent = TRUE; ++ event->sent = TRUE; ++ ik_move_matches++; ++ } else if (event->event->cookie) { ++ /* If we couldn't pair a MOVED_FROM and MOVED_TO together, we change ++ * the event masks */ ++ /* Changeing MOVED_FROM to DELETE and MOVED_TO to create lets us make ++ * the gaurantee that you will never see a non-matched MOVE event */ ++ ++ if (event->event->mask & IN_MOVED_FROM) { ++ event->event->mask = IN_DELETE|(event->event->mask & IN_ISDIR); ++ ik_move_misses++; // not super accurate, if we aren't watching the destination it still counts as a miss ++ } ++ if (event->event->mask & IN_MOVED_TO) ++ event->event->mask = IN_CREATE|(event->event->mask & IN_ISDIR); ++ } ++ ++ /* Push the ik_event_t onto the event queue */ ++ g_queue_push_tail (event_queue, event->event); ++ /* Free the internal event structure */ ++ g_free (event); ++ } ++} ++ ++gboolean ik_process_eq_callback (gpointer user_data) ++{ ++ /* Try and move as many events to the event queue */ ++ G_LOCK(inotify_lock); ++ ik_process_events (); ++ ++ while (!g_queue_is_empty (event_queue)) ++ { ++ ik_event_t *event = g_queue_pop_head (event_queue); ++ ++ user_cb (event); ++ } ++ ++ if (g_queue_get_length (events_to_process) == 0) ++ { ++ process_eq_running = FALSE; ++ G_UNLOCK(inotify_lock); ++ return FALSE; ++ } else { ++ G_UNLOCK(inotify_lock); ++ return TRUE; ++ } ++} +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-missing.c 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,158 @@ ++/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ ++ ++/* inotify-helper.c - Gnome VFS Monitor based on inotify. ++ ++ Copyright (C) 2005 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Authors: ++ John McCutchan <john@johnmccutchan.com> ++*/ ++ ++#include "config.h" ++#include <glib.h> ++#include "inotify-missing.h" ++#include "inotify-path.h" ++ ++#define SCAN_MISSING_TIME 4000 /* 1/4 Hz */ ++ ++static gboolean im_debug_enabled = FALSE; ++#define IM_W if (im_debug_enabled) g_warning ++ ++/* We put ih_sub_t's that are missing on this list */ ++static GList *missing_sub_list = NULL; ++static gboolean im_scan_missing (gpointer user_data); ++static gboolean scan_missing_running = FALSE; ++static void (*missing_cb)(ih_sub_t *sub) = NULL; ++ ++G_LOCK_EXTERN (inotify_lock); ++ ++/* inotify_lock must be held before calling */ ++void im_startup (void (*callback)(ih_sub_t *sub)) ++{ ++ static gboolean initialized = FALSE; ++ ++ if (!initialized) { ++ initialized = TRUE; ++ missing_cb = callback; ++ } ++} ++ ++/* inotify_lock must be held before calling */ ++void im_add (ih_sub_t *sub) ++{ ++ if (g_list_find (missing_sub_list, sub)) { ++ IM_W("asked to add %s to missing list but it's already on the list!\n", sub->pathname); ++ return; ++ } ++ ++ IM_W("adding %s to missing list\n", sub->dirname); ++ missing_sub_list = g_list_prepend (missing_sub_list, sub); ++ ++ /* If the timeout is turned off, we turn it back on */ ++ if (!scan_missing_running) ++ { ++ scan_missing_running = TRUE; ++ g_timeout_add (SCAN_MISSING_TIME, im_scan_missing, NULL); ++ } ++} ++ ++/* inotify_lock must be held before calling */ ++void im_rm (ih_sub_t *sub) ++{ ++ GList *link; ++ ++ link = g_list_find (missing_sub_list, sub); ++ ++ if (!link) { ++ IM_W("asked to remove %s from missing list but it isn't on the list!\n", sub->pathname); ++ return; ++ } ++ ++ IM_W("removing %s from missing list\n", sub->dirname); ++ ++ missing_sub_list = g_list_remove_link (missing_sub_list, link); ++ g_list_free_1 (link); ++} ++ ++/* Scans the list of missing subscriptions checking if they ++ * are available yet. ++ */ ++static gboolean im_scan_missing (gpointer user_data) ++{ ++ GList *nolonger_missing = NULL; ++ GList *l; ++ ++ G_LOCK(inotify_lock); ++ ++ IM_W("scanning missing list with %d items\n", g_list_length (missing_sub_list)); ++ for (l = missing_sub_list; l; l = l->next) ++ { ++ ih_sub_t *sub = l->data; ++ gboolean not_m = FALSE; ++ ++ IM_W("checking %p\n", sub); ++ g_assert (sub); ++ g_assert (sub->dirname); ++ not_m = ip_start_watching (sub); ++ ++ if (not_m) ++ { ++ missing_cb (sub); ++ IM_W("removed %s from missing list\n", sub->dirname); ++ /* We have to build a list of list nodes to remove from the ++ * missing_sub_list. We do the removal outside of this loop. ++ */ ++ nolonger_missing = g_list_prepend (nolonger_missing, l); ++ } ++ } ++ ++ for (l = nolonger_missing; l ; l = l->next) ++ { ++ GList *llink = l->data; ++ missing_sub_list = g_list_remove_link (missing_sub_list, llink); ++ g_list_free_1 (llink); ++ } ++ ++ g_list_free (nolonger_missing); ++ ++ /* If the missing list is now empty, we disable the timeout */ ++ if (missing_sub_list == NULL) ++ { ++ scan_missing_running = FALSE; ++ G_UNLOCK(inotify_lock); ++ return FALSE; ++ } else { ++ G_UNLOCK(inotify_lock); ++ return TRUE; ++ } ++} ++ ++ ++/* inotify_lock must be held */ ++void ++im_diag_dump (GIOChannel *ioc) ++{ ++ GList *l; ++ g_io_channel_write_chars (ioc, "missing list:\n", -1, NULL, NULL); ++ for (l = missing_sub_list; l; l = l->next) ++ { ++ ih_sub_t *sub = l->data; ++ g_io_channel_write_chars (ioc, sub->pathname, -1, NULL, NULL); ++ g_io_channel_write_chars (ioc, "\n", -1, NULL, NULL); ++ } ++} +--- gamin-0.1.7/server/gam_inotify.c.new-inotify-backend 2005-10-25 16:16:28.000000000 +0200 ++++ gamin-0.1.7/server/gam_inotify.c 2006-09-05 12:13:38.000000000 +0200 +@@ -17,1582 +17,201 @@ + */ + + #include "server_config.h" +-#define _GNU_SOURCE +-#include <errno.h> +-#include <stdio.h> + #include <string.h> +-#include <sys/types.h> +-#include <sys/stat.h> +-#include <sys/ioctl.h> +-#include <fcntl.h> +-#include <unistd.h> +-#include <asm/unistd.h> +-#include <time.h> +-#include <glib.h> ++/* Just include the local header to stop all the pain */ ++#include "local_inotify.h" ++#if 0 ++#ifdef HAVE_SYS_INOTIFY_H ++/* We don't actually include the libc header, because there has been ++ * problems with libc versions that was built without inotify support. ++ * Instead we use the local version. ++ */ ++#include "local_inotify.h" ++#elif defined (HAVE_LINUX_INOTIFY_H) ++#include <linux/inotify.h> ++#endif ++#endif ++#include "inotify-sub.h" ++#include "inotify-helper.h" ++#include "inotify-diag.h" + #ifdef GAMIN_DEBUG_API + #include "gam_debugging.h" + #endif + #include "gam_error.h" +-#include "gam_poll_basic.h" +-#ifdef HAVE_LINUX_INOTIFY_H +-#include <linux/inotify.h> +-#else +-#include "local_inotify.h" +-#endif +-#include "local_inotify_syscalls.h" +-#include "gam_inotify.h" +-#include "gam_tree.h" + #include "gam_event.h" + #include "gam_server.h" +-#include "gam_event.h" +-#include "gam_fs.h" +- +-#define GAM_INOTIFY_SANITY +-#define GAM_INOTIFY_WD_MISSING -1 +-#define GAM_INOTIFY_WD_PERM -2 +-#define GAM_INOTIFY_WD_LINK -3 +- +-/* Timings for pairing MOVED_TO / MOVED_FROM events */ +-/* These numbers are in microseconds */ +-#define DEFAULT_HOLD_UNTIL_TIME 1000 /* 1 ms */ +-#define MOVE_HOLD_UNTIL_TIME 5000 /* 5 ms */ +- +-/* Timings for main loop */ +-/* These numbers are in milliseconds */ +-#define SCAN_MISSING_TIME 1000 /* 1 Hz */ +-#define SCAN_LINKS_TIME 1000 /* 1 Hz */ +-#define PROCESS_EVENTS_TIME 33 /* 30 Hz */ +- +-typedef struct { +- /* The full pathname of this node */ +- char *path; +- gboolean dir; /* Is this path a directory */ +- +- /* Inotify */ +- int wd; +- +- /* State */ +- gboolean busy; +- gboolean missing; +- gboolean link; +- gboolean permission; /* Exists, but don't have read access */ +- gboolean deactivated; +- gboolean ignored; +- int refcount; +- +- /* Statistics */ +- int events; +- int deactivated_events; +- int ignored_events; +- +- /* Gamin state */ +- GList *subs; +-} inotify_data_t; +- +-typedef struct _inotify_event_t { +- gint wd; +- gint mask; +- gint cookie; +- char *name; +- gboolean seen; +- gboolean sent; +- GTimeVal hold_until; +- struct _inotify_event_t *pair; +-} inotify_event_t; +- +-typedef struct { +- char *path; +- GTime last_scan_time; +- GTime scan_interval; +- gboolean permission; +-} inotify_missing_t; +- +-typedef struct { +- char *path; +- struct stat sbuf; +- GTime last_scan_time; +- GTime scan_interval; +-} inotify_links_t; +- +-static GHashTable * path_hash = NULL; +-static GHashTable * wd_hash = NULL; +-static GList * missing_list = NULL; +-static GList * links_list = NULL; +-static GHashTable * cookie_hash = NULL; +-static GQueue * event_queue = NULL; +-static GQueue * events_to_process = NULL; +-static GIOChannel * inotify_read_ioc = NULL; +-static int inotify_device_fd = -1; +- +-#define GAM_INOTIFY_MASK (IN_MODIFY|IN_ATTRIB|IN_MOVED_FROM|IN_MOVED_TO|IN_DELETE|IN_CREATE|IN_DELETE_SELF|IN_UNMOUNT|IN_MOVE_SELF) +- +-static int gam_inotify_add_watch (const char *path, __u32 mask, int *err); +-static int gam_inotify_rm_watch (const char *path, __u32 wd); +-static void gam_inotify_read_events (gsize *buffer_size_out, gchar **buffer_out); +- +-static gboolean gam_inotify_is_missing (const char *path); +-static gboolean gam_inotify_nolonger_missing (const char *path); +-static void gam_inotify_add_missing (const char *path, gboolean perm); +-static void gam_inotify_rm_missing (const char *path); +-static gboolean gam_inotify_scan_missing (gpointer userdata); +- +-static gboolean gam_inotify_is_link (const char *path); +-static gboolean gam_inotify_nolonger_link (const char *path); +-static void gam_inotify_add_link (const char *path); +-static void gam_inotify_rm_link (const char *path); +-static gboolean gam_inotify_scan_links (gpointer userdata); +-static void gam_inotify_poll_link (inotify_links_t *links); +- +-static void gam_inotify_sanity_check (void); +- +-static gboolean g_timeval_lt (GTimeVal *val1, GTimeVal *val2); +-static gboolean g_timeval_eq (GTimeVal *val1, GTimeVal *val2); +- +-static void +-gam_inotify_data_debug (gpointer key, gpointer value, gpointer user_data) +-{ +- int busy; +- int deactivated; +- int ignored; +- int missing; +- int permission; +- inotify_data_t *data = (inotify_data_t *)value; +- +- if (!data) +- return; +- +- busy = data->busy; +- deactivated = data->deactivated; +- ignored = data->ignored; +- missing = data->missing; +- permission = data->permission; +- +- GAM_DEBUG(DEBUG_INFO, "isub wd %d refs %d permission %d missing %d busy %d deactivated %d ignored %d events (%d:%d:%d): %s\n", data->wd, data->refcount, permission, missing, busy, deactivated, ignored, data->events, data->deactivated_events, data->ignored_events, data->path); +-} +- +-gboolean +-gam_inotify_is_running(void) +-{ +- return inotify_device_fd >= 0; +-} +- +-void +-gam_inotify_debug(void) +-{ +- if (inotify_device_fd == -1) +- { +- return; +- } +- +- if (path_hash == NULL) +- return; +- +- GAM_DEBUG(DEBUG_INFO, "Inotify device fd = %d\n", inotify_device_fd); +- GAM_DEBUG(DEBUG_INFO, "Dumping inotify subscriptions\n"); +- g_hash_table_foreach (path_hash, gam_inotify_data_debug, NULL); +-} +- +-static const char * +-mask_to_string (int mask) +-{ +- mask &= ~IN_ISDIR; +- switch (mask) +- { +- case IN_ACCESS: +- return "ACCESS"; +- break; +- case IN_MODIFY: +- return "MODIFY"; +- break; +- case IN_ATTRIB: +- return "ATTRIB"; +- break; +- case IN_CLOSE_WRITE: +- return "CLOSE_WRITE"; +- break; +- case IN_CLOSE_NOWRITE: +- return "CLOSE_NOWRITE"; +- break; +- case IN_OPEN: +- return "OPEN"; +- break; +- case IN_MOVED_FROM: +- return "MOVED_FROM"; +- break; +- case IN_MOVED_TO: +- return "MOVED_TO"; +- break; +- case IN_DELETE: +- return "DELETE"; +- break; +- case IN_CREATE: +- return "CREATE"; +- break; +- case IN_DELETE_SELF: +- return "DELETE_SELF"; +- break; +- case IN_UNMOUNT: +- return "UNMOUNT"; +- break; +- case IN_Q_OVERFLOW: +- return "Q_OVERFLOW"; +- break; +- case IN_IGNORED: +- return "IGNORED"; +- break; +- default: +- return "UNKNOWN_EVENT"; +- break; +- } +-} +- +-static GaminEventType +-mask_to_gam_event (gint mask) +-{ +- mask &= ~IN_ISDIR; +- switch (mask) +- { +- case IN_MODIFY: +- case IN_ATTRIB: +- return GAMIN_EVENT_CHANGED; +- break; +- case IN_MOVE_SELF: +- case IN_MOVED_FROM: +- case IN_DELETE: +- case IN_DELETE_SELF: +- return GAMIN_EVENT_DELETED; +- break; +- case IN_CREATE: +- case IN_MOVED_TO: +- return GAMIN_EVENT_CREATED; +- break; +- case IN_Q_OVERFLOW: +- case IN_OPEN: +- case IN_CLOSE_WRITE: +- case IN_CLOSE_NOWRITE: +- case IN_UNMOUNT: +- case IN_ACCESS: +- case IN_IGNORED: +- default: +- return GAMIN_EVENT_UNKNOWN; +- break; +- } +-} +- +-/* Called when a directory is being watched as a file */ +-static GaminEventType +-gam_inotify_mask_to_gam_file_event (gint mask) +-{ +- mask &= ~IN_ISDIR; +- switch (mask) +- { +- case IN_MOVED_FROM: +- case IN_DELETE: +- case IN_CREATE: +- case IN_MOVED_TO: +- return GAMIN_EVENT_CHANGED; +- break; +- case IN_MOVE_SELF: +- case IN_DELETE_SELF: +- return GAMIN_EVENT_DELETED; +- break; +- case IN_ATTRIB: +- case IN_MODIFY: +- case IN_Q_OVERFLOW: +- case IN_OPEN: +- case IN_CLOSE_WRITE: +- case IN_CLOSE_NOWRITE: +- case IN_UNMOUNT: +- case IN_ACCESS: +- case IN_IGNORED: +- default: +- return GAMIN_EVENT_UNKNOWN; +- break; +- } +-} ++#include "gam_subscription.h" ++#include "gam_inotify.h" + +-/* Called when a file is watched as a directory */ ++/* Transforms a inotify event to a gamin event. */ + static GaminEventType +-gam_inotify_mask_to_gam_dir_event (gint mask) ++ih_mask_to_EventType (guint32 mask) + { +- mask &= ~IN_ISDIR; +- switch (mask) +- { +- case IN_MOVED_FROM: +- case IN_DELETE: +- case IN_CREATE: +- case IN_MOVED_TO: +- case IN_MOVE_SELF: +- case IN_DELETE_SELF: +- case IN_ATTRIB: +- case IN_MODIFY: +- case IN_Q_OVERFLOW: +- case IN_OPEN: +- case IN_CLOSE_WRITE: +- case IN_CLOSE_NOWRITE: +- case IN_UNMOUNT: +- case IN_ACCESS: +- case IN_IGNORED: +- default: +- return GAMIN_EVENT_UNKNOWN; ++ mask &= ~IN_ISDIR; ++ switch (mask) ++ { ++ case IN_MODIFY: ++ return GAMIN_EVENT_CHANGED; ++ break; ++ case IN_ATTRIB: ++ return GAMIN_EVENT_CHANGED; ++ break; ++ case IN_MOVE_SELF: ++ case IN_MOVED_FROM: ++ case IN_DELETE: ++ case IN_DELETE_SELF: ++ return GAMIN_EVENT_DELETED; ++ break; ++ case IN_CREATE: ++ case IN_MOVED_TO: ++ return GAMIN_EVENT_CREATED; ++ break; ++ case IN_Q_OVERFLOW: ++ case IN_OPEN: ++ case IN_CLOSE_WRITE: ++ case IN_CLOSE_NOWRITE: ++ case IN_UNMOUNT: ++ case IN_ACCESS: ++ case IN_IGNORED: ++ default: ++ return -1; + break; + } + } + +-static inotify_data_t * +-gam_inotify_data_new(const char *path, int wd, gboolean dir) +-{ +- inotify_data_t *data; +- +- data = g_new0(inotify_data_t, 1); +- +- data->path = g_strdup(path); +- data->wd = wd; +- data->busy = FALSE; +- if (wd == GAM_INOTIFY_WD_MISSING) +- data->missing = TRUE; +- else +- data->missing = FALSE; +- if (wd == GAM_INOTIFY_WD_PERM) +- data->permission = TRUE; +- else +- data->permission = FALSE; +- if (wd == GAM_INOTIFY_WD_LINK) +- data->link = TRUE; +- else +- data->link = FALSE; +- data->deactivated = FALSE; +- data->ignored = FALSE; +- data->refcount = 1; +- data->events = 0; +- data->deactivated_events = 0; +- data->ignored_events = 0; +- data->dir = dir; +- +- return data; +-} +- +-static void +-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); +-} +- +-static inotify_event_t * +-gam_inotify_event_new (struct inotify_event *event) +-{ +- inotify_event_t *gam_event; +- GTimeVal tv; +- +- gam_event = g_new0(inotify_event_t, 1); +- +- gam_event->wd = event->wd; +- gam_event->mask = event->mask; +- gam_event->cookie = event->cookie; +- +- if (event->len) +- { +- gam_event->name = g_strdup (event->name); +- } else { +- gam_event->name = g_strdup (""); +- } +- +- g_get_current_time (&tv); +- g_time_val_add (&tv, DEFAULT_HOLD_UNTIL_TIME); +- gam_event->hold_until = tv; +- +- return gam_event; +-} +- +-static void +-gam_inotify_event_free (inotify_event_t *event) +-{ +- g_free (event->name); +- g_free (event); +-} +- +-static void +-gam_inotify_event_pair_with (inotify_event_t *event1, inotify_event_t *event2) +-{ +- g_assert (event1 && event2); +- /* We should only be pairing events that have the same cookie */ +- g_assert (event1->cookie == event2->cookie); +- /* We shouldn't pair an event that already is paired */ +- g_assert (event1->pair == NULL && event2->pair == NULL); +- event1->pair = event2; +- event2->pair = event1; +- +- GAM_DEBUG(DEBUG_INFO, "inotify: pairing a MOVE together\n"); +- if (g_timeval_lt (&event1->hold_until, &event2->hold_until)) +- event1->hold_until = event2->hold_until; +- +- event2->hold_until = event1->hold_until; +-} +- +-static void +-gam_inotify_event_add_microseconds (inotify_event_t *event, glong ms) +-{ +- g_assert (event); +- g_time_val_add (&event->hold_until, ms); +-} +- +-static gboolean +-gam_inotify_event_ready (inotify_event_t *event) +-{ +- GTimeVal tv; +- g_assert (event); +- +- g_get_current_time (&tv); +- +- /* An event is ready if, +- * +- * it has no cookie -- there is nothing to be gained by holding it +- * or, it is already paired -- we don't need to hold it anymore +- * or, we have held it long enough +- */ +- return event->cookie == 0 || +- event->pair != NULL || +- g_timeval_lt(&event->hold_until, &tv) || g_timeval_eq(&event->hold_until, &tv); +-} +- + static void +-gam_inotify_emit_one_event (inotify_data_t *data, inotify_event_t *event, GamSubscription *sub) ++gam_inotify_send_initial_events (const char *pathname, GamSubscription *sub, gboolean is_dir, gboolean was_missing) + { +- gint force = 1; +- gint is_dir_node = 0; + GaminEventType gevent; +- gchar *fullpath = NULL; +- gboolean watching_dir_as_file; +- gboolean watching_file_as_dir; + +- g_assert (data && event); ++ gevent = was_missing ? GAMIN_EVENT_CREATED : GAMIN_EVENT_EXISTS; + +- is_dir_node = event->mask & IN_ISDIR; +- watching_dir_as_file = data->dir && !gam_subscription_is_dir (sub); +- watching_file_as_dir = !data->dir && gam_subscription_is_dir (sub); ++ gam_server_emit_one_event (pathname, is_dir ? 1 : 0, gevent, sub, 1); + +- if (watching_dir_as_file) ++ if (is_dir) + { +- gevent = gam_inotify_mask_to_gam_file_event (event->mask); +- fullpath = g_strdup (data->path); +- } else if (watching_file_as_dir) { +- gevent = gam_inotify_mask_to_gam_dir_event (event->mask); +- fullpath = g_strdup (data->path); +- } else { +- gevent = mask_to_gam_event (event->mask); +- if (strlen (event->name) == 0) +- fullpath = g_strdup (data->path); +- else +- fullpath = g_strdup_printf ("%s/%s", data->path, event->name); +- } +- +- if (gevent == GAMIN_EVENT_UNKNOWN) { +- GAM_DEBUG(DEBUG_INFO, "inotify: Not handling event %d\n", event->mask); +- g_free (fullpath); +- return; +- } +- +- GAM_DEBUG(DEBUG_INFO, "inotify: Emitting %s on %s\n", gam_event_to_string (gevent), fullpath); +- gam_server_emit_one_event (fullpath, is_dir_node, gevent, sub, force); +- g_free(fullpath); +-} +- +-static void +-gam_inotify_emit_events (inotify_data_t *data, inotify_event_t *event) +-{ +- GList *l; +- +- if (!data||!event) +- return; +- +- for (l = data->subs; l; l = l->next) { +- GamSubscription *sub = l->data; +- gam_inotify_emit_one_event (data, event, sub); +- } +-} +- +-static void +-gam_inotify_process_event (inotify_event_t *event) +-{ +- inotify_data_t *data = NULL; +- +- data = g_hash_table_lookup (wd_hash, GINT_TO_POINTER(event->wd)); +- +- if (!data) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify: got %s event for unknown wd %d\n", mask_to_string (event->mask), event->wd); +- return; +- } +- +- if (data->deactivated) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify: ignoring event on temporarily deactivated watch %s\n", data->path); +- data->deactivated_events++; +- return; +- } +- +- if (data->ignored) { +- GAM_DEBUG (DEBUG_INFO, "inotify: got event on ignored watch %s\n", data->path); +- data->ignored_events++; +- return; +- } +- +- if (event->mask & IN_IGNORED) +- { +- data->ignored = TRUE; +- data->ignored_events++; +- return; +- } +- +- if (event->mask & IN_DELETE_SELF || event->mask & IN_MOVE_SELF) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify: resource %s went away. Adding it to missing list\n", data->path); +- /* Remove the wd from the hash table */ +- g_hash_table_remove (wd_hash, GINT_TO_POINTER(data->wd)); +-#ifdef GAMIN_DEBUG_API +- gam_debug_report(GAMDnotifyDelete, data->path, 0); +-#endif +- /* Send delete event */ +- gam_inotify_emit_events (data, event); +- data->events++; +- /* Set state bits in struct */ +- data->wd = GAM_INOTIFY_WD_MISSING; +- data->missing = TRUE; +- data->permission = FALSE; +- data->dir = FALSE; +- /* Add path to missing list */ +- gam_inotify_add_missing (data->path, FALSE); +- return; +- } +- +- if (event->mask & GAM_INOTIFY_MASK) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify: got %s on = %s/%s\n", mask_to_string (event->mask), data->path, event->name); +- gam_inotify_emit_events (data, event); +- data->events++; +- return; +- } +- +- if (event->mask & IN_Q_OVERFLOW) +- { +- /* At this point we have missed some events, and no longer have a consistent +- * view of the filesystem. +- */ +- // XXX: Kill server and hope for the best? +- // XXX: Or we could send_initial_events , does this work for FAM? +- GAM_DEBUG (DEBUG_INFO, "inotify: DANGER, queue over flowed! Events have been missed.\n"); +- return; +- } +- +- GAM_DEBUG(DEBUG_INFO, "inotify: error event->mask = %d\n", event->mask); +-} +- +-static void +-gam_inotify_pair_moves (gpointer data, gpointer user_data) +-{ +- inotify_event_t *event = (inotify_event_t *)data; +- +- if (event->seen == TRUE || event->sent == TRUE) +- return; ++ GDir *dir; ++ GError *err = NULL; ++ dir = g_dir_open (pathname, 0, &err); ++ if (dir) ++ { ++ const char *filename; + +- if (event->cookie != 0) +- { +- if (event->mask & IN_MOVED_FROM) { +- g_hash_table_insert (cookie_hash, GINT_TO_POINTER(event->cookie), event); +- gam_inotify_event_add_microseconds (event, MOVE_HOLD_UNTIL_TIME); +- } else if (event->mask & IN_MOVED_TO) { +- inotify_event_t *match = NULL; +- match = g_hash_table_lookup (cookie_hash, GINT_TO_POINTER(event->cookie)); +- if (match) { +- g_hash_table_remove (cookie_hash, GINT_TO_POINTER(event->cookie)); +- gam_inotify_event_pair_with (match, event); ++ while ((filename = g_dir_read_name (dir))) ++ { ++ gchar *fullname = g_strdup_printf ("%s/%s", pathname, filename); ++ gboolean file_is_dir = FALSE; ++ struct stat fsb; ++ memset(&fsb, 0, sizeof (struct stat)); ++ lstat(fullname, &fsb); ++ file_is_dir = (fsb.st_mode & S_IFDIR) != 0 ? TRUE : FALSE; ++ gam_server_emit_one_event (fullname, file_is_dir ? 1 : 0, gevent, sub, 1); ++ g_free (fullname); + } +- } +- } +- event->seen = TRUE; +-} +- +-static void +-gam_inotify_process_internal () +-{ +- int ecount = 0; +- g_queue_foreach (events_to_process, gam_inotify_pair_moves, NULL); + +- while (!g_queue_is_empty (events_to_process)) +- { +- inotify_event_t *event = g_queue_peek_head (events_to_process); +- +- if (!gam_inotify_event_ready (event)) { +- GAM_DEBUG(DEBUG_INFO, "inotify: event not ready\n"); +- break; +- } +- +- /* Pop it */ +- event = g_queue_pop_head (events_to_process); +- /* This must have been sent as part of a MOVED_TO/MOVED_FROM */ +- if (event->sent) +- continue; +- +- /* Check if this is a MOVED_FROM that is also sitting in the cookie_hash */ +- if (event->cookie && event->pair == NULL && +- g_hash_table_lookup (cookie_hash, GINT_TO_POINTER(event->cookie))) +- { +- g_hash_table_remove (cookie_hash, GINT_TO_POINTER(event->cookie)); +- event->sent = TRUE; +- } +- +- g_queue_push_tail (event_queue, event); +- ecount++; +- if (event->pair) { +- // if this event has a pair +- event->pair->sent = TRUE; +- g_queue_push_tail (event_queue, event->pair); +- ecount++; ++ g_dir_close (dir); ++ } else { ++ GAM_DEBUG (DEBUG_INFO, "unable to open directory %s: %s\n", pathname, err->message); ++ g_error_free (err); + } + + } +- if (ecount) +- GAM_DEBUG(DEBUG_INFO, "inotify: moved %d events to event queue\n", ecount); +-} + +-static gboolean +-gam_inotify_process_event_queue (gpointer data) +-{ +- /* Try and move as many events to the event queue */ +- gam_inotify_process_internal (); +- +- /* Send the events on the event queue to gam clients */ +- while (!g_queue_is_empty (event_queue)) ++ if (!was_missing) + { +- inotify_event_t *event = g_queue_pop_head (event_queue); +- g_assert (event); +- gam_inotify_process_event (event); +- gam_inotify_event_free (event); ++ gam_server_emit_one_event (pathname, is_dir ? 1 : 0, GAMIN_EVENT_ENDEXISTS, sub, 1); + } + +- return TRUE; +-} +- +-static gboolean +-gam_inotify_read_handler(gpointer user_data) +-{ +- gchar *buffer; +- gsize buffer_size, buffer_i, events; +- +- gam_inotify_read_events (&buffer_size, &buffer); +- +- buffer_i = 0; +- events = 0; +- while (buffer_i < buffer_size) +- { +- struct inotify_event *event; +- gsize event_size; +- event = (struct inotify_event *)&buffer[buffer_i]; +- event_size = sizeof(struct inotify_event) + event->len; +- g_queue_push_tail (events_to_process, gam_inotify_event_new (event)); +- buffer_i += event_size; +- events++; +- } +- +- GAM_DEBUG(DEBUG_INFO, "inotify recieved %d events\n", events); +- return TRUE; + } + + static void +-gam_inotify_send_initial_events (inotify_data_t *data, GamSubscription *sub) ++gam_inotify_event_callback (const char *fullpath, guint32 mask, void *subdata) + { ++ GamSubscription *sub = (GamSubscription *)subdata; + GaminEventType gevent; +- gboolean is_dir = FALSE; +- gboolean was_missing = data->missing; +- gboolean was_permission = data->permission; +- gboolean exists = FALSE; +-#if 0 +- gboolean watching_dir_as_file = data->dir && !gam_subscription_is_dir (sub); +-#endif +- gboolean watching_file_as_dir = FALSE; +- +- struct stat sb; +- memset(&sb, 0, sizeof (struct stat)); +- +- exists = lstat (data->path, &sb) >= 0; +- is_dir = (exists && (sb.st_mode & S_IFDIR) != 0) ? TRUE : FALSE; +- +- if (was_missing) { +- GAM_DEBUG (DEBUG_INFO, "inotify: Sending initial events for %s -- WAS_MISSING\n", data->path); +- } else if (was_permission) { +- GAM_DEBUG (DEBUG_INFO, "inotify: Sending initial events for %s -- WAS_PERMISSION\n", data->path); +- } else { +- GAM_DEBUG (DEBUG_INFO, "inotify: Sending initial events for %s\n", data->path); +- } +- +- if (data->wd >= 0) +- watching_file_as_dir = !data->dir && gam_subscription_is_dir (sub); +- else +- watching_file_as_dir = FALSE; +- +- if (!watching_file_as_dir && exists) +- { +- gevent = was_permission ? GAMIN_EVENT_EXISTS : was_missing ? GAMIN_EVENT_CREATED : GAMIN_EVENT_EXISTS; +- +- gam_server_emit_one_event (data->path, is_dir ? 1 : 0, gevent, sub, 1); + +- if (is_dir) +- { +- GDir *dir; +- GError *err = NULL; +- dir = g_dir_open (data->path, 0, &err); +- if (dir) +- { +- const char *filename; +- +- while ((filename = g_dir_read_name (dir))) +- { +- gchar *fullname = g_strdup_printf ("%s/%s", data->path, filename); +- gboolean file_is_dir = FALSE; +- struct stat fsb; +- memset(&fsb, 0, sizeof (struct stat)); +- lstat(fullname, &fsb); +- file_is_dir = (fsb.st_mode & S_IFDIR) != 0 ? TRUE : FALSE; +- gam_server_emit_one_event (fullname, file_is_dir ? 1 : 0, gevent, sub, 1); +- g_free (fullname); +- } +- +- g_dir_close (dir); +- } else { +- GAM_DEBUG (DEBUG_INFO, "unable to open directory %s: %s\n", data->path, err->message); +- g_error_free (err); +- } ++ gevent = ih_mask_to_EventType (mask); + +- } +- +- if (!was_missing) +- { +- gam_server_emit_one_event (data->path, is_dir ? 1 : 0, GAMIN_EVENT_ENDEXISTS, sub, 1); +- } +- +- } else { +- gam_server_emit_one_event (data->path, is_dir ? 1 : 0, GAMIN_EVENT_DELETED, sub, 1); +- gam_server_emit_one_event (data->path, is_dir ? 1 : 0, GAMIN_EVENT_ENDEXISTS, sub, 1); +- } ++ gam_server_emit_one_event (fullpath, gam_subscription_is_dir (sub), gevent, sub, 1); + } + + static void +-gam_inotify_send_initial_events_all (inotify_data_t *data) +-{ +- GList *l; +- +- if (!data) +- return; +- +- for (l = data->subs; l; l = l->next) { +- GamSubscription *sub = l->data; +- gam_inotify_send_initial_events (data, sub); +- } +- +-} +- +-/** +- * Adds a subscription to be monitored. +- * +- * @param sub a #GamSubscription to be polled +- * @returns TRUE if adding the subscription succeeded, FALSE otherwise +- */ +-gboolean +-gam_inotify_add_subscription(GamSubscription * sub) +-{ +- const char *path = gam_subscription_get_path (sub); +- inotify_data_t *data = g_hash_table_lookup (path_hash, path); +- int wd, err; +- +- +- if (data) +- { +- data->subs = g_list_prepend (data->subs, sub); +- data->refcount++; +- gam_inotify_send_initial_events (data, sub); +-#ifdef GAMIN_DEBUG_API +- gam_debug_report(GAMDnotifyChange, path, data->refcount); +-#endif +- gam_listener_add_subscription(gam_subscription_get_listener(sub), sub); +- return TRUE; +- } +- +- wd = gam_inotify_add_watch (path, GAM_INOTIFY_MASK, &err); +- if (wd < 0) { +- GAM_DEBUG (DEBUG_INFO, "inotify: could not add watch for %s\n", path); +- if (err == EACCES) { +- GAM_DEBUG (DEBUG_INFO, "inotify: adding %s to missing list PERM\n", path); +- } else { +- GAM_DEBUG (DEBUG_INFO, "inotify: adding %s to missing list MISSING\n", path); +- } +- data = gam_inotify_data_new (path, err == EACCES ? GAM_INOTIFY_WD_PERM : GAM_INOTIFY_WD_MISSING, FALSE); +- gam_inotify_add_missing (path, err == EACCES ? TRUE : FALSE); +- } else if (gam_inotify_is_link (path)) { +- /* The file turned out to be a link, cancel the watch, and add it to the links list */ +- gam_inotify_rm_watch (path, wd); +- GAM_DEBUG (DEBUG_INFO, "inotify: could not add watch for %s\n", path); +- GAM_DEBUG (DEBUG_INFO, "inotify: adding %s to links list\n", path); +- data = gam_inotify_data_new (path, GAM_INOTIFY_WD_LINK, FALSE); +- gam_inotify_add_link (path); +- } else { +- struct stat sbuf; +- memset(&sbuf, 0, sizeof (struct stat)); +- lstat (path, &sbuf); +- /* Just in case, +- * Clear this path off the missing list */ +- gam_inotify_rm_missing (path); +- data = gam_inotify_data_new (path, wd, sbuf.st_mode & S_IFDIR); +- g_hash_table_insert(wd_hash, GINT_TO_POINTER(data->wd), data); +- } +- +-#ifdef GAMIN_DEBUG_API +- gam_debug_report(GAMDnotifyCreate, path, 0); +-#endif +- gam_listener_add_subscription(gam_subscription_get_listener(sub), sub); +- +- g_hash_table_insert(path_hash, data->path, data); +- data->subs = g_list_prepend (data->subs, sub); +- gam_inotify_send_initial_events (data, sub); +- return TRUE; +-} +- +-/** +- * Removes a subscription which was being monitored. +- * +- * @param sub a #GamSubscription to remove +- * @returns TRUE if removing the subscription succeeded, FALSE otherwise +- */ +-gboolean +-gam_inotify_remove_subscription(GamSubscription * sub) ++gam_inotify_found_callback (const char *fullpath, void *subdata) + { +- const char *path = gam_subscription_get_path (sub); +- inotify_data_t *data = g_hash_table_lookup (path_hash, path); +- +- g_assert (g_list_find (data->subs, sub)); +- +- data->subs = g_list_remove_all (data->subs, sub); +- data->refcount--; +- /* No one is watching this path anymore */ +- if (!data->subs && data->refcount == 0) +- { +- if (data->link) +- { +- g_assert (data->wd == GAM_INOTIFY_WD_LINK); +- g_assert (data->missing == FALSE && data->permission == FALSE); +- g_hash_table_remove (path_hash, data->path); +- gam_inotify_rm_link (data->path); +- } else if (data->missing) { +- g_assert (data->wd == GAM_INOTIFY_WD_MISSING); +- g_assert (data->link == FALSE && data->permission == FALSE); +- g_hash_table_remove (path_hash, data->path); +- gam_inotify_rm_missing (data->path); +- } else if (data->permission) { +- g_assert (data->wd == GAM_INOTIFY_WD_PERM); +- g_assert (data->link == FALSE && data->missing == FALSE); +- g_hash_table_remove (path_hash, data->path); +- gam_inotify_rm_missing (data->path); +- } else { +- g_hash_table_remove (wd_hash, GINT_TO_POINTER(data->wd)); +- g_hash_table_remove (path_hash, data->path); +- gam_inotify_rm_watch (data->path, data->wd); +- } +-#ifdef GAMIN_DEBUG_API +- gam_debug_report(GAMDnotifyDelete, path, 0); +-#endif +- gam_inotify_data_free (data); +- } else { +-#ifdef GAMIN_DEBUG_API +- gam_debug_report(GAMDnotifyChange, path, data->refcount); +-#endif +- } +- +- gam_subscription_cancel (sub); ++ GamSubscription *sub = (GamSubscription *)subdata; + +- return TRUE; ++ gam_inotify_send_initial_events (gam_subscription_get_path (sub), sub, gam_subscription_is_dir (sub), TRUE); + } + +-/** +- * Stop monitoring all subscriptions for a given listener. +- * +- * @param listener a #GamListener +- * @returns TRUE if removing the subscriptions succeeded, FALSE otherwise +- */ +-gboolean +-gam_inotify_remove_all_for(GamListener * listener) +-{ +- GList *subs; +- GList *l; +- gboolean success = TRUE; +- +- subs = gam_listener_get_subscriptions(listener); +- +- for (l = subs; l != NULL; l = l->next) +- if (!gam_inotify_remove_subscription(l->data)) +- success = FALSE; + +- g_list_free(subs); +- +- return success; +-} +- +-/** +- * Initializes the inotify backend. This must be called before +- * any other functions in this module. +- * +- * @returns TRUE if initialization succeeded, FALSE otherwise +- */ + gboolean +-gam_inotify_init(void) ++gam_inotify_init (void) + { +- GSource *source; +- +- inotify_device_fd = inotify_init (); +- +- if (inotify_device_fd < 0) { +- GAM_DEBUG(DEBUG_INFO, "Could not initialize inotify\n"); +- return FALSE; +- } +- +- inotify_read_ioc = g_io_channel_unix_new(inotify_device_fd); +- +- g_io_channel_set_encoding(inotify_read_ioc, NULL, NULL); +- 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_source_set_callback(source, gam_inotify_read_handler, NULL, NULL); +- g_source_attach(source, NULL); +- g_source_unref (source); +- g_timeout_add (SCAN_MISSING_TIME, gam_inotify_scan_missing, NULL); +- g_timeout_add (SCAN_LINKS_TIME, gam_inotify_scan_links, NULL); +- g_timeout_add (PROCESS_EVENTS_TIME, gam_inotify_process_event_queue, 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); +- cookie_hash = g_hash_table_new(g_direct_hash, g_direct_equal); +- event_queue = g_queue_new (); +- events_to_process = g_queue_new (); +- +- gam_poll_basic_init (); +- gam_server_install_kernel_hooks (GAMIN_K_INOTIFY2, ++ gam_server_install_kernel_hooks (GAMIN_K_INOTIFY2, + gam_inotify_add_subscription, + gam_inotify_remove_subscription, +- gam_inotify_remove_all_for, NULL, NULL); +- +- GAM_DEBUG(DEBUG_INFO, "inotify backend initialized\n"); +- +- +- return TRUE; +-} +- +-int gam_inotify_add_watch (const char *path, __u32 mask, int *err) +-{ +- int wd = -1; +- +- g_assert (path != NULL); +- g_assert (inotify_device_fd >= 0); +- +- wd = inotify_add_watch (inotify_device_fd, path, mask); +- +- if (wd < 0) +- { +- int e = errno; +- GAM_DEBUG (DEBUG_INFO, "inotify: failed to add watch for %s\n", path); +- GAM_DEBUG (DEBUG_INFO, "inotify: reason %d = %s\n", e, strerror (e)); +- if (err) +- *err = e; +- return wd; +- } +- else +- { +- GAM_DEBUG (DEBUG_INFO, "inotify: success adding watch for %s (wd = %d)\n", path, wd); +- } +- +- g_assert (wd >= 0); +- +- return wd; +-} +- +-int gam_inotify_rm_watch (const char *path, __u32 wd) +-{ +- g_assert (wd >= 0); +- +- if (inotify_rm_watch (inotify_device_fd, wd) < 0) +- { +- int e = errno; +- GAM_DEBUG (DEBUG_INFO, "inotify: failed to rm watch for %s (wd = %d)\n", path, wd); +- GAM_DEBUG (DEBUG_INFO, "inotify: reason = %s\n", strerror (e)); +- return -1; +- } +- else +- { +- GAM_DEBUG (DEBUG_INFO, "inotify: success removing watch for %s (wd = %d)\n", path, wd); +- } +- +- return 0; +-} +- +-/* Code below based on beagle inotify glue code. I assume it was written by Robert Love */ +-#define MAX_PENDING_COUNT 5 +-#define PENDING_THRESHOLD(qsize) ((qsize) >> 1) +-#define PENDING_MARGINAL_COST(p) ((unsigned int)(1 << (p))) +-#define MAX_QUEUED_EVENTS 8192 +-#define AVERAGE_EVENT_SIZE sizeof (struct inotify_event) + 16 +-#define PENDING_PAUSE_MICROSECONDS 8000 +- +-void gam_inotify_read_events (gsize *buffer_size_out, gchar **buffer_out) +-{ +- static int prev_pending = 0, pending_count = 0; +- static gchar *buffer = NULL; +- static gsize buffer_size; +- +- +- /* Initialize the buffer on our first read() */ +- if (buffer == NULL) +- { +- buffer_size = AVERAGE_EVENT_SIZE; +- buffer_size *= MAX_QUEUED_EVENTS; +- buffer = g_malloc (buffer_size); +- +- if (!buffer) { +- *buffer_size_out = 0; +- *buffer_out = NULL; +- GAM_DEBUG (DEBUG_INFO, "inotify: could not allocate read buffer\n"); +- return; +- } +- } +- +- *buffer_size_out = 0; +- *buffer_out = NULL; +- +- while (pending_count < MAX_PENDING_COUNT) { +- unsigned int pending; +- +- if (ioctl (inotify_device_fd, FIONREAD, &pending) == -1) +- break; +- +- pending /= AVERAGE_EVENT_SIZE; +- +- /* Don't wait if the number of pending events is too close +- * to the maximum queue size. +- */ +- +- if (pending > PENDING_THRESHOLD (MAX_QUEUED_EVENTS)) +- break; +- +- /* With each successive iteration, the minimum rate for +- * further sleep doubles. */ +- +- if (pending-prev_pending < PENDING_MARGINAL_COST(pending_count)) +- break; +- +- prev_pending = pending; +- pending_count++; +- +- /* We sleep for a bit and try again */ +- g_usleep (PENDING_PAUSE_MICROSECONDS); +- } +- +- memset(buffer, 0, buffer_size); +- +- if (g_io_channel_read_chars (inotify_read_ioc, (char *)buffer, buffer_size, buffer_size_out, NULL) != G_IO_STATUS_NORMAL) { +- GAM_DEBUG (DEBUG_INFO, "inotify: failed to read from buffer\n"); +- } +- *buffer_out = buffer; +- +- prev_pending = 0; +- pending_count = 0; +-} +- +-gboolean gam_inotify_is_missing (const char *path) +-{ +- struct stat sbuf; +- +- /* If the file doesn't exist, it is missing. */ +- if (lstat (path, &sbuf) < 0) +- return TRUE; +- +- /* If we can't read the file, it is missing. */ +- if (access (path, R_OK) < 0) +- return TRUE; +- +- return FALSE; +-} +- +-static gint missing_list_compare (gconstpointer a, gconstpointer b) +-{ +- const inotify_missing_t *missing = NULL; ++ gam_inotify_remove_all_for, ++ NULL, NULL); + +- g_assert (a); +- g_assert (b); +- missing = a; +- g_assert (missing->path); +- +- return strcmp (missing->path, b); +-} +- +-static void gam_inotify_add_missing (const char *path, gboolean perm) +-{ +- inotify_missing_t *missing = NULL; +- +- g_assert (path); +- +- missing = g_new0 (inotify_missing_t, 1); +- +- g_assert (missing); +- +- missing->path = g_strdup (path); +- missing->scan_interval = gam_fs_get_poll_timeout (path); +- missing->last_scan_time = time (NULL); +- missing->permission = perm; +- +- GAM_DEBUG (DEBUG_INFO, "inotify-missing: add - %s\n", path); +- +- missing_list = g_list_prepend (missing_list, missing); +-} +- +-static void gam_inotify_rm_missing (const char *path) +-{ +- GList *node = NULL; +- inotify_missing_t *missing = NULL; +- +- g_assert (path && *path); +- +- node = g_list_find_custom (missing_list, path, missing_list_compare); +- +- if (!node) +- return; +- +- GAM_DEBUG (DEBUG_INFO, "inotify-missing: rm - %s\n", path); +- missing = node->data; +- g_free (missing->path); +- g_free (missing); +- +- missing_list = g_list_remove_link (missing_list, node); +-} +- +-static gboolean gam_inotify_nolonger_missing (const char *path) +-{ +- int wd = -1, err; +- inotify_data_t *data = NULL; +- struct stat sbuf; +- memset(&sbuf, 0, sizeof (struct stat)); +- +- data = g_hash_table_lookup (path_hash, path); +- if (!data) { +- GAM_DEBUG (DEBUG_INFO, "inotify: Could not find missing %s in hash table.\n", path); +- return FALSE; +- } +- +- g_assert ((data->missing == TRUE || data->permission == TRUE) && data->link == FALSE); +- +- wd = gam_inotify_add_watch (path, GAM_INOTIFY_MASK,&err); +- if (wd < 0) { +- /* Check if we don't have access to the new file */ +- if (err == EACCES) +- { +- data->wd = GAM_INOTIFY_WD_PERM; +- data->permission = TRUE; +- data->missing = FALSE; +- } else { +- data->wd = GAM_INOTIFY_WD_MISSING; +- data->permission = FALSE; +- data->missing = TRUE; +- } +- return FALSE; +- } else if (gam_inotify_is_link (path)) { +- GAM_DEBUG(DEBUG_INFO, "inotify: Missing resource %s exists now BUT IT IS A LINK\n", path); +- /* XXX: See NOTE1 */ +- if (g_hash_table_lookup (wd_hash, GINT_TO_POINTER(wd)) == NULL) +- gam_inotify_rm_watch (path, wd); +- data->missing = FALSE; +- data->permission = FALSE; +- data->link = TRUE; +- data->wd = GAM_INOTIFY_WD_LINK; +- gam_inotify_add_link (path); +- gam_inotify_send_initial_events_all (data); +- return TRUE; +- } +- +- +- GAM_DEBUG(DEBUG_INFO, "inotify: Missing resource %s exists now\n", path); +- +- lstat (path, &sbuf); +- data->dir = (sbuf.st_mode & S_IFDIR); +- data->wd = wd; +- g_hash_table_insert(wd_hash, GINT_TO_POINTER(data->wd), data); +- gam_inotify_send_initial_events_all (data); +- data->missing = FALSE; +- data->permission = FALSE; +- +- return TRUE; ++ return ih_startup (gam_inotify_event_callback, ++ gam_inotify_found_callback); + } + +-/* This function is called once per second in the main loop*/ +-static gboolean gam_inotify_scan_missing (gpointer userdata) ++gboolean ++gam_inotify_add_subscription (GamSubscription *sub) + { +- guint i; ++ ih_sub_t *isub = NULL; ++ isub = ih_sub_new (gam_subscription_get_path (sub), gam_subscription_is_dir (sub), 0, sub); + +- gam_inotify_sanity_check (); +- /* We have to walk the list like this because entries might be removed while we walk the list */ +- for (i = 0; ; i++) ++ if (!ih_sub_add (isub)) + { +- inotify_missing_t *missing = g_list_nth_data (missing_list, i); +- +- if (!missing) +- break; +- +- /* Not enough time has passed since the last scan */ +- if (time(NULL) - missing->last_scan_time < missing->scan_interval) +- continue; +- +- missing->last_scan_time = time(NULL); +- if (!gam_inotify_is_missing (missing->path)) +- { +- if (gam_inotify_nolonger_missing (missing->path)) +- { +-#ifdef GAMIN_DEBUG_API +- gam_debug_report(GAMDnotifyCreate, missing->path, 0); +-#endif +- gam_inotify_rm_missing (missing->path); +- } +- } +- } +- +- gam_inotify_sanity_check (); +- return TRUE; +-} +- +- +-static gboolean +-gam_inotify_is_link (const char *path) +-{ +- struct stat sbuf; +- +- if (lstat(path, &sbuf) < 0) +- return FALSE; +- +- return S_ISLNK(sbuf.st_mode) != 0; +-} +- +-static gboolean +-gam_inotify_nolonger_link (const char *path) +-{ +- int wd = -1, err; +- inotify_data_t *data = NULL; +- struct stat sbuf; +- memset(&sbuf, 0, sizeof (struct stat)); +- +- GAM_DEBUG(DEBUG_INFO, "inotify: link resource %s no longer a link\n", path); +- data = g_hash_table_lookup (path_hash, path); +- if (!data) { +- GAM_DEBUG (DEBUG_INFO, "inotify: Could not find link %s in hash table.\n", path); ++ ih_sub_free (isub); + return FALSE; + } + +- g_assert (data->link == TRUE && data->missing == FALSE && data->permission == FALSE); +- +- wd = gam_inotify_add_watch (path, GAM_INOTIFY_MASK, &err); +- if (wd < 0) { +- /* The file must not exist anymore, so we add it to the missing list */ +- data->link = FALSE; +- /* Check if we don't have access to the new file */ +- if (err == EACCES) +- { +- data->wd = GAM_INOTIFY_WD_PERM; +- data->permission = TRUE; +- data->missing = FALSE; +- } else { +- data->wd = GAM_INOTIFY_WD_MISSING; +- data->permission = FALSE; +- data->missing = TRUE; +- } +- +- gam_server_emit_event (path, data->dir, GAMIN_EVENT_DELETED, data->subs, 1); +- gam_inotify_add_missing (path, data->permission); +- return TRUE; +- } else if (gam_inotify_is_link (path)) { +- GAM_DEBUG(DEBUG_INFO, "inotify: Link resource %s re-appeared as a link...\n", path); +- /* NOTE1: This is tricky, because inotify works on the inode level and +- * we are dealing with a link, we can be watching the same inode +- * from two different paths (the wd's will be the same). So, +- * if the wd isn't in the hash table, we can remvoe the watch, +- * otherwise we just leave the watch. This should probably be +- * handled by ref counting +- */ +- if (g_hash_table_lookup (wd_hash, GINT_TO_POINTER(wd)) == NULL) +- gam_inotify_rm_watch (path, wd); +- data->missing = FALSE; +- data->permission = FALSE; +- data->link = TRUE; +- data->wd = GAM_INOTIFY_WD_LINK; +- gam_inotify_send_initial_events_all (data); +- return FALSE; +- } ++ gam_inotify_send_initial_events (gam_subscription_get_path (sub), sub, gam_subscription_is_dir (sub), FALSE); + +- lstat (path, &sbuf); +- data->dir = (sbuf.st_mode & S_IFDIR); +- data->wd = wd; +- g_hash_table_insert(wd_hash, GINT_TO_POINTER(data->wd), data); +- gam_inotify_send_initial_events_all (data); +- data->missing = FALSE; +- data->permission = FALSE; + return TRUE; + } + +-static gint links_list_compare (gconstpointer a, gconstpointer b) +-{ +- const inotify_links_t *links = NULL; +- +- g_assert (a); +- g_assert (b); +- links = a; +- g_assert (links->path); +- +- return strcmp (links->path, b); +-} +- +-static void +-gam_inotify_add_link (const char *path) +-{ +- inotify_links_t *links = NULL; +- struct stat sbuf; +- +- g_assert (path); +- +- links = g_new0 (inotify_links_t, 1); +- +- g_assert (links); +- +- GAM_DEBUG (DEBUG_INFO, "inotify-link: add - %s\n", path); +- links->path = g_strdup (path); +- links->scan_interval = gam_fs_get_poll_timeout (path); +- links->last_scan_time = 0; +- lstat(path, &sbuf); +- links->sbuf = sbuf; +- links_list = g_list_prepend (links_list, links); +-} +- +-static void +-gam_inotify_rm_link (const char *path) ++static gboolean ++gam_inotify_remove_sub_pred (ih_sub_t *sub, void *callerdata) + { +- GList *node = NULL; +- inotify_links_t *links = NULL; +- +- g_assert (path && *path); +- +- node = g_list_find_custom (links_list, path, links_list_compare); +- +- if (!node) +- return; +- +- GAM_DEBUG (DEBUG_INFO, "inotify-link: rm - %s\n", path); +- links = node->data; +- g_free (links->path); +- g_free (links); +- +- links_list = g_list_remove_link (links_list, node); +- ++ return sub->usersubdata == callerdata; + } + +-static gboolean +-gam_inotify_scan_links (gpointer userdata) ++gboolean ++gam_inotify_remove_subscription (GamSubscription *sub) + { +- guint i; +- +- gam_inotify_sanity_check (); +- /* We have to walk the list like this because entries might be removed while we walk the list */ +- for (i = 0; ; i++) +- { +- inotify_links_t *links = g_list_nth_data (links_list, i); +- +- if (!links) +- break; +- +- /* Not enough time has passed since the last scan */ +- if (time(NULL) - links->last_scan_time < links->scan_interval) +- continue; +- +- links->last_scan_time = time(NULL); +- if (!gam_inotify_is_link (links->path)) +- { +- if (gam_inotify_nolonger_link (links->path)) +- { +- gam_inotify_rm_link (links->path); +- } +- } else { +- gam_inotify_poll_link (links); +- } +- +- } ++ ih_sub_foreach_free (sub, gam_inotify_remove_sub_pred); + +- gam_inotify_sanity_check (); + return TRUE; + } + + static gboolean +-gam_inotify_stat_changed (struct stat sbuf1, struct stat sbuf2) +-{ +-#ifdef ST_MTIM_NSEC +- return ((sbuf1.st_mtim.tv_sec != sbuf2.st_mtim.tv_sec) || +- (sbuf1.st_mtim.tv_nsec != sbuf2.st_mtim.tv_nsec) || +- (sbuf1.st_size != sbuf2.st_size) || +- (sbuf1.st_ctim.tv_sec != sbuf2.st_ctim.tv_sec) || +- (sbuf1.st_ctim.tv_nsec != sbuf2.st_ctim.tv_nsec)); +-#else +- return ((sbuf1.st_mtime != sbuf2.st_mtime) || +- (sbuf1.st_size != sbuf2.st_size) || +- (sbuf1.st_ctime != sbuf2.st_ctime)); +-#endif +-} +- +-static void +-gam_inotify_poll_link (inotify_links_t *links) +-{ +- struct stat sbuf; +- g_assert (links); +- +- /* Next time around, we will detect the deletion, and send the event */ +- if (lstat (links->path, &sbuf) < 0) +- return; +- +- if (gam_inotify_stat_changed (sbuf, links->sbuf)) +- { +- inotify_data_t *data = g_hash_table_lookup (path_hash, links->path); +- g_assert (data); +- gam_server_emit_event (data->path, data->dir, GAMIN_EVENT_CHANGED, data->subs, 1); +- } +- +- links->sbuf = sbuf; +-} +- +-static void +-gam_inotify_wd_check (gpointer key, gpointer value, gpointer user_data) +-{ +- gint wd = GPOINTER_TO_INT(key); +- inotify_data_t *data = (inotify_data_t *)value; +- if (wd < 0) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: FAILURE wd hash for %s key < 0\n", data->path); +- } +- if (data->wd < 0) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: FAILURE wd hash for %s value < 0\n", data->path); +- } +- if (data->wd != wd) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: FAILURE wd hash value & key don't match\n"); +- } +-} +- +-static void +-gam_inotify_wd_hash_sanity_check (void) +-{ +- g_hash_table_foreach (wd_hash, gam_inotify_wd_check, NULL); +-} +- +-static void +-gam_inotify_missing_check (gpointer data, gpointer user_data) ++gam_inotify_remove_listener_pred (ih_sub_t *sub, void *callerdata) + { +- inotify_missing_t *missing = data; +- inotify_data_t *idata = NULL; +- +- if (!missing) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: Missing check called with NULL argument\n"); +- return; +- } +- +- if (!missing->path) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: Missing entry missing path name\n"); +- return; +- } +- +- idata = g_hash_table_lookup (path_hash, missing->path); +- +- if (!idata) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: Could not find %s in path hash table\n", missing->path); +- return; +- } +- +- if (idata->wd != GAM_INOTIFY_WD_MISSING && idata->wd != GAM_INOTIFY_WD_PERM) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: data->wd != GAM_INOTIFY_WD_(MISSING/PERM) for path in missing list\n"); +- return; +- } +- +- if (idata->missing != TRUE && idata->permission != TRUE) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: data->missing/permission != TRUE for path in missing list\n"); +- return; +- } +- +- if (idata->missing == TRUE && idata->wd != GAM_INOTIFY_WD_MISSING) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: data->missing == TRUE && idata->wd != GAM_INOTIFY_WD_MISSING\n"); +- return; +- } +- +- if (idata->permission == TRUE && idata->wd != GAM_INOTIFY_WD_PERM) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: data->permission == TRUE && idata->wd != GAM_INOTIFY_WD_PERM\n"); +- return; +- } ++ GamSubscription *gsub = (GamSubscription *)sub->usersubdata; + +- if (idata->wd == GAM_INOTIFY_WD_MISSING && idata->missing != TRUE) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: data->missing == FALSE && idata->wd == GAM_INOTIFY_WD_MISSING\n"); +- return; +- } +- +- if (idata->wd == GAM_INOTIFY_WD_PERM && idata->permission != TRUE) +- { +- GAM_DEBUG (DEBUG_INFO, "inotify-sanity: data->permission != TRUE && idata->wd == GAM_INOTIFY_WD_PERM\n"); +- return; +- } ++ return gam_subscription_get_listener (gsub) == callerdata; + } + +-static void +-gam_inotify_missing_list_sanity_check (void) ++gboolean ++gam_inotify_remove_all_for (GamListener *listener) + { +- g_list_foreach (missing_list, gam_inotify_missing_check, NULL); +-} +- ++ ih_sub_foreach_free (listener, gam_inotify_remove_listener_pred); + +-static void +-gam_inotify_sanity_check (void) +-{ +-#ifdef GAM_INOTIFY_SANITY +- gam_inotify_wd_hash_sanity_check (); +- gam_inotify_missing_list_sanity_check (); +-#endif ++ return TRUE; + } + +-static gboolean +-g_timeval_lt(GTimeVal *val1, GTimeVal *val2) ++void ++gam_inotify_debug (void) + { +- if (val1->tv_sec < val2->tv_sec) +- return TRUE; +- +- if (val1->tv_sec > val2->tv_sec) +- return FALSE; +- +- /* val1->tv_sec == val2->tv_sec */ +- if (val1->tv_usec < val2->tv_usec) +- return TRUE; +- +- return FALSE; ++ id_dump (NULL); + } + +-static gboolean +-g_timeval_eq(GTimeVal *val1, GTimeVal *val2) ++gboolean ++gam_inotify_is_running (void) + { +- return (val1->tv_sec == val2->tv_sec) && (val1->tv_usec == val2->tv_usec); ++ return ih_running (); + } +- +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-sub.c 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,121 @@ ++/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ ++ ++/* inotify-helper.c - Gnome VFS Monitor based on inotify. ++ ++ Copyright (C) 2006 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Authors: ++ John McCutchan <john@johnmccutchan.com> ++*/ ++ ++#include "config.h" ++#include <string.h> ++#include <glib.h> ++#include "gam_subscription.h" ++#include "inotify-sub.h" ++ ++static gboolean is_debug_enabled = FALSE; ++#define IS_W if (is_debug_enabled) g_warning ++ ++static void ih_sub_setup (ih_sub_t *sub); ++ ++ih_sub_t * ++ih_sub_new (const char *pathname, gboolean is_dir, guint32 flags, void *userdata) ++{ ++ ih_sub_t *sub = NULL; ++ ++ sub = g_new0 (ih_sub_t, 1); ++ sub->usersubdata = userdata; ++ sub->is_dir = is_dir; ++ sub->extra_flags = flags; ++ sub->pathname = g_strdup (pathname); ++ ++ IS_W("new subscription for %s being setup\n", sub->pathname); ++ ++ ih_sub_setup (sub); ++ return sub; ++} ++ ++void ++ih_sub_free (ih_sub_t *sub) ++{ ++ if (sub->filename) ++ g_free (sub->filename); ++ if (sub->dirname) ++ g_free (sub->dirname); ++ g_free (sub->pathname); ++ g_free (sub); ++} ++ ++static ++gchar *ih_sub_get_dirname (gchar *pathname) ++{ ++ return g_path_get_dirname (pathname); ++} ++ ++static ++gchar *ih_sub_get_filename (gchar *pathname) ++{ ++ gchar *out; ++ // FIXME: return filename here ++ return out; ++} ++ ++static ++void ih_sub_fix_dirname (ih_sub_t *sub) ++{ ++ size_t len = 0; ++ ++ g_assert (sub->dirname); ++ ++ len = strlen (sub->dirname); ++ ++ /* We need to strip a trailing slash ++ * to get the correct behaviour ++ * out of the kernel ++ */ ++ if (sub->dirname[len] == '/') ++ sub->dirname[len] = '\0'; ++} ++ ++/* ++ * XXX: Currently we just follow the gnome vfs monitor type flags when ++ * deciding how to treat the path. In the future we could try ++ * and determine whether the path points to a directory or a file but ++ * that is racey. ++ */ ++static void ++ih_sub_setup (ih_sub_t *sub) ++{ ++ if (sub->is_dir) ++ { ++ sub->dirname = g_strdup (sub->pathname); ++ sub->filename = NULL; ++ } else { ++ sub->dirname = ih_sub_get_dirname (sub->pathname); ++ sub->filename = ih_sub_get_filename (sub->pathname); ++ } ++ ++ ih_sub_fix_dirname (sub); ++ ++ IS_W("sub->dirname = %s\n", sub->dirname); ++ if (sub->filename) ++ { ++ IS_W("sub->filename = %s\n", sub->filename); ++ } ++} +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-helper.c 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,234 @@ ++/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ ++ ++/* inotify-helper.c - Gnome VFS Monitor based on inotify. ++ ++ Copyright (C) 2005 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Authors: ++ John McCutchan <john@johnmccutchan.com> ++*/ ++ ++#include "config.h" ++#include <errno.h> ++#include <time.h> ++#include <string.h> ++#include <sys/ioctl.h> ++/* Just include the local header to stop all the pain */ ++#include "local_inotify.h" ++#if 0 ++#ifdef HAVE_SYS_INOTIFY_H ++/* We don't actually include the libc header, because there has been ++ * problems with libc versions that was built without inotify support. ++ * Instead we use the local version. ++ */ ++#include "local_inotify.h" ++#elif defined (HAVE_LINUX_INOTIFY_H) ++#include <linux/inotify.h> ++#endif ++#endif ++#include "inotify-helper.h" ++#include "inotify-missing.h" ++#include "inotify-path.h" ++#include "inotify-diag.h" ++ ++static gboolean ih_debug_enabled = FALSE; ++#define IH_W if (ih_debug_enabled) g_warning ++ ++static void ih_event_callback (ik_event_t *event, ih_sub_t *sub); ++static void ih_found_callback (ih_sub_t *sub); ++ ++/* We share this lock with inotify-kernel.c and inotify-missing.c ++ * ++ * inotify-kernel.c takes the lock when it reads events from ++ * the kernel and when it processes those events ++ * ++ * inotify-missing.c takes the lock when it is scanning the missing ++ * list. ++ * ++ * We take the lock in all public functions ++ */ ++G_LOCK_DEFINE (inotify_lock); ++static GList *sub_list = NULL; ++static gboolean initialized = FALSE; ++static event_callback_t user_ecb = NULL; ++static found_callback_t user_fcb = NULL; ++ ++/** ++ * Initializes the inotify backend. This must be called before ++ * any other functions in this module. ++ * ++ * @returns TRUE if initialization succeeded, FALSE otherwise ++ */ ++gboolean ++ih_startup (event_callback_t ecb, ++ found_callback_t fcb) ++{ ++ static gboolean result = FALSE; ++ ++ G_LOCK(inotify_lock); ++ ++ if (initialized == TRUE) { ++ G_UNLOCK(inotify_lock); ++ return result; ++ } ++ ++ initialized = TRUE; ++ ++ result = ip_startup (ih_event_callback); ++ if (!result) { ++ g_warning( "Could not initialize inotify\n"); ++ G_UNLOCK(inotify_lock); ++ return FALSE; ++ } ++ user_ecb = ecb; ++ user_fcb = fcb; ++ im_startup (ih_found_callback); ++ id_startup (); ++ ++ IH_W ("started gnome-vfs inotify backend\n"); ++ ++ G_UNLOCK(inotify_lock); ++ return TRUE; ++} ++ ++gboolean ++ih_running (void) ++{ ++ return initialized; ++} ++ ++/** ++ * Adds a subscription to be monitored. ++ */ ++gboolean ++ih_sub_add (ih_sub_t * sub) ++{ ++ G_LOCK(inotify_lock); ++ ++ g_assert (g_list_find (sub_list, sub) == NULL); ++ ++ // make sure that sub isn't on sub_list first. ++ if (!ip_start_watching (sub)) ++ { ++ im_add (sub); ++ } ++ ++ sub_list = g_list_prepend (sub_list, sub); ++ ++ G_UNLOCK(inotify_lock); ++ return TRUE; ++} ++ ++/** ++ * Cancels a subscription which was being monitored. ++ */ ++gboolean ++ih_sub_cancel (ih_sub_t * sub) ++{ ++ G_LOCK(inotify_lock); ++ ++ ++ if (!sub->cancelled) ++ { ++ IH_W("cancelling %s\n", sub->pathname); ++ g_assert (g_list_find (sub_list, sub) != NULL); ++ sub->cancelled = TRUE; ++ im_rm (sub); ++ ip_stop_watching (sub); ++ sub_list = g_list_remove (sub_list, sub); ++ } ++ ++ G_UNLOCK(inotify_lock); ++ return TRUE; ++} ++ ++static void ++ih_sub_foreach_worker (void *callerdata, gboolean (*f)(ih_sub_t *sub, void *callerdata), gboolean free) ++{ ++ GList *l = NULL; ++ GList *removed = NULL; ++ ++ G_LOCK(inotify_lock); ++ ++ for (l = sub_list; l; l = l->next) ++ { ++ ih_sub_t *sub = l->data; ++ ++ if (f(sub, callerdata)) ++ { ++ removed = g_list_prepend (removed, l); ++ ih_sub_cancel (sub); ++ if (free) ++ ih_sub_free (sub); ++ } ++ } ++ ++ for (l = removed; l ; l = l->next) ++ { ++ GList *llink = l->data; ++ sub_list = g_list_remove_link (sub_list, llink); ++ g_list_free_1 (llink); ++ } ++ ++ G_UNLOCK(inotify_lock); ++} ++ ++void ++ih_sub_foreach (void *callerdata, gboolean (*f)(ih_sub_t *sub, void *callerdata)) ++{ ++ ih_sub_foreach_worker (callerdata, f, FALSE); ++} ++ ++void ++ih_sub_foreach_free (void *callerdata, gboolean (*f)(ih_sub_t *sub, void *callerdata)) ++{ ++ ih_sub_foreach_worker (callerdata, f, TRUE); ++} ++ ++static void ih_event_callback (ik_event_t *event, ih_sub_t *sub) ++{ ++ gchar *fullpath; ++ if (event->name) ++ { ++ fullpath = g_strdup_printf ("%s/%s", sub->dirname, event->name); ++ } else { ++ fullpath = g_strdup_printf ("%s/", sub->dirname); ++ } ++ ++ user_ecb (fullpath, event->mask, sub->usersubdata); ++ g_free(fullpath); ++} ++ ++static void ih_found_callback (ih_sub_t *sub) ++{ ++ gchar *fullpath; ++ ++ if (sub->filename) ++ { ++ fullpath = g_strdup_printf ("%s/%s", sub->dirname, sub->filename); ++ if (!g_file_test (fullpath, G_FILE_TEST_EXISTS)) { ++ g_free (fullpath); ++ return; ++ } ++ } else { ++ fullpath = g_strdup_printf ("%s/", sub->dirname); ++ } ++ ++ user_fcb (fullpath, sub->usersubdata); ++ g_free(fullpath); ++} +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-diag.c 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,67 @@ ++/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ ++ ++/* inotify-helper.c - Gnome VFS Monitor based on inotify. ++ ++ Copyright (C) 2005 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Authors: ++ John McCutchan <john@johnmccutchan.com> ++*/ ++ ++#include "config.h" ++#include <glib.h> ++#include <sys/types.h> ++#include <unistd.h> ++#include "inotify-missing.h" ++#include "inotify-path.h" ++#include "inotify-diag.h" ++ ++#define DIAG_DUMP_TIME 20000 /* 20 seconds */ ++G_LOCK_EXTERN (inotify_lock); ++ ++gboolean id_dump (gpointer userdata) ++{ ++ G_LOCK (inotify_lock); ++ GIOChannel *ioc = NULL; ++ pid_t pid = getpid(); ++ char *fname = g_strdup_printf("/tmp/gvfsid.%d", pid); ++ ioc = g_io_channel_new_file (fname, "w", NULL); ++ g_free (fname); ++ if (!ioc) ++ { ++ G_UNLOCK (inotify_lock); ++ return TRUE; ++ } ++ ++ im_diag_dump (ioc); ++ ++ g_io_channel_shutdown (ioc, TRUE, NULL); ++ g_io_channel_unref (ioc); ++ G_UNLOCK (inotify_lock); ++ return TRUE; ++} ++ ++void id_startup () ++{ ++ if (!g_getenv ("GNOME_VFS_INOTIFY_DIAG")) ++ { ++ return; ++ } ++ ++ g_timeout_add (DIAG_DUMP_TIME, id_dump, NULL); ++} +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-path.h 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,27 @@ ++/* ++ Copyright (C) 2006 John McCutchan <john@johnmccutchan.com> ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; version 2. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License version 2 for more details. ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software Foundation, ++ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++*/ ++ ++#ifndef __INOTIFY_PATH_H ++#define __INOTIFY_PATH_H ++ ++#include "inotify-kernel.h" ++#include "inotify-sub.h" ++ ++gboolean ip_startup (void (*event_cb)(ik_event_t *event, ih_sub_t *sub)); ++gboolean ip_start_watching (ih_sub_t *sub); ++gboolean ip_stop_watching (ih_sub_t *sub); ++ ++#endif +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-path.c 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,387 @@ ++/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ ++ ++/* inotify-helper.c - Gnome VFS Monitor based on inotify. ++ ++ Copyright (C) 2006 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Authors: ++ John McCutchan <john@johnmccutchan.com> ++*/ ++ ++#include "config.h" ++ ++/* Don't put conflicting kernel types in the global namespace: */ ++#define __KERNEL_STRICT_NAMES ++ ++#include "local_inotify.h" ++#if 0 ++#ifdef HAVE_SYS_INOTIFY_H ++/* We don't actually include the libc header, because there has been ++ * problems with libc versions that was built without inotify support. ++ * Instead we use the local version. ++ */ ++#include "local_inotify.h" ++#elif defined (HAVE_LINUX_INOTIFY_H) ++#include <linux/inotify.h> ++#endif ++#endif ++#include <string.h> ++#include <glib.h> ++#include "inotify-kernel.h" ++#include "inotify-path.h" ++#include "inotify-missing.h" ++ ++#define IP_INOTIFY_MASK (IN_MODIFY|IN_ATTRIB|IN_MOVED_FROM|IN_MOVED_TO|IN_DELETE|IN_CREATE|IN_DELETE_SELF|IN_UNMOUNT|IN_MOVE_SELF) ++ ++typedef struct ip_watched_dir_s { ++ char *path; ++ /* TODO: We need to maintain a tree of watched directories ++ * so that we can deliver move/delete events to sub folders. ++ * Or the application could do it... ++ */ ++ struct ip_watched_dir_s *parent; ++ GList * children; ++ ++ /* Inotify state */ ++ gint32 wd; ++ ++ /* List of inotify subscriptions */ ++ GList *subs; ++} ip_watched_dir_t; ++ ++static gboolean ip_debug_enabled = FALSE; ++#define IP_W if (ip_debug_enabled) g_warning ++ ++/* path -> ip_watched_dir */ ++static GHashTable * path_dir_hash = NULL; ++/* ih_sub_t * -> ip_watched_dir * ++ * ++ * Each subscription is attached to a watched directory or it is on ++ * the missing list ++ */ ++static GHashTable * sub_dir_hash = NULL; ++/* This hash holds GLists of ip_watched_dir_t *'s ++ * We need to hold a list because symbolic links can share ++ * the same wd ++ */ ++static GHashTable * wd_dir_hash = NULL; ++ ++static ip_watched_dir_t * ip_watched_dir_new (const char *path, int wd); ++static void ip_watched_dir_free (ip_watched_dir_t *dir); ++static void ip_event_callback (ik_event_t *event); ++ ++static void (*event_callback)(ik_event_t *event, ih_sub_t *sub); ++ ++gboolean ip_startup (void (*cb)(ik_event_t *event, ih_sub_t *sub)) ++{ ++ static gboolean initialized = FALSE; ++ static gboolean result = FALSE; ++ ++ if (initialized == TRUE) { ++ return result; ++ } ++ ++ initialized = TRUE; ++ event_callback = cb; ++ result = ik_startup (ip_event_callback); ++ ++ if (!result) { ++ return FALSE; ++ } ++ ++ path_dir_hash = g_hash_table_new(g_str_hash, g_str_equal); ++ sub_dir_hash = g_hash_table_new(g_direct_hash, g_direct_equal); ++ wd_dir_hash = g_hash_table_new(g_direct_hash, g_direct_equal); ++ ++ return TRUE; ++} ++ ++static void ++ip_map_path_dir (const char *path, ip_watched_dir_t *dir) ++{ ++ g_assert (path && dir); ++ g_hash_table_insert(path_dir_hash, dir->path, dir); ++} ++ ++static void ++ip_map_sub_dir (ih_sub_t *sub, ip_watched_dir_t *dir) ++{ ++ /* Associate subscription and directory */ ++ g_assert (dir && sub); ++ g_hash_table_insert (sub_dir_hash, sub, dir); ++ dir->subs = g_list_prepend (dir->subs, sub); ++} ++ ++static void ++ip_map_wd_dir (gint32 wd, ip_watched_dir_t *dir) ++{ ++ g_assert (wd >= 0 && dir); ++ GList *dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER(wd)); ++ dir_list = g_list_prepend (dir_list, dir); ++ g_hash_table_replace(wd_dir_hash, GINT_TO_POINTER(dir->wd), dir_list); ++} ++ ++gboolean ip_start_watching (ih_sub_t *sub) ++{ ++ gint32 wd; ++ int err; ++ ip_watched_dir_t *dir; ++ ++ g_assert (sub); ++ g_assert (!sub->cancelled); ++ g_assert (sub->dirname); ++ ++ IP_W("Starting to watch %s\n", sub->dirname); ++ dir = g_hash_table_lookup (path_dir_hash, sub->dirname); ++ if (dir) ++ { ++ IP_W("Already watching\n"); ++ goto out; ++ } ++ ++ IP_W("Trying to add inotify watch "); ++ wd = ik_watch (sub->dirname, IP_INOTIFY_MASK|IN_ONLYDIR|sub->extra_flags, &err); ++ if (wd < 0) ++ { ++ IP_W("Failed\n"); ++ return FALSE; ++ } else { ++ /* Create new watched directory and associate it with the ++ * wd hash and path hash ++ */ ++ IP_W("Success\n"); ++ dir = ip_watched_dir_new (sub->dirname, wd); ++ ip_map_wd_dir (wd, dir); ++ ip_map_path_dir (sub->dirname, dir); ++ } ++ ++out: ++ ip_map_sub_dir (sub, dir); ++ ++ return TRUE; ++} ++ ++static void ++ip_unmap_path_dir (const char *path, ip_watched_dir_t *dir) ++{ ++ g_assert (path && dir); ++ g_hash_table_remove (path_dir_hash, dir->path); ++} ++ ++static void ++ip_unmap_wd_dir (gint32 wd, ip_watched_dir_t *dir) ++{ ++ GList *dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER(wd)); ++ if (!dir_list) ++ return; ++ g_assert (wd >= 0 && dir); ++ dir_list = g_list_remove (dir_list, dir); ++ if (dir_list == NULL) { ++ g_hash_table_remove (wd_dir_hash, GINT_TO_POINTER(dir->wd)); ++ } else { ++ g_hash_table_replace (wd_dir_hash, GINT_TO_POINTER(dir->wd), dir_list); ++ } ++} ++ ++static void ++ip_unmap_wd (gint32 wd) ++{ ++ GList *dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER(wd)); ++ if (!dir_list) ++ return; ++ g_assert (wd >= 0); ++ g_hash_table_remove (wd_dir_hash, GINT_TO_POINTER(wd)); ++ g_list_free (dir_list); ++} ++ ++static void ++ip_unmap_sub_dir (ih_sub_t *sub, ip_watched_dir_t *dir) ++{ ++ g_assert (sub && dir); ++ g_hash_table_remove (sub_dir_hash, sub); ++ dir->subs = g_list_remove (dir->subs, sub); ++} ++ ++static void ++ip_unmap_all_subs (ip_watched_dir_t *dir) ++{ ++ GList *l = NULL; ++ ++ for (l = dir->subs; l; l = l->next) ++ { ++ ih_sub_t *sub = l->data; ++ g_hash_table_remove (sub_dir_hash, sub); ++ } ++ g_list_free (dir->subs); ++ dir->subs = NULL; ++} ++ ++gboolean ip_stop_watching (ih_sub_t *sub) ++{ ++ ip_watched_dir_t *dir = NULL; ++ ++ dir = g_hash_table_lookup (sub_dir_hash, sub); ++ if (!dir) { ++ return TRUE; ++ } ++ ++ ip_unmap_sub_dir (sub, dir); ++ ++ /* No one is subscribing to this directory any more */ ++ if (dir->subs == NULL) { ++ ik_ignore (dir->path, dir->wd); ++ ip_unmap_wd_dir (dir->wd, dir); ++ ip_unmap_path_dir (dir->path, dir); ++ ip_watched_dir_free (dir); ++ } ++ ++ return TRUE; ++} ++ ++ ++static ip_watched_dir_t * ++ip_watched_dir_new (const char *path, gint32 wd) ++{ ++ ip_watched_dir_t *dir = g_new0(ip_watched_dir_t, 1); ++ ++ dir->path = g_strdup(path); ++ dir->wd = wd; ++ ++ return dir; ++} ++ ++static void ++ip_watched_dir_free (ip_watched_dir_t * dir) ++{ ++ g_assert (dir->subs == 0); ++ g_free(dir->path); ++ g_free(dir); ++} ++ ++static void ip_wd_delete (gpointer data, gpointer user_data) ++{ ++ ip_watched_dir_t *dir = data; ++ GList *l = NULL; ++ ++ for (l = dir->subs; l; l = l->next) ++ { ++ ih_sub_t *sub = l->data; ++ ++ /* Add subscription to missing list */ ++ im_add (sub); ++ } ++ ip_unmap_all_subs (dir); ++ /* Unassociate the path and the directory */ ++ ip_unmap_path_dir (dir->path, dir); ++ ip_watched_dir_free (dir); ++} ++ ++static void ip_event_dispatch (GList *dir_list, GList *pair_dir_list, ik_event_t *event) ++{ ++ GList *dirl; ++ ++ if (!event) ++ return; ++ ++ /* TODO: ++ * ++ * Figure out how we will deliver move events ++ */ ++ for (dirl = dir_list; dirl; dirl = dirl->next) ++ { ++ GList *subl; ++ ip_watched_dir_t *dir = dirl->data; ++ ++ for (subl = dir->subs; subl; subl = subl->next) ++ { ++ ih_sub_t *sub = subl->data; ++ ++ /* If the event and the subscription have a filename ++ * they need to match before the event could be delivered. ++ */ ++ if (event->name && sub->filename) { ++ if (strcmp (event->name, sub->filename)) ++ continue; ++ /* If the event doesn't have a filename, but the subscription does ++ * we shouldn't deliever the event */ ++ } else if (sub->filename) ++ continue; ++ ++ event_callback (event, sub); ++ } ++ } ++ ++ if (!event->pair) ++ return; ++ ++ for (dirl = pair_dir_list; dirl; dirl = dirl->next) ++ { ++ GList *subl; ++ ip_watched_dir_t *dir = dirl->data; ++ ++ for (subl = dir->subs; subl; subl = subl->next) ++ { ++ ih_sub_t *sub = subl->data; ++ ++ /* If the event and the subscription have a filename ++ * they need to match before the event could be delivered. ++ */ ++ if (event->pair->name && sub->filename) { ++ if (strcmp (event->pair->name, sub->filename)) ++ continue; ++ /* If the event doesn't have a filename, but the subscription does ++ * we shouldn't deliever the event */ ++ } else if (sub->filename) ++ continue; ++ ++ event_callback (event->pair, sub); ++ } ++ } ++} ++ ++static void ++ip_event_callback (ik_event_t *event) ++{ ++ GList *dir_list = NULL; ++ GList *pair_dir_list = NULL; ++ ++ dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER(event->wd)); ++ ++ /* We can ignore IN_IGNORED events */ ++ if (event->mask & IN_IGNORED) { ++ ik_event_free (event); ++ return; ++ } ++ ++ if (event->pair) ++ pair_dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER(event->pair->wd)); ++ ++ if (event->mask & IP_INOTIFY_MASK) ++ ip_event_dispatch (dir_list, pair_dir_list, event); ++ ++ /* We have to manage the missing list when we get a DELETE event. */ ++ if (event->mask & IN_DELETE_SELF || event->mask & IN_MOVE_SELF) ++ { ++ /* Add all subscriptions to missing list */ ++ g_list_foreach (dir_list, ip_wd_delete, NULL); ++ /* Unmap all directories attached to this wd */ ++ ip_unmap_wd (event->wd); ++ } ++ ++ ik_event_free (event); ++} +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-helper.h 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,45 @@ ++/* inotify-helper.h - GNOME VFS Monitor using inotify ++ ++ Copyright (C) 2005 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Author: John McCutchan <john@johnmccutchan.com> ++*/ ++ ++ ++#ifndef __INOTIFY_HELPER_H ++#define __INOTIFY_HELPER_H ++ ++#include "inotify-sub.h" ++#include "inotify-kernel.h" ++ ++typedef void (*event_callback_t)(const char *fullpath, guint32 mask, void *subdata); ++typedef void (*found_callback_t)(const char *fullpath, void *subdata); ++ ++gboolean ih_startup (event_callback_t ecb, ++ found_callback_t fcb); ++gboolean ih_running (void); ++gboolean ih_sub_add (ih_sub_t *sub); ++gboolean ih_sub_cancel (ih_sub_t *sub); ++ ++/* Return FALSE from 'f' if the subscription should be cancelled */ ++void ih_sub_foreach (void *callerdata, gboolean (*f)(ih_sub_t *sub, void *callerdata)); ++ ++/* Return FALSE from 'f' if the subscription should be cancelled and free'd */ ++void ih_sub_foreach_free (void *callerdata, gboolean (*f)(ih_sub_t *sub, void *callerdata)); ++ ++#endif /* __INOTIFY_HELPER_H */ +--- /dev/null 2006-08-28 15:22:40.902752500 +0200 ++++ gamin-0.1.7/server/inotify-sub.h 2006-09-05 11:01:21.000000000 +0200 +@@ -0,0 +1,42 @@ ++/* inotify-helper.h - GNOME VFS Monitor using inotify ++ ++ Copyright (C) 2006 John McCutchan ++ ++ The Gnome Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Library General Public License as ++ published by the Free Software Foundation; either version 2 of the ++ License, or (at your option) any later version. ++ ++ The Gnome Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Library General Public License for more details. ++ ++ You should have received a copy of the GNU Library General Public ++ License along with the Gnome Library; see the file COPYING.LIB. If not, ++ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ Boston, MA 02111-1307, USA. ++ ++ Author: John McCutchan <john@johnmccutchan.com> ++*/ ++ ++ ++#ifndef __INOTIFY_SUB_H ++#define __INOTIFY_SUB_H ++ ++#include "gam_subscription.h" ++ ++typedef struct { ++ gboolean is_dir; ++ char *pathname; ++ char *dirname; ++ char *filename; ++ guint32 extra_flags; ++ gboolean cancelled; ++ void *usersubdata; ++} ih_sub_t; ++ ++ih_sub_t *ih_sub_new (const char *pathname, gboolean is_dir, guint32 flags, void *userdata); ++void ih_sub_free (ih_sub_t *sub); ++ ++#endif /* __INOTIFY_SUB_H */ +--- gamin-0.1.7/server/local_inotify.h.new-inotify-backend 2005-08-17 15:50:04.000000000 +0200 ++++ gamin-0.1.7/server/local_inotify.h 2006-09-05 11:01:21.000000000 +0200 +@@ -47,6 +47,9 @@ + #define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO) /* moves */ + + /* special flags */ ++#define IN_ONLYDIR 0x01000000 /* only watch the path if it is a directory */ ++#define IN_DONT_FOLLOW 0x02000000 /* don't follow a sym link */ ++#define IN_MASK_ADD 0x20000000 /* add to the mask of an already existing watch */ + #define IN_ISDIR 0x40000000 /* event occurred against dir */ + #define IN_ONESHOT 0x80000000 /* only send event once */ + |