/*
- * Copyright (c) 2004-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2014 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <security/audit/audit.h>
#include <bsm/audit_kevents.h>
-
+#include <pexpert/pexpert.h>
typedef struct kfs_event {
LIST_ENTRY(kfs_event) kevent_list;
uint32_t num_dropped;
uint64_t max_event_id;
struct fsevent_handle *fseh;
+ pid_t pid;
+ char proc_name[(2 * MAXCOMLEN) + 1];
} fs_event_watcher;
// fs_event_watcher flags
#define WATCHER_CLOSING 0x0002
#define WATCHER_WANTS_COMPACT_EVENTS 0x0004
#define WATCHER_WANTS_EXTENDED_INFO 0x0008
-
+#define WATCHER_APPLE_SYSTEM_SERVICE 0x0010 // fseventsd, coreservicesd, mds
#define MAX_WATCHERS 8
static fs_event_watcher *watcher_table[MAX_WATCHERS];
-
-#define MAX_KFS_EVENTS 4096
+#define DEFAULT_MAX_KFS_EVENTS 4096
+static int max_kfs_events = DEFAULT_MAX_KFS_EVENTS;
// we allocate kfs_event structures out of this zone
static zone_t event_zone;
size_t member_size,
int (*)(const void *, const void *));
+static int
+is_ignored_directory(const char *path) {
+
+ if (!path) {
+ return 0;
+ }
+
+#define IS_TLD(x) strnstr((char *) path, x, MAXPATHLEN)
+ if (IS_TLD("/.Spotlight-V100/") ||
+ IS_TLD("/.MobileBackups/") ||
+ IS_TLD("/Backups.backupdb/")) {
+ return 1;
+ }
+#undef IS_TLD
+
+ return 0;
+}
static void
fsevents_internal_init(void)
lck_rw_init(&event_handling_lock, fsevent_rw_group, fsevent_lock_attr);
+ PE_get_default("kern.maxkfsevents", &max_kfs_events, sizeof(max_kfs_events));
+
event_zone = zinit(sizeof(kfs_event),
- MAX_KFS_EVENTS * sizeof(kfs_event),
- MAX_KFS_EVENTS * sizeof(kfs_event),
+ max_kfs_events * sizeof(kfs_event),
+ max_kfs_events * sizeof(kfs_event),
"fs-event-buf");
if (event_zone == NULL) {
printf("fsevents: failed to initialize the event zone.\n");
}
- if (zfill(event_zone, MAX_KFS_EVENTS) != MAX_KFS_EVENTS) {
- printf("fsevents: failed to pre-fill the event zone.\n");
- }
-
// mark the zone as exhaustible so that it will not
// ever grow beyond what we initially filled it with
zone_change(event_zone, Z_EXHAUST, TRUE);
zone_change(event_zone, Z_COLLECT, FALSE);
zone_change(event_zone, Z_CALLERACCT, FALSE);
+
+ if (zfill(event_zone, max_kfs_events) < max_kfs_events) {
+ printf("fsevents: failed to pre-fill the event zone.\n");
+ }
+
}
static void
return 1;
}
-static int
-prefix_match_len(const char *str1, const char *str2)
-{
- int len=0;
-
- while(*str1 && *str2 && *str1 == *str2) {
- len++;
- str1++;
- str2++;
- }
-
- if (*str1 == '\0' && *str2 == '\0') {
- len++;
- }
-
- return len;
-}
-
-
-struct history_item {
- kfs_event *kfse;
- kfs_event *oldest_kfse;
- int counter;
-};
-
-static int
-compare_history_items(const void *_a, const void *_b)
-{
- const struct history_item *a = (const struct history_item *)_a;
- const struct history_item *b = (const struct history_item *)_b;
-
- // we want a descending order
- return (b->counter - a->counter);
-}
#define is_throw_away(x) ((x) == FSE_STAT_CHANGED || (x) == FSE_CONTENT_MODIFIED)
#define KFSE_RECYCLED 0x0004
int num_dropped = 0;
-int num_combined_events = 0;
-int num_added_to_parent = 0;
int num_parent_switch = 0;
int num_recycled_rename = 0;
-//
-// NOTE: you must call lock_fs_event_list() before calling
-// this function.
-//
-static kfs_event *
-find_an_event(const char *str, int len, kfs_event *do_not_reuse, int *reuse_type, int *longest_match_len)
-{
- kfs_event *kfse, *best_kfse=NULL;
-
-// this seems to be enough to find most duplicate events for the same vnode
-#define MAX_HISTORY 12
- struct history_item history[MAX_HISTORY];
- int i;
-
- *longest_match_len = 0;
- *reuse_type = 0;
-
- memset(history, 0, sizeof(history));
-
- //
- // now walk the list of events and try to find the best match
- // for this event. if we have a vnode, we look for an event
- // that already references the vnode. if we don't find one
- // we'll also take the parent of this vnode (in which case it
- // will be marked as having dropped events within it).
- //
- // if we have a string we look for the longest match on the
- // path we have.
- //
-
- LIST_FOREACH(kfse, &kfse_list_head, kevent_list) {
- int match_len;
-
- //
- // don't look at events that are still in the process of being
- // created, have a null vnode ptr or rename/exchange events.
- //
- if ( (kfse->flags & KFSE_BEING_CREATED) || kfse->type == FSE_RENAME || kfse->type == FSE_EXCHANGE) {
-
- continue;
- }
-
- if (str != NULL) {
- if (kfse->len != 0 && kfse->str != NULL) {
- match_len = prefix_match_len(str, kfse->str);
- if (match_len > *longest_match_len) {
- best_kfse = kfse;
- *longest_match_len = match_len;
- }
- }
- }
-
- if (kfse == do_not_reuse) {
- continue;
- }
-
- for(i=0; i < MAX_HISTORY; i++) {
- if (history[i].kfse == NULL) {
- break;
- }
-
- //
- // do a quick check to see if we've got two simple events
- // that we can cheaply combine. if the event we're looking
- // at and one of the events in the history table are for the
- // same path then we'll just mark the newer event as combined
- // and recyle the older event.
- //
- if (history[i].kfse->str == kfse->str) {
-
- OSBitOrAtomic16(KFSE_COMBINED_EVENTS, &kfse->flags);
- *reuse_type = KFSE_RECYCLED;
- history[i].kfse->flags |= KFSE_RECYCLED_EVENT;
- return history[i].kfse;
- }
- }
-
- if (i < MAX_HISTORY && history[i].kfse == NULL) {
- history[i].kfse = kfse;
- history[i].counter = 1;
- } else if (i >= MAX_HISTORY) {
- qsort(history, MAX_HISTORY, sizeof(struct history_item), compare_history_items);
-
- // pluck off the lowest guy if he's only got a count of 1
- if (history[MAX_HISTORY-1].counter == 1) {
- history[MAX_HISTORY-1].kfse = kfse;
- }
- }
- }
-
-
- if (str != NULL && best_kfse) {
- if (*longest_match_len <= 1) {
- // if the best match we had was "/" then basically we're toast...
- *longest_match_len = 0;
- best_kfse = NULL;
- } else if (*longest_match_len != len) {
- OSBitOrAtomic16(KFSE_CONTAINS_DROPPED_EVENTS, &best_kfse->flags);
- *reuse_type = KFSE_COLLAPSED;
- } else {
- OSBitOrAtomic16(KFSE_COMBINED_EVENTS, &best_kfse->flags);
- *reuse_type = KFSE_COMBINED;
- }
- }
-
- return best_kfse;
-}
-
-
static struct timeval last_print;
//
add_fsevent(int type, vfs_context_t ctx, ...)
{
struct proc *p = vfs_context_proc(ctx);
- int i, arg_type, skip_init=0, longest_match_len, ret;
+ int i, arg_type, ret;
kfs_event *kfse, *kfse_dest=NULL, *cur;
fs_event_watcher *watcher;
va_list ap;
- int error = 0, did_alloc=0, need_event_unlock = 0;
+ int error = 0, did_alloc=0;
dev_t dev = 0;
uint64_t now, elapsed;
- int reuse_type = 0;
char *pathbuff=NULL;
int pathbuff_len;
// (as long as it's not an event type that can never be the
// same as a previous event)
//
- if (type != FSE_CREATE_FILE && type != FSE_DELETE && type != FSE_RENAME && type != FSE_EXCHANGE && type != FSE_CHOWN) {
+ if (type != FSE_CREATE_FILE && type != FSE_DELETE && type != FSE_RENAME && type != FSE_EXCHANGE && type != FSE_CHOWN && type != FSE_DOCID_CHANGED && type != FSE_DOCID_CREATED) {
void *ptr=NULL;
int vid=0, was_str=0, nlen=0;
if (kfse == NULL) { // yikes! no free events
- int len=0;
- char *str;
-
- //
- // Figure out what kind of reference we have to the
- // file in this event. This helps us find an event
- // to combine/collapse into to make room.
- //
- // If we have a rename or exchange event then we
- // don't want to go through the normal path, we
- // want to "steal" an event instead (which is what
- // find_an_event() will do if str is null).
- //
- arg_type = va_arg(ap, int32_t);
- if (type == FSE_RENAME || type == FSE_EXCHANGE) {
- str = NULL;
- } else if (arg_type == FSE_ARG_STRING) {
- len = va_arg(ap, int32_t);
- str = va_arg(ap, char *);
- } else if (arg_type == FSE_ARG_VNODE) {
- struct vnode *vp;
-
- vp = va_arg(ap, struct vnode *);
- pathbuff = get_pathbuff();
- pathbuff_len = MAXPATHLEN;
- if (vn_getpath(vp, pathbuff, &pathbuff_len) != 0 || pathbuff[0] == '\0') {
- release_pathbuff(pathbuff);
- pathbuff = NULL;
- }
- str = pathbuff;
- } else {
- str = NULL;
- }
-
- //
- // This will go through all events and find one that we
- // can combine with (hopefully), or "collapse" into (i.e
- // it has the same parent) or in the worst case we have
- // to "recycle" an event which means that it will combine
- // two other events and return us the now unused event.
- // failing all that, find_an_event() could still return
- // null and if it does then we have a catastrophic dropped
- // events scenario.
- //
- kfse = find_an_event(str, len, NULL, &reuse_type, &longest_match_len);
-
- if (kfse == NULL) {
- bail_early:
-
unlock_fs_event_list();
lock_watch_table();
printf("add_fsevent: kfse_list head %p ; num_pending_rename %d\n", listhead, num_pending_rename);
printf("add_fsevent: zalloc sez: %p\n", junkptr);
printf("add_fsevent: event_zone info: %d 0x%x\n", ((int *)event_zone)[0], ((int *)event_zone)[1]);
+ lock_watch_table();
for(ii=0; ii < MAX_WATCHERS; ii++) {
if (watcher_table[ii] == NULL) {
continue;
}
- printf("add_fsevent: watcher %p: num dropped %d rd %4d wr %4d q_size %4d flags 0x%x\n",
- watcher_table[ii], watcher_table[ii]->num_dropped,
- watcher_table[ii]->rd, watcher_table[ii]->wr,
- watcher_table[ii]->eventq_size, watcher_table[ii]->flags);
+ printf("add_fsevent: watcher %s %p: rd %4d wr %4d q_size %4d flags 0x%x\n",
+ watcher_table[ii]->proc_name,
+ watcher_table[ii],
+ watcher_table[ii]->rd, watcher_table[ii]->wr,
+ watcher_table[ii]->eventq_size, watcher_table[ii]->flags);
}
+ unlock_watch_table();
last_print = current_tv;
if (junkptr) {
release_pathbuff(pathbuff);
pathbuff = NULL;
}
-
return ENOSPC;
}
- if ((type == FSE_RENAME || type == FSE_EXCHANGE) && reuse_type != KFSE_RECYCLED) {
- panic("add_fsevent: type == %d but reuse type == %d!\n", type, reuse_type);
- } else if ((kfse->type == FSE_RENAME || kfse->type == FSE_EXCHANGE) && kfse->dest == NULL) {
- panic("add_fsevent: bogus kfse %p (type %d, but dest is NULL)\n", kfse, kfse->type);
- } else if (kfse->type == FSE_RENAME || kfse->type == FSE_EXCHANGE) {
- panic("add_fsevent: we should never re-use rename events (kfse %p reuse type %d)!\n", kfse, reuse_type);
- }
-
- if (reuse_type == KFSE_COLLAPSED) {
- if (str) {
- const char *tmp_ptr, *new_str;
-
- //
- // if we collapsed and have a string we have to chop off the
- // tail component of the pathname to get the parent.
- //
- // NOTE: it is VERY IMPORTANT that we leave the trailing slash
- // on the pathname. user-level code depends on this.
- //
- if (str[0] == '\0' || longest_match_len <= 1) {
- printf("add_fsevent: strange state (str %s / longest_match_len %d)\n", str, longest_match_len);
- if (longest_match_len < 0) {
- panic("add_fsevent: longest_match_len %d\n", longest_match_len);
- }
- }
- // chop off the tail component if it's not the
- // first character...
- if (longest_match_len > 1) {
- str[longest_match_len] = '\0';
- } else if (longest_match_len == 0) {
- longest_match_len = 1;
- }
-
- new_str = vfs_addname(str, longest_match_len, 0, 0);
- if (new_str == NULL || new_str[0] == '\0') {
- panic("add_fsevent: longest match is strange (new_str %p).\n", new_str);
- }
-
- lck_rw_lock_exclusive(&event_handling_lock);
-
- kfse->len = longest_match_len;
- tmp_ptr = kfse->str;
- kfse->str = new_str;
- kfse->ino = 0;
- kfse->mode = 0;
- kfse->uid = 0;
- kfse->gid = 0;
-
- lck_rw_unlock_exclusive(&event_handling_lock);
-
- vfs_removename(tmp_ptr);
- } else {
- panic("add_fsevent: don't have a vnode or a string pointer (kfse %p)\n", kfse);
- }
- }
-
- if (reuse_type == KFSE_RECYCLED && (type == FSE_RENAME || type == FSE_EXCHANGE)) {
-
- // if we're recycling this kfse and we have a rename or
- // exchange event then we need to also get an event for
- // kfse_dest.
- //
- if (did_alloc) {
- // only happens if we allocated one but then failed
- // for kfse_dest (and thus free'd the first one we
- // allocated)
- kfse_dest = zalloc_noblock(event_zone);
- if (kfse_dest != NULL) {
- memset(kfse_dest, 0, sizeof(kfs_event));
- kfse_dest->refcount = 1;
- OSBitOrAtomic16(KFSE_BEING_CREATED, &kfse_dest->flags);
- } else {
- did_alloc = 0;
- }
- }
-
- if (kfse_dest == NULL) {
- int dest_reuse_type, dest_match_len;
-
- kfse_dest = find_an_event(NULL, 0, kfse, &dest_reuse_type, &dest_match_len);
-
- if (kfse_dest == NULL) {
- // nothing we can do... gotta bail out
- goto bail_early;
- }
-
- if (dest_reuse_type != KFSE_RECYCLED) {
- panic("add_fsevent: type == %d but dest_reuse type == %d!\n", type, dest_reuse_type);
- }
- }
- }
-
-
- //
- // Here we check for some fast-path cases so that we can
- // jump over the normal initialization and just get on
- // with delivering the event. These cases are when we're
- // combining/collapsing an event and so basically there is
- // no more work to do (aside from a little book-keeping)
- //
- if (str && kfse->len != 0) {
- kfse->abstime = now;
- OSAddAtomic(1, &kfse->refcount);
- skip_init = 1;
-
- if (reuse_type == KFSE_COMBINED) {
- num_combined_events++;
- } else if (reuse_type == KFSE_COLLAPSED) {
- num_added_to_parent++;
- }
- } else if (reuse_type != KFSE_RECYCLED) {
- panic("add_fsevent: I'm so confused! (reuse_type %d str %p kfse->len %d)\n",
- reuse_type, str, kfse->len);
- }
-
- va_end(ap);
-
-
- if (skip_init) {
- if (kfse->refcount < 1) {
- panic("add_fsevent: line %d: kfse recount %d but should be at least 1\n", __LINE__, kfse->refcount);
- }
-
- last_event_ptr = kfse;
- unlock_fs_event_list();
- goto normal_delivery;
-
- } else if (reuse_type == KFSE_RECYCLED || reuse_type == KFSE_COMBINED) {
-
- //
- // If we're here we have to clear out the kfs_event(s)
- // that we were given by find_an_event() and set it
- // up to be re-filled in by the normal code path.
- //
- va_start(ap, ctx);
-
- need_event_unlock = 1;
- lck_rw_lock_exclusive(&event_handling_lock);
-
- OSAddAtomic(1, &kfse->refcount);
-
- if (kfse->refcount < 1) {
- panic("add_fsevent: line %d: kfse recount %d but should be at least 1\n", __LINE__, kfse->refcount);
- }
-
- if (kfse->len == 0) {
- panic("%s:%d: no more fref.vp\n", __FILE__, __LINE__);
- // vnode_rele_ext(kfse->fref.vp, O_EVTONLY, 0);
- } else {
- vfs_removename(kfse->str);
- kfse->len = 0;
- }
- kfse->str = NULL;
-
- if (kfse->kevent_list.le_prev != NULL) {
- num_events_outstanding--;
- if (kfse->type == FSE_RENAME) {
- num_pending_rename--;
- }
- LIST_REMOVE(kfse, kevent_list);
- memset(&kfse->kevent_list, 0, sizeof(kfse->kevent_list));
- }
-
- kfse->flags = 0 | KFSE_RECYCLED_EVENT;
-
- if (kfse_dest) {
- OSAddAtomic(1, &kfse_dest->refcount);
- kfse_dest->flags = 0 | KFSE_RECYCLED_EVENT;
-
- if (did_alloc == 0) {
- if (kfse_dest->len == 0) {
- panic("%s:%d: no more fref.vp\n", __FILE__, __LINE__);
- // vnode_rele_ext(kfse_dest->fref.vp, O_EVTONLY, 0);
- } else {
- vfs_removename(kfse_dest->str);
- kfse_dest->len = 0;
- }
- kfse_dest->str = NULL;
-
- if (kfse_dest->kevent_list.le_prev != NULL) {
- num_events_outstanding--;
- LIST_REMOVE(kfse_dest, kevent_list);
- memset(&kfse_dest->kevent_list, 0, sizeof(kfse_dest->kevent_list));
- }
-
- if (kfse_dest->dest) {
- panic("add_fsevent: should never recycle a rename event! kfse %p\n", kfse);
- }
- }
- }
-
- OSBitOrAtomic16(KFSE_BEING_CREATED, &kfse->flags);
- if (kfse_dest) {
- OSBitOrAtomic16(KFSE_BEING_CREATED, &kfse_dest->flags);
- }
-
- goto process_normally;
- }
- }
-
- if (reuse_type != 0) {
- panic("fsevents: we have a reuse_type (%d) but are about to clear out kfse %p\n", reuse_type, kfse);
- }
-
- //
- // we only want to do this for brand new events, not
- // events which have been recycled.
- //
memset(kfse, 0, sizeof(kfs_event));
kfse->refcount = 1;
OSBitOrAtomic16(KFSE_BEING_CREATED, &kfse->flags);
- process_normally:
last_event_ptr = kfse;
kfse->type = type;
kfse->abstime = now;
kfse->pid = p->p_pid;
if (type == FSE_RENAME || type == FSE_EXCHANGE) {
- if (need_event_unlock == 0) {
- memset(kfse_dest, 0, sizeof(kfs_event));
- kfse_dest->refcount = 1;
- OSBitOrAtomic16(KFSE_BEING_CREATED, &kfse_dest->flags);
- }
+ memset(kfse_dest, 0, sizeof(kfs_event));
+ kfse_dest->refcount = 1;
+ OSBitOrAtomic16(KFSE_BEING_CREATED, &kfse_dest->flags);
kfse_dest->type = type;
kfse_dest->pid = p->p_pid;
kfse_dest->abstime = now;
// now process the arguments passed in and copy them into
// the kfse
//
- if (need_event_unlock == 0) {
- lck_rw_lock_shared(&event_handling_lock);
- }
cur = kfse;
+
+ if (type == FSE_DOCID_CREATED || type == FSE_DOCID_CHANGED) {
+ uint64_t val;
+
+ //
+ // These events are special and not like the other events. They only
+ // have a dev_t, src inode #, dest inode #, and a doc-id. We use the
+ // fields that we can in the kfse but have to overlay the dest inode
+ // number and the doc-id on the other fields.
+ //
+
+ // First the dev_t
+ arg_type = va_arg(ap, int32_t);
+ if (arg_type == FSE_ARG_DEV) {
+ cur->dev = (dev_t)(va_arg(ap, dev_t));
+ } else {
+ cur->dev = (dev_t)0xbadc0de1;
+ }
+
+ // next the source inode #
+ arg_type = va_arg(ap, int32_t);
+ if (arg_type == FSE_ARG_INO) {
+ cur->ino = (ino64_t)(va_arg(ap, ino64_t));
+ } else {
+ cur->ino = 0xbadc0de2;
+ }
+
+ // now the dest inode #
+ arg_type = va_arg(ap, int32_t);
+ if (arg_type == FSE_ARG_INO) {
+ val = (ino64_t)(va_arg(ap, ino64_t));
+ } else {
+ val = 0xbadc0de2;
+ }
+ // overlay the dest inode number on the str/dest pointer fields
+ memcpy(&cur->str, &val, sizeof(ino64_t));
+
+
+ // and last the document-id
+ arg_type = va_arg(ap, int32_t);
+ if (arg_type == FSE_ARG_INT32) {
+ val = (uint64_t)va_arg(ap, uint32_t);
+ } else if (arg_type == FSE_ARG_INT64) {
+ val = (uint64_t)va_arg(ap, uint64_t);
+ } else {
+ val = 0xbadc0de3;
+ }
+
+ // the docid is 64-bit and overlays the uid/gid fields
+ memcpy(&cur->uid, &val, sizeof(uint64_t));
+
+ goto done_with_args;
+ }
+
for(arg_type=va_arg(ap, int32_t); arg_type != FSE_ARG_DONE; arg_type=va_arg(ap, int32_t))
switch(arg_type) {
VATTR_WANTED(&va, va_mode);
VATTR_WANTED(&va, va_uid);
VATTR_WANTED(&va, va_gid);
+ VATTR_WANTED(&va, va_nlink);
if ((ret = vnode_getattr(vp, &va, vfs_context_kernel())) != 0) {
// printf("add_fsevent: failed to getattr on vp %p (%d)\n", cur->fref.vp, ret);
cur->str = NULL;
error = EINVAL;
- if (need_event_unlock == 0) {
- // then we only grabbed it shared
- lck_rw_unlock_shared(&event_handling_lock);
- }
goto clean_up;
}
cur->mode = (int32_t)vnode_vttoif(vnode_vtype(vp)) | va.va_mode;
cur->uid = va.va_uid;
cur->gid = va.va_gid;
+ if (vp->v_flag & VISHARDLINK) {
+ cur->mode |= FSE_MODE_HLINK;
+ if ((vp->v_type == VDIR && va.va_dirlinkcount == 0) || (vp->v_type == VREG && va.va_nlink == 0)) {
+ cur->mode |= FSE_MODE_LAST_HLINK;
+ }
+ }
// if we haven't gotten the path yet, get it.
if (pathbuff == NULL) {
pathbuff[0] = '\0';
if ((ret = vn_getpath(vp, pathbuff, &pathbuff_len)) != 0 || pathbuff[0] == '\0') {
- struct vnode *orig_vp = vp;
- if (ret != ENOSPC) {
- printf("add_fsevent: unable to get path for vp %p (%s; ret %d; type %d)\n",
- vp, vp->v_name ? vp->v_name : "-UNKNOWN-FILE", ret, type);
- }
-
cur->flags |= KFSE_CONTAINS_DROPPED_EVENTS;
do {
} while (ret == ENOSPC);
if (ret != 0 || vp == NULL) {
- printf("add_fsevent: unabled to get a path for vp %p. dropping the event.\n", orig_vp);
error = ENOENT;
- if (need_event_unlock == 0) {
- // then we only grabbed it shared
- lck_rw_unlock_shared(&event_handling_lock);
- }
goto clean_up;
}
}
}
break;
+ case FSE_ARG_INT32: {
+ uint32_t ival = (uint32_t)va_arg(ap, int32_t);
+ kfse->uid = (ino64_t)ival;
+ break;
+ }
+
default:
printf("add_fsevent: unknown type %d\n", arg_type);
// just skip one 32-bit word and hope we sync up...
(void)va_arg(ap, int32_t);
}
+done_with_args:
va_end(ap);
OSBitAndAtomic16(~KFSE_BEING_CREATED, &kfse->flags);
OSBitAndAtomic16(~KFSE_BEING_CREATED, &kfse_dest->flags);
}
- if (need_event_unlock == 0) {
- // then we only grabbed it shared
- lck_rw_unlock_shared(&event_handling_lock);
- }
-
- normal_delivery:
- // unlock this here so we don't hold it across the
- // event delivery loop.
- if (need_event_unlock) {
- lck_rw_unlock_exclusive(&event_handling_lock);
- need_event_unlock = 0;
- }
-
//
// now we have to go and let everyone know that
// is interested in this type of event
if (watcher_add_event(watcher, kfse) != 0) {
watcher->num_dropped++;
+ continue;
}
}
- if (kfse->refcount < 1) {
- panic("add_fsevent: line %d: kfse recount %d but should be at least 1\n", __LINE__, kfse->refcount);
- }
+ // if (kfse->refcount < 1) {
+ // panic("add_fsevent: line %d: kfse recount %d but should be at least 1\n", __LINE__, kfse->refcount);
+ // }
}
unlock_watch_table();
clean_up:
- // have to check if this needs to be unlocked (in
- // case we came here from an error handling path)
- if (need_event_unlock) {
- lck_rw_unlock_exclusive(&event_handling_lock);
- need_event_unlock = 0;
- }
if (pathbuff) {
release_pathbuff(pathbuff);
unlock_fs_event_list();
// if we have a pointer in the union
- if (copy.str) {
+ if (copy.str && copy.type != FSE_DOCID_CHANGED) {
if (copy.len == 0) { // and it's not a string
panic("%s:%d: no more fref.vp!\n", __FILE__, __LINE__);
// vnode_rele_ext(copy.fref.vp, O_EVTONLY, 0);
}
}
-
static int
-add_watcher(int8_t *event_list, int32_t num_events, int32_t eventq_size, fs_event_watcher **watcher_out)
+add_watcher(int8_t *event_list, int32_t num_events, int32_t eventq_size, fs_event_watcher **watcher_out, void *fseh)
{
int i;
fs_event_watcher *watcher;
- if (eventq_size <= 0 || eventq_size > 100*MAX_KFS_EVENTS) {
- eventq_size = MAX_KFS_EVENTS;
+ if (eventq_size <= 0 || eventq_size > 100*max_kfs_events) {
+ eventq_size = max_kfs_events;
}
// Note: the event_queue follows the fs_event_watcher struct
watcher->blockers = 0;
watcher->num_readers = 0;
watcher->max_event_id = 0;
- watcher->fseh = NULL;
+ watcher->fseh = fseh;
+ watcher->pid = proc_selfpid();
+ proc_selfname(watcher->proc_name, sizeof(watcher->proc_name));
watcher->num_dropped = 0; // XXXdbg - debugging
- lock_watch_table();
-
- // now update the global list of who's interested in
- // events of a particular type...
- for(i=0; i < num_events; i++) {
- if (event_list[i] != FSE_IGNORE && i < FSE_MAX_EVENTS) {
- fs_event_type_watchers[i]++;
- }
+ if (!strncmp(watcher->proc_name, "fseventsd", sizeof(watcher->proc_name)) ||
+ !strncmp(watcher->proc_name, "coreservicesd", sizeof(watcher->proc_name)) ||
+ !strncmp(watcher->proc_name, "mds", sizeof(watcher->proc_name))) {
+ watcher->flags |= WATCHER_APPLE_SYSTEM_SERVICE;
+ } else {
+ printf("fsevents: watcher %s (pid: %d) - Using /dev/fsevents directly is unsupported. Migrate to FSEventsFramework\n",
+ watcher->proc_name, watcher->pid);
}
+ lock_watch_table();
+
+ // find a slot for the new watcher
for(i=0; i < MAX_WATCHERS; i++) {
if (watcher_table[i] == NULL) {
watcher->my_id = i;
}
}
- if (i > MAX_WATCHERS) {
+ if (i >= MAX_WATCHERS) {
printf("fsevents: too many watchers!\n");
unlock_watch_table();
+ FREE(watcher, M_TEMP);
return ENOSPC;
}
+ // now update the global list of who's interested in
+ // events of a particular type...
+ for(i=0; i < num_events; i++) {
+ if (event_list[i] != FSE_IGNORE && i < FSE_MAX_EVENTS) {
+ fs_event_type_watchers[i]++;
+ }
+ }
+
unlock_watch_table();
*watcher_out = watcher;
unlock_watch_table();
while (watcher->num_readers > 1 && counter++ < 5000) {
+ lock_watch_table();
fsevents_wakeup(watcher); // in case they're asleep
+ unlock_watch_table();
tsleep(watcher, PRIBIO, "fsevents-close", 1);
}
}
// drain the event_queue
- while(watcher->rd != watcher->wr) {
- lck_rw_lock_shared(&event_handling_lock);
+ lck_rw_lock_exclusive(&event_handling_lock);
+ while(watcher->rd != watcher->wr) {
kfse = watcher->event_queue[watcher->rd];
- if (kfse->type == FSE_INVALID || kfse->refcount < 1) {
- panic("remove_watcher: bogus kfse %p during cleanup (type %d refcount %d rd %d wr %d)\n", kfse, kfse->type, kfse->refcount, watcher->rd, watcher->wr);
- }
-
- lck_rw_unlock_shared(&event_handling_lock);
-
+ watcher->event_queue[watcher->rd] = NULL;
watcher->rd = (watcher->rd+1) % watcher->eventq_size;
-
- if (kfse != NULL) {
+ OSSynchronizeIO();
+ if (kfse != NULL && kfse->type != FSE_INVALID && kfse->refcount >= 1) {
release_event_ref(kfse);
}
}
+ lck_rw_unlock_exclusive(&event_handling_lock);
if (watcher->event_list) {
FREE(watcher->event_list, M_TEMP);
watcher->event_queue[watcher->wr] = kfse;
OSSynchronizeIO();
watcher->wr = (watcher->wr + 1) % watcher->eventq_size;
-
+
//
// wake up the watcher if there are more than MAX_NUM_PENDING events.
// otherwise schedule a timer (if one isn't already set) which will
// send any pending events if no more are received in the next
// EVENT_DELAY_IN_MS milli-seconds.
//
- if ( (watcher->rd < watcher->wr && (watcher->wr - watcher->rd) > MAX_NUM_PENDING)
- || (watcher->rd > watcher->wr && (watcher->wr + watcher->eventq_size - watcher->rd) > MAX_NUM_PENDING)) {
+ int32_t num_pending = 0;
+ if (watcher->rd < watcher->wr) {
+ num_pending = watcher->wr - watcher->rd;
+ }
+
+ if (watcher->rd > watcher->wr) {
+ num_pending = watcher->wr + watcher->eventq_size - watcher->rd;
+ }
+
+ if (num_pending > (watcher->eventq_size*3/4) && !(watcher->flags & WATCHER_APPLE_SYSTEM_SERVICE)) {
+ /* Non-Apple Service is falling behind, start dropping events for this process */
+ lck_rw_lock_exclusive(&event_handling_lock);
+ while (watcher->rd != watcher->wr) {
+ kfse = watcher->event_queue[watcher->rd];
+ watcher->event_queue[watcher->rd] = NULL;
+ watcher->rd = (watcher->rd+1) % watcher->eventq_size;
+ OSSynchronizeIO();
+ if (kfse != NULL && kfse->type != FSE_INVALID && kfse->refcount >= 1) {
+ release_event_ref(kfse);
+ }
+ }
+ watcher->flags |= WATCHER_DROPPED_EVENTS;
+ lck_rw_unlock_exclusive(&event_handling_lock);
- fsevents_wakeup(watcher);
+ printf("fsevents: watcher falling behind: %s (pid: %d) rd: %4d wr: %4d q_size: %4d flags: 0x%x\n",
+ watcher->proc_name, watcher->pid, watcher->rd, watcher->wr,
+ watcher->eventq_size, watcher->flags);
+ fsevents_wakeup(watcher);
+ } else if (num_pending > MAX_NUM_PENDING) {
+ fsevents_wakeup(watcher);
} else if (timer_set == 0) {
-
- schedule_event_wakeup();
- }
+ schedule_event_wakeup();
+ }
return 0;
}
copy_again:
+ if (kfse->type == FSE_DOCID_CHANGED || kfse->type == FSE_DOCID_CREATED) {
+ dev_t dev = cur->dev;
+ ino_t ino = cur->ino;
+ uint64_t ival;
+
+ error = fill_buff(FSE_ARG_DEV, sizeof(dev_t), &dev, evbuff, &evbuff_idx, sizeof(evbuff), uio);
+ if (error != 0) {
+ goto get_out;
+ }
+
+ error = fill_buff(FSE_ARG_INO, sizeof(ino_t), &ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);
+ if (error != 0) {
+ goto get_out;
+ }
+
+ memcpy(&ino, &cur->str, sizeof(ino_t));
+ error = fill_buff(FSE_ARG_INO, sizeof(ino_t), &ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);
+ if (error != 0) {
+ goto get_out;
+ }
+
+ memcpy(&ival, &cur->uid, sizeof(uint64_t)); // the docid gets stuffed into the ino field
+ error = fill_buff(FSE_ARG_INT64, sizeof(uint64_t), &ival, evbuff, &evbuff_idx, sizeof(evbuff), uio);
+ if (error != 0) {
+ goto get_out;
+ }
+
+ goto done;
+ }
+
if (cur->str == NULL || cur->str[0] == '\0') {
printf("copy_out_kfse:2: empty/short path (%s)\n", cur->str);
error = fill_buff(FSE_ARG_STRING, 2, "/", evbuff, &evbuff_idx, sizeof(evbuff), uio);
user_ssize_t last_full_event_resid;
kfs_event *kfse;
uint16_t tmp16;
+ int skipped;
last_full_event_resid = uio_resid(uio);
return EAGAIN;
}
+ restart_watch:
if (watcher->rd == watcher->wr) {
if (watcher->flags & WATCHER_CLOSING) {
OSAddAtomic(-1, &watcher->num_readers);
watcher->flags &= ~WATCHER_DROPPED_EVENTS;
}
+ skipped = 0;
+
+ lck_rw_lock_shared(&event_handling_lock);
while (uio_resid(uio) > 0 && watcher->rd != watcher->wr) {
if (watcher->flags & WATCHER_CLOSING) {
break;
// (since it may have been recycled/reused and changed
// its type or which device it is for)
//
- lck_rw_lock_shared(&event_handling_lock);
-
kfse = watcher->event_queue[watcher->rd];
- if (kfse->type == FSE_INVALID || kfse->refcount < 1) {
- panic("fmod_watch: someone left me a bogus kfse %p (type %d refcount %d rd %d wr %d)\n", kfse, kfse->type, kfse->refcount, watcher->rd, watcher->wr);
+ if (!kfse || kfse->type == FSE_INVALID || kfse->refcount < 1) {
+ break;
}
if (watcher->event_list[kfse->type] == FSE_REPORT && watcher_cares_about_dev(watcher, kfse->dev)) {
+ if (!(watcher->flags & WATCHER_APPLE_SYSTEM_SERVICE) && kfse->type != FSE_DOCID_CHANGED && is_ignored_directory(kfse->str)) {
+ // If this is not an Apple System Service, skip specified directories
+ // radar://12034844
+ error = 0;
+ skipped = 1;
+ } else {
+
+ skipped = 0;
if (last_event_ptr == kfse) {
last_event_ptr = NULL;
last_event_type = -1;
}
last_full_event_resid = uio_resid(uio);
+ }
}
- lck_rw_unlock_shared(&event_handling_lock);
-
+ watcher->event_queue[watcher->rd] = NULL;
watcher->rd = (watcher->rd + 1) % watcher->eventq_size;
OSSynchronizeIO();
-
- if (kfse->type == FSE_INVALID || kfse->refcount < 1) {
- panic("fmod_watch:2: my kfse became bogus! kfse %p (type %d refcount %d rd %d wr %d)\n", kfse, kfse->type, kfse->refcount, watcher->rd, watcher->wr);
- }
-
release_event_ref(kfse);
}
+ lck_rw_unlock_shared(&event_handling_lock);
+
+ if (skipped && error == 0) {
+ goto restart_watch;
+ }
get_out:
OSAddAtomic(-1, &watcher->num_readers);
} ext_fsevent_dev_filter_args;
#pragma pack(pop)
+#define NEW_FSEVENTS_DEVICE_FILTER _IOW('s', 100, ext_fsevent_dev_filter_args)
+
typedef struct old_fsevent_dev_filter_args {
uint32_t num_devices;
int32_t devices;
} old_fsevent_dev_filter_args;
#define OLD_FSEVENTS_DEVICE_FILTER _IOW('s', 100, old_fsevent_dev_filter_args)
-#define NEW_FSEVENTS_DEVICE_FILTER _IOW('s', 100, ext_fsevent_dev_filter_args)
#if __LP64__
/* need this in spite of the padding due to alignment of devices */
if (proc_is64bit(vfs_context_proc(ctx))) {
devfilt_args = (ext_fsevent_dev_filter_args *)data;
- } else if (cmd == OLD_FSEVENTS_DEVICE_FILTER) {
+ }
+ else if (cmd == OLD_FSEVENTS_DEVICE_FILTER) {
old_fsevent_dev_filter_args *udev_filt_args = (old_fsevent_dev_filter_args *)data;
devfilt_args = &_devfilt_args;
devfilt_args->num_devices = udev_filt_args->num_devices;
devfilt_args->devices = CAST_USER_ADDR_T(udev_filt_args->devices);
- } else {
+ }
+ else {
#if __LP64__
fsevent_dev_filter_args32 *udev_filt_args = (fsevent_dev_filter_args32 *)data;
#else
// and decision to tsleep in fmod_watch... this bit of
// latency is a decent tradeoff against not having to
// take and drop a lock in fmod_watch
+ lock_watch_table();
fsevents_wakeup(fseh->watcher);
+ unlock_watch_table();
tsleep((caddr_t)fseh->watcher, PRIBIO, "watcher-close", 1);
}
static int
fseventsopen(__unused dev_t dev, __unused int flag, __unused int mode, __unused struct proc *p)
{
- if (!is_suser()) {
+ if (!kauth_cred_issuser(kauth_cred_get())) {
return EPERM;
}
}
-static struct fileops fsevents_fops = {
+static const struct fileops fsevents_fops = {
+ DTYPE_FSEVENTS,
fseventsf_read,
fseventsf_write,
fseventsf_ioctl,
error = add_watcher(event_list,
fse_clone_args->num_events,
fse_clone_args->event_queue_depth,
- &fseh->watcher);
+ &fseh->watcher,
+ fseh);
if (error) {
FREE(event_list, M_TEMP);
FREE(fseh, M_TEMP);
return error;
}
- // connect up the watcher with this fsevent_handle
fseh->watcher->fseh = fseh;
error = falloc(p, &f, &fd, vfs_context_current());
if (error) {
+ remove_watcher(fseh->watcher);
FREE(event_list, M_TEMP);
FREE(fseh, M_TEMP);
return (error);
}
proc_fdlock(p);
f->f_fglob->fg_flag = FREAD | FWRITE;
- f->f_fglob->fg_type = DTYPE_FSEVENTS;
f->f_fglob->fg_ops = &fsevents_fops;
f->f_fglob->fg_data = (caddr_t) fseh;
proc_fdunlock(p);
projects / apple / xnu.git / blobdiff