svn commit: r565264 - in head/devel/glib20: . files
Tobias C. Berner
tcberner at FreeBSD.org
Sun Feb 14 19:38:27 UTC 2021
Author: tcberner
Date: Sun Feb 14 19:38:26 2021
New Revision: 565264
URL: https://svnweb.freebsd.org/changeset/ports/565264
Log:
devel/glib20: add alternative file monitoring backend
This altnerative file monitoring backend implemented by the submitter may lead
to a big decrease in cpu time usage in for example thunar.
Consider it experimental, but worth a try, if your having issues with high cpu.
PR: 214338
Submitted by: rozhuk.im at gmail.com
Added:
head/devel/glib20/files/gkqueuefilemonitor.c (contents, props changed)
head/devel/glib20/files/kqueue_fnm.c (contents, props changed)
head/devel/glib20/files/kqueue_fnm.h (contents, props changed)
Modified:
head/devel/glib20/Makefile
Modified: head/devel/glib20/Makefile
==============================================================================
--- head/devel/glib20/Makefile Sun Feb 14 19:31:00 2021 (r565263)
+++ head/devel/glib20/Makefile Sun Feb 14 19:38:26 2021 (r565264)
@@ -35,10 +35,12 @@ PORTSCOUT= limitw:1,even
_LIBVERSION= 0.6600.7
PLIST_SUB= LIBVERSION=${_LIBVERSION}
-OPTIONS_DEFINE= DEBUG MANPAGES NLS
+OPTIONS_DEFINE= DEBUG FAM_ALTBACKEND MANPAGES NLS
OPTIONS_DEFAULT= MANPAGES
OPTIONS_SUB= yes
+FAM_ALTBACKEND_DESC= Alternate file monitor backend
+
MANPAGES_BUILD_DEPENDS= docbook-xml>4.1.2:textproc/docbook-xml \
docbook-xsl>0:textproc/docbook-xsl
MANPAGES_USE= GNOME=libxslt:build
@@ -59,6 +61,15 @@ MESON_ARGS+= -Diconv=external
.if ${ARCH} == powerpc64
EXTRA_PATCHES= ${FILESDIR}/extra-arch-powerpc64
.endif
+
+pre-configure-FAM_ALTBACKEND-on:
+ @${REINPLACE_CMD} -e 's|kqueue-helper.c|kqueue_fnm.c|g ; \
+ s|.*kqueue-missing.c.*||g ; \
+ s|.*dep-list.c.*||g' \
+ ${WRKSRC}/gio/kqueue/meson.build
+ @${CP} -f ${FILESDIR}/gkqueuefilemonitor.c ${WRKSRC}/gio/kqueue/gkqueuefilemonitor.c
+ @${CP} ${FILESDIR}/kqueue_fnm.c ${WRKSRC}/gio/kqueue/kqueue_fnm.c
+ @${CP} ${FILESDIR}/kqueue_fnm.h ${WRKSRC}/gio/kqueue/kqueue_fnm.h
post-patch:
${REINPLACE_CMD} -e 's|/usr/local|${LOCALBASE}|g ; \
Added: head/devel/glib20/files/gkqueuefilemonitor.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/devel/glib20/files/gkqueuefilemonitor.c Sun Feb 14 19:38:26 2021 (r565264)
@@ -0,0 +1,224 @@
+/*-
+ * Copyright (c) 2016 - 2019 Rozhuk Ivan <rozhuk.im at gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Author: Rozhuk Ivan <rozhuk.im at gmail.com>
+ *
+ */
+
+#include "config.h"
+
+#include <glib-object.h>
+#include <string.h>
+#include <gio/gfilemonitor.h>
+#include <gio/glocalfilemonitor.h>
+#include <gio/giomodule.h>
+#include "glib-private.h"
+#include <glib-unix.h>
+#include "kqueue_fnm.h"
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+/* Defaults. */
+#ifndef KQUEUE_MON_RATE_LIMIT_TIME_INIT
+# define KQUEUE_MON_RATE_LIMIT_TIME_INIT 1000
+#endif
+
+#ifndef KQUEUE_MON_RATE_LIMIT_TIME_MAX
+# define KQUEUE_MON_RATE_LIMIT_TIME_MAX 4000
+#endif
+#ifndef KQUEUE_MON_RATE_LIMIT_TIME_MUL
+# define KQUEUE_MON_RATE_LIMIT_TIME_MUL 2
+#endif
+#ifndef KQUEUE_MON_MAX_DIR_FILES
+# define KQUEUE_MON_MAX_DIR_FILES 128
+#endif
+#ifndef KQUEUE_MON_LOCAL_SUBFILES
+# define KQUEUE_MON_LOCAL_SUBFILES 1
+#endif
+#ifndef KQUEUE_MON_LOCAL_SUBDIRS
+# define KQUEUE_MON_LOCAL_SUBDIRS 0
+#endif
+
+
+static GMutex kqueue_lock;
+static volatile kq_fnm_p kqueue_fnm = NULL;
+/* Exclude from file changes monitoring, watch only for dirs. */
+static const char *non_local_fs[] = {
+ "fusefs.sshfs",
+ NULL
+};
+
+#define G_TYPE_KQUEUE_FILE_MONITOR (g_kqueue_file_monitor_get_type())
+#define G_KQUEUE_FILE_MONITOR(inst) (G_TYPE_CHECK_INSTANCE_CAST((inst), \
+ G_TYPE_KQUEUE_FILE_MONITOR, GKqueueFileMonitor))
+
+typedef GLocalFileMonitorClass GKqueueFileMonitorClass;
+
+typedef struct {
+ GLocalFileMonitor parent_instance;
+ kq_fnme_p fnme;
+} GKqueueFileMonitor;
+
+GType g_kqueue_file_monitor_get_type(void);
+G_DEFINE_TYPE_WITH_CODE (GKqueueFileMonitor, g_kqueue_file_monitor, G_TYPE_LOCAL_FILE_MONITOR,
+ g_io_extension_point_implement(G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME,
+ g_define_type_id,
+ "kqueue",
+ 10))
+
+
+static void
+kqueue_event_handler(kq_fnm_p kfnm,
+ kq_fnme_p fnme, void *udata, uint32_t event,
+ const char *base, const char *filename, const char *new_filename) {
+ static const uint32_t kfnm_to_glib_map[] = {
+ 0, /* KF_EVENT_NOT_CHANGED */
+ G_FILE_MONITOR_EVENT_CREATED, /* KF_EVENT_CREATED */
+ G_FILE_MONITOR_EVENT_DELETED, /* KF_EVENT_DELETED */
+ G_FILE_MONITOR_EVENT_RENAMED, /* KF_EVENT_RENAMED */
+ G_FILE_MONITOR_EVENT_CHANGED /* KF_EVENT_CHANGED */
+ };
+
+ if (NULL == kfnm || NULL == filename || 0 == filename[0] ||
+ strchr(filename, '/') ||
+ KF_EVENT_CREATED > event ||
+ KF_EVENT_CHANGED < event)
+ return;
+
+ g_file_monitor_source_handle_event(udata,
+ kfnm_to_glib_map[event],
+ filename, new_filename, NULL,
+ g_get_monotonic_time());
+}
+
+static gboolean
+g_kqueue_file_monitor_is_supported(void) {
+ kq_file_mon_settings_t kfms;
+
+ if (NULL != kqueue_fnm)
+ return (TRUE);
+ /* Init only once. */
+ g_mutex_lock(&kqueue_lock);
+ if (NULL != kqueue_fnm) {
+ g_mutex_unlock(&kqueue_lock);
+ return (TRUE); /* Initialized while wait lock. */
+ }
+
+ memset(&kfms, 0x00, sizeof(kq_file_mon_settings_t));
+ kfms.rate_limit_time_init = KQUEUE_MON_RATE_LIMIT_TIME_INIT;
+ kfms.rate_limit_time_max = KQUEUE_MON_RATE_LIMIT_TIME_MAX;
+ kfms.rate_limit_time_mul = KQUEUE_MON_RATE_LIMIT_TIME_MUL;
+ kfms.max_dir_files = KQUEUE_MON_MAX_DIR_FILES;
+ kfms.mon_local_subfiles = KQUEUE_MON_LOCAL_SUBFILES;
+ kfms.mon_local_subdirs = KQUEUE_MON_LOCAL_SUBDIRS;
+ kfms.local_fs = NULL;
+ kfms.non_local_fs = non_local_fs;
+
+ kqueue_fnm = kq_fnm_create(&kfms, kqueue_event_handler);
+ if (NULL == kqueue_fnm) {
+ g_mutex_unlock(&kqueue_lock);
+ return (FALSE); /* Init fail. */
+ }
+ g_mutex_unlock(&kqueue_lock);
+
+ return (TRUE);
+}
+
+static gboolean
+g_kqueue_file_monitor_cancel(GFileMonitor *monitor) {
+ GKqueueFileMonitor *gffm = G_KQUEUE_FILE_MONITOR(monitor);
+
+ kq_fnm_del(kqueue_fnm, gffm->fnme);
+ gffm->fnme = NULL;
+
+ return (TRUE);
+}
+
+static void
+g_kqueue_file_monitor_finalize(GObject *object) {
+ //GKqueueFileMonitor *gffm = G_KQUEUE_FILE_MONITOR(object);
+
+ //g_mutex_lock(&kqueue_lock);
+ //kq_fnm_free(kqueue_fnm);
+ //kqueue_fnm = NULL;
+ //g_mutex_unlock(&kqueue_lock);
+ //G_OBJECT_CLASS(g_kqueue_file_monitor_parent_class)->finalize(object);
+}
+
+static void
+g_kqueue_file_monitor_start(GLocalFileMonitor *local_monitor,
+ const gchar *dirname, const gchar *basename,
+ const gchar *filename, GFileMonitorSource *source) {
+ GKqueueFileMonitor *gffm = G_KQUEUE_FILE_MONITOR(local_monitor);
+
+ g_assert(NULL != kqueue_fnm);
+ //g_source_ref((GSource*)source);
+
+ if (NULL == filename) {
+ filename = dirname;
+ }
+ gffm->fnme = kq_fnm_add(kqueue_fnm, filename, source);
+}
+
+static void
+g_kqueue_file_monitor_init(GKqueueFileMonitor *monitor) {
+
+}
+
+static void
+g_kqueue_file_monitor_class_init(GKqueueFileMonitorClass *class) {
+ GObjectClass *gobject_class = G_OBJECT_CLASS(class);
+ GFileMonitorClass *file_monitor_class = G_FILE_MONITOR_CLASS(class);
+
+ class->is_supported = g_kqueue_file_monitor_is_supported;
+ class->start = g_kqueue_file_monitor_start;
+ class->mount_notify = TRUE; /* TODO: ??? */
+ file_monitor_class->cancel = g_kqueue_file_monitor_cancel;
+ gobject_class->finalize = g_kqueue_file_monitor_finalize;
+}
+
+static void
+g_kqueue_file_monitor_class_finalize(GKqueueFileMonitorClass *class) {
+
+}
+
+void
+g_io_module_load(GIOModule *module) {
+
+ g_type_module_use(G_TYPE_MODULE(module));
+
+ g_io_extension_point_implement(G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME,
+ G_TYPE_KQUEUE_FILE_MONITOR, "kqueue", 10);
+ g_io_extension_point_implement(G_NFS_FILE_MONITOR_EXTENSION_POINT_NAME,
+ G_TYPE_KQUEUE_FILE_MONITOR, "kqueue", 10);
+}
+
+void
+g_io_module_unload(GIOModule *module) {
+
+ g_assert_not_reached();
+}
Added: head/devel/glib20/files/kqueue_fnm.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/devel/glib20/files/kqueue_fnm.c Sun Feb 14 19:38:26 2021 (r565264)
@@ -0,0 +1,1431 @@
+/*-
+ * Copyright (c) 2016 - 2019 Rozhuk Ivan <rozhuk.im at gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Author: Rozhuk Ivan <rozhuk.im at gmail.com>
+ *
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <sys/ucred.h>
+#include <sys/mount.h>
+#include <sys/fcntl.h> /* open, fcntl */
+#include <sys/queue.h>
+
+#include <inttypes.h>
+#include <stdlib.h> /* malloc, exit */
+#include <unistd.h> /* close, write, sysconf */
+#include <string.h> /* bcopy, bzero, memcpy, memmove, memset, strerror... */
+#include <dirent.h> /* opendir, readdir */
+#include <errno.h>
+#include <pthread.h>
+#include <glib.h>
+
+#include "kqueue_fnm.h"
+
+
+/* Preallocate items count. */
+#ifndef FILES_ALLOC_BLK_SIZE
+# define FILES_ALLOC_BLK_SIZE 32
+#endif
+
+
+typedef struct readdir_context_s {
+ int fd;
+ uint8_t *buf;
+ size_t buf_size;
+ size_t buf_used;
+ size_t buf_pos;
+} readdir_ctx_t, *readdir_ctx_p;
+
+
+typedef struct file_info_s { /* Directory file. */
+ int fd; /* For notify kqueue(). */
+ struct dirent de; /* d_reclen used for action. */
+ struct stat sb;
+} file_info_t, *file_info_p;
+
+
+typedef struct kq_file_nonify_monitor_obj_s *kq_fnmo_p;
+
+typedef struct kq_file_nonify_monitor_entry_s {
+ TAILQ_ENTRY(kq_file_nonify_monitor_entry_s) next;
+ kq_fnmo_p fnmo;
+ void *udata;
+ volatile int enabled;
+} kq_fnme_t;
+
+TAILQ_HEAD(kq_fnme_head, kq_file_nonify_monitor_entry_s);
+
+typedef struct kq_file_nonify_monitor_obj_s {
+ int fd; /* For notify kqueue(). */
+ int is_dir;
+ int is_local; /* Is file system local. */
+ int is_removed; /* File/dir deleted, reported and can be only free. */
+ int is_cached; /* Added to fnmo_cache. */
+ struct stat sb;
+ char path[(PATH_MAX + sizeof(void*))];
+ size_t path_size;
+ size_t name_offset; /* Parent path size. */
+ uint32_t rate_lim_cur_interval; /* From rate_limit_time_init to rate_limit_time_max. 0 disabled. */
+ size_t rate_lim_ev_cnt; /* Events count then rate_lim_cur_interval != 0 since last report. */
+ sbintime_t rate_lim_ev_last; /* Last event time. */
+ void *udata;
+ kq_fnm_p kfnm;
+ struct kq_fnme_head entry_head;
+ /* For dir. */
+ file_info_p files;
+ volatile size_t files_count;
+ size_t files_allocated;
+} kq_fnmo_t;
+
+
+typedef struct kq_file_nonify_monitor_s {
+ int fd; /* kqueue() fd. */
+ int pfd[2]; /* pipe queue specific. */
+ GHashTable *fnmo_cache;
+ struct statfs *mounts;
+ size_t mounts_count;
+ kfnm_event_handler_cb cb_func; /* Callback on dir/file change. */
+ kq_file_mon_settings_t s;
+ sbintime_t rate_lim_time_init; /* rate_limit_time_init */
+ pthread_t tid;
+} kq_fnm_t;
+
+
+typedef void (*kq_msg_cb)(void *arg);
+
+typedef struct kq_file_mon_msg_pkt_s {
+ size_t magic;
+ kq_msg_cb msg_cb;
+ void *arg;
+ size_t chk_sum;
+} kq_fnm_msg_pkt_t, *kq_fnm_msg_pkt_p;
+
+#define KF_MSG_PKT_MAGIC 0xffddaa00
+
+
+#ifndef O_NOATIME
+# define O_NOATIME 0
+#endif
+#ifndef O_EVTONLY
+# define O_EVTONLY O_RDONLY
+#endif
+#define OPEN_FILE_FLAGS (O_EVTONLY | O_NONBLOCK | O_NOFOLLOW | O_NOATIME | O_CLOEXEC)
+
+#ifndef NOTE_CLOSE_WRITE
+# define NOTE_CLOSE_WRITE 0
+#endif
+#define EVFILT_VNODE_SUB_FLAGS (NOTE_WRITE | \
+ NOTE_EXTEND | \
+ NOTE_ATTRIB | \
+ NOTE_LINK | \
+ NOTE_CLOSE_WRITE)
+
+#define EVFILT_VNODE_FLAGS_ALL (NOTE_DELETE | \
+ EVFILT_VNODE_SUB_FLAGS | \
+ NOTE_RENAME | \
+ NOTE_REVOKE)
+
+#ifndef _GENERIC_DIRSIZ
+# define _GENERIC_DIRSIZ(__de) MIN((__de)->d_reclen, sizeof(struct dirent))
+#endif
+
+#define IS_NAME_DOTS(__name) ('.' == (__name)[0] && \
+ ('\0' == (__name)[1] || \
+ ('.' == (__name)[1] && '\0' == (__name)[2])))
+#define IS_DE_NAME_EQ(__de1, __de2) (0 == mem_cmpn((__de1)->d_name, \
+ (__de1)->d_namlen, \
+ (__de2)->d_name, \
+ (__de2)->d_namlen))
+#define zalloc(__size) calloc(1, (__size))
+
+#if (!defined(HAVE_REALLOCARRAY) && (!defined(__FreeBSD_version) || __FreeBSD_version < 1100000))
+# define reallocarray(__mem, __size, __count) realloc((__mem), ((__size) * (__count)))
+#endif
+
+/* To not depend from compiler version. */
+#define MSTOSBT(__ms) ((sbintime_t)((((uint64_t)1 << 32) * (uint64_t)(__ms)) / 1000))
+
+#ifndef TAILQ_FOREACH_SAFE
+#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = TAILQ_FIRST((head)); \
+ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
+ (var) = (tvar))
+#endif
+
+#ifndef CLOCK_MONOTONIC_FAST
+# define CLOCK_MONOTONIC_FAST CLOCK_MONOTONIC
+#endif
+
+
+void *kq_fnm_proccess_events_proc(void *data);
+
+static inline int
+mem_cmpn(const void *buf1, const size_t buf1_size,
+ const void *buf2, const size_t buf2_size) {
+
+ if (buf1_size != buf2_size)
+ return (((buf1_size > buf2_size) ? 127 : -127));
+ if (0 == buf1_size || buf1 == buf2)
+ return (0);
+ if (NULL == buf1)
+ return (-127);
+ if (NULL == buf2)
+ return (127);
+ return (memcmp(buf1, buf2, buf1_size));
+}
+
+static int
+realloc_items(void **items, const size_t item_size,
+ size_t *allocated, const size_t alloc_blk_cnt, const size_t count) {
+ size_t allocated_prev, allocated_new;
+ uint8_t *items_new;
+
+ if (NULL == items || 0 == item_size || NULL == allocated ||
+ 0 == alloc_blk_cnt)
+ return (EINVAL);
+ allocated_prev = (*allocated);
+ if (NULL != (*items) &&
+ allocated_prev > count &&
+ allocated_prev <= (count + alloc_blk_cnt))
+ return (0);
+ allocated_new = (((count / alloc_blk_cnt) + 1) * alloc_blk_cnt);
+ items_new = (uint8_t*)reallocarray((*items), item_size, allocated_new);
+ if (NULL == items_new) /* Realloc fail! */
+ return (ENOMEM);
+
+ if (allocated_new > allocated_prev) { /* Init new mem. */
+ memset((items_new + (allocated_prev * item_size)), 0x00,
+ ((allocated_new - allocated_prev) * item_size));
+ }
+ (*items) = items_new;
+ (*allocated) = allocated_new;
+
+ return (0);
+}
+
+/* Like getmntinfo() but allow free mem. */
+static int
+getmntinfo_ex(struct statfs **mntbufp, int mode) {
+ int ret;
+ struct statfs *buf;
+
+ if (NULL == mntbufp)
+ return (EINVAL);
+ /* Request count. */
+ ret = getfsstat(NULL, 0, mode);
+ if (-1 == ret)
+ return (ret);
+ /* Alloc mem. */
+ buf = calloc((ret + 1), sizeof(struct statfs));
+ if (NULL == buf)
+ return (-1);
+ /* Request data. */
+ ret = getfsstat(buf, ((ret + 1) * sizeof(struct statfs)), mode);
+ if (-1 == ret) {
+ free(buf);
+ buf = NULL;
+ }
+ (*mntbufp) = buf;
+
+ return (ret);
+}
+
+static int
+mounts_find_name(struct statfs *mounts, size_t mounts_count,
+ const char *mntonname) {
+ size_t i;
+
+ if (NULL == mounts || NULL == mntonname)
+ return (0);
+ for (i = 0; i < mounts_count; i ++) {
+ if (0 != strncmp(mntonname, mounts[i].f_mntonname, MNAMELEN))
+ continue;
+ return (1);
+ }
+ return (0);
+}
+
+
+static int
+readdir_start(int fd, struct stat *sb, size_t exp_count, readdir_ctx_p rdd) {
+ size_t buf_size;
+
+ if (-1 == fd || NULL == sb || NULL == rdd)
+ return (EINVAL);
+ if (-1 == lseek(fd, 0, SEEK_SET))
+ return (errno);
+ /* Calculate buf size for getdents(). */
+ buf_size = MAX((size_t)sb->st_size, (exp_count * sizeof(struct dirent)));
+ if (0 == buf_size) {
+ buf_size = (16 * PAGE_SIZE);
+ }
+ /* Make buf size well aligned. */
+ if (0 != sb->st_blksize) {
+ if (powerof2(sb->st_blksize)) {
+ buf_size = roundup2(buf_size, sb->st_blksize);
+ } else {
+ buf_size = roundup(buf_size, sb->st_blksize);
+ }
+ } else {
+ buf_size = round_page(buf_size);
+ }
+ /* Init. */
+ memset(rdd, 0x00, sizeof(readdir_ctx_t));
+ rdd->buf = malloc(buf_size);
+ if (NULL == rdd->buf)
+ return (ENOMEM);
+ rdd->buf_size = buf_size;
+ rdd->fd = fd;
+
+ return (0);
+}
+
+static void
+readdir_free(readdir_ctx_p rdd) {
+
+ if (NULL == rdd || NULL == rdd->buf)
+ return;
+ free(rdd->buf);
+ memset(rdd, 0x00, sizeof(readdir_ctx_t));
+}
+
+static int
+readdir_next(readdir_ctx_p rdd, struct dirent *de) {
+ int error = 0;
+ ssize_t ios;
+ uint8_t *ptr;
+
+ if (NULL == rdd || NULL == rdd->buf || NULL == de)
+ return (EINVAL);
+
+ for (;;) {
+ if (rdd->buf_used <= rdd->buf_pos) {
+ /* Called once if buf size calculated ok. */
+ ios = getdents(rdd->fd, (char*)rdd->buf, rdd->buf_size);
+ if (-1 == ios) {
+ error = errno;
+ break;
+ }
+ if (0 == ios) {
+ error = ESPIPE; /* EOF. */
+ break;
+ }
+ rdd->buf_used = (size_t)ios;
+ rdd->buf_pos = 0;
+ }
+ /* Keep data aligned. */
+ ptr = (rdd->buf + rdd->buf_pos);
+ memcpy(de, ptr, (sizeof(struct dirent) - sizeof(de->d_name)));
+ if (0 == de->d_reclen) {
+ error = ESPIPE; /* EOF. */
+ break;
+ }
+ rdd->buf_pos += de->d_reclen;
+#ifdef DT_WHT
+ if (DT_WHT == de->d_type)
+ continue;
+#endif
+ if (0 == de->d_namlen)
+ continue; /* Empty. */
+ memcpy(de, ptr, _GENERIC_DIRSIZ(de));
+ if (0 == de->d_name[0])
+ continue; /* Empty. */
+ if (IS_NAME_DOTS(de->d_name))
+ continue; /* Dots. */
+ return (0); /* OK. */
+ }
+
+ /* Err or no more files. */
+ readdir_free(rdd);
+
+ return (error);
+}
+
+
+static int
+file_info_find_ni(file_info_p files, size_t files_count,
+ file_info_p fi, size_t *idx) {
+ size_t i;
+ mode_t st_ftype;
+
+ if (NULL == files || NULL == fi || NULL == idx)
+ return (0);
+ st_ftype = (S_IFMT & fi->sb.st_mode);
+ for (i = 0; i < files_count; i ++) {
+ if ((S_IFMT & files[i].sb.st_mode) != st_ftype)
+ continue;
+ if ((fi->sb.st_ino != files[i].sb.st_ino ||
+ fi->de.d_fileno != files[i].de.d_fileno) &&
+ 0 == IS_DE_NAME_EQ(&fi->de, &files[i].de))
+ continue;
+ (*idx) = i;
+ return (1);
+ }
+ (*idx) = files_count;
+ return (0);
+}
+
+static int
+file_info_find_ino(file_info_p files, size_t files_count,
+ file_info_p fi, size_t *idx) {
+ size_t i;
+ mode_t st_ftype;
+
+ if (NULL == files || NULL == fi || NULL == idx)
+ return (0);
+ st_ftype = (S_IFMT & fi->sb.st_mode);
+ for (i = 0; i < files_count; i ++) {
+ if ((S_IFMT & files[i].sb.st_mode) != st_ftype ||
+ fi->sb.st_ino != files[i].sb.st_ino ||
+ fi->de.d_fileno != files[i].de.d_fileno)
+ continue;
+ (*idx) = i;
+ return (1);
+ }
+ (*idx) = files_count;
+ return (0);
+}
+
+static int
+file_info_find_name(file_info_p files, size_t files_count,
+ file_info_p fi, size_t *idx) {
+ size_t i;
+ mode_t st_ftype;
+
+ if (NULL == files || NULL == fi || NULL == idx)
+ return (0);
+ st_ftype = (S_IFMT & fi->sb.st_mode);
+ for (i = 0; i < files_count; i ++) {
+ if ((S_IFMT & files[i].sb.st_mode) != st_ftype ||
+ 0 == IS_DE_NAME_EQ(&fi->de, &files[i].de))
+ continue;
+ (*idx) = i;
+ return (1);
+ }
+ (*idx) = files_count;
+ return (0);
+}
+
+static void
+file_info_fd_close(file_info_p files, size_t files_count) {
+ size_t i;
+
+ if (NULL == files || 0 == files_count)
+ return;
+ for (i = 0; i < files_count; i ++) {
+ if (-1 == files[i].fd)
+ continue;
+ close(files[i].fd);
+ files[i].fd = -1;
+ }
+}
+
+
+static int
+is_fs_local(struct statfs *stfs, const char **local_fs, const char **non_local_fs) {
+ size_t i;
+
+ if (NULL == stfs)
+ return (0);
+ /* White listed fs. */
+ if (NULL != local_fs) {
+ for (i = 0; NULL != local_fs[i]; i ++) {
+ if (0 == strncmp(stfs->f_fstypename, local_fs[i],
+ sizeof(stfs->f_fstypename)))
+ return (1);
+ }
+ }
+ if (0 == (MNT_LOCAL & stfs->f_flags))
+ return (0);
+ /* Filter out black listed fs. */
+ if (NULL != non_local_fs) {
+ for (i = 0; NULL != non_local_fs[i]; i ++) {
+ if (0 == strncmp(stfs->f_fstypename, non_local_fs[i],
+ sizeof(stfs->f_fstypename)))
+ return (0);
+ }
+ }
+ return (1);
+}
+
+
+static void
+kq_fnmo_rate_lim_stop(kq_fnmo_p fnmo) {
+ struct kevent kev;
+
+ if (NULL == fnmo || 0 == fnmo->rate_lim_cur_interval)
+ return;
+ fnmo->rate_lim_cur_interval = 0;
+ fnmo->rate_lim_ev_cnt = 0;
+ EV_SET(&kev, (uintptr_t)fnmo, EVFILT_TIMER,
+ (EV_DELETE | EV_CLEAR), 0, 0, NULL);
+ kevent(fnmo->kfnm->fd, &kev, 1, NULL, 0, NULL);
+}
+
+static int
+kq_fnmo_rate_lim_shedule_next(kq_fnmo_p fnmo) {
+ u_short flags = (EV_ADD | EV_CLEAR | EV_ONESHOT);
+ struct kevent kev;
+
+ if (NULL == fnmo || -1 == fnmo->fd ||
+ 0 == fnmo->kfnm->s.rate_limit_time_init)
+ return (EINVAL);
+ if (0 == fnmo->rate_lim_cur_interval) { /* First call. */
+ fnmo->rate_lim_cur_interval = fnmo->kfnm->s.rate_limit_time_init;
+ } else {
+ if (fnmo->rate_lim_cur_interval == fnmo->kfnm->s.rate_limit_time_max)
+ return (0); /* No need to modify timer. */
+ /* Increase rate limit interval. */
+ fnmo->rate_lim_cur_interval *= fnmo->kfnm->s.rate_limit_time_mul;
+ }
+ if (fnmo->rate_lim_cur_interval >= fnmo->kfnm->s.rate_limit_time_max) {
+ /* Check upper limit and shedule periodic timer with upper rate limit time. */
+ flags &= ~EV_ONESHOT;
+ fnmo->rate_lim_cur_interval = fnmo->kfnm->s.rate_limit_time_max;
+ }
+ /* Setup timer. */
+ EV_SET(&kev, (uintptr_t)fnmo, EVFILT_TIMER, flags,
+ NOTE_MSECONDS, fnmo->rate_lim_cur_interval, fnmo);
+ if (-1 == kevent(fnmo->kfnm->fd, &kev, 1, NULL, 0, NULL)) {
+ fnmo->rate_lim_cur_interval = 0;
+ return (errno);
+ }
+ if (0 != (EV_ERROR & kev.flags)) {
+ fnmo->rate_lim_cur_interval = 0;
+ return ((int)kev.data);
+ }
+ return (0);
+}
+
+/* Return:
+ * 0 for events that not handled
+ * 1 for handled = rate limited
+ * -1 on error.
+ */
+static int
+kq_fnmo_rate_lim_check(kq_fnmo_p fnmo) {
+ sbintime_t sbt, sbt_now;
+ struct timespec ts;
+
+ if (NULL == fnmo)
+ return (-1);
+ if (-1 == fnmo->fd ||
+ 0 == fnmo->kfnm->s.rate_limit_time_init)
+ return (0);
+ if (0 != fnmo->rate_lim_cur_interval) {
+ fnmo->rate_lim_ev_cnt ++; /* Count event, timer is active. */
+ return (1);
+ }
+
+ /* Do we need to enable rate limit? */
+ if (0 != clock_gettime(CLOCK_MONOTONIC_FAST, &ts))
+ return (-1);
+ sbt_now = tstosbt(ts);
+ sbt = (fnmo->rate_lim_ev_last + fnmo->kfnm->rate_lim_time_init);
+ fnmo->rate_lim_ev_last = sbt_now;
+ if (sbt < sbt_now) /* Events rate to low. */
+ return (0);
+ /* Try to enable rate limit. */
+ if (0 != kq_fnmo_rate_lim_shedule_next(fnmo))
+ return (-1);
+ /* Ok. */
+ fnmo->rate_lim_ev_cnt ++;
+
+ return (1);
+}
+
+static void
+kq_fnmo_clean(kq_fnmo_p fnmo) {
+
+ if (NULL == fnmo)
+ return;
+
+ kq_fnmo_rate_lim_stop(fnmo);
+ if (-1 != fnmo->fd) {
+ close(fnmo->fd);
+ fnmo->fd = -1;
+ }
+ fnmo->is_removed ++;
+
+ /* Stop monitoring files/dirs. */
+ file_info_fd_close(fnmo->files, fnmo->files_count);
+ free(fnmo->files);
+ fnmo->files = NULL;
+ fnmo->files_count = 0;
+ fnmo->files_allocated = 0;
+}
+
+static void
+kq_fnmo_free(kq_fnmo_p fnmo) {
+
+ if (NULL == fnmo)
+ return;
+
+ kq_fnmo_clean(fnmo);
+
+ if (0 != fnmo->is_cached &&
+ NULL != fnmo->kfnm &&
+ g_hash_table_lookup(fnmo->kfnm->fnmo_cache, fnmo->path) == fnmo) {
+ g_hash_table_remove(fnmo->kfnm->fnmo_cache, fnmo->path);
+ }
+ free(fnmo);
+}
+
+static kq_fnmo_p
+kq_fnmo_alloc(kq_fnm_p kfnm, const char *path, kq_fnme_p fnme) {
+ kq_fnmo_p fnmo;
+
+ if (NULL == kfnm || NULL == path)
+ return (NULL);
+ fnmo = zalloc(sizeof(kq_fnmo_t));
+ if (NULL == fnmo)
+ return (NULL);
+ fnmo->fd = -1;
+ /* Remember args. */
+ fnmo->path_size = strlcpy(fnmo->path, path, PATH_MAX);
+ /* Make sure that no trailing '/'. */
+ while (1 < fnmo->path_size && '/' == fnmo->path[(fnmo->path_size - 1)]) {
+ fnmo->path_size --;
+ fnmo->path[fnmo->path_size] = 0;
+ }
+ /* Get parent folder name. */
+ fnmo->name_offset = fnmo->path_size;
+ while (0 < fnmo->name_offset && '/' != fnmo->path[(fnmo->name_offset - 1)]) {
+ fnmo->name_offset --;
+ }
+ fnmo->kfnm = kfnm;
+ TAILQ_INIT(&fnmo->entry_head);
+ if (NULL != fnme) {
+ TAILQ_INSERT_HEAD(&fnmo->entry_head, fnme, next);
+ }
+
+ return (fnmo);
+}
+
+static void
+kq_fnmo_cb_func_call(kq_fnmo_p fnmo, uint32_t event,
+ const char *base, const char *filename, const char *new_filename) {
+ kq_fnm_p kfnm;
+ kq_fnme_p fnme;
+
+ if (NULL == fnmo)
+ return;
+ kfnm = fnmo->kfnm;
+ TAILQ_FOREACH(fnme, &fnmo->entry_head, next) {
+ if (0 == fnme->enabled) /* XXX: try lock here? */
+ continue;
+ kfnm->cb_func(kfnm, fnme, fnme->udata, event,
+ base, filename, new_filename);
+ }
+
+}
+
+static int
+kq_fnmo_readdir(kq_fnmo_p fnmo, size_t exp_count) {
+ int error;
+ struct dirent *de;
+ file_info_p tmfi;
+ readdir_ctx_t rdd;
+
+ if (NULL == fnmo || -1 == fnmo->fd || 0 == fnmo->is_dir)
+ return (EINVAL);
+
+ free(fnmo->files);
+ fnmo->files = NULL;
+ fnmo->files_count = 0;
+ fnmo->files_allocated = 0;
+ /* Pre allocate. */
+ if (0 != realloc_items((void**)&fnmo->files,
+ sizeof(file_info_t), &fnmo->files_allocated,
+ FILES_ALLOC_BLK_SIZE, (exp_count + 1)))
+ return (ENOMEM);
+
+ error = readdir_start(fnmo->fd, &fnmo->sb, exp_count, &rdd);
+ if (0 != error)
+ return (error);
+ for (;;) {
+ if (0 != realloc_items((void**)&fnmo->files,
+ sizeof(file_info_t), &fnmo->files_allocated,
+ FILES_ALLOC_BLK_SIZE, fnmo->files_count)) {
+ free(fnmo->files);
+ fnmo->files = NULL;
+ fnmo->files_count = 0;
+ fnmo->files_allocated = 0;
+ readdir_free(&rdd);
+ return (ENOMEM);
+ }
+ de = &fnmo->files[fnmo->files_count].de; /* Use short name. */
+ /* Get file name from folder. */
+ if (0 != readdir_next(&rdd, de))
+ break;
+ /* Get file attrs. */
+ if (0 != fstatat(fnmo->fd, de->d_name,
+ &fnmo->files[fnmo->files_count].sb,
+ AT_SYMLINK_NOFOLLOW)) {
+ if (ENOENT == errno)
+ continue; /* File deleted. */
+ memset(&fnmo->files[fnmo->files_count].sb, 0x00,
+ sizeof(struct stat));
+ }
+ fnmo->files[fnmo->files_count].fd = -1;
+ fnmo->files_count ++;
+ }
+ /* Mem compact. */
+ tmfi = reallocarray(fnmo->files, sizeof(file_info_t), (fnmo->files_count + 1));
+ if (NULL != tmfi) { /* realloc ok. */
+ fnmo->files = tmfi;
+ fnmo->files_allocated = (fnmo->files_count + 1);
+ }
+
+ readdir_free(&rdd);
+
+ return (0); /* OK. */
+}
+
+
+static void
+kq_fnmo_fi_start(kq_fnmo_p fnmo, file_info_p fi) {
+ struct kevent kev;
+
+ if (NULL == fnmo || -1 == fnmo->fd || NULL == fi)
+ return;
+ fi->fd = openat(fnmo->fd, fi->de.d_name, OPEN_FILE_FLAGS);
+ if (-1 == fi->fd)
+ return;
+ EV_SET(&kev, fi->fd, EVFILT_VNODE,
+ (EV_ADD | EV_CLEAR),
+ EVFILT_VNODE_SUB_FLAGS, 0, fnmo);
+ kevent(fnmo->kfnm->fd, &kev, 1, NULL, 0, NULL);
+}
+
+static int
+kq_fnmo_is_fi_monitored(kq_fnmo_p fnmo, file_info_p fi) {
+
+ if (NULL == fnmo)
+ return (0);
+ if (0 == fnmo->is_local ||
+ (0 != fnmo->kfnm->s.max_dir_files &&
+ fnmo->kfnm->s.max_dir_files < fnmo->files_count))
+ return (0);
+ if (NULL != fi &&
+ 0 == fnmo->kfnm->s.mon_local_subdirs &&
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-ports-all
mailing list