xnu-6153.11.26.tar.gz

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

diff --git a/bsd/vfs/kpi_vfs.c b/bsd/vfs/kpi_vfs.c
index 19a4be3d1c9ada9db2a89ac7a0c9cc3893d2ebbf..79a40a8173e3a5a5d7d5582cad63d12d8242ae60 100644 (file)
--- a/bsd/vfs/kpi_vfs.c
+++ b/bsd/vfs/kpi_vfs.c
@@ -1,8 +1,8 @@
 /*
 /*

- * Copyright (c) 2000-2014 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2017 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

- * 
+ *

  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in


@@ -11,10 +11,10 @@
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.

- * 
+ *

  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.

- * 
+ *

  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,


@@ -22,7 +22,7 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.

- * 
+ *

  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */


@@ -103,10 +103,12 @@
 #include <sys/user.h>
 #include <sys/lockf.h>
 #include <sys/xattr.h>
 #include <sys/user.h>
 #include <sys/lockf.h>
 #include <sys/xattr.h>

+#include <sys/kdebug.h>

 
 #include <kern/assert.h>
 #include <kern/kalloc.h>
 #include <kern/task.h>
 
 #include <kern/assert.h>
 #include <kern/kalloc.h>
 #include <kern/task.h>

+#include <kern/policy_internal.h>

 
 #include <libkern/OSByteOrder.h>
 
 
 #include <libkern/OSByteOrder.h>
 


@@ -120,6 +122,10 @@
 #include <security/mac_framework.h>
 #endif
 
 #include <security/mac_framework.h>
 #endif
 

+#if NULLFS
+#include <miscfs/nullfs/nullfs.h>
+#endif
+

 #include <sys/sdt.h>
 
 #define ESUCCESS 0
 #include <sys/sdt.h>
 
 #define ESUCCESS 0


@@ -133,32 +139,34 @@
 
 #if CONFIG_APPLEDOUBLE
 static void xattrfile_remove(vnode_t dvp, const char *basename,
 
 #if CONFIG_APPLEDOUBLE
 static void xattrfile_remove(vnode_t dvp, const char *basename,

-                               vfs_context_t ctx, int force);
+    vfs_context_t ctx, int force);

 static void xattrfile_setattr(vnode_t dvp, const char * basename,
 static void xattrfile_setattr(vnode_t dvp, const char * basename,

-                               struct vnode_attr * vap, vfs_context_t ctx);
+    struct vnode_attr * vap, vfs_context_t ctx);

 #endif /* CONFIG_APPLEDOUBLE */
 
 #endif /* CONFIG_APPLEDOUBLE */
 

+static errno_t post_rename(vnode_t fdvp, vnode_t fvp, vnode_t tdvp, vnode_t tvp);
+

 /*
  * vnode_setneedinactive
  *
  * Description: Indicate that when the last iocount on this vnode goes away,
 /*
  * vnode_setneedinactive
  *
  * Description: Indicate that when the last iocount on this vnode goes away,

- *             and the usecount is also zero, we should inform the filesystem
- *             via VNOP_INACTIVE.
+ *              and the usecount is also zero, we should inform the filesystem
+ *              via VNOP_INACTIVE.

  *
  * Parameters:  vnode_t                vnode to mark
  *
  * Returns:     Nothing
  *
  *
  * Parameters:  vnode_t                vnode to mark
  *
  * Returns:     Nothing
  *

- * Notes:       Notably used when we're deleting a file--we need not have a 
- *             usecount, so VNOP_INACTIVE may not get called by anyone.  We
- *             want it called when we drop our iocount.
+ * Notes:       Notably used when we're deleting a file--we need not have a
+ *              usecount, so VNOP_INACTIVE may not get called by anyone.  We
+ *              want it called when we drop our iocount.

  */
 void
 vnode_setneedinactive(vnode_t vp)
 {
  */
 void
 vnode_setneedinactive(vnode_t vp)
 {

-        cache_purge(vp);
+       cache_purge(vp);

 
 

-        vnode_lock_spin(vp);
+       vnode_lock_spin(vp);

        vp->v_lflag |= VL_NEEDINACTIVE;
        vnode_unlock(vp);
 }
        vp->v_lflag |= VL_NEEDINACTIVE;
        vnode_unlock(vp);
 }


@@ -171,53 +179,54 @@ vnode_setneedinactive(vnode_t vp)
 /*
  * implementations of exported VFS operations
  */
 /*
  * implementations of exported VFS operations
  */

-int 
+int

 VFS_MOUNT(mount_t mp, vnode_t devvp, user_addr_t data, vfs_context_t ctx)
 {
        int error;
 
 VFS_MOUNT(mount_t mp, vnode_t devvp, user_addr_t data, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_mount == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_mount == 0)) {
+               return ENOTSUP;
+       }

 
        if (vfs_context_is64bit(ctx)) {
                if (vfs_64bitready(mp)) {
                        error = (*mp->mnt_op->vfs_mount)(mp, devvp, data, ctx);
 
        if (vfs_context_is64bit(ctx)) {
                if (vfs_64bitready(mp)) {
                        error = (*mp->mnt_op->vfs_mount)(mp, devvp, data, ctx);

-               }
-               else {
+               } else {

                        error = ENOTSUP;
                }
                        error = ENOTSUP;
                }

-       }
-       else {
+       } else {

                error = (*mp->mnt_op->vfs_mount)(mp, devvp, data, ctx);
        }
                error = (*mp->mnt_op->vfs_mount)(mp, devvp, data, ctx);
        }

-       
-       return (error);
+
+       return error;

 }
 
 }
 

-int 
+int

 VFS_START(mount_t mp, int flags, vfs_context_t ctx)
 {
        int error;
 
 VFS_START(mount_t mp, int flags, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_start == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_start == 0)) {
+               return ENOTSUP;
+       }

 
        error = (*mp->mnt_op->vfs_start)(mp, flags, ctx);
 
 
        error = (*mp->mnt_op->vfs_start)(mp, flags, ctx);
 

-       return (error);
+       return error;

 }
 
 }
 

-int 
+int

 VFS_UNMOUNT(mount_t mp, int flags, vfs_context_t ctx)
 {
        int error;
 
 VFS_UNMOUNT(mount_t mp, int flags, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_unmount == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_unmount == 0)) {
+               return ENOTSUP;
+       }

 
        error = (*mp->mnt_op->vfs_unmount)(mp, flags, ctx);
 
 
        error = (*mp->mnt_op->vfs_unmount)(mp, flags, ctx);
 

-       return (error);
+       return error;

 }
 
 /*
 }
 
 /*


@@ -233,17 +242,18 @@ VFS_UNMOUNT(mount_t mp, int flags, vfs_context_t ctx)
  *
  *             The return codes documented above are those which may currently
  *             be returned by HFS from hfs_vfs_root, which is a simple wrapper
  *
  *             The return codes documented above are those which may currently
  *             be returned by HFS from hfs_vfs_root, which is a simple wrapper

- *             for a call to hfs_vget on the volume mount poit, not including
+ *             for a call to hfs_vget on the volume mount point, not including

  *             additional error codes which may be propagated from underlying
  *             routines called by hfs_vget.
  */
  *             additional error codes which may be propagated from underlying
  *             routines called by hfs_vget.
  */

-int 
+int

 VFS_ROOT(mount_t mp, struct vnode  ** vpp, vfs_context_t ctx)
 {
        int error;
 
 VFS_ROOT(mount_t mp, struct vnode  ** vpp, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_root == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_root == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 
        if (ctx == NULL) {
                ctx = vfs_context_current();


@@ -251,46 +261,49 @@ VFS_ROOT(mount_t mp, struct vnode  ** vpp, vfs_context_t ctx)
 
        error = (*mp->mnt_op->vfs_root)(mp, vpp, ctx);
 
 
        error = (*mp->mnt_op->vfs_root)(mp, vpp, ctx);
 

-       return (error);
+       return error;

 }
 
 }
 

-int 
+int

 VFS_QUOTACTL(mount_t mp, int cmd, uid_t uid, caddr_t datap, vfs_context_t ctx)
 {
        int error;
 
 VFS_QUOTACTL(mount_t mp, int cmd, uid_t uid, caddr_t datap, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_quotactl == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_quotactl == 0)) {
+               return ENOTSUP;
+       }

 
        error = (*mp->mnt_op->vfs_quotactl)(mp, cmd, uid, datap, ctx);
 
 
        error = (*mp->mnt_op->vfs_quotactl)(mp, cmd, uid, datap, ctx);
 

-       return (error);
+       return error;

 }
 
 }
 

-int 
+int

 VFS_GETATTR(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
        int error;
 
 VFS_GETATTR(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_getattr == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_getattr == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
        }
 
        error = (*mp->mnt_op->vfs_getattr)(mp, vfa, ctx);
 
        if (ctx == NULL) {
                ctx = vfs_context_current();
        }
 
        error = (*mp->mnt_op->vfs_getattr)(mp, vfa, ctx);

-       
-       return(error);
+
+       return error;

 }
 
 }
 

-int 
+int

 VFS_SETATTR(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
        int error;
 
 VFS_SETATTR(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_setattr == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_setattr == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 
        if (ctx == NULL) {
                ctx = vfs_context_current();


@@ -298,16 +311,17 @@ VFS_SETATTR(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 
        error = (*mp->mnt_op->vfs_setattr)(mp, vfa, ctx);
 
 
        error = (*mp->mnt_op->vfs_setattr)(mp, vfa, ctx);
 

-       return(error);
+       return error;

 }
 
 }
 

-int 
+int

 VFS_SYNC(mount_t mp, int flags, vfs_context_t ctx)
 {
        int error;
 
 VFS_SYNC(mount_t mp, int flags, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_sync == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_sync == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 
        if (ctx == NULL) {
                ctx = vfs_context_current();


@@ -315,16 +329,17 @@ VFS_SYNC(mount_t mp, int flags, vfs_context_t ctx)
 
        error = (*mp->mnt_op->vfs_sync)(mp, flags, ctx);
 
 
        error = (*mp->mnt_op->vfs_sync)(mp, flags, ctx);
 

-       return(error);
+       return error;

 }
 
 }
 

-int 
+int

 VFS_VGET(mount_t mp, ino64_t ino, struct vnode **vpp, vfs_context_t ctx)
 {
        int error;
 
 VFS_VGET(mount_t mp, ino64_t ino, struct vnode **vpp, vfs_context_t ctx)
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_vget == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_vget == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 
        if (ctx == NULL) {
                ctx = vfs_context_current();


@@ -332,16 +347,17 @@ VFS_VGET(mount_t mp, ino64_t ino, struct vnode **vpp, vfs_context_t ctx)
 
        error = (*mp->mnt_op->vfs_vget)(mp, ino, vpp, ctx);
 
 
        error = (*mp->mnt_op->vfs_vget)(mp, ino, vpp, ctx);
 

-       return(error);
+       return error;

 }
 
 }
 

-int 
-VFS_FHTOVP(mount_t mp, int fhlen, unsigned char * fhp, vnode_t * vpp, vfs_context_t ctx) 
+int
+VFS_FHTOVP(mount_t mp, int fhlen, unsigned char *fhp, vnode_t *vpp, vfs_context_t ctx)

 {
        int error;
 
 {
        int error;
 

-       if ((mp == dead_mountp) || (mp->mnt_op->vfs_fhtovp == 0))
-               return(ENOTSUP);
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_fhtovp == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 
        if (ctx == NULL) {
                ctx = vfs_context_current();


@@ -349,16 +365,17 @@ VFS_FHTOVP(mount_t mp, int fhlen, unsigned char * fhp, vnode_t * vpp, vfs_contex
 
        error = (*mp->mnt_op->vfs_fhtovp)(mp, fhlen, fhp, vpp, ctx);
 
 
        error = (*mp->mnt_op->vfs_fhtovp)(mp, fhlen, fhp, vpp, ctx);
 

-       return(error);
+       return error;

 }
 
 }
 

-int 
-VFS_VPTOFH(struct vnode * vp, int *fhlenp, unsigned char * fhp, vfs_context_t ctx)
+int
+VFS_VPTOFH(struct vnode *vp, int *fhlenp, unsigned char *fhp, vfs_context_t ctx)

 {
        int error;
 
 {
        int error;
 

-       if ((vp->v_mount == dead_mountp) || (vp->v_mount->mnt_op->vfs_vptofh == 0))
-               return(ENOTSUP);
+       if ((vp->v_mount == dead_mountp) || (vp->v_mount->mnt_op->vfs_vptofh == 0)) {
+               return ENOTSUP;
+       }

 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 
        if (ctx == NULL) {
                ctx = vfs_context_current();


@@ -366,29 +383,58 @@ VFS_VPTOFH(struct vnode * vp, int *fhlenp, unsigned char * fhp, vfs_context_t ct
 
        error = (*vp->v_mount->mnt_op->vfs_vptofh)(vp, fhlenp, fhp, ctx);
 
 
        error = (*vp->v_mount->mnt_op->vfs_vptofh)(vp, fhlenp, fhp, ctx);
 

-       return(error);
+       return error;

 }
 
 }
 

+int
+VFS_IOCTL(struct mount *mp, u_long command, caddr_t data,
+    int flags, vfs_context_t context)
+{
+       if (mp == dead_mountp || !mp->mnt_op->vfs_ioctl) {
+               return ENOTSUP;
+       }
+
+       return mp->mnt_op->vfs_ioctl(mp, command, data, flags,
+                  context ?: vfs_context_current());
+}
+
+int
+VFS_VGET_SNAPDIR(mount_t mp, vnode_t *vpp, vfs_context_t ctx)
+{
+       int error;
+
+       if ((mp == dead_mountp) || (mp->mnt_op->vfs_vget_snapdir == 0)) {
+               return ENOTSUP;
+       }
+
+       if (ctx == NULL) {
+               ctx = vfs_context_current();
+       }
+
+       error = (*mp->mnt_op->vfs_vget_snapdir)(mp, vpp, ctx);
+
+       return error;
+}

 
 /* returns the cached throttle mask for the mount_t */
 uint64_t
 vfs_throttle_mask(mount_t mp)
 {
 
 /* returns the cached throttle mask for the mount_t */
 uint64_t
 vfs_throttle_mask(mount_t mp)
 {

-       return(mp->mnt_throttle_mask);
+       return mp->mnt_throttle_mask;

 }
 
 /* returns a  copy of vfs type name for the mount_t */
 }
 
 /* returns a  copy of vfs type name for the mount_t */

-void 
-vfs_name(mount_t mp, char * buffer)
+void
+vfs_name(mount_t mp, char *buffer)

 {
 {

-        strncpy(buffer, mp->mnt_vtable->vfc_name, MFSNAMELEN);
+       strncpy(buffer, mp->mnt_vtable->vfc_name, MFSNAMELEN);

 }
 
 /* returns  vfs type number for the mount_t */
 }
 
 /* returns  vfs type number for the mount_t */

-int 
+int

 vfs_typenum(mount_t mp)
 {
 vfs_typenum(mount_t mp)
 {

-       return(mp->mnt_vtable->vfc_typenum);
+       return mp->mnt_vtable->vfc_typenum;

 }
 
 /* Safe to cast to "struct label*"; returns "void*" to limit dependence of mount.h on security headers.  */
 }
 
 /* Safe to cast to "struct label*"; returns "void*" to limit dependence of mount.h on security headers.  */


@@ -399,17 +445,17 @@ vfs_mntlabel(mount_t mp)
 }
 
 /* returns command modifier flags of mount_t ie. MNT_CMDFLAGS */
 }
 
 /* returns command modifier flags of mount_t ie. MNT_CMDFLAGS */

-uint64_t 
+uint64_t

 vfs_flags(mount_t mp)
 {
 vfs_flags(mount_t mp)
 {

-       return((uint64_t)(mp->mnt_flag & (MNT_CMDFLAGS | MNT_VISFLAGMASK)));
+       return (uint64_t)(mp->mnt_flag & (MNT_CMDFLAGS | MNT_VISFLAGMASK));

 }
 
 /* set any of the command modifier flags(MNT_CMDFLAGS) in mount_t */
 }
 
 /* set any of the command modifier flags(MNT_CMDFLAGS) in mount_t */

-void 
+void

 vfs_setflags(mount_t mp, uint64_t flags)
 {
 vfs_setflags(mount_t mp, uint64_t flags)
 {

-       uint32_t lflags = (uint32_t)(flags & (MNT_CMDFLAGS | MNT_VISFLAGMASK)); 
+       uint32_t lflags = (uint32_t)(flags & (MNT_CMDFLAGS | MNT_VISFLAGMASK));

 
        mount_lock(mp);
        mp->mnt_flag |= lflags;
 
        mount_lock(mp);
        mp->mnt_flag |= lflags;


@@ -417,10 +463,10 @@ vfs_setflags(mount_t mp, uint64_t flags)
 }
 
 /* clear any of the command modifier flags(MNT_CMDFLAGS) in mount_t */
 }
 
 /* clear any of the command modifier flags(MNT_CMDFLAGS) in mount_t */

-void 
-vfs_clearflags(mount_t mp , uint64_t flags)
+void
+vfs_clearflags(mount_t mp, uint64_t flags)

 {
 {

-       uint32_t lflags = (uint32_t)(flags & (MNT_CMDFLAGS | MNT_VISFLAGMASK)); 
+       uint32_t lflags = (uint32_t)(flags & (MNT_CMDFLAGS | MNT_VISFLAGMASK));

 
        mount_lock(mp);
        mp->mnt_flag &= ~lflags;
 
        mount_lock(mp);
        mp->mnt_flag &= ~lflags;


@@ -428,58 +474,59 @@ vfs_clearflags(mount_t mp , uint64_t flags)
 }
 
 /* Is the mount_t ronly and upgrade read/write requested? */
 }
 
 /* Is the mount_t ronly and upgrade read/write requested? */

-int 
+int

 vfs_iswriteupgrade(mount_t mp) /* ronly &&  MNTK_WANTRDWR */
 {
 vfs_iswriteupgrade(mount_t mp) /* ronly &&  MNTK_WANTRDWR */
 {

-       return ((mp->mnt_flag & MNT_RDONLY) && (mp->mnt_kern_flag & MNTK_WANTRDWR));
+       return (mp->mnt_flag & MNT_RDONLY) && (mp->mnt_kern_flag & MNTK_WANTRDWR);

 }
 
 
 /* Is the mount_t mounted ronly */
 }
 
 
 /* Is the mount_t mounted ronly */

-int 
+int

 vfs_isrdonly(mount_t mp)
 {
 vfs_isrdonly(mount_t mp)
 {

-       return (mp->mnt_flag & MNT_RDONLY);
+       return mp->mnt_flag & MNT_RDONLY;

 }
 
 /* Is the mount_t mounted for filesystem synchronous writes? */
 }
 
 /* Is the mount_t mounted for filesystem synchronous writes? */

-int 
+int

 vfs_issynchronous(mount_t mp)
 {
 vfs_issynchronous(mount_t mp)
 {

-       return (mp->mnt_flag & MNT_SYNCHRONOUS);
+       return mp->mnt_flag & MNT_SYNCHRONOUS;

 }
 
 /* Is the mount_t mounted read/write? */
 }
 
 /* Is the mount_t mounted read/write? */

-int 
+int

 vfs_isrdwr(mount_t mp)
 {
 vfs_isrdwr(mount_t mp)
 {

-       return ((mp->mnt_flag & MNT_RDONLY) == 0);
+       return (mp->mnt_flag & MNT_RDONLY) == 0;

 }
 
 
 /* Is mount_t marked for update (ie MNT_UPDATE) */
 }
 
 
 /* Is mount_t marked for update (ie MNT_UPDATE) */

-int 
-vfs_isupdate(mount_t mp) 
+int
+vfs_isupdate(mount_t mp)

 {
 {

-       return (mp->mnt_flag & MNT_UPDATE);
+       return mp->mnt_flag & MNT_UPDATE;

 }
 
 
 /* Is mount_t marked for reload (ie MNT_RELOAD) */
 }
 
 
 /* Is mount_t marked for reload (ie MNT_RELOAD) */

-int 
+int

 vfs_isreload(mount_t mp)
 {
 vfs_isreload(mount_t mp)
 {

-       return ((mp->mnt_flag & MNT_UPDATE) && (mp->mnt_flag & MNT_RELOAD));
+       return (mp->mnt_flag & MNT_UPDATE) && (mp->mnt_flag & MNT_RELOAD);

 }
 
 /* Is mount_t marked for forced unmount (ie MNT_FORCE or MNTK_FRCUNMOUNT) */
 }
 
 /* Is mount_t marked for forced unmount (ie MNT_FORCE or MNTK_FRCUNMOUNT) */

-int 
+int

 vfs_isforce(mount_t mp)
 {
 vfs_isforce(mount_t mp)
 {

-       if (mp->mnt_lflag & MNT_LFORCE)
-               return(1);
-       else
-               return(0);
+       if (mp->mnt_lflag & MNT_LFORCE) {
+               return 1;
+       } else {
+               return 0;
+       }

 }
 
 int
 }
 
 int


@@ -495,20 +542,22 @@ vfs_isunmount(mount_t mp)
 int
 vfs_64bitready(mount_t mp)
 {
 int
 vfs_64bitready(mount_t mp)
 {

-       if ((mp->mnt_vtable->vfc_vfsflags & VFC_VFS64BITREADY))
-               return(1);
-       else
-               return(0);
+       if ((mp->mnt_vtable->vfc_vfsflags & VFC_VFS64BITREADY)) {
+               return 1;
+       } else {
+               return 0;
+       }

 }
 
 
 int
 vfs_authcache_ttl(mount_t mp)
 {
 }
 
 
 int
 vfs_authcache_ttl(mount_t mp)
 {

-        if ( (mp->mnt_kern_flag & (MNTK_AUTH_OPAQUE | MNTK_AUTH_CACHE_TTL)) )
-               return (mp->mnt_authcache_ttl);
-       else
-               return (CACHED_RIGHT_INFINITE_TTL);
+       if ((mp->mnt_kern_flag & (MNTK_AUTH_OPAQUE | MNTK_AUTH_CACHE_TTL))) {
+               return mp->mnt_authcache_ttl;
+       } else {
+               return CACHED_RIGHT_INFINITE_TTL;
+       }

 }
 
 void
 }
 
 void


@@ -536,19 +585,21 @@ vfs_clearauthcache_ttl(mount_t mp)
 int
 vfs_authopaque(mount_t mp)
 {
 int
 vfs_authopaque(mount_t mp)
 {

-       if ((mp->mnt_kern_flag & MNTK_AUTH_OPAQUE))
-               return(1);
-       else
-               return(0);
+       if ((mp->mnt_kern_flag & MNTK_AUTH_OPAQUE)) {
+               return 1;
+       } else {
+               return 0;
+       }

 }
 
 }
 

-int 
+int

 vfs_authopaqueaccess(mount_t mp)
 {
 vfs_authopaqueaccess(mount_t mp)
 {

-       if ((mp->mnt_kern_flag & MNTK_AUTH_OPAQUE_ACCESS))
-               return(1);
-       else
-               return(0);
+       if ((mp->mnt_kern_flag & MNTK_AUTH_OPAQUE_ACCESS)) {
+               return 1;
+       } else {
+               return 0;
+       }

 }
 
 void
 }
 
 void


@@ -559,7 +610,7 @@ vfs_setauthopaque(mount_t mp)
        mount_unlock(mp);
 }
 
        mount_unlock(mp);
 }
 

-void 
+void

 vfs_setauthopaqueaccess(mount_t mp)
 {
        mount_lock(mp);
 vfs_setauthopaqueaccess(mount_t mp)
 {
        mount_lock(mp);


@@ -575,7 +626,7 @@ vfs_clearauthopaque(mount_t mp)
        mount_unlock(mp);
 }
 
        mount_unlock(mp);
 }
 

-void 
+void

 vfs_clearauthopaqueaccess(mount_t mp)
 {
        mount_lock(mp);
 vfs_clearauthopaqueaccess(mount_t mp)
 {
        mount_lock(mp);


@@ -599,62 +650,87 @@ vfs_clearextendedsecurity(mount_t mp)
        mount_unlock(mp);
 }
 
        mount_unlock(mp);
 }
 

+void
+vfs_setnoswap(mount_t mp)
+{
+       mount_lock(mp);
+       mp->mnt_kern_flag |= MNTK_NOSWAP;
+       mount_unlock(mp);
+}
+
+void
+vfs_clearnoswap(mount_t mp)
+{
+       mount_lock(mp);
+       mp->mnt_kern_flag &= ~MNTK_NOSWAP;
+       mount_unlock(mp);
+}
+

 int
 vfs_extendedsecurity(mount_t mp)
 {
 int
 vfs_extendedsecurity(mount_t mp)
 {

-       return(mp->mnt_kern_flag & MNTK_EXTENDED_SECURITY);
+       return mp->mnt_kern_flag & MNTK_EXTENDED_SECURITY;

 }
 
 /* returns the max size of short symlink in this mount_t */
 }
 
 /* returns the max size of short symlink in this mount_t */

-uint32_t 
+uint32_t

 vfs_maxsymlen(mount_t mp)
 {
 vfs_maxsymlen(mount_t mp)
 {

-       return(mp->mnt_maxsymlinklen);
+       return mp->mnt_maxsymlinklen;

 }
 
 /* set  max size of short symlink on mount_t */
 }
 
 /* set  max size of short symlink on mount_t */

-void 
+void

 vfs_setmaxsymlen(mount_t mp, uint32_t symlen)
 {
        mp->mnt_maxsymlinklen = symlen;
 }
 
 /* return a pointer to the RO vfs_statfs associated with mount_t */
 vfs_setmaxsymlen(mount_t mp, uint32_t symlen)
 {
        mp->mnt_maxsymlinklen = symlen;
 }
 
 /* return a pointer to the RO vfs_statfs associated with mount_t */

-struct vfsstatfs * 
+struct vfsstatfs *

 vfs_statfs(mount_t mp)
 {
 vfs_statfs(mount_t mp)
 {

-       return(&mp->mnt_vfsstat);
+       return &mp->mnt_vfsstat;

 }
 
 int
 vfs_getattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
 }
 
 int
 vfs_getattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {

-       int             error;
+       int             error;

 
 

-       if ((error = VFS_GETATTR(mp, vfa, ctx)) != 0)
-               return(error);
+       if ((error = VFS_GETATTR(mp, vfa, ctx)) != 0) {
+               return error;
+       }

 
        /*
 
        /*

-        * If we have a filesystem create time, use it to default some others.
-        */
-       if (VFSATTR_IS_SUPPORTED(vfa, f_create_time)) {
-               if (VFSATTR_IS_ACTIVE(vfa, f_modify_time) && !VFSATTR_IS_SUPPORTED(vfa, f_modify_time))
-                       VFSATTR_RETURN(vfa, f_modify_time, vfa->f_create_time);
-       }
+        * If we have a filesystem create time, use it to default some others.
+        */
+       if (VFSATTR_IS_SUPPORTED(vfa, f_create_time)) {
+               if (VFSATTR_IS_ACTIVE(vfa, f_modify_time) && !VFSATTR_IS_SUPPORTED(vfa, f_modify_time)) {
+                       VFSATTR_RETURN(vfa, f_modify_time, vfa->f_create_time);
+               }
+       }

 
 

-       return(0);
+       return 0;

 }
 
 int
 vfs_setattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
        int error;
 }
 
 int
 vfs_setattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 {
        int error;

-       
-       if (vfs_isrdonly(mp))
+
+       /*
+        * with a read-only system volume, we need to allow rename of the root volume
+        * even if it's read-only.  Don't return EROFS here if setattr changes only
+        * the volume name
+        */
+       if (vfs_isrdonly(mp) &&
+           !((mp->mnt_flag & MNT_ROOTFS) && (vfa->f_active == VFSATTR_f_vol_name))) {

                return EROFS;
                return EROFS;

+       }

 
        error = VFS_SETATTR(mp, vfa, ctx);
 
        error = VFS_SETATTR(mp, vfa, ctx);

-       
+

        /*
         * If we had alternate ways of setting vfs attributes, we'd
         * fall back here.
        /*
         * If we had alternate ways of setting vfs attributes, we'd
         * fall back here.


@@ -667,11 +743,11 @@ vfs_setattr(mount_t mp, struct vfs_attr *vfa, vfs_context_t ctx)
 void *
 vfs_fsprivate(mount_t mp)
 {
 void *
 vfs_fsprivate(mount_t mp)
 {

-       return(mp->mnt_data);
+       return mp->mnt_data;

 }
 
 /* set the private data handle in mount_t */
 }
 
 /* set the private data handle in mount_t */

-void 
+void

 vfs_setfsprivate(mount_t mp, void *mntdata)
 {
        mount_lock(mp);
 vfs_setfsprivate(mount_t mp, void *mntdata)
 {
        mount_lock(mp);


@@ -680,26 +756,27 @@ vfs_setfsprivate(mount_t mp, void *mntdata)
 }
 
 /* query whether the mount point supports native EAs */
 }
 
 /* query whether the mount point supports native EAs */

-int 
-vfs_nativexattrs(mount_t mp) {
-       return (mp->mnt_kern_flag & MNTK_EXTENDED_ATTRS);
+int
+vfs_nativexattrs(mount_t mp)
+{
+       return mp->mnt_kern_flag & MNTK_EXTENDED_ATTRS;

 }
 }

-       
+

 /*
  * return the block size of the underlying
  * device associated with mount_t
  */
 int
 /*
  * return the block size of the underlying
  * device associated with mount_t
  */
 int

-vfs_devblocksize(mount_t mp) {
-
-        return(mp->mnt_devblocksize);
+vfs_devblocksize(mount_t mp)
+{
+       return mp->mnt_devblocksize;

 }
 
 }
 

-/* 
- * Returns vnode with an iocount that must be released with vnode_put() 
+/*
+ * Returns vnode with an iocount that must be released with vnode_put()

  */
 vnode_t
  */
 vnode_t

-vfs_vnodecovered(mount_t mp) 
+vfs_vnodecovered(mount_t mp)

 {
        vnode_t vp = mp->mnt_vnodecovered;
        if ((vp == NULL) || (vnode_getwithref(vp) != 0)) {
 {
        vnode_t vp = mp->mnt_vnodecovered;
        if ((vp == NULL) || (vnode_getwithref(vp) != 0)) {


@@ -714,7 +791,7 @@ vfs_vnodecovered(mount_t mp)
  * The iocount must be released with vnode_put().  Note that this KPI is subtle
  * with respect to the validity of using this device vnode for anything substantial
  * (which is discouraged).  If commands are sent to the device driver without
  * The iocount must be released with vnode_put().  Note that this KPI is subtle
  * with respect to the validity of using this device vnode for anything substantial
  * (which is discouraged).  If commands are sent to the device driver without

- * taking proper steps to ensure that the device is still open, chaos may ensue.  
+ * taking proper steps to ensure that the device is still open, chaos may ensue.

  * Similarly, this routine should only be called if there is some guarantee that
  * the mount itself is still valid.
  */
  * Similarly, this routine should only be called if there is some guarantee that
  * the mount itself is still valid.
  */


@@ -736,8 +813,10 @@ vfs_devvp(mount_t mp)
 void
 vfs_ioattr(mount_t mp, struct vfsioattr *ioattrp)
 {
 void
 vfs_ioattr(mount_t mp, struct vfsioattr *ioattrp)
 {

-        if (mp == NULL) {
-               ioattrp->io_maxreadcnt  = MAXPHYS;
+       ioattrp->io_reserved[0] = NULL;
+       ioattrp->io_reserved[1] = NULL;
+       if (mp == NULL) {
+               ioattrp->io_maxreadcnt  = MAXPHYS;

                ioattrp->io_maxwritecnt = MAXPHYS;
                ioattrp->io_segreadcnt  = 32;
                ioattrp->io_segwritecnt = 32;
                ioattrp->io_maxwritecnt = MAXPHYS;
                ioattrp->io_segreadcnt  = 32;
                ioattrp->io_segwritecnt = 32;


@@ -745,8 +824,9 @@ vfs_ioattr(mount_t mp, struct vfsioattr *ioattrp)
                ioattrp->io_maxsegwritesize = MAXPHYS;
                ioattrp->io_devblocksize = DEV_BSIZE;
                ioattrp->io_flags = 0;
                ioattrp->io_maxsegwritesize = MAXPHYS;
                ioattrp->io_devblocksize = DEV_BSIZE;
                ioattrp->io_flags = 0;

+               ioattrp->io_max_swappin_available = 0;

        } else {
        } else {

-               ioattrp->io_maxreadcnt  = mp->mnt_maxreadcnt;
+               ioattrp->io_maxreadcnt  = mp->mnt_maxreadcnt;

                ioattrp->io_maxwritecnt = mp->mnt_maxwritecnt;
                ioattrp->io_segreadcnt  = mp->mnt_segreadcnt;
                ioattrp->io_segwritecnt = mp->mnt_segwritecnt;
                ioattrp->io_maxwritecnt = mp->mnt_maxwritecnt;
                ioattrp->io_segreadcnt  = mp->mnt_segreadcnt;
                ioattrp->io_segwritecnt = mp->mnt_segwritecnt;


@@ -754,21 +834,21 @@ vfs_ioattr(mount_t mp, struct vfsioattr *ioattrp)
                ioattrp->io_maxsegwritesize = mp->mnt_maxsegwritesize;
                ioattrp->io_devblocksize = mp->mnt_devblocksize;
                ioattrp->io_flags = mp->mnt_ioflags;
                ioattrp->io_maxsegwritesize = mp->mnt_maxsegwritesize;
                ioattrp->io_devblocksize = mp->mnt_devblocksize;
                ioattrp->io_flags = mp->mnt_ioflags;

+               ioattrp->io_max_swappin_available = mp->mnt_max_swappin_available;

        }
        }

-       ioattrp->io_reserved[0] = NULL;
-       ioattrp->io_reserved[1] = NULL;

 }
 
 
 /*
  * set the IO attributes associated with mount_t
  */
 }
 
 
 /*
  * set the IO attributes associated with mount_t
  */

-void 
+void

 vfs_setioattr(mount_t mp, struct vfsioattr * ioattrp)
 {
 vfs_setioattr(mount_t mp, struct vfsioattr * ioattrp)
 {

-        if (mp == NULL)
-               return;
-        mp->mnt_maxreadcnt  = ioattrp->io_maxreadcnt;
+       if (mp == NULL) {
+               return;
+       }
+       mp->mnt_maxreadcnt  = ioattrp->io_maxreadcnt;

        mp->mnt_maxwritecnt = ioattrp->io_maxwritecnt;
        mp->mnt_segreadcnt  = ioattrp->io_segreadcnt;
        mp->mnt_segwritecnt = ioattrp->io_segwritecnt;
        mp->mnt_maxwritecnt = ioattrp->io_maxwritecnt;
        mp->mnt_segreadcnt  = ioattrp->io_segreadcnt;
        mp->mnt_segwritecnt = ioattrp->io_segwritecnt;


@@ -776,24 +856,25 @@ vfs_setioattr(mount_t mp, struct vfsioattr * ioattrp)
        mp->mnt_maxsegwritesize = ioattrp->io_maxsegwritesize;
        mp->mnt_devblocksize = ioattrp->io_devblocksize;
        mp->mnt_ioflags = ioattrp->io_flags;
        mp->mnt_maxsegwritesize = ioattrp->io_maxsegwritesize;
        mp->mnt_devblocksize = ioattrp->io_devblocksize;
        mp->mnt_ioflags = ioattrp->io_flags;

+       mp->mnt_max_swappin_available = ioattrp->io_max_swappin_available;

 }
 }

- 
+

 /*
  * Add a new filesystem into the kernel specified in passed in
 /*
  * Add a new filesystem into the kernel specified in passed in

- * vfstable structure. It fills in the vnode 
+ * vfstable structure. It fills in the vnode

  * dispatch vector that is to be passed to when vnodes are created.
  * It returns a handle which is to be used to when the FS is to be removed
  */
 typedef int (*PFI)(void *);
 extern int vfs_opv_numops;
 errno_t
  * dispatch vector that is to be passed to when vnodes are created.
  * It returns a handle which is to be used to when the FS is to be removed
  */
 typedef int (*PFI)(void *);
 extern int vfs_opv_numops;
 errno_t

-vfs_fsadd(struct vfs_fsentry *vfe, vfstable_t * handle)
+vfs_fsadd(struct vfs_fsentry *vfe, vfstable_t *handle)

 {
 {

-       struct vfstable *newvfstbl = NULL;
-       int     i,j;
-       int     (***opv_desc_vector_p)(void *);
-       int     (**opv_desc_vector)(void *);
-       struct vnodeopv_entry_desc      *opve_descp; 
+       struct vfstable *newvfstbl = NULL;
+       int     i, j;
+       int(***opv_desc_vector_p)(void *);
+       int(**opv_desc_vector)(void *);
+       const struct vnodeopv_entry_desc        *opve_descp;

        int desccount;
        int descsize;
        PFI *descptr;
        int desccount;
        int descsize;
        PFI *descptr;


@@ -803,57 +884,76 @@ vfs_fsadd(struct vfs_fsentry *vfe, vfstable_t * handle)
         * ordinarily be done as part of the system startup;
         */
 
         * ordinarily be done as part of the system startup;
         */
 

-       if (vfe == (struct vfs_fsentry *)0)
-               return(EINVAL);
+       if (vfe == (struct vfs_fsentry *)0) {
+               return EINVAL;
+       }

 
        desccount = vfe->vfe_vopcnt;
 
        desccount = vfe->vfe_vopcnt;

-       if ((desccount <=0) || ((desccount > 8)) || (vfe->vfe_vfsops == (struct vfsops *)NULL)
-               || (vfe->vfe_opvdescs == (struct vnodeopv_desc **)NULL))
-               return(EINVAL);
+       if ((desccount <= 0) || ((desccount > 8)) || (vfe->vfe_vfsops == (struct vfsops *)NULL)
+           || (vfe->vfe_opvdescs == (struct vnodeopv_desc **)NULL)) {
+               return EINVAL;
+       }

 
        /* Non-threadsafe filesystems are not supported */
        if ((vfe->vfe_flags &  (VFS_TBLTHREADSAFE | VFS_TBLFSNODELOCK)) == 0) {
 
        /* Non-threadsafe filesystems are not supported */
        if ((vfe->vfe_flags &  (VFS_TBLTHREADSAFE | VFS_TBLFSNODELOCK)) == 0) {

-               return (EINVAL);
+               return EINVAL;

        }
 
        MALLOC(newvfstbl, void *, sizeof(struct vfstable), M_TEMP,
        }
 
        MALLOC(newvfstbl, void *, sizeof(struct vfstable), M_TEMP,

-              M_WAITOK);
+           M_WAITOK);

        bzero(newvfstbl, sizeof(struct vfstable));
        newvfstbl->vfc_vfsops = vfe->vfe_vfsops;
        strncpy(&newvfstbl->vfc_name[0], vfe->vfe_fsname, MFSNAMELEN);
        bzero(newvfstbl, sizeof(struct vfstable));
        newvfstbl->vfc_vfsops = vfe->vfe_vfsops;
        strncpy(&newvfstbl->vfc_name[0], vfe->vfe_fsname, MFSNAMELEN);

-       if ((vfe->vfe_flags & VFS_TBLNOTYPENUM))
+       if ((vfe->vfe_flags & VFS_TBLNOTYPENUM)) {

                newvfstbl->vfc_typenum = maxvfstypenum++;
                newvfstbl->vfc_typenum = maxvfstypenum++;

-       else
+       } else {

                newvfstbl->vfc_typenum = vfe->vfe_fstypenum;
                newvfstbl->vfc_typenum = vfe->vfe_fstypenum;

-       
+       }
+

        newvfstbl->vfc_refcount = 0;
        newvfstbl->vfc_flags = 0;
        newvfstbl->vfc_mountroot = NULL;
        newvfstbl->vfc_next = NULL;
        newvfstbl->vfc_vfsflags = 0;
        newvfstbl->vfc_refcount = 0;
        newvfstbl->vfc_flags = 0;
        newvfstbl->vfc_mountroot = NULL;
        newvfstbl->vfc_next = NULL;
        newvfstbl->vfc_vfsflags = 0;

-       if (vfe->vfe_flags &  VFS_TBL64BITREADY)
+       if (vfe->vfe_flags &  VFS_TBL64BITREADY) {

                newvfstbl->vfc_vfsflags |= VFC_VFS64BITREADY;
                newvfstbl->vfc_vfsflags |= VFC_VFS64BITREADY;

-       if (vfe->vfe_flags &  VFS_TBLVNOP_PAGEINV2)
+       }
+       if (vfe->vfe_flags &  VFS_TBLVNOP_PAGEINV2) {

                newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_PAGEINV2;
                newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_PAGEINV2;

-       if (vfe->vfe_flags &  VFS_TBLVNOP_PAGEOUTV2)
+       }
+       if (vfe->vfe_flags &  VFS_TBLVNOP_PAGEOUTV2) {

                newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_PAGEOUTV2;
                newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_PAGEOUTV2;

-       if ((vfe->vfe_flags & VFS_TBLLOCALVOL) == VFS_TBLLOCALVOL)
+       }
+       if ((vfe->vfe_flags & VFS_TBLLOCALVOL) == VFS_TBLLOCALVOL) {

                newvfstbl->vfc_flags |= MNT_LOCAL;
                newvfstbl->vfc_flags |= MNT_LOCAL;

-       if ((vfe->vfe_flags & VFS_TBLLOCALVOL) && (vfe->vfe_flags & VFS_TBLGENERICMNTARGS) == 0)
+       }
+       if ((vfe->vfe_flags & VFS_TBLLOCALVOL) && (vfe->vfe_flags & VFS_TBLGENERICMNTARGS) == 0) {

                newvfstbl->vfc_vfsflags |= VFC_VFSLOCALARGS;
                newvfstbl->vfc_vfsflags |= VFC_VFSLOCALARGS;

-       else
+       } else {

                newvfstbl->vfc_vfsflags |= VFC_VFSGENERICARGS;
                newvfstbl->vfc_vfsflags |= VFC_VFSGENERICARGS;

+       }

 
 

-       if (vfe->vfe_flags &  VFS_TBLNATIVEXATTR)
+       if (vfe->vfe_flags &  VFS_TBLNATIVEXATTR) {

                newvfstbl->vfc_vfsflags |= VFC_VFSNATIVEXATTR;
                newvfstbl->vfc_vfsflags |= VFC_VFSNATIVEXATTR;

-       if (vfe->vfe_flags &  VFS_TBLUNMOUNT_PREFLIGHT)
+       }
+       if (vfe->vfe_flags &  VFS_TBLUNMOUNT_PREFLIGHT) {

                newvfstbl->vfc_vfsflags |= VFC_VFSPREFLIGHT;
                newvfstbl->vfc_vfsflags |= VFC_VFSPREFLIGHT;

-       if (vfe->vfe_flags &  VFS_TBLREADDIR_EXTENDED)
+       }
+       if (vfe->vfe_flags &  VFS_TBLREADDIR_EXTENDED) {

                newvfstbl->vfc_vfsflags |= VFC_VFSREADDIR_EXTENDED;
                newvfstbl->vfc_vfsflags |= VFC_VFSREADDIR_EXTENDED;

-       if (vfe->vfe_flags & VFS_TBLNOMACLABEL)
+       }
+       if (vfe->vfe_flags & VFS_TBLNOMACLABEL) {

                newvfstbl->vfc_vfsflags |= VFC_VFSNOMACLABEL;
                newvfstbl->vfc_vfsflags |= VFC_VFSNOMACLABEL;

-       if (vfe->vfe_flags & VFS_TBLVNOP_NOUPDATEID_RENAME)
+       }
+       if (vfe->vfe_flags & VFS_TBLVNOP_NOUPDATEID_RENAME) {

                newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_NOUPDATEID_RENAME;
                newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_NOUPDATEID_RENAME;

+       }
+       if (vfe->vfe_flags & VFS_TBLVNOP_SECLUDE_RENAME) {
+               newvfstbl->vfc_vfsflags |= VFC_VFSVNOP_SECLUDE_RENAME;
+       }
+       if (vfe->vfe_flags & VFS_TBLCANMOUNTROOT) {
+               newvfstbl->vfc_vfsflags |= VFC_VFSCANMOUNTROOT;
+       }

 
        /*
         * Allocate and init the vectors.
 
        /*
         * Allocate and init the vectors.


@@ -866,84 +966,94 @@ vfs_fsadd(struct vfs_fsentry *vfe, vfstable_t * handle)
 
        descsize = desccount * vfs_opv_numops * sizeof(PFI);
        MALLOC(descptr, PFI *, descsize,
 
        descsize = desccount * vfs_opv_numops * sizeof(PFI);
        MALLOC(descptr, PFI *, descsize,

-              M_TEMP, M_WAITOK);
+           M_TEMP, M_WAITOK);

        bzero(descptr, descsize);
 
        newvfstbl->vfc_descptr = descptr;
        newvfstbl->vfc_descsize = descsize;
        bzero(descptr, descsize);
 
        newvfstbl->vfc_descptr = descptr;
        newvfstbl->vfc_descsize = descsize;

-       
-       newvfstbl->vfc_sysctl = NULL;

 
 

-       for (i= 0; i< desccount; i++ ) {
-       opv_desc_vector_p = vfe->vfe_opvdescs[i]->opv_desc_vector_p;
-       /*
-        * Fill in the caller's pointer to the start of the i'th vector.
-        * They'll need to supply it when calling vnode_create.
-        */
-       opv_desc_vector = descptr + i * vfs_opv_numops;
-       *opv_desc_vector_p = opv_desc_vector;
-
-       for (j = 0; vfe->vfe_opvdescs[i]->opv_desc_ops[j].opve_op; j++) {
-               opve_descp = &(vfe->vfe_opvdescs[i]->opv_desc_ops[j]);
+       newvfstbl->vfc_sysctl = NULL;

 
 

+       for (i = 0; i < desccount; i++) {
+               opv_desc_vector_p = vfe->vfe_opvdescs[i]->opv_desc_vector_p;

                /*
                /*

-                * Sanity check:  is this operation listed
-                * in the list of operations?  We check this
-                * by seeing if its offset is zero.  Since
-                * the default routine should always be listed
-                * first, it should be the only one with a zero
-                * offset.  Any other operation with a zero
-                * offset is probably not listed in
-                * vfs_op_descs, and so is probably an error.
-                *
-                * A panic here means the layer programmer
-                * has committed the all-too common bug
-                * of adding a new operation to the layer's
-                * list of vnode operations but
-                * not adding the operation to the system-wide
-                * list of supported operations.
+                * Fill in the caller's pointer to the start of the i'th vector.
+                * They'll need to supply it when calling vnode_create.

                 */
                 */

-               if (opve_descp->opve_op->vdesc_offset == 0 &&
-                   opve_descp->opve_op->vdesc_offset != VOFFSET(vnop_default)) {
-                       printf("vfs_fsadd: operation %s not listed in %s.\n",
-                              opve_descp->opve_op->vdesc_name,
-                              "vfs_op_descs");
-                       panic("vfs_fsadd: bad operation");
-               }
-               /*
-                * Fill in this entry.
-                */
-               opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
-                   opve_descp->opve_impl;
-       }
+               opv_desc_vector = descptr + i * vfs_opv_numops;
+               *opv_desc_vector_p = opv_desc_vector;

 
 

+               for (j = 0; vfe->vfe_opvdescs[i]->opv_desc_ops[j].opve_op; j++) {
+                       opve_descp = &(vfe->vfe_opvdescs[i]->opv_desc_ops[j]);
+
+                       /* Silently skip known-disabled operations */
+                       if (opve_descp->opve_op->vdesc_flags & VDESC_DISABLED) {
+                               printf("vfs_fsadd: Ignoring reference in %p to disabled operation %s.\n",
+                                   vfe->vfe_opvdescs[i], opve_descp->opve_op->vdesc_name);
+                               continue;
+                       }
+
+                       /*
+                        * Sanity check:  is this operation listed
+                        * in the list of operations?  We check this
+                        * by seeing if its offset is zero.  Since
+                        * the default routine should always be listed
+                        * first, it should be the only one with a zero
+                        * offset.  Any other operation with a zero
+                        * offset is probably not listed in
+                        * vfs_op_descs, and so is probably an error.
+                        *
+                        * A panic here means the layer programmer
+                        * has committed the all-too common bug
+                        * of adding a new operation to the layer's
+                        * list of vnode operations but
+                        * not adding the operation to the system-wide
+                        * list of supported operations.
+                        */
+                       if (opve_descp->opve_op->vdesc_offset == 0 &&
+                           opve_descp->opve_op != VDESC(vnop_default)) {
+                               printf("vfs_fsadd: operation %s not listed in %s.\n",
+                                   opve_descp->opve_op->vdesc_name,
+                                   "vfs_op_descs");
+                               panic("vfs_fsadd: bad operation");
+                       }
+                       /*
+                        * Fill in this entry.
+                        */
+                       opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
+                           opve_descp->opve_impl;
+               }

 
 

-       /*  
-        * Finally, go back and replace unfilled routines
-        * with their default.  (Sigh, an O(n^3) algorithm.  I
-        * could make it better, but that'd be work, and n is small.)
-        */  
-       opv_desc_vector_p = vfe->vfe_opvdescs[i]->opv_desc_vector_p;

 
 

-       /*   
-        * Force every operations vector to have a default routine.
-        */  
-       opv_desc_vector = *opv_desc_vector_p;
-       if (opv_desc_vector[VOFFSET(vnop_default)] == NULL)
-           panic("vfs_fsadd: operation vector without default routine.");
-       for (j = 0; j < vfs_opv_numops; j++)  
-               if (opv_desc_vector[j] == NULL)
-                       opv_desc_vector[j] =
-                           opv_desc_vector[VOFFSET(vnop_default)];
+               /*
+                * Finally, go back and replace unfilled routines
+                * with their default.  (Sigh, an O(n^3) algorithm.  I
+                * could make it better, but that'd be work, and n is small.)
+                */
+               opv_desc_vector_p = vfe->vfe_opvdescs[i]->opv_desc_vector_p;

 
 

+               /*
+                * Force every operations vector to have a default routine.
+                */
+               opv_desc_vector = *opv_desc_vector_p;
+               if (opv_desc_vector[VOFFSET(vnop_default)] == NULL) {
+                       panic("vfs_fsadd: operation vector without default routine.");
+               }
+               for (j = 0; j < vfs_opv_numops; j++) {
+                       if (opv_desc_vector[j] == NULL) {
+                               opv_desc_vector[j] =
+                                   opv_desc_vector[VOFFSET(vnop_default)];
+                       }
+               }

        } /* end of each vnodeopv_desc parsing */
 
 
        } /* end of each vnodeopv_desc parsing */
 
 

-       
+

        *handle = vfstable_add(newvfstbl);
 
        *handle = vfstable_add(newvfstbl);
 

-       if (newvfstbl->vfc_typenum <= maxvfstypenum )
-                       maxvfstypenum = newvfstbl->vfc_typenum + 1;
+       if (newvfstbl->vfc_typenum <= maxvfstypenum) {
+               maxvfstypenum = newvfstbl->vfc_typenum + 1;
+       }

 
        if (newvfstbl->vfc_vfsops->vfs_init) {
                struct vfsconf vfsc;
 
        if (newvfstbl->vfc_vfsops->vfs_init) {
                struct vfsconf vfsc;


@@ -961,28 +1071,28 @@ vfs_fsadd(struct vfs_fsentry *vfe, vfstable_t * handle)
 
        FREE(newvfstbl, M_TEMP);
 
 
        FREE(newvfstbl, M_TEMP);
 

-       return(0);
+       return 0;

 }
 
 /*
  * Removes the filesystem from kernel.
 }
 
 /*
  * Removes the filesystem from kernel.

- * The argument passed in is the handle that was given when 
+ * The argument passed in is the handle that was given when

  * file system was added
  */
  * file system was added
  */

-errno_t  
-vfs_fsremove(vfstable_t  handle)
+errno_t
+vfs_fsremove(vfstable_t handle)

 {
        struct vfstable * vfstbl =  (struct vfstable *)handle;
        void *old_desc = NULL;
        errno_t err;
 {
        struct vfstable * vfstbl =  (struct vfstable *)handle;
        void *old_desc = NULL;
        errno_t err;

-       
+

        /* Preflight check for any mounts */
        mount_list_lock();
        /* Preflight check for any mounts */
        mount_list_lock();

-       if ( vfstbl->vfc_refcount != 0 ) {
+       if (vfstbl->vfc_refcount != 0) {

                mount_list_unlock();
                return EBUSY;
        }
                mount_list_unlock();
                return EBUSY;
        }

-       
+

        /*
         * save the old descriptor; the free cannot occur unconditionally,
         * since vfstable_del() may fail.
        /*
         * save the old descriptor; the free cannot occur unconditionally,
         * since vfstable_del() may fail.


@@ -999,19 +1109,48 @@ vfs_fsremove(vfstable_t  handle)
                FREE(old_desc, M_TEMP);
        }
 
                FREE(old_desc, M_TEMP);
        }
 

-       return(err);
+       return err;
+}
+
+void
+vfs_setowner(mount_t mp, uid_t uid, gid_t gid)
+{
+       mp->mnt_fsowner = uid;
+       mp->mnt_fsgroup = gid;
+}
+
+/*
+ * Callers should be careful how they use this; accessing
+ * mnt_last_write_completed_timestamp is not thread-safe.  Writing to
+ * it isn't either.  Point is: be prepared to deal with strange values
+ * being returned.
+ */
+uint64_t
+vfs_idle_time(mount_t mp)
+{
+       if (mp->mnt_pending_write_size) {
+               return 0;
+       }
+
+       struct timeval now;
+
+       microuptime(&now);
+
+       return (now.tv_sec
+              - mp->mnt_last_write_completed_timestamp.tv_sec) * 1000000
+              + now.tv_usec - mp->mnt_last_write_completed_timestamp.tv_usec;

 }
 
 int
 vfs_context_pid(vfs_context_t ctx)
 {
 }
 
 int
 vfs_context_pid(vfs_context_t ctx)
 {

-       return (proc_pid(vfs_context_proc(ctx)));
+       return proc_pid(vfs_context_proc(ctx));

 }
 
 int
 vfs_context_suser(vfs_context_t ctx)
 {
 }
 
 int
 vfs_context_suser(vfs_context_t ctx)
 {

-       return (suser(ctx->vc_ucred, NULL));
+       return suser(ctx->vc_ucred, NULL);

 }
 
 /*
 }
 
 /*


@@ -1024,9 +1163,10 @@ int
 vfs_context_issignal(vfs_context_t ctx, sigset_t mask)
 {
        proc_t p = vfs_context_proc(ctx);
 vfs_context_issignal(vfs_context_t ctx, sigset_t mask)
 {
        proc_t p = vfs_context_proc(ctx);

-       if (p)
-               return(proc_pendingsignals(p, mask));
-       return(0);
+       if (p) {
+               return proc_pendingsignals(p, mask);
+       }
+       return 0;

 }
 
 int
 }
 
 int


@@ -1034,9 +1174,10 @@ vfs_context_is64bit(vfs_context_t ctx)
 {
        proc_t proc = vfs_context_proc(ctx);
 
 {
        proc_t proc = vfs_context_proc(ctx);
 

-       if (proc)
-               return(proc_is64bit(proc));
-       return(0);
+       if (proc) {
+               return proc_is64bit(proc);
+       }
+       return 0;

 }
 
 
 }
 
 


@@ -1066,35 +1207,38 @@ vfs_context_is64bit(vfs_context_t ctx)
 proc_t
 vfs_context_proc(vfs_context_t ctx)
 {
 proc_t
 vfs_context_proc(vfs_context_t ctx)
 {

-       proc_t  proc = NULL;
+       proc_t  proc = NULL;

 
 

-       if (ctx != NULL && ctx->vc_thread != NULL)
+       if (ctx != NULL && ctx->vc_thread != NULL) {

                proc = (proc_t)get_bsdthreadtask_info(ctx->vc_thread);
                proc = (proc_t)get_bsdthreadtask_info(ctx->vc_thread);

-       if (proc != NULL && (proc->p_fd == NULL || (proc->p_lflag & P_LVFORK)))
+       }
+       if (proc != NULL && (proc->p_fd == NULL || (proc->p_lflag & P_LVFORK))) {

                proc = NULL;
                proc = NULL;

+       }

 
 

-       return(proc == NULL ? current_proc() : proc);
+       return proc == NULL ? current_proc() : proc;

 }
 
 /*
  * vfs_context_get_special_port
  *
  * Description: Return the requested special port from the task associated
 }
 
 /*
  * vfs_context_get_special_port
  *
  * Description: Return the requested special port from the task associated

- *             with the given context.
+ *              with the given context.

  *
  * Parameters: vfs_context_t                   The context to use
  *
  * Parameters: vfs_context_t                   The context to use

- *             int                             Index of special port
- *             ipc_port_t *                    Pointer to returned port
+ *              int                            Index of special port
+ *              ipc_port_t *                   Pointer to returned port

  *
  * Returns:    kern_return_t                   see task_get_special_port()
  */
 kern_return_t
 vfs_context_get_special_port(vfs_context_t ctx, int which, ipc_port_t *portp)
 {
  *
  * Returns:    kern_return_t                   see task_get_special_port()
  */
 kern_return_t
 vfs_context_get_special_port(vfs_context_t ctx, int which, ipc_port_t *portp)
 {

-       task_t                  task = NULL;
+       task_t                  task = NULL;

 
 

-       if (ctx != NULL && ctx->vc_thread != NULL)
+       if (ctx != NULL && ctx->vc_thread != NULL) {

                task = get_threadtask(ctx->vc_thread);
                task = get_threadtask(ctx->vc_thread);

+       }

 
        return task_get_special_port(task, which, portp);
 }
 
        return task_get_special_port(task, which, portp);
 }


@@ -1103,21 +1247,22 @@ vfs_context_get_special_port(vfs_context_t ctx, int which, ipc_port_t *portp)
  * vfs_context_set_special_port
  *
  * Description: Set the requested special port in the task associated
  * vfs_context_set_special_port
  *
  * Description: Set the requested special port in the task associated

- *             with the given context.
+ *              with the given context.

  *
  * Parameters: vfs_context_t                   The context to use
  *
  * Parameters: vfs_context_t                   The context to use

- *             int                             Index of special port
- *             ipc_port_t                      New special port
+ *              int                            Index of special port
+ *              ipc_port_t                     New special port

  *
  * Returns:    kern_return_t                   see task_set_special_port()
  */
 kern_return_t
 vfs_context_set_special_port(vfs_context_t ctx, int which, ipc_port_t port)
 {
  *
  * Returns:    kern_return_t                   see task_set_special_port()
  */
 kern_return_t
 vfs_context_set_special_port(vfs_context_t ctx, int which, ipc_port_t port)
 {

-       task_t                  task = NULL;
+       task_t                  task = NULL;

 
 

-       if (ctx != NULL && ctx->vc_thread != NULL)
+       if (ctx != NULL && ctx->vc_thread != NULL) {

                task = get_threadtask(ctx->vc_thread);
                task = get_threadtask(ctx->vc_thread);

+       }

 
        return task_set_special_port(task, which, port);
 }
 
        return task_set_special_port(task, which, port);
 }


@@ -1142,7 +1287,7 @@ vfs_context_set_special_port(vfs_context_t ctx, int which, ipc_port_t port)
 thread_t
 vfs_context_thread(vfs_context_t ctx)
 {
 thread_t
 vfs_context_thread(vfs_context_t ctx)
 {

-       return(ctx->vc_thread);
+       return ctx->vc_thread;

 }
 
 
 }
 
 


@@ -1167,7 +1312,7 @@ vfs_context_cwd(vfs_context_t ctx)
 {
        vnode_t cwd = NULLVP;
 
 {
        vnode_t cwd = NULLVP;
 

-       if(ctx != NULL && ctx->vc_thread != NULL) {
+       if (ctx != NULL && ctx->vc_thread != NULL) {

                uthread_t uth = get_bsdthread_info(ctx->vc_thread);
                proc_t proc;
 
                uthread_t uth = get_bsdthread_info(ctx->vc_thread);
                proc_t proc;
 


@@ -1177,25 +1322,26 @@ vfs_context_cwd(vfs_context_t ctx)
                 */
                if ((cwd = uth->uu_cdir) == NULLVP &&
                    (proc = (proc_t)get_bsdthreadtask_info(ctx->vc_thread)) != NULL &&
                 */
                if ((cwd = uth->uu_cdir) == NULLVP &&
                    (proc = (proc_t)get_bsdthreadtask_info(ctx->vc_thread)) != NULL &&

-                   proc->p_fd != NULL)
+                   proc->p_fd != NULL) {

                        cwd = proc->p_fd->fd_cdir;
                        cwd = proc->p_fd->fd_cdir;

+               }

        }
 
        }
 

-       return(cwd);
+       return cwd;

 }
 
 /*
  * vfs_context_create
  *
 }
 
 /*
  * vfs_context_create
  *

- * Description: Allocate and initialize a new context. 
+ * Description: Allocate and initialize a new context.

  *
  *

- * Parameters:  vfs_context_t:                         Context to copy, or NULL for new
+ * Parameters:  vfs_context_t:                  Context to copy, or NULL for new

  *
  * Returns:     Pointer to new context
  *
  *
  * Returns:     Pointer to new context
  *

- * Notes:       Copy cred and thread from argument, if available; else 
- *             initialize with current thread and new cred.  Returns 
- *             with a reference held on the credential.
+ * Notes:       Copy cred and thread from argument, if available; else
+ *              initialize with current thread and new cred.  Returns
+ *              with a reference held on the credential.

  */
 vfs_context_t
 vfs_context_create(vfs_context_t ctx)
  */
 vfs_context_t
 vfs_context_create(vfs_context_t ctx)


@@ -1213,12 +1359,13 @@ vfs_context_create(vfs_context_t ctx)
                        newcontext->vc_thread = current_thread();
                        safecred = kauth_cred_get();
                }
                        newcontext->vc_thread = current_thread();
                        safecred = kauth_cred_get();
                }

-               if (IS_VALID_CRED(safecred))
+               if (IS_VALID_CRED(safecred)) {

                        kauth_cred_ref(safecred);
                        kauth_cred_ref(safecred);

+               }

                newcontext->vc_ucred = safecred;
                newcontext->vc_ucred = safecred;

-               return(newcontext);
+               return newcontext;

        }
        }

-       return(NULL);   
+       return NULL;

 }
 
 
 }
 
 


@@ -1228,13 +1375,13 @@ vfs_context_current(void)
        vfs_context_t ctx = NULL;
        volatile uthread_t ut = (uthread_t)get_bsdthread_info(current_thread());
 
        vfs_context_t ctx = NULL;
        volatile uthread_t ut = (uthread_t)get_bsdthread_info(current_thread());
 

-       if (ut != NULL ) {
+       if (ut != NULL) {

                if (ut->uu_context.vc_ucred != NULL) {
                        ctx = &ut->uu_context;
                }
        }
 
                if (ut->uu_context.vc_ucred != NULL) {
                        ctx = &ut->uu_context;
                }
        }
 

-       return(ctx == NULL ? vfs_context_kernel() : ctx);
+       return ctx == NULL ? vfs_context_kernel() : ctx;

 }
 
 
 }
 
 


@@ -1259,12 +1406,14 @@ static struct vfs_context kerncontext;
 vfs_context_t
 vfs_context_kernel(void)
 {
 vfs_context_t
 vfs_context_kernel(void)
 {

-       if (kerncontext.vc_ucred == NOCRED)
+       if (kerncontext.vc_ucred == NOCRED) {

                kerncontext.vc_ucred = kernproc->p_ucred;
                kerncontext.vc_ucred = kernproc->p_ucred;

-       if (kerncontext.vc_thread == NULL)
+       }
+       if (kerncontext.vc_thread == NULL) {

                kerncontext.vc_thread = proc_thread(kernproc);
                kerncontext.vc_thread = proc_thread(kernproc);

+       }

 
 

-       return(&kerncontext);
+       return &kerncontext;

 }
 
 
 }
 
 


@@ -1272,18 +1421,19 @@ int
 vfs_context_rele(vfs_context_t ctx)
 {
        if (ctx) {
 vfs_context_rele(vfs_context_t ctx)
 {
        if (ctx) {

-               if (IS_VALID_CRED(ctx->vc_ucred))
+               if (IS_VALID_CRED(ctx->vc_ucred)) {

                        kauth_cred_unref(&ctx->vc_ucred);
                        kauth_cred_unref(&ctx->vc_ucred);

+               }

                kfree(ctx, sizeof(struct vfs_context));
        }
                kfree(ctx, sizeof(struct vfs_context));
        }

-       return(0);
+       return 0;

 }
 
 
 kauth_cred_t
 vfs_context_ucred(vfs_context_t ctx)
 {
 }
 
 
 kauth_cred_t
 vfs_context_ucred(vfs_context_t ctx)
 {

-       return (ctx->vc_ucred);
+       return ctx->vc_ucred;

 }
 
 /*
 }
 
 /*


@@ -1292,21 +1442,27 @@ vfs_context_ucred(vfs_context_t ctx)
 int
 vfs_context_issuser(vfs_context_t ctx)
 {
 int
 vfs_context_issuser(vfs_context_t ctx)
 {

-       return(kauth_cred_issuser(vfs_context_ucred(ctx)));
+       return kauth_cred_issuser(vfs_context_ucred(ctx));
+}
+
+int
+vfs_context_iskernel(vfs_context_t ctx)
+{
+       return ctx == &kerncontext;

 }
 
 /*
  * Given a context, for all fields of vfs_context_t which
  * are not held with a reference, set those fields to the
 }
 
 /*
  * Given a context, for all fields of vfs_context_t which
  * are not held with a reference, set those fields to the

- * values for the current execution context.  Currently, this 
+ * values for the current execution context.  Currently, this

  * just means the vc_thread.
  *
  * Returns: 0 for success, nonzero for failure
  *
  * The intended use is:
  * 1. vfs_context_create()     gets the caller a context
  * just means the vc_thread.
  *
  * Returns: 0 for success, nonzero for failure
  *
  * The intended use is:
  * 1. vfs_context_create()     gets the caller a context

- * 2. vfs_context_bind()       sets the unrefcounted data
- * 3. vfs_context_rele()       releases the context
+ * 2. vfs_context_bind()        sets the unrefcounted data
+ * 3. vfs_context_rele()        releases the context

  *
  */
 int
  *
  */
 int


@@ -1316,26 +1472,32 @@ vfs_context_bind(vfs_context_t ctx)
        return 0;
 }
 
        return 0;
 }
 

+int
+vfs_isswapmount(mount_t mnt)
+{
+       return mnt && ISSET(mnt->mnt_kern_flag, MNTK_SWAP_MOUNT) ? 1 : 0;
+}
+

 /* XXXXXXXXXXXXXX VNODE KAPIS XXXXXXXXXXXXXXXXXXXXXXXXX */
 
 /* XXXXXXXXXXXXXX VNODE KAPIS XXXXXXXXXXXXXXXXXXXXXXXXX */
 

- 
+

 /*
  * Convert between vnode types and inode formats (since POSIX.1
  * defines mode word of stat structure in terms of inode formats).
  */
 /*
  * Convert between vnode types and inode formats (since POSIX.1
  * defines mode word of stat structure in terms of inode formats).
  */

-enum vtype 
+enum vtype

 vnode_iftovt(int mode)
 {
 vnode_iftovt(int mode)
 {

-       return(iftovt_tab[((mode) & S_IFMT) >> 12]);
+       return iftovt_tab[((mode) & S_IFMT) >> 12];

 }
 
 }
 

-int 
+int

 vnode_vttoif(enum vtype indx)
 {
 vnode_vttoif(enum vtype indx)
 {

-       return(vttoif_tab[(int)(indx)]);
+       return vttoif_tab[(int)(indx)];

 }
 
 }
 

-int 
+int

 vnode_makeimode(int indx, int mode)
 {
        return (int)(VTTOIF(indx) | (mode));
 vnode_makeimode(int indx, int mode)
 {
        return (int)(VTTOIF(indx) | (mode));


@@ -1347,176 +1509,197 @@ vnode_makeimode(int indx, int mode)
  */
 
 /* returns system root vnode iocount; It should be released using vnode_put() */
  */
 
 /* returns system root vnode iocount; It should be released using vnode_put() */

-vnode_t  
+vnode_t

 vfs_rootvnode(void)
 {
        int error;
 
        error = vnode_get(rootvnode);
 vfs_rootvnode(void)
 {
        int error;
 
        error = vnode_get(rootvnode);

-       if (error)
-               return ((vnode_t)0);
-       else
+       if (error) {
+               return (vnode_t)0;
+       } else {

                return rootvnode;
                return rootvnode;

-}      
+       }
+}

 
 
 
 

-uint32_t 
+uint32_t

 vnode_vid(vnode_t vp)
 {
 vnode_vid(vnode_t vp)
 {

-       return ((uint32_t)(vp->v_id));
-}      
+       return (uint32_t)(vp->v_id);
+}

 
 

-mount_t 
+mount_t

 vnode_mount(vnode_t vp)
 {
 vnode_mount(vnode_t vp)
 {

-       return (vp->v_mount);
+       return vp->v_mount;

 }
 
 #if CONFIG_IOSCHED
 vnode_t
 vnode_mountdevvp(vnode_t vp)
 {
 }
 
 #if CONFIG_IOSCHED
 vnode_t
 vnode_mountdevvp(vnode_t vp)
 {

-       if (vp->v_mount)
-               return (vp->v_mount->mnt_devvp);
-       else
-               return ((vnode_t)0);
+       if (vp->v_mount) {
+               return vp->v_mount->mnt_devvp;
+       } else {
+               return (vnode_t)0;
+       }

 }
 #endif
 
 }
 #endif
 

-mount_t 
+boolean_t
+vnode_isonexternalstorage(vnode_t vp)
+{
+       if (vp) {
+               if (vp->v_mount) {
+                       if (vp->v_mount->mnt_ioflags & MNT_IOFLAGS_PERIPHERAL_DRIVE) {
+                               return TRUE;
+                       }
+               }
+       }
+       return FALSE;
+}
+
+mount_t

 vnode_mountedhere(vnode_t vp)
 {
        mount_t mp;
 
        if ((vp->v_type == VDIR) && ((mp = vp->v_mountedhere) != NULL) &&
 vnode_mountedhere(vnode_t vp)
 {
        mount_t mp;
 
        if ((vp->v_type == VDIR) && ((mp = vp->v_mountedhere) != NULL) &&

-           (mp->mnt_vnodecovered == vp))
-               return (mp);
-       else
+           (mp->mnt_vnodecovered == vp)) {
+               return mp;
+       } else {

                return (mount_t)NULL;
                return (mount_t)NULL;

+       }

 }
 
 /* returns vnode type of vnode_t */
 }
 
 /* returns vnode type of vnode_t */

-enum vtype 
+enum vtype

 vnode_vtype(vnode_t vp)
 {
 vnode_vtype(vnode_t vp)
 {

-       return (vp->v_type);
+       return vp->v_type;

 }
 
 /* returns FS specific node saved in vnode */
 }
 
 /* returns FS specific node saved in vnode */

-void * 
+void *

 vnode_fsnode(vnode_t vp)
 {
 vnode_fsnode(vnode_t vp)
 {

-       return (vp->v_data);
+       return vp->v_data;

 }
 
 }
 

-void 
+void

 vnode_clearfsnode(vnode_t vp)
 {
        vp->v_data = NULL;
 }
 
 vnode_clearfsnode(vnode_t vp)
 {
        vp->v_data = NULL;
 }
 

-dev_t 
+dev_t

 vnode_specrdev(vnode_t vp)
 {
 vnode_specrdev(vnode_t vp)
 {

-       return(vp->v_rdev);
+       return vp->v_rdev;

 }
 
 
 /* Accessor functions */
 /* is vnode_t a root vnode */
 }
 
 
 /* Accessor functions */
 /* is vnode_t a root vnode */

-int 
+int

 vnode_isvroot(vnode_t vp)
 {
 vnode_isvroot(vnode_t vp)
 {

-       return ((vp->v_flag & VROOT)? 1 : 0);
+       return (vp->v_flag & VROOT)? 1 : 0;

 }
 
 /* is vnode_t a system vnode */
 }
 
 /* is vnode_t a system vnode */

-int 
+int

 vnode_issystem(vnode_t vp)
 {
 vnode_issystem(vnode_t vp)
 {

-       return ((vp->v_flag & VSYSTEM)? 1 : 0);
+       return (vp->v_flag & VSYSTEM)? 1 : 0;

 }
 
 /* is vnode_t a swap file vnode */
 }
 
 /* is vnode_t a swap file vnode */

-int 
+int

 vnode_isswap(vnode_t vp)
 {
 vnode_isswap(vnode_t vp)
 {

-       return ((vp->v_flag & VSWAP)? 1 : 0);
+       return (vp->v_flag & VSWAP)? 1 : 0;

 }
 
 /* is vnode_t a tty */
 int
 vnode_istty(vnode_t vp)
 {
 }
 
 /* is vnode_t a tty */
 int
 vnode_istty(vnode_t vp)
 {

-       return ((vp->v_flag & VISTTY) ? 1 : 0);
+       return (vp->v_flag & VISTTY) ? 1 : 0;

 }
 
 /* if vnode_t mount operation in progress */
 }
 
 /* if vnode_t mount operation in progress */

-int 
+int

 vnode_ismount(vnode_t vp)
 {
 vnode_ismount(vnode_t vp)
 {

-       return ((vp->v_flag & VMOUNT)? 1 : 0);
+       return (vp->v_flag & VMOUNT)? 1 : 0;

 }
 
 /* is this vnode under recyle now */
 }
 
 /* is this vnode under recyle now */

-int 
+int

 vnode_isrecycled(vnode_t vp)
 {
        int ret;
 
        vnode_lock_spin(vp);
 vnode_isrecycled(vnode_t vp)
 {
        int ret;
 
        vnode_lock_spin(vp);

-       ret =  (vp->v_lflag & (VL_TERMINATE|VL_DEAD))? 1 : 0;
+       ret =  (vp->v_lflag & (VL_TERMINATE | VL_DEAD))? 1 : 0;

        vnode_unlock(vp);
        vnode_unlock(vp);

-       return(ret);
+       return ret;

 }
 
 /* vnode was created by background task requesting rapid aging
 }
 
 /* vnode was created by background task requesting rapid aging

-   and has not since been referenced by a normal task */
+ *  and has not since been referenced by a normal task */

 int
 vnode_israge(vnode_t vp)
 {
 int
 vnode_israge(vnode_t vp)
 {

-        return ((vp->v_flag & VRAGE)? 1 : 0);
+       return (vp->v_flag & VRAGE)? 1 : 0;

 }
 
 int
 vnode_needssnapshots(vnode_t vp)
 {
 }
 
 int
 vnode_needssnapshots(vnode_t vp)
 {

-       return ((vp->v_flag & VNEEDSSNAPSHOT)? 1 : 0);
+       return (vp->v_flag & VNEEDSSNAPSHOT)? 1 : 0;

 }
 
 
 /* Check the process/thread to see if we should skip atime updates */
 int
 }
 
 
 /* Check the process/thread to see if we should skip atime updates */
 int

-vfs_ctx_skipatime (vfs_context_t ctx) {
+vfs_ctx_skipatime(vfs_context_t ctx)
+{

        struct uthread *ut;
        proc_t proc;
        thread_t thr;
 
        proc = vfs_context_proc(ctx);
        struct uthread *ut;
        proc_t proc;
        thread_t thr;
 
        proc = vfs_context_proc(ctx);

-       thr = vfs_context_thread (ctx);
+       thr = vfs_context_thread(ctx);

 
        /* Validate pointers in case we were invoked via a kernel context */
        if (thr && proc) {
 
        /* Validate pointers in case we were invoked via a kernel context */
        if (thr && proc) {

-               ut = get_bsdthread_info (thr);
+               ut = get_bsdthread_info(thr);

 
                if (proc->p_lflag & P_LRAGE_VNODES) {
                        return 1;
                }
 
                if (proc->p_lflag & P_LRAGE_VNODES) {
                        return 1;
                }

-               
+

                if (ut) {
                if (ut) {

-                       if  (ut->uu_flag & UT_RAGE_VNODES) {
+                       if (ut->uu_flag & (UT_RAGE_VNODES | UT_ATIME_UPDATE)) {

                                return 1;
                        }
                }
                                return 1;
                        }
                }

+
+               if (proc->p_vfs_iopolicy & P_VFS_IOPOLICY_ATIME_UPDATES) {
+                       return 1;
+               }

        }
        return 0;
 }
 
 /* is vnode_t marked to not keep data cached once it's been consumed */
        }
        return 0;
 }
 
 /* is vnode_t marked to not keep data cached once it's been consumed */

-int 
+int

 vnode_isnocache(vnode_t vp)
 {
 vnode_isnocache(vnode_t vp)
 {

-       return ((vp->v_flag & VNOCACHE_DATA)? 1 : 0);
+       return (vp->v_flag & VNOCACHE_DATA)? 1 : 0;

 }
 
 /*
 }
 
 /*


@@ -1525,48 +1708,48 @@ vnode_isnocache(vnode_t vp)
 int
 vnode_isnoreadahead(vnode_t vp)
 {
 int
 vnode_isnoreadahead(vnode_t vp)
 {

-       return ((vp->v_flag & VRAOFF)? 1 : 0);
+       return (vp->v_flag & VRAOFF)? 1 : 0;

 }
 
 int
 vnode_is_openevt(vnode_t vp)
 {
 }
 
 int
 vnode_is_openevt(vnode_t vp)
 {

-       return ((vp->v_flag & VOPENEVT)? 1 : 0);
+       return (vp->v_flag & VOPENEVT)? 1 : 0;

 }
 
 /* is vnode_t a standard one? */
 }
 
 /* is vnode_t a standard one? */

-int 
+int

 vnode_isstandard(vnode_t vp)
 {
 vnode_isstandard(vnode_t vp)
 {

-       return ((vp->v_flag & VSTANDARD)? 1 : 0);
+       return (vp->v_flag & VSTANDARD)? 1 : 0;

 }
 
 /* don't vflush() if SKIPSYSTEM */
 }
 
 /* don't vflush() if SKIPSYSTEM */

-int 
+int

 vnode_isnoflush(vnode_t vp)
 {
 vnode_isnoflush(vnode_t vp)
 {

-       return ((vp->v_flag & VNOFLUSH)? 1 : 0);
+       return (vp->v_flag & VNOFLUSH)? 1 : 0;

 }
 
 /* is vnode_t a regular file */
 }
 
 /* is vnode_t a regular file */

-int 
+int

 vnode_isreg(vnode_t vp)
 {
 vnode_isreg(vnode_t vp)
 {

-       return ((vp->v_type == VREG)? 1 : 0);
+       return (vp->v_type == VREG)? 1 : 0;

 }
 
 /* is vnode_t a directory? */
 }
 
 /* is vnode_t a directory? */

-int 
+int

 vnode_isdir(vnode_t vp)
 {
 vnode_isdir(vnode_t vp)
 {

-       return ((vp->v_type == VDIR)? 1 : 0);
+       return (vp->v_type == VDIR)? 1 : 0;

 }
 
 /* is vnode_t a symbolic link ? */
 }
 
 /* is vnode_t a symbolic link ? */

-int 
+int

 vnode_islnk(vnode_t vp)
 {
 vnode_islnk(vnode_t vp)
 {

-       return ((vp->v_type == VLNK)? 1 : 0);
+       return (vp->v_type == VLNK)? 1 : 0;

 }
 
 int
 }
 
 int


@@ -1588,13 +1771,12 @@ vnode_lookup_continue_needed(vnode_t vp, struct componentname *cnp)
                        goto yes;
                }
 #endif /* CONFIG_TRIGGERS */
                        goto yes;
                }
 #endif /* CONFIG_TRIGGERS */

-

        }
 
 
        if (vnode_islnk(vp)) {
                /* From lookup():  || *ndp->ni_next == '/') No need for this, we know we're NULL-terminated here */
        }
 
 
        if (vnode_islnk(vp)) {
                /* From lookup():  || *ndp->ni_next == '/') No need for this, we know we're NULL-terminated here */

-               if (cnp->cn_flags & FOLLOW) { 
+               if (cnp->cn_flags & FOLLOW) {

                        goto yes;
                }
                if (ndp->ni_flag & NAMEI_TRAILINGSLASH) {
                        goto yes;
                }
                if (ndp->ni_flag & NAMEI_TRAILINGSLASH) {


@@ -1610,102 +1792,102 @@ yes:
 }
 
 /* is vnode_t a fifo ? */
 }
 
 /* is vnode_t a fifo ? */

-int 
+int

 vnode_isfifo(vnode_t vp)
 {
 vnode_isfifo(vnode_t vp)
 {

-       return ((vp->v_type == VFIFO)? 1 : 0);
+       return (vp->v_type == VFIFO)? 1 : 0;

 }
 
 /* is vnode_t a block device? */
 }
 
 /* is vnode_t a block device? */

-int 
+int

 vnode_isblk(vnode_t vp)
 {
 vnode_isblk(vnode_t vp)
 {

-       return ((vp->v_type == VBLK)? 1 : 0);
+       return (vp->v_type == VBLK)? 1 : 0;

 }
 
 int
 vnode_isspec(vnode_t vp)
 {
 }
 
 int
 vnode_isspec(vnode_t vp)
 {

-       return (((vp->v_type == VCHR) || (vp->v_type == VBLK)) ? 1 : 0);
+       return ((vp->v_type == VCHR) || (vp->v_type == VBLK)) ? 1 : 0;

 }
 
 /* is vnode_t a char device? */
 }
 
 /* is vnode_t a char device? */

-int 
+int

 vnode_ischr(vnode_t vp)
 {
 vnode_ischr(vnode_t vp)
 {

-       return ((vp->v_type == VCHR)? 1 : 0);
+       return (vp->v_type == VCHR)? 1 : 0;

 }
 
 /* is vnode_t a socket? */
 }
 
 /* is vnode_t a socket? */

-int 
+int

 vnode_issock(vnode_t vp)
 {
 vnode_issock(vnode_t vp)
 {

-       return ((vp->v_type == VSOCK)? 1 : 0);
+       return (vp->v_type == VSOCK)? 1 : 0;

 }
 
 /* is vnode_t a device with multiple active vnodes referring to it? */
 int
 vnode_isaliased(vnode_t vp)
 }
 
 /* is vnode_t a device with multiple active vnodes referring to it? */
 int
 vnode_isaliased(vnode_t vp)

-{      
+{

        enum vtype vt = vp->v_type;
        if (!((vt == VCHR) || (vt == VBLK))) {
                return 0;
        } else {
        enum vtype vt = vp->v_type;
        if (!((vt == VCHR) || (vt == VBLK))) {
                return 0;
        } else {

-               return (vp->v_specflags & SI_ALIASED);
+               return vp->v_specflags & SI_ALIASED;

        }
 }
 
 /* is vnode_t a named stream? */
        }
 }
 
 /* is vnode_t a named stream? */

-int 
+int

 vnode_isnamedstream(
 #if NAMEDSTREAMS
 vnode_isnamedstream(
 #if NAMEDSTREAMS

-               vnode_t vp
+       vnode_t vp

 #else
 #else

-               __unused vnode_t vp
+       __unused vnode_t vp

 #endif
 #endif

-               )
+       )

 {
 #if NAMEDSTREAMS
 {
 #if NAMEDSTREAMS

-       return ((vp->v_flag & VISNAMEDSTREAM) ? 1 : 0);
+       return (vp->v_flag & VISNAMEDSTREAM) ? 1 : 0;

 #else
 #else

-       return (0);
+       return 0;

 #endif
 }
 
 #endif
 }
 

-int    
+int

 vnode_isshadow(
 #if NAMEDSTREAMS
 vnode_isshadow(
 #if NAMEDSTREAMS

-               vnode_t vp
+       vnode_t vp

 #else
 #else

-               __unused vnode_t vp
+       __unused vnode_t vp

 #endif
 #endif

-               )
+       )

 {
 #if NAMEDSTREAMS
 {
 #if NAMEDSTREAMS

-       return ((vp->v_flag & VISSHADOW) ? 1 : 0);
+       return (vp->v_flag & VISSHADOW) ? 1 : 0;

 #else
 #else

-       return (0);
+       return 0;

 #endif
 }
 
 /* does vnode have associated named stream vnodes ? */
 #endif
 }
 
 /* does vnode have associated named stream vnodes ? */

-int 
+int

 vnode_hasnamedstreams(
 #if NAMEDSTREAMS
 vnode_hasnamedstreams(
 #if NAMEDSTREAMS

-               vnode_t vp
+       vnode_t vp

 #else
 #else

-               __unused vnode_t vp
+       __unused vnode_t vp

 #endif
 #endif

-               )
+       )

 {
 #if NAMEDSTREAMS
 {
 #if NAMEDSTREAMS

-       return ((vp->v_lflag & VL_HASSTREAMS) ? 1 : 0);
+       return (vp->v_lflag & VL_HASSTREAMS) ? 1 : 0;

 #else
 #else

-       return (0);
+       return 0;

 #endif
 }
 /* TBD:  set vnode_t to not cache data after it is consumed once; used for quota */
 #endif
 }
 /* TBD:  set vnode_t to not cache data after it is consumed once; used for quota */

-void 
+void

 vnode_setnocache(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_setnocache(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1713,7 +1895,7 @@ vnode_setnocache(vnode_t vp)
        vnode_unlock(vp);
 }
 
        vnode_unlock(vp);
 }
 

-void 
+void

 vnode_clearnocache(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_clearnocache(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1738,7 +1920,7 @@ vnode_clear_openevt(vnode_t vp)
 }
 
 
 }
 
 

-void 
+void

 vnode_setnoreadahead(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_setnoreadahead(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1746,7 +1928,7 @@ vnode_setnoreadahead(vnode_t vp)
        vnode_unlock(vp);
 }
 
        vnode_unlock(vp);
 }
 

-void 
+void

 vnode_clearnoreadahead(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_clearnoreadahead(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1757,7 +1939,7 @@ vnode_clearnoreadahead(vnode_t vp)
 int
 vnode_isfastdevicecandidate(vnode_t vp)
 {
 int
 vnode_isfastdevicecandidate(vnode_t vp)
 {

-       return ((vp->v_flag & VFASTDEVCANDIDATE)? 1 : 0);
+       return (vp->v_flag & VFASTDEVCANDIDATE)? 1 : 0;

 }
 
 void
 }
 
 void


@@ -1779,7 +1961,7 @@ vnode_clearfastdevicecandidate(vnode_t vp)
 int
 vnode_isautocandidate(vnode_t vp)
 {
 int
 vnode_isautocandidate(vnode_t vp)
 {

-       return ((vp->v_flag & VAUTOCANDIDATE)? 1 : 0);
+       return (vp->v_flag & VAUTOCANDIDATE)? 1 : 0;

 }
 
 void
 }
 
 void


@@ -1802,7 +1984,7 @@ vnode_clearautocandidate(vnode_t vp)
 
 
 /* mark vnode_t to skip vflush() is SKIPSYSTEM */
 
 
 /* mark vnode_t to skip vflush() is SKIPSYSTEM */

-void 
+void

 vnode_setnoflush(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_setnoflush(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1810,7 +1992,7 @@ vnode_setnoflush(vnode_t vp)
        vnode_unlock(vp);
 }
 
        vnode_unlock(vp);
 }
 

-void 
+void

 vnode_clearnoflush(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_clearnoflush(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1820,13 +2002,13 @@ vnode_clearnoflush(vnode_t vp)
 
 
 /* is vnode_t a blkdevice and has a FS mounted on it */
 
 
 /* is vnode_t a blkdevice and has a FS mounted on it */

-int 
+int

 vnode_ismountedon(vnode_t vp)
 {
 vnode_ismountedon(vnode_t vp)
 {

-       return ((vp->v_specflags & SI_MOUNTEDON)? 1 : 0);
+       return (vp->v_specflags & SI_MOUNTEDON)? 1 : 0;

 }
 
 }
 

-void 
+void

 vnode_setmountedon(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_setmountedon(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1834,7 +2016,7 @@ vnode_setmountedon(vnode_t vp)
        vnode_unlock(vp);
 }
 
        vnode_unlock(vp);
 }
 

-void 
+void

 vnode_clearmountedon(vnode_t vp)
 {
        vnode_lock_spin(vp);
 vnode_clearmountedon(vnode_t vp)
 {
        vnode_lock_spin(vp);


@@ -1847,20 +2029,18 @@ void
 vnode_settag(vnode_t vp, int tag)
 {
        vp->v_tag = tag;
 vnode_settag(vnode_t vp, int tag)
 {
        vp->v_tag = tag;

-

 }
 
 int
 vnode_tag(vnode_t vp)
 {
 }
 
 int
 vnode_tag(vnode_t vp)
 {

-       return(vp->v_tag);
+       return vp->v_tag;

 }
 
 }
 

-vnode_t 
+vnode_t

 vnode_parent(vnode_t vp)
 {
 vnode_parent(vnode_t vp)
 {

-
-       return(vp->v_parent);
+       return vp->v_parent;

 }
 
 void
 }
 
 void


@@ -1876,106 +2056,106 @@ vnode_setname(vnode_t vp, char * name)
 }
 
 /* return the registered  FS name when adding the FS to kernel */
 }
 
 /* return the registered  FS name when adding the FS to kernel */

-void 
+void

 vnode_vfsname(vnode_t vp, char * buf)
 {
 vnode_vfsname(vnode_t vp, char * buf)
 {

-        strlcpy(buf, vp->v_mount->mnt_vtable->vfc_name, MFSNAMELEN);
+       strlcpy(buf, vp->v_mount->mnt_vtable->vfc_name, MFSNAMELEN);

 }
 
 /* return the FS type number */
 }
 
 /* return the FS type number */

-int 
+int

 vnode_vfstypenum(vnode_t vp)
 {
 vnode_vfstypenum(vnode_t vp)
 {

-       return(vp->v_mount->mnt_vtable->vfc_typenum);
+       return vp->v_mount->mnt_vtable->vfc_typenum;

 }
 
 int
 }
 
 int

-vnode_vfs64bitready(vnode_t vp) 
+vnode_vfs64bitready(vnode_t vp)

 {
 {

-
-       /* 
+       /*

         * Checking for dead_mountp is a bit of a hack for SnowLeopard: <rdar://problem/6269051>
         */
         * Checking for dead_mountp is a bit of a hack for SnowLeopard: <rdar://problem/6269051>
         */

-       if ((vp->v_mount != dead_mountp) && (vp->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFS64BITREADY))
-               return(1);
-       else
-               return(0);
+       if ((vp->v_mount != dead_mountp) && (vp->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFS64BITREADY)) {
+               return 1;
+       } else {
+               return 0;
+       }

 }
 
 
 
 /* return the visible flags on associated mount point of vnode_t */
 }
 
 
 
 /* return the visible flags on associated mount point of vnode_t */

-uint32_t 
+uint32_t

 vnode_vfsvisflags(vnode_t vp)
 {
 vnode_vfsvisflags(vnode_t vp)
 {

-       return(vp->v_mount->mnt_flag & MNT_VISFLAGMASK);
+       return vp->v_mount->mnt_flag & MNT_VISFLAGMASK;

 }
 
 /* return the command modifier flags on associated mount point of vnode_t */
 }
 
 /* return the command modifier flags on associated mount point of vnode_t */

-uint32_t 
+uint32_t

 vnode_vfscmdflags(vnode_t vp)
 {
 vnode_vfscmdflags(vnode_t vp)
 {

-       return(vp->v_mount->mnt_flag & MNT_CMDFLAGS);
+       return vp->v_mount->mnt_flag & MNT_CMDFLAGS;

 }
 
 /* return the max symlink of short links  of vnode_t */
 }
 
 /* return the max symlink of short links  of vnode_t */

-uint32_t 
+uint32_t

 vnode_vfsmaxsymlen(vnode_t vp)
 {
 vnode_vfsmaxsymlen(vnode_t vp)
 {

-       return(vp->v_mount->mnt_maxsymlinklen);
+       return vp->v_mount->mnt_maxsymlinklen;

 }
 
 /* return a pointer to the RO vfs_statfs associated with vnode_t's mount point */
 struct vfsstatfs *
 vnode_vfsstatfs(vnode_t vp)
 {
 }
 
 /* return a pointer to the RO vfs_statfs associated with vnode_t's mount point */
 struct vfsstatfs *
 vnode_vfsstatfs(vnode_t vp)
 {

-        return(&vp->v_mount->mnt_vfsstat);
+       return &vp->v_mount->mnt_vfsstat;

 }
 
 /* return a handle to the FSs specific private handle associated with vnode_t's mount point */
 void *
 vnode_vfsfsprivate(vnode_t vp)
 {
 }
 
 /* return a handle to the FSs specific private handle associated with vnode_t's mount point */
 void *
 vnode_vfsfsprivate(vnode_t vp)
 {

-       return(vp->v_mount->mnt_data);
+       return vp->v_mount->mnt_data;

 }
 
 /* is vnode_t in a rdonly mounted  FS */
 }
 
 /* is vnode_t in a rdonly mounted  FS */

-int 
+int

 vnode_vfsisrdonly(vnode_t vp)
 {
 vnode_vfsisrdonly(vnode_t vp)
 {

-       return ((vp->v_mount->mnt_flag & MNT_RDONLY)? 1 : 0);
+       return (vp->v_mount->mnt_flag & MNT_RDONLY)? 1 : 0;

 }
 
 int
 }
 
 int

-vnode_compound_rename_available(vnode_t vp) 
+vnode_compound_rename_available(vnode_t vp)

 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_RENAME);
 }
 int
 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_RENAME);
 }
 int

-vnode_compound_rmdir_available(vnode_t vp) 
+vnode_compound_rmdir_available(vnode_t vp)

 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_RMDIR);
 }
 int
 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_RMDIR);
 }
 int

-vnode_compound_mkdir_available(vnode_t vp) 
+vnode_compound_mkdir_available(vnode_t vp)

 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_MKDIR);
 }
 int
 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_MKDIR);
 }
 int

-vnode_compound_remove_available(vnode_t vp) 
+vnode_compound_remove_available(vnode_t vp)

 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_REMOVE);
 }
 int
 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_REMOVE);
 }
 int

-vnode_compound_open_available(vnode_t vp) 
+vnode_compound_open_available(vnode_t vp)

 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_OPEN);
 }
 
 int
 {
        return vnode_compound_op_available(vp, COMPOUND_VNOP_OPEN);
 }
 
 int

-vnode_compound_op_available(vnode_t vp, compound_vnop_id_t opid) 
+vnode_compound_op_available(vnode_t vp, compound_vnop_id_t opid)

 {
 {

-       return ((vp->v_mount->mnt_compound_ops & opid) != 0);
+       return (vp->v_mount->mnt_compound_ops & opid) != 0;

 }
 
 /*
 }
 
 /*


@@ -1984,22 +2164,23 @@ vnode_compound_op_available(vnode_t vp, compound_vnop_id_t opid)
  *
  * XXX Published, but not used.
  */
  *
  * XXX Published, but not used.
  */

-vnode_t 
+vnode_t

 current_workingdir(void)
 {
        return vfs_context_cwd(vfs_context_current());
 }
 
 /* returns vnode ref to current root(chroot) directory */
 current_workingdir(void)
 {
        return vfs_context_cwd(vfs_context_current());
 }
 
 /* returns vnode ref to current root(chroot) directory */

-vnode_t 
+vnode_t

 current_rootdir(void)
 {
        proc_t proc = current_proc();
 current_rootdir(void)
 {
        proc_t proc = current_proc();

-       struct vnode * vp ;
+       struct vnode * vp;

 
 

-       if ( (vp = proc->p_fd->fd_rdir) ) {
-               if ( (vnode_getwithref(vp)) )
-                       return (NULL);
+       if ((vp = proc->p_fd->fd_rdir)) {
+               if ((vnode_getwithref(vp))) {
+                       return NULL;
+               }

        }
        return vp;
 }
        }
        return vp;
 }


@@ -2041,22 +2222,23 @@ static int
 vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
 {
        kauth_filesec_t fsec;
 vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
 {
        kauth_filesec_t fsec;

-       uio_t   fsec_uio;
-       size_t  fsec_size;
-       size_t  xsize, rsize;
-       int     error;
-       uint32_t        host_fsec_magic;
-       uint32_t        host_acl_entrycount;
+       uio_t   fsec_uio;
+       size_t  fsec_size;
+       size_t  xsize, rsize;
+       int     error;
+       uint32_t        host_fsec_magic;
+       uint32_t        host_acl_entrycount;

 
        fsec = NULL;
        fsec_uio = NULL;
 
        fsec = NULL;
        fsec_uio = NULL;

-       error = 0;
-       
+

        /* find out how big the EA is */
        /* find out how big the EA is */

-       if (vn_getxattr(vp, KAUTH_FILESEC_XATTR, NULL, &xsize, XATTR_NOSECURITY, ctx) != 0) {
+       error = vn_getxattr(vp, KAUTH_FILESEC_XATTR, NULL, &xsize, XATTR_NOSECURITY, ctx);
+       if (error != 0) {

                /* no EA, no filesec */
                /* no EA, no filesec */

-               if ((error == ENOATTR) || (error == ENOENT) || (error == EJUSTRETURN))
+               if ((error == ENOATTR) || (error == ENOENT) || (error == EJUSTRETURN)) {

                        error = 0;
                        error = 0;

+               }

                /* either way, we are done */
                goto out;
        }
                /* either way, we are done */
                goto out;
        }


@@ -2068,19 +2250,24 @@ vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
         * rather than partial entries.  Otherwise, we ignore it.
         */
        if (!KAUTH_FILESEC_VALID(xsize)) {
         * rather than partial entries.  Otherwise, we ignore it.
         */
        if (!KAUTH_FILESEC_VALID(xsize)) {

-               KAUTH_DEBUG("    ERROR - Bogus kauth_fiilesec_t: %ld bytes", xsize);    
+               KAUTH_DEBUG("    ERROR - Bogus kauth_fiilesec_t: %ld bytes", xsize);

                error = 0;
                goto out;
        }
                error = 0;
                goto out;
        }

-                               
+

        /* how many entries would fit? */
        fsec_size = KAUTH_FILESEC_COUNT(xsize);
        /* how many entries would fit? */
        fsec_size = KAUTH_FILESEC_COUNT(xsize);

+       if (fsec_size > KAUTH_ACL_MAX_ENTRIES) {
+               KAUTH_DEBUG("    ERROR - Bogus (too large) kauth_fiilesec_t: %ld bytes", xsize);
+               error = 0;
+               goto out;
+       }

 
        /* get buffer and uio */
        if (((fsec = kauth_filesec_alloc(fsec_size)) == NULL) ||
            ((fsec_uio = uio_create(1, 0, UIO_SYSSPACE, UIO_READ)) == NULL) ||
            uio_addiov(fsec_uio, CAST_USER_ADDR_T(fsec), xsize)) {
 
        /* get buffer and uio */
        if (((fsec = kauth_filesec_alloc(fsec_size)) == NULL) ||
            ((fsec_uio = uio_create(1, 0, UIO_SYSSPACE, UIO_READ)) == NULL) ||
            uio_addiov(fsec_uio, CAST_USER_ADDR_T(fsec), xsize)) {

-               KAUTH_DEBUG("    ERROR - could not allocate iov to read ACL");  
+               KAUTH_DEBUG("    ERROR - could not allocate iov to read ACL");

                error = ENOMEM;
                goto out;
        }
                error = ENOMEM;
                goto out;
        }


@@ -2088,15 +2275,15 @@ vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
        /* read security attribute */
        rsize = xsize;
        if ((error = vn_getxattr(vp,
        /* read security attribute */
        rsize = xsize;
        if ((error = vn_getxattr(vp,

-                KAUTH_FILESEC_XATTR,
-                fsec_uio,
-                &rsize,
-                XATTR_NOSECURITY,
-                ctx)) != 0) {
-
+           KAUTH_FILESEC_XATTR,
+           fsec_uio,
+           &rsize,
+           XATTR_NOSECURITY,
+           ctx)) != 0) {

                /* no attribute - no security data */
                /* no attribute - no security data */

-               if ((error == ENOATTR) || (error == ENOENT) || (error == EJUSTRETURN))
+               if ((error == ENOATTR) || (error == ENOENT) || (error == EJUSTRETURN)) {

                        error = 0;
                        error = 0;

+               }

                /* either way, we are done */
                goto out;
        }
                /* either way, we are done */
                goto out;
        }


@@ -2126,7 +2313,7 @@ vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
                        KAUTH_DEBUG("ACL - BAD ENTRYCOUNT %x", host_acl_entrycount);
                        goto out;
                }
                        KAUTH_DEBUG("ACL - BAD ENTRYCOUNT %x", host_acl_entrycount);
                        goto out;
                }

-               if (KAUTH_FILESEC_SIZE(host_acl_entrycount) > rsize) {
+               if (KAUTH_FILESEC_SIZE(host_acl_entrycount) > rsize) {

                        KAUTH_DEBUG("ACL - BUFFER OVERFLOW (%d entries too big for %d)", host_acl_entrycount, rsize);
                        goto out;
                }
                        KAUTH_DEBUG("ACL - BUFFER OVERFLOW (%d entries too big for %d)", host_acl_entrycount, rsize);
                        goto out;
                }


@@ -2138,13 +2325,16 @@ vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
        fsec = NULL;
        error = 0;
 out:
        fsec = NULL;
        error = 0;
 out:

-       if (fsec != NULL)
+       if (fsec != NULL) {

                kauth_filesec_free(fsec);
                kauth_filesec_free(fsec);

-       if (fsec_uio != NULL)
+       }
+       if (fsec_uio != NULL) {

                uio_free(fsec_uio);
                uio_free(fsec_uio);

-       if (error)
+       }
+       if (error) {

                *fsecp = NULL;
                *fsecp = NULL;

-       return(error);
+       }
+       return error;

 }
 
 /*
 }
 
 /*


@@ -2181,14 +2371,14 @@ out:
 static int
 vnode_set_filesec(vnode_t vp, kauth_filesec_t fsec, kauth_acl_t acl, vfs_context_t ctx)
 {
 static int
 vnode_set_filesec(vnode_t vp, kauth_filesec_t fsec, kauth_acl_t acl, vfs_context_t ctx)
 {

-       uio_t           fsec_uio;
-       int             error;
-       uint32_t        saved_acl_copysize;
+       uio_t           fsec_uio;
+       int             error;
+       uint32_t        saved_acl_copysize;

 
        fsec_uio = NULL;
 
        fsec_uio = NULL;

-       
+

        if ((fsec_uio = uio_create(2, 0, UIO_SYSSPACE, UIO_WRITE)) == NULL) {
        if ((fsec_uio = uio_create(2, 0, UIO_SYSSPACE, UIO_WRITE)) == NULL) {

-               KAUTH_DEBUG("    ERROR - could not allocate iov to write ACL"); 
+               KAUTH_DEBUG("    ERROR - could not allocate iov to write ACL");

                error = ENOMEM;
                goto out;
        }
                error = ENOMEM;
                goto out;
        }


@@ -2205,22 +2395,24 @@ vnode_set_filesec(vnode_t vp, kauth_filesec_t fsec, kauth_acl_t acl, vfs_context
        error = vn_setxattr(vp,
            KAUTH_FILESEC_XATTR,
            fsec_uio,
        error = vn_setxattr(vp,
            KAUTH_FILESEC_XATTR,
            fsec_uio,

-           XATTR_NOSECURITY,           /* we have auth'ed already */
+           XATTR_NOSECURITY,           /* we have auth'ed already */

            ctx);
        VFS_DEBUG(ctx, vp, "SETATTR - set ACL returning %d", error);
 
        kauth_filesec_acl_setendian(KAUTH_ENDIAN_HOST, fsec, acl);
 
 out:
            ctx);
        VFS_DEBUG(ctx, vp, "SETATTR - set ACL returning %d", error);
 
        kauth_filesec_acl_setendian(KAUTH_ENDIAN_HOST, fsec, acl);
 
 out:

-       if (fsec_uio != NULL)
+       if (fsec_uio != NULL) {

                uio_free(fsec_uio);
                uio_free(fsec_uio);

-       return(error);
+       }
+       return error;

 }
 
 
 /*
  * Returns:    0                       Success
  *             ENOMEM                  Not enough space [only if has filesec]
 }
 
 
 /*
  * Returns:    0                       Success
  *             ENOMEM                  Not enough space [only if has filesec]

+ *             EINVAL                  Requested unknown attributes

  *             VNOP_GETATTR:           ???
  *             vnode_get_filesec:      ???
  *             kauth_cred_guid2uid:    ???
  *             VNOP_GETATTR:           ???
  *             vnode_get_filesec:      ???
  *             kauth_cred_guid2uid:    ???


@@ -2232,9 +2424,16 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
 {
        kauth_filesec_t fsec;
        kauth_acl_t facl;
 {
        kauth_filesec_t fsec;
        kauth_acl_t facl;

-       int     error;
-       uid_t   nuid;
-       gid_t   ngid;
+       int     error;
+       uid_t   nuid;
+       gid_t   ngid;
+
+       /*
+        * Reject attempts to fetch unknown attributes.
+        */
+       if (vap->va_active & ~VNODE_ATTR_ALL) {
+               return EINVAL;
+       }

 
        /* don't ask for extended security data if the filesystem doesn't support it */
        if (!vfs_extendedsecurity(vnode_mount(vp))) {
 
        /* don't ask for extended security data if the filesystem doesn't support it */
        if (!vfs_extendedsecurity(vnode_mount(vp))) {


@@ -2255,7 +2454,9 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                VATTR_SET_ACTIVE(vap, va_total_size);
                VATTR_SET_ACTIVE(vap, va_total_alloc);
        }
                VATTR_SET_ACTIVE(vap, va_total_size);
                VATTR_SET_ACTIVE(vap, va_total_alloc);
        }

-       
+
+       vap->va_vaflags &= ~VA_USEFSID;
+

        error = VNOP_GETATTR(vp, vap, ctx);
        if (error) {
                KAUTH_DEBUG("ERROR - returning %d", error);
        error = VNOP_GETATTR(vp, vap, ctx);
        if (error) {
                KAUTH_DEBUG("ERROR - returning %d", error);


@@ -2271,8 +2472,9 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
 
                if (XATTR_VNODE_SUPPORTED(vp)) {
                        /* try to get the filesec */
 
                if (XATTR_VNODE_SUPPORTED(vp)) {
                        /* try to get the filesec */

-                       if ((error = vnode_get_filesec(vp, &fsec, ctx)) != 0)
+                       if ((error = vnode_get_filesec(vp, &fsec, ctx)) != 0) {

                                goto out;
                                goto out;

+                       }

                }
                /* if no filesec, no attributes */
                if (fsec == NULL) {
                }
                /* if no filesec, no attributes */
                if (fsec == NULL) {


@@ -2280,7 +2482,6 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                        VATTR_RETURN(vap, va_uuuid, kauth_null_guid);
                        VATTR_RETURN(vap, va_guuid, kauth_null_guid);
                } else {
                        VATTR_RETURN(vap, va_uuuid, kauth_null_guid);
                        VATTR_RETURN(vap, va_guuid, kauth_null_guid);
                } else {

-

                        /* looks good, try to return what we were asked for */
                        VATTR_RETURN(vap, va_uuuid, fsec->fsec_owner);
                        VATTR_RETURN(vap, va_guuid, fsec->fsec_group);
                        /* looks good, try to return what we were asked for */
                        VATTR_RETURN(vap, va_uuuid, fsec->fsec_owner);
                        VATTR_RETURN(vap, va_guuid, fsec->fsec_group);


@@ -2296,7 +2497,7 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                                                error = ENOMEM;
                                                goto out;
                                        }
                                                error = ENOMEM;
                                                goto out;
                                        }

-                                       bcopy(&fsec->fsec_acl, facl, KAUTH_ACL_COPYSIZE(&fsec->fsec_acl));
+                                       __nochk_bcopy(&fsec->fsec_acl, facl, KAUTH_ACL_COPYSIZE(&fsec->fsec_acl));

                                        VATTR_RETURN(vap, va_acl, facl);
                                }
                        }
                                        VATTR_RETURN(vap, va_acl, facl);
                                }
                        }


@@ -2309,12 +2510,13 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
         * only expect what they asked for.
         */
        if (VATTR_IS_SUPPORTED(vap, va_acl) && !VATTR_IS_ACTIVE(vap, va_acl)) {
         * only expect what they asked for.
         */
        if (VATTR_IS_SUPPORTED(vap, va_acl) && !VATTR_IS_ACTIVE(vap, va_acl)) {

-               if (vap->va_acl != NULL)
+               if (vap->va_acl != NULL) {

                        kauth_acl_free(vap->va_acl);
                        kauth_acl_free(vap->va_acl);

+               }

                VATTR_CLEAR_SUPPORTED(vap, va_acl);
        }
 
                VATTR_CLEAR_SUPPORTED(vap, va_acl);
        }
 

-#if 0  /* enable when we have a filesystem only supporting UUIDs */
+#if 0   /* enable when we have a filesystem only supporting UUIDs */

        /*
         * Handle the case where we need a UID/GID, but only have extended
         * security information.
        /*
         * Handle the case where we need a UID/GID, but only have extended
         * security information.


@@ -2322,17 +2524,19 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
        if (VATTR_NOT_RETURNED(vap, va_uid) &&
            VATTR_IS_SUPPORTED(vap, va_uuuid) &&
            !kauth_guid_equal(&vap->va_uuuid, &kauth_null_guid)) {
        if (VATTR_NOT_RETURNED(vap, va_uid) &&
            VATTR_IS_SUPPORTED(vap, va_uuuid) &&
            !kauth_guid_equal(&vap->va_uuuid, &kauth_null_guid)) {

-               if ((error = kauth_cred_guid2uid(&vap->va_uuuid, &nuid)) == 0)
+               if ((error = kauth_cred_guid2uid(&vap->va_uuuid, &nuid)) == 0) {

                        VATTR_RETURN(vap, va_uid, nuid);
                        VATTR_RETURN(vap, va_uid, nuid);

+               }

        }
        if (VATTR_NOT_RETURNED(vap, va_gid) &&
            VATTR_IS_SUPPORTED(vap, va_guuid) &&
            !kauth_guid_equal(&vap->va_guuid, &kauth_null_guid)) {
        }
        if (VATTR_NOT_RETURNED(vap, va_gid) &&
            VATTR_IS_SUPPORTED(vap, va_guuid) &&
            !kauth_guid_equal(&vap->va_guuid, &kauth_null_guid)) {

-               if ((error = kauth_cred_guid2gid(&vap->va_guuid, &ngid)) == 0)
+               if ((error = kauth_cred_guid2gid(&vap->va_guuid, &ngid)) == 0) {

                        VATTR_RETURN(vap, va_gid, ngid);
                        VATTR_RETURN(vap, va_gid, ngid);

+               }

        }
 #endif
        }
 #endif

-       
+

        /*
         * Handle uid/gid == 99 and MNT_IGNORE_OWNERSHIP here.
         */
        /*
         * Handle uid/gid == 99 and MNT_IGNORE_OWNERSHIP here.
         */


@@ -2341,16 +2545,18 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                        nuid = vap->va_uid;
                } else if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
                        nuid = vp->v_mount->mnt_fsowner;
                        nuid = vap->va_uid;
                } else if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
                        nuid = vp->v_mount->mnt_fsowner;

-                       if (nuid == KAUTH_UID_NONE)
+                       if (nuid == KAUTH_UID_NONE) {

                                nuid = 99;
                                nuid = 99;

+                       }

                } else if (VATTR_IS_SUPPORTED(vap, va_uid)) {
                        nuid = vap->va_uid;
                } else {
                        /* this will always be something sensible */
                        nuid = vp->v_mount->mnt_fsowner;
                }
                } else if (VATTR_IS_SUPPORTED(vap, va_uid)) {
                        nuid = vap->va_uid;
                } else {
                        /* this will always be something sensible */
                        nuid = vp->v_mount->mnt_fsowner;
                }

-               if ((nuid == 99) && !vfs_context_issuser(ctx))
+               if ((nuid == 99) && !vfs_context_issuser(ctx)) {

                        nuid = kauth_cred_getuid(vfs_context_ucred(ctx));
                        nuid = kauth_cred_getuid(vfs_context_ucred(ctx));

+               }

                VATTR_RETURN(vap, va_uid, nuid);
        }
        if (VATTR_IS_ACTIVE(vap, va_gid)) {
                VATTR_RETURN(vap, va_uid, nuid);
        }
        if (VATTR_IS_ACTIVE(vap, va_gid)) {


@@ -2358,68 +2564,80 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                        ngid = vap->va_gid;
                } else if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
                        ngid = vp->v_mount->mnt_fsgroup;
                        ngid = vap->va_gid;
                } else if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
                        ngid = vp->v_mount->mnt_fsgroup;

-                       if (ngid == KAUTH_GID_NONE)
+                       if (ngid == KAUTH_GID_NONE) {

                                ngid = 99;
                                ngid = 99;

+                       }

                } else if (VATTR_IS_SUPPORTED(vap, va_gid)) {
                        ngid = vap->va_gid;
                } else {
                        /* this will always be something sensible */
                        ngid = vp->v_mount->mnt_fsgroup;
                }
                } else if (VATTR_IS_SUPPORTED(vap, va_gid)) {
                        ngid = vap->va_gid;
                } else {
                        /* this will always be something sensible */
                        ngid = vp->v_mount->mnt_fsgroup;
                }

-               if ((ngid == 99) && !vfs_context_issuser(ctx))
+               if ((ngid == 99) && !vfs_context_issuser(ctx)) {

                        ngid = kauth_cred_getgid(vfs_context_ucred(ctx));
                        ngid = kauth_cred_getgid(vfs_context_ucred(ctx));

+               }

                VATTR_RETURN(vap, va_gid, ngid);
        }
 
        /*
         * Synthesise some values that can be reasonably guessed.
         */
                VATTR_RETURN(vap, va_gid, ngid);
        }
 
        /*
         * Synthesise some values that can be reasonably guessed.
         */

-       if (!VATTR_IS_SUPPORTED(vap, va_iosize))
+       if (!VATTR_IS_SUPPORTED(vap, va_iosize)) {

                VATTR_RETURN(vap, va_iosize, vp->v_mount->mnt_vfsstat.f_iosize);
                VATTR_RETURN(vap, va_iosize, vp->v_mount->mnt_vfsstat.f_iosize);

-       
-       if (!VATTR_IS_SUPPORTED(vap, va_flags))
+       }
+
+       if (!VATTR_IS_SUPPORTED(vap, va_flags)) {

                VATTR_RETURN(vap, va_flags, 0);
                VATTR_RETURN(vap, va_flags, 0);

+       }

 
 

-       if (!VATTR_IS_SUPPORTED(vap, va_filerev))
+       if (!VATTR_IS_SUPPORTED(vap, va_filerev)) {

                VATTR_RETURN(vap, va_filerev, 0);
                VATTR_RETURN(vap, va_filerev, 0);

+       }

 
 

-       if (!VATTR_IS_SUPPORTED(vap, va_gen))
+       if (!VATTR_IS_SUPPORTED(vap, va_gen)) {

                VATTR_RETURN(vap, va_gen, 0);
                VATTR_RETURN(vap, va_gen, 0);

+       }

 
        /*
         * Default sizes.  Ordering here is important, as later defaults build on earlier ones.
         */
 
        /*
         * Default sizes.  Ordering here is important, as later defaults build on earlier ones.
         */

-       if (!VATTR_IS_SUPPORTED(vap, va_data_size))
+       if (!VATTR_IS_SUPPORTED(vap, va_data_size)) {

                VATTR_RETURN(vap, va_data_size, 0);
                VATTR_RETURN(vap, va_data_size, 0);

+       }

 
        /* do we want any of the possibly-computed values? */
        if (VATTR_IS_ACTIVE(vap, va_data_alloc) ||
            VATTR_IS_ACTIVE(vap, va_total_size) ||
            VATTR_IS_ACTIVE(vap, va_total_alloc)) {
 
        /* do we want any of the possibly-computed values? */
        if (VATTR_IS_ACTIVE(vap, va_data_alloc) ||
            VATTR_IS_ACTIVE(vap, va_total_size) ||
            VATTR_IS_ACTIVE(vap, va_total_alloc)) {

-                /* make sure f_bsize is valid */
-                if (vp->v_mount->mnt_vfsstat.f_bsize == 0) {
-                    if ((error = vfs_update_vfsstat(vp->v_mount, ctx, VFS_KERNEL_EVENT)) != 0)
-                        goto out;
-                }
+               /* make sure f_bsize is valid */
+               if (vp->v_mount->mnt_vfsstat.f_bsize == 0) {
+                       if ((error = vfs_update_vfsstat(vp->v_mount, ctx, VFS_KERNEL_EVENT)) != 0) {
+                               goto out;
+                       }
+               }

 
                /* default va_data_alloc from va_data_size */
 
                /* default va_data_alloc from va_data_size */

-               if (!VATTR_IS_SUPPORTED(vap, va_data_alloc))
+               if (!VATTR_IS_SUPPORTED(vap, va_data_alloc)) {

                        VATTR_RETURN(vap, va_data_alloc, roundup(vap->va_data_size, vp->v_mount->mnt_vfsstat.f_bsize));
                        VATTR_RETURN(vap, va_data_alloc, roundup(vap->va_data_size, vp->v_mount->mnt_vfsstat.f_bsize));

+               }

 
                /* default va_total_size from va_data_size */
 
                /* default va_total_size from va_data_size */

-               if (!VATTR_IS_SUPPORTED(vap, va_total_size))
+               if (!VATTR_IS_SUPPORTED(vap, va_total_size)) {

                        VATTR_RETURN(vap, va_total_size, vap->va_data_size);
                        VATTR_RETURN(vap, va_total_size, vap->va_data_size);

+               }

 
                /* default va_total_alloc from va_total_size which is guaranteed at this point */
 
                /* default va_total_alloc from va_total_size which is guaranteed at this point */

-               if (!VATTR_IS_SUPPORTED(vap, va_total_alloc))
+               if (!VATTR_IS_SUPPORTED(vap, va_total_alloc)) {

                        VATTR_RETURN(vap, va_total_alloc, roundup(vap->va_total_size, vp->v_mount->mnt_vfsstat.f_bsize));
                        VATTR_RETURN(vap, va_total_alloc, roundup(vap->va_total_size, vp->v_mount->mnt_vfsstat.f_bsize));

+               }

        }
 
        /*
         * If we don't have a change time, pull it from the modtime.
         */
        }
 
        /*
         * If we don't have a change time, pull it from the modtime.
         */

-       if (!VATTR_IS_SUPPORTED(vap, va_change_time) && VATTR_IS_SUPPORTED(vap, va_modify_time))
+       if (!VATTR_IS_SUPPORTED(vap, va_change_time) && VATTR_IS_SUPPORTED(vap, va_modify_time)) {

                VATTR_RETURN(vap, va_change_time, vap->va_modify_time);
                VATTR_RETURN(vap, va_change_time, vap->va_modify_time);

+       }

 
        /*
         * This is really only supported for the creation VNOPs, but since the field is there
 
        /*
         * This is really only supported for the creation VNOPs, but since the field is there


@@ -2430,11 +2648,28 @@ vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
        /*
         * The fsid can be obtained from the mountpoint directly.
         */
        /*
         * The fsid can be obtained from the mountpoint directly.
         */

-       VATTR_RETURN(vap, va_fsid, vp->v_mount->mnt_vfsstat.f_fsid.val[0]);
+       if (VATTR_IS_ACTIVE(vap, va_fsid) &&
+           (!VATTR_IS_SUPPORTED(vap, va_fsid) ||
+           vap->va_vaflags & VA_REALFSID || !(vap->va_vaflags & VA_USEFSID))) {
+               VATTR_RETURN(vap, va_fsid, vp->v_mount->mnt_vfsstat.f_fsid.val[0]);
+       }

 
 out:
 
 out:

+       vap->va_vaflags &= ~VA_USEFSID;

 
 

-       return(error);
+       return error;
+}
+
+/*
+ * Choose 32 bit or 64 bit fsid
+ */
+uint64_t
+vnode_get_va_fsid(struct vnode_attr *vap)
+{
+       if (VATTR_IS_SUPPORTED(vap, va_fsid64)) {
+               return (uint64_t)vap->va_fsid64.val[0] + ((uint64_t)vap->va_fsid64.val[1] << 32);
+       }
+       return vap->va_fsid;

 }
 
 /*
 }
 
 /*


@@ -2462,7 +2697,19 @@ out:
 int
 vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
 {
 int
 vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
 {

-       int     error, is_perm_change=0;
+       int     error;
+#if CONFIG_FSE
+       uint64_t active;
+       int     is_perm_change = 0;
+       int     is_stat_change = 0;
+#endif
+
+       /*
+        * Reject attempts to set unknown attributes.
+        */
+       if (vap->va_active & ~VNODE_ATTR_ALL) {
+               return EINVAL;
+       }

 
        /*
         * Make sure the filesystem is mounted R/W.
 
        /*
         * Make sure the filesystem is mounted R/W.


@@ -2472,6 +2719,20 @@ vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                error = EROFS;
                goto out;
        }
                error = EROFS;
                goto out;
        }

+
+#if DEVELOPMENT || DEBUG
+       /*
+        * XXX VSWAP: Check for entitlements or special flag here
+        * so we can restrict access appropriately.
+        */
+#else /* DEVELOPMENT || DEBUG */
+
+       if (vnode_isswap(vp) && (ctx != vfs_context_kernel())) {
+               error = EPERM;
+               goto out;
+       }
+#endif /* DEVELOPMENT || DEBUG */
+

 #if NAMEDSTREAMS
        /* For streams, va_data_size is the only setable attribute. */
        if ((vp->v_flag & VISNAMEDSTREAM) && (vap->va_active != VNODE_ATTR_va_data_size)) {
 #if NAMEDSTREAMS
        /* For streams, va_data_size is the only setable attribute. */
        if ((vp->v_flag & VISNAMEDSTREAM) && (vap->va_active != VNODE_ATTR_va_data_size)) {


@@ -2479,7 +2740,27 @@ vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                goto out;
        }
 #endif
                goto out;
        }
 #endif

-       
+       /* Check for truncation */
+       if (VATTR_IS_ACTIVE(vap, va_data_size)) {
+               switch (vp->v_type) {
+               case VREG:
+                       /* For regular files it's ok */
+                       break;
+               case VDIR:
+                       /* Not allowed to truncate directories */
+                       error = EISDIR;
+                       goto out;
+               default:
+                       /* For everything else we will clear the bit and let underlying FS decide on the rest */
+                       VATTR_CLEAR_ACTIVE(vap, va_data_size);
+                       if (vap->va_active) {
+                               break;
+                       }
+                       /* If it was the only bit set, return success, to handle cases like redirect to /dev/null */
+                       return 0;
+               }
+       }
+

        /*
         * If ownership is being ignored on this volume, we silently discard
         * ownership changes.
        /*
         * If ownership is being ignored on this volume, we silently discard
         * ownership changes.


@@ -2489,11 +2770,6 @@ vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                VATTR_CLEAR_ACTIVE(vap, va_gid);
        }
 
                VATTR_CLEAR_ACTIVE(vap, va_gid);
        }
 

-       if (   VATTR_IS_ACTIVE(vap, va_uid)  || VATTR_IS_ACTIVE(vap, va_gid)
-           || VATTR_IS_ACTIVE(vap, va_mode) || VATTR_IS_ACTIVE(vap, va_acl)) {
-           is_perm_change = 1;
-       }
-       

        /*
         * Make sure that extended security is enabled if we're going to try
         * to set any.
        /*
         * Make sure that extended security is enabled if we're going to try
         * to set any.


@@ -2507,30 +2783,64 @@ vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
 
        /* Never allow the setting of any unsupported superuser flags. */
        if (VATTR_IS_ACTIVE(vap, va_flags)) {
 
        /* Never allow the setting of any unsupported superuser flags. */
        if (VATTR_IS_ACTIVE(vap, va_flags)) {

-           vap->va_flags &= (SF_SUPPORTED | UF_SETTABLE);
+               vap->va_flags &= (SF_SUPPORTED | UF_SETTABLE);

        }
 
        }
 

+#if CONFIG_FSE
+       /*
+        * Remember all of the active attributes that we're
+        * attempting to modify.
+        */
+       active = vap->va_active & ~VNODE_ATTR_RDONLY;
+#endif
+

        error = VNOP_SETATTR(vp, vap, ctx);
 
        error = VNOP_SETATTR(vp, vap, ctx);
 

-       if ((error == 0) && !VATTR_ALL_SUPPORTED(vap))
+       if ((error == 0) && !VATTR_ALL_SUPPORTED(vap)) {

                error = vnode_setattr_fallback(vp, vap, ctx);
                error = vnode_setattr_fallback(vp, vap, ctx);

+       }

 
 #if CONFIG_FSE
 
 #if CONFIG_FSE

-       // only send a stat_changed event if this is more than
-       // just an access or backup time update
-       if (error == 0 && (vap->va_active != VNODE_ATTR_BIT(va_access_time)) && (vap->va_active != VNODE_ATTR_BIT(va_backup_time))) {
-           if (is_perm_change) {
-               if (need_fsevent(FSE_CHOWN, vp)) {
-                   add_fsevent(FSE_CHOWN, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);
+#define PERMISSION_BITS (VNODE_ATTR_BIT(va_uid) | VNODE_ATTR_BIT(va_uuuid) | \
+                        VNODE_ATTR_BIT(va_gid) | VNODE_ATTR_BIT(va_guuid) | \
+                        VNODE_ATTR_BIT(va_mode) | VNODE_ATTR_BIT(va_acl))
+
+       /*
+        * Now that we've changed them, decide whether to send an
+        * FSevent.
+        */
+       if ((active & PERMISSION_BITS) & vap->va_supported) {
+               is_perm_change = 1;
+       } else {
+               /*
+                * We've already checked the permission bits, and we
+                * also want to filter out access time / backup time
+                * changes.
+                */
+               active &= ~(PERMISSION_BITS |
+                   VNODE_ATTR_BIT(va_access_time) |
+                   VNODE_ATTR_BIT(va_backup_time));
+
+               /* Anything left to notify about? */
+               if (active & vap->va_supported) {
+                       is_stat_change = 1;
+               }
+       }
+
+       if (error == 0) {
+               if (is_perm_change) {
+                       if (need_fsevent(FSE_CHOWN, vp)) {
+                               add_fsevent(FSE_CHOWN, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);
+                       }
+               } else if (is_stat_change && need_fsevent(FSE_STAT_CHANGED, vp)) {
+                       add_fsevent(FSE_STAT_CHANGED, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);

                }
                }

-           } else if(need_fsevent(FSE_STAT_CHANGED, vp)) {
-               add_fsevent(FSE_STAT_CHANGED, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);
-           }

        }
        }

+#undef PERMISSION_BITS

 #endif
 
 out:
 #endif
 
 out:

-       return(error);
+       return error;

 }
 
 /*
 }
 
 /*


@@ -2563,7 +2873,7 @@ vnode_setattr_fallback(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
        kauth_filesec_t fsec;
        kauth_acl_t facl;
        struct kauth_filesec lfsec;
        kauth_filesec_t fsec;
        kauth_acl_t facl;
        struct kauth_filesec lfsec;

-       int     error;
+       int     error;

 
        error = 0;
 
 
        error = 0;
 


@@ -2611,7 +2921,7 @@ vnode_setattr_fallback(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                }
                /* find the ACL */
                facl = &fsec->fsec_acl;
                }
                /* find the ACL */
                facl = &fsec->fsec_acl;

-               
+

                /* if we're using the local filesec, we need to initialise it */
                if (fsec == &lfsec) {
                        fsec->fsec_magic = KAUTH_FILESEC_MAGIC;
                /* if we're using the local filesec, we need to initialise it */
                if (fsec == &lfsec) {
                        fsec->fsec_magic = KAUTH_FILESEC_MAGIC;


@@ -2644,7 +2954,7 @@ vnode_setattr_fallback(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                        }
                        VATTR_SET_SUPPORTED(vap, va_acl);
                }
                        }
                        VATTR_SET_SUPPORTED(vap, va_acl);
                }

-               
+

                /*
                 * If the filesec data is all invalid, we can just remove
                 * the EA completely.
                /*
                 * If the filesec data is all invalid, we can just remove
                 * the EA completely.


@@ -2654,8 +2964,9 @@ vnode_setattr_fallback(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                    kauth_guid_equal(&fsec->fsec_group, &kauth_null_guid)) {
                        error = vn_removexattr(vp, KAUTH_FILESEC_XATTR, XATTR_NOSECURITY, ctx);
                        /* no attribute is ok, nothing to delete */
                    kauth_guid_equal(&fsec->fsec_group, &kauth_null_guid)) {
                        error = vn_removexattr(vp, KAUTH_FILESEC_XATTR, XATTR_NOSECURITY, ctx);
                        /* no attribute is ok, nothing to delete */

-                       if (error == ENOATTR)
+                       if (error == ENOATTR) {

                                error = 0;
                                error = 0;

+                       }

                        VFS_DEBUG(ctx, vp, "SETATTR - remove filesec returning %d", error);
                } else {
                        /* write the EA */
                        VFS_DEBUG(ctx, vp, "SETATTR - remove filesec returning %d", error);
                } else {
                        /* write the EA */


@@ -2664,12 +2975,13 @@ vnode_setattr_fallback(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
                }
 
                /* if we fetched a filesec, dispose of the buffer */
                }
 
                /* if we fetched a filesec, dispose of the buffer */

-               if (fsec != &lfsec)
+               if (fsec != &lfsec) {

                        kauth_filesec_free(fsec);
                        kauth_filesec_free(fsec);

+               }

        }
 out:
 
        }
 out:
 

-       return(error);
+       return error;

 }
 
 /*
 }
 
 /*


@@ -2677,25 +2989,25 @@ out:
  * event on a vnode.
  */
 int
  * event on a vnode.
  */
 int

-vnode_notify(vnode_t vp, uint32_t events, struct vnode_attr *vap) 
+vnode_notify(vnode_t vp, uint32_t events, struct vnode_attr *vap)

 {
        /* These are the same as the corresponding knotes, at least for now.  Cheating a little. */
 {
        /* These are the same as the corresponding knotes, at least for now.  Cheating a little. */

-       uint32_t knote_mask = (VNODE_EVENT_WRITE | VNODE_EVENT_DELETE | VNODE_EVENT_RENAME 
-               | VNODE_EVENT_LINK | VNODE_EVENT_EXTEND | VNODE_EVENT_ATTRIB);
-       uint32_t dir_contents_mask = (VNODE_EVENT_DIR_CREATED | VNODE_EVENT_FILE_CREATED 
-                       | VNODE_EVENT_DIR_REMOVED | VNODE_EVENT_FILE_REMOVED);
+       uint32_t knote_mask = (VNODE_EVENT_WRITE | VNODE_EVENT_DELETE | VNODE_EVENT_RENAME
+           | VNODE_EVENT_LINK | VNODE_EVENT_EXTEND | VNODE_EVENT_ATTRIB);
+       uint32_t dir_contents_mask = (VNODE_EVENT_DIR_CREATED | VNODE_EVENT_FILE_CREATED
+           | VNODE_EVENT_DIR_REMOVED | VNODE_EVENT_FILE_REMOVED);

        uint32_t knote_events = (events & knote_mask);
 
        /* Permissions are not explicitly part of the kqueue model */
        if (events & VNODE_EVENT_PERMS) {
                knote_events |= NOTE_ATTRIB;
        uint32_t knote_events = (events & knote_mask);
 
        /* Permissions are not explicitly part of the kqueue model */
        if (events & VNODE_EVENT_PERMS) {
                knote_events |= NOTE_ATTRIB;

-       } 
+       }

 
        /* Directory contents information just becomes NOTE_WRITE */
        if ((vnode_isdir(vp)) && (events & dir_contents_mask)) {
                knote_events |= NOTE_WRITE;
        }
 
        /* Directory contents information just becomes NOTE_WRITE */
        if ((vnode_isdir(vp)) && (events & dir_contents_mask)) {
                knote_events |= NOTE_WRITE;
        }

-       
+

        if (knote_events) {
                lock_vnode_and_post(vp, knote_events);
 #if CONFIG_FSE
        if (knote_events) {
                lock_vnode_and_post(vp, knote_events);
 #if CONFIG_FSE


@@ -2705,7 +3017,7 @@ vnode_notify(vnode_t vp, uint32_t events, struct vnode_attr *vap)
 #else
                (void)vap;
 #endif
 #else
                (void)vap;
 #endif

-       } 
+       }

 
        return 0;
 }
 
        return 0;
 }


@@ -2715,7 +3027,7 @@ vnode_notify(vnode_t vp, uint32_t events, struct vnode_attr *vap)
 int
 vnode_isdyldsharedcache(vnode_t vp)
 {
 int
 vnode_isdyldsharedcache(vnode_t vp)
 {

-       return ((vp->v_flag & VSHARED_DYLD) ? 1 : 0);
+       return (vp->v_flag & VSHARED_DYLD) ? 1 : 0;

 }
 
 
 }
 
 


@@ -2724,8 +3036,23 @@ vnode_isdyldsharedcache(vnode_t vp)
  * check whether a vnode is being monitored.
  */
 int
  * check whether a vnode is being monitored.
  */
 int

-vnode_ismonitored(vnode_t vp) {
-       return (vp->v_knotes.slh_first != NULL);
+vnode_ismonitored(vnode_t vp)
+{
+       return vp->v_knotes.slh_first != NULL;
+}
+
+int
+vnode_getbackingvnode(vnode_t in_vp, vnode_t* out_vpp)
+{
+       if (out_vpp) {
+               *out_vpp = NULLVP;
+       }
+#if NULLFS
+       return nullfs_getbackingvnode(in_vp, out_vpp);
+#else
+#pragma unused(in_vp)
+       return ENOENT;
+#endif

 }
 
 /*
 }
 
 /*


@@ -2733,15 +3060,15 @@ vnode_ismonitored(vnode_t vp) {
  * by the vnode_notify() call.
  */
 int
  * by the vnode_notify() call.
  */
 int

-vfs_get_notify_attributes(struct vnode_attr *vap) 
+vfs_get_notify_attributes(struct vnode_attr *vap)

 {
 {

-       VATTR_INIT(vap); 
+       VATTR_INIT(vap);

        vap->va_active = VNODE_NOTIFY_ATTRS;
        return 0;
 }
 
 #if CONFIG_TRIGGERS
        vap->va_active = VNODE_NOTIFY_ATTRS;
        return 0;
 }
 
 #if CONFIG_TRIGGERS

-int 
+int

 vfs_settriggercallback(fsid_t *fsid, vfs_trigger_callback_t vtc, void *data, uint32_t flags __unused, vfs_context_t ctx)
 {
        int error;
 vfs_settriggercallback(fsid_t *fsid, vfs_trigger_callback_t vtc, void *data, uint32_t flags __unused, vfs_context_t ctx)
 {
        int error;


@@ -2784,10 +3111,10 @@ out:
 
 #if 0
 /*
 
 #if 0
 /*

- *# 
- *#% lookup       dvp     L ? ?
- *#% lookup       vpp     - L -
- */
+*#
+*#% lookup       dvp     L ? ?
+*#% lookup       vpp     - L -
+*/

 struct vnop_lookup_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;
 struct vnop_lookup_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;


@@ -2819,7 +3146,7 @@ struct vnop_lookup_args {
  *             be returned by HFS from hfs_lookup, not including additional
  *             error code which may be propagated from underlying routines.
  */
  *             be returned by HFS from hfs_lookup, not including additional
  *             error code which may be propagated from underlying routines.
  */

-errno_t 
+errno_t

 VNOP_LOOKUP(vnode_t dvp, vnode_t *vpp, struct componentname *cnp, vfs_context_t ctx)
 {
        int _err;
 VNOP_LOOKUP(vnode_t dvp, vnode_t *vpp, struct componentname *cnp, vfs_context_t ctx)
 {
        int _err;


@@ -2836,7 +3163,7 @@ VNOP_LOOKUP(vnode_t dvp, vnode_t *vpp, struct componentname *cnp, vfs_context_t
                DTRACE_FSINFO(lookup, vnode_t, *vpp);
        }
 
                DTRACE_FSINFO(lookup, vnode_t, *vpp);
        }
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -2890,7 +3217,7 @@ VNOP_COMPOUND_OPEN(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t fla
 
        _err = (*dvp->v_op[vnop_compound_open_desc.vdesc_offset])(&a);
        if (want_create) {
 
        _err = (*dvp->v_op[vnop_compound_open_desc.vdesc_offset])(&a);
        if (want_create) {

-               if (_err == 0 && *vpp) {
+               if (_err == 0 && *vpp) {

                        DTRACE_FSINFO(compound_open, vnode_t, *vpp);
                } else {
                        DTRACE_FSINFO(compound_open, vnode_t, dvp);
                        DTRACE_FSINFO(compound_open, vnode_t, *vpp);
                } else {
                        DTRACE_FSINFO(compound_open, vnode_t, dvp);


@@ -2905,10 +3232,10 @@ VNOP_COMPOUND_OPEN(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t fla
                panic("Filesystem did a create, even though none was requested?");
        }
 
                panic("Filesystem did a create, even though none was requested?");
        }
 

-       if (did_create) { 
+       if (did_create) {

 #if CONFIG_APPLEDOUBLE
                if (!NATIVE_XATTR(dvp)) {
 #if CONFIG_APPLEDOUBLE
                if (!NATIVE_XATTR(dvp)) {

-                       /* 
+                       /*

                         * Remove stale Apple Double file (if any).
                         */
                        xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);
                         * Remove stale Apple Double file (if any).
                         */
                        xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);


@@ -2926,8 +3253,7 @@ VNOP_COMPOUND_OPEN(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t fla
        }
 #endif /* 0 */
 
        }
 #endif /* 0 */
 

-       return (_err);
-
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -2940,7 +3266,7 @@ struct vnop_create_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_CREATE(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode_attr * vap, vfs_context_t ctx)
 {
        int _err;
 VNOP_CREATE(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode_attr * vap, vfs_context_t ctx)
 {
        int _err;


@@ -2960,7 +3286,7 @@ VNOP_CREATE(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode
 
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {
 
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {

-               /* 
+               /*

                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);
                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);


@@ -2969,17 +3295,17 @@ VNOP_CREATE(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode
 
        post_event_if_success(dvp, _err, NOTE_WRITE);
 
 
        post_event_if_success(dvp, _err, NOTE_WRITE);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% whiteout     dvp     L L L
- *#% whiteout     cnp     - - -
- *#% whiteout     flag    - - -
- *#
- */
+*#
+*#% whiteout     dvp     L L L
+*#% whiteout     cnp     - - -
+*#% whiteout     flag    - - -
+*#
+*/

 struct vnop_whiteout_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;
 struct vnop_whiteout_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;


@@ -2988,59 +3314,58 @@ struct vnop_whiteout_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_WHITEOUT(__unused vnode_t dvp, __unused struct componentname *cnp,
 VNOP_WHITEOUT(__unused vnode_t dvp, __unused struct componentname *cnp,

-       __unused int flags, __unused vfs_context_t ctx)
+    __unused int flags, __unused vfs_context_t ctx)

 {
 {

-       return (ENOTSUP);       // XXX OBSOLETE
+       return ENOTSUP;       // XXX OBSOLETE

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% mknod        dvp     L U U
- *#% mknod        vpp     - X -
- *#
- */
+*#
+*#% mknod        dvp     L U U
+*#% mknod        vpp     - X -
+*#
+*/

 struct vnop_mknod_args {
 struct vnop_mknod_args {

-       struct vnodeop_desc *a_desc;
-       vnode_t a_dvp;
-       vnode_t *a_vpp;
-       struct componentname *a_cnp;
-       struct vnode_attr *a_vap;
-       vfs_context_t a_context;
+       struct vnodeop_desc *a_desc;
+       vnode_t a_dvp;
+       vnode_t *a_vpp;
+       struct componentname *a_cnp;
+       struct vnode_attr *a_vap;
+       vfs_context_t a_context;

 };
 #endif /* 0*/
 errno_t
 VNOP_MKNOD(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode_attr * vap, vfs_context_t ctx)
 {
 };
 #endif /* 0*/
 errno_t
 VNOP_MKNOD(vnode_t dvp, vnode_t * vpp, struct componentname * cnp, struct vnode_attr * vap, vfs_context_t ctx)
 {

+       int _err;
+       struct vnop_mknod_args a;

 
 

-       int _err;
-       struct vnop_mknod_args a;
-
-       a.a_desc = &vnop_mknod_desc;
-       a.a_dvp = dvp;
-       a.a_vpp = vpp;
-       a.a_cnp = cnp;
-       a.a_vap = vap;
-       a.a_context = ctx;
+       a.a_desc = &vnop_mknod_desc;
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       a.a_context = ctx;

 
 

-       _err = (*dvp->v_op[vnop_mknod_desc.vdesc_offset])(&a);
-       if (_err == 0 && *vpp) {
+       _err = (*dvp->v_op[vnop_mknod_desc.vdesc_offset])(&a);
+       if (_err == 0 && *vpp) {

                DTRACE_FSINFO(mknod, vnode_t, *vpp);
                DTRACE_FSINFO(mknod, vnode_t, *vpp);

-       }
+       }

 
 

-       post_event_if_success(dvp, _err, NOTE_WRITE);
+       post_event_if_success(dvp, _err, NOTE_WRITE);

 
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% open         vp      L L L
- *#
- */
+*#
+*#% open         vp      L L L
+*#
+*/

 struct vnop_open_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_open_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3048,32 +3373,32 @@ struct vnop_open_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
-VNOP_OPEN(vnode_t vp, int mode, vfs_context_t ctx) 
+errno_t
+VNOP_OPEN(vnode_t vp, int mode, vfs_context_t ctx)

 {
        int _err;
        struct vnop_open_args a;
 
        if (ctx == NULL) {
                ctx = vfs_context_current();
 {
        int _err;
        struct vnop_open_args a;
 
        if (ctx == NULL) {
                ctx = vfs_context_current();

-       }    
+       }

        a.a_desc = &vnop_open_desc;
        a.a_vp = vp;
        a.a_mode = mode;
        a.a_desc = &vnop_open_desc;
        a.a_vp = vp;
        a.a_mode = mode;

-       a.a_context = ctx; 
+       a.a_context = ctx;

 
        _err = (*vp->v_op[vnop_open_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(open, vnode_t, vp);
 
 
        _err = (*vp->v_op[vnop_open_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(open, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% close        vp      U U U
- *#
- */
+*#
+*#% close        vp      U U U
+*#
+*/

 struct vnop_close_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_close_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3081,7 +3406,7 @@ struct vnop_close_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_CLOSE(vnode_t vp, int fflag, vfs_context_t ctx)
 {
        int _err;
 VNOP_CLOSE(vnode_t vp, int fflag, vfs_context_t ctx)
 {
        int _err;


@@ -3098,15 +3423,15 @@ VNOP_CLOSE(vnode_t vp, int fflag, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_close_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(close, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_close_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(close, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% access       vp      L L L
- *#
- */
+*#
+*#% access       vp      L L L
+*#
+*/

 struct vnop_access_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_access_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3114,7 +3439,7 @@ struct vnop_access_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_ACCESS(vnode_t vp, int action, vfs_context_t ctx)
 {
        int _err;
 VNOP_ACCESS(vnode_t vp, int action, vfs_context_t ctx)
 {
        int _err;


@@ -3131,15 +3456,15 @@ VNOP_ACCESS(vnode_t vp, int action, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_access_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(access, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_access_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(access, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% getattr      vp      = = =
- *#
- */
+*#
+*#% getattr      vp      = = =
+*#
+*/

 struct vnop_getattr_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_getattr_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3147,7 +3472,7 @@ struct vnop_getattr_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_GETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
 {
        int _err;
 VNOP_GETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
 {
        int _err;


@@ -3161,15 +3486,15 @@ VNOP_GETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_getattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(getattr, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_getattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(getattr, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% setattr      vp      L L L
- *#
- */
+*#
+*#% setattr      vp      L L L
+*#
+*/

 struct vnop_setattr_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_setattr_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3177,7 +3502,7 @@ struct vnop_setattr_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
 {
        int _err;
 VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
 {
        int _err;


@@ -3192,7 +3517,7 @@ VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
        DTRACE_FSINFO(setattr, vnode_t, vp);
 
 #if CONFIG_APPLEDOUBLE
        DTRACE_FSINFO(setattr, vnode_t, vp);
 
 #if CONFIG_APPLEDOUBLE

-       /* 
+       /*

         * Shadow uid/gid/mod change to extended attribute file.
         */
        if (_err == 0 && !NATIVE_XATTR(vp)) {
         * Shadow uid/gid/mod change to extended attribute file.
         */
        if (_err == 0 && !NATIVE_XATTR(vp)) {


@@ -3213,17 +3538,19 @@ VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
                        change = 1;
                }
                if (change) {
                        change = 1;
                }
                if (change) {

-                       vnode_t dvp;
+                       vnode_t dvp;

                        const char   *vname;
 
                        dvp = vnode_getparent(vp);
                        vname = vnode_getname(vp);
 
                        xattrfile_setattr(dvp, vname, &va, ctx);
                        const char   *vname;
 
                        dvp = vnode_getparent(vp);
                        vname = vnode_getname(vp);
 
                        xattrfile_setattr(dvp, vname, &va, ctx);

-                       if (dvp != NULLVP)
-                               vnode_put(dvp);
-                       if (vname != NULL)
-                               vnode_putname(vname);
+                       if (dvp != NULLVP) {
+                               vnode_put(dvp);
+                       }
+                       if (vname != NULL) {
+                               vnode_putname(vname);
+                       }

                }
        }
 #endif /* CONFIG_APPLEDOUBLE */
                }
        }
 #endif /* CONFIG_APPLEDOUBLE */


@@ -3234,14 +3561,14 @@ VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
         * cache
         */
        if (_err == 0 && (
         * cache
         */
        if (_err == 0 && (

-                         VATTR_IS_SUPPORTED(vap, va_mode) ||
-                         VATTR_IS_SUPPORTED(vap, va_uid) ||
-                         VATTR_IS_SUPPORTED(vap, va_gid) ||
-                         VATTR_IS_SUPPORTED(vap, va_flags) ||
-                         VATTR_IS_SUPPORTED(vap, va_acl) ||
-                         VATTR_IS_SUPPORTED(vap, va_uuuid) ||
-                         VATTR_IS_SUPPORTED(vap, va_guuid))) {
-               vnode_uncache_authorized_action(vp, KAUTH_INVALIDATE_CACHED_RIGHTS);
+                   VATTR_IS_SUPPORTED(vap, va_mode) ||
+                   VATTR_IS_SUPPORTED(vap, va_uid) ||
+                   VATTR_IS_SUPPORTED(vap, va_gid) ||
+                   VATTR_IS_SUPPORTED(vap, va_flags) ||
+                   VATTR_IS_SUPPORTED(vap, va_acl) ||
+                   VATTR_IS_SUPPORTED(vap, va_uuuid) ||
+                   VATTR_IS_SUPPORTED(vap, va_guuid))) {
+               vnode_uncache_authorized_action(vp, KAUTH_INVALIDATE_CACHED_RIGHTS);

 
 #if NAMEDSTREAMS
                if (vfs_authopaque(vp->v_mount) && vnode_hasnamedstreams(vp)) {
 
 #if NAMEDSTREAMS
                if (vfs_authopaque(vp->v_mount) && vnode_hasnamedstreams(vp)) {


@@ -3249,24 +3576,24 @@ VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
                        if (vnode_getnamedstream(vp, &svp, XATTR_RESOURCEFORK_NAME, NS_OPEN, 0, ctx) == 0) {
                                vnode_uncache_authorized_action(svp, KAUTH_INVALIDATE_CACHED_RIGHTS);
                                vnode_put(svp);
                        if (vnode_getnamedstream(vp, &svp, XATTR_RESOURCEFORK_NAME, NS_OPEN, 0, ctx) == 0) {
                                vnode_uncache_authorized_action(svp, KAUTH_INVALIDATE_CACHED_RIGHTS);
                                vnode_put(svp);

-                       } 
-               } 
+                       }
+               }

 #endif /* NAMEDSTREAMS */
        }
 
 
        post_event_if_success(vp, _err, NOTE_ATTRIB);
 
 #endif /* NAMEDSTREAMS */
        }
 
 
        post_event_if_success(vp, _err, NOTE_ATTRIB);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% read         vp      L L L
- *#
- */
+*#
+*#% read         vp      L L L
+*#
+*/

 struct vnop_read_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_read_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3275,7 +3602,7 @@ struct vnop_read_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_READ(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
 {
        int _err;
 VNOP_READ(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
 {
        int _err;


@@ -3298,16 +3625,16 @@ VNOP_READ(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
        DTRACE_FSINFO_IO(read,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 
        DTRACE_FSINFO_IO(read,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% write        vp      L L L
- *#
- */
+*#
+*#% write        vp      L L L
+*#
+*/

 struct vnop_write_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_write_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3316,7 +3643,7 @@ struct vnop_write_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_WRITE(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
 {
        struct vnop_write_args a;
 VNOP_WRITE(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
 {
        struct vnop_write_args a;


@@ -3341,16 +3668,16 @@ VNOP_WRITE(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
 
        post_event_if_success(vp, _err, NOTE_WRITE);
 
 
        post_event_if_success(vp, _err, NOTE_WRITE);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% ioctl        vp      U U U
- *#
- */
+*#
+*#% ioctl        vp      U U U
+*#
+*/

 struct vnop_ioctl_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_ioctl_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3360,7 +3687,7 @@ struct vnop_ioctl_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_IOCTL(vnode_t vp, u_long command, caddr_t data, int fflag, vfs_context_t ctx)
 {
        int _err;
 VNOP_IOCTL(vnode_t vp, u_long command, caddr_t data, int fflag, vfs_context_t ctx)
 {
        int _err;


@@ -3386,7 +3713,7 @@ VNOP_IOCTL(vnode_t vp, u_long command, caddr_t data, int fflag, vfs_context_t ct
         */
        if (vfs_context_is64bit(ctx) && !(vnode_ischr(vp) || vnode_isblk(vp))) {
                if (data != NULL && !vnode_vfs64bitready(vp)) {
         */
        if (vfs_context_is64bit(ctx) && !(vnode_ischr(vp) || vnode_isblk(vp))) {
                if (data != NULL && !vnode_vfs64bitready(vp)) {

-                       return(ENOTTY);
+                       return ENOTTY;

                }
        }
 
                }
        }
 


@@ -3395,21 +3722,21 @@ VNOP_IOCTL(vnode_t vp, u_long command, caddr_t data, int fflag, vfs_context_t ct
        a.a_command = command;
        a.a_data = data;
        a.a_fflag = fflag;
        a.a_command = command;
        a.a_data = data;
        a.a_fflag = fflag;

-       a.a_context= ctx;
+       a.a_context = ctx;

 
        _err = (*vp->v_op[vnop_ioctl_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(ioctl, vnode_t, vp);
 
 
        _err = (*vp->v_op[vnop_ioctl_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(ioctl, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% select       vp      U U U
- *#
- */
+*#
+*#% select       vp      U U U
+*#
+*/

 struct vnop_select_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_select_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3419,8 +3746,8 @@ struct vnop_select_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
-VNOP_SELECT(vnode_t vp, int which , int fflags, void * wql, vfs_context_t ctx)
+errno_t
+VNOP_SELECT(vnode_t vp, int which, int fflags, void * wql, vfs_context_t ctx)

 {
        int _err;
        struct vnop_select_args a;
 {
        int _err;
        struct vnop_select_args a;


@@ -3438,26 +3765,26 @@ VNOP_SELECT(vnode_t vp, int which , int fflags, void * wql, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_select_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(select, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_select_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(select, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% exchange fvp         L L L
- *#% exchange tvp         L L L
- *#
- */
+*#
+*#% exchange fvp         L L L
+*#% exchange tvp         L L L
+*#
+*/

 struct vnop_exchange_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_fvp;
 struct vnop_exchange_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_fvp;

-        vnode_t a_tvp;
-        int a_options;
+       vnode_t a_tvp;
+       int a_options;

        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_EXCHANGE(vnode_t fvp, vnode_t tvp, int options, vfs_context_t ctx)
 {
        int _err;
 VNOP_EXCHANGE(vnode_t fvp, vnode_t tvp, int options, vfs_context_t ctx)
 {
        int _err;


@@ -3476,16 +3803,16 @@ VNOP_EXCHANGE(vnode_t fvp, vnode_t tvp, int options, vfs_context_t ctx)
        post_event_if_success(fvp, _err, NOTE_ATTRIB);
        post_event_if_success(tvp, _err, NOTE_ATTRIB);
 
        post_event_if_success(fvp, _err, NOTE_ATTRIB);
        post_event_if_success(tvp, _err, NOTE_ATTRIB);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% revoke       vp      U U U
- *#
- */
+*#
+*#% revoke       vp      U U U
+*#
+*/

 struct vnop_revoke_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_revoke_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3493,7 +3820,7 @@ struct vnop_revoke_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_REVOKE(vnode_t vp, int flags, vfs_context_t ctx)
 {
        struct vnop_revoke_args a;
 VNOP_REVOKE(vnode_t vp, int flags, vfs_context_t ctx)
 {
        struct vnop_revoke_args a;


@@ -3507,16 +3834,49 @@ VNOP_REVOKE(vnode_t vp, int flags, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_revoke_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(revoke, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_revoke_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(revoke, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *# mmap - vp U U U
- *#
- */
+*#
+*# mmap_check - vp U U U
+*#
+*/
+struct vnop_mmap_check_args {
+       struct vnodeop_desc *a_desc;
+       vnode_t a_vp;
+       int a_flags;
+       vfs_context_t a_context;
+};
+#endif /* 0 */
+errno_t
+VNOP_MMAP_CHECK(vnode_t vp, int flags, vfs_context_t ctx)
+{
+       int _err;
+       struct vnop_mmap_check_args a;
+
+       a.a_desc = &vnop_mmap_check_desc;
+       a.a_vp = vp;
+       a.a_flags = flags;
+       a.a_context = ctx;
+
+       _err = (*vp->v_op[vnop_mmap_check_desc.vdesc_offset])(&a);
+       if (_err == ENOTSUP) {
+               _err = 0;
+       }
+       DTRACE_FSINFO(mmap_check, vnode_t, vp);
+
+       return _err;
+}
+
+#if 0
+/*
+*#
+*# mmap - vp U U U
+*#
+*/

 struct vnop_mmap_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_mmap_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3524,7 +3884,7 @@ struct vnop_mmap_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_MMAP(vnode_t vp, int fflags, vfs_context_t ctx)
 {
        int _err;
 VNOP_MMAP(vnode_t vp, int fflags, vfs_context_t ctx)
 {
        int _err;


@@ -3538,23 +3898,23 @@ VNOP_MMAP(vnode_t vp, int fflags, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_mmap_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(mmap, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_mmap_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(mmap, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *# mnomap - vp U U U
- *#
- */
+*#
+*# mnomap - vp U U U
+*#
+*/

 struct vnop_mnomap_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
        vfs_context_t a_context;
 };
 #endif /* 0*/
 struct vnop_mnomap_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_MNOMAP(vnode_t vp, vfs_context_t ctx)
 {
        int _err;
 VNOP_MNOMAP(vnode_t vp, vfs_context_t ctx)
 {
        int _err;


@@ -3567,16 +3927,16 @@ VNOP_MNOMAP(vnode_t vp, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_mnomap_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(mnomap, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_mnomap_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(mnomap, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% fsync        vp      L L L
- *#
- */
+*#
+*#% fsync        vp      L L L
+*#
+*/

 struct vnop_fsync_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_fsync_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3584,7 +3944,7 @@ struct vnop_fsync_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_FSYNC(vnode_t vp, int waitfor, vfs_context_t ctx)
 {
        struct vnop_fsync_args a;
 VNOP_FSYNC(vnode_t vp, int waitfor, vfs_context_t ctx)
 {
        struct vnop_fsync_args a;


@@ -3598,17 +3958,17 @@ VNOP_FSYNC(vnode_t vp, int waitfor, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_fsync_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(fsync, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_fsync_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(fsync, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% remove       dvp     L U U
- *#% remove       vp      L U U
- *#
- */
+*#
+*#% remove       dvp     L U U
+*#% remove       vp      L U U
+*#
+*/

 struct vnop_remove_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;
 struct vnop_remove_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;


@@ -3618,7 +3978,7 @@ struct vnop_remove_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_REMOVE(vnode_t dvp, vnode_t vp, struct componentname * cnp, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_REMOVE(vnode_t dvp, vnode_t vp, struct componentname * cnp, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -3635,21 +3995,21 @@ VNOP_REMOVE(vnode_t dvp, vnode_t vp, struct componentname * cnp, int flags, vfs_
        DTRACE_FSINFO(remove, vnode_t, vp);
 
        if (_err == 0) {
        DTRACE_FSINFO(remove, vnode_t, vp);
 
        if (_err == 0) {

-               vnode_setneedinactive(vp);
+               vnode_setneedinactive(vp);

 #if CONFIG_APPLEDOUBLE
 #if CONFIG_APPLEDOUBLE

-               if ( !(NATIVE_XATTR(dvp)) ) {
-                       /* 
+               if (!(NATIVE_XATTR(dvp))) {
+                       /*

                         * Remove any associated extended attribute file (._ AppleDouble file).
                         */
                         * Remove any associated extended attribute file (._ AppleDouble file).
                         */

-                       xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 1);
+                       xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 1);

                }
 #endif /* CONFIG_APPLEDOUBLE */
        }
 
        post_event_if_success(vp, _err, NOTE_DELETE | NOTE_LINK);
        post_event_if_success(dvp, _err, NOTE_WRITE);
                }
 #endif /* CONFIG_APPLEDOUBLE */
        }
 
        post_event_if_success(vp, _err, NOTE_DELETE | NOTE_LINK);
        post_event_if_success(dvp, _err, NOTE_WRITE);

-       
-       return (_err);
+
+       return _err;

 }
 
 int
 }
 
 int


@@ -3675,13 +4035,13 @@ VNOP_COMPOUND_REMOVE(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t f
                DTRACE_FSINFO(compound_remove, vnode_t, dvp);
        }
        if (_err == 0) {
                DTRACE_FSINFO(compound_remove, vnode_t, dvp);
        }
        if (_err == 0) {

-               vnode_setneedinactive(*vpp);
+               vnode_setneedinactive(*vpp);

 #if CONFIG_APPLEDOUBLE
 #if CONFIG_APPLEDOUBLE

-               if ( !(NATIVE_XATTR(dvp)) ) {
-                       /* 
+               if (!(NATIVE_XATTR(dvp))) {
+                       /*

                         * Remove any associated extended attribute file (._ AppleDouble file).
                         */
                         * Remove any associated extended attribute file (._ AppleDouble file).
                         */

-                       xattrfile_remove(dvp, ndp->ni_cnd.cn_nameptr, ctx, 1);
+                       xattrfile_remove(dvp, ndp->ni_cnd.cn_nameptr, ctx, 1);

                }
 #endif /* CONFIG_APPLEDOUBLE */
        }
                }
 #endif /* CONFIG_APPLEDOUBLE */
        }


@@ -3699,16 +4059,16 @@ VNOP_COMPOUND_REMOVE(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t f
 
        //printf("VNOP_COMPOUND_REMOVE() returning %d\n", _err);
 
 
        //printf("VNOP_COMPOUND_REMOVE() returning %d\n", _err);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% link         vp      U U U
- *#% link         tdvp    L U U
- *#
- */
+*#
+*#% link         vp      U U U
+*#% link         tdvp    L U U
+*#
+*/

 struct vnop_link_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_link_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -3717,7 +4077,7 @@ struct vnop_link_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_LINK(vnode_t vp, vnode_t tdvp, struct componentname * cnp, vfs_context_t ctx)
 {
        int _err;
 VNOP_LINK(vnode_t vp, vnode_t tdvp, struct componentname * cnp, vfs_context_t ctx)
 {
        int _err;


@@ -3728,7 +4088,7 @@ VNOP_LINK(vnode_t vp, vnode_t tdvp, struct componentname * cnp, vfs_context_t ct
         * For file systems with non-native extended attributes,
         * disallow linking to an existing "._" Apple Double file.
         */
         * For file systems with non-native extended attributes,
         * disallow linking to an existing "._" Apple Double file.
         */

-       if ( !NATIVE_XATTR(tdvp) && (vp->v_type == VREG)) {
+       if (!NATIVE_XATTR(tdvp) && (vp->v_type == VREG)) {

                const char   *vname;
 
                vname = vnode_getname(vp);
                const char   *vname;
 
                vname = vnode_getname(vp);


@@ -3738,8 +4098,9 @@ VNOP_LINK(vnode_t vp, vnode_t tdvp, struct componentname * cnp, vfs_context_t ct
                                _err = EPERM;
                        }
                        vnode_putname(vname);
                                _err = EPERM;
                        }
                        vnode_putname(vname);

-                       if (_err)
-                               return (_err);
+                       if (_err) {
+                               return _err;
+                       }

                }
        }
 #endif /* CONFIG_APPLEDOUBLE */
                }
        }
 #endif /* CONFIG_APPLEDOUBLE */


@@ -3756,13 +4117,13 @@ VNOP_LINK(vnode_t vp, vnode_t tdvp, struct componentname * cnp, vfs_context_t ct
        post_event_if_success(vp, _err, NOTE_LINK);
        post_event_if_success(tdvp, _err, NOTE_WRITE);
 
        post_event_if_success(vp, _err, NOTE_LINK);
        post_event_if_success(tdvp, _err, NOTE_WRITE);
 

-       return (_err);
+       return _err;

 }
 
 errno_t
 vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, struct vnode_attr *fvap,
 }
 
 errno_t
 vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, struct vnode_attr *fvap,

-            struct vnode *tdvp, struct vnode **tvpp, struct componentname *tcnp, struct vnode_attr *tvap,
-            uint32_t flags, vfs_context_t ctx)
+    struct vnode *tdvp, struct vnode **tvpp, struct componentname *tcnp, struct vnode_attr *tvap,
+    vfs_rename_flags_t flags, vfs_context_t ctx)

 {
        int _err;
        struct nameidata *fromnd = NULL;
 {
        int _err;
        struct nameidata *fromnd = NULL;


@@ -3776,31 +4137,25 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
        char *xtoname = NULL;
 #endif /* CONFIG_APPLEDOUBLE */
        int batched;
        char *xtoname = NULL;
 #endif /* CONFIG_APPLEDOUBLE */
        int batched;

-       uint32_t tdfflags;      // Target directory file flags
+       uint32_t tdfflags;      // Target directory file flags

 
        batched = vnode_compound_rename_available(fdvp);
 
        if (!batched) {
 
        batched = vnode_compound_rename_available(fdvp);
 
        if (!batched) {

-               if (*fvpp == NULLVP) 
+               if (*fvpp == NULLVP) {

                        panic("Not batched, and no fvp?");
                        panic("Not batched, and no fvp?");

+               }

        }
 
        }
 

-#if CONFIG_SECLUDED_RENAME
-       if ((fcnp->cn_flags & CN_SECLUDE_RENAME) && 
-           (((*fvpp)->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFSVNOP_SECLUDE_RENAME) == 0)) {
-           return ENOTSUP;
-       }
-#endif
-

 #if CONFIG_APPLEDOUBLE
 #if CONFIG_APPLEDOUBLE

-       /* 
+       /*

         * We need to preflight any potential AppleDouble file for the source file
         * before doing the rename operation, since we could potentially be doing
         * this operation on a network filesystem, and would end up duplicating
         * the work.  Also, save the source and destination names.  Skip it if the
         * source has a "._" prefix.
         */
         * We need to preflight any potential AppleDouble file for the source file
         * before doing the rename operation, since we could potentially be doing
         * this operation on a network filesystem, and would end up duplicating
         * the work.  Also, save the source and destination names.  Skip it if the
         * source has a "._" prefix.
         */

-       
+

        if (!NATIVE_XATTR(fdvp) &&
            !(fcnp->cn_nameptr[0] == '.' && fcnp->cn_nameptr[1] == '_')) {
                size_t len;
        if (!NATIVE_XATTR(fdvp) &&
            !(fcnp->cn_nameptr[0] == '.' && fcnp->cn_nameptr[1] == '_')) {
                size_t len;


@@ -3813,9 +4168,8 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
                } else {
                        xfromname = &smallname1[0];
                }
                } else {
                        xfromname = &smallname1[0];
                }

-               strlcpy(xfromname, "._", min(sizeof smallname1, len));
-               strncat(xfromname, fcnp->cn_nameptr, fcnp->cn_namelen);
-               xfromname[len-1] = '\0';
+               strlcpy(xfromname, "._", len);
+               strlcat(xfromname, fcnp->cn_nameptr, len);

 
                /* Get destination attribute file name. */
                len = tcnp->cn_namelen + 3;
 
                /* Get destination attribute file name. */
                len = tcnp->cn_namelen + 3;


@@ -3824,47 +4178,44 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
                } else {
                        xtoname = &smallname2[0];
                }
                } else {
                        xtoname = &smallname2[0];
                }

-               strlcpy(xtoname, "._", min(sizeof smallname2, len));
-               strncat(xtoname, tcnp->cn_nameptr, tcnp->cn_namelen);
-               xtoname[len-1] = '\0';
-       
-               /* 
+               strlcpy(xtoname, "._", len);
+               strlcat(xtoname, tcnp->cn_nameptr, len);
+
+               /*

                 * Look up source attribute file, keep reference on it if exists.
                 * Note that we do the namei with the nameiop of RENAME, which is different than
                 * in the rename syscall. It's OK if the source file does not exist, since this
                 * is only for AppleDouble files.
                 */
                 * Look up source attribute file, keep reference on it if exists.
                 * Note that we do the namei with the nameiop of RENAME, which is different than
                 * in the rename syscall. It's OK if the source file does not exist, since this
                 * is only for AppleDouble files.
                 */

-               if (xfromname != NULL) {
-                       MALLOC(fromnd, struct nameidata *, sizeof (struct nameidata), M_TEMP, M_WAITOK);
-                       NDINIT(fromnd, RENAME, OP_RENAME, NOFOLLOW | USEDVP | CN_NBMOUNTLOOK,
-                              UIO_SYSSPACE, CAST_USER_ADDR_T(xfromname), ctx);
-                       fromnd->ni_dvp = fdvp;
-                       error = namei(fromnd);
-               
-                       /* 
-                        * If there was an error looking up source attribute file, 
-                        * we'll behave as if it didn't exist. 
-                        */
+               MALLOC(fromnd, struct nameidata *, sizeof(struct nameidata), M_TEMP, M_WAITOK);
+               NDINIT(fromnd, RENAME, OP_RENAME, NOFOLLOW | USEDVP | CN_NBMOUNTLOOK,
+                   UIO_SYSSPACE, CAST_USER_ADDR_T(xfromname), ctx);
+               fromnd->ni_dvp = fdvp;
+               error = namei(fromnd);
+
+               /*
+                * If there was an error looking up source attribute file,
+                * we'll behave as if it didn't exist.
+                */

 
 

-                       if (error == 0) {
-                               if (fromnd->ni_vp) {
-                                       /* src_attr_vp indicates need to call vnode_put / nameidone later */
-                                       src_attr_vp = fromnd->ni_vp;
-                                                                               
-                                       if (fromnd->ni_vp->v_type != VREG) {
-                                               src_attr_vp = NULLVP;
-                                               vnode_put(fromnd->ni_vp);
-                                       }
-                               } 
-                               /*
-                                * Either we got an invalid vnode type (not a regular file) or the namei lookup 
-                                * suppressed ENOENT as a valid error since we're renaming. Either way, we don't 
-                                * have a vnode here, so we drop our namei buffer for the source attribute file
-                                */
-                               if (src_attr_vp == NULLVP) {
-                                       nameidone(fromnd);
+               if (error == 0) {
+                       if (fromnd->ni_vp) {
+                               /* src_attr_vp indicates need to call vnode_put / nameidone later */
+                               src_attr_vp = fromnd->ni_vp;
+
+                               if (fromnd->ni_vp->v_type != VREG) {
+                                       src_attr_vp = NULLVP;
+                                       vnode_put(fromnd->ni_vp);

                                }
                        }
                                }
                        }

+                       /*
+                        * Either we got an invalid vnode type (not a regular file) or the namei lookup
+                        * suppressed ENOENT as a valid error since we're renaming. Either way, we don't
+                        * have a vnode here, so we drop our namei buffer for the source attribute file
+                        */
+                       if (src_attr_vp == NULLVP) {
+                               nameidone(fromnd);
+                       }

                }
        }
 #endif /* CONFIG_APPLEDOUBLE */
                }
        }
 #endif /* CONFIG_APPLEDOUBLE */


@@ -3875,7 +4226,18 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
                        printf("VNOP_COMPOUND_RENAME() returned %d\n", _err);
                }
        } else {
                        printf("VNOP_COMPOUND_RENAME() returned %d\n", _err);
                }
        } else {

-               _err = VNOP_RENAME(fdvp, *fvpp, fcnp, tdvp, *tvpp, tcnp, ctx);
+               if (flags) {
+                       _err = VNOP_RENAMEX(fdvp, *fvpp, fcnp, tdvp, *tvpp, tcnp, flags, ctx);
+                       if (_err == ENOTSUP && flags == VFS_RENAME_SECLUDE) {
+                               // Legacy...
+                               if ((*fvpp)->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFSVNOP_SECLUDE_RENAME) {
+                                       fcnp->cn_flags |= CN_SECLUDE_RENAME;
+                                       _err = VNOP_RENAME(fdvp, *fvpp, fcnp, tdvp, *tvpp, tcnp, ctx);
+                               }
+                       }
+               } else {
+                       _err = VNOP_RENAME(fdvp, *fvpp, fcnp, tdvp, *tvpp, tcnp, ctx);
+               }

        }
 
        /*
        }
 
        /*


@@ -3884,14 +4246,17 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
         */
        if (_err == 0) {
                _err = vnode_flags(tdvp, &tdfflags, ctx);
         */
        if (_err == 0) {
                _err = vnode_flags(tdvp, &tdfflags, ctx);

-               if (_err == 0 && (tdfflags & SF_RESTRICTED)) {
-                       uint32_t fflags;
-                       _err = vnode_flags(*fvpp, &fflags, ctx);
-                       if (_err == 0 && !(fflags & SF_RESTRICTED)) {
-                               struct vnode_attr va;
-                               VATTR_INIT(&va);
-                               VATTR_SET(&va, va_flags, fflags | SF_RESTRICTED);
-                               _err = vnode_setattr(*fvpp, &va, ctx);
+               if (_err == 0) {
+                       uint32_t inherit_flags = tdfflags & (UF_DATAVAULT | SF_RESTRICTED);
+                       if (inherit_flags) {
+                               uint32_t fflags;
+                               _err = vnode_flags(*fvpp, &fflags, ctx);
+                               if (_err == 0 && fflags != (fflags | inherit_flags)) {
+                                       struct vnode_attr va;
+                                       VATTR_INIT(&va);
+                                       VATTR_SET(&va, va_flags, fflags | inherit_flags);
+                                       _err = vnode_setattr(*fvpp, &va, ctx);
+                               }

                        }
                }
        }
                        }
                }
        }


@@ -3899,16 +4264,19 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
 #if CONFIG_MACF
        if (_err == 0) {
                mac_vnode_notify_rename(ctx, *fvpp, tdvp, tcnp);
 #if CONFIG_MACF
        if (_err == 0) {
                mac_vnode_notify_rename(ctx, *fvpp, tdvp, tcnp);

+               if (flags & VFS_RENAME_SWAP) {
+                       mac_vnode_notify_rename(ctx, *tvpp, fdvp, fcnp);
+               }

        }
 #endif
 
 #if CONFIG_APPLEDOUBLE
        }
 #endif
 
 #if CONFIG_APPLEDOUBLE

-       /* 
+       /*

         * Rename any associated extended attribute file (._ AppleDouble file).
         */
        if (_err == 0 && !NATIVE_XATTR(fdvp) && xfromname != NULL) {
                int error = 0;
         * Rename any associated extended attribute file (._ AppleDouble file).
         */
        if (_err == 0 && !NATIVE_XATTR(fdvp) && xfromname != NULL) {
                int error = 0;

-       
+

                /*
                 * Get destination attribute file vnode.
                 * Note that tdvp already has an iocount reference. Make sure to check that we
                /*
                 * Get destination attribute file vnode.
                 * Note that tdvp already has an iocount reference. Make sure to check that we


@@ -3916,57 +4284,58 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
                 */
                MALLOC(tond, struct nameidata *, sizeof(struct nameidata), M_TEMP, M_WAITOK);
                NDINIT(tond, RENAME, OP_RENAME,
                 */
                MALLOC(tond, struct nameidata *, sizeof(struct nameidata), M_TEMP, M_WAITOK);
                NDINIT(tond, RENAME, OP_RENAME,

-                      NOCACHE | NOFOLLOW | USEDVP | CN_NBMOUNTLOOK, UIO_SYSSPACE,
-                      CAST_USER_ADDR_T(xtoname), ctx);
+                   NOCACHE | NOFOLLOW | USEDVP | CN_NBMOUNTLOOK, UIO_SYSSPACE,
+                   CAST_USER_ADDR_T(xtoname), ctx);

                tond->ni_dvp = tdvp;
                error = namei(tond);
 
                tond->ni_dvp = tdvp;
                error = namei(tond);
 

-               if (error) 
+               if (error) {

                        goto ad_error;
                        goto ad_error;

-               
+               }
+

                if (tond->ni_vp) {
                        dst_attr_vp = tond->ni_vp;
                }
                if (tond->ni_vp) {
                        dst_attr_vp = tond->ni_vp;
                }

-               
+

                if (src_attr_vp) {
                        const char *old_name = src_attr_vp->v_name;
                        vnode_t old_parent = src_attr_vp->v_parent;
                if (src_attr_vp) {
                        const char *old_name = src_attr_vp->v_name;
                        vnode_t old_parent = src_attr_vp->v_parent;

-       
+

                        if (batched) {
                                error = VNOP_COMPOUND_RENAME(fdvp, &src_attr_vp, &fromnd->ni_cnd, NULL,
                        if (batched) {
                                error = VNOP_COMPOUND_RENAME(fdvp, &src_attr_vp, &fromnd->ni_cnd, NULL,

-                                               tdvp, &dst_attr_vp, &tond->ni_cnd, NULL,
-                                               0, ctx);
+                                   tdvp, &dst_attr_vp, &tond->ni_cnd, NULL,
+                                   0, ctx);

                        } else {
                        } else {

-                               error = VNOP_RENAME(fdvp, src_attr_vp, &fromnd->ni_cnd, 
-                                               tdvp, dst_attr_vp, &tond->ni_cnd, ctx);
+                               error = VNOP_RENAME(fdvp, src_attr_vp, &fromnd->ni_cnd,
+                                   tdvp, dst_attr_vp, &tond->ni_cnd, ctx);

                        }
 
                        if (error == 0 && old_name == src_attr_vp->v_name &&
                        }
 
                        if (error == 0 && old_name == src_attr_vp->v_name &&

-                                       old_parent == src_attr_vp->v_parent) {
+                           old_parent == src_attr_vp->v_parent) {

                                int update_flags = VNODE_UPDATE_NAME;
                                int update_flags = VNODE_UPDATE_NAME;

-                               
-                               if (fdvp != tdvp)
+
+                               if (fdvp != tdvp) {

                                        update_flags |= VNODE_UPDATE_PARENT;
                                        update_flags |= VNODE_UPDATE_PARENT;

-                               
+                               }
+

                                if ((src_attr_vp->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFSVNOP_NOUPDATEID_RENAME) == 0) {
                                        vnode_update_identity(src_attr_vp, tdvp,
                                if ((src_attr_vp->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFSVNOP_NOUPDATEID_RENAME) == 0) {
                                        vnode_update_identity(src_attr_vp, tdvp,

-                                               tond->ni_cnd.cn_nameptr,
-                                               tond->ni_cnd.cn_namelen,
-                                               tond->ni_cnd.cn_hash,
-                                               update_flags);
+                                           tond->ni_cnd.cn_nameptr,
+                                           tond->ni_cnd.cn_namelen,
+                                           tond->ni_cnd.cn_hash,
+                                           update_flags);

                                }
                        }
                                }
                        }

-                       
-                       /* kevent notifications for moving resource files 
+
+                       /* kevent notifications for moving resource files

                         * _err is zero if we're here, so no need to notify directories, code
                         * below will do that.  only need to post the rename on the source and
                         * possibly a delete on the dest
                         */
                        post_event_if_success(src_attr_vp, error, NOTE_RENAME);
                        if (dst_attr_vp) {
                         * _err is zero if we're here, so no need to notify directories, code
                         * below will do that.  only need to post the rename on the source and
                         * possibly a delete on the dest
                         */
                        post_event_if_success(src_attr_vp, error, NOTE_RENAME);
                        if (dst_attr_vp) {

-                               post_event_if_success(dst_attr_vp, error, NOTE_DELETE); 
+                               post_event_if_success(dst_attr_vp, error, NOTE_DELETE);

                        }
                        }

-

                } else if (dst_attr_vp) {
                        /*
                         * Just delete destination attribute file vnode if it exists, since
                } else if (dst_attr_vp) {
                        /*
                         * Just delete destination attribute file vnode if it exists, since


@@ -3975,7 +4344,7 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
                         */
 
                        struct vnop_remove_args args;
                         */
 
                        struct vnop_remove_args args;

-                       
+

                        args.a_desc    = &vnop_remove_desc;
                        args.a_dvp     = tdvp;
                        args.a_vp      = dst_attr_vp;
                        args.a_desc    = &vnop_remove_desc;
                        args.a_dvp     = tdvp;
                        args.a_vp      = dst_attr_vp;


@@ -3985,15 +4354,16 @@ vn_rename(struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, s
                        if (error == 0) {
                                error = (*tdvp->v_op[vnop_remove_desc.vdesc_offset])(&args);
 
                        if (error == 0) {
                                error = (*tdvp->v_op[vnop_remove_desc.vdesc_offset])(&args);
 

-                               if (error == 0)
+                               if (error == 0) {

                                        vnode_setneedinactive(dst_attr_vp);
                                        vnode_setneedinactive(dst_attr_vp);

+                               }

                        }
                        }

-                       
+

                        /* kevent notification for deleting the destination's attribute file
                         * if it existed.  Only need to post the delete on the destination, since
                        /* kevent notification for deleting the destination's attribute file
                         * if it existed.  Only need to post the delete on the destination, since

-                        * the code below will handle the directories. 
+                        * the code below will handle the directories.

                         */
                         */

-                       post_event_if_success(dst_attr_vp, error, NOTE_DELETE); 
+                       post_event_if_success(dst_attr_vp, error, NOTE_DELETE);

                }
        }
 ad_error:
                }
        }
 ad_error:


@@ -4024,13 +4394,13 @@ ad_error:
 
 #if 0
 /*
 
 #if 0
 /*

- *#
- *#% rename       fdvp    U U U
- *#% rename       fvp     U U U
- *#% rename       tdvp    L U U
- *#% rename       tvp     X U U
- *#
- */
+*#
+*#% rename       fdvp    U U U
+*#% rename       fvp     U U U
+*#% rename       tdvp    L U U
+*#% rename       tvp     X U U
+*#
+*/

 struct vnop_rename_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_fdvp;
 struct vnop_rename_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_fdvp;


@@ -4044,11 +4414,10 @@ struct vnop_rename_args {
 #endif /* 0*/
 errno_t
 VNOP_RENAME(struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp,
 #endif /* 0*/
 errno_t
 VNOP_RENAME(struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp,

-            struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp,
-            vfs_context_t ctx)
+    struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp,
+    vfs_context_t ctx)

 {
        int _err = 0;
 {
        int _err = 0;

-       int events;

        struct vnop_rename_args a;
 
        a.a_desc = &vnop_rename_desc;
        struct vnop_rename_args a;
 
        a.a_desc = &vnop_rename_desc;


@@ -4064,46 +4433,103 @@ VNOP_RENAME(struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp,
        _err = (*fdvp->v_op[vnop_rename_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(rename, vnode_t, fdvp);
 
        _err = (*fdvp->v_op[vnop_rename_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(rename, vnode_t, fdvp);
 

-       if (_err == 0) {
-               if (tvp && tvp != fvp)
-                       vnode_setneedinactive(tvp);
+       if (_err) {
+               return _err;
+       }
+
+       return post_rename(fdvp, fvp, tdvp, tvp);
+}
+
+static errno_t
+post_rename(vnode_t fdvp, vnode_t fvp, vnode_t tdvp, vnode_t tvp)
+{
+       if (tvp && tvp != fvp) {
+               vnode_setneedinactive(tvp);

        }
 
        /* Wrote at least one directory.  If transplanted a dir, also changed link counts */
        }
 
        /* Wrote at least one directory.  If transplanted a dir, also changed link counts */

-       if (_err == 0) {
-               events = NOTE_WRITE;
-               if (vnode_isdir(fvp)) {
-                       /* Link count on dir changed only if we are moving a dir and...
-                        *      --Moved to new dir, not overwriting there
-                        *      --Kept in same dir and DID overwrite
-                        */
-                       if (((fdvp != tdvp) && (!tvp)) || ((fdvp == tdvp) && (tvp))) {
-                               events |= NOTE_LINK;
-                       }
+       int events = NOTE_WRITE;
+       if (vnode_isdir(fvp)) {
+               /* Link count on dir changed only if we are moving a dir and...
+                *      --Moved to new dir, not overwriting there
+                *      --Kept in same dir and DID overwrite
+                */
+               if (((fdvp != tdvp) && (!tvp)) || ((fdvp == tdvp) && (tvp))) {
+                       events |= NOTE_LINK;

                }
                }

+       }

 
 

-               lock_vnode_and_post(fdvp, events);
-               if (fdvp != tdvp) {
-                       lock_vnode_and_post(tdvp,  events);
-               }
+       lock_vnode_and_post(fdvp, events);
+       if (fdvp != tdvp) {
+               lock_vnode_and_post(tdvp, events);
+       }

 
 

-               /* If you're replacing the target, post a deletion for it */
-               if (tvp)
-               {
-                       lock_vnode_and_post(tvp, NOTE_DELETE);
-               }
+       /* If you're replacing the target, post a deletion for it */
+       if (tvp) {
+               lock_vnode_and_post(tvp, NOTE_DELETE);
+       }
+
+       lock_vnode_and_post(fvp, NOTE_RENAME);
+
+       return 0;
+}
+
+#if 0
+/*
+*#
+*#% renamex      fdvp    U U U
+*#% renamex      fvp     U U U
+*#% renamex      tdvp    L U U
+*#% renamex      tvp     X U U
+*#
+*/
+struct vnop_renamex_args {
+       struct vnodeop_desc *a_desc;
+       vnode_t a_fdvp;
+       vnode_t a_fvp;
+       struct componentname *a_fcnp;
+       vnode_t a_tdvp;
+       vnode_t a_tvp;
+       struct componentname *a_tcnp;
+       vfs_rename_flags_t a_flags;
+       vfs_context_t a_context;
+};
+#endif /* 0*/
+errno_t
+VNOP_RENAMEX(struct vnode *fdvp, struct vnode *fvp, struct componentname *fcnp,
+    struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp,
+    vfs_rename_flags_t flags, vfs_context_t ctx)
+{
+       int _err = 0;
+       struct vnop_renamex_args a;
+
+       a.a_desc = &vnop_renamex_desc;
+       a.a_fdvp = fdvp;
+       a.a_fvp = fvp;
+       a.a_fcnp = fcnp;
+       a.a_tdvp = tdvp;
+       a.a_tvp = tvp;
+       a.a_tcnp = tcnp;
+       a.a_flags = flags;
+       a.a_context = ctx;
+
+       /* do the rename of the main file. */
+       _err = (*fdvp->v_op[vnop_renamex_desc.vdesc_offset])(&a);
+       DTRACE_FSINFO(renamex, vnode_t, fdvp);

 
 

-               lock_vnode_and_post(fvp, NOTE_RENAME);
+       if (_err) {
+               return _err;

        }
 
        }
 

-       return (_err);
+       return post_rename(fdvp, fvp, tdvp, tvp);

 }
 
 }
 

+

 int
 int

-VNOP_COMPOUND_RENAME( 
-               struct vnode *fdvp,  struct vnode **fvpp,  struct componentname *fcnp, struct vnode_attr *fvap,
-               struct vnode *tdvp,  struct vnode **tvpp,  struct componentname *tcnp, struct vnode_attr *tvap,  
-               uint32_t flags, vfs_context_t ctx)
+VNOP_COMPOUND_RENAME(
+       struct vnode *fdvp, struct vnode **fvpp, struct componentname *fcnp, struct vnode_attr *fvap,
+       struct vnode *tdvp, struct vnode **tvpp, struct componentname *tcnp, struct vnode_attr *tvap,
+       uint32_t flags, vfs_context_t ctx)

 {
        int _err = 0;
        int events;
 {
        int _err = 0;
        int events;


@@ -4114,7 +4540,7 @@ VNOP_COMPOUND_RENAME(
        no_tvp = (*tvpp) == NULLVP;
 
        a.a_desc = &vnop_compound_rename_desc;
        no_tvp = (*tvpp) == NULLVP;
 
        a.a_desc = &vnop_compound_rename_desc;

-       
+

        a.a_fdvp = fdvp;
        a.a_fvpp = fvpp;
        a.a_fcnp = fcnp;
        a.a_fdvp = fdvp;
        a.a_fvpp = fvpp;
        a.a_fcnp = fcnp;


@@ -4124,7 +4550,7 @@ VNOP_COMPOUND_RENAME(
        a.a_tvpp = tvpp;
        a.a_tcnp = tcnp;
        a.a_tvap = tvap;
        a.a_tvpp = tvpp;
        a.a_tcnp = tcnp;
        a.a_tvap = tvap;

-       
+

        a.a_flags = flags;
        a.a_context = ctx;
        a.a_rename_authorizer = vn_authorize_rename;
        a.a_flags = flags;
        a.a_context = ctx;
        a.a_rename_authorizer = vn_authorize_rename;


@@ -4135,8 +4561,9 @@ VNOP_COMPOUND_RENAME(
        DTRACE_FSINFO(compound_rename, vnode_t, fdvp);
 
        if (_err == 0) {
        DTRACE_FSINFO(compound_rename, vnode_t, fdvp);
 
        if (_err == 0) {

-               if (*tvpp && *tvpp != *fvpp)
-                       vnode_setneedinactive(*tvpp);
+               if (*tvpp && *tvpp != *fvpp) {
+                       vnode_setneedinactive(*tvpp);
+               }

        }
 
        /* Wrote at least one directory.  If transplanted a dir, also changed link counts */
        }
 
        /* Wrote at least one directory.  If transplanted a dir, also changed link counts */


@@ -4148,8 +4575,8 @@ VNOP_COMPOUND_RENAME(
                events = NOTE_WRITE;
                if (vnode_isdir(*fvpp)) {
                        /* Link count on dir changed only if we are moving a dir and...
                events = NOTE_WRITE;
                if (vnode_isdir(*fvpp)) {
                        /* Link count on dir changed only if we are moving a dir and...

-                        *      --Moved to new dir, not overwriting there
-                        *      --Kept in same dir and DID overwrite
+                        *      --Moved to new dir, not overwriting there
+                        *      --Kept in same dir and DID overwrite

                         */
                        if (((fdvp != tdvp) && (!*tvpp)) || ((fdvp == tdvp) && (*tvpp))) {
                                events |= NOTE_LINK;
                         */
                        if (((fdvp != tdvp) && (!*tvpp)) || ((fdvp == tdvp) && (*tvpp))) {
                                events |= NOTE_LINK;


@@ -4158,12 +4585,11 @@ VNOP_COMPOUND_RENAME(
 
                lock_vnode_and_post(fdvp, events);
                if (fdvp != tdvp) {
 
                lock_vnode_and_post(fdvp, events);
                if (fdvp != tdvp) {

-                       lock_vnode_and_post(tdvp,  events);
+                       lock_vnode_and_post(tdvp, events);

                }
 
                /* If you're replacing the target, post a deletion for it */
                }
 
                /* If you're replacing the target, post a deletion for it */

-               if (*tvpp)
-               {
+               if (*tvpp) {

                        lock_vnode_and_post(*tvpp, NOTE_DELETE);
                }
 
                        lock_vnode_and_post(*tvpp, NOTE_DELETE);
                }
 


@@ -4171,7 +4597,7 @@ VNOP_COMPOUND_RENAME(
        }
 
        if (no_fvp) {
        }
 
        if (no_fvp) {

-               lookup_compound_vnop_post_hook(_err, fdvp, *fvpp, fcnp->cn_ndp, 0); 
+               lookup_compound_vnop_post_hook(_err, fdvp, *fvpp, fcnp->cn_ndp, 0);

        }
        if (no_tvp && *tvpp != NULLVP) {
                lookup_compound_vnop_post_hook(_err, tdvp, *tvpp, tcnp->cn_ndp, 0);
        }
        if (no_tvp && *tvpp != NULLVP) {
                lookup_compound_vnop_post_hook(_err, tdvp, *tvpp, tcnp->cn_ndp, 0);


@@ -4188,12 +4614,12 @@ VNOP_COMPOUND_RENAME(
                }
        }
 
                }
        }
 

-       return (_err);
+       return _err;

 }
 
 int
 vn_mkdir(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,
 }
 
 int
 vn_mkdir(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,

-           struct vnode_attr *vap, vfs_context_t ctx)
+    struct vnode_attr *vap, vfs_context_t ctx)

 {
        if (ndp->ni_cnd.cn_nameiop != CREATE) {
                panic("Non-CREATE nameiop in vn_mkdir()?");
 {
        if (ndp->ni_cnd.cn_nameiop != CREATE) {
                panic("Non-CREATE nameiop in vn_mkdir()?");


@@ -4208,78 +4634,78 @@ vn_mkdir(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,
 
 #if 0
 /*
 
 #if 0
 /*

- *#
- *#% mkdir        dvp     L U U
- *#% mkdir        vpp     - L -
- *#
- */
+*#
+*#% mkdir        dvp     L U U
+*#% mkdir        vpp     - L -
+*#
+*/

 struct vnop_mkdir_args {
 struct vnop_mkdir_args {

-       struct vnodeop_desc *a_desc;
-       vnode_t a_dvp;
-       vnode_t *a_vpp;
-       struct componentname *a_cnp;
-       struct vnode_attr *a_vap;
-       vfs_context_t a_context;
+       struct vnodeop_desc *a_desc;
+       vnode_t a_dvp;
+       vnode_t *a_vpp;
+       struct componentname *a_cnp;
+       struct vnode_attr *a_vap;
+       vfs_context_t a_context;

 };
 #endif /* 0*/
 errno_t
 VNOP_MKDIR(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
 };
 #endif /* 0*/
 errno_t
 VNOP_MKDIR(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,

-           struct vnode_attr *vap, vfs_context_t ctx)
+    struct vnode_attr *vap, vfs_context_t ctx)

 {
 {

-       int _err;
-       struct vnop_mkdir_args a;
+       int _err;
+       struct vnop_mkdir_args a;

 
 

-       a.a_desc = &vnop_mkdir_desc;
-       a.a_dvp = dvp;
-       a.a_vpp = vpp;
-       a.a_cnp = cnp;
-       a.a_vap = vap;
-       a.a_context = ctx;
+       a.a_desc = &vnop_mkdir_desc;
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       a.a_context = ctx;

 
 

-       _err = (*dvp->v_op[vnop_mkdir_desc.vdesc_offset])(&a);
+       _err = (*dvp->v_op[vnop_mkdir_desc.vdesc_offset])(&a);

        if (_err == 0 && *vpp) {
                DTRACE_FSINFO(mkdir, vnode_t, *vpp);
        }
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {
        if (_err == 0 && *vpp) {
                DTRACE_FSINFO(mkdir, vnode_t, *vpp);
        }
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {

-               /* 
+               /*

                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);
        }
 #endif /* CONFIG_APPLEDOUBLE */
 
                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);
        }
 #endif /* CONFIG_APPLEDOUBLE */
 

-       post_event_if_success(dvp, _err, NOTE_LINK | NOTE_WRITE);
+       post_event_if_success(dvp, _err, NOTE_LINK | NOTE_WRITE);

 
 

-       return (_err);
+       return _err;

 }
 
 int
 VNOP_COMPOUND_MKDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,
 }
 
 int
 VNOP_COMPOUND_MKDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,

-           struct vnode_attr *vap, vfs_context_t ctx)
-{
-       int _err;
-       struct vnop_compound_mkdir_args a;
-
-       a.a_desc = &vnop_compound_mkdir_desc;
-       a.a_dvp = dvp;
-       a.a_vpp = vpp;
-       a.a_cnp = &ndp->ni_cnd;
-       a.a_vap = vap;
-       a.a_flags = 0;
-       a.a_context = ctx;
+    struct vnode_attr *vap, vfs_context_t ctx)
+{
+       int _err;
+       struct vnop_compound_mkdir_args a;
+
+       a.a_desc = &vnop_compound_mkdir_desc;
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = &ndp->ni_cnd;
+       a.a_vap = vap;
+       a.a_flags = 0;
+       a.a_context = ctx;

 #if 0
 #if 0

-       a.a_mkdir_authorizer = vn_authorize_mkdir;
+       a.a_mkdir_authorizer = vn_authorize_mkdir;

 #endif /* 0 */
 #endif /* 0 */

-       a.a_reserved = NULL;
+       a.a_reserved = NULL;

 
 

-       _err = (*dvp->v_op[vnop_compound_mkdir_desc.vdesc_offset])(&a);
+       _err = (*dvp->v_op[vnop_compound_mkdir_desc.vdesc_offset])(&a);

        if (_err == 0 && *vpp) {
                DTRACE_FSINFO(compound_mkdir, vnode_t, *vpp);
        }
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {
        if (_err == 0 && *vpp) {
                DTRACE_FSINFO(compound_mkdir, vnode_t, *vpp);
        }
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {

-               /* 
+               /*

                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, ndp->ni_cnd.cn_nameptr, ctx, 0);
                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, ndp->ni_cnd.cn_nameptr, ctx, 0);


@@ -4294,7 +4720,7 @@ VNOP_COMPOUND_MKDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp
                *vpp = NULLVP;
        }
 
                *vpp = NULLVP;
        }
 

-       return (_err);
+       return _err;

 }
 
 int
 }
 
 int


@@ -4315,11 +4741,11 @@ vn_rmdir(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, struct vnode_attr *va
 
 #if 0
 /*
 
 #if 0
 /*

- *#
- *#% rmdir        dvp     L U U
- *#% rmdir        vp      L U U
- *#
- */
+*#
+*#% rmdir        dvp     L U U
+*#% rmdir        vp      L U U
+*#
+*/

 struct vnop_rmdir_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;
 struct vnop_rmdir_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_dvp;


@@ -4345,13 +4771,13 @@ VNOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, vfs_c
        DTRACE_FSINFO(rmdir, vnode_t, vp);
 
        if (_err == 0) {
        DTRACE_FSINFO(rmdir, vnode_t, vp);
 
        if (_err == 0) {

-               vnode_setneedinactive(vp);
+               vnode_setneedinactive(vp);

 #if CONFIG_APPLEDOUBLE
 #if CONFIG_APPLEDOUBLE

-               if ( !(NATIVE_XATTR(dvp)) ) {
-                       /* 
+               if (!(NATIVE_XATTR(dvp))) {
+                       /*

                         * Remove any associated extended attribute file (._ AppleDouble file).
                         */
                         * Remove any associated extended attribute file (._ AppleDouble file).
                         */

-                       xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 1);
+                       xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 1);

                }
 #endif
        }
                }
 #endif
        }


@@ -4360,36 +4786,36 @@ VNOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, vfs_c
        post_event_if_success(vp, _err, NOTE_DELETE | NOTE_LINK);
        post_event_if_success(dvp, _err, NOTE_LINK | NOTE_WRITE);
 
        post_event_if_success(vp, _err, NOTE_DELETE | NOTE_LINK);
        post_event_if_success(dvp, _err, NOTE_LINK | NOTE_WRITE);
 

-       return (_err);
+       return _err;

 }
 
 int
 VNOP_COMPOUND_RMDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,
 }
 
 int
 VNOP_COMPOUND_RMDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp,

-           struct vnode_attr *vap, vfs_context_t ctx)
+    struct vnode_attr *vap, vfs_context_t ctx)

 {
 {

-       int _err;
-       struct vnop_compound_rmdir_args a;
-       int no_vp;
+       int _err;
+       struct vnop_compound_rmdir_args a;
+       int no_vp;

 
 

-       a.a_desc = &vnop_mkdir_desc;
-       a.a_dvp = dvp;
-       a.a_vpp = vpp;
-       a.a_cnp = &ndp->ni_cnd;
-       a.a_vap = vap;
-       a.a_flags = 0;
-       a.a_context = ctx;
-       a.a_rmdir_authorizer = vn_authorize_rmdir;
-       a.a_reserved = NULL;
+       a.a_desc = &vnop_mkdir_desc;
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = &ndp->ni_cnd;
+       a.a_vap = vap;
+       a.a_flags = 0;
+       a.a_context = ctx;
+       a.a_rmdir_authorizer = vn_authorize_rmdir;
+       a.a_reserved = NULL;

 
 

-       no_vp = (*vpp == NULLVP);
+       no_vp = (*vpp == NULLVP);

 
 

-       _err = (*dvp->v_op[vnop_compound_rmdir_desc.vdesc_offset])(&a);
+       _err = (*dvp->v_op[vnop_compound_rmdir_desc.vdesc_offset])(&a);

        if (_err == 0 && *vpp) {
                DTRACE_FSINFO(compound_rmdir, vnode_t, *vpp);
        }
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {
        if (_err == 0 && *vpp) {
                DTRACE_FSINFO(compound_rmdir, vnode_t, *vpp);
        }
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {

-               /* 
+               /*

                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, ndp->ni_cnd.cn_nameptr, ctx, 0);
                 * Remove stale Apple Double file (if any).
                 */
                xattrfile_remove(dvp, ndp->ni_cnd.cn_nameptr, ctx, 0);


@@ -4401,18 +4827,18 @@ VNOP_COMPOUND_RMDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp
        }
        post_event_if_success(dvp, _err, NOTE_LINK | NOTE_WRITE);
 
        }
        post_event_if_success(dvp, _err, NOTE_LINK | NOTE_WRITE);
 

-       if (no_vp) {
-              lookup_compound_vnop_post_hook(_err, dvp, *vpp, ndp, 0);
+       if (no_vp) {
+               lookup_compound_vnop_post_hook(_err, dvp, *vpp, ndp, 0);

 
 #if 0 /* Removing orphaned ._ files requires a vp.... */
 
 #if 0 /* Removing orphaned ._ files requires a vp.... */

-              if (*vpp && _err && _err != EKEEPLOOKING) {
-                      vnode_put(*vpp);
-                      *vpp = NULLVP;
-              }
+               if (*vpp && _err && _err != EKEEPLOOKING) {
+                       vnode_put(*vpp);
+                       *vpp = NULLVP;
+               }

 #endif  /* 0 */
 #endif  /* 0 */

-       }
+       }

 
 

-       return (_err);
+       return _err;

 }
 
 #if CONFIG_APPLEDOUBLE
 }
 
 #if CONFIG_APPLEDOUBLE


@@ -4421,7 +4847,7 @@ VNOP_COMPOUND_RMDIR(struct vnode *dvp, struct vnode **vpp, struct nameidata *ndp
  */
 #define AD_STALE_SECS  (180)
 static void
  */
 #define AD_STALE_SECS  (180)
 static void

-xattrfile_remove(vnode_t dvp, const char * basename, vfs_context_t ctx, int force) 
+xattrfile_remove(vnode_t dvp, const char * basename, vfs_context_t ctx, int force)

 {
        vnode_t xvp;
        struct nameidata nd;
 {
        vnode_t xvp;
        struct nameidata nd;


@@ -4441,15 +4867,17 @@ xattrfile_remove(vnode_t dvp, const char * basename, vfs_context_t ctx, int forc
                len = snprintf(filename, len, "._%s", basename);
        }
        NDINIT(&nd, DELETE, OP_UNLINK, WANTPARENT | LOCKLEAF | NOFOLLOW | USEDVP, UIO_SYSSPACE,
                len = snprintf(filename, len, "._%s", basename);
        }
        NDINIT(&nd, DELETE, OP_UNLINK, WANTPARENT | LOCKLEAF | NOFOLLOW | USEDVP, UIO_SYSSPACE,

-              CAST_USER_ADDR_T(filename), ctx);
+           CAST_USER_ADDR_T(filename), ctx);

        nd.ni_dvp = dvp;
        nd.ni_dvp = dvp;

-       if (namei(&nd) != 0)
+       if (namei(&nd) != 0) {

                goto out2;
                goto out2;

+       }

 
        xvp = nd.ni_vp;
        nameidone(&nd);
 
        xvp = nd.ni_vp;
        nameidone(&nd);

-       if (xvp->v_type != VREG)
+       if (xvp->v_type != VREG) {

                goto out1;
                goto out1;

+       }

 
        /*
         * When creating a new object and a "._" file already
 
        /*
         * When creating a new object and a "._" file already


@@ -4462,9 +4890,9 @@ xattrfile_remove(vnode_t dvp, const char * basename, vfs_context_t ctx, int forc
                VATTR_INIT(&va);
                VATTR_WANTED(&va, va_data_size);
                VATTR_WANTED(&va, va_modify_time);
                VATTR_INIT(&va);
                VATTR_WANTED(&va, va_data_size);
                VATTR_WANTED(&va, va_modify_time);

-               if (VNOP_GETATTR(xvp, &va, ctx) == 0  &&
-                   VATTR_IS_SUPPORTED(&va, va_data_size)  &&
-                   VATTR_IS_SUPPORTED(&va, va_modify_time)  &&
+               if (VNOP_GETATTR(xvp, &va, ctx) == 0 &&
+                   VATTR_IS_SUPPORTED(&va, va_data_size) &&
+                   VATTR_IS_SUPPORTED(&va, va_modify_time) &&

                    va.va_data_size != 0) {
                        struct timeval tv;
 
                    va.va_data_size != 0) {
                        struct timeval tv;
 


@@ -4477,16 +4905,17 @@ xattrfile_remove(vnode_t dvp, const char * basename, vfs_context_t ctx, int forc
        }
        if (force) {
                int  error;
        }
        if (force) {
                int  error;

-       
+

                error = VNOP_REMOVE(dvp, xvp, &nd.ni_cnd, 0, ctx);
                error = VNOP_REMOVE(dvp, xvp, &nd.ni_cnd, 0, ctx);

-               if (error == 0)
+               if (error == 0) {

                        vnode_setneedinactive(xvp);
                        vnode_setneedinactive(xvp);

+               }

 
                post_event_if_success(xvp, error, NOTE_DELETE);
                post_event_if_success(dvp, error, NOTE_WRITE);
        }
 
 
                post_event_if_success(xvp, error, NOTE_DELETE);
                post_event_if_success(dvp, error, NOTE_WRITE);
        }
 

-out1:          
+out1:

        vnode_put(dvp);
        vnode_put(xvp);
 out2:
        vnode_put(dvp);
        vnode_put(xvp);
 out2:


@@ -4500,7 +4929,7 @@ out2:
  */
 static void
 xattrfile_setattr(vnode_t dvp, const char * basename, struct vnode_attr * vap,
  */
 static void
 xattrfile_setattr(vnode_t dvp, const char * basename, struct vnode_attr * vap,

-                  vfs_context_t ctx) 
+    vfs_context_t ctx)

 {
        vnode_t xvp;
        struct nameidata nd;
 {
        vnode_t xvp;
        struct nameidata nd;


@@ -4521,10 +4950,11 @@ xattrfile_setattr(vnode_t dvp, const char * basename, struct vnode_attr * vap,
                len = snprintf(filename, len, "._%s", basename);
        }
        NDINIT(&nd, LOOKUP, OP_SETATTR, NOFOLLOW | USEDVP, UIO_SYSSPACE,
                len = snprintf(filename, len, "._%s", basename);
        }
        NDINIT(&nd, LOOKUP, OP_SETATTR, NOFOLLOW | USEDVP, UIO_SYSSPACE,

-              CAST_USER_ADDR_T(filename), ctx);
+           CAST_USER_ADDR_T(filename), ctx);

        nd.ni_dvp = dvp;
        nd.ni_dvp = dvp;

-       if (namei(&nd) != 0)
+       if (namei(&nd) != 0) {

                goto out2;
                goto out2;

+       }

 
        xvp = nd.ni_vp;
        nameidone(&nd);
 
        xvp = nd.ni_vp;
        nameidone(&nd);


@@ -4550,42 +4980,42 @@ out2:
 
  #if 0
 /*
 
  #if 0
 /*

- *#
- *#% symlink      dvp     L U U
- *#% symlink      vpp     - U -
- *#
- */
+*#
+*#% symlink      dvp     L U U
+*#% symlink      vpp     - U -
+*#
+*/

 struct vnop_symlink_args {
 struct vnop_symlink_args {

-       struct vnodeop_desc *a_desc;
-       vnode_t a_dvp;
-       vnode_t *a_vpp;
-       struct componentname *a_cnp;
-       struct vnode_attr *a_vap;
-       char *a_target;
-       vfs_context_t a_context;
+       struct vnodeop_desc *a_desc;
+       vnode_t a_dvp;
+       vnode_t *a_vpp;
+       struct componentname *a_cnp;
+       struct vnode_attr *a_vap;
+       char *a_target;
+       vfs_context_t a_context;

 };
 
 #endif /* 0*/
 errno_t
 VNOP_SYMLINK(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
 };
 
 #endif /* 0*/
 errno_t
 VNOP_SYMLINK(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,

-             struct vnode_attr *vap, char *target, vfs_context_t ctx)
+    struct vnode_attr *vap, char *target, vfs_context_t ctx)

 {
 {

-       int _err;
-       struct vnop_symlink_args a;
+       int _err;
+       struct vnop_symlink_args a;

 
 

-       a.a_desc = &vnop_symlink_desc;
-       a.a_dvp = dvp;
-       a.a_vpp = vpp;
-       a.a_cnp = cnp;
-       a.a_vap = vap;
-       a.a_target = target;
-       a.a_context = ctx;
+       a.a_desc = &vnop_symlink_desc;
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       a.a_target = target;
+       a.a_context = ctx;

 
 

-       _err = (*dvp->v_op[vnop_symlink_desc.vdesc_offset])(&a);   
+       _err = (*dvp->v_op[vnop_symlink_desc.vdesc_offset])(&a);

        DTRACE_FSINFO(symlink, vnode_t, dvp);
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {
        DTRACE_FSINFO(symlink, vnode_t, dvp);
 #if CONFIG_APPLEDOUBLE
        if (_err == 0 && !NATIVE_XATTR(dvp)) {

-               /* 
+               /*

                 * Remove stale Apple Double file (if any).  Posts its own knotes
                 */
                xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);
                 * Remove stale Apple Double file (if any).  Posts its own knotes
                 */
                xattrfile_remove(dvp, cnp->cn_nameptr, ctx, 0);


@@ -4594,15 +5024,15 @@ VNOP_SYMLINK(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
 
        post_event_if_success(dvp, _err, NOTE_WRITE);
 
 
        post_event_if_success(dvp, _err, NOTE_WRITE);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% readdir      vp      L L L
- *#
- */
+*#
+*#% readdir      vp      L L L
+*#
+*/

 struct vnop_readdir_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_readdir_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4614,9 +5044,9 @@ struct vnop_readdir_args {
 };
 
 #endif /* 0*/
 };
 
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_READDIR(struct vnode *vp, struct uio *uio, int flags, int *eofflag,
 VNOP_READDIR(struct vnode *vp, struct uio *uio, int flags, int *eofflag,

-             int *numdirent, vfs_context_t ctx)
+    int *numdirent, vfs_context_t ctx)

 {
        int _err;
        struct vnop_readdir_args a;
 {
        int _err;
        struct vnop_readdir_args a;


@@ -4636,15 +5066,15 @@ VNOP_READDIR(struct vnode *vp, struct uio *uio, int flags, int *eofflag,
        DTRACE_FSINFO_IO(readdir,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 
        DTRACE_FSINFO_IO(readdir,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% readdirattr  vp      L L L
- *#
- */
+*#
+*#% readdirattr  vp      L L L
+*#
+*/

 struct vnop_readdirattr_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_readdirattr_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4659,9 +5089,9 @@ struct vnop_readdirattr_args {
 };
 
 #endif /* 0*/
 };
 
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_READDIRATTR(struct vnode *vp, struct attrlist *alist, struct uio *uio, uint32_t maxcount,
 VNOP_READDIRATTR(struct vnode *vp, struct attrlist *alist, struct uio *uio, uint32_t maxcount,

-                 uint32_t options, uint32_t *newstate, int *eofflag, uint32_t *actualcount, vfs_context_t ctx)
+    uint32_t options, uint32_t *newstate, int *eofflag, uint32_t *actualcount, vfs_context_t ctx)

 {
        int _err;
        struct vnop_readdirattr_args a;
 {
        int _err;
        struct vnop_readdirattr_args a;


@@ -4684,7 +5114,7 @@ VNOP_READDIRATTR(struct vnode *vp, struct attrlist *alist, struct uio *uio, uint
        DTRACE_FSINFO_IO(readdirattr,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 
        DTRACE_FSINFO_IO(readdirattr,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -4727,15 +5157,15 @@ VNOP_GETATTRLISTBULK(struct vnode *vp, struct attrlist *alist,
        DTRACE_FSINFO_IO(getattrlistbulk,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 
        DTRACE_FSINFO_IO(getattrlistbulk,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% readlink     vp      L L L
- *#
- */
+*#
+*#% readlink     vp      L L L
+*#
+*/

 struct vnop_readlink_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_readlink_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4763,7 +5193,7 @@ struct vnop_readlink_args {
  *             additional error code which may be propagated from underlying
  *             routines.
  */
  *             additional error code which may be propagated from underlying
  *             routines.
  */

-errno_t 
+errno_t

 VNOP_READLINK(struct vnode *vp, struct uio *uio, vfs_context_t ctx)
 {
        int _err;
 VNOP_READLINK(struct vnode *vp, struct uio *uio, vfs_context_t ctx)
 {
        int _err;


@@ -4780,22 +5210,22 @@ VNOP_READLINK(struct vnode *vp, struct uio *uio, vfs_context_t ctx)
        DTRACE_FSINFO_IO(readlink,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 
        DTRACE_FSINFO_IO(readlink,
            vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% inactive     vp      L U U
- *#
- */
+*#
+*#% inactive     vp      L U U
+*#
+*/

 struct vnop_inactive_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
        vfs_context_t a_context;
 };
 #endif /* 0*/
 struct vnop_inactive_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_INACTIVE(struct vnode *vp, vfs_context_t ctx)
 {
        int _err;
 VNOP_INACTIVE(struct vnode *vp, vfs_context_t ctx)
 {
        int _err;


@@ -4804,14 +5234,14 @@ VNOP_INACTIVE(struct vnode *vp, vfs_context_t ctx)
        a.a_desc = &vnop_inactive_desc;
        a.a_vp = vp;
        a.a_context = ctx;
        a.a_desc = &vnop_inactive_desc;
        a.a_vp = vp;
        a.a_context = ctx;

-       
+

        _err = (*vp->v_op[vnop_inactive_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(inactive, vnode_t, vp);
 
 #if NAMEDSTREAMS
        _err = (*vp->v_op[vnop_inactive_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(inactive, vnode_t, vp);
 
 #if NAMEDSTREAMS

-       /* For file systems that do not support namedstream natively, mark 
-        * the shadow stream file vnode to be recycled as soon as the last 
-        * reference goes away.  To avoid re-entering reclaim code, do not 
+       /* For file systems that do not support namedstream natively, mark
+        * the shadow stream file vnode to be recycled as soon as the last
+        * reference goes away.  To avoid re-entering reclaim code, do not

         * call recycle on terminating namedstream vnodes.
         */
        if (vnode_isnamedstream(vp) &&
         * call recycle on terminating namedstream vnodes.
         */
        if (vnode_isnamedstream(vp) &&


@@ -4822,16 +5252,16 @@ VNOP_INACTIVE(struct vnode *vp, vfs_context_t ctx)
        }
 #endif
 
        }
 #endif
 

-       return (_err);
+       return _err;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% reclaim      vp      U U U
- *#
- */
+*#
+*#% reclaim      vp      U U U
+*#
+*/

 struct vnop_reclaim_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_reclaim_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4851,7 +5281,7 @@ VNOP_RECLAIM(struct vnode *vp, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_reclaim_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(reclaim, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_reclaim_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(reclaim, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 
 }
 
 


@@ -4864,10 +5294,10 @@ VNOP_RECLAIM(struct vnode *vp, vfs_context_t ctx)
  */
 #if 0
 /*
  */
 #if 0
 /*

- *#
- *#% pathconf     vp      L L L
- *#
- */
+*#
+*#% pathconf     vp      L L L
+*#
+*/

 struct vnop_pathconf_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_pathconf_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4876,7 +5306,7 @@ struct vnop_pathconf_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_PATHCONF(struct vnode *vp, int name, int32_t *retval, vfs_context_t ctx)
 {
        int _err;
 VNOP_PATHCONF(struct vnode *vp, int name, int32_t *retval, vfs_context_t ctx)
 {
        int _err;


@@ -4891,7 +5321,7 @@ VNOP_PATHCONF(struct vnode *vp, int name, int32_t *retval, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_pathconf_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(pathconf, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_pathconf_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(pathconf, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 /*
 }
 
 /*


@@ -4907,10 +5337,10 @@ VNOP_PATHCONF(struct vnode *vp, int name, int32_t *retval, vfs_context_t ctx)
  */
 #if 0
 /*
  */
 #if 0
 /*

- *#
- *#% advlock      vp      U U U
- *#
- */
+*#
+*#% advlock      vp      U U U
+*#
+*/

 struct vnop_advlock_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_advlock_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4921,7 +5351,7 @@ struct vnop_advlock_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_ADVLOCK(struct vnode *vp, caddr_t id, int op, struct flock *fl, int flags, vfs_context_t ctx, struct timespec *timeout)
 {
        int _err;
 VNOP_ADVLOCK(struct vnode *vp, caddr_t id, int op, struct flock *fl, int flags, vfs_context_t ctx, struct timespec *timeout)
 {
        int _err;


@@ -4951,19 +5381,22 @@ VNOP_ADVLOCK(struct vnode *vp, caddr_t id, int op, struct flock *fl, int flags,
                        _err = (*vp->v_op[vnop_advlock_desc.vdesc_offset])(&a);
                }
                DTRACE_FSINFO(advlock, vnode_t, vp);
                        _err = (*vp->v_op[vnop_advlock_desc.vdesc_offset])(&a);
                }
                DTRACE_FSINFO(advlock, vnode_t, vp);

+               if (op == F_UNLCK && flags == F_FLOCK) {
+                       post_event_if_success(vp, _err, NOTE_FUNLOCK);
+               }

        }
 
        }
 

-       return (_err);
+       return _err;

 }
 
 
 
 #if 0
 /*
 }
 
 
 
 #if 0
 /*

- *#
- *#% allocate     vp      L L L
- *#
- */
+*#
+*#% allocate     vp      L L L
+*#
+*/

 struct vnop_allocate_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_allocate_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -4975,7 +5408,7 @@ struct vnop_allocate_args {
 };
 
 #endif /* 0*/
 };
 
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_ALLOCATE(struct vnode *vp, off_t length, u_int32_t flags, off_t *bytesallocated, off_t offset, vfs_context_t ctx)
 {
        int _err;
 VNOP_ALLOCATE(struct vnode *vp, off_t length, u_int32_t flags, off_t *bytesallocated, off_t offset, vfs_context_t ctx)
 {
        int _err;


@@ -4997,15 +5430,15 @@ VNOP_ALLOCATE(struct vnode *vp, off_t length, u_int32_t flags, off_t *bytesalloc
        }
 #endif
 
        }
 #endif
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% pagein       vp      = = =
- *#
- */
+*#
+*#% pagein       vp      = = =
+*#
+*/

 struct vnop_pagein_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_pagein_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -5017,7 +5450,7 @@ struct vnop_pagein_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_PAGEIN(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset, size_t size, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_PAGEIN(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset, size_t size, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -5035,15 +5468,15 @@ VNOP_PAGEIN(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset,
        _err = (*vp->v_op[vnop_pagein_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(pagein, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_pagein_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(pagein, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% pageout      vp      = = =
- *#
- */
+*#
+*#% pageout      vp      = = =
+*#
+*/

 struct vnop_pageout_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_pageout_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -5056,7 +5489,7 @@ struct vnop_pageout_args {
 };
 
 #endif /* 0*/
 };
 
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_PAGEOUT(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset, size_t size, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_PAGEOUT(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset, size_t size, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -5076,7 +5509,7 @@ VNOP_PAGEOUT(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset,
 
        post_event_if_success(vp, _err, NOTE_WRITE);
 
 
        post_event_if_success(vp, _err, NOTE_WRITE);
 

-       return (_err);
+       return _err;

 }
 
 int
 }
 
 int


@@ -5093,10 +5526,10 @@ vn_remove(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, int32_t flags, struc
 
 #if 0
 /*
 
 #if 0
 /*

- *#
- *#% searchfs     vp      L L L
- *#
- */
+*#
+*#% searchfs     vp      L L L
+*#
+*/

 struct vnop_searchfs_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_searchfs_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -5115,7 +5548,7 @@ struct vnop_searchfs_args {
 };
 
 #endif /* 0*/
 };
 
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_SEARCHFS(struct vnode *vp, void *searchparams1, void *searchparams2, struct attrlist *searchattrs, uint32_t maxmatches, struct timeval *timelimit, struct attrlist *returnattrs, uint32_t *nummatches, uint32_t scriptcode, uint32_t options, struct uio *uio, struct searchstate *searchstate, vfs_context_t ctx)
 {
        int _err;
 VNOP_SEARCHFS(struct vnode *vp, void *searchparams1, void *searchparams2, struct attrlist *searchattrs, uint32_t maxmatches, struct timeval *timelimit, struct attrlist *returnattrs, uint32_t *nummatches, uint32_t scriptcode, uint32_t options, struct uio *uio, struct searchstate *searchstate, vfs_context_t ctx)
 {
        int _err;


@@ -5139,18 +5572,18 @@ VNOP_SEARCHFS(struct vnode *vp, void *searchparams1, void *searchparams2, struct
        _err = (*vp->v_op[vnop_searchfs_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(searchfs, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_searchfs_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(searchfs, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 #endif /* CONFIG_SEARCHFS */
 
 #if 0
 /*
 }
 #endif /* CONFIG_SEARCHFS */
 
 #if 0
 /*

- *#
- *#% copyfile fvp U U U
- *#% copyfile tdvp L U U
- *#% copyfile tvp X U U
- *#
- */
+*#
+*#% copyfile fvp U U U
+*#% copyfile tdvp L U U
+*#% copyfile tvp X U U
+*#
+*/

 struct vnop_copyfile_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_fvp;
 struct vnop_copyfile_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_fvp;


@@ -5162,9 +5595,9 @@ struct vnop_copyfile_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_COPYFILE(struct vnode *fvp, struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp,
 VNOP_COPYFILE(struct vnode *fvp, struct vnode *tdvp, struct vnode *tvp, struct componentname *tcnp,

-              int mode, int flags, vfs_context_t ctx)
+    int mode, int flags, vfs_context_t ctx)

 {
        int _err;
        struct vnop_copyfile_args a;
 {
        int _err;
        struct vnop_copyfile_args a;


@@ -5178,7 +5611,67 @@ VNOP_COPYFILE(struct vnode *fvp, struct vnode *tdvp, struct vnode *tvp, struct c
        a.a_context = ctx;
        _err = (*fvp->v_op[vnop_copyfile_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(copyfile, vnode_t, fvp);
        a.a_context = ctx;
        _err = (*fvp->v_op[vnop_copyfile_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(copyfile, vnode_t, fvp);

-       return (_err);
+       return _err;
+}
+
+#if 0
+struct vnop_clonefile_args {
+       struct vnodeop_desc *a_desc;
+       vnode_t a_fvp;
+       vnode_t a_dvp;
+       vnode_t *a_vpp;
+       struct componentname *a_cnp;
+       struct vnode_attr *a_vap;
+       uint32_t a_flags;
+       vfs_context_t a_context;
+       int (*a_dir_clone_authorizer)(  /* Authorization callback */
+               struct vnode_attr *vap,         /* attribute to be authorized */
+               kauth_action_t action,         /* action for which attribute is to be authorized */
+               struct vnode_attr *dvap,         /* target directory attributes */
+               vnode_t sdvp,         /* source directory vnode pointer (optional) */
+               mount_t mp,         /* mount point of filesystem */
+               dir_clone_authorizer_op_t vattr_op,         /* specific operation requested : setup, authorization or cleanup  */
+               uint32_t flags;         /* value passed in a_flags to the VNOP */
+               vfs_context_t ctx,                      /* As passed to VNOP */
+               void *reserved);                        /* Always NULL */
+       void *a_reserved;               /* Currently unused */
+};
+#endif /* 0 */
+
+errno_t
+VNOP_CLONEFILE(vnode_t fvp, vnode_t dvp, vnode_t *vpp,
+    struct componentname *cnp, struct vnode_attr *vap, uint32_t flags,
+    vfs_context_t ctx)
+{
+       int _err;
+       struct vnop_clonefile_args a;
+       a.a_desc = &vnop_clonefile_desc;
+       a.a_fvp = fvp;
+       a.a_dvp = dvp;
+       a.a_vpp = vpp;
+       a.a_cnp = cnp;
+       a.a_vap = vap;
+       a.a_flags = flags;
+       a.a_context = ctx;
+
+       if (vnode_vtype(fvp) == VDIR) {
+               a.a_dir_clone_authorizer = vnode_attr_authorize_dir_clone;
+       } else {
+               a.a_dir_clone_authorizer = NULL;
+       }
+
+       _err = (*dvp->v_op[vnop_clonefile_desc.vdesc_offset])(&a);
+
+       if (_err == 0 && *vpp) {
+               DTRACE_FSINFO(clonefile, vnode_t, *vpp);
+               if (kdebug_enable) {
+                       kdebug_lookup(*vpp, cnp);
+               }
+       }
+
+       post_event_if_success(dvp, _err, NOTE_WRITE);
+
+       return _err;

 }
 
 errno_t
 }
 
 errno_t


@@ -5198,7 +5691,7 @@ VNOP_GETXATTR(vnode_t vp, const char *name, uio_t uio, size_t *size, int options
        error = (*vp->v_op[vnop_getxattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(getxattr, vnode_t, vp);
 
        error = (*vp->v_op[vnop_getxattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(getxattr, vnode_t, vp);
 

-       return (error);
+       return error;

 }
 
 errno_t
 }
 
 errno_t


@@ -5217,12 +5710,13 @@ VNOP_SETXATTR(vnode_t vp, const char *name, uio_t uio, int options, vfs_context_
        error = (*vp->v_op[vnop_setxattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(setxattr, vnode_t, vp);
 
        error = (*vp->v_op[vnop_setxattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(setxattr, vnode_t, vp);
 

-       if (error == 0)
-               vnode_uncache_authorized_action(vp, KAUTH_INVALIDATE_CACHED_RIGHTS);
+       if (error == 0) {
+               vnode_uncache_authorized_action(vp, KAUTH_INVALIDATE_CACHED_RIGHTS);
+       }

 
        post_event_if_success(vp, error, NOTE_ATTRIB);
 
 
        post_event_if_success(vp, error, NOTE_ATTRIB);
 

-       return (error);
+       return error;

 }
 
 errno_t
 }
 
 errno_t


@@ -5241,8 +5735,8 @@ VNOP_REMOVEXATTR(vnode_t vp, const char *name, int options, vfs_context_t ctx)
        DTRACE_FSINFO(removexattr, vnode_t, vp);
 
        post_event_if_success(vp, error, NOTE_ATTRIB);
        DTRACE_FSINFO(removexattr, vnode_t, vp);
 
        post_event_if_success(vp, error, NOTE_ATTRIB);

-       
-       return (error);
+
+       return error;

 }
 
 errno_t
 }
 
 errno_t


@@ -5261,16 +5755,16 @@ VNOP_LISTXATTR(vnode_t vp, uio_t uio, size_t *size, int options, vfs_context_t c
        error = (*vp->v_op[vnop_listxattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(listxattr, vnode_t, vp);
 
        error = (*vp->v_op[vnop_listxattr_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(listxattr, vnode_t, vp);
 

-       return (error);
+       return error;

 }
 
 
 #if 0
 /*
 }
 
 
 #if 0
 /*

- *#
- *#% blktooff vp = = =
- *#
- */
+*#
+*#% blktooff vp = = =
+*#
+*/

 struct vnop_blktooff_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_blktooff_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -5278,7 +5772,7 @@ struct vnop_blktooff_args {
        off_t *a_offset;
 };
 #endif /* 0*/
        off_t *a_offset;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_BLKTOOFF(struct vnode *vp, daddr64_t lblkno, off_t *offset)
 {
        int _err;
 VNOP_BLKTOOFF(struct vnode *vp, daddr64_t lblkno, off_t *offset)
 {
        int _err;


@@ -5292,15 +5786,15 @@ VNOP_BLKTOOFF(struct vnode *vp, daddr64_t lblkno, off_t *offset)
        _err = (*vp->v_op[vnop_blktooff_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(blktooff, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_blktooff_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(blktooff, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% offtoblk vp = = =
- *#
- */
+*#
+*#% offtoblk vp = = =
+*#
+*/

 struct vnop_offtoblk_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_offtoblk_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -5308,7 +5802,7 @@ struct vnop_offtoblk_args {
        daddr64_t *a_lblkno;
 };
 #endif /* 0*/
        daddr64_t *a_lblkno;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_OFFTOBLK(struct vnode *vp, off_t offset, daddr64_t *lblkno)
 {
        int _err;
 VNOP_OFFTOBLK(struct vnode *vp, off_t offset, daddr64_t *lblkno)
 {
        int _err;


@@ -5322,15 +5816,15 @@ VNOP_OFFTOBLK(struct vnode *vp, off_t offset, daddr64_t *lblkno)
        _err = (*vp->v_op[vnop_offtoblk_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(offtoblk, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_offtoblk_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(offtoblk, vnode_t, vp);
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 /*
 }
 
 #if 0
 /*

- *#
- *#% blockmap vp L L L
- *#
- */
+*#
+*#% blockmap vp L L L
+*#
+*/

 struct vnop_blockmap_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;
 struct vnop_blockmap_args {
        struct vnodeop_desc *a_desc;
        vnode_t a_vp;


@@ -5343,7 +5837,7 @@ struct vnop_blockmap_args {
        vfs_context_t a_context;
 };
 #endif /* 0*/
        vfs_context_t a_context;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_BLOCKMAP(struct vnode *vp, off_t foffset, size_t size, daddr64_t *bpn, size_t *run, void *poff, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_BLOCKMAP(struct vnode *vp, off_t foffset, size_t size, daddr64_t *bpn, size_t *run, void *poff, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -5382,7 +5876,7 @@ VNOP_BLOCKMAP(struct vnode *vp, off_t foffset, size_t size, daddr64_t *bpn, size
                }
        }
 
                }
        }
 

-       return (_err);
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -5392,7 +5886,7 @@ struct vnop_strategy_args {
 };
 
 #endif /* 0*/
 };
 
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_STRATEGY(struct buf *bp)
 {
        int _err;
 VNOP_STRATEGY(struct buf *bp)
 {
        int _err;


@@ -5402,7 +5896,7 @@ VNOP_STRATEGY(struct buf *bp)
        a.a_bp = bp;
        _err = (*vp->v_op[vnop_strategy_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(strategy, vnode_t, vp);
        a.a_bp = bp;
        _err = (*vp->v_op[vnop_strategy_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(strategy, vnode_t, vp);

-       return (_err);
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -5411,7 +5905,7 @@ struct vnop_bwrite_args {
        buf_t a_bp;
 };
 #endif /* 0*/
        buf_t a_bp;
 };
 #endif /* 0*/

-errno_t 
+errno_t

 VNOP_BWRITE(struct buf *bp)
 {
        int _err;
 VNOP_BWRITE(struct buf *bp)
 {
        int _err;


@@ -5421,7 +5915,7 @@ VNOP_BWRITE(struct buf *bp)
        a.a_bp = bp;
        _err = (*vp->v_op[vnop_bwrite_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(bwrite, vnode_t, vp);
        a.a_bp = bp;
        _err = (*vp->v_op[vnop_bwrite_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(bwrite, vnode_t, vp);

-       return (_err);
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -5445,8 +5939,8 @@ VNOP_KQFILT_ADD(struct vnode *vp, struct knote *kn, vfs_context_t ctx)
 
        _err = (*vp->v_op[vnop_kqfilt_add_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(kqfilt_add, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_kqfilt_add_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(kqfilt_add, vnode_t, vp);

-       
-       return(_err);
+
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -5471,7 +5965,7 @@ VNOP_KQFILT_REMOVE(struct vnode *vp, uintptr_t ident, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_kqfilt_remove_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(kqfilt_remove, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_kqfilt_remove_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(kqfilt_remove, vnode_t, vp);
 

-       return(_err);
+       return _err;

 }
 
 errno_t
 }
 
 errno_t


@@ -5490,7 +5984,7 @@ VNOP_MONITOR(vnode_t vp, uint32_t events, uint32_t flags, void *handle, vfs_cont
        _err = (*vp->v_op[vnop_monitor_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(monitor, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_monitor_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(monitor, vnode_t, vp);
 

-       return(_err);
+       return _err;

 }
 
 #if 0
 }
 
 #if 0


@@ -5515,7 +6009,7 @@ VNOP_SETLABEL(struct vnode *vp, struct label *label, vfs_context_t ctx)
        _err = (*vp->v_op[vnop_setlabel_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(setlabel, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_setlabel_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(setlabel, vnode_t, vp);
 

-       return(_err);
+       return _err;

 }
 
 
 }
 
 


@@ -5523,7 +6017,7 @@ VNOP_SETLABEL(struct vnode *vp, struct label *label, vfs_context_t ctx)
 /*
  * Get a named streamed
  */
 /*
  * Get a named streamed
  */

-errno_t 
+errno_t

 VNOP_GETNAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, enum nsoperation operation, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_GETNAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, enum nsoperation operation, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -5539,13 +6033,13 @@ VNOP_GETNAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, enum nsoperatio
 
        _err = (*vp->v_op[vnop_getnamedstream_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(getnamedstream, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_getnamedstream_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(getnamedstream, vnode_t, vp);

-       return (_err);
+       return _err;

 }
 
 /*
  * Create a named streamed
  */
 }
 
 /*
  * Create a named streamed
  */

-errno_t 
+errno_t

 VNOP_MAKENAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_MAKENAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -5560,14 +6054,14 @@ VNOP_MAKENAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, int flags, vfs
 
        _err = (*vp->v_op[vnop_makenamedstream_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(makenamedstream, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_makenamedstream_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(makenamedstream, vnode_t, vp);

-       return (_err);
+       return _err;

 }
 
 
 /*
  * Remove a named streamed
  */
 }
 
 
 /*
  * Remove a named streamed
  */

-errno_t 
+errno_t

 VNOP_REMOVENAMEDSTREAM(vnode_t vp, vnode_t svp, const char *name, int flags, vfs_context_t ctx)
 {
        int _err;
 VNOP_REMOVENAMEDSTREAM(vnode_t vp, vnode_t svp, const char *name, int flags, vfs_context_t ctx)
 {
        int _err;


@@ -5582,6 +6076,6 @@ VNOP_REMOVENAMEDSTREAM(vnode_t vp, vnode_t svp, const char *name, int flags, vfs
 
        _err = (*vp->v_op[vnop_removenamedstream_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(removenamedstream, vnode_t, vp);
 
        _err = (*vp->v_op[vnop_removenamedstream_desc.vdesc_offset])(&a);
        DTRACE_FSINFO(removenamedstream, vnode_t, vp);

-       return (_err);
+       return _err;

 }
 #endif
 }
 #endif