Attachment #52612 for bug #79680

View | Details | Raw Unified | Return to bug 79680
Collapse All | Expand All





PORTNAME=	gamin
PORTVERSION=	0.0.26
PORTREVISION?=	10
CATEGORIES?=	devel
MASTER_SITES=	http://www.gnome.org/~veillard/gamin/sources/



CONFLICTS=	fam-[0-9]*

.if !defined(GAMIN_SLAVE)
OPTIONS=	KQUEUE "Enable the KQueue backend (UFS only)" on
.endif

.include <bsd.port.pre.mk>

.if !defined(GAMIN_SLAVE)
.if defined(WITHOUT_KQUEUE)
CONFIGURE_ARGS+=	--disable-kqueue
.else
CONFIGURE_ARGS+=	--enable-kqueue
.endif
.endif

post-patch:
	@${FIND} ${WRKSRC} -type f | ${XARGS} ${TOUCH} -f

.include <bsd.port.mk>




--- server/gam_kqueue.c.orig	Fri Apr  8 14:50:41 2005
+++ server/gam_kqueue.c	Fri Apr  8 14:51:01 2005
@@ -0,0 +1,690 @@
+/*
+ * Copyright (C) 2005 Joe Marcus Clarke <marcus@FreeBSD.org>
+ * Copyright (C) 2005 Jean-Yves Lefort <jylefort@brutele.be>

+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "config.h"
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include "gam_error.h"
+#include "gam_kqueue.h"
+#include "gam_tree.h"
+#include "gam_event.h"
+#include "gam_server.h"
+#include "gam_event.h"
+
+#define VN_NOTE_ALL	(NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | \
+			 NOTE_ATTRIB | NOTE_LINK | NOTE_RENAME | \
+			 NOTE_REVOKE)
+#define VN_NOTE_CHANGED	(NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_LINK)
+#define VN_NOTE_DELETED (NOTE_DELETE | NOTE_REVOKE)
+    GList *subs;
+    GSList *dirlist;
+} KQueueData;
+
+typedef struct
+{
+  gboolean	exists;
+  ino_t		ino;
+  mode_t	mode;
+  uid_t		uid;
+  gid_t		gid;
+  time_t	mtime;
+  time_t	ctime;
+  off_t		size;
+} MiniStat;
+
+typedef struct
+{
+  const char	*path;		/* belongs to the first sub in subs */
+  GList		*subs;
+  GSList	*files;		/* list of files in directory */
+  MiniStat	sb;		/* for poll */
+  int		fd;		/* for kqueue */
+  gboolean	isdir;		/* is a directory monitor? */
+} Monitor;
+
+static GSList *exist_list = NULL;
+
+typedef struct
+{
+  char		*pathname;
+  char		*filename;	/* pointer into pathname */
+  MiniStat	sb;
+} FileEntry;
+
+typedef struct
+{
+  GSourceFunc	func;
+  unsigned int	interval;
+  unsigned int	timeout_id;
+  GSList	*monitors;
+} Poller;
+
+static int kq = -1;
+
+static GHashTable *dir_hash = NULL;
+static GHashTable *file_hash = NULL;
+
+/*
+ * The poller monitoring file creations. Low usage is expected,
+ * therefore we set a small interval (one second).
+ */
+static gboolean gam_kqueue_missing_poll (gpointer user_data);
+static Poller missing_poller = { gam_kqueue_missing_poll, 1000, -1, NULL };
+
+/*
+ * The poller monitoring files not supported by kqueue (remote files,
+ * etc). Very low usage is expected, but since this poller is likely
+ * going to access the network, we set a medium interval (3 seconds).
+ */
+static gboolean gam_kqueue_unsupported_poll (gpointer user_data);
+static Poller unsupported_poller = { gam_kqueue_unsupported_poll, 3000, -1, NULL };
+
+/*
+ * The poller monitoring files inside monitored directories. Very high
+ * usage is expected (a mail checker monitoring a couple of large MH
+ * folders will lead to thousands of lstat() calls for each check),
+ * therefore we set a large interval (6 seconds, same as FAM's
+ * default).
+ */
+static gboolean gam_kqueue_dirs_poll (gpointer user_data);
+static Poller dirs_poller = { gam_kqueue_dirs_poll, 6000, -1, NULL };
+
+static void
+gam_kqueue_mini_lstat (const char *pathname, MiniStat *mini_sb)
+{
+  struct stat sb;
+  
+  if (lstat(pathname, &sb) < 0)
+    memset(mini_sb, 0, sizeof(*mini_sb));
+  else
+    {
+      mini_sb->exists = TRUE;
+      mini_sb->ino = sb.st_ino;
+      mini_sb->mode = sb.st_mode;
+      mini_sb->uid = sb.st_uid;
+      mini_sb->gid = sb.st_gid;
+      mini_sb->mtime = sb.st_mtime;
+      mini_sb->ctime = sb.st_ctime;
+      mini_sb->size = sb.st_size;
+    }
+}
+
+static FileEntry *
+gam_kqueue_file_entry_new (const char *path, const char *filename)
+{
+  FileEntry *entry;
+
+    fdata = g_new(FileData, 1);
+    fdata->pathname = g_build_filename(path, filename, NULL);
+    fdata->filename = strrchr(fdata->pathname, G_DIR_SEPARATOR);
+    fdata->filename = fdata->filename ? fdata->filename + 1 : fdata->pathname;
+    gam_kqueue_mini_stat(fdata->pathname, &fdata->sb);
+
+  entry = g_new(FileEntry, 1);
+  entry->pathname = g_build_filename(path, filename, NULL);
+  entry->filename = strrchr(entry->pathname, G_DIR_SEPARATOR);
+  entry->filename = entry->filename ? entry->filename + 1 : entry->pathname;
+  gam_kqueue_mini_lstat(entry->pathname, &entry->sb);
+  
+  return entry;
+}
+
+static void
+gam_kqueue_file_entry_free (FileEntry *entry)
+{
+  g_free(entry->pathname);
+  g_free(entry);
+}
+
+static gboolean
+gam_kqueue_differs (const MiniStat *sb1, const MiniStat *sb2)
+{
+  return sb1->mtime != sb2->mtime
+    || sb1->ctime != sb2->ctime
+    || sb1->size != sb2->size
+    || sb1->mode != sb2->mode
+    || sb1->uid != sb2->uid
+    || sb1->gid != sb2->gid
+    || sb1->ino != sb2->ino;
+    }
+    g_free(data);
+}
+
+static int
+gam_kqueue_files_find (const FileEntry *entry, const char *filename)
+{
+    return strcmp(entry->filename, filename);
+}
+
+static void
+gam_kqueue_poller_add_monitor (Poller *poller, Monitor *mon)
+{
+  if (! g_slist_find(poller->monitors, mon))
+    {
+      poller->monitors = g_slist_prepend(poller->monitors, mon);
+      if (poller->timeout_id == -1)
+	poller->timeout_id = g_timeout_add(poller->interval, poller->func, NULL);
+    G_LOCK(kqueue);
+
+    isdir = g_file_test(path, G_FILE_TEST_IS_DIR);
+    if (gam_subscription_is_dir(sub)) {
+        data = g_hash_table_lookup(dir_path_hash, path);
+    }
+    else {
+        data = g_hash_table_lookup(file_path_hash, path);
+    }
+}
+
+static void
+gam_kqueue_poller_remove_monitor (Poller *poller, Monitor *mon)
+{
+  poller->monitors = g_slist_remove(poller->monitors, mon);
+  if (! poller->monitors && poller->timeout_id != -1)
+    {
+      g_source_remove(poller->timeout_id);
+      poller->timeout_id = -1;
+	    data->subs = g_list_prepend(data->subs, sub);
+            G_UNLOCK(kqueue);
+	    GAM_DEBUG(DEBUG_INFO, "kqueue updated refcount\n");
+	    if (!was_missing) {
+	        gam_server_emit_event (path, isdir, GAMIN_EVENT_EXISTS, subs, 1);
+                gam_server_emit_event (path, isdir, GAMIN_EVENT_ENDEXISTS, subs, 1);
+	    }
+	    else {
+                gam_server_emit_event (path, isdir, GAMIN_EVENT_CREATED, subs, 1);
+	    }
+            return;
+        }
+
+	if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
+	    data = gam_kqueue_data_new(path, -1);
+	    data->subs = g_list_prepend(data->subs, sub);
+            exist_list = g_slist_append(exist_list, data);
+	    gam_server_emit_event (path, isdir, GAMIN_EVENT_DELETED, subs, 1);
+	    gam_server_emit_event (path, isdir, GAMIN_EVENT_ENDEXISTS, subs, 1);
+	    G_UNLOCK(kqueue);
+	    return;
+	}
+
+	fd = open(path, O_RDONLY);
+
+	if (fd < 0) {
+            G_UNLOCK(kqueue);
+	    return;
+	}
+
+        EV_SET(ev, fd, EVFILT_VNODE,
+            EV_ADD | EV_ENABLE | EV_CLEAR, VN_NOTE_ALL, 0, 0);
+        kevent(kq, ev, 1, NULL, 0, NULL);
+
+        data = gam_kqueue_data_new(path, fd);
+        data->subs = g_list_prepend(data->subs, sub);
+
+	if (!was_missing) {
+            gam_server_emit_event (path, isdir, GAMIN_EVENT_EXISTS, subs, 1);
+	}
+	else {
+            gam_server_emit_event (path, isdir, GAMIN_EVENT_CREATED, subs, 1);
+	}
+        if (gam_subscription_is_dir(sub) && isdir) {
+	    GDir *dir;
+
+            data->isdir = TRUE;
+	    data->dirlist = NULL;
+
+	    dir = g_dir_open(path, 0, NULL);
+	    if (dir) {
+	        const char *entry;
+
+		while ((entry = g_dir_read_name(dir))) {
+		    FileData *fdata;
+
+		    fdata = gam_kqueue_file_data_new(path, entry);
+		    data->dirlist = g_slist_prepend(data->dirlist, fdata);
+
+		    if (!was_missing) {
+		        gam_server_emit_event(fdata->pathname,
+					      g_file_test(fdata->pathname, G_FILE_TEST_IS_DIR),
+					      GAMIN_EVENT_EXISTS, subs, 1);
+		    }
+		}
+
+		g_dir_close(dir);
+	    }
+	}
+
+	if (!was_missing) {
+	    gam_server_emit_event (path, isdir, GAMIN_EVENT_ENDEXISTS, subs, 1);
+	}
+
+        g_hash_table_insert(fd_hash, GINT_TO_POINTER(data->fd), data);
+	if (data->isdir) {
+            g_hash_table_insert(dir_path_hash, data->path, data);
+	}
+	else {
+            g_hash_table_insert(file_path_hash, data->path, data);
+	}
+
+	if (subs)
+            g_list_free(subs);
+
+        GAM_DEBUG(DEBUG_INFO, "added kqueue watch for %s\n", path);
+    } else {
+
+        if (!data) {
+            G_UNLOCK(kqueue);
+            return;
+        }
+
+	if (g_list_find (data->subs, sub)) {
+		data->subs = g_list_remove_all (data->subs, sub);
+	}
+        data->refcount--;
+	    GAM_DEBUG(DEBUG_INFO, "kqueue decremeneted refcount for %s\n", path);
+
+        if (data->refcount == 0) {
+            GList *l;
+
+	    close(data->fd);
+            l = data->subs;
+            for (l = l; l; l = l->next) {
+                GamSubscription *sub = l->data;
+                gam_kqueue_remove_subscription (sub);
+            }
+            GAM_DEBUG(DEBUG_INFO, "removed kqueue watch for %s\n", data->path);
+	    if (data->isdir) {
+                g_hash_table_remove(dir_path_hash, data->path);
+	    }
+	    else {
+		g_hash_table_remove(file_path_hash, data->path);
+	    }
+            g_hash_table_remove(fd_hash, GINT_TO_POINTER(data->fd));
+            gam_kqueue_data_free(data);
+        }
+    }
+    G_UNLOCK(kqueue);
+}
+
+static void
+gam_kqueue_monitor_clear_files (Monitor *mon)
+{
+  gam_kqueue_poller_remove_monitor(&dirs_poller, mon);
+  g_slist_foreach(mon->files, (GFunc) gam_kqueue_file_entry_free, NULL);
+  g_slist_free(mon->files);
+  mon->files = NULL;
+	else if ((mask & NOTE_REVOKE) != 0)
+		return GAMIN_EVENT_ENDEXISTS;
+	else if ((mask & NOTE_RENAME) != 0)
+		return GAMIN_EVENT_MOVED;
+	else
+		return GAMIN_EVENT_UNKNOWN;
+}
+
+static void
+gam_kqueue_monitor_set_missing (Monitor *mon)
+{
+  if (mon->fd >= 0)
+    {
+      close(mon->fd);
+      mon->fd = -1;
+    }
+
+  /*
+   * This shouldn't normally happen, since a directory cannot be
+   * deleted unless all its files are deleted first.
+   */
+  if (mon->files)
+    gam_kqueue_monitor_clear_files(mon);
+
+  gam_kqueue_poller_remove_monitor(&unsupported_poller, mon);
+  gam_kqueue_poller_add_monitor(&missing_poller, mon);
+}
+
+static void
+gam_kqueue_monitor_set_unsupported (Monitor *mon)
+{
+  if (mon->fd >= 0)
+    {
+      close(mon->fd);
+      mon->fd = -1;
+    }
+
+  gam_kqueue_mini_lstat(mon->path, &mon->sb);
+  gam_kqueue_poller_add_monitor(&unsupported_poller, mon);
+}
+
+static void
+gam_kqueue_monitor_enable_notification (Monitor *mon, gboolean was_missing)
+{
+  struct stat sb;
+  gboolean exists;
+  gboolean isdir;
+  struct kevent ev[1];
+	        const char *entry;
+
+  /* we first send CREATED or EXISTS/DELETED+ENDEXISTS events */
+		    dirlist = g_slist_prepend(dirlist, g_strdup(entry));
+		}
+
+  exists = lstat(mon->path, &sb) >= 0;
+  isdir = exists && (sb.st_mode & S_IFDIR) != 0;
+  
+  if (exists)
+    {
+      GaminEventType gevent;
+
+      gevent = was_missing ? GAMIN_EVENT_CREATED : GAMIN_EVENT_EXISTS;
+      gam_server_emit_event(mon->path, isdir, gevent, mon->subs, 1);
+
+      if (mon->isdir && isdir)
+	{
+	  GDir *dir;
+	  GError *err = NULL;
+	  
+	  if (mon->files)
+	    {
+	      /* be robust, handle the bug gracefully */
+	      GAM_DEBUG(DEBUG_INFO, "there is a bug in gam_kqueue: monitor had files\n");
+	      gam_kqueue_monitor_clear_files(mon);
+	    }
+	  
+	  dir = g_dir_open(mon->path, 0, &err);
+	  if (dir)
+	    {
+	      const char *filename;
+	      
+	      while ((filename = g_dir_read_name(dir)))
+		{
+		  FileEntry *entry;
+		  
+		  entry = gam_kqueue_file_entry_new(mon->path, filename);
+		  mon->files = g_slist_prepend(mon->files, entry);
+		  
+		  gam_server_emit_event(entry->pathname,
+					(entry->sb.mode & S_IFDIR) != 0,
+					gevent, mon->subs, 1);
+		}
+	      
+	      g_dir_close(dir);
+	    }
+	  else
+	    {
+	      GAM_DEBUG(DEBUG_INFO, "unable to open directory %s: %s\n", mon->path, err->message);
+	      g_error_free(err);
+
+	        if (! g_slist_find_custom(dirlist, fdata->filename, (GCompareFunc) strcmp)) {
+		    data->dirlist = g_slist_remove(data->dirlist, fdata);
+
+                    GAM_DEBUG(DEBUG_INFO, "kqueue emitting event %s for %s\n", gam_event_to_string(GAMIN_EVENT_DELETED), fdata->pathname);
+		    gam_server_emit_event(fdata->pathname,
+					  g_file_test(fdata->pathname, G_FILE_TEST_IS_DIR),
+					  GAMIN_EVENT_DELETED, data->subs, 1);
+
+		    gam_kqueue_file_data_free(fdata);
+		    goto iterate; /* list changed, start again */
+		}
+	    }
+
+	  if (mon->files)
+	    gam_kqueue_poller_add_monitor(&dirs_poller, mon);
+	        g_slist_free(dirlist);
+	    }
+            return;
+	}
+	else {
+	    event_path = g_strdup (data->path);
+
+	    if (gevent == GAMIN_EVENT_DELETED
+		|| gevent == GAMIN_EVENT_ENDEXISTS
+		|| gevent == GAMIN_EVENT_MOVED) {
+	      /* close and move to exist_list, to catch next creation */
+	      close(data->fd);
+	      if (data->isdir) {
+		  g_hash_table_remove(dir_path_hash, data->path);
+	      }
+	      else {
+		  g_hash_table_remove(file_path_hash, data->path);
+	      }
+	      g_hash_table_remove(fd_hash, GINT_TO_POINTER(data->fd));
+
+      if (! was_missing)
+	gam_server_emit_event(mon->path, isdir, GAMIN_EVENT_ENDEXISTS, mon->subs, 1);
+    }
+  else
+    {
+      if (! was_missing)
+	{
+	  gam_server_emit_event(mon->path, isdir, GAMIN_EVENT_DELETED, mon->subs, 1);
+	  gam_server_emit_event(mon->path, isdir, GAMIN_EVENT_ENDEXISTS, mon->subs, 1);
+	}
+
+      gam_kqueue_monitor_set_missing(mon);
+      return;
+    }
+    
+  /* then we enable kqueue notification, falling back to poll if necessary */
+
+  mon->fd = open(mon->path, O_RDONLY);
+  if (mon->fd < 0)
+    {
+      GAM_DEBUG(DEBUG_INFO, "cannot open %s (%s), falling back to poll\n", mon->path, g_strerror(errno));
+      gam_kqueue_monitor_set_unsupported(mon);
+      return;
+    }
+
+  EV_SET(ev, mon->fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR, VN_NOTE_ALL, 0, mon);
+  if (kevent(kq, ev, G_N_ELEMENTS(ev), NULL, 0, NULL) < 0)
+    {
+      GAM_DEBUG(DEBUG_INFO, "cannot enable kqueue notification for %s (%s), falling back to poll\n", mon->path, g_strerror(errno));
+      gam_kqueue_monitor_set_unsupported(mon);
+    }
+}
+
+static void
+gam_kqueue_monitor_handle_directory_change (Monitor *mon)
+{
+  GSList *filenames = NULL;
+  GSList *l;
+  GSList *tmp_files;
+  GDir *dir;
+  GError *err = NULL;
+
+  dir = g_dir_open(mon->path, 0, &err);
+  if (dir)
+    {
+      const char *filename;
+
+      while ((filename = g_dir_read_name(dir)))
+	filenames = g_slist_prepend(filenames, g_strdup(filename));
+
+      g_dir_close(dir);
+    }
+  else
+    {
+      GAM_DEBUG(DEBUG_INFO, "unable to open directory %s: %s\n", mon->path, err->message);
+      g_error_free(err);
+    }
+
+  /* handle created files */
+  for (l = filenames; l; l = l->next)
+    if (! g_slist_find_custom(mon->files, l->data, (GCompareFunc) gam_kqueue_files_find))
+      {
+	FileEntry *entry;
+      
+	entry = gam_kqueue_file_entry_new(mon->path, l->data);
+	mon->files = g_slist_prepend(mon->files, entry);
+      
+	gam_server_emit_event(entry->pathname,
+			      (entry->sb.mode & S_IFDIR) != 0,
+			      GAMIN_EVENT_CREATED, mon->subs, 1);
+      }
+
+  /* handle deleted files */
+  tmp_files = g_slist_copy(mon->files);
+  for (l = tmp_files; l; l = l->next)
+    {
+      FileEntry *entry = l->data;
+
+      if (! g_slist_find_custom(filenames, entry->filename, (GCompareFunc) strcmp))
+	{
+	  mon->files = g_slist_remove(mon->files, entry);
+
+	  gam_server_emit_event(entry->pathname,
+				(entry->sb.mode & S_IFDIR) != 0,
+				GAMIN_EVENT_DELETED, mon->subs, 1);
+
+	  gam_kqueue_file_entry_free(entry);
+	    gam_kqueue_add_rm_handler(data->path, sub, TRUE, TRUE);
+	    gam_kqueue_data_free(data);
+	}
+    }
+  g_slist_free(tmp_files);
+
+  if (filenames)
+    {
+      g_slist_foreach(filenames, (GFunc) g_free, NULL);
+      g_slist_free(filenames);
+    }
+
+  if (mon->files)
+    gam_kqueue_poller_add_monitor(&dirs_poller, mon);
+  else
+    gam_kqueue_poller_remove_monitor(&dirs_poller, mon);
+}
+
+static void
+gam_kqueue_monitor_emit_event (Monitor *mon,
+			       GaminEventType event,
+			       gboolean has_isdir,
+			       gboolean isdir)
+{
+  if (! has_isdir)
+    {
+      struct stat sb;
+      isdir = lstat(mon->path, &sb) >= 0 && (sb.st_mode & S_IFDIR) != 0;
+    }
+
+  switch (event)
+    {
+    case GAMIN_EVENT_CHANGED:
+      if (mon->isdir)
+	{
+	  gam_kqueue_monitor_handle_directory_change(mon);
+	  return;
+	}
+      break;
+
+    case GAMIN_EVENT_DELETED:
+    case GAMIN_EVENT_MOVED:
+      gam_kqueue_monitor_set_missing(mon);
+      break;
+    }
+
+  gam_server_emit_event(mon->path, isdir, event, mon->subs, 1);
+}
+	    || sb.size != fdata->sb.size
+	    || sb.mode != fdata->sb.mode
+	    || sb.uid != fdata->sb.uid
+	    || sb.gid != fdata->sb.gid
+	    || sb.ino != fdata->sb.ino)
+	  {
+	      memcpy(&fdata->sb, &sb, sizeof(sb));
+
+static void
+gam_kqueue_monitor_handle_kevent (Monitor *mon, struct kevent *event)
+{
+  if ((event->flags & EV_ERROR) != 0)
+    {
+      /* kqueue failed, fallback to poll */
+      GAM_DEBUG(DEBUG_INFO, "kqueue failed for %s, falling back to poll\n", mon->path);
+      gam_kqueue_monitor_set_unsupported(mon);
+      return;
+    }
+
+  /*
+   * kevent aggregates events, so we must handle a fflags with
+   * multiple event bits set.
+   */
+  if ((event->fflags & VN_NOTE_CHANGED) != 0)
+    gam_kqueue_monitor_emit_event(mon, GAMIN_EVENT_CHANGED, FALSE, FALSE);
+  if ((event->fflags & VN_NOTE_DELETED) != 0)
+    gam_kqueue_monitor_emit_event(mon, GAMIN_EVENT_DELETED, FALSE, FALSE);
+  if ((event->fflags & NOTE_RENAME) != 0)
+    gam_kqueue_monitor_emit_event(mon, GAMIN_EVENT_MOVED, FALSE, FALSE);
+}
+
+static gboolean
+gam_kqueue_kevent_cb (GIOChannel *source, GIOCondition condition, gpointer user_data)
+{
+  int nevents;
+  struct kevent ev[1];
+  struct timespec timeout = { 0, 0 };
+  int i;
+
+  nevents = kevent(kq, NULL, 0, ev, G_N_ELEMENTS(ev), &timeout);
+  if (nevents < 0)
+    {
+      GAM_DEBUG(DEBUG_INFO, "kevent() failure: %s\n", g_strerror(errno));
+      return TRUE;		/* keep source */
+    }
+
+  for (i = 0; i < nevents; i++)
+    gam_kqueue_monitor_handle_kevent(ev[i].udata, &ev[i]);
+
+  return TRUE;			/* keep source */
+}
+
+static gboolean
+gam_kqueue_missing_poll (gpointer user_data)
+{
+  GSList *tmp_list;
+  GSList *l;
+    struct timespec timeout = { 0, 0 };
+    int fd, i, nevents;
+
+    G_LOCK(kqueue);
+
+    GAM_DEBUG(DEBUG_INFO, "gam_kqueue_event_handler()\n");
+
+    nevents = kevent(kq, NULL, 0, ev, 1, &timeout);
+    if (nevents == -1)
+        return FALSE;
+    for (i = 0; i < nevents; i++) {
+        fd = ev[i].ident;
+
+	data = g_hash_table_lookup (fd_hash, GINT_TO_POINTER(fd));
+	if (!data) {
+	    GAM_DEBUG(DEBUG_INFO, "kqueue can't find fd %d\n", fd);
+	    GAM_DEBUG(DEBUG_INFO, "weird things have happened to kqueue.\n");
+	} else {
+	    gam_kqueue_emit_event (data, &ev[i]);
+	}
+
+  /* the list may be modified while we're iterating, so we use a copy */
+
+  tmp_list = g_slist_copy(missing_poller.monitors);
+  for (l = tmp_list; l; l = l->next)
+    {
+      Monitor *mon = l->data;
+      struct stat sb;
+
+      if (lstat(mon->path, &sb) >= 0)
+	{
+	  gam_kqueue_poller_remove_monitor(&missing_poller, mon);
+	  gam_kqueue_monitor_enable_notification(mon, TRUE);
+	}
+    }
+  g_slist_free(tmp_list);
+
+  return TRUE;
+}
+
+static gboolean
+gam_kqueue_unsupported_poll (gpointer user_data)
+{
+  GSList *tmp_list;
+  GSList *l;
+
+  /* the list may be modified while we're iterating, so we use a copy */
+	if (new_subs) {
+		subs = new_subs;
+		new_subs = NULL;
+		G_UNLOCK(new_subs);
+
+		for (l = subs; l; l = l->next) {
+			GamSubscription *sub = l->data;
+			GAM_DEBUG(DEBUG_INFO, "called gam_kqueue_add_handler()\n");
+			gam_kqueue_add_rm_handler (gam_subscription_get_path (sub), sub, TRUE, FALSE);
+		}
+
+	} else {
+		G_UNLOCK(new_subs);
+	}
+
+	G_LOCK(removed_subs);
+	if (removed_subs) {
+		subs = removed_subs;
+		removed_subs = NULL;
+		G_UNLOCK(removed_subs);
+
+		for (l = subs; l; l = l->next) {
+			GamSubscription *sub = l->data;
+			GAM_DEBUG(DEBUG_INFO, "called gam_kqueue_rm_handler()\n");
+			gam_kqueue_add_rm_handler (gam_subscription_get_path (sub), sub, FALSE, FALSE);
+		}
+	} else {
+		G_UNLOCK(removed_subs);
+	}
+
+  tmp_list = g_slist_copy(unsupported_poller.monitors);
+  for (l = tmp_list; l; l = l->next)
+    {
+      Monitor *mon = l->data;
+      MiniStat sb;
+      GaminEventType event;
+
+      gam_kqueue_mini_lstat(mon->path, &sb);
+
+      if (! sb.exists && mon->sb.exists)
+	event = GAMIN_EVENT_DELETED;
+      else if (gam_kqueue_differs(&sb, &mon->sb))
+	event = GAMIN_EVENT_CHANGED;
+      else
+	continue;
+	
+      memcpy(&mon->sb, &sb, sizeof(sb));
+      gam_kqueue_monitor_emit_event(mon, event, TRUE, (sb.mode & S_IFDIR) != 0);
+    }
+  g_slist_free(tmp_list);
+
+  return TRUE;
+	return FALSE;
+}
+
+static gboolean
+gam_kqueue_dirs_poll (gpointer user_data)
+{
+  GSList *l;
+
+	if (have_consume_idler)
+		return;
+
+  /* the list cannot be modified while we're iterating */
+
+  for (l = dirs_poller.monitors; l; l = l->next)
+    {
+      Monitor *mon = l->data;
+      GSList *f;
+
+      for (f = mon->files; f; f = f->next)
+	{
+	  FileEntry *entry = f->data;
+	  MiniStat sb;
+
+	  gam_kqueue_mini_lstat(entry->pathname, &sb);
+	  if (gam_kqueue_differs(&sb, &entry->sb))
+	    {
+	      memcpy(&entry->sb, &sb, sizeof(sb));
+	      gam_server_emit_event(entry->pathname,
+				    (sb.mode & S_IFDIR) != 0,
+				    GAMIN_EVENT_CHANGED,
+				    mon->subs, 1);
+	    }
+	}
+    }
+
+  return TRUE;
+}
+
+/**
+ * @defgroup kqueue kqueue backend
+ * @ingroup Backends
+ * @brief kqueue backend API
+ *
+ * Since 4.1, FreeBSD kernels have included the kernel event notification
+ * machanism (kqueue).  This backend uses kqueue to know when
+ * files are changed/created/deleted.
+ *
+ * @{
+ */
+
+
+/**
+ * Initializes the kqueue system.  This must be called before
+ * any other functions in this module.
+ *
+ * @returns TRUE if initialization succeeded, FALSE otherwise
+ */
+gboolean
+gam_kqueue_init (void)
+{
+  GIOChannel *channel;
+
+  kq = kqueue();
+  if (kq < 0)
+    {
+      gam_error(DEBUG_INFO, "kqueue initialization failure: %s\n", g_strerror(errno));
+      return FALSE;
+    }
+
+  dir_hash = g_hash_table_new(g_str_hash, g_str_equal);
+  file_hash = g_hash_table_new(g_str_hash, g_str_equal);
+    channel = g_io_channel_unix_new(kq);
+    g_io_add_watch(channel, G_IO_IN, gam_kqueue_event_handler, NULL);
+
+  channel = g_io_channel_unix_new(kq);
+  g_io_add_watch(channel, G_IO_IN, gam_kqueue_kevent_cb, NULL);
+    fd_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
+
+  gam_backend_add_subscription = gam_kqueue_add_subscription;
+  gam_backend_remove_subscription = gam_kqueue_remove_subscription;
+  gam_backend_remove_all_for = gam_kqueue_remove_all_for;
+     * if a few large directories are monitored (for instance a mail
+     * checker monitoring a couple of MH folders), therefore we use a
+     * reasonable poll interval (6 seconds, same as FAM's default).
+     */
+    g_timeout_add(6000, gam_kqueue_dirlist_check, NULL);
+
+  return TRUE;
+
+    gam_backend_add_subscription = gam_kqueue_add_subscription;
+    gam_backend_remove_subscription = gam_kqueue_remove_subscription;
+    gam_backend_remove_all_for = gam_kqueue_remove_all_for;
+
+    return TRUE;
+}
+
+/**

+ * @returns TRUE if adding the subscription succeeded, FALSE otherwise
+ */
+gboolean
+gam_kqueue_add_subscription (GamSubscription *sub)
+{
+  const char *path;
+  GHashTable *hash;
+  Monitor *mon;
+
+  gam_listener_add_subscription(gam_subscription_get_listener(sub), sub);
+
+  path = gam_subscription_get_path(sub);
+  hash = gam_subscription_is_dir(sub) ? dir_hash : file_hash;
+  mon = g_hash_table_lookup(hash, path);
+
+  if (mon)
+    {
+      mon->subs = g_list_append(mon->subs, sub);
+      return TRUE;
+    }
+  
+  mon = g_new0(Monitor, 1);
+  mon->path = path;
+  mon->subs = g_list_append(mon->subs, sub);
+  mon->fd = -1;
+  mon->isdir = hash == dir_hash;
+
+  g_hash_table_insert(hash, (gpointer) mon->path, mon);
+  gam_kqueue_monitor_enable_notification(mon, FALSE);
+
+  return TRUE;
+    return TRUE;
+}
+
+/**

+ * @returns TRUE if removing the subscription succeeded, FALSE otherwise
+ */
+gboolean
+gam_kqueue_remove_subscription (GamSubscription *sub)
+{
+  GHashTable *hash;
+  Monitor *mon;
+
+  hash = gam_subscription_is_dir(sub) ? dir_hash : file_hash;
+  mon = g_hash_table_lookup(hash, gam_subscription_get_path(sub));
+
+  if (! mon)
+    return FALSE;
+
+  mon->subs = g_list_remove_all(mon->subs, sub);
+  if (! mon->subs)
+    {
+      g_hash_table_remove(hash, mon->path);
+
+      /* might have been in any of these two */
+      gam_kqueue_poller_remove_monitor(&missing_poller, mon);
+      gam_kqueue_poller_remove_monitor(&unsupported_poller, mon);
+
+      if (mon->fd >= 0)
+	close(mon->fd);
+
+      if (mon->files)
+	gam_kqueue_monitor_clear_files(mon);
+
+      g_free(mon);
+    }
+
+  gam_subscription_cancel(sub);
+  gam_listener_remove_subscription(gam_subscription_get_listener(sub), sub);
+
+  return TRUE;
+}
+
+/**

+ * @returns TRUE if removing the subscriptions succeeded, FALSE otherwise
+ */
+gboolean
+gam_kqueue_remove_all_for (GamListener *listener)
+{
+  GList *subs;
+  GList *l;
+  gboolean success = TRUE;
+
+  subs = gam_listener_get_subscriptions(listener);
+		GamSubscription *sub = l->data;
+
+  for (l = subs; l; l = l->next)
+    if (! gam_kqueue_remove_subscription(l->data))
+      success = FALSE;
+
+  g_list_free(subs);
+  
+  return success;
+
+	if (subs) {
+		g_list_free (subs);
+		gam_kqueue_consume_subscriptions();
+		return TRUE;
+	} else {
+		return FALSE;
+	}
+}
+
+/** @} */




--- server/gam_kqueue.h.orig	Fri Apr  8 14:50:41 2005
+++ server/gam_kqueue.h	Fri Apr  8 14:51:01 2005
@@ -0,0 +1,16 @@
+
+#ifndef __MD_KQUEUE_H__
+#define __MD_KQUEUE_H__
+
+#include <glib.h>
+#include "gam_poll.h"
+#include "gam_subscription.h"
+
+#define VN_NOTE_MOST	(NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | \
+			 NOTE_ATTRIB | NOTE_LINK | NOTE_RENAME | \
+			 NOTE_REVOKE)
+#define VN_NOTE_ALL	VN_NOTE_MOST
+#define VN_NOTE_CHANGED	(NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_LINK)
+
+G_BEGIN_DECLS
+




--- tests/testing.c.orig	Fri Apr  8 15:09:45 2005
+++ tests/testing.c	Fri Apr  8 15:09:57 2005
@@ -424,9 +424,9 @@
             return (-1);
         }
         /*
-         * wait at most 3 secs before declaring failure
+         * wait at most 7 secs before declaring failure
          */
-        while ((delay < 30) && (testState.nb_events < nb_events + count)) {
+        while ((delay < 70) && (testState.nb_events < nb_events + count)) {
             debugLoop(100);
 
 /*	    printf("+"); fflush(stdout); */

Lines 2-5 Link Here

(-)gamin/pkg-descr (+3 lines)
2	FAM (File Alteration Monitor) system. This is a service provided by a library	2	FAM (File Alteration Monitor) system. This is a service provided by a library
3	which allows to detect when a file or a directory has been modified.	3	which allows to detect when a file or a directory has been modified.
4		4
		5	Whereas the FreeBSD port of FAM polls files every few seconds, this port
		6	includes a kqueue(2) backend for immediate notification of most alterations.
		7
5	WWW: http://www.gnome.org/~veillard/gamin/index.html	8	WWW: http://www.gnome.org/~veillard/gamin/index.html

Return to bug 79680

Lines 7-13 Link Here

(-)gamin/Makefile (-16 / +2 lines)
7		7
8	PORTNAME= gamin	8	PORTNAME= gamin
9	PORTVERSION= 0.0.26	9	PORTVERSION= 0.0.26
10	PORTREVISION?= 9	10	PORTREVISION?= 10
11	CATEGORIES?= devel	11	CATEGORIES?= devel
12	MASTER_SITES= http://www.gnome.org/~veillard/gamin/sources/	12	MASTER_SITES= http://www.gnome.org/~veillard/gamin/sources/
13		13
Lines 25-45 Link Here
25		25
26	CONFLICTS= fam-[0-9]*	26	CONFLICTS= fam-[0-9]*
27		27
28	.if !defined(GAMIN_SLAVE)
29	OPTIONS= KQUEUE "Enable the KQueue backend (UFS only)" on
30	.endif
31
32	.include <bsd.port.pre.mk>
33
34	.if !defined(GAMIN_SLAVE)
35	.if defined(WITHOUT_KQUEUE)
36	CONFIGURE_ARGS+= --disable-kqueue
37	.else
38	CONFIGURE_ARGS+= --enable-kqueue
39	.endif
40	.endif
41
42	post-patch:	28	post-patch:
43	@${FIND} ${WRKSRC} -type f \| ${XARGS} ${TOUCH} -f	29	@${FIND} ${WRKSRC} -type f \| ${XARGS} ${TOUCH} -f
44		30
45	.include <bsd.port.post.mk>	31	.include <bsd.port.mk>

Lines 1-19 Link Here

(-)gamin/files/patch-server_gam_kqueue.h (-11 / +3 lines)
1	--- server/gam_kqueue.h.orig Sat Mar 26 18:32:19 2005	1	--- server/gam_kqueue.h.orig Fri Apr 8 14:50:41 2005
2	+++ server/gam_kqueue.h Sat Mar 26 18:36:11 2005	2	+++ server/gam_kqueue.h Fri Apr 8 14:51:01 2005
3	@@ -0,0 +1,24 @@	3	@@ -0,0 +1,16 @@
4	+
5	+#ifndef __MD_KQUEUE_H__	4	+#ifndef __MD_KQUEUE_H__
6	+#define __MD_KQUEUE_H__	5	+#define __MD_KQUEUE_H__
7	+	6	+
8	+#include <glib.h>	7	+#include <glib.h>
9	+#include "gam_poll.h"
10	+#include "gam_subscription.h"	8	+#include "gam_subscription.h"
11	+
12	+#define VN_NOTE_MOST (NOTE_DELETE \| NOTE_WRITE \| NOTE_EXTEND \| \
13	+ NOTE_ATTRIB \| NOTE_LINK \| NOTE_RENAME \| \
14	+ NOTE_REVOKE)
15	+#define VN_NOTE_ALL VN_NOTE_MOST
16	+#define VN_NOTE_CHANGED (NOTE_WRITE \| NOTE_EXTEND \| NOTE_ATTRIB \| NOTE_LINK)
17	+	9	+
18	+G_BEGIN_DECLS	10	+G_BEGIN_DECLS
19	+	11	+

Line 0 Link Here

(-)gamin/files/patch-tests_testing.c (+14 lines)
	1	--- tests/testing.c.orig Fri Apr 8 15:09:45 2005
	2	+++ tests/testing.c Fri Apr 8 15:09:57 2005
	3	@@ -424,9 +424,9 @@
	4	return (-1);
	5	}
	6	/*
	7	- * wait at most 3 secs before declaring failure
	8	+ * wait at most 7 secs before declaring failure
	9	*/
	10	- while ((delay < 30) && (testState.nb_events < nb_events + count)) {
	11	+ while ((delay < 70) && (testState.nb_events < nb_events + count)) {
	12	debugLoop(100);
	13
	14	/* printf("+"); fflush(stdout); */