xnu-4903.221.2.tar.gz

[apple/xnu.git] / bsd / vfs / vfs_fsevents.c

diff --git a/bsd/vfs/vfs_fsevents.c b/bsd/vfs/vfs_fsevents.c
index fd363613211bb670bb456ddee59785554f7f3e7e..5b8eac30ec581d84b41d5656b4640de672f2e214 100644 (file)
--- a/bsd/vfs/vfs_fsevents.c
+++ b/bsd/vfs/vfs_fsevents.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2004-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2014 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -62,6 +62,7 @@
 #include <bsm/audit_kevents.h>
 
 #include <pexpert/pexpert.h>
 #include <bsm/audit_kevents.h>
 
 #include <pexpert/pexpert.h>

+#include <libkern/section_keywords.h>

 
 typedef struct kfs_event {
     LIST_ENTRY(kfs_event) kevent_list;
 
 typedef struct kfs_event {
     LIST_ENTRY(kfs_event) kevent_list;


@@ -121,7 +122,7 @@ typedef struct fs_event_watcher {
 #define WATCHER_CLOSING                0x0002
 #define WATCHER_WANTS_COMPACT_EVENTS   0x0004
 #define WATCHER_WANTS_EXTENDED_INFO    0x0008
 #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 WATCHER_APPLE_SYSTEM_SERVICE   0x0010   // fseventsd, coreservicesd, mds, revisiond

 
 #define MAX_WATCHERS  8
 static fs_event_watcher *watcher_table[MAX_WATCHERS];
 
 #define MAX_WATCHERS  8
 static fs_event_watcher *watcher_table[MAX_WATCHERS];


@@ -140,6 +141,11 @@ static int        fs_event_init = 0;
 //
 static int16_t     fs_event_type_watchers[FSE_MAX_EVENTS];
 
 //
 static int16_t     fs_event_type_watchers[FSE_MAX_EVENTS];
 

+// the device currently being unmounted:
+static dev_t fsevent_unmount_dev = 0;
+// how many ACKs are still outstanding:
+static int fsevent_unmount_ack_count = 0;
+

 static int  watcher_add_event(fs_event_watcher *watcher, kfs_event *kfse);
 static void fsevents_wakeup(fs_event_watcher *watcher);
 
 static int  watcher_add_event(fs_event_watcher *watcher, kfs_event *kfse);
 static void fsevents_wakeup(fs_event_watcher *watcher);
 


@@ -172,14 +178,14 @@ is_ignored_directory(const char *path) {
       return 0;
     }
 
       return 0;
     }
 

-#define IS_TLD(x) strnstr((char *) path, x, MAXPATHLEN) 
+#define IS_TLD(x) strnstr(__DECONST(char *, path), x, MAXPATHLEN)

     if (IS_TLD("/.Spotlight-V100/") ||
         IS_TLD("/.MobileBackups/") || 
         IS_TLD("/Backups.backupdb/")) {
         return 1;
     }
 #undef IS_TLD
     if (IS_TLD("/.Spotlight-V100/") ||
         IS_TLD("/.MobileBackups/") || 
         IS_TLD("/Backups.backupdb/")) {
         return 1;
     }
 #undef IS_TLD

-    
+       

     return 0;
 }
 
     return 0;
 }
 


@@ -392,7 +398,7 @@ add_fsevent(int type, vfs_context_t ctx, ...)
     // (as long as it's not an event type that can never be the
     // same as a previous event)
     //
     // (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 && type != FSE_DOCID_CHANGED && type != FSE_DOCID_CREATED) {
+    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 && type != FSE_CLONE) {

        void *ptr=NULL;
        int   vid=0, was_str=0, nlen=0;
 
        void *ptr=NULL;
        int   vid=0, was_str=0, nlen=0;
 


@@ -460,7 +466,7 @@ add_fsevent(int type, vfs_context_t ctx, ...)
 
 
     kfse = zalloc_noblock(event_zone);
 
 
     kfse = zalloc_noblock(event_zone);

-    if (kfse && (type == FSE_RENAME || type == FSE_EXCHANGE)) {
+    if (kfse && (type == FSE_RENAME || type == FSE_EXCHANGE || type == FSE_CLONE)) {

        kfse_dest = zalloc_noblock(event_zone);
        if (kfse_dest == NULL) {
            did_alloc = 1;
        kfse_dest = zalloc_noblock(event_zone);
        if (kfse_dest == NULL) {
            did_alloc = 1;


@@ -536,7 +542,7 @@ add_fsevent(int type, vfs_context_t ctx, ...)
     kfse->type     = type;
     kfse->abstime  = now;
     kfse->pid      = p->p_pid;
     kfse->type     = type;
     kfse->abstime  = now;
     kfse->pid      = p->p_pid;

-    if (type == FSE_RENAME || type == FSE_EXCHANGE) {
+    if (type == FSE_RENAME || type == FSE_EXCHANGE || type == FSE_CLONE) {

        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);


@@ -619,6 +625,19 @@ add_fsevent(int type, vfs_context_t ctx, ...)
            goto done_with_args;
     }
 
            goto done_with_args;
     }
 

+    if (type == FSE_UNMOUNT_PENDING) {
+
+           // Just a 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;
+           }
+
+           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) {
     for(arg_type=va_arg(ap, int32_t); arg_type != FSE_ARG_DONE; arg_type=va_arg(ap, int32_t))
 
        switch(arg_type) {


@@ -643,6 +662,7 @@ add_fsevent(int type, vfs_context_t ctx, ...)
                VATTR_WANTED(&va, va_mode);
                VATTR_WANTED(&va, va_uid);
                VATTR_WANTED(&va, va_gid);
                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;
                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;


@@ -655,6 +675,12 @@ add_fsevent(int type, vfs_context_t ctx, ...)
                cur->mode = (int32_t)vnode_vttoif(vnode_vtype(vp)) | va.va_mode;
                cur->uid  = va.va_uid;
                cur->gid  = va.va_gid;
                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) {
 
                // if we haven't gotten the path yet, get it.
                if (pathbuff == NULL) {


@@ -775,7 +801,8 @@ done_with_args:
            continue;
        }
        
            continue;
        }
        

-       if (   watcher->event_list[type] == FSE_REPORT
+       if (   type < watcher->num_events
+           && watcher->event_list[type] == FSE_REPORT

            && watcher_cares_about_dev(watcher, dev)) {
            
            if (watcher_add_event(watcher, kfse) != 0) {
            && watcher_cares_about_dev(watcher, dev)) {
            
            if (watcher_add_event(watcher, kfse) != 0) {


@@ -849,8 +876,8 @@ release_event_ref(kfs_event *kfse)
     // holding the fs_event_buf lock
     //
     copy = *kfse;
     // holding the fs_event_buf lock
     //
     copy = *kfse;

-    if (kfse->dest && OSAddAtomic(-1, &kfse->dest->refcount) == 1) {
-       dest_copy = *kfse->dest;
+    if (kfse->type != FSE_DOCID_CREATED && kfse->type != FSE_DOCID_CHANGED && kfse->dest && OSAddAtomic(-1, &kfse->dest->refcount) == 1) {
+           dest_copy = *kfse->dest;

     } else {
        dest_copy.str  = NULL;
        dest_copy.len  = 0;
     } else {
        dest_copy.str  = NULL;
        dest_copy.len  = 0;


@@ -898,7 +925,7 @@ release_event_ref(kfs_event *kfse)
     unlock_fs_event_list();
     
     // if we have a pointer in the union
     unlock_fs_event_list();
     
     // if we have a pointer in the union

-    if (copy.str && copy.type != FSE_DOCID_CHANGED) {
+    if (copy.str && copy.type != FSE_DOCID_CREATED && 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);
        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);


@@ -957,6 +984,7 @@ add_watcher(int8_t *event_list, int32_t num_events, int32_t eventq_size, fs_even
 
     if (!strncmp(watcher->proc_name, "fseventsd", sizeof(watcher->proc_name)) ||
        !strncmp(watcher->proc_name, "coreservicesd", sizeof(watcher->proc_name)) ||
 
     if (!strncmp(watcher->proc_name, "fseventsd", sizeof(watcher->proc_name)) ||
        !strncmp(watcher->proc_name, "coreservicesd", sizeof(watcher->proc_name)) ||

+       !strncmp(watcher->proc_name, "revisiond", sizeof(watcher->proc_name)) ||

        !strncmp(watcher->proc_name, "mds", sizeof(watcher->proc_name))) {
        watcher->flags |= WATCHER_APPLE_SYSTEM_SERVICE;
     } else {
        !strncmp(watcher->proc_name, "mds", sizeof(watcher->proc_name))) {
        watcher->flags |= WATCHER_APPLE_SYSTEM_SERVICE;
     } else {


@@ -1275,11 +1303,11 @@ copy_out_kfse(fs_event_watcher *watcher, kfs_event *kfse, struct uio *uio)
        return 0;
     }
 
        return 0;
     }
 

-    if (kfse->type == FSE_RENAME && kfse->dest == NULL) {
+    if (((kfse->type == FSE_RENAME) || (kfse->type == FSE_CLONE)) && kfse->dest == NULL) {

        //
        // This can happen if an event gets recycled but we had a
        // pointer to it in our event queue.  The event is the
        //
        // This can happen if an event gets recycled but we had a
        // pointer to it in our event queue.  The event is the

-       // destination of a rename which we'll process separately
+       // destination of a rename or clone which we'll process separately

        // (that is, another kfse points to this one so it's ok
        // to skip this guy because we'll process it when we process
        // the other one)
        // (that is, another kfse points to this one so it's ok
        // to skip this guy because we'll process it when we process
        // the other one)


@@ -1315,7 +1343,7 @@ copy_out_kfse(fs_event_watcher *watcher, kfs_event *kfse, struct uio *uio)
 
     if (kfse->type == FSE_DOCID_CHANGED || kfse->type == FSE_DOCID_CREATED) {
        dev_t    dev  = cur->dev;
 
     if (kfse->type == FSE_DOCID_CHANGED || kfse->type == FSE_DOCID_CREATED) {
        dev_t    dev  = cur->dev;

-       ino_t    ino  = cur->ino;
+       ino64_t    ino  = cur->ino;

        uint64_t ival;
 
        error = fill_buff(FSE_ARG_DEV, sizeof(dev_t), &dev, evbuff, &evbuff_idx, sizeof(evbuff), uio);
        uint64_t ival;
 
        error = fill_buff(FSE_ARG_DEV, sizeof(dev_t), &dev, evbuff, &evbuff_idx, sizeof(evbuff), uio);


@@ -1323,13 +1351,13 @@ copy_out_kfse(fs_event_watcher *watcher, kfs_event *kfse, struct uio *uio)
            goto get_out;
        }
 
            goto get_out;
        }
 

-       error = fill_buff(FSE_ARG_INO, sizeof(ino_t), &ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);
+       error = fill_buff(FSE_ARG_INO, sizeof(ino64_t), &ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);

        if (error != 0) {
            goto get_out;
        }
 
        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);
+       memcpy(&ino, &cur->str, sizeof(ino64_t));
+       error = fill_buff(FSE_ARG_INO, sizeof(ino64_t), &ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);

        if (error != 0) {
            goto get_out;
        }
        if (error != 0) {
            goto get_out;
        }


@@ -1343,6 +1371,17 @@ copy_out_kfse(fs_event_watcher *watcher, kfs_event *kfse, struct uio *uio)
        goto done;
     }
 
        goto done;
     }
 

+    if (kfse->type == FSE_UNMOUNT_PENDING) {
+       dev_t    dev  = cur->dev;
+
+       error = fill_buff(FSE_ARG_DEV, sizeof(dev_t), &dev, 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);
     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);


@@ -1371,15 +1410,12 @@ copy_out_kfse(fs_event_watcher *watcher, kfs_event *kfse, struct uio *uio)
            goto get_out;
        }
     } else {
            goto get_out;
        }
     } else {

-       ino_t ino;
-       

        error = fill_buff(FSE_ARG_DEV, sizeof(dev_t), &cur->dev, evbuff, &evbuff_idx, sizeof(evbuff), uio);
        if (error != 0) {
            goto get_out;
        }
 
        error = fill_buff(FSE_ARG_DEV, sizeof(dev_t), &cur->dev, evbuff, &evbuff_idx, sizeof(evbuff), uio);
        if (error != 0) {
            goto get_out;
        }
 

-       ino = (ino_t)cur->ino;
-       error = fill_buff(FSE_ARG_INO, sizeof(ino_t), &ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);
+       error = fill_buff(FSE_ARG_INO, sizeof(ino64_t), &cur->ino, evbuff, &evbuff_idx, sizeof(evbuff), uio);

        if (error != 0) {
            goto get_out;
        }
        if (error != 0) {
            goto get_out;
        }


@@ -1527,13 +1563,13 @@ fmod_watch(fs_event_watcher *watcher, struct uio *uio)
        // its type or which device it is for)
        //
        kfse = watcher->event_queue[watcher->rd];
        // its type or which device it is for)
        //
        kfse = watcher->event_queue[watcher->rd];

-       if (!kfse || kfse->type == FSE_INVALID || kfse->refcount < 1) {
+       if (!kfse || kfse->type == FSE_INVALID || kfse->type >= watcher->num_events || kfse->refcount < 1) {

          break;
        }
 
        if (watcher->event_list[kfse->type] == FSE_REPORT && watcher_cares_about_dev(watcher, kfse->dev)) {
 
          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 (!(watcher->flags & WATCHER_APPLE_SYSTEM_SERVICE) && kfse->type != FSE_DOCID_CREATED && 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;
            // If this is not an Apple System Service, skip specified directories
            // radar://12034844
            error = 0;


@@ -1583,18 +1619,70 @@ fmod_watch(fs_event_watcher *watcher, struct uio *uio)
 }
 
 
 }
 
 

-// release any references we might have on vnodes which are 
-// the mount point passed to us (so that it can be cleanly
-// unmounted).

 //
 //

-// since we don't want to lose the events we'll convert the
-// vnode refs to full paths.
+// Shoo watchers away from a volume that's about to be unmounted
+// (so that it can be cleanly unmounted).

 //
 void
 //
 void

-fsevent_unmount(__unused struct mount *mp)
+fsevent_unmount(__unused struct mount *mp, __unused vfs_context_t ctx)

 {
 {

-    // we no longer maintain pointers to vnodes so
-    // there is nothing to do... 
+#if CONFIG_EMBEDDED
+    dev_t dev = mp->mnt_vfsstat.f_fsid.val[0];
+    int error, waitcount = 0;
+    struct timespec ts = {1, 0};
+
+    // wait for any other pending unmounts to complete
+    lock_watch_table();
+    while (fsevent_unmount_dev != 0) {
+        error = msleep((caddr_t)&fsevent_unmount_dev, &watch_table_lock, PRIBIO, "fsevent_unmount_wait", &ts);
+        if (error == EWOULDBLOCK)
+            error = 0;
+        if (!error && (++waitcount >= 10)) {
+            error = EWOULDBLOCK;
+            printf("timeout waiting to signal unmount pending for dev %d (fsevent_unmount_dev %d)\n", dev, fsevent_unmount_dev);
+        }
+        if (error) {
+            // there's a problem, bail out
+            unlock_watch_table();
+            return;
+        }
+    }
+    if (fs_event_type_watchers[FSE_UNMOUNT_PENDING] == 0) {
+        // nobody watching for unmount pending events
+        unlock_watch_table();
+        return;
+    }
+    // this is now the current unmount pending
+    fsevent_unmount_dev = dev;
+    fsevent_unmount_ack_count = fs_event_type_watchers[FSE_UNMOUNT_PENDING];
+    unlock_watch_table();
+
+    // send an event to notify the watcher they need to get off the mount
+    error = add_fsevent(FSE_UNMOUNT_PENDING, ctx, FSE_ARG_DEV, dev, FSE_ARG_DONE);
+
+    // wait for acknowledgment(s) (give up if it takes too long)
+    lock_watch_table();
+    waitcount = 0;
+    while (fsevent_unmount_dev == dev) {
+        error = msleep((caddr_t)&fsevent_unmount_dev, &watch_table_lock, PRIBIO, "fsevent_unmount_pending", &ts);
+        if (error == EWOULDBLOCK)
+            error = 0;
+        if (!error && (++waitcount >= 10)) {
+            error = EWOULDBLOCK;
+            printf("unmount pending ack timeout for dev %d\n", dev);
+        }
+        if (error) {
+            // there's a problem, bail out
+            if (fsevent_unmount_dev == dev) {
+                fsevent_unmount_dev = 0;
+                fsevent_unmount_ack_count = 0;
+           }
+            wakeup((caddr_t)&fsevent_unmount_dev);
+            break;
+        }
+    }
+    unlock_watch_table();
+#endif

 }
 
 
 }
 
 


@@ -1634,62 +1722,25 @@ fseventsf_write(__unused struct fileproc *fp, __unused struct uio *uio,
 }
 
 #pragma pack(push, 4)
 }
 
 #pragma pack(push, 4)

-typedef struct ext_fsevent_dev_filter_args {
-    uint32_t    num_devices;
-    user_addr_t devices;
-} 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)
-
-#if __LP64__
-/* need this in spite of the padding due to alignment of devices */

 typedef struct fsevent_dev_filter_args32 {
 typedef struct fsevent_dev_filter_args32 {

-    uint32_t  num_devices;
-    uint32_t  devices;
-    int32_t   pad1;
+    uint32_t            num_devices;
+    user32_addr_t       devices;

 } fsevent_dev_filter_args32;
 } fsevent_dev_filter_args32;

-#endif
+typedef struct fsevent_dev_filter_args64 {
+    uint32_t            num_devices;
+    user64_addr_t       devices;
+} fsevent_dev_filter_args64;
+#pragma pack(pop)
+
+#define        FSEVENTS_DEVICE_FILTER_32       _IOW('s', 100, fsevent_dev_filter_args32)
+#define        FSEVENTS_DEVICE_FILTER_64       _IOW('s', 100, fsevent_dev_filter_args64)

 
 static int
 fseventsf_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx)
 {
     fsevent_handle *fseh = (struct fsevent_handle *)fp->f_fglob->fg_data;
     int ret = 0;
 
 static int
 fseventsf_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx)
 {
     fsevent_handle *fseh = (struct fsevent_handle *)fp->f_fglob->fg_data;
     int ret = 0;

-    ext_fsevent_dev_filter_args *devfilt_args, _devfilt_args;
-
-    if (proc_is64bit(vfs_context_proc(ctx))) {
-       devfilt_args = (ext_fsevent_dev_filter_args *)data;
-    }
-    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;
-       memset(devfilt_args, 0, sizeof(ext_fsevent_dev_filter_args));
-
-       devfilt_args->num_devices = udev_filt_args->num_devices;
-       devfilt_args->devices     = CAST_USER_ADDR_T(udev_filt_args->devices);
-    }
-    else {
-#if __LP64__
-       fsevent_dev_filter_args32 *udev_filt_args = (fsevent_dev_filter_args32 *)data;
-#else
-       fsevent_dev_filter_args *udev_filt_args = (fsevent_dev_filter_args *)data;
-#endif
-       
-       devfilt_args = &_devfilt_args;
-       memset(devfilt_args, 0, sizeof(ext_fsevent_dev_filter_args));
-
-       devfilt_args->num_devices = udev_filt_args->num_devices;
-       devfilt_args->devices     = CAST_USER_ADDR_T(udev_filt_args->devices);
-    }
+    fsevent_dev_filter_args64 *devfilt_args, _devfilt_args;

 
     OSAddAtomic(1, &fseh->active);
     if (fseh->flags & FSEH_CLOSING) {
 
     OSAddAtomic(1, &fseh->active);
     if (fseh->flags & FSEH_CLOSING) {


@@ -1718,8 +1769,29 @@ fseventsf_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx
                break;
        }
 
                break;
        }
 

-       case OLD_FSEVENTS_DEVICE_FILTER:
-       case NEW_FSEVENTS_DEVICE_FILTER: {
+       case FSEVENTS_DEVICE_FILTER_32: {
+           if (proc_is64bit(vfs_context_proc(ctx))) {
+                   ret = EINVAL;
+                   break;
+           }
+           fsevent_dev_filter_args32 *devfilt_args32 = (fsevent_dev_filter_args32 *)data;
+
+           devfilt_args = &_devfilt_args;
+           memset(devfilt_args, 0, sizeof(fsevent_dev_filter_args64));
+           devfilt_args->num_devices = devfilt_args32->num_devices;
+           devfilt_args->devices     = CAST_USER_ADDR_T(devfilt_args32->devices);
+           goto handle_dev_filter;
+       }
+
+       case FSEVENTS_DEVICE_FILTER_64:
+           if (!proc_is64bit(vfs_context_proc(ctx))) {
+                   ret = EINVAL;
+                   break;
+           }
+           devfilt_args = (fsevent_dev_filter_args64 *)data;
+
+       handle_dev_filter:
+       {

            int new_num_devices;
            dev_t *devices_not_to_watch, *tmp=NULL;
            
            int new_num_devices;
            dev_t *devices_not_to_watch, *tmp=NULL;
            


@@ -1730,13 +1802,13 @@ fseventsf_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx
            
            new_num_devices = devfilt_args->num_devices;
            if (new_num_devices == 0) {
            
            new_num_devices = devfilt_args->num_devices;
            if (new_num_devices == 0) {

-               tmp = fseh->watcher->devices_not_to_watch;
-

                lock_watch_table();
                lock_watch_table();

+
+               tmp = fseh->watcher->devices_not_to_watch;

                fseh->watcher->devices_not_to_watch = NULL;
                fseh->watcher->num_devices = new_num_devices;
                fseh->watcher->devices_not_to_watch = NULL;
                fseh->watcher->num_devices = new_num_devices;

-               unlock_watch_table();

 
 

+               unlock_watch_table();

                if (tmp) {
                    FREE(tmp, M_TEMP);
                }
                if (tmp) {
                    FREE(tmp, M_TEMP);
                }


@@ -1772,6 +1844,22 @@ fseventsf_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx
            break;
        }           
 
            break;
        }           
 

+       case FSEVENTS_UNMOUNT_PENDING_ACK: {
+           lock_watch_table();
+           dev_t dev = *(dev_t *)data;
+           if (fsevent_unmount_dev == dev) {
+               if (--fsevent_unmount_ack_count <= 0) {
+                       fsevent_unmount_dev = 0;
+                       wakeup((caddr_t)&fsevent_unmount_dev);
+               }
+           } else {
+               printf("unexpected unmount pending ack %d (%d)\n", dev, fsevent_unmount_dev);
+               ret = EINVAL;
+           }
+           unlock_watch_table();
+           break;
+       }
+

        default:
            ret = EINVAL;
            break;
        default:
            ret = EINVAL;
            break;


@@ -1879,7 +1967,7 @@ filt_fsevent(struct knote *kn, long hint)
        switch(kn->kn_filter) {
                case EVFILT_READ:
                        kn->kn_data = amt;
        switch(kn->kn_filter) {
                case EVFILT_READ:
                        kn->kn_data = amt;

-                       
+

                        if (kn->kn_data != 0) {
                                activate = 1;
                        }
                        if (kn->kn_data != 0) {
                                activate = 1;
                        }


@@ -1903,28 +1991,83 @@ filt_fsevent(struct knote *kn, long hint)
 }
 
 
 }
 
 

-struct  filterops fsevent_filtops = { 
-       .f_isfd = 1, 
-       .f_attach = NULL, 
-       .f_detach = filt_fsevent_detach, 
-       .f_event = filt_fsevent
+static int
+filt_fsevent_touch(struct knote *kn, struct kevent_internal_s *kev)
+{
+       int res;
+
+       lock_watch_table();
+
+       /* accept new fflags/data as saved */
+       kn->kn_sfflags = kev->fflags;
+       kn->kn_sdata = kev->data;
+
+       /* restrict the current results to the (smaller?) set of new interest */
+       /*
+        * For compatibility with previous implementations, we leave kn_fflags
+        * as they were before.
+        */
+       //kn->kn_fflags &= kev->fflags;
+
+       /* determine if the filter is now fired */
+       res = filt_fsevent(kn, 0);
+
+       unlock_watch_table();
+
+       return res;
+}
+
+static int
+filt_fsevent_process(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev)
+{
+#pragma unused(data)
+       int res;
+
+       lock_watch_table();
+
+       res = filt_fsevent(kn, 0);
+       if (res) {
+               *kev = kn->kn_kevent;
+               if (kev->flags & EV_CLEAR) {
+                       kn->kn_data = 0;
+                       kn->kn_fflags = 0;
+               }
+       }
+
+       unlock_watch_table();
+       return res;
+}
+
+SECURITY_READ_ONLY_EARLY(struct  filterops) fsevent_filtops = {
+       .f_isfd = 1,
+       .f_attach = NULL,
+       .f_detach = filt_fsevent_detach,
+       .f_event = filt_fsevent,
+       .f_touch = filt_fsevent_touch,
+       .f_process = filt_fsevent_process,

 };
 
 static int
 };
 
 static int

-fseventsf_kqfilter(__unused struct fileproc *fp, __unused struct knote *kn, __unused vfs_context_t ctx)
+fseventsf_kqfilter(__unused struct fileproc *fp, __unused struct knote *kn,
+               __unused struct kevent_internal_s *kev, __unused vfs_context_t ctx)

 {
     fsevent_handle *fseh = (struct fsevent_handle *)fp->f_fglob->fg_data;
 {
     fsevent_handle *fseh = (struct fsevent_handle *)fp->f_fglob->fg_data;

+    int res;

 
     kn->kn_hook = (void*)fseh;
     kn->kn_hookid = 1;
 
     kn->kn_hook = (void*)fseh;
     kn->kn_hookid = 1;

-    kn->kn_fop = &fsevent_filtops;
-    
+       kn->kn_filtid = EVFILTID_FSEVENT;
+

     lock_watch_table();
 
     KNOTE_ATTACH(&fseh->knotes, kn);
 
     lock_watch_table();
 
     KNOTE_ATTACH(&fseh->knotes, kn);
 

+    /* check to see if it is fired already */
+    res = filt_fsevent(kn, 0);
+

     unlock_watch_table();
     unlock_watch_table();

-    return 0;
+
+    return res;

 }
 
 
 }
 
 


@@ -1934,8 +2077,6 @@ fseventsf_drain(struct fileproc *fp, __unused vfs_context_t ctx)
     int counter = 0;
     fsevent_handle *fseh = (struct fsevent_handle *)fp->f_fglob->fg_data;
 
     int counter = 0;
     fsevent_handle *fseh = (struct fsevent_handle *)fp->f_fglob->fg_data;
 

-    fseh->watcher->flags |= WATCHER_CLOSING;
-

     // if there are people still waiting, sleep for 10ms to
     // let them clean up and get out of there.  however we
     // also don't want to get stuck forever so if they don't
     // if there are people still waiting, sleep for 10ms to
     // let them clean up and get out of there.  however we
     // also don't want to get stuck forever so if they don't


@@ -2015,7 +2156,7 @@ parse_buffer_and_add_events(const char *buffer, int bufsize, vfs_context_t ctx,
 
        path_len = ptr - path;
 
 
        path_len = ptr - path;
 

-       if (type != FSE_RENAME && type != FSE_EXCHANGE) {
+       if (type != FSE_RENAME && type != FSE_EXCHANGE && type != FSE_CLONE) {

            event_start = ptr;   // record where the next event starts
 
            err = add_fsevent(type, ctx, FSE_ARG_STRING, path_len, path, FSE_ARG_FINFO, finfo, FSE_ARG_DONE);
            event_start = ptr;   // record where the next event starts
 
            err = add_fsevent(type, ctx, FSE_ARG_STRING, path_len, path, FSE_ARG_FINFO, finfo, FSE_ARG_DONE);


@@ -2100,7 +2241,7 @@ fseventswrite(__unused dev_t dev, struct uio *uio, __unused int ioflag)
     lck_mtx_lock(&event_writer_lock);
 
     if (write_buffer == NULL) {
     lck_mtx_lock(&event_writer_lock);
 
     if (write_buffer == NULL) {

-       if (kmem_alloc(kernel_map, (vm_offset_t *)&write_buffer, WRITE_BUFFER_SIZE)) {
+       if (kmem_alloc(kernel_map, (vm_offset_t *)&write_buffer, WRITE_BUFFER_SIZE, VM_KERN_MEMORY_FILE)) {

            lck_mtx_unlock(&event_writer_lock);
            return ENOMEM;
        }
            lck_mtx_unlock(&event_writer_lock);
            return ENOMEM;
        }


@@ -2155,31 +2296,32 @@ fseventswrite(__unused dev_t dev, struct uio *uio, __unused int ioflag)
 
 
 static const struct fileops fsevents_fops = {
 
 
 static const struct fileops fsevents_fops = {

-    DTYPE_FSEVENTS,
-    fseventsf_read,
-    fseventsf_write,
-    fseventsf_ioctl,
-    fseventsf_select,
-    fseventsf_close,
-    fseventsf_kqfilter,
-    fseventsf_drain
+    .fo_type = DTYPE_FSEVENTS,
+    .fo_read = fseventsf_read,
+    .fo_write = fseventsf_write,
+    .fo_ioctl = fseventsf_ioctl,
+    .fo_select = fseventsf_select,
+    .fo_close = fseventsf_close,
+    .fo_kqfilter = fseventsf_kqfilter,
+    .fo_drain = fseventsf_drain,

 };
 
 };
 

-typedef struct ext_fsevent_clone_args {
-    user_addr_t  event_list;
-    int32_t      num_events;
-    int32_t      event_queue_depth;
-    user_addr_t  fd;
-} ext_fsevent_clone_args;
+typedef struct fsevent_clone_args32 {
+    user32_addr_t       event_list;
+    int32_t             num_events;
+    int32_t             event_queue_depth;
+    user32_addr_t       fd;
+} fsevent_clone_args32;

 
 

-typedef struct old_fsevent_clone_args {
-    uint32_t  event_list;
-    int32_t  num_events;
-    int32_t  event_queue_depth;
-    uint32_t  fd;
-} old_fsevent_clone_args;
+typedef struct fsevent_clone_args64 {
+    user64_addr_t       event_list;
+    int32_t             num_events;
+    int32_t             event_queue_depth;
+    user64_addr_t       fd;
+} fsevent_clone_args64;

 
 

-#define        OLD_FSEVENTS_CLONE      _IOW('s', 1, old_fsevent_clone_args)
+#define        FSEVENTS_CLONE_32       _IOW('s', 1, fsevent_clone_args32)
+#define        FSEVENTS_CLONE_64       _IOW('s', 1, fsevent_clone_args64)

 
 static int
 fseventsioctl(__unused dev_t dev, u_long cmd, caddr_t data, __unused int flag, struct proc *p)
 
 static int
 fseventsioctl(__unused dev_t dev, u_long cmd, caddr_t data, __unused int flag, struct proc *p)


@@ -2187,38 +2329,32 @@ fseventsioctl(__unused dev_t dev, u_long cmd, caddr_t data, __unused int flag, s
     struct fileproc *f;
     int fd, error;
     fsevent_handle *fseh = NULL;
     struct fileproc *f;
     int fd, error;
     fsevent_handle *fseh = NULL;

-    ext_fsevent_clone_args *fse_clone_args, _fse_clone;
+    fsevent_clone_args64 *fse_clone_args, _fse_clone;

     int8_t *event_list;
     int is64bit = proc_is64bit(p);
 
     switch (cmd) {
     int8_t *event_list;
     int is64bit = proc_is64bit(p);
 
     switch (cmd) {

-       case OLD_FSEVENTS_CLONE: {
-           old_fsevent_clone_args *old_args = (old_fsevent_clone_args *)data;
+       case FSEVENTS_CLONE_32: {
+           if (is64bit) {
+                   return EINVAL;
+           }
+           fsevent_clone_args32 *args32 = (fsevent_clone_args32 *)data;

 
            fse_clone_args = &_fse_clone;
 
            fse_clone_args = &_fse_clone;

-           memset(fse_clone_args, 0, sizeof(ext_fsevent_clone_args));
+           memset(fse_clone_args, 0, sizeof(fsevent_clone_args64));

 
 

-           fse_clone_args->event_list        = CAST_USER_ADDR_T(old_args->event_list);
-           fse_clone_args->num_events        = old_args->num_events;
-           fse_clone_args->event_queue_depth = old_args->event_queue_depth;
-           fse_clone_args->fd                = CAST_USER_ADDR_T(old_args->fd);
+           fse_clone_args->event_list        = CAST_USER_ADDR_T(args32->event_list);
+           fse_clone_args->num_events        = args32->num_events;
+           fse_clone_args->event_queue_depth = args32->event_queue_depth;
+           fse_clone_args->fd                = CAST_USER_ADDR_T(args32->fd);

            goto handle_clone;
        }
            goto handle_clone;
        }

-           
-       case FSEVENTS_CLONE:
-           if (is64bit) {
-               fse_clone_args = (ext_fsevent_clone_args *)data;
-           } else {
-               fsevent_clone_args *ufse_clone = (fsevent_clone_args *)data;
-               
-               fse_clone_args = &_fse_clone;
-               memset(fse_clone_args, 0, sizeof(ext_fsevent_clone_args));

 
 

-               fse_clone_args->event_list        = CAST_USER_ADDR_T(ufse_clone->event_list);
-               fse_clone_args->num_events        = ufse_clone->num_events;
-               fse_clone_args->event_queue_depth = ufse_clone->event_queue_depth;
-               fse_clone_args->fd                = CAST_USER_ADDR_T(ufse_clone->fd);
+       case FSEVENTS_CLONE_64:
+           if (!is64bit) {
+                   return EINVAL;

            }
            }

+           fse_clone_args = (fsevent_clone_args64 *)data;

 
        handle_clone:
            if (fse_clone_args->num_events < 0 || fse_clone_args->num_events > 4096) {
 
        handle_clone:
            if (fse_clone_args->num_events < 0 || fse_clone_args->num_events > 4096) {


@@ -2474,6 +2610,9 @@ create_fsevent_from_kevent(vnode_t vp, uint32_t kevents, struct vnode_attr *vap)
 }
 
 #else /* CONFIG_FSE */
 }
 
 #else /* CONFIG_FSE */

+
+#include <sys/fsevents.h>
+

 /*
  * The get_pathbuff and release_pathbuff routines are used in places not
  * related to fsevents, and it's a handy abstraction, so define trivial
 /*
  * The get_pathbuff and release_pathbuff routines are used in places not
  * related to fsevents, and it's a handy abstraction, so define trivial


@@ -2494,4 +2633,16 @@ release_pathbuff(char *path)
 {
        FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
 }
 {
        FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
 }

+
+int
+add_fsevent(__unused int type, __unused vfs_context_t ctx, ...)
+{
+       return 0;
+}
+
+int need_fsevent(__unused int type, __unused vnode_t vp)
+{
+       return 0;
+}
+

 #endif /* CONFIG_FSE */
 #endif /* CONFIG_FSE */