]> git.saurik.com Git - apple/xnu.git/blobdiff - bsd/miscfs/deadfs/dead_vnops.c
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-792.6.56.tar.gz
[apple/xnu.git] / bsd / miscfs / deadfs / dead_vnops.c
diff --git a/bsd/miscfs/deadfs/dead_vnops.c b/bsd/miscfs/deadfs/dead_vnops.c
index aaca316c933d455132e813e07ba32013fcc4bf50..84ab174d64e3a65605cf61f27571f8753b9104d4 100644 (file)
--- a/bsd/miscfs/deadfs/dead_vnops.c
+++ b/bsd/miscfs/deadfs/dead_vnops.c
@@ -3,19 +3,20 @@
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * 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
+ * file.
  * 
  * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * 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,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE 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_LICENSE_HEADER_END@
  */
  * 
  * @APPLE_LICENSE_HEADER_END@
  */
@@ -58,7 +59,7 @@
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
-#include <sys/vnode.h>
+#include <sys/vnode_internal.h>
 #include <sys/errno.h>
 #include <sys/namei.h>
 #include <sys/buf.h>
 #include <sys/errno.h>
 #include <sys/namei.h>
 #include <sys/buf.h>
@@ -67,104 +68,80 @@
 /*
  * Prototypes for dead operations on vnodes.
  */
 /*
  * Prototypes for dead operations on vnodes.
  */
-int    dead_badop(),
-       dead_ebadf();
-int    dead_lookup __P((struct vop_lookup_args *));
-#define dead_create ((int (*) __P((struct  vop_create_args *)))dead_badop)
-#define dead_mknod ((int (*) __P((struct  vop_mknod_args *)))dead_badop)
-int    dead_open __P((struct vop_open_args *));
-#define dead_close ((int (*) __P((struct  vop_close_args *)))nullop)
-#define dead_access ((int (*) __P((struct  vop_access_args *)))dead_ebadf)
-#define dead_getattr ((int (*) __P((struct  vop_getattr_args *)))dead_ebadf)
-#define dead_setattr ((int (*) __P((struct  vop_setattr_args *)))dead_ebadf)
-int    dead_read __P((struct vop_read_args *));
-int    dead_write __P((struct vop_write_args *));
-int    dead_ioctl __P((struct vop_ioctl_args *));
-int    dead_select __P((struct vop_select_args *));
-#define dead_mmap ((int (*) __P((struct  vop_mmap_args *)))dead_badop)
-#define dead_fsync ((int (*) __P((struct  vop_fsync_args *)))nullop)
-#define dead_seek ((int (*) __P((struct  vop_seek_args *)))nullop)
-#define dead_remove ((int (*) __P((struct  vop_remove_args *)))dead_badop)
-#define dead_link ((int (*) __P((struct  vop_link_args *)))dead_badop)
-#define dead_rename ((int (*) __P((struct  vop_rename_args *)))dead_badop)
-#define dead_mkdir ((int (*) __P((struct  vop_mkdir_args *)))dead_badop)
-#define dead_rmdir ((int (*) __P((struct  vop_rmdir_args *)))dead_badop)
-#define dead_symlink ((int (*) __P((struct  vop_symlink_args *)))dead_badop)
-#define dead_readdir ((int (*) __P((struct  vop_readdir_args *)))dead_ebadf)
-#define dead_readlink ((int (*) __P((struct  vop_readlink_args *)))dead_ebadf)
-#define dead_abortop ((int (*) __P((struct  vop_abortop_args *)))dead_badop)
-#define dead_inactive ((int (*) __P((struct  vop_inactive_args *)))nullop)
-#define dead_reclaim ((int (*) __P((struct  vop_reclaim_args *)))nullop)
-int    dead_lock __P((struct vop_lock_args *));
-#define dead_unlock ((int (*) __P((struct  vop_unlock_args *)))nullop)
-int    dead_bmap __P((struct vop_bmap_args *));
-int    dead_strategy __P((struct vop_strategy_args *));
-int    dead_print __P((struct vop_print_args *));
-#define dead_islocked ((int (*) __P((struct  vop_islocked_args *)))nullop)
-#define dead_pathconf ((int (*) __P((struct  vop_pathconf_args *)))dead_ebadf)
-#define dead_advlock ((int (*) __P((struct  vop_advlock_args *)))dead_ebadf)
-#define dead_blkatoff ((int (*) __P((struct  vop_blkatoff_args *)))dead_badop)
-#define dead_valloc ((int (*) __P((struct  vop_valloc_args *)))dead_badop)
-#define dead_vfree ((int (*) __P((struct  vop_vfree_args *)))dead_badop)
-#define dead_truncate ((int (*) __P((struct  vop_truncate_args *)))nullop)
-#define dead_update ((int (*) __P((struct  vop_update_args *)))nullop)
-#define dead_bwrite ((int (*) __P((struct  vop_bwrite_args *)))nullop)
-int    dead_pagein __P((struct vop_pagein_args *));
-int    dead_pageout __P((struct vop_pageout_args *));
-int dead_blktooff __P((struct vop_blktooff_args *));
-int dead_offtoblk __P((struct vop_offtoblk_args *));
-int dead_cmap __P((struct vop_cmap_args *));
+int    dead_badop(void *);
+int    dead_ebadf(void *);
+int    dead_lookup(struct vnop_lookup_args *);
+#define dead_create (int (*)(struct  vnop_create_args *))dead_badop
+#define dead_mknod (int (*)(struct  vnop_mknod_args *))dead_badop
+int    dead_open(struct vnop_open_args *);
+#define dead_close (int (*)(struct  vnop_close_args *))nullop
+#define dead_access (int (*)(struct  vnop_access_args *))dead_ebadf
+#define dead_getattr (int (*)(struct  vnop_getattr_args *))dead_ebadf
+#define dead_setattr (int (*)(struct  vnop_setattr_args *))dead_ebadf
+int    dead_read(struct vnop_read_args *);
+int    dead_write(struct vnop_write_args *);
+int    dead_ioctl(struct vnop_ioctl_args *);
+int    dead_select(struct vnop_select_args *);
+#define dead_mmap (int (*)(struct  vnop_mmap_args *))dead_badop
+#define dead_fsync (int (*)(struct  vnop_fsync_args *))nullop
+#define dead_remove (int (*)(struct  vnop_remove_args ))dead_badop
+#define dead_link (int (*)(struct  vnop_link_args *))dead_badop
+#define dead_rename (int (*)(struct  vnop_rename_args *))dead_badop
+#define dead_mkdir (int (*)(struct  vnop_mkdir_args *))dead_badop
+#define dead_rmdir (int (*)(struct  vnop_rmdir_args *))dead_badop
+#define dead_symlink (int (*)(struct  vnop_symlink_args *))dead_badop
+#define dead_readdir (int (*)(struct  vnop_readdir_args *))dead_ebadf
+#define dead_readlink (int (*)(struct  vnop_readlink_args *))dead_ebadf
+#define dead_inactive (int (*)(struct  vnop_inactive_args *))nullop
+#define dead_reclaim (int (*)(struct  vnop_reclaim_args *))nullop
+int    dead_strategy(struct vnop_strategy_args *);
+#define dead_pathconf (int (*)(struct  vnop_pathconf_args *))dead_ebadf
+#define dead_advlock (int (*)(struct  vnop_advlock_args *))dead_ebadf
+#define dead_bwrite (int (*)(struct  vnop_bwrite_args *))nullop
+int    dead_pagein(struct vnop_pagein_args *);
+int    dead_pageout(struct vnop_pageout_args *);
+int dead_blktooff(struct vnop_blktooff_args *);
+int dead_offtoblk(struct vnop_offtoblk_args *);
+int dead_blockmap(struct vnop_blockmap_args *);
 
 #define VOPFUNC int (*)(void *)
 int (**dead_vnodeop_p)(void *);
 struct vnodeopv_entry_desc dead_vnodeop_entries[] = {
 
 #define VOPFUNC int (*)(void *)
 int (**dead_vnodeop_p)(void *);
 struct vnodeopv_entry_desc dead_vnodeop_entries[] = {
-       { &vop_default_desc, (VOPFUNC)vn_default_error },
-       { &vop_lookup_desc, (VOPFUNC)dead_lookup },     /* lookup */
-       { &vop_create_desc, (VOPFUNC)dead_create },     /* create */
-       { &vop_mknod_desc, (VOPFUNC)dead_mknod },       /* mknod */
-       { &vop_open_desc, (VOPFUNC)dead_open },         /* open */
-       { &vop_close_desc, (VOPFUNC)dead_close },       /* close */
-       { &vop_access_desc, (VOPFUNC)dead_access },     /* access */
-       { &vop_getattr_desc, (VOPFUNC)dead_getattr },   /* getattr */
-       { &vop_setattr_desc, (VOPFUNC)dead_setattr },   /* setattr */
-       { &vop_read_desc, (VOPFUNC)dead_read },         /* read */
-       { &vop_write_desc, (VOPFUNC)dead_write },       /* write */
-       { &vop_ioctl_desc, (VOPFUNC)dead_ioctl },       /* ioctl */
-       { &vop_select_desc, (VOPFUNC)dead_select },     /* select */
-       { &vop_mmap_desc, (VOPFUNC)dead_mmap },         /* mmap */
-       { &vop_fsync_desc, (VOPFUNC)dead_fsync },       /* fsync */
-       { &vop_seek_desc, (VOPFUNC)dead_seek },         /* seek */
-       { &vop_remove_desc, (VOPFUNC)dead_remove },     /* remove */
-       { &vop_link_desc, (VOPFUNC)dead_link },         /* link */
-       { &vop_rename_desc, (VOPFUNC)dead_rename },     /* rename */
-       { &vop_mkdir_desc, (VOPFUNC)dead_mkdir },       /* mkdir */
-       { &vop_rmdir_desc, (VOPFUNC)dead_rmdir },       /* rmdir */
-       { &vop_symlink_desc, (VOPFUNC)dead_symlink },   /* symlink */
-       { &vop_readdir_desc, (VOPFUNC)dead_readdir },   /* readdir */
-       { &vop_readlink_desc, (VOPFUNC)dead_readlink }, /* readlink */
-       { &vop_abortop_desc, (VOPFUNC)dead_abortop },   /* abortop */
-       { &vop_inactive_desc, (VOPFUNC)dead_inactive }, /* inactive */
-       { &vop_reclaim_desc, (VOPFUNC)dead_reclaim },   /* reclaim */
-       { &vop_lock_desc, (VOPFUNC)dead_lock },         /* lock */
-       { &vop_unlock_desc, (VOPFUNC)dead_unlock },     /* unlock */
-       { &vop_bmap_desc, (VOPFUNC)dead_bmap },         /* bmap */
-       { &vop_strategy_desc, (VOPFUNC)dead_strategy }, /* strategy */
-       { &vop_print_desc, (VOPFUNC)dead_print },       /* print */
-       { &vop_islocked_desc, (VOPFUNC)dead_islocked }, /* islocked */
-       { &vop_pathconf_desc, (VOPFUNC)dead_pathconf }, /* pathconf */
-       { &vop_advlock_desc, (VOPFUNC)dead_advlock },   /* advlock */
-       { &vop_blkatoff_desc, (VOPFUNC)dead_blkatoff }, /* blkatoff */
-       { &vop_valloc_desc, (VOPFUNC)dead_valloc },     /* valloc */
-       { &vop_vfree_desc, (VOPFUNC)dead_vfree },       /* vfree */
-       { &vop_truncate_desc, (VOPFUNC)dead_truncate }, /* truncate */
-       { &vop_update_desc, (VOPFUNC)dead_update },     /* update */
-       { &vop_bwrite_desc, (VOPFUNC)dead_bwrite },     /* bwrite */
-       { &vop_pagein_desc, (VOPFUNC)err_pagein },      /* Pagein */
-       { &vop_pageout_desc, (VOPFUNC)err_pageout },    /* Pageout */
-        { &vop_copyfile_desc, (VOPFUNC)err_copyfile }, /* Copyfile */
-       { &vop_blktooff_desc, (VOPFUNC)dead_blktooff }, /* blktooff */
-       { &vop_offtoblk_desc, (VOPFUNC)dead_offtoblk }, /* offtoblk */
-       { &vop_cmap_desc, (VOPFUNC)dead_cmap },         /* cmap */
+       { &vnop_default_desc, (VOPFUNC)vn_default_error },
+       { &vnop_lookup_desc, (VOPFUNC)dead_lookup },    /* lookup */
+       { &vnop_create_desc, (VOPFUNC)dead_create },    /* create */
+       { &vnop_open_desc, (VOPFUNC)dead_open },                /* open */
+       { &vnop_mknod_desc, (VOPFUNC)dead_mknod },              /* mknod */
+       { &vnop_close_desc, (VOPFUNC)dead_close },      /* close */
+       { &vnop_access_desc, (VOPFUNC)dead_access },    /* access */
+       { &vnop_getattr_desc, (VOPFUNC)dead_getattr },  /* getattr */
+       { &vnop_setattr_desc, (VOPFUNC)dead_setattr },  /* setattr */
+       { &vnop_read_desc, (VOPFUNC)dead_read },                /* read */
+       { &vnop_write_desc, (VOPFUNC)dead_write },      /* write */
+       { &vnop_ioctl_desc, (VOPFUNC)dead_ioctl },      /* ioctl */
+       { &vnop_select_desc, (VOPFUNC)dead_select },    /* select */
+       { &vnop_mmap_desc, (VOPFUNC)dead_mmap },                /* mmap */
+       { &vnop_fsync_desc, (VOPFUNC)dead_fsync },      /* fsync */
+       { &vnop_remove_desc, (VOPFUNC)dead_remove },    /* remove */
+       { &vnop_link_desc, (VOPFUNC)dead_link },                /* link */
+       { &vnop_rename_desc, (VOPFUNC)dead_rename },    /* rename */
+       { &vnop_mkdir_desc, (VOPFUNC)dead_mkdir },      /* mkdir */
+       { &vnop_rmdir_desc, (VOPFUNC)dead_rmdir },      /* rmdir */
+       { &vnop_symlink_desc, (VOPFUNC)dead_symlink },  /* symlink */
+       { &vnop_readdir_desc, (VOPFUNC)dead_readdir },  /* readdir */
+       { &vnop_readlink_desc, (VOPFUNC)dead_readlink },        /* readlink */
+       { &vnop_inactive_desc, (VOPFUNC)dead_inactive },        /* inactive */
+       { &vnop_reclaim_desc, (VOPFUNC)dead_reclaim },  /* reclaim */
+       { &vnop_strategy_desc, (VOPFUNC)dead_strategy },        /* strategy */
+       { &vnop_pathconf_desc, (VOPFUNC)dead_pathconf },        /* pathconf */
+       { &vnop_advlock_desc, (VOPFUNC)dead_advlock },  /* advlock */
+       { &vnop_bwrite_desc, (VOPFUNC)dead_bwrite },    /* bwrite */
+       { &vnop_pagein_desc, (VOPFUNC)err_pagein },     /* Pagein */
+       { &vnop_pageout_desc, (VOPFUNC)err_pageout },   /* Pageout */
+        { &vnop_copyfile_desc, (VOPFUNC)err_copyfile },        /* Copyfile */
+       { &vnop_blktooff_desc, (VOPFUNC)dead_blktooff },        /* blktooff */
+       { &vnop_offtoblk_desc, (VOPFUNC)dead_offtoblk },        /* offtoblk */
+       { &vnop_blockmap_desc, (VOPFUNC)dead_blockmap },                /* blockmap */
        { (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }
 };
 struct vnodeopv_desc dead_vnodeop_opv_desc =
        { (struct vnodeop_desc*)NULL, (VOPFUNC)NULL }
 };
 struct vnodeopv_desc dead_vnodeop_opv_desc =
@@ -176,10 +153,11 @@ struct vnodeopv_desc dead_vnodeop_opv_desc =
 /* ARGSUSED */
 int
 dead_lookup(ap)
 /* ARGSUSED */
 int
 dead_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;
 {
 
        } */ *ap;
 {
 
@@ -193,11 +171,10 @@ dead_lookup(ap)
 /* ARGSUSED */
 int
 dead_open(ap)
 /* ARGSUSED */
 int
 dead_open(ap)
-       struct vop_open_args /* {
+       struct vnop_open_args /* {
                struct vnode *a_vp;
                int  a_mode;
                struct vnode *a_vp;
                int  a_mode;
-               struct ucred *a_cred;
-               struct proc *a_p;
+               vfs_context_t a_context;
        } */ *ap;
 {
 
        } */ *ap;
 {
 
@@ -210,11 +187,11 @@ dead_open(ap)
 /* ARGSUSED */
 int
 dead_read(ap)
 /* ARGSUSED */
 int
 dead_read(ap)
-       struct vop_read_args /* {
+       struct vnop_read_args /* {
                struct vnode *a_vp;
                struct uio *a_uio;
                int  a_ioflag;
                struct vnode *a_vp;
                struct uio *a_uio;
                int  a_ioflag;
-               struct ucred *a_cred;
+               vfs_context_t a_context;
        } */ *ap;
 {
 
        } */ *ap;
 {
 
@@ -234,11 +211,11 @@ dead_read(ap)
 /* ARGSUSED */
 int
 dead_write(ap)
 /* ARGSUSED */
 int
 dead_write(ap)
-       struct vop_write_args /* {
+       struct vnop_write_args /* {
                struct vnode *a_vp;
                struct uio *a_uio;
                int  a_ioflag;
                struct vnode *a_vp;
                struct uio *a_uio;
                int  a_ioflag;
-               struct ucred *a_cred;
+               vfs_context_t a_context;
        } */ *ap;
 {
 
        } */ *ap;
 {
 
@@ -253,29 +230,28 @@ dead_write(ap)
 /* ARGSUSED */
 int
 dead_ioctl(ap)
 /* ARGSUSED */
 int
 dead_ioctl(ap)
-       struct vop_ioctl_args /* {
+       struct vnop_ioctl_args /* {
                struct vnode *a_vp;
                u_long a_command;
                caddr_t  a_data;
                int  a_fflag;
                struct vnode *a_vp;
                u_long a_command;
                caddr_t  a_data;
                int  a_fflag;
-               struct ucred *a_cred;
-               struct proc *a_p;
+               vfs_context_t a_context;
        } */ *ap;
 {
 
        if (!chkvnlock(ap->a_vp))
                return (EBADF);
        } */ *ap;
 {
 
        if (!chkvnlock(ap->a_vp))
                return (EBADF);
-       return (VCALL(ap->a_vp, VOFFSET(vop_ioctl), ap));
+       return (VCALL(ap->a_vp, VOFFSET(vnop_ioctl), ap));
 }
 
 /* ARGSUSED */
 int
 dead_select(ap)
 }
 
 /* ARGSUSED */
 int
 dead_select(ap)
-       struct vop_select_args /* {
+       struct vnop_select_args /* {
                struct vnode *a_vp;
                int  a_which;
                int  a_fflags;
                struct vnode *a_vp;
                int  a_which;
                int  a_fflags;
-               struct ucred *a_cred;
+               kauth_cred_t a_cred;
                void *a_wql;
                struct proc *a_p;
        } */ *ap;
                void *a_wql;
                struct proc *a_p;
        } */ *ap;
@@ -292,102 +268,48 @@ dead_select(ap)
  */
 int
 dead_strategy(ap)
  */
 int
 dead_strategy(ap)
-       struct vop_strategy_args /* {
+       struct vnop_strategy_args /* {
                struct buf *a_bp;
        } */ *ap;
 {
 
                struct buf *a_bp;
        } */ *ap;
 {
 
-       if (ap->a_bp->b_vp == NULL || !chkvnlock(ap->a_bp->b_vp)) {
-               ap->a_bp->b_flags |= B_ERROR;
-               biodone(ap->a_bp);
+       if (buf_vnode(ap->a_bp) == NULL || !chkvnlock(buf_vnode(ap->a_bp))) {
+               buf_seterror(ap->a_bp, EIO);
+               buf_biodone(ap->a_bp);
                return (EIO);
        }
                return (EIO);
        }
-       return (VOP_STRATEGY(ap->a_bp));
+       return (VNOP_STRATEGY(ap->a_bp));
 }
 
 /*
  * Wait until the vnode has finished changing state.
  */
 int
 }
 
 /*
  * Wait until the vnode has finished changing state.
  */
 int
-dead_lock(ap)
-       struct vop_lock_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
-{
-
-       struct vnode *vp = ap->a_vp;
-
-       /*
-        * Since we are not using the lock manager, we must clear
-        * the interlock here.
-        */
-       if (ap->a_flags & LK_INTERLOCK) {
-               simple_unlock(&vp->v_interlock);
-               ap->a_flags &= ~LK_INTERLOCK;
-       }
-       if (!chkvnlock(ap->a_vp))
-               return (0);
-       return (VCALL(ap->a_vp, VOFFSET(vop_lock), ap));
-}
-
-/*
- * Wait until the vnode has finished changing state.
- */
-int
-dead_bmap(ap)
-       struct vop_bmap_args /* {
-               struct vnode *a_vp;
-               daddr_t  a_bn;
-               struct vnode **a_vpp;
-               daddr_t *a_bnp;
-               int *a_runp;
-       } */ *ap;
-{
-
-       if (!chkvnlock(ap->a_vp))
-               return (EIO);
-       return (VOP_BMAP(ap->a_vp, ap->a_bn, ap->a_vpp, ap->a_bnp, ap->a_runp));
-}
-
-/*
- * Wait until the vnode has finished changing state.
- */
-int
-dead_cmap(ap)
-       struct vop_cmap_args /* {
+dead_blockmap(ap)
+       struct vnop_blockmap_args /* {
                struct vnode *a_vp;
                off_t a_foffset;
                size_t a_size;
                struct vnode *a_vp;
                off_t a_foffset;
                size_t a_size;
-               daddr_t *a_bpn;
+               daddr64_t *a_bpn;
                size_t *a_run;
                void *a_poff;
                size_t *a_run;
                void *a_poff;
+               int flags;
+               vfs_context_t a_context;
        } */ *ap;
 {
 
        if (!chkvnlock(ap->a_vp))
                return (EIO);
        } */ *ap;
 {
 
        if (!chkvnlock(ap->a_vp))
                return (EIO);
-       return (VOP_CMAP(ap->a_vp, ap->a_foffset, ap->a_size, ap->a_bpn, ap->a_run, ap->a_poff));
-}
-
-/*
- * Print out the contents of a dead vnode.
- */
-/* ARGSUSED */
-int
-dead_print(ap)
-       struct vop_print_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
-{
-
-       printf("tag VT_NON, dead vnode\n");
+       return (VNOP_BLOCKMAP(ap->a_vp, ap->a_foffset, ap->a_size, ap->a_bpn,
+                        ap->a_run, ap->a_poff, ap->a_flags, ap->a_context));
 }
 
 /*
  * Empty vnode failed operation
  */
 }
 
 /*
  * Empty vnode failed operation
  */
+/* ARGSUSED */
 int
 int
-dead_ebadf()
+dead_ebadf(void *dummy)
 {
 
        return (EBADF);
 {
 
        return (EBADF);
@@ -396,8 +318,9 @@ dead_ebadf()
 /*
  * Empty vnode bad operation
  */
 /*
  * Empty vnode bad operation
  */
+/* ARGSUSED */
 int
 int
-dead_badop()
+dead_badop(void *dummy)
 {
 
        panic("dead_badop called");
 {
 
        panic("dead_badop called");
@@ -407,8 +330,9 @@ dead_badop()
 /*
  * Empty vnode null operation
  */
 /*
  * Empty vnode null operation
  */
+/* ARGSUSED */
 int
 int
-dead_nullop()
+dead_nullop(void *dummy)
 {
 
        return (0);
 {
 
        return (0);
@@ -419,26 +343,18 @@ dead_nullop()
  * in a state of change.
  */
 int
  * in a state of change.
  */
 int
-chkvnlock(vp)
-       register struct vnode *vp;
+chkvnlock(__unused vnode_t vp)
 {
 {
-       int locked = 0;
-
-       while (vp->v_flag & VXLOCK) {
-               vp->v_flag |= VXWANT;
-               sleep((caddr_t)vp, PINOD);
-               locked = 1;
-       }
-       return (locked);
+       return (0);
 }
 
 
 /* Blktooff */
 int
 dead_blktooff(ap)
 }
 
 
 /* Blktooff */
 int
 dead_blktooff(ap)
-       struct vop_blktooff_args /* {
+       struct vnop_blktooff_args /* {
                struct vnode *a_vp;
                struct vnode *a_vp;
-               daddr_t a_lblkno;
+               daddr64_t a_lblkno;
                off_t *a_offset;    
        } */ *ap;
 {
                off_t *a_offset;    
        } */ *ap;
 {
@@ -451,15 +367,15 @@ dead_blktooff(ap)
 /* Blktooff */
 int
 dead_offtoblk(ap)
 /* Blktooff */
 int
 dead_offtoblk(ap)
-struct vop_offtoblk_args /* {
+struct vnop_offtoblk_args /* {
        struct vnode *a_vp;
        off_t a_offset;    
        struct vnode *a_vp;
        off_t a_offset;    
-       daddr_t *a_lblkno;
+       daddr64_t *a_lblkno;
        } */ *ap;
 {
     if (!chkvnlock(ap->a_vp))
                return (EIO);
 
        } */ *ap;
 {
     if (!chkvnlock(ap->a_vp))
                return (EIO);
 
-       *ap->a_lblkno = (daddr_t)-1;    /* failure */
+       *ap->a_lblkno = (daddr64_t)-1;  /* failure */
        return (0);
 }
        return (0);
 }
mirror of XNU