summaryrefslogtreecommitdiffabout
authorSergey Poznyakoff <gray@gnu.org.ua>2016-08-22 14:49:30 (GMT)
committer Sergey Poznyakoff <gray@gnu.org>2016-08-25 19:29:47 (GMT)
commit6f39bd7e00acee689ce9a8a3916888a815242557 (patch) (side-by-side diff)
treed6319602bb9f4b171358823a4b0c38270f54f841
parentcccafb5ff305978b2b7a41fd68ade359aa27007b (diff)
downloaddirevent-6f39bd7e00acee689ce9a8a3916888a815242557.tar.gz
direvent-6f39bd7e00acee689ce9a8a3916888a815242557.tar.bz2
Rename: struct dirwatcher -> struct watchpoint
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--src/config.c12
-rw-r--r--src/direvent.c2
-rw-r--r--src/direvent.h55
-rw-r--r--src/ev_inotify.c72
-rw-r--r--src/ev_kqueue.c38
-rw-r--r--src/handler.c20
-rw-r--r--src/progman.c8
-rw-r--r--src/watcher.c274
8 files changed, 241 insertions, 240 deletions
diff --git a/src/config.c b/src/config.c
index a11e629..1f8d26e 100644
--- a/src/config.c
+++ b/src/config.c
@@ -176,18 +176,18 @@ eventconf_flush(grecs_locus_t *loc)
for (ep = eventconf.pathlist->head; ep; ep = ep->next) {
struct pathent *pe = ep->data;
- struct dirwatcher *dwp;
+ struct watchpoint *wpt;
int isnew;
- dwp = dirwatcher_install(pe->path, &isnew);
- if (!dwp)
+ wpt = watchpoint_install(pe->path, &isnew);
+ if (!wpt)
abort();
- if (!isnew && dwp->depth != pe->depth)
+ if (!isnew && wpt->depth != pe->depth)
grecs_error(loc, 0,
_("%s: recursion depth does not match previous definition"),
pe->path);
- dwp->depth = pe->depth;
- handler_list_append(dwp->handler_list, hp);
+ wpt->depth = pe->depth;
+ handler_list_append(wpt->handler_list, hp);
}
grecs_list_free(eventconf.pathlist);
eventconf_init();
diff --git a/src/direvent.c b/src/direvent.c
index 6c6a278..e1775f9 100644
--- a/src/direvent.c
+++ b/src/direvent.c
@@ -364,7 +364,7 @@ setuser(const char *user)
}
void
-ev_log(int flags, struct dirwatcher *dp)
+ev_log(int flags, struct watchpoint *dp)
{
int i;
char *p;
diff --git a/src/direvent.h b/src/direvent.h
index bc5bb46..faa1657 100644
--- a/src/direvent.h
+++ b/src/direvent.h
@@ -95,7 +95,7 @@ struct handler {
char **env; /* Environment */
} prog;
struct {
- struct dirwatcher *watcher;
+ struct watchpoint *watchpoint;
} sentinel;
} v;
#define prog_flags v.prog.flags
@@ -105,17 +105,18 @@ struct handler {
#define prog_gidc v.prog.gidc
#define prog_timeout v.prog.timeout
#define prog_env v.prog.env
-#define sentinel_watcher v.sentinel.watcher
+#define sentinel_watchpoint v.sentinel.watchpoint
};
typedef struct handler_list *handler_list_t;
typedef struct handler_iterator *handler_iterator_t;
-/* A directory watcher is described by the following structure */
-struct dirwatcher {
+/* Watchpoint links the directory being monitored and a list of
+ handlers for various events: */
+struct watchpoint {
size_t refcnt;
int wd; /* Watch descriptor */
- struct dirwatcher *parent; /* Points to the parent watcher.
+ struct watchpoint *parent; /* Points to the parent watcher.
NULL for top-level watchers */
char *dirname; /* Pathname being watched */
handler_list_t handler_list; /* List of handlers */
@@ -174,10 +175,10 @@ void debugprt(const char *fmt, ...);
void signal_setup(void (*sf) (int));
int detach(void (*)(void));
-int sysev_filemask(struct dirwatcher *dp);
+int sysev_filemask(struct watchpoint *dp);
void sysev_init(void);
-int sysev_add_watch(struct dirwatcher *dwp, event_mask mask);
-void sysev_rm_watch(struct dirwatcher *dwp);
+int sysev_add_watch(struct watchpoint *dwp, event_mask mask);
+void sysev_rm_watch(struct watchpoint *dwp);
int sysev_select(void);
int sysev_name_to_code(const char *name);
const char *sysev_code_to_name(int code);
@@ -240,35 +241,35 @@ void config_parse(const char *file);
int get_facility(const char *arg);
int get_priority(const char *arg);
-int dirwatcher_init(struct dirwatcher *dwp);
-void dirwatcher_ref(struct dirwatcher *dw);
-void dirwatcher_unref(struct dirwatcher *dw);
-void dirwatcher_gc(void);
+int watchpoint_init(struct watchpoint *dwp);
+void watchpoint_ref(struct watchpoint *dw);
+void watchpoint_unref(struct watchpoint *dw);
+void watchpoint_gc(void);
-int dirwatcher_pattern_match(struct dirwatcher *dwp, const char *file_name);
+int watchpoint_pattern_match(struct watchpoint *dwp, const char *file_name);
void setup_watchers(void);
void shutdown_watchers(void);
-struct dirwatcher *dirwatcher_lookup(const char *dirname);
+struct watchpoint *watchpoint_lookup(const char *dirname);
int check_new_watcher(const char *dir, const char *name);
-struct dirwatcher *dirwatcher_install(const char *path, int *pnew);
-struct dirwatcher *dirwatcher_install_ptr(struct dirwatcher *dw);
-void dirwatcher_suspend(struct dirwatcher *dwp);
-void dirwatcher_destroy(struct dirwatcher *dwp);
-struct dirwatcher *dirwatcher_install_sentinel(struct dirwatcher *dwp);
+struct watchpoint *watchpoint_install(const char *path, int *pnew);
+struct watchpoint *watchpoint_install_ptr(struct watchpoint *dw);
+void watchpoint_suspend(struct watchpoint *dwp);
+void watchpoint_destroy(struct watchpoint *dwp);
+struct watchpoint *watchpoint_install_sentinel(struct watchpoint *dwp);
-int watch_pathname(struct dirwatcher *parent, const char *dirname, int isdir, int notify);
+int watch_pathname(struct watchpoint *parent, const char *dirname, int isdir, int notify);
-char *split_pathname(struct dirwatcher *dp, char **dirname);
-void unsplit_pathname(struct dirwatcher *dp);
+char *split_pathname(struct watchpoint *dp, char **dirname);
+void unsplit_pathname(struct watchpoint *dp);
-void ev_log(int flags, struct dirwatcher *dp);
-void deliver_ev_create(struct dirwatcher *dp, const char *name);
-int subwatcher_create(struct dirwatcher *parent, const char *dirname,
+void ev_log(int flags, struct watchpoint *dp);
+void deliver_ev_create(struct watchpoint *dp, const char *name);
+int subwatcher_create(struct watchpoint *parent, const char *dirname,
int isdir, int notify);
-struct handler *handler_itr_first(struct dirwatcher *dp,
+struct handler *handler_itr_first(struct watchpoint *dp,
handler_iterator_t *itr);
struct handler *handler_itr_next(handler_iterator_t *itr);
struct handler *handler_itr_current(handler_iterator_t itr);
@@ -291,7 +292,7 @@ size_t handler_list_size(handler_list_t hlist);
struct process *process_lookup(pid_t pid);
void process_cleanup(int expect_term);
void process_timeouts(void);
-int run_handler(struct dirwatcher *dp, struct handler *hp, event_mask *event,
+int run_handler(struct watchpoint *dp, struct handler *hp, event_mask *event,
const char *dir, const char *file);
char **environ_setup(char **hint, char **kve);
diff --git a/src/ev_inotify.c b/src/ev_inotify.c
index 6d4c03a..7b2ee1d 100644
--- a/src/ev_inotify.c
+++ b/src/ev_inotify.c
@@ -45,30 +45,30 @@ event_mask genev_xlat[] = {
static int ifd;
-static struct dirwatcher **dwtab;
-static size_t dwsize;
+static struct watchpoint **wptab;
+static size_t wpsize;
static int
-dwreg(int wd, struct dirwatcher *wp)
+wpreg(int wd, struct watchpoint *wpt)
{
if (wd < 0)
abort();
- if (wd >= dwsize) {
- size_t n = dwsize;
- struct dirwatcher **p;
+ if (wd >= wpsize) {
+ size_t n = wpsize;
+ struct watchpoint **p;
if (n == 0)
n = sysconf(_SC_OPEN_MAX);
while (wd >= n) {
n *= 2;
- if (n < dwsize) {
+ if (n < wpsize) {
diag(LOG_CRIT,
_("can't allocate memory for fd %d"),
wd);
return -1;
}
}
- p = realloc(dwtab, n * sizeof(dwtab[0]));
+ p = realloc(wptab, n * sizeof(wptab[0]));
if (!p) {
diag(LOG_CRIT,
_("can't allocate memory for fd %d"),
@@ -76,36 +76,36 @@ dwreg(int wd, struct dirwatcher *wp)
return -1;
}
- memset(p + dwsize, 0, (n - dwsize) * sizeof(dwtab[0]));
- dwtab = p;
- dwsize = n;
+ memset(p + wpsize, 0, (n - wpsize) * sizeof(wptab[0]));
+ wptab = p;
+ wpsize = n;
}
- dirwatcher_ref(wp);
- dwtab[wd] = wp;
+ watchpoint_ref(wpt);
+ wptab[wd] = wpt;
return 0;
}
static void
-dwunreg(int wd)
+wpunreg(int wd)
{
- if (wd < 0 || wd > dwsize)
+ if (wd < 0 || wd > wpsize)
abort();
- if (dwtab[wd]) {
- dirwatcher_unref(dwtab[wd]);
- dwtab[wd] = NULL;
+ if (wptab[wd]) {
+ watchpoint_unref(wptab[wd]);
+ wptab[wd] = NULL;
}
}
-static struct dirwatcher *
-dwget(int wd)
+static struct watchpoint *
+wpget(int wd)
{
- if (wd >= 0 && wd < dwsize)
- return dwtab[wd];
+ if (wd >= 0 && wd < wpsize)
+ return wptab[wd];
return NULL;
}
int
-sysev_filemask(struct dirwatcher *dp)
+sysev_filemask(struct watchpoint *dp)
{
return 0;
}
@@ -121,10 +121,10 @@ sysev_init()
}
int
-sysev_add_watch(struct dirwatcher *dwp, event_mask mask)
+sysev_add_watch(struct watchpoint *wpt, event_mask mask)
{
- int wd = inotify_add_watch(ifd, dwp->dirname, mask.sys_mask);
- if (wd >= 0 && dwreg(wd, dwp)) {
+ int wd = inotify_add_watch(ifd, wpt->dirname, mask.sys_mask);
+ if (wd >= 0 && wpreg(wd, wpt)) {
inotify_rm_watch(ifd, wd);
return -1;
}
@@ -132,39 +132,39 @@ sysev_add_watch(struct dirwatcher *dwp, event_mask mask)
}
void
-sysev_rm_watch(struct dirwatcher *dwp)
+sysev_rm_watch(struct watchpoint *wpt)
{
- dwunreg(dwp->wd);
- inotify_rm_watch(ifd, dwp->wd);
+ wpunreg(wpt->wd);
+ inotify_rm_watch(ifd, wpt->wd);
}
/* Remove a watcher identified by its directory and file name */
void
remove_watcher(const char *dir, const char *name)
{
- struct dirwatcher *dwp;
+ struct watchpoint *wpt;
char *fullname = mkfilename(dir, name);
if (!fullname) {
diag(LOG_EMERG, "not enough memory: "
"cannot look up a watcher to delete");
return;
}
- dwp = dirwatcher_lookup(fullname);
+ wpt = watchpoint_lookup(fullname);
free(fullname);
- if (dwp)
- dirwatcher_suspend(dwp);
+ if (wpt)
+ watchpoint_suspend(wpt);
}
static void
process_event(struct inotify_event *ep)
{
- struct dirwatcher *dp;
+ struct watchpoint *dp;
struct handler *h;
handler_iterator_t itr;
event_mask m;
char *dirname, *filename;
- dp = dwget(ep->wd);
+ dp = wpget(ep->wd);
if (!dp) {
if (!(ep->mask & IN_IGNORED))
diag(LOG_NOTICE, _("watcher not found: %d (%s)"),
@@ -174,7 +174,7 @@ process_event(struct inotify_event *ep)
if (ep->mask & IN_IGNORED) {
diag(LOG_NOTICE, _("%s deleted"), dp->dirname);
- dirwatcher_suspend(dp);
+ watchpoint_suspend(dp);
return;
}
diff --git a/src/ev_kqueue.c b/src/ev_kqueue.c
index a9921c6..680fb42 100644
--- a/src/ev_kqueue.c
+++ b/src/ev_kqueue.c
@@ -60,7 +60,7 @@ sysev_init()
}
int
-sysev_filemask(struct dirwatcher *dp)
+sysev_filemask(struct watchpoint *dp)
{
struct handler *h;
handler_iterator_t itr;
@@ -73,9 +73,9 @@ sysev_filemask(struct dirwatcher *dp)
}
int
-sysev_add_watch(struct dirwatcher *dwp, event_mask mask)
+sysev_add_watch(struct watchpoint *wpt, event_mask mask)
{
- int wd = open(dwp->dirname, O_RDONLY);
+ int wd = open(wpt->dirname, O_RDONLY);
if (wd >= 0) {
struct stat st;
int sysmask;
@@ -84,26 +84,26 @@ sysev_add_watch(struct dirwatcher *dwp, event_mask mask)
close(wd);
return -1;
}
- dwp->file_mode = st.st_mode;
- dwp->file_ctime = st.st_ctime;
+ wpt->file_mode = st.st_mode;
+ wpt->file_ctime = st.st_ctime;
sysmask = mask.sys_mask;
if (S_ISDIR(st.st_mode) && mask.gen_mask & GENEV_CREATE)
sysmask |= NOTE_WRITE;
EV_SET(chtab + chcnt, wd, EVFILT_VNODE,
EV_ADD | EV_ENABLE | EV_CLEAR, sysmask,
- 0, dwp);
+ 0, wpt);
wd = chcnt++;
}
return wd;
}
void
-sysev_rm_watch(struct dirwatcher *dwp)
+sysev_rm_watch(struct watchpoint *wpt)
{
- close(chtab[dwp->wd].ident);
- chtab[dwp->wd].ident = -1;
- if (chclosed == -1 || chclosed > dwp->wd)
- chclosed = dwp->wd;
+ close(chtab[wpt->wd].ident);
+ chtab[wpt->wd].ident = -1;
+ if (chclosed == -1 || chclosed > wpt->wd)
+ chclosed = wpt->wd;
}
static void
@@ -116,11 +116,11 @@ chclosed_elim()
for (i = chclosed, j = chclosed + 1; j < chcnt; j++)
if (chtab[j].ident != -1) {
- struct dirwatcher *dwp;
+ struct watchpoint *wpt;
chtab[i] = chtab[j];
- dwp = chtab[i].udata;
- dwp->wd = i;
+ wpt = chtab[i].udata;
+ wpt->wd = i;
i++;
}
chcnt = i;
@@ -128,7 +128,7 @@ chclosed_elim()
}
static void
-check_created(struct dirwatcher *dp)
+check_created(struct watchpoint *dp)
{
DIR *dir;
struct dirent *ent;
@@ -150,7 +150,7 @@ check_created(struct dirwatcher *dp)
(ent->d_name[1] == '.' && ent->d_name[2] == 0)))
continue;
- if (dirwatcher_pattern_match(dp, ent->d_name))
+ if (watchpoint_pattern_match(dp, ent->d_name))
continue;
pathname = mkfilename(dp->dirname, ent->d_name);
@@ -171,7 +171,7 @@ check_created(struct dirwatcher *dp)
know about that file. If the file is new, register
a watcher for it. */
} else if (st.st_ctime > dp->file_ctime ||
- !dirwatcher_lookup(pathname)) {
+ !watchpoint_lookup(pathname)) {
deliver_ev_create(dp, ent->d_name);
subwatcher_create(dp, pathname,
S_ISDIR(st.st_mode), 1);
@@ -185,7 +185,7 @@ check_created(struct dirwatcher *dp)
static void
process_event(struct kevent *ep)
{
- struct dirwatcher *dp = ep->udata;
+ struct watchpoint *dp = ep->udata;
struct handler *h;
handler_iterator_t itr;
event_mask m;
@@ -217,7 +217,7 @@ process_event(struct kevent *ep)
if (ep->fflags & (NOTE_DELETE|NOTE_RENAME)) {
debug(1, ("%s deleted", dp->dirname));
- dirwatcher_suspend(dp);
+ watchpoint_suspend(dp);
return;
}
}
diff --git a/src/handler.c b/src/handler.c
index 0e86a44..2d27824 100644
--- a/src/handler.c
+++ b/src/handler.c
@@ -108,7 +108,7 @@ handler_free(struct handler *hp)
envfree(hp->prog_env);
break;
case HANDLER_SENTINEL:
- dirwatcher_unref(hp->sentinel_watcher);
+ watchpoint_unref(hp->sentinel_watchpoint);
}
}
@@ -146,11 +146,11 @@ struct handler_iterator {
static struct handler_iterator *itr_avail;
struct handler *
-handler_itr_first(struct dirwatcher *dwp, handler_iterator_t *ret_itr)
+handler_itr_first(struct watchpoint *wpt, handler_iterator_t *ret_itr)
{
struct handler_iterator *itr;
- if (!dwp->handler_list)
+ if (!wpt->handler_list)
return NULL;
if (itr_avail) {
@@ -162,13 +162,13 @@ handler_itr_first(struct dirwatcher *dwp, handler_iterator_t *ret_itr)
itr = emalloc(sizeof *itr);
itr->prev = NULL;
- itr->next = dwp->handler_list->itr_chain;
- itr->hlist = dwp->handler_list;
- if (dwp->handler_list->itr_chain)
- dwp->handler_list->itr_chain->prev = itr;
- dwp->handler_list->itr_chain = itr;
+ itr->next = wpt->handler_list->itr_chain;
+ itr->hlist = wpt->handler_list;
+ if (wpt->handler_list->itr_chain)
+ wpt->handler_list->itr_chain->prev = itr;
+ wpt->handler_list->itr_chain = itr;
- itr->ent = dwp->handler_list->list->head;
+ itr->ent = wpt->handler_list->list->head;
itr->advanced = 0;
*ret_itr = itr;
return handler_itr_current(itr);
@@ -284,5 +284,5 @@ handler_list_remove(handler_list_t hlist, struct handler *hp)
grecs_list_remove_entry(hlist->list, ep);
if (grecs_list_size(hlist->list) == 0)
/* Remove watchers that don't have handlers */
- dirwatcher_gc();
+ watchpoint_gc();
}
diff --git a/src/progman.c b/src/progman.c
index 823d51c..134deaf 100644
--- a/src/progman.c
+++ b/src/progman.c
@@ -541,16 +541,16 @@ run_handler_prog(struct handler *hp, event_mask *event,
}
static int
-run_sentinel(struct dirwatcher *dp, struct handler *hp)
+run_sentinel(struct watchpoint *dp, struct handler *hp)
{
- dirwatcher_init(hp->sentinel_watcher);
- dirwatcher_install_ptr(hp->sentinel_watcher);
+ watchpoint_init(hp->sentinel_watchpoint);
+ watchpoint_install_ptr(hp->sentinel_watchpoint);
handler_list_remove(dp->handler_list, hp);
return 0;
}
int
-run_handler(struct dirwatcher *dp, struct handler *hp, event_mask *event,
+run_handler(struct watchpoint *dp, struct handler *hp, event_mask *event,
const char *dirname, const char *file)
{
int rc;
diff --git a/src/watcher.c b/src/watcher.c
index b625276..e0b4950 100644
--- a/src/watcher.c
+++ b/src/watcher.c
@@ -19,177 +19,177 @@
#include <sys/stat.h>
void
-dirwatcher_ref(struct dirwatcher *dw)
+watchpoint_ref(struct watchpoint *wpt)
{
- ++dw->refcnt;
+ ++wpt->refcnt;
}
void
-dirwatcher_unref(struct dirwatcher *dw)
+watchpoint_unref(struct watchpoint *wpt)
{
- if (--dw->refcnt)
+ if (--wpt->refcnt)
return;
- free(dw->dirname);
- handler_list_unref(dw->handler_list);
- free(dw);
+ free(wpt->dirname);
+ handler_list_unref(wpt->handler_list);
+ free(wpt);
}
-struct dwref {
+struct wpref {
int used;
- struct dirwatcher *dw;
+ struct watchpoint *wpt;
};
static unsigned
-dwname_hash(void *data, unsigned long hashsize)
+wpref_hash(void *data, unsigned long hashsize)
{
- struct dwref *sym = data;
- return hash_string(sym->dw->dirname, hashsize);
+ struct wpref *sym = data;
+ return hash_string(sym->wpt->dirname, hashsize);
}
static int
-dwname_cmp(const void *a, const void *b)
+wpref_cmp(const void *a, const void *b)
{
- struct dwref const *syma = a;
- struct dwref const *symb = b;
+ struct wpref const *syma = a;
+ struct wpref const *symb = b;
- return strcmp(syma->dw->dirname, symb->dw->dirname);
+ return strcmp(syma->wpt->dirname, symb->wpt->dirname);
}
static int
-dwname_copy(void *a, void *b)
+wpref_copy(void *a, void *b)
{
- struct dwref *syma = a;
- struct dwref *symb = b;
+ struct wpref *syma = a;
+ struct wpref *symb = b;
syma->used = 1;
- syma->dw = symb->dw;
+ syma->wpt = symb->wpt;
return 0;
}
static void
-dwref_free(void *p)
+wpref_free(void *p)
{
- struct dwref *dwref = p;
- dirwatcher_unref(dwref->dw);
- free(dwref);
+ struct wpref *wpref = p;
+ watchpoint_unref(wpref->wpt);
+ free(wpref);
}
struct hashtab *nametab;
-struct dirwatcher *
-dirwatcher_install(const char *path, int *pnew)
+struct watchpoint *
+watchpoint_install(const char *path, int *pnew)
{
- struct dirwatcher *dw, dwkey;
- struct dwref key;
- struct dwref *ent;
+ struct watchpoint *wpt, wpkey;
+ struct wpref key;
+ struct wpref *ent;
int install = 1;
if (!nametab) {
- nametab = hashtab_create(sizeof(struct dwref),
- dwname_hash, dwname_cmp, dwname_copy,
- NULL, dwref_free);
+ nametab = hashtab_create(sizeof(struct wpref),
+ wpref_hash, wpref_cmp, wpref_copy,
+ NULL, wpref_free);
if (!nametab) {
diag(LOG_CRIT, _("not enough memory"));
exit(1);
}
}
- dwkey.dirname = (char*) path;
- key.dw = &dwkey;
+ wpkey.dirname = (char*) path;
+ key.wpt = &wpkey;
ent = hashtab_lookup_or_install(nametab, &key, &install);
if (install) {
- dw = ecalloc(1, sizeof(*dw));
- dw->dirname = estrdup(path);
- dw->wd = -1;
- dw->handler_list = handler_list_create();
- dw->refcnt++;
- ent->dw = dw;
+ wpt = ecalloc(1, sizeof(*wpt));
+ wpt->dirname = estrdup(path);
+ wpt->wd = -1;
+ wpt->handler_list = handler_list_create();
+ wpt->refcnt++;
+ ent->wpt = wpt;
}
if (!ent)
abort(); /* FIXME */
if (pnew)
*pnew = install;
- return ent->dw;
+ return ent->wpt;
}
-struct dirwatcher *
-dirwatcher_install_ptr(struct dirwatcher *dw)
+struct watchpoint *
+watchpoint_install_ptr(struct watchpoint *wpt)
{
- struct dwref key;
+ struct wpref key;
int install = 1;
- key.dw = dw;
+ key.wpt = wpt;
if (!hashtab_lookup_or_install(nametab, &key, &install)) {
diag(LOG_CRIT, _("not enough memory"));
exit(1);
}
- dirwatcher_ref(dw);
- return dw;
+ watchpoint_ref(wpt);
+ return wpt;
}
static int
-dwref_gc(struct hashent *ent, void *data)
+wpref_gc(struct hashent *ent, void *data)
{
- struct dwref *dwref = (struct dwref *) ent;
- struct dirwatcher *dwp = dwref->dw;
+ struct wpref *wpref = (struct wpref *) ent;
+ struct watchpoint *wpt = wpref->wpt;
- if (handler_list_size(dwp->handler_list) == 0)
- dirwatcher_destroy(dwp);
+ if (handler_list_size(wpt->handler_list) == 0)
+ watchpoint_destroy(wpt);
return 0;
}
void
-dirwatcher_gc(void)
+watchpoint_gc(void)
{
- hashtab_foreach(nametab, dwref_gc, NULL);
+ hashtab_foreach(nametab, wpref_gc, NULL);
}
-struct dirwatcher *
-dirwatcher_lookup(const char *dirname)
+struct watchpoint *
+watchpoint_lookup(const char *dirname)
{
- struct dirwatcher dwkey;
- struct dwref key;
- struct dwref *ent;
+ struct watchpoint wpkey;
+ struct wpref key;
+ struct wpref *ent;
if (!nametab)
return NULL;
- dwkey.dirname = (char*) dirname;
- key.dw = &dwkey;
+ wpkey.dirname = (char*) dirname;
+ key.wpt = &wpkey;
ent = hashtab_lookup_or_install(nametab, &key, NULL);
- return ent ? ent->dw : NULL;
+ return ent ? ent->wpt : NULL;
}
static void
-dirwatcher_remove(const char *dirname)
+watchpoint_remove(const char *dirname)
{
- struct dirwatcher dwkey;
- struct dwref key;
+ struct watchpoint wpkey;
+ struct wpref key;
if (!nametab)
return;
- dwkey.dirname = (char*) dirname;
- key.dw = &dwkey;
+ wpkey.dirname = (char*) dirname;
+ key.wpt = &wpkey;
hashtab_remove(nametab, &key);
}
void
-dirwatcher_destroy(struct dirwatcher *dwp)
+watchpoint_destroy(struct watchpoint *wpt)
{
- debug(1, (_("removing watcher %s"), dwp->dirname));
- sysev_rm_watch(dwp);
- dirwatcher_remove(dwp->dirname);
+ debug(1, (_("removing watcher %s"), wpt->dirname));
+ sysev_rm_watch(wpt);
+ watchpoint_remove(wpt->dirname);
}
// FIXME: Perhaps the check for count is not needed after all
void
-dirwatcher_suspend(struct dirwatcher *dwp)
+watchpoint_suspend(struct watchpoint *wpt)
{
- struct dirwatcher *sent = dirwatcher_install_sentinel(dwp);
- dirwatcher_init(sent);//FIXME: error checking
- dirwatcher_destroy(dwp);
+ struct watchpoint *sent = watchpoint_install_sentinel(wpt);
+ watchpoint_init(sent);//FIXME: error checking
+ watchpoint_destroy(wpt);
if (hashtab_count(nametab) == 0) {
diag(LOG_CRIT, _("no watchers left; exiting now"));
stop = 1;
@@ -197,7 +197,7 @@ dirwatcher_suspend(struct dirwatcher *dwp)
}
static int
-convert_watcher(struct dirwatcher *dwp)
+convert_watcher(struct watchpoint *wpt)
{
char *dirname;
char *filename;
@@ -205,51 +205,51 @@ convert_watcher(struct dirwatcher *dwp)
struct handler *hp;
handler_iterator_t itr;
- for_each_handler(dwp, itr, hp) {
+ for_each_handler(wpt, itr, hp) {
if (hp->fnames) {
/* FIXME: Error message */
return 1;
}
}
- filename = split_pathname(dwp, &dirname);
- for_each_handler(dwp, itr, hp)
+ filename = split_pathname(wpt, &dirname);
+ for_each_handler(wpt, itr, hp)
handler_add_exact_filename(hp, filename);
new_dirname = estrdup(dirname);
- unsplit_pathname(dwp);
+ unsplit_pathname(wpt);
diag(LOG_NOTICE, _("watcher %s converted to %s"),
- dwp->dirname, new_dirname);
+ wpt->dirname, new_dirname);
- free(dwp->dirname);
- dwp->dirname = new_dirname;
+ free(wpt->dirname);
+ wpt->dirname = new_dirname;
return 0;
}
-struct dirwatcher *
-dirwatcher_install_sentinel(struct dirwatcher *dwp)
+struct watchpoint *
+watchpoint_install_sentinel(struct watchpoint *wpt)
{
- struct dirwatcher *sent;
+ struct watchpoint *sent;
char *dirname;
char *filename;
struct handler *hp;
- filename = split_pathname(dwp, &dirname);
- sent = dirwatcher_install(dirname, NULL);
+ filename = split_pathname(wpt, &dirname);
+ sent = watchpoint_install(dirname, NULL);
hp = handler_alloc(HANDLER_SENTINEL);
getevt("CREATE", &hp->ev_mask);
- hp->sentinel_watcher = dwp;
- dirwatcher_ref(dwp);
+ hp->sentinel_watchpoint = wpt;
+ watchpoint_ref(wpt);
handler_add_exact_filename(hp, filename);
handler_list_append(sent->handler_list, hp);
- unsplit_pathname(dwp);
- diag(LOG_NOTICE, _("installing CREATE sentinel for %s"), dwp->dirname);
- dirwatcher_init(sent);
+ unsplit_pathname(wpt);
+ diag(LOG_NOTICE, _("installing CREATE sentinel for %s"), wpt->dirname);
+ watchpoint_init(sent);
return sent;
}
int
-dirwatcher_init(struct dirwatcher *dwp)
+watchpoint_init(struct watchpoint *wpt)
{
struct stat st;
event_mask mask = { 0, 0 };
@@ -257,73 +257,73 @@ dirwatcher_init(struct dirwatcher *dwp)
handler_iterator_t itr;
int wd;
- debug(1, (_("creating watcher %s"), dwp->dirname));
+ debug(1, (_("creating watcher %s"), wpt->dirname));
- if (stat(dwp->dirname, &st)) {
+ if (stat(wpt->dirname, &st)) {
if (errno == ENOENT) {
- dwp = dirwatcher_install_sentinel(dwp);
+ wpt = watchpoint_install_sentinel(wpt);
return 0;
} else {
diag(LOG_ERR, _("cannot set watcher on %s: %s"),
- dwp->dirname, strerror(errno));
+ wpt->dirname, strerror(errno));
return 1;
}
} else if (!S_ISDIR(st.st_mode)) {
- diag(LOG_NOTICE, _("%s is a regular file"), dwp->dirname);
- convert_watcher(dwp);
+ diag(LOG_NOTICE, _("%s is a regular file"), wpt->dirname);
+ convert_watcher(wpt);
}
- for_each_handler(dwp, itr, hp) {
+ for_each_handler(wpt, itr, hp) {
mask.sys_mask |= hp->ev_mask.sys_mask;
mask.gen_mask |= hp->ev_mask.gen_mask;
}
- wd = sysev_add_watch(dwp, mask);
+ wd = sysev_add_watch(wpt, mask);
if (wd == -1) {
diag(LOG_ERR, _("cannot set watcher on %s: %s"),
- dwp->dirname, strerror(errno));
+ wpt->dirname, strerror(errno));
return 1;
}
- dwp->wd = wd;
+ wpt->wd = wd;
return 0;
}
-static int watch_subdirs(struct dirwatcher *parent, int notify);
+static int watch_subdirs(struct watchpoint *parent, int notify);
int
-subwatcher_create(struct dirwatcher *parent, const char *dirname,
+subwatcher_create(struct watchpoint *parent, const char *dirname,
int isdir, int notify)
{
- struct dirwatcher *dwp;
+ struct watchpoint *wpt;
int inst;
- dwp = dirwatcher_install(dirname, &inst);
+ wpt = watchpoint_install(dirname, &inst);
if (!inst)
return -1;
- dwp->handler_list = handler_list_copy(parent->handler_list);
- dwp->parent = parent;
+ wpt->handler_list = handler_list_copy(parent->handler_list);
+ wpt->parent = parent;
if (parent->depth == -1)
- dwp->depth = parent->depth;
+ wpt->depth = parent->depth;
else if (parent->depth)
- dwp->depth = parent->depth - 1;
+ wpt->depth = parent->depth - 1;
else
- dwp->depth = 0;
+ wpt->depth = 0;
- if (dirwatcher_init(dwp)) {
- //FIXME dirwatcher_free(dwp);
+ if (watchpoint_init(wpt)) {
+ //FIXME watchpoint_free(wpt);
return -1;
}
- return 1 + (isdir ? watch_subdirs(dwp, notify) : 0);
+ return 1 + (isdir ? watch_subdirs(wpt, notify) : 0);
}
/* Deliver GENEV_CREATE event */
void
-deliver_ev_create(struct dirwatcher *dp, const char *name)
+deliver_ev_create(struct watchpoint *dp, const char *name)
{
event_mask m = { GENEV_CREATE, 0 };
struct handler *h;
@@ -352,9 +352,9 @@ check_new_watcher(const char *dir, const char *name)
int rc;
char *fname;
struct stat st;
- struct dirwatcher *parent;
+ struct watchpoint *parent;
- parent = dirwatcher_lookup(dir);
+ parent = watchpoint_lookup(dir);
if (!parent || !parent->depth)
return 0;
@@ -381,12 +381,12 @@ check_new_watcher(const char *dir, const char *name)
}
int
-dirwatcher_pattern_match(struct dirwatcher *dwp, const char *file_name)
+watchpoint_pattern_match(struct watchpoint *wpt, const char *file_name)
{
struct handler *hp;
handler_iterator_t itr;
- for_each_handler(dwp, itr, hp) {
+ for_each_handler(wpt, itr, hp) {
if (filename_pattern_match(hp->fnames, file_name) == 0)
return 0;
}
@@ -396,7 +396,7 @@ dirwatcher_pattern_match(struct dirwatcher *dwp, const char *file_name)
/* Recursively scan subdirectories of parent and add them to the
watcher list, as requested by the parent's recursion depth value. */
static int
-watch_subdirs(struct dirwatcher *parent, int notify)
+watch_subdirs(struct watchpoint *parent, int notify)
{
DIR *dir;
struct dirent *ent;
@@ -434,7 +434,7 @@ watch_subdirs(struct dirwatcher *parent, int notify)
if (stat(dirname, &st)) {
diag(LOG_ERR, _("cannot stat %s: %s"),
dirname, strerror(errno));
- } else if (dirwatcher_pattern_match(parent, ent->d_name)
+ } else if (watchpoint_pattern_match(parent, ent->d_name)
== 0) {
if (notify)
deliver_ev_create(parent, ent->d_name);
@@ -456,20 +456,20 @@ watch_subdirs(struct dirwatcher *parent, int notify)
static int
setwatcher(struct hashent *ent, void *data)
{
- struct dwref *dwref = (struct dwref *) ent;
- struct dirwatcher *dwp = dwref->dw;
+ struct wpref *wpref = (struct wpref *) ent;
+ struct watchpoint *wpt = wpref->wpt;
- if (dwp->wd == -1 && dirwatcher_init(dwp) == 0)
- watch_subdirs(dwp, 0);
+ if (wpt->wd == -1 && watchpoint_init(wpt) == 0)
+ watch_subdirs(wpt, 0);
return 0;
}
static int
checkwatcher(struct hashent *ent, void *data)
{
- struct dwref *dwref = (struct dwref *) ent;
- struct dirwatcher *dwp = dwref->dw;
- return dwp->wd >= 0;
+ struct wpref *wpref = (struct wpref *) ent;
+ struct watchpoint *wpt = wpref->wpt;
+ return wpt->wd >= 0;
}
void
@@ -490,11 +490,11 @@ setup_watchers(void)
static int
stopwatcher(struct hashent *ent, void *data)
{
- struct dwref *dwref = (struct dwref *) ent;
- struct dirwatcher *dwp = dwref->dw;
- if (dwp->wd != -1) {
- debug(1, (_("removing watcher %s"), dwp->dirname));
- sysev_rm_watch(dwp);
+ struct wpref *wpref = (struct wpref *) ent;
+ struct watchpoint *wpt = wpref->wpt;
+ if (wpt->wd != -1) {
+ debug(1, (_("removing watcher %s"), wpt->dirname));
+ sysev_rm_watch(wpt);
}
return 0;
}
@@ -508,7 +508,7 @@ shutdown_watchers(void)
char *
-split_pathname(struct dirwatcher *dp, char **dirname)
+split_pathname(struct watchpoint *dp, char **dirname)
{
char *p = strrchr(dp->dirname, '/');
if (p) {
@@ -523,7 +523,7 @@ split_pathname(struct dirwatcher *dp, char **dirname)
}
void
-unsplit_pathname(struct dirwatcher *dp)
+unsplit_pathname(struct watchpoint *dp)
{
if (dp->split_p) {
*dp->split_p = '/';

Return to:

Send suggestions and report system problems to the System administrator.