xnu-792.12.6.tar.gz

[apple/xnu.git] / bsd / miscfs / nullfs / null_vnops.c

diff --git a/bsd/miscfs/nullfs/null_vnops.c b/bsd/miscfs/nullfs/null_vnops.c
index 0bb2b76e0172c8263ba78b9241004c537ae9495b..8c52320fdbbd3412fddfd21c4c1f53fba35216d6 100644 (file)
--- a/bsd/miscfs/nullfs/null_vnops.c
+++ b/bsd/miscfs/nullfs/null_vnops.c
@@ -1,26 +1,31 @@
 /*
 /*

- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
+ * Copyright (c) 2006 Apple Computer, Inc. All Rights Reserved.

  * 
  * 

- * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
+ * @APPLE_LICENSE_OSREFERENCE_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
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
+ * 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 
+ * compliance with the License.  The rights granted to you under the 
+ * License may not be used to create, or enable the creation or 
+ * redistribution of, 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.
  * 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,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
+ *
+ * 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, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 
+ * 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.
  * limitations under the License.

- * 
- * @APPLE_LICENSE_HEADER_END@
+ *
+ * @APPLE_LICENSE_OSREFERENCE_HEADER_END@

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


@@ -116,12 +121,12 @@
  * in the arguments and, if a vnode is return by the operation,
  * stacks a null-node on top of the returned vnode.
  *
  * in the arguments and, if a vnode is return by the operation,
  * stacks a null-node on top of the returned vnode.
  *

- * Although bypass handles most operations, vop_getattr, vop_lock,
- * vop_unlock, vop_inactive, vop_reclaim, and vop_print are not
+ * Although bypass handles most operations, vnop_getattr, vnop_lock,
+ * vnop_unlock, vnop_inactive, vnop_reclaim, and vnop_print are not

  * bypassed. Vop_getattr must change the fsid being returned.
  * bypassed. Vop_getattr must change the fsid being returned.

- * Vop_lock and vop_unlock must handle any locking for the
+ * Vop_lock and vnop_unlock must handle any locking for the

  * current vnode as well as pass the lock request down.
  * current vnode as well as pass the lock request down.

- * Vop_inactive and vop_reclaim are not bypassed so that
+ * Vop_inactive and vnop_reclaim are not bypassed so that

  * they can handle freeing null-layer specific data. Vop_print
  * is not bypassed to avoid excessive debugging information.
  * Also, certain vnode operations change the locking state within
  * they can handle freeing null-layer specific data. Vop_print
  * is not bypassed to avoid excessive debugging information.
  * Also, certain vnode operations change the locking state within


@@ -153,7 +158,7 @@
  * "mount_null /usr/include /dev/layer/null".
  * Changing directory to /dev/layer/null will assign
  * the root null-node (which was created when the null layer was mounted).
  * "mount_null /usr/include /dev/layer/null".
  * Changing directory to /dev/layer/null will assign
  * the root null-node (which was created when the null layer was mounted).

- * Now consider opening "sys".  A vop_lookup would be
+ * Now consider opening "sys".  A vnop_lookup would be

  * done on the root null-node.  This operation would bypass through
  * to the lower layer which would return a vnode representing 
  * the UFS "sys".  Null_bypass then builds a null-node
  * done on the root null-node.  This operation would bypass through
  * to the lower layer which would return a vnode representing 
  * the UFS "sys".  Null_bypass then builds a null-node


@@ -199,10 +204,11 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>

+#include <sys/kauth.h>

 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/vnode.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/vnode.h>

-#include <sys/mount.h>
+#include <sys/mount_internal.h>

 #include <sys/namei.h>
 #include <sys/malloc.h>
 #include <sys/buf.h>
 #include <sys/namei.h>
 #include <sys/malloc.h>
 #include <sys/buf.h>


@@ -222,7 +228,7 @@ int null_bug_bypass = 0;   /* for debugging: enables bypass printf'ing */
  * As an exception to this, vnodes can be marked "unmapped" by setting
  * the Nth bit in operation's vdesc_flags.
  *
  * As an exception to this, vnodes can be marked "unmapped" by setting
  * the Nth bit in operation's vdesc_flags.
  *

- * Also, some BSD vnode operations have the side effect of vrele'ing
+ * Also, some BSD vnode operations have the side effect of node_put'ing

  * their arguments.  With stacking, the reference counts are held
  * by the upper node, not the lower one, so we must handle these
  * side-effects here.  This is not of concern in Sun-derived systems
  * their arguments.  With stacking, the reference counts are held
  * by the upper node, not the lower one, so we must handle these
  * side-effects here.  This is not of concern in Sun-derived systems


@@ -230,7 +236,7 @@ int null_bug_bypass = 0;   /* for debugging: enables bypass printf'ing */
  *
  * This makes the following assumptions:
  * - only one returned vpp
  *
  * This makes the following assumptions:
  * - only one returned vpp

- * - no INOUT vpp's (Sun's vop_open has one of these)
+ * - no INOUT vpp's (Sun's vnop_open has one of these)

  * - the vnode operation vector of the first vnode should be used
  *   to determine what implementation of the op should be invoked
  * - all mapped vnodes are of our vnode-type (NEEDSWORK:
  * - the vnode operation vector of the first vnode should be used
  *   to determine what implementation of the op should be invoked
  * - all mapped vnodes are of our vnode-type (NEEDSWORK:


@@ -238,7 +244,7 @@ int null_bug_bypass = 0;   /* for debugging: enables bypass printf'ing */
  */ 
 int
 null_bypass(ap)
  */ 
 int
 null_bypass(ap)

-       struct vop_generic_args /* {
+       struct vnop_generic_args /* {

                struct vnodeop_desc *a_desc;
                <other random data follows, presumably>
        } */ *ap;
                struct vnodeop_desc *a_desc;
                <other random data follows, presumably>
        } */ *ap;


@@ -288,11 +294,11 @@ null_bypass(ap)
                        *(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p);
                        /*
                         * XXX - Several operations have the side effect
                        *(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p);
                        /*
                         * XXX - Several operations have the side effect

-                        * of vrele'ing their vp's.  We must account for
+                        * of vnode_put'ing their vp's.  We must account for

                         * that.  (This should go away in the future.)
                         */
                        if (reles & 1)
                         * that.  (This should go away in the future.)
                         */
                        if (reles & 1)

-                               VREF(*this_vp_p);
+                               vnode_get(*this_vp_p);

                }
                        
        }
                }
                        
        }


@@ -315,21 +321,21 @@ null_bypass(ap)
                if (old_vps[i]) {
                        *(vps_p[i]) = old_vps[i];
                        if (reles & 1)
                if (old_vps[i]) {
                        *(vps_p[i]) = old_vps[i];
                        if (reles & 1)

-                               vrele(*(vps_p[i]));
+                               vnode_put(*(vps_p[i]));

                }
        }
 
        /*
         * Map the possible out-going vpp
         * (Assumes that the lower layer always returns
                }
        }
 
        /*
         * Map the possible out-going vpp
         * (Assumes that the lower layer always returns

-        * a VREF'ed vpp unless it gets an error.)
+        * a vnode_get'ed vpp unless it gets an error.)

         */
        if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&
            !(descp->vdesc_flags & VDESC_NOMAP_VPP) &&
            !error) {
                /*
                 * XXX - even though some ops have vpp returned vp's,
         */
        if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&
            !(descp->vdesc_flags & VDESC_NOMAP_VPP) &&
            !error) {
                /*
                 * XXX - even though some ops have vpp returned vp's,

-                * several ops actually vrele this before returning.
+                * several ops actually vnode_put this before returning.

                 * We must avoid these ops.
                 * (This should go away when these ops are regularized.)
                 */
                 * We must avoid these ops.
                 * (This should go away when these ops are regularized.)
                 */


@@ -350,28 +356,21 @@ null_bypass(ap)
  * if this layer is mounted read-only.
  */
 null_lookup(ap)
  * if this layer is mounted read-only.
  */
 null_lookup(ap)

-       struct vop_lookup_args /* {
+       struct vnop_lookup_args /* {

                struct vnode * a_dvp;
                struct vnode ** a_vpp;
                struct componentname * a_cnp;
                struct vnode * a_dvp;
                struct vnode ** a_vpp;
                struct componentname * a_cnp;

+               vfs_context_t a_context;

        } */ *ap;
 {
        struct componentname *cnp = ap->a_cnp;
        struct proc *p = cnp->cn_proc;
        int flags = cnp->cn_flags;
        } */ *ap;
 {
        struct componentname *cnp = ap->a_cnp;
        struct proc *p = cnp->cn_proc;
        int flags = cnp->cn_flags;

-       struct vop_lock_args lockargs;
-       struct vop_unlock_args unlockargs;

        struct vnode *dvp, *vp;
        int error;
 
        struct vnode *dvp, *vp;
        int error;
 

-       if ((flags & ISLASTCN) && (ap->a_dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-           (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
-               return (EROFS);

        error = null_bypass(ap);
        error = null_bypass(ap);

-       if (error == EJUSTRETURN && (flags & ISLASTCN) &&
-           (ap->a_dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-           (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME))
-               error = EROFS;
+

        /*
         * We must do the same locking and unlocking at this layer as 
         * is done in the layers below us. We could figure this out 
        /*
         * We must do the same locking and unlocking at this layer as 
         * is done in the layers below us. We could figure this out 


@@ -384,43 +383,26 @@ null_lookup(ap)
        vp = *ap->a_vpp;
        if (dvp == vp)
                return (error);
        vp = *ap->a_vpp;
        if (dvp == vp)
                return (error);

-       if (!VOP_ISLOCKED(dvp)) {
-               unlockargs.a_vp = dvp;
-               unlockargs.a_flags = 0;
-               unlockargs.a_p = p;
-               vop_nounlock(&unlockargs);
-       }
-       if (vp != NULL && VOP_ISLOCKED(vp)) {
-               lockargs.a_vp = vp;
-               lockargs.a_flags = LK_SHARED;
-               lockargs.a_p = p;
-               vop_nolock(&lockargs);
-       }

        return (error);
 }
 
 /*
        return (error);
 }
 
 /*

- * Setattr call. Disallow write attempts if the layer is mounted read-only.
+ * Setattr call.

  */
 int
  */
 int

-null_setattr(ap)
-       struct vop_setattr_args /* {
+null_setattr(
+       struct vnop_setattr_args /* {

                struct vnodeop_desc *a_desc;
                struct vnode *a_vp;
                struct vnodeop_desc *a_desc;
                struct vnode *a_vp;

-               struct vattr *a_vap;
-               struct ucred *a_cred;
+               struct vnode_attr *a_vap;
+               kauth_cred_t a_cred;

                struct proc *a_p;
                struct proc *a_p;

-       } */ *ap;
+       } */ *ap)

 {
        struct vnode *vp = ap->a_vp;
 {
        struct vnode *vp = ap->a_vp;

-       struct vattr *vap = ap->a_vap;
-
-       if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
-           vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
-           vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
-           (vp->v_mount->mnt_flag & MNT_RDONLY))
-               return (EROFS);
-       if (vap->va_size != VNOVAL) {
+       struct vnode_attr *vap = ap->a_vap;
+
+       if (VATTR_IS_ACTIVE(vap, va_data_size)) {

                switch (vp->v_type) {
                case VDIR:
                        return (EISDIR);
                switch (vp->v_type) {
                case VDIR:
                        return (EISDIR);


@@ -432,12 +414,6 @@ null_setattr(ap)
                case VREG:
                case VLNK:
                default:
                case VREG:
                case VLNK:
                default:

-                       /*
-                        * Disallow write attempts if the filesystem is
-                        * mounted read-only.
-                        */
-                       if (vp->v_mount->mnt_flag & MNT_RDONLY)
-                               return (EROFS);

                }
        }
        return (null_bypass(ap));
                }
        }
        return (null_bypass(ap));


@@ -448,11 +424,10 @@ null_setattr(ap)
  */
 int
 null_getattr(ap)
  */
 int
 null_getattr(ap)

-       struct vop_getattr_args /* {
+       struct vnop_getattr_args /* {

                struct vnode *a_vp;
                struct vnode *a_vp;

-               struct vattr *a_vap;
-               struct ucred *a_cred;
-               struct proc *a_p;
+               struct vnode_attr *a_vap;
+               vfs_context_t a_context;

        } */ *ap;
 {
        int error;
        } */ *ap;
 {
        int error;


@@ -460,91 +435,31 @@ null_getattr(ap)
        if (error = null_bypass(ap))
                return (error);
        /* Requires that arguments be restored. */
        if (error = null_bypass(ap))
                return (error);
        /* Requires that arguments be restored. */

-       ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
+       VATTR_RETURN(ap->a_vap, va_fsid, ap->a_vp->v_mount->mnt_vfsstat.f_fsid.val[0]);

        return (0);
 }
 
 int
 null_access(ap)
        return (0);
 }
 
 int
 null_access(ap)

-       struct vop_access_args /* {
-               struct vnode *a_vp;
-               int  a_mode;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
-{
-       struct vnode *vp = ap->a_vp;
-       mode_t mode = ap->a_mode;
-
-       /*
-        * Disallow write attempts on read-only layers;
-        * unless the file is a socket, fifo, or a block or
-        * character device resident on the file system.
-        */
-       if (mode & VWRITE) {
-               switch (vp->v_type) {
-               case VDIR:
-               case VLNK:
-               case VREG:
-                       if (vp->v_mount->mnt_flag & MNT_RDONLY)
-                               return (EROFS);
-                       break;
-               }
-       }
-       return (null_bypass(ap));
-}
-
-/*
- * We need to process our own vnode lock and then clear the
- * interlock flag as it applies only to our vnode, not the
- * vnodes below us on the stack.
- */
-int
-null_lock(ap)
-       struct vop_lock_args /* {
-               struct vnode *a_vp;
-               int a_flags;
-               struct proc *a_p;
-       } */ *ap;
-{
-
-       vop_nolock(ap);
-       if ((ap->a_flags & LK_TYPE_MASK) == LK_DRAIN)
-               return (0);
-       ap->a_flags &= ~LK_INTERLOCK;
-       return (null_bypass(ap));
-}
-
-/*
- * We need to process our own vnode unlock and then clear the
- * interlock flag as it applies only to our vnode, not the
- * vnodes below us on the stack.
- */
-int
-null_unlock(ap)
-       struct vop_unlock_args /* {
+       struct vnop_access_args /* {

                struct vnode *a_vp;
                struct vnode *a_vp;

-               int a_flags;
-               struct proc *a_p;
+               int  a_action;
+               vfs_context_t a_context;

        } */ *ap;
 {
        } */ *ap;
 {

-       struct vnode *vp = ap->a_vp;
-
-       vop_nounlock(ap);
-       ap->a_flags &= ~LK_INTERLOCK;

        return (null_bypass(ap));
 }
 
 int
 null_inactive(ap)
        return (null_bypass(ap));
 }
 
 int
 null_inactive(ap)

-       struct vop_inactive_args /* {
+       struct vnop_inactive_args /* {

                struct vnode *a_vp;
                struct vnode *a_vp;

-               struct proc *a_p;
+               vfs_context_t a_context;

        } */ *ap;
 {
        /*
         * Do nothing (and _don't_ bypass).
        } */ *ap;
 {
        /*
         * Do nothing (and _don't_ bypass).

-        * Wait to vrele lowervp until reclaim,
+        * Wait to vnode_put lowervp until reclaim,

         * so that until then our null_node is in the
         * cache and reusable.
         *
         * so that until then our null_node is in the
         * cache and reusable.
         *


@@ -554,15 +469,14 @@ null_inactive(ap)
         * like they do in the name lookup cache code.
         * That's too much work for now.
         */
         * like they do in the name lookup cache code.
         * That's too much work for now.
         */

-       VOP_UNLOCK(ap->a_vp, 0, ap->a_p);

        return (0);
 }
 
 int
 null_reclaim(ap)
        return (0);
 }
 
 int
 null_reclaim(ap)

-       struct vop_reclaim_args /* {
+       struct vnop_reclaim_args /* {

                struct vnode *a_vp;
                struct vnode *a_vp;

-               struct proc *a_p;
+               vfs_context_t a_context;

        } */ *ap;
 {
        struct vnode *vp = ap->a_vp;
        } */ *ap;
 {
        struct vnode *vp = ap->a_vp;


@@ -570,7 +484,7 @@ null_reclaim(ap)
        struct vnode *lowervp = xp->null_lowervp;
 
        /*
        struct vnode *lowervp = xp->null_lowervp;
 
        /*

-        * Note: in vop_reclaim, vp->v_op == dead_vnodeop_p,
+        * Note: in vnop_reclaim, vp->v_op == dead_vnodeop_p,

         * so we can't call VOPs on ourself.
         */
        /* After this assignment, this node will not be re-used. */
         * so we can't call VOPs on ourself.
         */
        /* After this assignment, this node will not be re-used. */


@@ -578,29 +492,18 @@ null_reclaim(ap)
        LIST_REMOVE(xp, null_hash);
        FREE(vp->v_data, M_TEMP);
        vp->v_data = NULL;
        LIST_REMOVE(xp, null_hash);
        FREE(vp->v_data, M_TEMP);
        vp->v_data = NULL;

-       vrele (lowervp);
-       return (0);
-}
-
-int
-null_print(ap)
-       struct vop_print_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
-{
-       register struct vnode *vp = ap->a_vp;
-       printf ("\ttag VT_NULLFS, vp=%x, lowervp=%x\n", vp, NULLVPTOLOWERVP(vp));
+       vnode_put (lowervp);

        return (0);
 }
 
 /*
        return (0);
 }
 
 /*

- * XXX - vop_strategy must be hand coded because it has no
+ * XXX - vnop_strategy must be hand coded because it has no

  * vnode in its arguments.
  * This goes away with a merged VM/buffer cache.
  */
 int
 null_strategy(ap)
  * vnode in its arguments.
  * This goes away with a merged VM/buffer cache.
  */
 int
 null_strategy(ap)

-       struct vop_strategy_args /* {
+       struct vnop_strategy_args /* {

                struct buf *a_bp;
        } */ *ap;
 {
                struct buf *a_bp;
        } */ *ap;
 {


@@ -608,24 +511,24 @@ null_strategy(ap)
        int error;
        struct vnode *savedvp;
 
        int error;
        struct vnode *savedvp;
 

-       savedvp = bp->b_vp;
-       bp->b_vp = NULLVPTOLOWERVP(bp->b_vp);
+       savedvp = vnode(bp);
+       buf_setvnode(bp, NULLVPTOLOWERVP(savedvp));

 
 

-       error = VOP_STRATEGY(bp);
+       error = VNOP_STRATEGY(bp);

 
 

-       bp->b_vp = savedvp;
+       buf_setvnode(bp, savedvp);

 
        return (error);
 }
 
 /*
 
        return (error);
 }
 
 /*

- * XXX - like vop_strategy, vop_bwrite must be hand coded because it has no
+ * XXX - like vnop_strategy, vnop_bwrite must be hand coded because it has no

  * vnode in its arguments.
  * This goes away with a merged VM/buffer cache.
  */
 int
 null_bwrite(ap)
  * vnode in its arguments.
  * This goes away with a merged VM/buffer cache.
  */
 int
 null_bwrite(ap)

-       struct vop_bwrite_args /* {
+       struct vnop_bwrite_args /* {

                struct buf *a_bp;
        } */ *ap;
 {
                struct buf *a_bp;
        } */ *ap;
 {


@@ -633,12 +536,12 @@ null_bwrite(ap)
        int error;
        struct vnode *savedvp;
 
        int error;
        struct vnode *savedvp;
 

-       savedvp = bp->b_vp;
-       bp->b_vp = NULLVPTOLOWERVP(bp->b_vp);
+       savedvp = buf_vnode(bp);
+       buf_setvnode(bp, NULLVPTOLOWERVP(savedvp));

 
 

-       error = VOP_BWRITE(bp);
+       error = VNOP_BWRITE(bp);

 
 

-       bp->b_vp = savedvp;
+       buf_setvnode(bp, savedvp);

 
        return (error);
 }
 
        return (error);
 }


@@ -651,20 +554,17 @@ null_bwrite(ap)
 
 int (**null_vnodeop_p)(void *);
 struct vnodeopv_entry_desc null_vnodeop_entries[] = {
 
 int (**null_vnodeop_p)(void *);
 struct vnodeopv_entry_desc null_vnodeop_entries[] = {

-       { &vop_default_desc, (VOPFUNC)null_bypass },
-
-       { &vop_lookup_desc, (VOPFUNC)null_lookup },
-       { &vop_setattr_desc, (VOPFUNC)null_setattr },
-       { &vop_getattr_desc, (VOPFUNC)null_getattr },
-       { &vop_access_desc, (VOPFUNC)null_access },
-       { &vop_lock_desc, (VOPFUNC)null_lock },
-       { &vop_unlock_desc, (VOPFUNC)null_unlock },
-       { &vop_inactive_desc, (VOPFUNC)null_inactive },
-       { &vop_reclaim_desc, (VOPFUNC)null_reclaim },
-       { &vop_print_desc, (VOPFUNC)null_print },
-
-       { &vop_strategy_desc, (VOPFUNC)null_strategy },
-       { &vop_bwrite_desc, (VOPFUNC)null_bwrite },
+       { &vnop_default_desc, (VOPFUNC)null_bypass },
+
+       { &vnop_lookup_desc, (VOPFUNC)null_lookup },
+       { &vnop_setattr_desc, (VOPFUNC)null_setattr },
+       { &vnop_getattr_desc, (VOPFUNC)null_getattr },
+       { &vnop_access_desc, (VOPFUNC)null_access },
+       { &vnop_inactive_desc, (VOPFUNC)null_inactive },
+       { &vnop_reclaim_desc, (VOPFUNC)null_reclaim },
+
+       { &vnop_strategy_desc, (VOPFUNC)null_strategy },
+       { &vnop_bwrite_desc, (VOPFUNC)null_bwrite },

 
        { (struct vnodeop_desc*)NULL, (int(*)())NULL }
 };
 
        { (struct vnodeop_desc*)NULL, (int(*)())NULL }
 };