]> git.saurik.com Git - apple/xnu.git/blobdiff - bsd/nfs/nfs_vnops.c
xnu-1504.15.3.tar.gz
[apple/xnu.git] / bsd / nfs / nfs_vnops.c
index 882ed59fe681b848d03f6e0ee8f58c46e260c446..00199a6dfc61245bdae296b092ef60c3e1537db9 100644 (file)
@@ -1,16 +1,19 @@
 /*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
  *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
+ * @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
- * 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.
+ * 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.
  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
@@ -20,7 +23,7 @@
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
 /*
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/resourcevar.h>
-#include <sys/proc.h>
-#include <sys/mount.h>
+#include <sys/proc_internal.h>
+#include <sys/kauth.h>
+#include <sys/mount_internal.h>
 #include <sys/malloc.h>
-#include <sys/mbuf.h>
+#include <sys/kpi_mbuf.h>
 #include <sys/conf.h>
-#include <sys/namei.h>
-#include <sys/vnode.h>
+#include <sys/vnode_internal.h>
 #include <sys/dirent.h>
 #include <sys/fcntl.h>
 #include <sys/lockf.h>
-#include <sys/ubc.h>
+#include <sys/ubc_internal.h>
+#include <sys/attr.h>
+#include <sys/signalvar.h>
+#include <sys/uio_internal.h>
 
 #include <vfs/vfs_support.h>
 
 #include <sys/vm.h>
-#include <machine/spl.h>
-#include <vm/vm_pageout.h>
 
-#include <sys/time.h> 
+#include <sys/time.h>
 #include <kern/clock.h>
+#include <libkern/OSAtomic.h>
 
 #include <miscfs/fifofs/fifo.h>
 #include <miscfs/specfs/specdev.h>
 #include <nfs/nfsproto.h>
 #include <nfs/nfs.h>
 #include <nfs/nfsnode.h>
+#include <nfs/nfs_gss.h>
 #include <nfs/nfsmount.h>
 #include <nfs/nfs_lock.h>
 #include <nfs/xdr_subs.h>
 #include <nfs/nfsm_subs.h>
-#include <nfs/nqnfs.h>
 
 #include <net/if.h>
 #include <netinet/in.h>
 #include <netinet/in_var.h>
+
 #include <vm/vm_kern.h>
+#include <vm/vm_pageout.h>
 
 #include <kern/task.h>
 #include <kern/sched_prim.h>
 
-#include <sys/kdebug.h>
-
-#define FSDBG(A, B, C, D, E) \
-       KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, (A))) | DBG_FUNC_NONE, \
-               (int)(B), (int)(C), (int)(D), (int)(E), 0)
-#define FSDBG_TOP(A, B, C, D, E) \
-       KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, (A))) | DBG_FUNC_START, \
-               (int)(B), (int)(C), (int)(D), (int)(E), 0)
-#define FSDBG_BOT(A, B, C, D, E) \
-       KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, (A))) | DBG_FUNC_END, \
-               (int)(B), (int)(C), (int)(D), (int)(E), 0)
-
-#define        TRUE    1
-#define        FALSE   0
-
-#define NFS_FREE_PNBUF(CNP) \
-       do { \
-               char *tmp = (CNP)->cn_pnbuf; \
-               (CNP)->cn_pnbuf = NULL; \
-               (CNP)->cn_flags &= ~HASBUF; \
-               FREE_ZONE(tmp, (CNP)->cn_pnlen, M_NAMEI); \
-       } while (0)
-
-
-static int     nfsspec_read __P((struct vop_read_args *));
-static int     nfsspec_write __P((struct vop_write_args *));
-static int     nfsfifo_read __P((struct vop_read_args *));
-static int     nfsfifo_write __P((struct vop_write_args *));
-static int     nfsspec_close __P((struct vop_close_args *));
-static int     nfsfifo_close __P((struct vop_close_args *));
-#define nfs_poll vop_nopoll
-static int     nfs_ioctl __P((struct vop_ioctl_args *));
-static int     nfs_select __P((struct vop_select_args *));
-static int     nfs_flush __P((struct vnode *,struct ucred *,int,struct proc *,int));
-static int     nfs_setattrrpc __P((struct vnode *,struct vattr *,struct ucred *,struct proc *));
-static int     nfs_lookup __P((struct vop_lookup_args *));
-static int     nfs_create __P((struct vop_create_args *));
-static int     nfs_mknod __P((struct vop_mknod_args *));
-static int     nfs_open __P((struct vop_open_args *));
-static int     nfs_close __P((struct vop_close_args *));
-static int     nfs_access __P((struct vop_access_args *));
-static int     nfs_getattr __P((struct vop_getattr_args *));
-static int     nfs_setattr __P((struct vop_setattr_args *));
-static int     nfs_read __P((struct vop_read_args *));
-static int     nfs_mmap __P((struct vop_mmap_args *));
-static int     nfs_fsync __P((struct vop_fsync_args *));
-static int     nfs_remove __P((struct vop_remove_args *));
-static int     nfs_link __P((struct vop_link_args *));
-static int     nfs_rename __P((struct vop_rename_args *));
-static int     nfs_mkdir __P((struct vop_mkdir_args *));
-static int     nfs_rmdir __P((struct vop_rmdir_args *));
-static int     nfs_symlink __P((struct vop_symlink_args *));
-static int     nfs_readdir __P((struct vop_readdir_args *));
-static int     nfs_bmap __P((struct vop_bmap_args *));
-static int     nfs_lookitup __P((struct vnode *,char *,int,struct ucred *,struct proc *,struct nfsnode **));
-static int     nfs_sillyrename __P((struct vnode *,struct vnode *,struct componentname *));
-static int     nfsspec_access __P((struct vop_access_args *));
-static int     nfs_readlink __P((struct vop_readlink_args *));
-static int     nfs_print __P((struct vop_print_args *));
-static int     nfs_pathconf __P((struct vop_pathconf_args *));
-static int     nfs_advlock __P((struct vop_advlock_args *));
-static int     nfs_blkatoff __P((struct vop_blkatoff_args *));
-static int     nfs_valloc __P((struct vop_valloc_args *));
-static int     nfs_vfree __P((struct vop_vfree_args *));
-static int     nfs_truncate __P((struct vop_truncate_args *));
-static int     nfs_update __P((struct vop_update_args *));
-static int     nfs_pagein __P((struct vop_pagein_args *));
-static int     nfs_pageout __P((struct vop_pageout_args *));
-static int nfs_blktooff __P((struct vop_blktooff_args *));
-static int nfs_offtoblk __P((struct vop_offtoblk_args *));
-static int nfs_cmap __P((struct vop_cmap_args *));
-
 /*
- * Global vfs data structures for nfs
+ * NFS vnode ops
  */
-vop_t **nfsv2_vnodeop_p;
+int    nfs_vnop_lookup(struct vnop_lookup_args *);
+int    nfsspec_vnop_read(struct vnop_read_args *);
+int    nfsspec_vnop_write(struct vnop_write_args *);
+int    nfsspec_vnop_close(struct vnop_close_args *);
+#if FIFO
+int    nfsfifo_vnop_read(struct vnop_read_args *);
+int    nfsfifo_vnop_write(struct vnop_write_args *);
+int    nfsfifo_vnop_close(struct vnop_close_args *);
+#endif
+int    nfs_vnop_ioctl(struct vnop_ioctl_args *);
+int    nfs_vnop_select(struct vnop_select_args *);
+int    nfs_vnop_setattr(struct vnop_setattr_args *);
+int    nfs_vnop_read(struct vnop_read_args *);
+int    nfs_vnop_write(struct vnop_write_args *);
+int    nfs_vnop_mmap(struct vnop_mmap_args *);
+int    nfs_vnop_fsync(struct vnop_fsync_args *);
+int    nfs_vnop_remove(struct vnop_remove_args *);
+int    nfs_vnop_rename(struct vnop_rename_args *);
+int    nfs_vnop_readdir(struct vnop_readdir_args *);
+int    nfs_vnop_readlink(struct vnop_readlink_args *);
+int    nfs_vnop_pathconf(struct vnop_pathconf_args *);
+int    nfs_vnop_pagein(struct vnop_pagein_args *);
+int    nfs_vnop_pageout(struct vnop_pageout_args *);
+int    nfs_vnop_blktooff(struct vnop_blktooff_args *);
+int    nfs_vnop_offtoblk(struct vnop_offtoblk_args *);
+int    nfs_vnop_blockmap(struct vnop_blockmap_args *);
+
+int    nfs3_vnop_create(struct vnop_create_args *);
+int    nfs3_vnop_mknod(struct vnop_mknod_args *);
+int    nfs3_vnop_getattr(struct vnop_getattr_args *);
+int    nfs3_vnop_link(struct vnop_link_args *);
+int    nfs3_vnop_mkdir(struct vnop_mkdir_args *);
+int    nfs3_vnop_rmdir(struct vnop_rmdir_args *);
+int    nfs3_vnop_symlink(struct vnop_symlink_args *);
+
+vnop_t **nfsv2_vnodeop_p;
 static struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
-       { &vop_default_desc, (vop_t *)vn_default_error },
-       { &vop_lookup_desc, (vop_t *)nfs_lookup },      /* lookup */
-       { &vop_create_desc, (vop_t *)nfs_create },      /* create */
-       { &vop_mknod_desc, (vop_t *)nfs_mknod },        /* mknod */
-       { &vop_open_desc, (vop_t *)nfs_open },          /* open */
-       { &vop_close_desc, (vop_t *)nfs_close },        /* close */
-       { &vop_access_desc, (vop_t *)nfs_access },      /* access */
-       { &vop_getattr_desc, (vop_t *)nfs_getattr },    /* getattr */
-       { &vop_setattr_desc, (vop_t *)nfs_setattr },    /* setattr */
-       { &vop_read_desc, (vop_t *)nfs_read },          /* read */
-       { &vop_write_desc, (vop_t *)nfs_write },        /* write */
-       { &vop_lease_desc, (vop_t *)nfs_lease_check },  /* lease */
-       { &vop_ioctl_desc, (vop_t *)nfs_ioctl },        /* ioctl */
-       { &vop_select_desc, (vop_t *)nfs_select },      /* select */
-       { &vop_revoke_desc, (vop_t *)nfs_revoke },      /* revoke */
-       { &vop_mmap_desc, (vop_t *)nfs_mmap },          /* mmap */
-       { &vop_fsync_desc, (vop_t *)nfs_fsync },        /* fsync */
-       { &vop_seek_desc, (vop_t *)nfs_seek },          /* seek */
-       { &vop_remove_desc, (vop_t *)nfs_remove },      /* remove */
-       { &vop_link_desc, (vop_t *)nfs_link },          /* link */
-       { &vop_rename_desc, (vop_t *)nfs_rename },      /* rename */
-       { &vop_mkdir_desc, (vop_t *)nfs_mkdir },        /* mkdir */
-       { &vop_rmdir_desc, (vop_t *)nfs_rmdir },        /* rmdir */
-       { &vop_symlink_desc, (vop_t *)nfs_symlink },    /* symlink */
-       { &vop_readdir_desc, (vop_t *)nfs_readdir },    /* readdir */
-       { &vop_readlink_desc, (vop_t *)nfs_readlink },  /* readlink */
-       { &vop_abortop_desc, (vop_t *)nop_abortop },    /* abortop */
-       { &vop_inactive_desc, (vop_t *)nfs_inactive },  /* inactive */
-       { &vop_reclaim_desc, (vop_t *)nfs_reclaim },    /* reclaim */
-       { &vop_lock_desc, (vop_t *)nfs_lock },          /* lock */
-       { &vop_unlock_desc, (vop_t *)nfs_unlock },      /* unlock */
-       { &vop_bmap_desc, (vop_t *)nfs_bmap },          /* bmap */
-       { &vop_strategy_desc, (vop_t *)err_strategy },  /* strategy */
-       { &vop_print_desc, (vop_t *)nfs_print },        /* print */
-       { &vop_islocked_desc, (vop_t *)nfs_islocked },  /* islocked */
-       { &vop_pathconf_desc, (vop_t *)nfs_pathconf },  /* pathconf */
-       { &vop_advlock_desc, (vop_t *)nfs_advlock },    /* advlock */
-       { &vop_blkatoff_desc, (vop_t *)nfs_blkatoff },  /* blkatoff */
-       { &vop_valloc_desc, (vop_t *)nfs_valloc },      /* valloc */
-       { &vop_reallocblks_desc, (vop_t *)nfs_reallocblks },    /* reallocblks */
-       { &vop_vfree_desc, (vop_t *)nfs_vfree },        /* vfree */
-       { &vop_truncate_desc, (vop_t *)nfs_truncate },  /* truncate */
-       { &vop_update_desc, (vop_t *)nfs_update },      /* update */
-       { &vop_bwrite_desc, (vop_t *)err_bwrite },      /* bwrite */
-       { &vop_pagein_desc, (vop_t *)nfs_pagein },              /* Pagein */
-       { &vop_pageout_desc, (vop_t *)nfs_pageout },            /* Pageout */
-       { &vop_copyfile_desc, (vop_t *)err_copyfile },          /* Copyfile */
-       { &vop_blktooff_desc, (vop_t *)nfs_blktooff },          /* blktooff */
-       { &vop_offtoblk_desc, (vop_t *)nfs_offtoblk },          /* offtoblk */
-       { &vop_cmap_desc, (vop_t *)nfs_cmap },          /* cmap */
+       { &vnop_default_desc, (vnop_t *)vn_default_error },
+       { &vnop_lookup_desc, (vnop_t *)nfs_vnop_lookup },       /* lookup */
+       { &vnop_create_desc, (vnop_t *)nfs3_vnop_create },      /* create */
+       { &vnop_mknod_desc, (vnop_t *)nfs3_vnop_mknod },        /* mknod */
+       { &vnop_open_desc, (vnop_t *)nfs3_vnop_open },          /* open */
+       { &vnop_close_desc, (vnop_t *)nfs3_vnop_close },        /* close */
+       { &vnop_access_desc, (vnop_t *)nfs_vnop_access },       /* access */
+       { &vnop_getattr_desc, (vnop_t *)nfs3_vnop_getattr },    /* getattr */
+       { &vnop_setattr_desc, (vnop_t *)nfs_vnop_setattr },     /* setattr */
+       { &vnop_read_desc, (vnop_t *)nfs_vnop_read },           /* read */
+       { &vnop_write_desc, (vnop_t *)nfs_vnop_write },         /* write */
+       { &vnop_ioctl_desc, (vnop_t *)nfs_vnop_ioctl },         /* ioctl */
+       { &vnop_select_desc, (vnop_t *)nfs_vnop_select },       /* select */
+       { &vnop_revoke_desc, (vnop_t *)nfs_vnop_revoke },       /* revoke */
+       { &vnop_mmap_desc, (vnop_t *)nfs_vnop_mmap },           /* mmap */
+       { &vnop_fsync_desc, (vnop_t *)nfs_vnop_fsync },         /* fsync */
+       { &vnop_remove_desc, (vnop_t *)nfs_vnop_remove },       /* remove */
+       { &vnop_link_desc, (vnop_t *)nfs3_vnop_link },          /* link */
+       { &vnop_rename_desc, (vnop_t *)nfs_vnop_rename },       /* rename */
+       { &vnop_mkdir_desc, (vnop_t *)nfs3_vnop_mkdir },        /* mkdir */
+       { &vnop_rmdir_desc, (vnop_t *)nfs3_vnop_rmdir },        /* rmdir */
+       { &vnop_symlink_desc, (vnop_t *)nfs3_vnop_symlink },    /* symlink */
+       { &vnop_readdir_desc, (vnop_t *)nfs_vnop_readdir },     /* readdir */
+       { &vnop_readlink_desc, (vnop_t *)nfs_vnop_readlink },   /* readlink */
+       { &vnop_inactive_desc, (vnop_t *)nfs_vnop_inactive },   /* inactive */
+       { &vnop_reclaim_desc, (vnop_t *)nfs_vnop_reclaim },     /* reclaim */
+       { &vnop_strategy_desc, (vnop_t *)err_strategy },        /* strategy */
+       { &vnop_pathconf_desc, (vnop_t *)nfs_vnop_pathconf },   /* pathconf */
+       { &vnop_advlock_desc, (vnop_t *)nfs3_vnop_advlock },    /* advlock */
+       { &vnop_bwrite_desc, (vnop_t *)err_bwrite },            /* bwrite */
+       { &vnop_pagein_desc, (vnop_t *)nfs_vnop_pagein },       /* Pagein */
+       { &vnop_pageout_desc, (vnop_t *)nfs_vnop_pageout },     /* Pageout */
+       { &vnop_copyfile_desc, (vnop_t *)err_copyfile },        /* Copyfile */
+       { &vnop_blktooff_desc, (vnop_t *)nfs_vnop_blktooff },   /* blktooff */
+       { &vnop_offtoblk_desc, (vnop_t *)nfs_vnop_offtoblk },   /* offtoblk */
+       { &vnop_blockmap_desc, (vnop_t *)nfs_vnop_blockmap },   /* blockmap */
        { NULL, NULL }
 };
 struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
        { &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
-#ifdef __FreeBSD__
-VNODEOP_SET(nfsv2_vnodeop_opv_desc);
-#endif
+
+vnop_t **nfsv4_vnodeop_p;
+static struct vnodeopv_entry_desc nfsv4_vnodeop_entries[] = {
+       { &vnop_default_desc, (vnop_t *)vn_default_error },
+       { &vnop_lookup_desc, (vnop_t *)nfs_vnop_lookup },       /* lookup */
+       { &vnop_create_desc, (vnop_t *)nfs4_vnop_create },      /* create */
+       { &vnop_mknod_desc, (vnop_t *)nfs4_vnop_mknod },        /* mknod */
+       { &vnop_open_desc, (vnop_t *)nfs4_vnop_open },          /* open */
+       { &vnop_close_desc, (vnop_t *)nfs4_vnop_close },        /* close */
+       { &vnop_access_desc, (vnop_t *)nfs_vnop_access },       /* access */
+       { &vnop_getattr_desc, (vnop_t *)nfs4_vnop_getattr },    /* getattr */
+       { &vnop_setattr_desc, (vnop_t *)nfs_vnop_setattr },     /* setattr */
+       { &vnop_read_desc, (vnop_t *)nfs4_vnop_read },          /* read */
+       { &vnop_write_desc, (vnop_t *)nfs_vnop_write },         /* write */
+       { &vnop_ioctl_desc, (vnop_t *)nfs_vnop_ioctl },         /* ioctl */
+       { &vnop_select_desc, (vnop_t *)nfs_vnop_select },       /* select */
+       { &vnop_revoke_desc, (vnop_t *)nfs_vnop_revoke },       /* revoke */
+       { &vnop_mmap_desc, (vnop_t *)nfs4_vnop_mmap },          /* mmap */
+       { &vnop_mnomap_desc, (vnop_t *)nfs4_vnop_mnomap },      /* mnomap */
+       { &vnop_fsync_desc, (vnop_t *)nfs_vnop_fsync },         /* fsync */
+       { &vnop_remove_desc, (vnop_t *)nfs_vnop_remove },       /* remove */
+       { &vnop_link_desc, (vnop_t *)nfs4_vnop_link },          /* link */
+       { &vnop_rename_desc, (vnop_t *)nfs_vnop_rename },       /* rename */
+       { &vnop_mkdir_desc, (vnop_t *)nfs4_vnop_mkdir },        /* mkdir */
+       { &vnop_rmdir_desc, (vnop_t *)nfs4_vnop_rmdir },        /* rmdir */
+       { &vnop_symlink_desc, (vnop_t *)nfs4_vnop_symlink },    /* symlink */
+       { &vnop_readdir_desc, (vnop_t *)nfs_vnop_readdir },     /* readdir */
+       { &vnop_readlink_desc, (vnop_t *)nfs_vnop_readlink },   /* readlink */
+       { &vnop_inactive_desc, (vnop_t *)nfs_vnop_inactive },   /* inactive */
+       { &vnop_reclaim_desc, (vnop_t *)nfs_vnop_reclaim },     /* reclaim */
+       { &vnop_strategy_desc, (vnop_t *)err_strategy },        /* strategy */
+       { &vnop_pathconf_desc, (vnop_t *)nfs_vnop_pathconf },   /* pathconf */
+       { &vnop_advlock_desc, (vnop_t *)nfs4_vnop_advlock },    /* advlock */
+       { &vnop_bwrite_desc, (vnop_t *)err_bwrite },            /* bwrite */
+       { &vnop_pagein_desc, (vnop_t *)nfs_vnop_pagein },       /* Pagein */
+       { &vnop_pageout_desc, (vnop_t *)nfs_vnop_pageout },     /* Pageout */
+       { &vnop_copyfile_desc, (vnop_t *)err_copyfile },        /* Copyfile */
+       { &vnop_blktooff_desc, (vnop_t *)nfs_vnop_blktooff },   /* blktooff */
+       { &vnop_offtoblk_desc, (vnop_t *)nfs_vnop_offtoblk },   /* offtoblk */
+       { &vnop_blockmap_desc, (vnop_t *)nfs_vnop_blockmap },   /* blockmap */
+       { NULL, NULL }
+};
+struct vnodeopv_desc nfsv4_vnodeop_opv_desc =
+       { &nfsv4_vnodeop_p, nfsv4_vnodeop_entries };
 
 /*
  * Special device vnode ops
  */
-vop_t **spec_nfsv2nodeop_p;
+vnop_t **spec_nfsv2nodeop_p;
 static struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
-       { &vop_default_desc, (vop_t *)vn_default_error },
-       { &vop_lookup_desc, (vop_t *)spec_lookup },     /* lookup */
-       { &vop_create_desc, (vop_t *)spec_create },     /* create */
-       { &vop_mknod_desc, (vop_t *)spec_mknod },       /* mknod */
-       { &vop_open_desc, (vop_t *)spec_open },         /* open */
-       { &vop_close_desc, (vop_t *)nfsspec_close },    /* close */
-       { &vop_access_desc, (vop_t *)nfsspec_access },  /* access */
-       { &vop_getattr_desc, (vop_t *)nfs_getattr },    /* getattr */
-       { &vop_setattr_desc, (vop_t *)nfs_setattr },    /* setattr */
-       { &vop_read_desc, (vop_t *)nfsspec_read },      /* read */
-       { &vop_write_desc, (vop_t *)nfsspec_write },    /* write */
-       { &vop_lease_desc, (vop_t *)spec_lease_check }, /* lease */
-       { &vop_ioctl_desc, (vop_t *)spec_ioctl },       /* ioctl */
-       { &vop_select_desc, (vop_t *)spec_select },     /* select */
-       { &vop_revoke_desc, (vop_t *)spec_revoke },     /* revoke */
-       { &vop_mmap_desc, (vop_t *)spec_mmap },         /* mmap */
-       { &vop_fsync_desc, (vop_t *)nfs_fsync },        /* fsync */
-       { &vop_seek_desc, (vop_t *)spec_seek },         /* seek */
-       { &vop_remove_desc, (vop_t *)spec_remove },     /* remove */
-       { &vop_link_desc, (vop_t *)spec_link },         /* link */
-       { &vop_rename_desc, (vop_t *)spec_rename },     /* rename */
-       { &vop_mkdir_desc, (vop_t *)spec_mkdir },       /* mkdir */
-       { &vop_rmdir_desc, (vop_t *)spec_rmdir },       /* rmdir */
-       { &vop_symlink_desc, (vop_t *)spec_symlink },   /* symlink */
-       { &vop_readdir_desc, (vop_t *)spec_readdir },   /* readdir */
-       { &vop_readlink_desc, (vop_t *)spec_readlink }, /* readlink */
-       { &vop_abortop_desc, (vop_t *)spec_abortop },   /* abortop */
-       { &vop_inactive_desc, (vop_t *)nfs_inactive },  /* inactive */
-       { &vop_reclaim_desc, (vop_t *)nfs_reclaim },    /* reclaim */
-       { &vop_lock_desc, (vop_t *)nfs_lock },          /* lock */
-       { &vop_unlock_desc, (vop_t *)nfs_unlock },      /* unlock */
-       { &vop_bmap_desc, (vop_t *)spec_bmap },         /* bmap */
-       { &vop_strategy_desc, (vop_t *)spec_strategy }, /* strategy */
-       { &vop_print_desc, (vop_t *)nfs_print },        /* print */
-       { &vop_islocked_desc, (vop_t *)nfs_islocked },  /* islocked */
-       { &vop_pathconf_desc, (vop_t *)spec_pathconf }, /* pathconf */
-       { &vop_advlock_desc, (vop_t *)spec_advlock },   /* advlock */
-       { &vop_blkatoff_desc, (vop_t *)spec_blkatoff }, /* blkatoff */
-       { &vop_valloc_desc, (vop_t *)spec_valloc },     /* valloc */
-       { &vop_reallocblks_desc, (vop_t *)spec_reallocblks },   /* reallocblks */
-       { &vop_vfree_desc, (vop_t *)spec_vfree },       /* vfree */
-       { &vop_truncate_desc, (vop_t *)spec_truncate }, /* truncate */
-       { &vop_update_desc, (vop_t *)nfs_update },      /* update */
-       { &vop_bwrite_desc, (vop_t *)vn_bwrite },       /* bwrite */
-       { &vop_devblocksize_desc, (vop_t *)spec_devblocksize },  /* devblocksize */
-       { &vop_pagein_desc, (vop_t *)nfs_pagein },              /* Pagein */
-       { &vop_pageout_desc, (vop_t *)nfs_pageout },            /* Pageout */
-       { &vop_blktooff_desc, (vop_t *)nfs_blktooff },          /* blktooff */
-       { &vop_offtoblk_desc, (vop_t *)nfs_offtoblk },          /* offtoblk */
-       { &vop_cmap_desc, (vop_t *)nfs_cmap },          /* cmap */
+       { &vnop_default_desc, (vnop_t *)vn_default_error },
+       { &vnop_lookup_desc, (vnop_t *)spec_lookup },           /* lookup */
+       { &vnop_create_desc, (vnop_t *)spec_create },           /* create */
+       { &vnop_mknod_desc, (vnop_t *)spec_mknod },             /* mknod */
+       { &vnop_open_desc, (vnop_t *)spec_open },               /* open */
+       { &vnop_close_desc, (vnop_t *)nfsspec_vnop_close },     /* close */
+       { &vnop_getattr_desc, (vnop_t *)nfs3_vnop_getattr },    /* getattr */
+       { &vnop_setattr_desc, (vnop_t *)nfs_vnop_setattr },     /* setattr */
+       { &vnop_read_desc, (vnop_t *)nfsspec_vnop_read },       /* read */
+       { &vnop_write_desc, (vnop_t *)nfsspec_vnop_write },     /* write */
+       { &vnop_ioctl_desc, (vnop_t *)spec_ioctl },             /* ioctl */
+       { &vnop_select_desc, (vnop_t *)spec_select },           /* select */
+       { &vnop_revoke_desc, (vnop_t *)spec_revoke },           /* revoke */
+       { &vnop_mmap_desc, (vnop_t *)spec_mmap },               /* mmap */
+       { &vnop_fsync_desc, (vnop_t *)nfs_vnop_fsync },         /* fsync */
+       { &vnop_remove_desc, (vnop_t *)spec_remove },           /* remove */
+       { &vnop_link_desc, (vnop_t *)spec_link },               /* link */
+       { &vnop_rename_desc, (vnop_t *)spec_rename },           /* rename */
+       { &vnop_mkdir_desc, (vnop_t *)spec_mkdir },             /* mkdir */
+       { &vnop_rmdir_desc, (vnop_t *)spec_rmdir },             /* rmdir */
+       { &vnop_symlink_desc, (vnop_t *)spec_symlink },         /* symlink */
+       { &vnop_readdir_desc, (vnop_t *)spec_readdir },         /* readdir */
+       { &vnop_readlink_desc, (vnop_t *)spec_readlink },       /* readlink */
+       { &vnop_inactive_desc, (vnop_t *)nfs_vnop_inactive },   /* inactive */
+       { &vnop_reclaim_desc, (vnop_t *)nfs_vnop_reclaim },     /* reclaim */
+       { &vnop_strategy_desc, (vnop_t *)spec_strategy },       /* strategy */
+       { &vnop_pathconf_desc, (vnop_t *)spec_pathconf },       /* pathconf */
+       { &vnop_advlock_desc, (vnop_t *)spec_advlock },         /* advlock */
+       { &vnop_bwrite_desc, (vnop_t *)vn_bwrite },             /* bwrite */
+       { &vnop_pagein_desc, (vnop_t *)nfs_vnop_pagein },       /* Pagein */
+       { &vnop_pageout_desc, (vnop_t *)nfs_vnop_pageout },     /* Pageout */
+       { &vnop_blktooff_desc, (vnop_t *)nfs_vnop_blktooff },   /* blktooff */
+       { &vnop_offtoblk_desc, (vnop_t *)nfs_vnop_offtoblk },   /* offtoblk */
+       { &vnop_blockmap_desc, (vnop_t *)nfs_vnop_blockmap },   /* blockmap */
        { NULL, NULL }
 };
 struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
        { &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
-#ifdef __FreeBSD__
-VNODEOP_SET(spec_nfsv2nodeop_opv_desc);
-#endif
+vnop_t **spec_nfsv4nodeop_p;
+static struct vnodeopv_entry_desc spec_nfsv4nodeop_entries[] = {
+       { &vnop_default_desc, (vnop_t *)vn_default_error },
+       { &vnop_lookup_desc, (vnop_t *)spec_lookup },           /* lookup */
+       { &vnop_create_desc, (vnop_t *)spec_create },           /* create */
+       { &vnop_mknod_desc, (vnop_t *)spec_mknod },             /* mknod */
+       { &vnop_open_desc, (vnop_t *)spec_open },               /* open */
+       { &vnop_close_desc, (vnop_t *)nfsspec_vnop_close },     /* close */
+       { &vnop_getattr_desc, (vnop_t *)nfs4_vnop_getattr },    /* getattr */
+       { &vnop_setattr_desc, (vnop_t *)nfs_vnop_setattr },     /* setattr */
+       { &vnop_read_desc, (vnop_t *)nfsspec_vnop_read },       /* read */
+       { &vnop_write_desc, (vnop_t *)nfsspec_vnop_write },     /* write */
+       { &vnop_ioctl_desc, (vnop_t *)spec_ioctl },             /* ioctl */
+       { &vnop_select_desc, (vnop_t *)spec_select },           /* select */
+       { &vnop_revoke_desc, (vnop_t *)spec_revoke },           /* revoke */
+       { &vnop_mmap_desc, (vnop_t *)spec_mmap },               /* mmap */
+       { &vnop_fsync_desc, (vnop_t *)nfs_vnop_fsync },         /* fsync */
+       { &vnop_remove_desc, (vnop_t *)spec_remove },           /* remove */
+       { &vnop_link_desc, (vnop_t *)spec_link },               /* link */
+       { &vnop_rename_desc, (vnop_t *)spec_rename },           /* rename */
+       { &vnop_mkdir_desc, (vnop_t *)spec_mkdir },             /* mkdir */
+       { &vnop_rmdir_desc, (vnop_t *)spec_rmdir },             /* rmdir */
+       { &vnop_symlink_desc, (vnop_t *)spec_symlink },         /* symlink */
+       { &vnop_readdir_desc, (vnop_t *)spec_readdir },         /* readdir */
+       { &vnop_readlink_desc, (vnop_t *)spec_readlink },       /* readlink */
+       { &vnop_inactive_desc, (vnop_t *)nfs_vnop_inactive },   /* inactive */
+       { &vnop_reclaim_desc, (vnop_t *)nfs_vnop_reclaim },     /* reclaim */
+       { &vnop_strategy_desc, (vnop_t *)spec_strategy },       /* strategy */
+       { &vnop_pathconf_desc, (vnop_t *)spec_pathconf },       /* pathconf */
+       { &vnop_advlock_desc, (vnop_t *)spec_advlock },         /* advlock */
+       { &vnop_bwrite_desc, (vnop_t *)vn_bwrite },             /* bwrite */
+       { &vnop_pagein_desc, (vnop_t *)nfs_vnop_pagein },       /* Pagein */
+       { &vnop_pageout_desc, (vnop_t *)nfs_vnop_pageout },     /* Pageout */
+       { &vnop_blktooff_desc, (vnop_t *)nfs_vnop_blktooff },   /* blktooff */
+       { &vnop_offtoblk_desc, (vnop_t *)nfs_vnop_offtoblk },   /* offtoblk */
+       { &vnop_blockmap_desc, (vnop_t *)nfs_vnop_blockmap },   /* blockmap */
+       { NULL, NULL }
+};
+struct vnodeopv_desc spec_nfsv4nodeop_opv_desc =
+       { &spec_nfsv4nodeop_p, spec_nfsv4nodeop_entries };
 
-vop_t **fifo_nfsv2nodeop_p;
+#if FIFO
+vnop_t **fifo_nfsv2nodeop_p;
 static struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
-       { &vop_default_desc, (vop_t *)vn_default_error },
-       { &vop_lookup_desc, (vop_t *)fifo_lookup },     /* lookup */
-       { &vop_create_desc, (vop_t *)fifo_create },     /* create */
-       { &vop_mknod_desc, (vop_t *)fifo_mknod },       /* mknod */
-       { &vop_open_desc, (vop_t *)fifo_open },         /* open */
-       { &vop_close_desc, (vop_t *)nfsfifo_close },    /* close */
-       { &vop_access_desc, (vop_t *)nfsspec_access },  /* access */
-       { &vop_getattr_desc, (vop_t *)nfs_getattr },    /* getattr */
-       { &vop_setattr_desc, (vop_t *)nfs_setattr },    /* setattr */
-       { &vop_read_desc, (vop_t *)nfsfifo_read },      /* read */
-       { &vop_write_desc, (vop_t *)nfsfifo_write },    /* write */
-       { &vop_lease_desc, (vop_t *)fifo_lease_check }, /* lease */
-       { &vop_ioctl_desc, (vop_t *)fifo_ioctl },       /* ioctl */
-       { &vop_select_desc, (vop_t *)fifo_select },     /* select */
-       { &vop_revoke_desc, (vop_t *)fifo_revoke },     /* revoke */
-       { &vop_mmap_desc, (vop_t *)fifo_mmap },         /* mmap */
-       { &vop_fsync_desc, (vop_t *)nfs_fsync },        /* fsync */
-       { &vop_seek_desc, (vop_t *)fifo_seek },         /* seek */
-       { &vop_remove_desc, (vop_t *)fifo_remove },     /* remove */
-       { &vop_link_desc, (vop_t *)fifo_link },         /* link */
-       { &vop_rename_desc, (vop_t *)fifo_rename },     /* rename */
-       { &vop_mkdir_desc, (vop_t *)fifo_mkdir },       /* mkdir */
-       { &vop_rmdir_desc, (vop_t *)fifo_rmdir },       /* rmdir */
-       { &vop_symlink_desc, (vop_t *)fifo_symlink },   /* symlink */
-       { &vop_readdir_desc, (vop_t *)fifo_readdir },   /* readdir */
-       { &vop_readlink_desc, (vop_t *)fifo_readlink }, /* readlink */
-       { &vop_abortop_desc, (vop_t *)fifo_abortop },   /* abortop */
-       { &vop_inactive_desc, (vop_t *)nfs_inactive },  /* inactive */
-       { &vop_reclaim_desc, (vop_t *)nfs_reclaim },    /* reclaim */
-       { &vop_lock_desc, (vop_t *)nfs_lock },          /* lock */
-       { &vop_unlock_desc, (vop_t *)nfs_unlock },      /* unlock */
-       { &vop_bmap_desc, (vop_t *)fifo_bmap },         /* bmap */
-       { &vop_strategy_desc, (vop_t *)fifo_strategy }, /* strategy */
-       { &vop_print_desc, (vop_t *)nfs_print },        /* print */
-       { &vop_islocked_desc, (vop_t *)nfs_islocked },  /* islocked */
-       { &vop_pathconf_desc, (vop_t *)fifo_pathconf }, /* pathconf */
-       { &vop_advlock_desc, (vop_t *)fifo_advlock },   /* advlock */
-       { &vop_blkatoff_desc, (vop_t *)fifo_blkatoff }, /* blkatoff */
-       { &vop_valloc_desc, (vop_t *)fifo_valloc },     /* valloc */
-       { &vop_reallocblks_desc, (vop_t *)fifo_reallocblks },   /* reallocblks */
-       { &vop_vfree_desc, (vop_t *)fifo_vfree },       /* vfree */
-       { &vop_truncate_desc, (vop_t *)fifo_truncate }, /* truncate */
-       { &vop_update_desc, (vop_t *)nfs_update },      /* update */
-       { &vop_bwrite_desc, (vop_t *)vn_bwrite },       /* bwrite */
-       { &vop_pagein_desc, (vop_t *)nfs_pagein },              /* Pagein */
-       { &vop_pageout_desc, (vop_t *)nfs_pageout },            /* Pageout */
-       { &vop_blktooff_desc, (vop_t *)nfs_blktooff },          /* blktooff */
-       { &vop_offtoblk_desc, (vop_t *)nfs_offtoblk },          /* offtoblk */
-       { &vop_cmap_desc, (vop_t *)nfs_cmap },          /* cmap */
+       { &vnop_default_desc, (vnop_t *)vn_default_error },
+       { &vnop_lookup_desc, (vnop_t *)fifo_lookup },           /* lookup */
+       { &vnop_create_desc, (vnop_t *)fifo_create },           /* create */
+       { &vnop_mknod_desc, (vnop_t *)fifo_mknod },             /* mknod */
+       { &vnop_open_desc, (vnop_t *)fifo_open },               /* open */
+       { &vnop_close_desc, (vnop_t *)nfsfifo_vnop_close },     /* close */
+       { &vnop_getattr_desc, (vnop_t *)nfs3_vnop_getattr },    /* getattr */
+       { &vnop_setattr_desc, (vnop_t *)nfs_vnop_setattr },     /* setattr */
+       { &vnop_read_desc, (vnop_t *)nfsfifo_vnop_read },       /* read */
+       { &vnop_write_desc, (vnop_t *)nfsfifo_vnop_write },     /* write */
+       { &vnop_ioctl_desc, (vnop_t *)fifo_ioctl },             /* ioctl */
+       { &vnop_select_desc, (vnop_t *)fifo_select },           /* select */
+       { &vnop_revoke_desc, (vnop_t *)fifo_revoke },           /* revoke */
+       { &vnop_mmap_desc, (vnop_t *)fifo_mmap },               /* mmap */
+       { &vnop_fsync_desc, (vnop_t *)nfs_vnop_fsync },         /* fsync */
+       { &vnop_remove_desc, (vnop_t *)fifo_remove },           /* remove */
+       { &vnop_link_desc, (vnop_t *)fifo_link },               /* link */
+       { &vnop_rename_desc, (vnop_t *)fifo_rename },           /* rename */
+       { &vnop_mkdir_desc, (vnop_t *)fifo_mkdir },             /* mkdir */
+       { &vnop_rmdir_desc, (vnop_t *)fifo_rmdir },             /* rmdir */
+       { &vnop_symlink_desc, (vnop_t *)fifo_symlink },         /* symlink */
+       { &vnop_readdir_desc, (vnop_t *)fifo_readdir },         /* readdir */
+       { &vnop_readlink_desc, (vnop_t *)fifo_readlink },       /* readlink */
+       { &vnop_inactive_desc, (vnop_t *)nfs_vnop_inactive },   /* inactive */
+       { &vnop_reclaim_desc, (vnop_t *)nfs_vnop_reclaim },     /* reclaim */
+       { &vnop_strategy_desc, (vnop_t *)fifo_strategy },       /* strategy */
+       { &vnop_pathconf_desc, (vnop_t *)fifo_pathconf },       /* pathconf */
+       { &vnop_advlock_desc, (vnop_t *)fifo_advlock },         /* advlock */
+       { &vnop_bwrite_desc, (vnop_t *)vn_bwrite },             /* bwrite */
+       { &vnop_pagein_desc, (vnop_t *)nfs_vnop_pagein },       /* Pagein */
+       { &vnop_pageout_desc, (vnop_t *)nfs_vnop_pageout },     /* Pageout */
+       { &vnop_blktooff_desc, (vnop_t *)nfs_vnop_blktooff },   /* blktooff */
+       { &vnop_offtoblk_desc, (vnop_t *)nfs_vnop_offtoblk },   /* offtoblk */
+       { &vnop_blockmap_desc, (vnop_t *)nfs_vnop_blockmap },   /* blockmap */
        { NULL, NULL }
 };
 struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
        { &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
-#ifdef __FreeBSD__
-VNODEOP_SET(fifo_nfsv2nodeop_opv_desc);
-#endif
-
-static int     nfs_mknodrpc __P((struct vnode *dvp, struct vnode **vpp,
-                                 struct componentname *cnp,
-                                 struct vattr *vap));
-static int     nfs_removerpc __P((struct vnode *dvp, char *name, int namelen,
-                                  struct ucred *cred, struct proc *proc));
-static int     nfs_renamerpc __P((struct vnode *fdvp, char *fnameptr,
-                                  int fnamelen, struct vnode *tdvp,
-                                  char *tnameptr, int tnamelen,
-                                  struct ucred *cred, struct proc *proc));
-static int     nfs_renameit __P((struct vnode *sdvp,
-                                 struct componentname *scnp,
-                                 struct sillyrename *sp));
-
-/*
- * Global variables
- */
-extern u_long nfs_true, nfs_false;
-extern struct nfsstats nfsstats;
-extern nfstype nfsv3_type[9];
-struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
-struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON];
-int nfs_numasync = 0;
-int nfs_ioddelwri = 0;
-#define        DIRHDSIZ        (sizeof (struct dirent) - (MAXNAMLEN + 1))
-
-static int     nfsaccess_cache_timeout = NFS_MAXATTRTIMO;
-/* SYSCTL_INT(_vfs_nfs, OID_AUTO, access_cache_timeout, CTLFLAG_RW,
-           &nfsaccess_cache_timeout, 0, "NFS ACCESS cache timeout");
-*/
-#define        NFSV3ACCESS_ALL (NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY          \
-                        | NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE     \
-                        | NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP)
-                         
-
-/* 
- * the following are needed only by nfs_pageout to know how to handle errors
- * see nfs_pageout comments on explanation of actions.
- * the errors here are copied from errno.h and errors returned by servers
- * are expected to match the same numbers here. If not, our actions maybe
- * erroneous.
- */
-enum actiontype {NOACTION, DUMP, DUMPANDLOG, RETRY, RETRYWITHSLEEP, SEVER};
-
-static int errorcount[ELAST+1]; /* better be zeros when initialized */
-
-static const short errortooutcome[ELAST+1] = {
-       NOACTION,
-       DUMP,                   /* EPERM        1       Operation not permitted */
-       DUMP,                   /* ENOENT       2       No such file or directory */
-       DUMPANDLOG,             /* ESRCH        3       No such process */
-       RETRY,                  /* EINTR        4       Interrupted system call */
-       DUMP,                   /* EIO          5       Input/output error */
-       DUMP,                   /* ENXIO        6       Device not configured */
-       DUMPANDLOG,             /* E2BIG        7       Argument list too long */
-       DUMPANDLOG,             /* ENOEXEC      8       Exec format error */
-       DUMPANDLOG,             /* EBADF        9       Bad file descriptor */
-       DUMPANDLOG,             /* ECHILD       10      No child processes */
-       DUMPANDLOG,             /* EDEADLK      11      Resource deadlock avoided - was EAGAIN */
-       RETRY,                  /* ENOMEM       12      Cannot allocate memory */
-       DUMP,                   /* EACCES       13      Permission denied */
-       DUMPANDLOG,             /* EFAULT       14      Bad address */
-       DUMPANDLOG,             /* ENOTBLK      15      POSIX - Block device required */
-       RETRY,                  /* EBUSY        16      Device busy */
-       DUMP,                   /* EEXIST       17      File exists */
-       DUMP,                   /* EXDEV        18      Cross-device link */
-       DUMP,                   /* ENODEV       19      Operation not supported by device */
-       DUMP,                   /* ENOTDIR      20      Not a directory */
-       DUMP,                   /* EISDIR       21      Is a directory */
-       DUMP,                   /* EINVAL       22      Invalid argument */
-       DUMPANDLOG,             /* ENFILE       23      Too many open files in system */
-       DUMPANDLOG,             /* EMFILE       24      Too many open files */
-       DUMPANDLOG,             /* ENOTTY       25      Inappropriate ioctl for device */
-       DUMPANDLOG,             /* ETXTBSY      26      Text file busy - POSIX */
-       DUMP,                   /* EFBIG        27      File too large */
-       DUMP,                   /* ENOSPC       28      No space left on device */
-       DUMPANDLOG,             /* ESPIPE       29      Illegal seek */
-       DUMP,                   /* EROFS        30      Read-only file system */
-       DUMP,                   /* EMLINK       31      Too many links */
-       RETRY,                  /* EPIPE        32      Broken pipe */
-       /* math software */
-       DUMPANDLOG,             /* EDOM                         33      Numerical argument out of domain */
-       DUMPANDLOG,             /* ERANGE                       34      Result too large */
-       RETRY,                  /* EAGAIN/EWOULDBLOCK   35      Resource temporarily unavailable */
-       DUMPANDLOG,             /* EINPROGRESS          36      Operation now in progress */
-       DUMPANDLOG,             /* EALREADY                     37      Operation already in progress */
-       /* ipc/network software -- argument errors */
-       DUMPANDLOG,             /* ENOTSOC                      38      Socket operation on non-socket */
-       DUMPANDLOG,             /* EDESTADDRREQ         39      Destination address required */
-       DUMPANDLOG,             /* EMSGSIZE                     40      Message too long */
-       DUMPANDLOG,             /* EPROTOTYPE           41      Protocol wrong type for socket */
-       DUMPANDLOG,             /* ENOPROTOOPT          42      Protocol not available */
-       DUMPANDLOG,             /* EPROTONOSUPPORT      43      Protocol not supported */
-       DUMPANDLOG,             /* ESOCKTNOSUPPORT      44      Socket type not supported */
-       DUMPANDLOG,             /* ENOTSUP                      45      Operation not supported */
-       DUMPANDLOG,             /* EPFNOSUPPORT         46      Protocol family not supported */
-       DUMPANDLOG,             /* EAFNOSUPPORT         47      Address family not supported by protocol family */
-       DUMPANDLOG,             /* EADDRINUSE           48      Address already in use */
-       DUMPANDLOG,             /* EADDRNOTAVAIL        49      Can't assign requested address */
-       /* ipc/network software -- operational errors */
-       RETRY,                  /* ENETDOWN                     50      Network is down */
-       RETRY,                  /* ENETUNREACH          51      Network is unreachable */
-       RETRY,                  /* ENETRESET            52      Network dropped connection on reset */
-       RETRY,                  /* ECONNABORTED         53      Software caused connection abort */
-       RETRY,                  /* ECONNRESET           54      Connection reset by peer */
-       RETRY,                  /* ENOBUFS                      55      No buffer space available */
-       RETRY,                  /* EISCONN                      56      Socket is already connected */
-       RETRY,                  /* ENOTCONN                     57      Socket is not connected */
-       RETRY,                  /* ESHUTDOWN            58      Can't send after socket shutdown */
-       RETRY,                  /* ETOOMANYREFS         59      Too many references: can't splice */
-       RETRY,                  /* ETIMEDOUT            60      Operation timed out */
-       RETRY,                  /* ECONNREFUSED         61      Connection refused */
-
-       DUMPANDLOG,             /* ELOOP                        62      Too many levels of symbolic links */
-       DUMP,                   /* ENAMETOOLONG         63      File name too long */
-       RETRY,                  /* EHOSTDOWN            64      Host is down */ 
-       RETRY,                  /* EHOSTUNREACH         65      No route to host */
-       DUMP,                   /* ENOTEMPTY            66      Directory not empty */
-       /* quotas & mush */     
-       DUMPANDLOG,             /* PROCLIM                      67      Too many processes */
-       DUMPANDLOG,             /* EUSERS                       68      Too many users */
-       DUMPANDLOG,             /* EDQUOT                       69      Disc quota exceeded */   
-       /* Network File System */
-       DUMP,                   /* ESTALE                       70      Stale NFS file handle */
-       DUMP,                   /* EREMOTE                      71      Too many levels of remote in path */
-       DUMPANDLOG,             /* EBADRPC                      72      RPC struct is bad */
-       DUMPANDLOG,             /* ERPCMISMATCH         73      RPC version wrong */
-       DUMPANDLOG,             /* EPROGUNAVAIL         74      RPC prog. not avail */
-       DUMPANDLOG,             /* EPROGMISMATCH        75      Program version wrong */
-       DUMPANDLOG,             /* EPROCUNAVAIL         76      Bad procedure for program */
 
-       DUMPANDLOG,             /* ENOLCK                       77      No locks available */
-       DUMPANDLOG,             /* ENOSYS                       78      Function not implemented */
-       DUMPANDLOG,             /* EFTYPE                       79      Inappropriate file type or format */  
-       DUMPANDLOG,             /* EAUTH                        80      Authentication error */
-       DUMPANDLOG,             /* ENEEDAUTH            81      Need authenticator */
-       /* Intelligent device errors */
-       DUMPANDLOG,             /* EPWROFF                      82      Device power is off */
-       DUMPANDLOG,             /* EDEVERR                      83      Device error, e.g. paper out */
-       DUMPANDLOG,             /* EOVERFLOW            84      Value too large to be stored in data type */
-       /* Program loading errors */
-       DUMPANDLOG,             /* EBADEXEC                     85      Bad executable */
-       DUMPANDLOG,             /* EBADARCH                     86      Bad CPU type in executable */
-       DUMPANDLOG,             /* ESHLIBVERS           87      Shared library version mismatch */
-       DUMPANDLOG,             /* EBADMACHO            88      Malformed Macho file */
+vnop_t **fifo_nfsv4nodeop_p;
+static struct vnodeopv_entry_desc fifo_nfsv4nodeop_entries[] = {
+       { &vnop_default_desc, (vnop_t *)vn_default_error },
+       { &vnop_lookup_desc, (vnop_t *)fifo_lookup },           /* lookup */
+       { &vnop_create_desc, (vnop_t *)fifo_create },           /* create */
+       { &vnop_mknod_desc, (vnop_t *)fifo_mknod },             /* mknod */
+       { &vnop_open_desc, (vnop_t *)fifo_open },               /* open */
+       { &vnop_close_desc, (vnop_t *)nfsfifo_vnop_close },     /* close */
+       { &vnop_getattr_desc, (vnop_t *)nfs4_vnop_getattr },    /* getattr */
+       { &vnop_setattr_desc, (vnop_t *)nfs_vnop_setattr },     /* setattr */
+       { &vnop_read_desc, (vnop_t *)nfsfifo_vnop_read },       /* read */
+       { &vnop_write_desc, (vnop_t *)nfsfifo_vnop_write },     /* write */
+       { &vnop_ioctl_desc, (vnop_t *)fifo_ioctl },             /* ioctl */
+       { &vnop_select_desc, (vnop_t *)fifo_select },           /* select */
+       { &vnop_revoke_desc, (vnop_t *)fifo_revoke },           /* revoke */
+       { &vnop_mmap_desc, (vnop_t *)fifo_mmap },               /* mmap */
+       { &vnop_fsync_desc, (vnop_t *)nfs_vnop_fsync },         /* fsync */
+       { &vnop_remove_desc, (vnop_t *)fifo_remove },           /* remove */
+       { &vnop_link_desc, (vnop_t *)fifo_link },               /* link */
+       { &vnop_rename_desc, (vnop_t *)fifo_rename },           /* rename */
+       { &vnop_mkdir_desc, (vnop_t *)fifo_mkdir },             /* mkdir */
+       { &vnop_rmdir_desc, (vnop_t *)fifo_rmdir },             /* rmdir */
+       { &vnop_symlink_desc, (vnop_t *)fifo_symlink },         /* symlink */
+       { &vnop_readdir_desc, (vnop_t *)fifo_readdir },         /* readdir */
+       { &vnop_readlink_desc, (vnop_t *)fifo_readlink },       /* readlink */
+       { &vnop_inactive_desc, (vnop_t *)nfs_vnop_inactive },   /* inactive */
+       { &vnop_reclaim_desc, (vnop_t *)nfs_vnop_reclaim },     /* reclaim */
+       { &vnop_strategy_desc, (vnop_t *)fifo_strategy },       /* strategy */
+       { &vnop_pathconf_desc, (vnop_t *)fifo_pathconf },       /* pathconf */
+       { &vnop_advlock_desc, (vnop_t *)fifo_advlock },         /* advlock */
+       { &vnop_bwrite_desc, (vnop_t *)vn_bwrite },             /* bwrite */
+       { &vnop_pagein_desc, (vnop_t *)nfs_vnop_pagein },       /* Pagein */
+       { &vnop_pageout_desc, (vnop_t *)nfs_vnop_pageout },     /* Pageout */
+       { &vnop_blktooff_desc, (vnop_t *)nfs_vnop_blktooff },   /* blktooff */
+       { &vnop_offtoblk_desc, (vnop_t *)nfs_vnop_offtoblk },   /* offtoblk */
+       { &vnop_blockmap_desc, (vnop_t *)nfs_vnop_blockmap },   /* blockmap */
+       { NULL, NULL }
 };
+struct vnodeopv_desc fifo_nfsv4nodeop_opv_desc =
+       { &fifo_nfsv4nodeop_p, fifo_nfsv4nodeop_entries };
+#endif /* FIFO */
 
 
-static short
-nfs_pageouterrorhandler(error)
-       int error;
+int    nfs_sillyrename(nfsnode_t,nfsnode_t,struct componentname *,vfs_context_t);
+
+/*
+ * Find the slot in the access cache for this UID.
+ * If adding and no existing slot is found, reuse slots in FIFO order.
+ * The index of the next slot to use is kept in the last entry of the n_mode array.
+ */
+int
+nfs_node_mode_slot(nfsnode_t np, uid_t uid, int add)
 {
-       if (error > ELAST) 
-               return(DUMP);
-       else 
-               return(errortooutcome[error]);
+       int slot;
+
+       for (slot=0; slot < NFS_ACCESS_CACHE_SIZE; slot++)
+               if (np->n_modeuid[slot] == uid)
+                       break;
+       if (slot == NFS_ACCESS_CACHE_SIZE) {
+               if (!add)
+                       return (-1);
+               slot = np->n_mode[NFS_ACCESS_CACHE_SIZE];
+               np->n_mode[NFS_ACCESS_CACHE_SIZE] = (slot + 1) % NFS_ACCESS_CACHE_SIZE;
+       }
+       return (slot);
 }
 
-static int
-nfs3_access_otw(struct vnode *vp,  
-               int wmode,
-               struct proc *p,
-               struct ucred *cred)  
+int
+nfs3_access_rpc(nfsnode_t np, u_int32_t *mode, vfs_context_t ctx)
 {
-       const int v3 = 1;
-       u_long *tl;
-       int error = 0, attrflag;
-
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       caddr_t bpos, dpos, cp2;
-       register long t1, t2;
-       register caddr_t cp;
-       u_int32_t rmode;
-       struct nfsnode *np = VTONFS(vp);
+       int error = 0, lockerror = ENOENT, status, slot;
+       uint32_t access = 0;
        u_int64_t xid;
+       struct nfsm_chain nmreq, nmrep;
        struct timeval now;
+       uid_t uid;
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(NFS_VER3) + NFSX_UNSIGNED);
+       nfsm_chain_add_fh(error, &nmreq, NFS_VER3, np->n_fhp, np->n_fhsize);
+       nfsm_chain_add_32(error, &nmreq, *mode);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request(np, NULL, &nmreq, NFSPROC_ACCESS, ctx,
+                       &nmrep, &xid, &status);
+       if ((lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
+       if (!error)
+               error = status;
+       nfsm_chain_get_32(error, &nmrep, access);
+       nfsmout_if(error);
 
-       nfsstats.rpccnt[NFSPROC_ACCESS]++;   
-       nfsm_reqhead(vp, NFSPROC_ACCESS, NFSX_FH(v3) + NFSX_UNSIGNED);
-       nfsm_fhtom(vp, v3);
-       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-       *tl = txdr_unsigned(wmode);
-       nfsm_request(vp, NFSPROC_ACCESS, p, cred, &xid);
-       nfsm_postop_attr(vp, attrflag, &xid);
-       if (!error) {
-               nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-               rmode = fxdr_unsigned(u_int32_t, *tl);
-               np->n_mode = rmode;
-               np->n_modeuid = cred->cr_uid;
-               microuptime(&now);
-               np->n_modestamp = now.tv_sec;
-       }
-       nfsm_reqdone;
-       return error;
+       uid = kauth_cred_getuid(vfs_context_ucred(ctx));
+       slot = nfs_node_mode_slot(np, uid, 1);
+       np->n_modeuid[slot] = uid;
+       microuptime(&now);
+       np->n_modestamp[slot] = now.tv_sec;
+       np->n_mode[slot] = access;
+
+       /*
+        * If we asked for DELETE but didn't get it, the server
+        * may simply not support returning that bit (possible
+        * on UNIX systems).  So, we'll assume that it is OK,
+        * and just let any subsequent delete action fail if it
+        * really isn't deletable.
+        */
+       if ((*mode & NFS_ACCESS_DELETE) &&
+           !(np->n_mode[slot] & NFS_ACCESS_DELETE))
+               np->n_mode[slot] |= NFS_ACCESS_DELETE;
+       /* pass back the mode returned with this request */
+       *mode = np->n_mode[slot];
+nfsmout:
+       if (!lockerror)
+               nfs_node_unlock(np);
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       return (error);
 }
 
 /*
- * nfs access vnode op.
- * For nfs version 2, just return ok. File accesses may fail later.
- * For nfs version 3, use the access rpc to check accessibility. If file modes
+ * NFS access vnode op.
+ * For NFS version 2, just return ok. File accesses may fail later.
+ * For NFS version 3+, use the access RPC to check accessibility. If file modes
  * are changed on the server, accesses might still fail later.
  */
-static int
-nfs_access(ap)
-       struct vop_access_args /* {
-               struct vnode *a_vp;
-               int  a_mode;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+int
+nfs_vnop_access(
+       struct vnop_access_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_action;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       int error = 0;
-       u_long mode, wmode;
-       int v3 = NFS_ISV3(vp);
-       struct nfsnode *np = VTONFS(vp);
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       int error = 0, slot, dorpc;
+       u_int32_t mode, wmode;
+       nfsnode_t np = VTONFS(vp);
+       struct nfsmount *nmp;
+       int nfsvers;
        struct timeval now;
+       uid_t uid;
+
+       nmp = VTONMP(vp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       if (nfsvers == NFS_VER2) {
+               if ((ap->a_action & KAUTH_VNODE_WRITE_RIGHTS) &&
+                   vfs_isrdonly(vnode_mount(vp)))
+                       return (EROFS);
+               return (0);
+       }
 
        /*
-        * For nfs v3, do an access rpc, otherwise you are stuck emulating
+        * For NFS v3, do an access rpc, otherwise you are stuck emulating
         * ufs_access() locally using the vattr. This may not be correct,
         * since the server may apply other access criteria such as
         * client uid-->server uid mapping that we do not know about, but
         * this is better than just returning anything that is lying about
         * in the cache.
         */
-       if (v3) {
-               if (ap->a_mode & VREAD)
-                       mode = NFSV3ACCESS_READ;
-               else
-                       mode = 0;
-               if (vp->v_type == VDIR) {
-                       if (ap->a_mode & VWRITE)
-                               mode |= NFSV3ACCESS_MODIFY |
-                                       NFSV3ACCESS_EXTEND | NFSV3ACCESS_DELETE;
-                       if (ap->a_mode & VEXEC)
-                               mode |= NFSV3ACCESS_LOOKUP;
-               } else {
-                       if (ap->a_mode & VWRITE)
-                               mode |= NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND;
-                       if (ap->a_mode & VEXEC)
-                               mode |= NFSV3ACCESS_EXECUTE;
-               }
-               /* XXX safety belt, only make blanket request if caching */
-               if (nfsaccess_cache_timeout > 0) {
-                       wmode = NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY |
-                               NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE |
-                               NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP;
-               } else
-                       wmode = mode;
-                
-               /*
-                * Does our cached result allow us to give a definite yes to
-                * this request?
-                */     
-               microuptime(&now);
-               if (now.tv_sec < np->n_modestamp + nfsaccess_cache_timeout &&
-                   ap->a_cred->cr_uid == np->n_modeuid &&
-                   (np->n_mode & mode) == mode) {
-                       /* nfsstats.accesscache_hits++; */
-               } else {
-                       /*
-                        * Either a no, or a don't know.  Go to the wire.
-                        */
-                       /* nfsstats.accesscache_misses++; */
-                       error = nfs3_access_otw(vp, wmode, ap->a_p,ap->a_cred);
-                       if (!error) {
-                               if ((np->n_mode & mode) != mode)
-                                       error = EACCES;
-                       }
-               }
-       } else
-               return (nfsspec_access(ap)); /* NFSv2 case checks for EROFS here */
+
        /*
-        * Disallow write attempts on filesystems mounted read-only;
-        * unless the file is a socket, fifo, or a block or character
-        * device resident on the filesystem.
-        * CSM - moved EROFS check down per NetBSD rev 1.71.  So you
-        * get the correct error value with layered filesystems. 
-        * EKN - moved the return(error) below this so it does get called.       
+        * Convert KAUTH primitives to NFS access rights.
         */
-       if (!error && (ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
-               switch (vp->v_type) {
-                       case VREG: case VDIR: case VLNK:
-                               error = EROFS;
-                       default: 
-                               break;
+       mode = 0;
+       if (vnode_isdir(vp)) {
+               /* directory */
+               if (ap->a_action &
+                   (KAUTH_VNODE_LIST_DIRECTORY |
+                   KAUTH_VNODE_READ_EXTATTRIBUTES))
+                       mode |= NFS_ACCESS_READ;
+               if (ap->a_action & KAUTH_VNODE_SEARCH)
+                       mode |= NFS_ACCESS_LOOKUP;
+               if (ap->a_action &
+                   (KAUTH_VNODE_ADD_FILE |
+                   KAUTH_VNODE_ADD_SUBDIRECTORY))
+                       mode |= NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND;
+               if (ap->a_action & KAUTH_VNODE_DELETE_CHILD)
+                       mode |= NFS_ACCESS_MODIFY;
+       } else {
+               /* file */
+               if (ap->a_action &
+                   (KAUTH_VNODE_READ_DATA |
+                   KAUTH_VNODE_READ_EXTATTRIBUTES))
+                       mode |= NFS_ACCESS_READ;
+               if (ap->a_action & KAUTH_VNODE_WRITE_DATA)
+                       mode |= NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND;
+               if (ap->a_action & KAUTH_VNODE_APPEND_DATA)
+                       mode |= NFS_ACCESS_EXTEND;
+               if (ap->a_action & KAUTH_VNODE_EXECUTE)
+                       mode |= NFS_ACCESS_EXECUTE;
+       }
+       /* common */
+       if (ap->a_action & KAUTH_VNODE_DELETE)
+               mode |= NFS_ACCESS_DELETE;
+       if (ap->a_action &
+           (KAUTH_VNODE_WRITE_ATTRIBUTES |
+           KAUTH_VNODE_WRITE_EXTATTRIBUTES |
+           KAUTH_VNODE_WRITE_SECURITY))
+               mode |= NFS_ACCESS_MODIFY;
+       /* XXX this is pretty dubious */
+       if (ap->a_action & KAUTH_VNODE_CHANGE_OWNER)
+               mode |= NFS_ACCESS_MODIFY;
+
+       /* if caching, always ask for every right */
+       if (nfs_access_cache_timeout > 0) {
+               wmode = NFS_ACCESS_READ | NFS_ACCESS_MODIFY |
+                       NFS_ACCESS_EXTEND | NFS_ACCESS_EXECUTE |
+                       NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP;
+       } else {
+               wmode = mode;
+       }
+
+       if ((error = nfs_node_lock(np)))
+               return (error);
+
+       /*
+        * Does our cached result allow us to give a definite yes to
+        * this request?
+        */
+       uid = kauth_cred_getuid(vfs_context_ucred(ctx));
+       slot = nfs_node_mode_slot(np, uid, 0);
+       dorpc = 1;
+       if (mode == 0) {
+               /* not asking for any rights understood by NFS, so don't bother doing an RPC */
+               /* OSAddAtomic(1, &nfsstats.accesscache_hits); */
+               dorpc = 0;
+               wmode = 0;
+       } else if (NMODEVALID(np, slot)) {
+               microuptime(&now);
+               if ((now.tv_sec < (np->n_modestamp[slot] + nfs_access_cache_timeout)) &&
+                   ((np->n_mode[slot] & mode) == mode)) {
+                       /* OSAddAtomic(1, &nfsstats.accesscache_hits); */
+                       dorpc = 0;
+                       wmode = np->n_mode[slot];
                }
        }
+       nfs_node_unlock(np);
+       if (dorpc) {
+               /* Either a no, or a don't know.  Go to the wire. */
+               /* OSAddAtomic(1, &nfsstats.accesscache_misses); */
+               error = nmp->nm_funcs->nf_access_rpc(np, &wmode, ctx);
+       }
+       if (!error && ((wmode & mode) != mode))
+               error = EACCES;
+
        return (error);
 }
 
 /*
- * nfs open vnode op
- * Check to see if the type is ok
- * and that deletion is not in progress.
- * For paged in text files, you will need to flush the page cache
- * if consistency is lost.
+ * NFS open vnode op
  */
-/* ARGSUSED */
-
-static int
-nfs_open(ap)
-       struct vop_open_args /* {
-               struct vnode *a_vp;
-               int  a_mode;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+int
+nfs3_vnop_open(
+       struct vnop_open_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_mode;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       struct nfsnode *np = VTONFS(vp);
-       struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-       struct vattr vattr;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
+       struct nfsmount *nmp;
+       struct nfs_vattr nvattr;
+       enum vtype vtype;
        int error;
 
-       if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) {
+       nmp = VTONMP(vp);
+       if (!nmp)
+               return (ENXIO);
+
+       vtype = vnode_vtype(vp);
+       if ((vtype != VREG) && (vtype != VDIR) && (vtype != VLNK))
                return (EACCES);
+       if (ISSET(np->n_flag, NUPDATESIZE))
+               nfs_data_update_size(np, 0);
+       if ((error = nfs_node_lock(np)))
+               return (error);
+       if (np->n_flag & NNEEDINVALIDATE) {
+               np->n_flag &= ~NNEEDINVALIDATE;
+               if (vtype == VDIR)
+                       nfs_invaldir(np);
+               nfs_node_unlock(np);
+               nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, ctx, 1);
+               if ((error = nfs_node_lock(np)))
+                       return (error);
        }
-       /*
-        * Get a valid lease. If cached data is stale, flush it.
-        */
-       if (nmp->nm_flag & NFSMNT_NQNFS) {
-               if (NQNFS_CKINVALID(vp, np, ND_READ)) {
-                   do {
-                       error = nqnfs_getlease(vp, ND_READ, ap->a_cred,
-                           ap->a_p);
-                   } while (error == NQNFS_EXPIRED);
-                   if (error)
+       if (vnode_vtype(NFSTOV(np)) == VREG)
+               np->n_lastrahead = -1;
+       if (np->n_flag & NMODIFIED) {
+               if (vtype == VDIR)
+                       nfs_invaldir(np);
+               nfs_node_unlock(np);
+               if ((error = nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, ctx, 1)))
                        return (error);
-                   if (np->n_lrev != np->n_brev ||
-                       (np->n_flag & NQNFSNONCACHE)) {
-                       if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
-                               ap->a_p, 1)) == EINTR)
-                               return (error);
-                       np->n_brev = np->n_lrev;
-                   }
-               }
        } else {
-               if (np->n_flag & NMODIFIED) {
-                       if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
-                               ap->a_p, 1)) == EINTR)
-                               return (error);
-                       np->n_attrstamp = 0;
-                       if (vp->v_type == VDIR)
-                               np->n_direofoffset = 0;
-                       error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p);
-                       if (error)
-                               return (error);
-                       /* if directory changed, purge any name cache entries */
-                       if ((vp->v_type == VDIR) &&
-                           (np->n_mtime != vattr.va_mtime.tv_sec))
-                               cache_purge(vp);
-                       np->n_mtime = vattr.va_mtime.tv_sec;
-               } else {
-                       error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p);
-                       if (error)
-                               return (error);
-                       if (np->n_mtime != vattr.va_mtime.tv_sec) {
-                               if (vp->v_type == VDIR) {
-                                       np->n_direofoffset = 0;
-                                       nfs_invaldir(vp);
-                                       /* purge name cache entries */
-                                       cache_purge(vp);
-                               }
-                               if ((error = nfs_vinvalbuf(vp, V_SAVE,
-                                       ap->a_cred, ap->a_p, 1)) == EINTR)
-                                       return (error);
-                               np->n_mtime = vattr.va_mtime.tv_sec;
-                       }
-               }
+               nfs_node_unlock(np);
        }
-       if ((nmp->nm_flag & NFSMNT_NQNFS) == 0)
-               np->n_attrstamp = 0; /* For Open/Close consistency */
-       return (0);
+       /* nfs_getattr() will check changed and purge caches */
+       return (nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED));
 }
 
 /*
- * nfs close vnode op
+ * NFS close vnode op
  * What an NFS client should do upon close after writing is a debatable issue.
  * Most NFS clients push delayed writes to the server upon close, basically for
  * two reasons:
@@ -765,1296 +701,2481 @@ nfs_open(ap)
  * The current code does the following:
  * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
  * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
- *                     or commit them (this satisfies 1 and 2 except for the
- *                     case where the server crashes after this close but
- *                     before the commit RPC, which is felt to be "good
- *                     enough". Changing the last argument to nfs_flush() to
- *                     a 1 would force a commit operation, if it is felt a
- *                     commit is necessary now.
- * for NQNFS         - do nothing now, since 2 is dealt with via leases and
- *                     1 should be dealt with via an fsync() system call for
- *                     cases where write errors are important.
+ *                     them.
  */
-/* ARGSUSED */
-static int
-nfs_close(ap)
-       struct vop_close_args /* {
+int
+nfs3_vnop_close(
+       struct vnop_close_args /* {
                struct vnodeop_desc *a_desc;
-               struct vnode *a_vp;
-               int  a_fflag;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+               vnode_t a_vp;
+               int a_fflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
        struct nfsmount *nmp;
+       int nfsvers;
        int error = 0;
 
-       if (vp->v_type == VREG) {
-#if DIAGNOSTIC
-           register struct sillyrename *sp = np->n_sillyrename;
-           if (sp)
-                kprintf("nfs_close: %s, dvp=%x, vp=%x, ap=%x, np=%x, sp=%x\n",
-                       &sp->s_name[0], (unsigned)(sp->s_dvp), (unsigned)vp,
-                       (unsigned)ap, (unsigned)np, (unsigned)sp);
-#endif
-           nmp = VFSTONFS(vp->v_mount);
-           if (!nmp)
-               return (ENXIO);
-           if ((nmp->nm_flag & NFSMNT_NQNFS) == 0 &&
-               (np->n_flag & NMODIFIED)) {
-               int getlock = !VOP_ISLOCKED(vp);
-               if (getlock) {
-                       error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_p);
-                       if (!error && !VFSTONFS(vp->v_mount)) {
-                               VOP_UNLOCK(vp, 0, ap->a_p);
-                               error = ENXIO;
-                       }
-                       if (error)
-                               return (error);
-               }
-               if (NFS_ISV3(vp)) {
-                   error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_p, 1);
-                    /*
-                     * We cannot clear the NMODIFIED bit in np->n_flag due to
-                     * potential races with other processes
-                    * NMODIFIED is a hint
-                     */
-                   /* np->n_flag &= ~NMODIFIED; */
-               } else {
-                   error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1);
-               }
-               np->n_attrstamp = 0;
-               if (getlock)
-                       VOP_UNLOCK(vp, 0, ap->a_p);
-           }
-           if (np->n_flag & NWRITEERR) {
+       if (vnode_vtype(vp) != VREG)
+               return (0);
+       nmp = VTONMP(vp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       if (ISSET(np->n_flag, NUPDATESIZE))
+               nfs_data_update_size(np, 0);
+       if ((error = nfs_node_lock(np)))
+               return (error);
+       if (np->n_flag & NNEEDINVALIDATE) {
+               np->n_flag &= ~NNEEDINVALIDATE;
+               nfs_node_unlock(np);
+               nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, ctx, 1);
+               if ((error = nfs_node_lock(np)))
+                       return (error);
+       }
+       if (np->n_flag & NMODIFIED) {
+               nfs_node_unlock(np);
+               if (nfsvers != NFS_VER2)
+                       error = nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), 0);
+               else
+                       error = nfs_vinvalbuf(vp, V_SAVE, ctx, 1);
+               if (error)
+                       return (error);
+               nfs_node_lock_force(np);
+               NATTRINVALIDATE(np);
+       }
+       if (np->n_flag & NWRITEERR) {
                np->n_flag &= ~NWRITEERR;
                error = np->n_error;
-           }
        }
+       nfs_node_unlock(np);
        return (error);
 }
 
-/*
- * nfs getattr call from vfs.
- */
-static int
-nfs_getattr(ap)
-       struct vop_getattr_args /* {
-               struct vnode *a_vp;
-               struct vattr *a_vap;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+
+int
+nfs3_getattr_rpc(
+       nfsnode_t np,
+       mount_t mp,
+       u_char *fhp,
+       size_t fhsize,
+       vfs_context_t ctx,
+       struct nfs_vattr *nvap,
+       u_int64_t *xidp)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
-       register caddr_t cp;
-       register u_long *tl;
-       register int t1, t2;
-       caddr_t bpos, dpos;
-       int error = 0;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3;
-       u_int64_t xid;
-       int avoidfloods;
-       
-       FSDBG_TOP(513, np->n_size, np, np->n_vattr.va_size, np->n_flag);
-       /*
-        * Update local times for special files.
-        */
-       if (np->n_flag & (NACC | NUPD))
-               np->n_flag |= NCHG;
-       /*
-        * First look in the cache.
-        */
-       if ((error = nfs_getattrcache(vp, ap->a_vap)) == 0) {
-               FSDBG_BOT(513, np->n_size, 0, np->n_vattr.va_size, np->n_flag);
-               return (0);
-       }
-       if (error != ENOENT) {
-               FSDBG_BOT(513, np->n_size, error, np->n_vattr.va_size,
-                         np->n_flag);
-               return (error);
-       }
+       struct nfsmount *nmp = mp ? VFSTONFS(mp) : NFSTONMP(np);
+       int error = 0, status, nfsvers;
+       struct nfsm_chain nmreq, nmrep;
 
-       if (!VFSTONFS(vp->v_mount)) {
-               FSDBG_BOT(513, np->n_size, ENXIO, np->n_vattr.va_size, np->n_flag);
+       if (!nmp)
                return (ENXIO);
-       }
-       v3 = NFS_ISV3(vp);
-       error = 0;
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(nfsvers));
+       if (nfsvers != NFS_VER2)
+               nfsm_chain_add_32(error, &nmreq, fhsize);
+       nfsm_chain_add_opaque(error, &nmreq, fhp, fhsize);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request(np, mp, &nmreq, NFSPROC_GETATTR, ctx,
+                       &nmrep, xidp, &status);
+       if (!error)
+               error = status;
+       nfsmout_if(error);
+       error = nfs_parsefattr(&nmrep, nfsvers, nvap);
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       return (error);
+}
+
+
+int
+nfs_getattr(nfsnode_t np, struct nfs_vattr *nvap, vfs_context_t ctx, int uncached)
+{
+       struct nfsmount *nmp;
+       int error = 0, nfsvers, inprogset = 0, wanted = 0, avoidfloods;
+       struct timespec ts = { 2, 0 };
+       u_int64_t xid;
+
+       FSDBG_TOP(513, np->n_size, np, np->n_vattr.nva_size, np->n_flag);
+
+       if (!(nmp = NFSTONMP(np)))
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       /* Update local times for special files. */
+       if (np->n_flag & (NACC | NUPD)) {
+               nfs_node_lock_force(np);
+               np->n_flag |= NCHG;
+               nfs_node_unlock(np);
+       }
+       /* Update size, if necessary */
+       if (ISSET(np->n_flag, NUPDATESIZE))
+               nfs_data_update_size(np, 0);
+
+       error = nfs_node_lock(np);
+       nfsmout_if(error);
+       if (!uncached) {
+               while (1) {
+                       error = nfs_getattrcache(np, nvap);
+                       if (!error || (error != ENOENT)) {
+                               nfs_node_unlock(np);
+                               goto nfsmout;
+                       }
+                       if (!ISSET(np->n_flag, NGETATTRINPROG))
+                               break;
+                       SET(np->n_flag, NGETATTRWANT);
+                       msleep(np, &np->n_lock, PZERO-1, "nfsgetattrwant", &ts);
+                       if ((error = nfs_sigintr(NFSTONMP(np), NULL, vfs_context_thread(ctx), 0))) {
+                               nfs_node_unlock(np);
+                               goto nfsmout;
+                       }
+               }
+               SET(np->n_flag, NGETATTRINPROG);
+               inprogset = 1;
+       } else if (!ISSET(np->n_flag, NGETATTRINPROG)) {
+               SET(np->n_flag, NGETATTRINPROG);
+               inprogset = 1;
+       }
+       nfs_node_unlock(np);
+
+       nmp = NFSTONMP(np);
+       if (!nmp) {
+               error = ENXIO;
+               goto nfsmout;
+       }
+
+       /*
+        * Try to get both the attributes and access info by making an
+        * ACCESS call and seeing if it returns updated attributes.
+        * But don't bother if we aren't caching access info or if the
+        * attributes returned wouldn't be cached.
+        */
+       if ((nfsvers != NFS_VER2) && (nfs_access_cache_timeout > 0)) {
+               if (nfs_attrcachetimeout(np) > 0) {
+                       /*  OSAddAtomic(1, &nfsstats.accesscache_misses); */
+                       u_int32_t mode = NFS_ACCESS_ALL;
+                       error = nmp->nm_funcs->nf_access_rpc(np, &mode, ctx);
+                       if (error)
+                               goto nfsmout;
+                       nfs_node_lock_force(np);
+                       error = nfs_getattrcache(np, nvap);
+                       nfs_node_unlock(np);
+                       if (!error || (error != ENOENT))
+                               goto nfsmout;
+                       /* Well, that didn't work... just do a getattr... */
+                       error = 0;
+               }
+       }
 
-       if (v3 && nfsaccess_cache_timeout > 0) {
-               /*  nfsstats.accesscache_misses++; */
-               if (error = nfs3_access_otw(vp, NFSV3ACCESS_ALL, ap->a_p,
-                                           ap->a_cred))
-                       return (error);
-               if ((error = nfs_getattrcache(vp, ap->a_vap)) == 0)
-                       return (0);
-               if (error != ENOENT)
-                       return (error);
-               error = 0;
-       }
        avoidfloods = 0;
 tryagain:
-       nfsstats.rpccnt[NFSPROC_GETATTR]++;
-       nfsm_reqhead(vp, NFSPROC_GETATTR, NFSX_FH(v3));
-       nfsm_fhtom(vp, v3);
-       nfsm_request(vp, NFSPROC_GETATTR, ap->a_p, ap->a_cred, &xid);
+       error = nmp->nm_funcs->nf_getattr_rpc(np, NULL, np->n_fhp, np->n_fhsize, ctx, nvap, &xid);
        if (!error) {
-               nfsm_loadattr(vp, ap->a_vap, &xid);
-               if (!xid) { /* out-of-order rpc - attributes were dropped */
-                       m_freem(mrep);
-                       FSDBG(513, -1, np, np->n_xid << 32, np->n_xid);
-                       if (avoidfloods++ < 100)
-                               goto tryagain;
-                       /*
-                        * avoidfloods>1 is bizarre.  at 100 pull the plug
-                        */
-                       panic("nfs_getattr: getattr flood\n");
+               nfs_node_lock_force(np);
+               error = nfs_loadattrcache(np, nvap, &xid, 0);
+               nfs_node_unlock(np);
+       }
+       nfsmout_if(error);
+       if (!xid) { /* out-of-order rpc - attributes were dropped */
+               FSDBG(513, -1, np, np->n_xid >> 32, np->n_xid);
+               if (avoidfloods++ < 20)
+                       goto tryagain;
+               /* avoidfloods>1 is bizarre.  at 20 pull the plug */
+               /* just return the last attributes we got */
+       }
+nfsmout:
+       nfs_node_lock_force(np);
+       if (inprogset) {
+               wanted = ISSET(np->n_flag, NGETATTRWANT);
+               CLR(np->n_flag, (NGETATTRINPROG | NGETATTRWANT));
+       }
+       if (!error) {
+               /* check if the node changed on us */
+               vnode_t vp = NFSTOV(np);
+               enum vtype vtype = vnode_vtype(vp);
+               if ((vtype == VDIR) && NFS_CHANGED_NC(nfsvers, np, nvap)) {
+                       FSDBG(513, -1, np, 0, np);
+                       np->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge(vp);
+                       np->n_ncgen++;
+                       NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap);
                }
-               if (np->n_mtime != ap->a_vap->va_mtime.tv_sec) {
-                       FSDBG(513, -1, np, -1, vp);
-                       if (vp->v_type == VDIR) {
-                               nfs_invaldir(vp);
-                               /* purge name cache entries */
-                               cache_purge(vp);
-                       }
-                       error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
-                                             ap->a_p, 1);
+               if (NFS_CHANGED(nfsvers, np, nvap)) {
+                       FSDBG(513, -1, np, -1, np);
+                       if (vtype == VDIR)
+                               nfs_invaldir(np);
+                       nfs_node_unlock(np);
+                       if (wanted)
+                               wakeup(np);
+                       error = nfs_vinvalbuf(vp, V_SAVE, ctx, 1);
                        FSDBG(513, -1, np, -2, error);
                        if (!error) {
-                               np->n_mtime = ap->a_vap->va_mtime.tv_sec;
+                               nfs_node_lock_force(np);
+                               NFS_CHANGED_UPDATE(nfsvers, np, nvap);
+                               nfs_node_unlock(np);
                        }
+               } else {
+                       nfs_node_unlock(np);
+                       if (wanted)
+                               wakeup(np);
                }
+       } else {
+               nfs_node_unlock(np);
+               if (wanted)
+                       wakeup(np);
        }
-       nfsm_reqdone;
-
-       FSDBG_BOT(513, np->n_size, -1, np->n_vattr.va_size, error);
+       FSDBG_BOT(513, np->n_size, error, np->n_vattr.nva_size, np->n_flag);
        return (error);
 }
 
 /*
- * nfs setattr call.
+ * NFS getattr call from vfs.
  */
-static int
-nfs_setattr(ap)
-       struct vop_setattr_args /* {
+int
+nfs3_vnop_getattr(
+       struct vnop_getattr_args /* {
                struct vnodeop_desc *a_desc;
-               struct vnode *a_vp;
-               struct vattr *a_vap;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+               vnode_t a_vp;
+               struct vnode_attr *a_vap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
-       register struct vattr *vap = ap->a_vap;
-       int error = 0;
-       u_quad_t tsize;
+       int error;
+       struct nfs_vattr nva;
+       struct vnode_attr *vap = ap->a_vap;
+       dev_t rdev;
 
-#ifndef nolint
-       tsize = (u_quad_t)0;
-#endif
+       error = nfs_getattr(VTONFS(ap->a_vp), &nva, ap->a_context, NGA_CACHED);
+       if (error)
+               return (error);
 
-#ifdef XXX /* enable this code soon! (but test it first) */
-       /*                
-        * Setting of flags is not supported.
-        */
-       if (vap->va_flags != VNOVAL)
-               return (EOPNOTSUPP);
-#endif
+       /* copy nva to *a_vap */
+       VATTR_RETURN(vap, va_type, nva.nva_type);
+       VATTR_RETURN(vap, va_mode, nva.nva_mode);
+       rdev = makedev(nva.nva_rawdev.specdata1, nva.nva_rawdev.specdata2);
+       VATTR_RETURN(vap, va_rdev, rdev);
+       VATTR_RETURN(vap, va_uid, nva.nva_uid);
+       VATTR_RETURN(vap, va_gid, nva.nva_gid);
+       VATTR_RETURN(vap, va_nlink, nva.nva_nlink);
+       VATTR_RETURN(vap, va_fileid, nva.nva_fileid);
+       VATTR_RETURN(vap, va_data_size, nva.nva_size);
+       VATTR_RETURN(vap, va_data_alloc, nva.nva_bytes);
+       VATTR_RETURN(vap, va_iosize, nfs_iosize);
+       vap->va_access_time.tv_sec = nva.nva_timesec[NFSTIME_ACCESS];
+       vap->va_access_time.tv_nsec = nva.nva_timensec[NFSTIME_ACCESS];
+       VATTR_SET_SUPPORTED(vap, va_access_time);
+       vap->va_modify_time.tv_sec = nva.nva_timesec[NFSTIME_MODIFY];
+       vap->va_modify_time.tv_nsec = nva.nva_timensec[NFSTIME_MODIFY];
+       VATTR_SET_SUPPORTED(vap, va_modify_time);
+       vap->va_change_time.tv_sec = nva.nva_timesec[NFSTIME_CHANGE];
+       vap->va_change_time.tv_nsec = nva.nva_timensec[NFSTIME_CHANGE];
+       VATTR_SET_SUPPORTED(vap, va_change_time);
+
+       // VATTR_RETURN(vap, va_encoding, 0xffff /* kTextEncodingUnknown */);
+       return (error);
+}
 
-       /*
-        * Disallow write attempts if the filesystem is mounted read-only.
-        */
-       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))
+/*
+ * NFS setattr call.
+ */
+int
+nfs_vnop_setattr(
+       struct vnop_setattr_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               struct vnode_attr *a_vap;
+               vfs_context_t a_context;
+       } */ *ap)
+{
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
+       struct nfsmount *nmp;
+       struct vnode_attr *vap = ap->a_vap;
+       int error = 0;
+       int biosize, nfsvers;
+       u_quad_t origsize;
+       struct nfs_dulookup dul;
+       nfsnode_t dnp = NULL;
+       vnode_t dvp = NULL;
+       const char *vname = NULL;
+       struct nfs_open_owner *noop = NULL;
+       struct nfs_open_file *nofp = NULL;
+       struct nfs_vattr nvattr;
+
+       nmp = VTONMP(vp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       biosize = nmp->nm_biosize;
+
+       /* Disallow write attempts if the filesystem is mounted read-only. */
+       if (vnode_vfsisrdonly(vp))
                return (EROFS);
-       if (vap->va_size != VNOVAL) {
-               switch (vp->v_type) {
-               case VDIR:
-                       return (EISDIR);
-               case VCHR:
-               case VBLK:
-               case VSOCK:
-               case VFIFO:
-                       if (vap->va_mtime.tv_sec == VNOVAL &&
-                           vap->va_atime.tv_sec == VNOVAL &&
-                           vap->va_mode == (u_short)VNOVAL &&
-                           vap->va_uid == (uid_t)VNOVAL &&
-                           vap->va_gid == (gid_t)VNOVAL)
+
+       origsize = np->n_size;
+       if (VATTR_IS_ACTIVE(vap, va_data_size)) {
+               switch (vnode_vtype(vp)) {
+               case VDIR:
+                       return (EISDIR);
+               case VCHR:
+               case VBLK:
+               case VSOCK:
+               case VFIFO:
+                       if (!VATTR_IS_ACTIVE(vap, va_modify_time) &&
+                           !VATTR_IS_ACTIVE(vap, va_access_time) &&
+                           !VATTR_IS_ACTIVE(vap, va_mode) &&
+                           !VATTR_IS_ACTIVE(vap, va_uid) &&
+                           !VATTR_IS_ACTIVE(vap, va_gid)) {
                                return (0);
-                       vap->va_size = VNOVAL;
-                       break;
-               default:
+                       }
+                       VATTR_CLEAR_ACTIVE(vap, va_data_size);
+                       break;
+               default:
                        /*
                         * Disallow write attempts if the filesystem is
                         * mounted read-only.
                         */
-                       if (vp->v_mount->mnt_flag & MNT_RDONLY)
+                       if (vnode_vfsisrdonly(vp))
                                return (EROFS);
-                       FSDBG_TOP(512, np->n_size, vap->va_size,
-                                 np->n_vattr.va_size, np->n_flag);
-                       if (np->n_flag & NMODIFIED) {
-                               if (vap->va_size == 0)
-                                       error = nfs_vinvalbuf(vp, 0,
-                                               ap->a_cred, ap->a_p, 1);
-                               else
-                                       error = nfs_vinvalbuf(vp, V_SAVE,
-                                               ap->a_cred, ap->a_p, 1);
-                               if (error) {
-                                       printf("nfs_setattr: nfs_vinvalbuf %d\n", error);
-                                       FSDBG_BOT(512, np->n_size, vap->va_size,
-                                                 np->n_vattr.va_size, -1);
-                                       return (error);
+                       FSDBG_TOP(512, np->n_size, vap->va_data_size,
+                                 np->n_vattr.nva_size, np->n_flag);
+                       /* clear NNEEDINVALIDATE, if set */
+                       if ((error = nfs_node_lock(np)))
+                               return (error);
+                       if (np->n_flag & NNEEDINVALIDATE)
+                               np->n_flag &= ~NNEEDINVALIDATE;
+                       nfs_node_unlock(np);
+                       /* flush everything */
+                       error = nfs_vinvalbuf(vp, (vap->va_data_size ? V_SAVE : 0) , ctx, 1);
+                       if (error) {
+                               printf("nfs_setattr: nfs_vinvalbuf %d\n", error);
+                               FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, -1);
+                               return (error);
+                       }
+                       if (nfsvers >= NFS_VER4) {
+                               /* setting file size requires having the file open for write access */
+                               noop = nfs_open_owner_find(nmp, vfs_context_ucred(ctx), 1);
+                               if (!noop)
+                                       return (ENOMEM);
+retryopen:
+                               error = nfs_open_file_find(np, noop, &nofp, 0, 0, 1);
+                               if (!error && (nofp->nof_flags & NFS_OPEN_FILE_LOST))
+                                       error = EIO;
+                               if (!error && (nofp->nof_flags & NFS_OPEN_FILE_REOPEN)) {
+                                       nfs4_reopen(nofp, vfs_context_thread(ctx));
+                                       nofp = NULL;
+                                       goto retryopen;
+                               }
+                               if (error) {
+                                       nfs_open_owner_rele(noop);
+                                       return (error);
+                               }
+                               if (!(nofp->nof_access & NFS_OPEN_SHARE_ACCESS_WRITE)) {
+                                       /* we don't have the file open for write access, so open it */
+                                       error = nfs_mount_state_in_use_start(nmp);
+                                       if (!error)
+                                               error = nfs_open_file_set_busy(nofp, vfs_context_thread(ctx));
+                                       if (error) {
+                                               nfs_open_owner_rele(noop);
+                                               return (error);
+                                       }
+                                       error = nfs4_open(np, nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_NONE, ctx);
+                                       if (!error)
+                                               nofp->nof_flags |= NFS_OPEN_FILE_SETATTR;
+                                       if (nfs_mount_state_error_should_restart(error)) {
+                                               nfs_open_file_clear_busy(nofp);
+                                               nofp = NULL;
+                                       }
+                                       if (nfs_mount_state_in_use_end(nmp, error))
+                                               goto retryopen;
                                }
-                       } else if (np->n_size > vap->va_size) { /* shrinking? */
-                               daddr_t obn, bn;
-                               int biosize;
+                       }
+                       nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
+                       if (np->n_size > vap->va_data_size) { /* shrinking? */
+                               daddr64_t obn, bn;
+                               int neweofoff, mustwrite;
                                struct nfsbuf *bp;
 
-                               biosize = vp->v_mount->mnt_stat.f_iosize;
                                obn = (np->n_size - 1) / biosize;
-                               bn = vap->va_size / biosize; 
-                               for ( ; obn >= bn; obn--)
-                                   if (nfs_buf_incore(vp, obn)) {
-                                       bp = nfs_buf_get(vp, obn, biosize, 0, BLK_READ);
-                                       if (!bp)
+                               bn = vap->va_data_size / biosize;
+                               for ( ; obn >= bn; obn--) {
+                                       if (!nfs_buf_is_incore(np, obn))
+                                               continue;
+                                       error = nfs_buf_get(np, obn, biosize, NULL, NBLK_READ, &bp);
+                                       if (error)
+                                               continue;
+                                       if (obn != bn) {
+                                               FSDBG(512, bp, bp->nb_flags, 0, obn);
+                                               SET(bp->nb_flags, NB_INVAL);
+                                               nfs_buf_release(bp, 1);
                                                continue;
-                                       if (obn == bn) {
-                                           int neweofoff, mustwrite;
-                                           mustwrite = 0;
-                                           neweofoff = vap->va_size - NBOFF(bp);
-                                           /* check for any dirty data before the new EOF */
-                                           if (bp->nb_dirtyend && bp->nb_dirtyoff < neweofoff) {
+                                       }
+                                       mustwrite = 0;
+                                       neweofoff = vap->va_data_size - NBOFF(bp);
+                                       /* check for any dirty data before the new EOF */
+                                       if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < neweofoff)) {
                                                /* clip dirty range to EOF */
-                                               if (bp->nb_dirtyend > neweofoff)
-                                                   bp->nb_dirtyend = neweofoff;
-                                               mustwrite++;
-                                           }
-                                           bp->nb_dirty &= (1 << round_page_32(neweofoff)/PAGE_SIZE) - 1;
-                                           if (bp->nb_dirty)
+                                               if (bp->nb_dirtyend > neweofoff) {
+                                                       bp->nb_dirtyend = neweofoff;
+                                                       if (bp->nb_dirtyoff >= bp->nb_dirtyend)
+                                                               bp->nb_dirtyoff = bp->nb_dirtyend = 0;
+                                               }
+                                               if ((bp->nb_dirtyend > 0) && (bp->nb_dirtyoff < neweofoff))
+                                                       mustwrite++;
+                                       }
+                                       bp->nb_dirty &= (1 << round_page_32(neweofoff)/PAGE_SIZE) - 1;
+                                       if (bp->nb_dirty)
                                                mustwrite++;
-                                           if (mustwrite) {
-                                               /* gotta write out dirty data before invalidating */
-                                               /* (NB_STABLE indicates that data writes should be FILESYNC) */
-                                               /* (NB_NOCACHE indicates buffer should be discarded) */
-                                               CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL | NB_ASYNC | NB_READ));
-                                               SET(bp->nb_flags, NB_STABLE | NB_NOCACHE);
+                                       if (!mustwrite) {
+                                               FSDBG(512, bp, bp->nb_flags, 0, obn);
+                                               SET(bp->nb_flags, NB_INVAL);
+                                               nfs_buf_release(bp, 1);
+                                               continue;
+                                       }
+                                       /* gotta write out dirty data before invalidating */
+                                       /* (NB_STABLE indicates that data writes should be FILESYNC) */
+                                       /* (NB_NOCACHE indicates buffer should be discarded) */
+                                       CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL | NB_ASYNC | NB_READ));
+                                       SET(bp->nb_flags, NB_STABLE | NB_NOCACHE);
+                                       if (!IS_VALID_CRED(bp->nb_wcred)) {
+                                               kauth_cred_t cred = vfs_context_ucred(ctx);
+                                               kauth_cred_ref(cred);
+                                               bp->nb_wcred = cred;
+                                       }
+                                       error = nfs_buf_write(bp);
+                                       // Note: bp has been released
+                                       if (error) {
+                                               FSDBG(512, bp, 0xd00dee, 0xbad, error);
+                                               nfs_node_lock_force(np);
+                                               np->n_error = error;
+                                               np->n_flag |= NWRITEERR;
                                                /*
-                                                * NFS has embedded ucred so crhold() risks zone corruption
+                                                * There was a write error and we need to
+                                                * invalidate attrs and flush buffers in
+                                                * order to sync up with the server.
+                                                * (if this write was extending the file,
+                                                * we may no longer know the correct size)
                                                 */
-                                               if (bp->nb_wcred == NOCRED)
-                                                   bp->nb_wcred = crdup(ap->a_cred);
-                                               error = nfs_buf_write(bp);
-                                               // Note: bp has been released
-                                               if (error) {
-                                                   FSDBG(512, bp, 0xd00dee, 0xbad, error);
-                                                   np->n_error = error;
-                                                   np->n_flag |= NWRITEERR;
-                                                   error = 0;
-                                               }
-                                               bp = NULL;
-                                           }
+                                               NATTRINVALIDATE(np);
+                                               nfs_node_unlock(np);
+                                               nfs_data_unlock(np);
+                                               nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, ctx, 1);
+                                               nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
+                                               error = 0;
                                        }
-                                       if (bp) {
-                                           FSDBG(512, bp, bp->nb_flags, 0, obn);
-                                           SET(bp->nb_flags, NB_INVAL);
-                                           nfs_buf_release(bp);
-                                       }
-                                   }
+                               }
                        }
-                       tsize = np->n_size;
-                       np->n_size = np->n_vattr.va_size = vap->va_size;
-                       ubc_setsize(vp, (off_t)vap->va_size); /* XXX error? */
-               };
-       } else if ((vap->va_mtime.tv_sec != VNOVAL ||
-                   vap->va_atime.tv_sec != VNOVAL) &&
-                  (np->n_flag & NMODIFIED) && vp->v_type == VREG) {
-               error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1);
-               if (error == EINTR)
+                       if (vap->va_data_size != np->n_size)
+                               ubc_setsize(vp, (off_t)vap->va_data_size); /* XXX error? */
+                       origsize = np->n_size;
+                       np->n_size = np->n_vattr.nva_size = vap->va_data_size;
+                       nfs_node_lock_force(np);
+                       CLR(np->n_flag, NUPDATESIZE);
+                       nfs_node_unlock(np);
+                       FSDBG(512, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
+               }
+       } else if (VATTR_IS_ACTIVE(vap, va_modify_time) ||
+                   VATTR_IS_ACTIVE(vap, va_access_time) ||
+                   (vap->va_vaflags & VA_UTIMES_NULL)) {
+               if ((error = nfs_node_lock(np)))
+                       return (error);
+               if ((np->n_flag & NMODIFIED) && (vnode_vtype(vp) == VREG)) {
+                       nfs_node_unlock(np);
+                       error = nfs_vinvalbuf(vp, V_SAVE, ctx, 1);
+                       if (error == EINTR)
+                               return (error);
+               } else {
+                       nfs_node_unlock(np);
+               }
+       }
+       if (VATTR_IS_ACTIVE(vap, va_mode) ||
+           VATTR_IS_ACTIVE(vap, va_uid) ||
+           VATTR_IS_ACTIVE(vap, va_gid)) {
+               if ((error = nfs_node_lock(np))) {
+                       if (VATTR_IS_ACTIVE(vap, va_data_size))
+                               nfs_data_unlock(np);
                        return (error);
+               }
+               NMODEINVALIDATE(np);
+               nfs_node_unlock(np);
+               dvp = vnode_getparent(vp);
+               vname = vnode_getname(vp);
+               dnp = (dvp && vname) ? VTONFS(dvp) : NULL;
+               if (dnp) {
+                       error = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
+                       if (error) {
+                               dnp = NULL;
+                               error = 0;
+                       }
+               }
+               if (dnp) {
+                       nfs_dulookup_init(&dul, dnp, vname, strlen(vname), ctx);
+                       nfs_dulookup_start(&dul, dnp, ctx);
+               }
+       }
+
+retrysetattr:
+       if (VATTR_IS_ACTIVE(vap, va_data_size) && (nfsvers >= NFS_VER4))
+               error = nfs_mount_state_in_use_start(nmp);
+
+       if (!error) {
+               error = nmp->nm_funcs->nf_setattr_rpc(np, vap, ctx);
+
+               if (VATTR_IS_ACTIVE(vap, va_data_size) && (nfsvers >= NFS_VER4))
+                       if (nfs_mount_state_in_use_end(nmp, error))
+                               goto retrysetattr;
+       }
+
+       if (VATTR_IS_ACTIVE(vap, va_mode) ||
+           VATTR_IS_ACTIVE(vap, va_uid) ||
+           VATTR_IS_ACTIVE(vap, va_gid)) {
+               if (dnp) {
+                       nfs_dulookup_finish(&dul, dnp, ctx);
+                       nfs_node_clear_busy(dnp);
+               }
+               if (dvp != NULLVP)
+                       vnode_put(dvp);
+               if (vname != NULL)
+                       vnode_putname(vname);
        }
-       error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p);
-       FSDBG_BOT(512, np->n_size, vap->va_size, np->n_vattr.va_size, error);
-       if (error && vap->va_size != VNOVAL) {
-               /* make every effort to resync file size w/ server... */
-               int err = 0; /* preserve "error" for return */
 
-               printf("nfs_setattr: nfs_setattrrpc %d\n", error);
-               np->n_size = np->n_vattr.va_size = tsize;
-               ubc_setsize(vp, (off_t)np->n_size); /* XXX check error */
-               vap->va_size = tsize;
-               err = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p);
-               if (err)
-                       printf("nfs_setattr1: nfs_setattrrpc %d\n", err);
+       FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, error);
+       if (VATTR_IS_ACTIVE(vap, va_data_size)) {
+               if (error && (origsize != np->n_size)) {
+                       /* make every effort to resync file size w/ server... */
+                       int err; /* preserve "error" for return */
+                       np->n_size = np->n_vattr.nva_size = origsize;
+                       nfs_node_lock_force(np);
+                       CLR(np->n_flag, NUPDATESIZE);
+                       nfs_node_unlock(np);
+                       FSDBG(512, np, np->n_size, np->n_vattr.nva_size, 0xf00d0002);
+                       ubc_setsize(vp, (off_t)np->n_size); /* XXX check error */
+                       vap->va_data_size = origsize;
+                       err = nmp->nm_funcs->nf_setattr_rpc(np, vap, ctx);
+                       if (err)
+                               printf("nfs_vnop_setattr: nfs%d_setattr_rpc %d %d\n", nfsvers, error, err);
+               }
+               nfs_node_lock_force(np);
+               /*
+                * The size was just set.  If the size is already marked for update, don't
+                * trust the newsize (it may have been set while the setattr was in progress).
+                * Clear the update flag and make sure we fetch new attributes so we are sure
+                * we have the latest size.
+                */
+               if (ISSET(np->n_flag, NUPDATESIZE)) {
+                       CLR(np->n_flag, NUPDATESIZE);
+                       NATTRINVALIDATE(np);
+                       nfs_node_unlock(np);
+                       nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED);
+               } else {
+                       nfs_node_unlock(np);
+               }
+               nfs_data_unlock(np);
+               if (nfsvers >= NFS_VER4) {
+                       if (nofp->nof_flags & NFS_OPEN_FILE_SETATTR) {
+                               int err = nfs4_close(np, nofp, NFS_OPEN_SHARE_ACCESS_WRITE, NFS_OPEN_SHARE_DENY_NONE, ctx);
+                               if (err) {
+                                       vname = vnode_getname(NFSTOV(np));
+                                       printf("nfs_vnop_setattr: close error: %d, %s\n", err, vname);
+                                       vnode_putname(vname);
+                               }
+                               nofp->nof_flags &= ~NFS_OPEN_FILE_SETATTR;
+                               nfs_open_file_clear_busy(nofp);
+                       }
+                       nfs_open_owner_rele(noop);
+               }
        }
        return (error);
 }
 
 /*
- * Do an nfs setattr rpc.
+ * Do an NFS setattr RPC.
  */
-static int
-nfs_setattrrpc(vp, vap, cred, procp)
-       register struct vnode *vp;
-       register struct vattr *vap;
-       struct ucred *cred;
-       struct proc *procp;
+int
+nfs3_setattr_rpc(
+       nfsnode_t np,
+       struct vnode_attr *vap,
+       vfs_context_t ctx)
 {
-       register struct nfsv2_sattr *sp;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       u_long *tl;
-       int error = 0, wccflag = NFSV3_WCCRATTR;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3;
-       u_int64_t xid;
-       struct timeval now;
+       struct nfsmount *nmp = NFSTONMP(np);
+       int error = 0, lockerror = ENOENT, status, wccpostattr = 0, nfsvers;
+       u_int64_t xid, nextxid;
+       struct nfsm_chain nmreq, nmrep;
 
-       if (!VFSTONFS(vp->v_mount))
+       if (!nmp)
                return (ENXIO);
-       v3 = NFS_ISV3(vp);
-
-       nfsstats.rpccnt[NFSPROC_SETATTR]++;
-       nfsm_reqhead(vp, NFSPROC_SETATTR, NFSX_FH(v3) + NFSX_SATTR(v3));
-       nfsm_fhtom(vp, v3);
-       if (v3) {
-               if (vap->va_mode != (u_short)VNOVAL) {
-                       nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       *tl++ = nfs_true;
-                       *tl = txdr_unsigned(vap->va_mode);
+       nfsvers = nmp->nm_vers;
+
+       VATTR_SET_SUPPORTED(vap, va_mode);
+       VATTR_SET_SUPPORTED(vap, va_uid);
+       VATTR_SET_SUPPORTED(vap, va_gid);
+       VATTR_SET_SUPPORTED(vap, va_data_size);
+       VATTR_SET_SUPPORTED(vap, va_access_time);
+       VATTR_SET_SUPPORTED(vap, va_modify_time);
+
+       if (VATTR_IS_ACTIVE(vap, va_flags)) {
+               if (vap->va_flags) {    /* we don't support setting flags */
+                       if (vap->va_active & ~VNODE_ATTR_va_flags)
+                               return (EINVAL);        /* return EINVAL if other attributes also set */
+                       else
+                               return (ENOTSUP);       /* return ENOTSUP for chflags(2) */
+               }
+               /* no flags set, so we'll just ignore it */
+               if (!(vap->va_active & ~VNODE_ATTR_va_flags))
+                       return (0); /* no (other) attributes to set, so nothing to do */
+       }
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + NFSX_SATTR(nfsvers));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       if (nfsvers == NFS_VER3) {
+               if (VATTR_IS_ACTIVE(vap, va_mode)) {
+                       nfsm_chain_add_32(error, &nmreq, TRUE);
+                       nfsm_chain_add_32(error, &nmreq, vap->va_mode);
                } else {
-                       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                       *tl = nfs_false;
+                       nfsm_chain_add_32(error, &nmreq, FALSE);
                }
-               if (vap->va_uid != (uid_t)VNOVAL) {
-                       nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       *tl++ = nfs_true;
-                       *tl = txdr_unsigned(vap->va_uid);
+               if (VATTR_IS_ACTIVE(vap, va_uid)) {
+                       nfsm_chain_add_32(error, &nmreq, TRUE);
+                       nfsm_chain_add_32(error, &nmreq, vap->va_uid);
                } else {
-                       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                       *tl = nfs_false;
+                       nfsm_chain_add_32(error, &nmreq, FALSE);
                }
-               if (vap->va_gid != (gid_t)VNOVAL) {
-                       nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       *tl++ = nfs_true;
-                       *tl = txdr_unsigned(vap->va_gid);
+               if (VATTR_IS_ACTIVE(vap, va_gid)) {
+                       nfsm_chain_add_32(error, &nmreq, TRUE);
+                       nfsm_chain_add_32(error, &nmreq, vap->va_gid);
                } else {
-                       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                       *tl = nfs_false;
+                       nfsm_chain_add_32(error, &nmreq, FALSE);
                }
-               if (vap->va_size != VNOVAL) {
-                       nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
-                       *tl++ = nfs_true;
-                       txdr_hyper(&vap->va_size, tl);
+               if (VATTR_IS_ACTIVE(vap, va_data_size)) {
+                       nfsm_chain_add_32(error, &nmreq, TRUE);
+                       nfsm_chain_add_64(error, &nmreq, vap->va_data_size);
                } else {
-                       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                       *tl = nfs_false;
+                       nfsm_chain_add_32(error, &nmreq, FALSE);
                }
-               microtime(&now);
-               if (vap->va_atime.tv_sec != VNOVAL) {
-                       if (vap->va_atime.tv_sec != now.tv_sec) {
-                               nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
-                               *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
-                               txdr_nfsv3time(&vap->va_atime, tl);
+               if (vap->va_vaflags & VA_UTIMES_NULL) {
+                       nfsm_chain_add_32(error, &nmreq, NFS_TIME_SET_TO_SERVER);
+                       nfsm_chain_add_32(error, &nmreq, NFS_TIME_SET_TO_SERVER);
+               } else {
+                       if (VATTR_IS_ACTIVE(vap, va_access_time)) {
+                               nfsm_chain_add_32(error, &nmreq, NFS_TIME_SET_TO_CLIENT);
+                               nfsm_chain_add_32(error, &nmreq, vap->va_access_time.tv_sec);
+                               nfsm_chain_add_32(error, &nmreq, vap->va_access_time.tv_nsec);
                        } else {
-                               nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                               *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
+                               nfsm_chain_add_32(error, &nmreq, NFS_TIME_DONT_CHANGE);
                        }
-               } else {
-                       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                       *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
-               }
-               if (vap->va_mtime.tv_sec != VNOVAL) {
-                       if (vap->va_mtime.tv_sec != now.tv_sec) {
-                               nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
-                               *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
-                               txdr_nfsv3time(&vap->va_mtime, tl);
+                       if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
+                               nfsm_chain_add_32(error, &nmreq, NFS_TIME_SET_TO_CLIENT);
+                               nfsm_chain_add_32(error, &nmreq, vap->va_modify_time.tv_sec);
+                               nfsm_chain_add_32(error, &nmreq, vap->va_modify_time.tv_nsec);
                        } else {
-                               nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                               *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
+                               nfsm_chain_add_32(error, &nmreq, NFS_TIME_DONT_CHANGE);
                        }
+               }
+               nfsm_chain_add_32(error, &nmreq, FALSE);
+       } else {
+               nfsm_chain_add_32(error, &nmreq, VATTR_IS_ACTIVE(vap, va_mode) ?
+                       vtonfsv2_mode(vnode_vtype(NFSTOV(np)), vap->va_mode) : -1);
+               nfsm_chain_add_32(error, &nmreq, VATTR_IS_ACTIVE(vap, va_uid) ?
+                       vap->va_uid : (uint32_t)-1);
+               nfsm_chain_add_32(error, &nmreq, VATTR_IS_ACTIVE(vap, va_gid) ?
+                       vap->va_gid : (uint32_t)-1);
+               nfsm_chain_add_32(error, &nmreq, VATTR_IS_ACTIVE(vap, va_data_size) ?
+                       vap->va_data_size : (uint32_t)-1);
+               if (VATTR_IS_ACTIVE(vap, va_access_time)) {
+                       nfsm_chain_add_32(error, &nmreq, vap->va_access_time.tv_sec);
+                       nfsm_chain_add_32(error, &nmreq, (vap->va_access_time.tv_nsec != -1) ?
+                               ((uint32_t)vap->va_access_time.tv_nsec / 1000) : 0xffffffff);
                } else {
-                       nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-                       *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
+                       nfsm_chain_add_32(error, &nmreq, -1);
+                       nfsm_chain_add_32(error, &nmreq, -1);
                }
-               nfsm_build(tl, u_long *, NFSX_UNSIGNED);
-               *tl = nfs_false;
+               if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
+                       nfsm_chain_add_32(error, &nmreq, vap->va_modify_time.tv_sec);
+                       nfsm_chain_add_32(error, &nmreq, (vap->va_modify_time.tv_nsec != -1) ?
+                               ((uint32_t)vap->va_modify_time.tv_nsec / 1000) : 0xffffffff);
+               } else {
+                       nfsm_chain_add_32(error, &nmreq, -1);
+                       nfsm_chain_add_32(error, &nmreq, -1);
+               }
+       }
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request(np, NULL, &nmreq, NFSPROC_SETATTR, ctx,
+                       &nmrep, &xid, &status);
+       if ((lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3) {
+               struct timespec premtime = { 0, 0 };
+               nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
+               nfsmout_if(error);
+               /* if file hadn't changed, update cached mtime */
+               if (nfstimespeccmp(&np->n_mtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE(nfsvers, np, &np->n_vattr);
+               /* if directory hadn't changed, update namecache mtime */
+               if ((vnode_vtype(NFSTOV(np)) == VDIR) &&
+                   nfstimespeccmp(&np->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, np, &np->n_vattr);
+               if (!wccpostattr)
+                       NATTRINVALIDATE(np);
+               error = status;
        } else {
-               nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
-               if (vap->va_mode == (u_short)VNOVAL)
-                       sp->sa_mode = VNOVAL;
-               else
-                       sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
-               if (vap->va_uid == (uid_t)VNOVAL)
-                       sp->sa_uid = VNOVAL;
-               else
-                       sp->sa_uid = txdr_unsigned(vap->va_uid);
-               if (vap->va_gid == (gid_t)VNOVAL)
-                       sp->sa_gid = VNOVAL;
-               else
-                       sp->sa_gid = txdr_unsigned(vap->va_gid);
-               sp->sa_size = txdr_unsigned(vap->va_size);
-               txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-               txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-       }
-       nfsm_request(vp, NFSPROC_SETATTR, procp, cred, &xid);
-       if (v3) {
-               nfsm_wcc_data(vp, wccflag, &xid);
-               if (!wccflag)
-                       VTONFS(vp)->n_attrstamp = 0;
-       } else
-               nfsm_loadattr(vp, (struct vattr *)0, &xid);
-       nfsm_reqdone;
+               if (!error)
+                       error = status;
+               nfsm_chain_loadattr(error, &nmrep, np, nfsvers, NULL, &xid);
+       }
+       /*
+        * We just changed the attributes and we want to make sure that we
+        * see the latest attributes.  Get the next XID.  If it's not the
+        * next XID after the SETATTR XID, then it's possible that another
+        * RPC was in flight at the same time and it might put stale attributes
+        * in the cache.  In that case, we invalidate the attributes and set
+        * the attribute cache XID to guarantee that newer attributes will
+        * get loaded next.
+        */
+       nextxid = 0;
+       nfs_get_xid(&nextxid);
+       if (nextxid != (xid + 1)) {
+               np->n_xid = nextxid;
+               NATTRINVALIDATE(np);
+       }
+nfsmout:
+       if (!lockerror)
+               nfs_node_unlock(np);
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
        return (error);
 }
 
 /*
- * nfs lookup call, one step at a time...
+ * NFS lookup call, one step at a time...
  * First look in cache
- * If not found, unlock the directory nfsnode and do the rpc
+ * If not found, unlock the directory nfsnode and do the RPC
  */
-static int
-nfs_lookup(ap)
-       struct vop_lookup_args /* {
+int
+nfs_vnop_lookup(
+       struct vnop_lookup_args /* {
                struct vnodeop_desc *a_desc;
-               struct vnode *a_dvp;
-               struct vnode **a_vpp;
+               vnode_t a_dvp;
+               vnode_t *a_vpp;
                struct componentname *a_cnp;
-       } */ *ap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct componentname *cnp = ap->a_cnp;
-       register struct vnode *dvp = ap->a_dvp;
-       register struct vnode **vpp = ap->a_vpp;
-       register int flags = cnp->cn_flags;
-       register struct vnode *newvp;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       long len;
-       nfsfh_t *fhp;
-       struct nfsnode *np;
-       int lockparent, wantparent, error = 0, attrflag, fhsize;
-       int v3 = NFS_ISV3(dvp);
-       struct proc *p = cnp->cn_proc;
-       int unlockdvp = 0;
+       vfs_context_t ctx = ap->a_context;
+       struct componentname *cnp = ap->a_cnp;
+       vnode_t dvp = ap->a_dvp;
+       vnode_t *vpp = ap->a_vpp;
+       int flags = cnp->cn_flags;
+       vnode_t newvp;
+       nfsnode_t dnp, np;
+       struct nfsmount *nmp;
+       mount_t mp;
+       int nfsvers, error, busyerror = ENOENT, isdot, isdotdot, negnamecache;
        u_int64_t xid;
-       struct vattr vattr;
+       struct nfs_vattr nvattr;
+       int ngflags;
+       struct vnop_access_args naa;
+       fhandle_t fh;
+       struct nfsreq rq, *req = &rq;
 
-       if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-           (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
-               return (EROFS);
        *vpp = NULLVP;
-       if (dvp->v_type != VDIR)
-               return (ENOTDIR);
-
-       lockparent = flags & LOCKPARENT;
-       wantparent = flags & (LOCKPARENT|WANTPARENT);
-       np = VTONFS(dvp);
 
-       /* if directory has changed, purge any name cache entries */
-       if (!VOP_GETATTR(dvp, &vattr, cnp->cn_cred, p) &&
-           (np->n_mtime != vattr.va_mtime.tv_sec))
-               cache_purge(dvp);
+       dnp = VTONFS(dvp);
 
-       if ((error = cache_lookup(dvp, vpp, cnp)) && error != ENOENT) {
-               int vpid;
-
-               newvp = *vpp;
-               vpid = newvp->v_id;
-
-               /*
-                * See the comment starting `Step through' in ufs/ufs_lookup.c
-                * for an explanation of the locking protocol
-                */
-
-               /*
-                * Note: we need to make sure to get a lock/ref on newvp
-                * before we possibly go off to the server in VOP_ACCESS.
-                */
-               if (dvp == newvp) {
-                       VREF(newvp);
-                       error = 0;
-               } else if (flags & ISDOTDOT) {
-                       VOP_UNLOCK(dvp, 0, p);
-                       error = vget(newvp, LK_EXCLUSIVE, p);
-                       if (!error)
-                               error = vn_lock(dvp, LK_EXCLUSIVE, p);
-               } else {
-                       error = vget(newvp, LK_EXCLUSIVE, p);
-                       if (error)
-                               VOP_UNLOCK(dvp, 0, p);
-               }
+       mp = vnode_mount(dvp);
+       nmp = VFSTONFS(mp);
+       if (!nmp) {
+               error = ENXIO;
+               goto error_return;
+       }
+       nfsvers = nmp->nm_vers;
+       negnamecache = !(nmp->nm_flag & NFSMNT_NONEGNAMECACHE);
 
-               if (error)
-                       goto cache_lookup_out;
+       if ((error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx))))
+               goto error_return;
+       /* nfs_getattr() will check changed and purge caches */
+       if ((error = nfs_getattr(dnp, &nvattr, ctx, NGA_CACHED)))
+               goto error_return;
 
-               if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, p))) {
-                       if (dvp == newvp)
-                               vrele(newvp);
-                       else
-                               vput(newvp);
-                       *vpp = NULLVP;
-                       goto error_return;
+       error = cache_lookup(dvp, vpp, cnp);
+       switch (error) {
+       case ENOENT:
+               /* negative cache entry */
+               goto error_return;
+       case 0:
+               /* cache miss */
+               if ((nfsvers > NFS_VER2) && (nmp->nm_flag & NFSMNT_RDIRPLUS)) {
+                       /* if rdirplus, try dir buf cache lookup */
+                       error = nfs_dir_buf_cache_lookup(dnp, &np, cnp, ctx, 0);
+                       if (!error && np) {
+                               /* dir buf cache hit */
+                               *vpp = NFSTOV(np);
+                               error = -1;
                        }
+               }
+               if (error != -1) /* cache miss */
+                       break;
+               /* FALLTHROUGH */
+       case -1:
+               /* cache hit, not really an error */
+               OSAddAtomic(1, &nfsstats.lookupcache_hits);
+
+               nfs_node_clear_busy(dnp);
+
+               /* check for directory access */
+               naa.a_vp = dvp;
+               naa.a_action = KAUTH_VNODE_SEARCH;
+               naa.a_context = ctx;
+
+               /* compute actual success/failure based on accessibility */
+               error = nfs_vnop_access(&naa);
+               /* FALLTHROUGH */
+       default:
+               /* unexpected error from cache_lookup */
+               goto error_return;
+       }
 
-               if ((dvp != newvp) && (!lockparent || !(flags & ISLASTCN)))
-                       VOP_UNLOCK(dvp, 0, p);
+       /* skip lookup, if we know who we are: "." or ".." */
+       isdot = isdotdot = 0;
+       if (cnp->cn_nameptr[0] == '.') {
+               if (cnp->cn_namelen == 1)
+                       isdot = 1;
+               if ((cnp->cn_namelen == 2) && (cnp->cn_nameptr[1] == '.'))
+                       isdotdot = 1;
+       }
+       if (isdotdot || isdot) {
+               fh.fh_len = 0;
+               goto found;
+       }
 
-               if (vpid == newvp->v_id) {
-                       if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, p)
-                               && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) {
-                               nfsstats.lookupcache_hits++;
-                               if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
-                                       cnp->cn_flags |= SAVENAME;
-                               error = 0; /* ignore any from VOP_GETATTR  */
-                               goto error_return;
-                       }
-                       cache_purge(newvp);
-               }
-               vput(newvp);
-               if ((dvp != newvp) && lockparent && (flags & ISLASTCN))
-                       VOP_UNLOCK(dvp, 0, p);
-cache_lookup_out:
-               error = vn_lock(dvp, LK_EXCLUSIVE, p);
-               *vpp = NULLVP;
-               if (error) 
-                       goto error_return;
+       /* do we know this name is too long? */
+       nmp = VTONMP(dvp);
+       if (!nmp) {
+               error = ENXIO;
+               goto error_return;
+       }
+       if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXNAME) &&
+            (cnp->cn_namelen > (int)nmp->nm_fsattr.nfsa_maxname)) {
+               error = ENAMETOOLONG;
+               goto error_return;
        }
 
        error = 0;
        newvp = NULLVP;
-       nfsstats.lookupcache_misses++;
-       nfsstats.rpccnt[NFSPROC_LOOKUP]++;
-       len = cnp->cn_namelen;
-       nfsm_reqhead(dvp, NFSPROC_LOOKUP,
-               NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
-       /* nfsm_request for NFSv2 causes you to goto to nfsmout upon errors */
-       nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred, &xid); 
 
-       if (error) {
-               nfsm_postop_attr(dvp, attrflag, &xid);
-               m_freem(mrep);
-               goto nfsmout;
-       }
-       nfsm_getfh(fhp, fhsize, v3);
+       OSAddAtomic(1, &nfsstats.lookupcache_misses);
 
-       /*
-        * Handle RENAME case...
-        */
-       if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
-               if (NFS_CMPFH(np, fhp, fhsize)) {
-                       m_freem(mrep);
-                       error = EISDIR;
-                       goto error_return;
-               }
-               if ((error = nfs_nget(dvp->v_mount, fhp, fhsize, &np))) {
-                       m_freem(mrep);
-                       goto error_return;
-               }
-               newvp = NFSTOV(np);
-               if (v3) {
-                       u_int64_t dxid = xid;
+       error = nmp->nm_funcs->nf_lookup_rpc_async(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &req);
+       nfsmout_if(error);
+       error = nmp->nm_funcs->nf_lookup_rpc_async_finish(dnp, ctx, req, &xid, &fh, &nvattr);
+       nfsmout_if(error);
 
-                       nfsm_postop_attr(newvp, attrflag, &xid);
-                       nfsm_postop_attr(dvp, attrflag, &dxid);
-               } else
-                       nfsm_loadattr(newvp, (struct vattr *)0, &xid);
-               *vpp = newvp;
-               m_freem(mrep);
-               cnp->cn_flags |= SAVENAME;
-               if (!lockparent)
-                       VOP_UNLOCK(dvp, 0, p);
-               error = 0;
-               goto error_return;
+       /* is the file handle the same as this directory's file handle? */
+       isdot = NFS_CMPFH(dnp, fh.fh_data, fh.fh_len);
+
+found:
+       if (flags & ISLASTCN) {
+               switch (cnp->cn_nameiop) {
+               case DELETE:
+                       cnp->cn_flags &= ~MAKEENTRY;
+                       break;
+               case RENAME:
+                       cnp->cn_flags &= ~MAKEENTRY;
+                       if (isdot) {
+                               error = EISDIR;
+                               goto error_return;
+                       }
+                       break;
+               }
        }
 
-       if (NFS_CMPFH(np, fhp, fhsize)) {
-               VREF(dvp);
-               newvp = dvp;
-       } else if (flags & ISDOTDOT) {
-               VOP_UNLOCK(dvp, 0, p);
-               error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
-               if (error) {
-                       m_freem(mrep);
-                       vn_lock(dvp, LK_EXCLUSIVE + LK_RETRY, p);
+       if (isdotdot) {
+               newvp = vnode_getparent(dvp);
+               if (!newvp) {
+                       error = ENOENT;
                        goto error_return;
                }
-               newvp = NFSTOV(np);
-               if (!lockparent || !(flags & ISLASTCN))
-                       unlockdvp = 1; /* keep dvp locked until after postops */
-               if (error = vn_lock(dvp, LK_EXCLUSIVE, p)) {
-                       m_freem(mrep);
-                       vput(newvp);
+       } else if (isdot) {
+               error = vnode_get(dvp);
+               if (error)
                        goto error_return;
-               }
+               newvp = dvp;
+               nfs_node_lock_force(dnp);
+               if (fh.fh_len && (dnp->n_xid <= xid))
+                       nfs_loadattrcache(dnp, &nvattr, &xid, 0);
+               nfs_node_unlock(dnp);
        } else {
-               if ((error = nfs_nget(dvp->v_mount, fhp, fhsize, &np))) {
-                       m_freem(mrep);
+               ngflags = (cnp->cn_flags & MAKEENTRY) ? NG_MAKEENTRY : 0;
+               error = nfs_nget(mp, dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, ngflags, &np);
+               if (error)
                        goto error_return;
-               }
-               if (!lockparent || !(flags & ISLASTCN))
-                       unlockdvp = 1; /* keep dvp locked until after postops */
                newvp = NFSTOV(np);
-       }
-       if (v3) {
-               u_int64_t dxid = xid;
-
-               nfsm_postop_attr(newvp, attrflag, &xid);
-               nfsm_postop_attr(dvp, attrflag, &dxid);
-       } else
-               nfsm_loadattr(newvp, (struct vattr *)0, &xid);
-       if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
-               cnp->cn_flags |= SAVENAME;
-       if ((cnp->cn_flags & MAKEENTRY) &&
-           (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))) {
-               np->n_ctime = np->n_vattr.va_ctime.tv_sec;
-               cache_enter(dvp, newvp, cnp);
+               nfs_node_unlock(np);
        }
        *vpp = newvp;
-       nfsm_reqdone;
-       if (unlockdvp)
-               VOP_UNLOCK(dvp, 0, p);
+
+nfsmout:
        if (error) {
-               if (newvp != NULLVP) {
-                       if (newvp == dvp)
-                               vrele(newvp);
-                       else
-                               vput(newvp);
-                       *vpp = NULLVP;
-               }
-               if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
-                   (flags & ISLASTCN) && error == ENOENT) {
-                       if (dvp->v_mount && (dvp->v_mount->mnt_flag & MNT_RDONLY))
+               if (((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME)) &&
+                   (flags & ISLASTCN) && (error == ENOENT)) {
+                       if (vnode_mount(dvp) && vnode_vfsisrdonly(dvp))
                                error = EROFS;
                        else
                                error = EJUSTRETURN;
-                       if (!lockparent)
-                               VOP_UNLOCK(dvp, 0, p);
                }
-               if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
-                       cnp->cn_flags |= SAVENAME;
+       }
+       if ((error == ENOENT) && (cnp->cn_flags & MAKEENTRY) &&
+           (cnp->cn_nameiop != CREATE) && negnamecache) {
+               /* add a negative entry in the name cache */
+               nfs_node_lock_force(dnp);
+               cache_enter(dvp, NULL, cnp);
+               dnp->n_flag |= NNEGNCENTRIES;
+               nfs_node_unlock(dnp);
        }
 error_return:
+       if (!busyerror)
+               nfs_node_clear_busy(dnp);
+       if (error && *vpp) {
+               vnode_put(*vpp);
+               *vpp = NULLVP;
+       }
        return (error);
 }
 
 /*
- * nfs read call.
+ * NFS read call.
  * Just call nfs_bioread() to do the work.
  */
-static int
-nfs_read(ap)
-       struct vop_read_args /* {
-               struct vnode *a_vp;
+int
+nfs_vnop_read(
+       struct vnop_read_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               int  a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
+               int a_ioflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-
-       if (vp->v_type != VREG)
+       if (vnode_vtype(ap->a_vp) != VREG)
                return (EPERM);
-       return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred, 0));
+       return (nfs_bioread(VTONFS(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_context));
 }
 
 
 /*
- * nfs readlink call
+ * NFS readlink call
  */
-static int
-nfs_readlink(ap)
-       struct vop_readlink_args /* {
-               struct vnode *a_vp;
+int
+nfs_vnop_readlink(
+       struct vnop_readlink_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               struct ucred *a_cred;
-       } */ *ap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
+       vfs_context_t ctx = ap->a_context;
+       nfsnode_t np = VTONFS(ap->a_vp);
+       struct nfsmount *nmp;
+       int error = 0, nfsvers;
+       uint32_t buflen;
+       uio_t uio = ap->a_uio;
+       struct nfs_vattr nvattr;
+       struct nfsbuf *bp = NULL;
 
-       if (vp->v_type != VLNK)
+       if (vnode_vtype(ap->a_vp) != VLNK)
                return (EPERM);
-       return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred, 0));
-}
 
-/*
- * Do a readlink rpc.
- * Called by nfs_doio() from below the buffer cache.
- */
-int
-nfs_readlinkrpc(vp, uiop, cred)
-       register struct vnode *vp;
-       struct uio *uiop;
-       struct ucred *cred;
-{
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, len, attrflag;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3;
-       u_int64_t xid;
+       if (uio_resid(uio) == 0)
+               return (0);
+       if (uio_offset(uio) < 0)
+               return (EINVAL);
 
-       if (!VFSTONFS(vp->v_mount))
+       nmp = VTONMP(ap->a_vp);
+       if (!nmp)
                return (ENXIO);
-       v3 = NFS_ISV3(vp);
-
-       nfsstats.rpccnt[NFSPROC_READLINK]++;
-       nfsm_reqhead(vp, NFSPROC_READLINK, NFSX_FH(v3));
-       nfsm_fhtom(vp, v3);
-       nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, cred, &xid);
-       if (v3)
-               nfsm_postop_attr(vp, attrflag, &xid);
-       if (!error) {
-               nfsm_strsiz(len, NFS_MAXPATHLEN);
-               if (len == NFS_MAXPATHLEN) {
-                       struct nfsnode *np = VTONFS(vp);
-#if DIAGNOSTIC
-                        if (!np)
-                                panic("nfs_readlinkrpc: null np");
-#endif  
-                        if (np->n_size && np->n_size < NFS_MAXPATHLEN)
-                                len = np->n_size;
-                }
-               nfsm_mtouio(uiop, len);
-       }
-       nfsm_reqdone;
+       nfsvers = nmp->nm_vers;
+
+       /* nfs_getattr() will check changed and purge caches */
+       if ((error = nfs_getattr(np, &nvattr, ctx, NGA_CACHED))) {
+               FSDBG(531, np, 0xd1e0001, 0, error);
+               return (error);
+       }
+
+       OSAddAtomic(1, &nfsstats.biocache_readlinks);
+       error = nfs_buf_get(np, 0, NFS_MAXPATHLEN, vfs_context_thread(ctx), NBLK_READ, &bp);
+       if (error) {
+               FSDBG(531, np, 0xd1e0002, 0, error);
+               return (error);
+       }
+       if (!ISSET(bp->nb_flags, NB_CACHE)) {
+               OSAddAtomic(1, &nfsstats.readlink_bios);
+               buflen = bp->nb_bufsize;
+               error = nmp->nm_funcs->nf_readlink_rpc(np, bp->nb_data, &buflen, ctx);
+               if (error) {
+                       SET(bp->nb_flags, NB_ERROR);
+                       bp->nb_error = error;
+               } else {
+                       bp->nb_validoff = 0;
+                       bp->nb_validend = buflen;
+               }
+       }
+       if (!error && (bp->nb_validend > 0))
+               error = uiomove(bp->nb_data, bp->nb_validend, uio);
+       FSDBG(531, np, bp->nb_validend, 0, error);
+       nfs_buf_release(bp, 1);
        return (error);
 }
 
 /*
- * nfs read rpc call
- * Ditto above
+ * Do a readlink RPC.
  */
 int
-nfs_readrpc(vp, uiop, cred)
-       register struct vnode *vp;
-       struct uio *uiop;
-       struct ucred *cred;
+nfs3_readlink_rpc(nfsnode_t np, char *buf, uint32_t *buflenp, vfs_context_t ctx)
 {
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
        struct nfsmount *nmp;
-       int error = 0, len, retlen, tsiz, eof = 0, attrflag;
-       int v3, nmrsize;
+       int error = 0, lockerror = ENOENT, nfsvers, status;
+       uint32_t len;
        u_int64_t xid;
+       struct nfsm_chain nmreq, nmrep;
 
-       FSDBG_TOP(536, vp, uiop->uio_offset, uiop->uio_resid, 0);
-       nmp = VFSTONFS(vp->v_mount);
+       nmp = NFSTONMP(np);
        if (!nmp)
                return (ENXIO);
-       v3 = NFS_ISV3(vp);
-       nmrsize = nmp->nm_rsize;
+       nfsvers = nmp->nm_vers;
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(nfsvers));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request(np, NULL, &nmreq, NFSPROC_READLINK, ctx,
+                       &nmrep, &xid, &status);
+       if ((lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
+       if (!error)
+               error = status;
+       nfsm_chain_get_32(error, &nmrep, len);
+       nfsmout_if(error);
+       if ((nfsvers == NFS_VER2) && (len > *buflenp)) {
+               error = EBADRPC;
+               goto nfsmout;
+       }
+       if (len >= *buflenp) {
+               if (np->n_size && (np->n_size < *buflenp))
+                       len = np->n_size;
+               else
+                       len = *buflenp - 1;
+       }
+       nfsm_chain_get_opaque(error, &nmrep, len, buf);
+       if (!error)
+               *buflenp = len;
+nfsmout:
+       if (!lockerror)
+               nfs_node_unlock(np);
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       return (error);
+}
 
-       tsiz = uiop->uio_resid;
-        if (((u_int64_t)uiop->uio_offset + (unsigned int)tsiz > 0xffffffff) && !v3) {
-               FSDBG_BOT(536, vp, uiop->uio_offset, uiop->uio_resid, EFBIG);
+/*
+ * NFS read RPC call
+ * Ditto above
+ */
+int
+nfs_read_rpc(nfsnode_t np, uio_t uio, vfs_context_t ctx)
+{
+       struct nfsmount *nmp;
+       int error = 0, nfsvers, eof = 0;
+       size_t nmrsize, len, retlen;
+       user_ssize_t tsiz;
+       off_t txoffset;
+       struct nfsreq rq, *req = &rq;
+       uint32_t stategenid = 0, restart = 0;
+
+       FSDBG_TOP(536, np, uio_offset(uio), uio_resid(uio), 0);
+       nmp = NFSTONMP(np);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       nmrsize = nmp->nm_rsize;
+
+       txoffset = uio_offset(uio);
+       tsiz = uio_resid(uio);
+       if ((nfsvers == NFS_VER2) && ((uint64_t)(txoffset + tsiz) > 0xffffffffULL)) {
+               FSDBG_BOT(536, np, uio_offset(uio), uio_resid(uio), EFBIG);
                return (EFBIG);
        }
+
        while (tsiz > 0) {
-               nfsstats.rpccnt[NFSPROC_READ]++;
-               len = (tsiz > nmrsize) ? nmrsize : tsiz;
-               nfsm_reqhead(vp, NFSPROC_READ, NFSX_FH(v3) + NFSX_UNSIGNED * 3);
-               nfsm_fhtom(vp, v3);
-               nfsm_build(tl, u_long *, NFSX_UNSIGNED * 3);
-               if (v3) {
-                       txdr_hyper(&uiop->uio_offset, tl);
-                       *(tl + 2) = txdr_unsigned(len);
-               } else {
-                       *tl++ = txdr_unsigned(uiop->uio_offset);
-                       *tl++ = txdr_unsigned(len);
-                       *tl = 0;
-               }
-               FSDBG(536, vp, uiop->uio_offset, len, 0);
-               nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, cred, &xid);
-               if (v3) {
-                       nfsm_postop_attr(vp, attrflag, &xid);
-                       if (error) {
-                               m_freem(mrep);
-                               goto nfsmout;
+               len = retlen = (tsiz > (user_ssize_t)nmrsize) ? nmrsize : (size_t)tsiz;
+               FSDBG(536, np, txoffset, len, 0);
+               if (nmp->nm_vers >= NFS_VER4)
+                       stategenid = nmp->nm_stategenid;
+               error = nmp->nm_funcs->nf_read_rpc_async(np, txoffset, len,
+                               vfs_context_thread(ctx), vfs_context_ucred(ctx), NULL, &req);
+               if (!error)
+                       error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req, uio, &retlen, &eof);
+               if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error) &&
+                   (++restart <= nfs_mount_state_max_restarts(nmp))) { /* guard against no progress */
+                       lck_mtx_lock(&nmp->nm_lock);
+                       if ((error != NFSERR_GRACE) && (stategenid == nmp->nm_stategenid) && !(nmp->nm_state & NFSSTA_RECOVER)) {
+                               printf("nfs_read_rpc: error %d, initiating recovery\n", error);
+                               nmp->nm_state |= NFSSTA_RECOVER;
+                               nfs_mount_sock_thread_wake(nmp);
                        }
-                       nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       eof = fxdr_unsigned(int, *(tl + 1));
-               } else
-                       nfsm_loadattr(vp, (struct vattr *)0, &xid);
-               nfsm_strsiz(retlen, nmrsize);
-               nfsm_mtouio(uiop, retlen);
-               m_freem(mrep);
+                       lck_mtx_unlock(&nmp->nm_lock);
+                       if (error == NFSERR_GRACE)
+                               tsleep(&nmp->nm_state, (PZERO-1), "nfsgrace", 2*hz);
+                       if (!(error = nfs_mount_state_wait_for_recovery(nmp)))
+                               continue;
+               }
+               if (error)
+                       break;
+               txoffset += retlen;
                tsiz -= retlen;
-               if (v3) {
-                       if (eof || retlen == 0)
+               if (nfsvers != NFS_VER2) {
+                       if (eof || (retlen == 0))
                                tsiz = 0;
                } else if (retlen < len)
                        tsiz = 0;
        }
-nfsmout:
-       FSDBG_BOT(536, vp, eof, uiop->uio_resid, error);
+
+       FSDBG_BOT(536, np, eof, uio_resid(uio), error);
        return (error);
 }
 
-/*
- * nfs write call
- */
 int
-nfs_writerpc(vp, uiop, cred, iomode, must_commit)
-       register struct vnode *vp;
-       register struct uio *uiop;
-       struct ucred *cred;
-       int *iomode, *must_commit;
+nfs3_read_rpc_async(
+       nfsnode_t np,
+       off_t offset,
+       size_t len,
+       thread_t thd,
+       kauth_cred_t cred,
+       struct nfsreq_cbinfo *cb,
+       struct nfsreq **reqp)
 {
-       register u_long *tl;
-       register caddr_t cp;
-       register int t1, t2, backup;
-       caddr_t bpos, dpos, cp2;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
        struct nfsmount *nmp;
-       int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR, rlen, commit;
-       int v3, committed = NFSV3WRITE_FILESYNC;
-       u_int64_t xid;
+       int error = 0, nfsvers;
+       struct nfsm_chain nmreq;
 
-#if DIAGNOSTIC
-       if (uiop->uio_iovcnt != 1)
-               panic("nfs_writerpc: iovcnt > 1");
-#endif
-       FSDBG_TOP(537, vp, uiop->uio_offset, uiop->uio_resid, *iomode);
-       nmp = VFSTONFS(vp->v_mount);
+       nmp = NFSTONMP(np);
        if (!nmp)
                return (ENXIO);
-       v3 = NFS_ISV3(vp);
-       *must_commit = 0;
-       tsiz = uiop->uio_resid;
-        if (((u_int64_t)uiop->uio_offset + (unsigned int)tsiz > 0xffffffff) && !v3) {
-               FSDBG_BOT(537, vp, uiop->uio_offset, uiop->uio_resid, EFBIG);
-               return (EFBIG);
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(nfsvers) + 3 * NFSX_UNSIGNED);
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       if (nfsvers == NFS_VER3) {
+               nfsm_chain_add_64(error, &nmreq, offset);
+               nfsm_chain_add_32(error, &nmreq, len);
+       } else {
+               nfsm_chain_add_32(error, &nmreq, offset);
+               nfsm_chain_add_32(error, &nmreq, len);
+               nfsm_chain_add_32(error, &nmreq, 0);
        }
-       while (tsiz > 0) {
-               nmp = VFSTONFS(vp->v_mount);
-               if (!nmp) {
-                       error = ENXIO;
-                       break;
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request_async(np, NULL, &nmreq, NFSPROC_READ, thd, cred, cb, reqp);
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       return (error);
+}
+
+int
+nfs3_read_rpc_async_finish(
+       nfsnode_t np,
+       struct nfsreq *req,
+       uio_t uio,
+       size_t *lenp,
+       int *eofp)
+{
+       int error = 0, lockerror, nfsvers, status, eof = 0;
+       size_t retlen = 0;
+       uint64_t xid;
+       struct nfsmount *nmp;
+       struct nfsm_chain nmrep;
+
+       nmp = NFSTONMP(np);
+       if (!nmp) {
+               nfs_request_async_cancel(req);
+               return (ENXIO);
+       }
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmrep);
+
+       error = nfs_request_async_finish(req, &nmrep, &xid, &status);
+       if (error == EINPROGRESS) /* async request restarted */
+               return (error);
+
+       if ((lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
+       if (!error)
+               error = status;
+       if (nfsvers == NFS_VER3) {
+               nfsm_chain_adv(error, &nmrep, NFSX_UNSIGNED);
+               nfsm_chain_get_32(error, &nmrep, eof);
+       } else {
+               nfsm_chain_loadattr(error, &nmrep, np, nfsvers, NULL, &xid);
+       }
+       if (!lockerror)
+               nfs_node_unlock(np);
+       nfsm_chain_get_32(error, &nmrep, retlen);
+       if ((nfsvers == NFS_VER2) && (retlen > *lenp))
+               error = EBADRPC;
+       nfsmout_if(error);
+       error = nfsm_chain_get_uio(&nmrep, MIN(retlen, *lenp), uio);
+       if (eofp) {
+               if (nfsvers == NFS_VER3) {
+                       if (!eof && !retlen)
+                               eof = 1;
+               } else if (retlen < *lenp) {
+                       eof = 1;
                }
-               nfsstats.rpccnt[NFSPROC_WRITE]++;
-               len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
-               nfsm_reqhead(vp, NFSPROC_WRITE,
-                       NFSX_FH(v3) + 5 * NFSX_UNSIGNED + nfsm_rndup(len));
-               nfsm_fhtom(vp, v3);
-               if (v3) {
-                       nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
-                       txdr_hyper(&uiop->uio_offset, tl);
-                       tl += 2;
-                       *tl++ = txdr_unsigned(len);
-                       *tl++ = txdr_unsigned(*iomode);
+               *eofp = eof;
+       }
+       *lenp = MIN(retlen, *lenp);
+nfsmout:
+       nfsm_chain_cleanup(&nmrep);
+       return (error);
+}
+
+/*
+ * NFS write call
+ */
+int
+nfs_vnop_write(
+       struct vnop_write_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               struct uio *a_uio;
+               int a_ioflag;
+               vfs_context_t a_context;
+       } */ *ap)
+{
+       vfs_context_t ctx = ap->a_context;
+       uio_t uio = ap->a_uio;
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
+       int ioflag = ap->a_ioflag;
+       struct nfsbuf *bp;
+       struct nfs_vattr nvattr;
+       struct nfsmount *nmp = VTONMP(vp);
+       daddr64_t lbn;
+       int biosize;
+       int n, on, error = 0;
+       off_t boff, start, end;
+       uio_t auio;
+       char auio_buf [ UIO_SIZEOF(1) ];
+       thread_t thd;
+       kauth_cred_t cred;
+
+       FSDBG_TOP(515, np, uio_offset(uio), uio_resid(uio), ioflag);
+
+       if (vnode_vtype(vp) != VREG) {
+               FSDBG_BOT(515, np, uio_offset(uio), uio_resid(uio), EIO);
+               return (EIO);
+       }
+
+       thd = vfs_context_thread(ctx);
+       cred = vfs_context_ucred(ctx);
+
+       nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
+
+       if ((error = nfs_node_lock(np))) {
+               nfs_data_unlock(np);
+               FSDBG_BOT(515, np, uio_offset(uio), uio_resid(uio), error);
+               return (error);
+       }
+       np->n_wrbusy++;
+
+       if (np->n_flag & NWRITEERR) {
+               error = np->n_error;
+               np->n_flag &= ~NWRITEERR;
+       }
+       if (np->n_flag & NNEEDINVALIDATE) {
+               np->n_flag &= ~NNEEDINVALIDATE;
+               nfs_node_unlock(np);
+               nfs_data_unlock(np);
+               nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, ctx, 1);
+               nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
+       } else {
+               nfs_node_unlock(np);
+       }
+       if (error)
+               goto out;
+
+       biosize = nmp->nm_biosize;
+
+       if (ioflag & (IO_APPEND | IO_SYNC)) {
+               nfs_node_lock_force(np);
+               if (np->n_flag & NMODIFIED) {
+                       NATTRINVALIDATE(np);
+                       nfs_node_unlock(np);
+                       nfs_data_unlock(np);
+                       error = nfs_vinvalbuf(vp, V_SAVE, ctx, 1);
+                       nfs_data_lock(np, NFS_DATA_LOCK_SHARED);
+                       if (error) {
+                               FSDBG(515, np, uio_offset(uio), 0x10bad01, error);
+                               goto out;
+                       }
                } else {
-                       nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
-                       *++tl = txdr_unsigned(uiop->uio_offset);
-                       tl += 2;
+                       nfs_node_unlock(np);
+               }
+               if (ioflag & IO_APPEND) {
+                       nfs_data_unlock(np);
+                       /* nfs_getattr() will check changed and purge caches */
+                       error = nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED);
+                       /* we'll be extending the file, so take the data lock exclusive */
+                       nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
+                       if (error) {
+                               FSDBG(515, np, uio_offset(uio), 0x10bad02, error);
+                               goto out;
+                       }
+                       uio_setoffset(uio, np->n_size);
+               }
+       }
+       if (uio_offset(uio) < 0) {
+               error = EINVAL;
+               FSDBG_BOT(515, np, uio_offset(uio), 0xbad0ff, error);
+               goto out;
+       }
+       if (uio_resid(uio) == 0)
+               goto out;
+
+       if (((uio_offset(uio) + uio_resid(uio)) > (off_t)np->n_size) && !(ioflag & IO_APPEND)) {
+               /* it looks like we'll be extending the file, so take the data lock exclusive */
+               nfs_data_unlock(np);
+               nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
+       }
+
+       do {
+               OSAddAtomic(1, &nfsstats.biocache_writes);
+               lbn = uio_offset(uio) / biosize;
+               on = uio_offset(uio) % biosize;
+               n = biosize - on;
+               if (uio_resid(uio) < n)
+                       n = uio_resid(uio);
+again:
+               /*
+                * Get a cache block for writing.  The range to be written is
+                * (off..off+n) within the block.  We ensure that the block
+                * either has no dirty region or that the given range is
+                * contiguous with the existing dirty region.
+                */
+               error = nfs_buf_get(np, lbn, biosize, thd, NBLK_WRITE, &bp);
+               if (error)
+                       goto out;
+               /* map the block because we know we're going to write to it */
+               NFS_BUF_MAP(bp);
+
+               if (ioflag & IO_NOCACHE)
+                       SET(bp->nb_flags, NB_NOCACHE);
+
+               if (!IS_VALID_CRED(bp->nb_wcred)) {
+                       kauth_cred_ref(cred);
+                       bp->nb_wcred = cred;
+               }
+
+               /*
+                * If there's already a dirty range AND dirty pages in this block we
+                * need to send a commit AND write the dirty pages before continuing.
+                *
+                * If there's already a dirty range OR dirty pages in this block
+                * and the new write range is not contiguous with the existing range,
+                * then force the buffer to be written out now.
+                * (We used to just extend the dirty range to cover the valid,
+                * but unwritten, data in between also.  But writing ranges
+                * of data that weren't actually written by an application
+                * risks overwriting some other client's data with stale data
+                * that's just masquerading as new written data.)
+                */
+               if (bp->nb_dirtyend > 0) {
+                   if (on > bp->nb_dirtyend || (on + n) < bp->nb_dirtyoff || bp->nb_dirty) {
+                       FSDBG(515, np, uio_offset(uio), bp, 0xd15c001);
+                       /* write/commit buffer "synchronously" */
+                       /* (NB_STABLE indicates that data writes should be FILESYNC) */
+                       CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL));
+                       SET(bp->nb_flags, (NB_ASYNC | NB_STABLE));
+                       error = nfs_buf_write(bp);
+                       if (error)
+                           goto out;
+                       goto again;
+                   }
+               } else if (bp->nb_dirty) {
+                   int firstpg, lastpg;
+                   u_int32_t pagemask;
+                   /* calculate write range pagemask */
+                   firstpg = on/PAGE_SIZE;
+                   lastpg = (on+n-1)/PAGE_SIZE;
+                   pagemask = ((1 << (lastpg+1)) - 1) & ~((1 << firstpg) - 1);
+                   /* check if there are dirty pages outside the write range */
+                   if (bp->nb_dirty & ~pagemask) {
+                       FSDBG(515, np, uio_offset(uio), bp, 0xd15c002);
+                       /* write/commit buffer "synchronously" */
+                       /* (NB_STABLE indicates that data writes should be FILESYNC) */
+                       CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL));
+                       SET(bp->nb_flags, (NB_ASYNC | NB_STABLE));
+                       error = nfs_buf_write(bp);
+                       if (error)
+                           goto out;
+                       goto again;
+                   }
+                   /* if the first or last pages are already dirty */
+                   /* make sure that the dirty range encompasses those pages */
+                   if (NBPGDIRTY(bp,firstpg) || NBPGDIRTY(bp,lastpg)) {
+                       FSDBG(515, np, uio_offset(uio), bp, 0xd15c003);
+                       bp->nb_dirtyoff = min(on, firstpg * PAGE_SIZE);
+                       if (NBPGDIRTY(bp,lastpg)) {
+                           bp->nb_dirtyend = (lastpg+1) * PAGE_SIZE;
+                           /* clip to EOF */
+                           if (NBOFF(bp) + bp->nb_dirtyend > (off_t)np->n_size) {
+                                   bp->nb_dirtyend = np->n_size - NBOFF(bp);
+                                   if (bp->nb_dirtyoff >= bp->nb_dirtyend)
+                                           bp->nb_dirtyoff = bp->nb_dirtyend = 0;
+                           }
+                       } else
+                           bp->nb_dirtyend = on+n;
+                   }
                }
-               *tl = txdr_unsigned(len);
-               FSDBG(537, vp, uiop->uio_offset, len, 0);
-               nfsm_uiotom(uiop, len);
-               nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp, cred, &xid);
-               nmp = VFSTONFS(vp->v_mount);
-               if (!nmp)
-                       error = ENXIO;
-               if (v3) {
-                       wccflag = NFSV3_WCCCHK;
-                       nfsm_wcc_data(vp, wccflag, &xid);
-                       if (!error) {
-                               nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED +
-                                       NFSX_V3WRITEVERF);
-                               rlen = fxdr_unsigned(int, *tl++);
-                               if (rlen <= 0) {
-                                       error = NFSERR_IO;
-                                       break;
-                               } else if (rlen < len) {
-                                       backup = len - rlen;
-                                       uiop->uio_iov->iov_base -= backup;
-                                       uiop->uio_iov->iov_len += backup;
-                                       uiop->uio_offset -= backup;
-                                       uiop->uio_resid += backup;
-                                       len = rlen;
-                               }
-                               commit = fxdr_unsigned(int, *tl++);
 
+               /*
+                * Are we extending the size of the file with this write?
+                * If so, update file size now that we have the block.
+                * If there was a partial buf at the old eof, validate
+                * and zero the new bytes.
+                */
+               if ((uio_offset(uio) + n) > (off_t)np->n_size) {
+                       struct nfsbuf *eofbp = NULL;
+                       daddr64_t eofbn = np->n_size / biosize;
+                       int eofoff = np->n_size % biosize;
+                       int neweofoff = (uio_offset(uio) + n) % biosize;
+
+                       FSDBG(515, 0xb1ffa000, uio_offset(uio) + n, eofoff, neweofoff);
+
+                       if (eofoff && (eofbn < lbn) &&
+                           ((error = nfs_buf_get(np, eofbn, biosize, thd, NBLK_WRITE|NBLK_ONLYVALID, &eofbp))))
+                               goto out;
+
+                       /* if we're extending within the same last block */
+                       /* and the block is flagged as being cached... */
+                       if ((lbn == eofbn) && ISSET(bp->nb_flags, NB_CACHE)) {
+                               /* ...check that all pages in buffer are valid */
+                               int endpg = ((neweofoff ? neweofoff : biosize) - 1)/PAGE_SIZE;
+                               u_int32_t pagemask;
+                               /* pagemask only has to extend to last page being written to */
+                               pagemask = (1 << (endpg+1)) - 1;
+                               FSDBG(515, 0xb1ffa001, bp->nb_valid, pagemask, 0);
+                               if ((bp->nb_valid & pagemask) != pagemask) {
+                                       /* zerofill any hole */
+                                       if (on > bp->nb_validend) {
+                                               int i;
+                                               for (i=bp->nb_validend/PAGE_SIZE; i <= (on - 1)/PAGE_SIZE; i++)
+                                                       NBPGVALID_SET(bp, i);
+                                               NFS_BUF_MAP(bp);
+                                               FSDBG(516, bp, bp->nb_validend, on - bp->nb_validend, 0xf01e);
+                                               bzero((char *)bp->nb_data + bp->nb_validend,
+                                                       on - bp->nb_validend);
+                                       }
+                                       /* zerofill any trailing data in the last page */
+                                       if (neweofoff) {
+                                               NFS_BUF_MAP(bp);
+                                               FSDBG(516, bp, neweofoff, PAGE_SIZE - (neweofoff & PAGE_MASK), 0xe0f);
+                                               bzero((char *)bp->nb_data + neweofoff,
+                                                       PAGE_SIZE - (neweofoff & PAGE_MASK));
+                                       }
+                               }
+                       }
+                       np->n_size = uio_offset(uio) + n;
+                       nfs_node_lock_force(np);
+                       CLR(np->n_flag, NUPDATESIZE);
+                       np->n_flag |= NMODIFIED;
+                       nfs_node_unlock(np);
+                       FSDBG(516, np, np->n_size, np->n_vattr.nva_size, 0xf00d0001);
+                       ubc_setsize(vp, (off_t)np->n_size); /* XXX errors */
+                       if (eofbp) {
                                /*
-                                * Return the lowest committment level
-                                * obtained by any of the RPCs.
+                                * We may need to zero any previously invalid data
+                                * after the old EOF in the previous EOF buffer.
+                                *
+                                * For the old last page, don't zero bytes if there
+                                * are invalid bytes in that page (i.e. the page isn't
+                                * currently valid).
+                                * For pages after the old last page, zero them and
+                                * mark them as valid.
                                 */
-                               if (committed == NFSV3WRITE_FILESYNC)
-                                       committed = commit;
-                               else if (committed == NFSV3WRITE_DATASYNC &&
-                                       commit == NFSV3WRITE_UNSTABLE)
-                                       committed = commit;
-                               if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0) {
-                                   bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
-                                       NFSX_V3WRITEVERF);
-                                   nmp->nm_state |= NFSSTA_HASWRITEVERF;
-                               } else if (bcmp((caddr_t)tl,
-                                   (caddr_t)nmp->nm_verf, NFSX_V3WRITEVERF)) {
-                                   *must_commit = 1;
-                                   bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
-                                       NFSX_V3WRITEVERF);
+                               char *d;
+                               int i;
+                               if (ioflag & IO_NOCACHE)
+                                       SET(eofbp->nb_flags, NB_NOCACHE);
+                               NFS_BUF_MAP(eofbp);
+                               FSDBG(516, eofbp, eofoff, biosize - eofoff, 0xe0fff01e);
+                               d = eofbp->nb_data;
+                               i = eofoff/PAGE_SIZE;
+                               while (eofoff < biosize) {
+                                       int poff = eofoff & PAGE_MASK;
+                                       if (!poff || NBPGVALID(eofbp,i)) {
+                                               bzero(d + eofoff, PAGE_SIZE - poff);
+                                               NBPGVALID_SET(eofbp, i);
+                                       }
+                                       if (bp->nb_validend == eofoff)
+                                               bp->nb_validend += PAGE_SIZE - poff;
+                                       eofoff += PAGE_SIZE - poff;
+                                       i++;
+                               }
+                               nfs_buf_release(eofbp, 1);
+                       }
+               }
+               /*
+                * If dirtyend exceeds file size, chop it down.  This should
+                * not occur unless there is a race.
+                */
+               if (NBOFF(bp) + bp->nb_dirtyend > (off_t)np->n_size) {
+                       bp->nb_dirtyend = np->n_size - NBOFF(bp);
+                       if (bp->nb_dirtyoff >= bp->nb_dirtyend)
+                               bp->nb_dirtyoff = bp->nb_dirtyend = 0;
+               }
+               /*
+                * UBC doesn't handle partial pages, so we need to make sure
+                * that any pages left in the page cache are completely valid.
+                *
+                * Writes that are smaller than a block are delayed if they
+                * don't extend to the end of the block.
+                *
+                * If the block isn't (completely) cached, we may need to read
+                * in some parts of pages that aren't covered by the write.
+                * If the write offset (on) isn't page aligned, we'll need to
+                * read the start of the first page being written to.  Likewise,
+                * if the offset of the end of the write (on+n) isn't page aligned,
+                * we'll need to read the end of the last page being written to.
+                *
+                * Notes:
+                * We don't want to read anything we're just going to write over.
+                * We don't want to issue multiple I/Os if we don't have to
+                *   (because they're synchronous rpcs).
+                * We don't want to read anything we already have modified in the
+                *   page cache.
+                */
+               if (!ISSET(bp->nb_flags, NB_NOCACHE) && !ISSET(bp->nb_flags, NB_CACHE) && (n < biosize)) {
+                       int firstpg, lastpg, dirtypg;
+                       int firstpgoff, lastpgoff;
+                       start = end = -1;
+                       firstpg = on/PAGE_SIZE;
+                       firstpgoff = on & PAGE_MASK;
+                       lastpg = (on+n-1)/PAGE_SIZE;
+                       lastpgoff = (on+n) & PAGE_MASK;
+                       if (firstpgoff && !NBPGVALID(bp,firstpg)) {
+                               /* need to read start of first page */
+                               start = firstpg * PAGE_SIZE;
+                               end = start + firstpgoff;
+                       }
+                       if (lastpgoff && !NBPGVALID(bp,lastpg)) {
+                               /* need to read end of last page */
+                               if (start < 0)
+                                       start = (lastpg * PAGE_SIZE) + lastpgoff;
+                               end = (lastpg + 1) * PAGE_SIZE;
+                       }
+                       if (end > start) {
+                               /* need to read the data in range: start...end-1 */
+
+                               /* first, check for dirty pages in between */
+                               /* if there are, we'll have to do two reads because */
+                               /* we don't want to overwrite the dirty pages. */
+                               for (dirtypg=start/PAGE_SIZE; dirtypg <= (end-1)/PAGE_SIZE; dirtypg++)
+                                       if (NBPGDIRTY(bp,dirtypg))
+                                               break;
+
+                               /* if start is at beginning of page, try */
+                               /* to get any preceeding pages as well. */
+                               if (!(start & PAGE_MASK)) {
+                                       /* stop at next dirty/valid page or start of block */
+                                       for (; start > 0; start-=PAGE_SIZE)
+                                               if (NBPGVALID(bp,((start-1)/PAGE_SIZE)))
+                                                       break;
                                }
+
+                               NFS_BUF_MAP(bp);
+                               /* setup uio for read(s) */
+                               boff = NBOFF(bp);
+                               auio = uio_createwithbuffer(1, 0, UIO_SYSSPACE, UIO_READ,
+                                       &auio_buf, sizeof(auio_buf));
+
+                               if (dirtypg <= (end-1)/PAGE_SIZE) {
+                                       /* there's a dirty page in the way, so just do two reads */
+                                       /* we'll read the preceding data here */
+                                       uio_reset(auio, boff + start, UIO_SYSSPACE, UIO_READ);
+                                       uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + start), on - start);
+                                       error = nfs_read_rpc(np, auio, ctx);
+                                       if (error) /* couldn't read the data, so treat buffer as NOCACHE */
+                                               SET(bp->nb_flags, (NB_NOCACHE|NB_STABLE));
+                                       if (uio_resid(auio) > 0) {
+                                               FSDBG(516, bp, (caddr_t)uio_curriovbase(auio) - bp->nb_data, uio_resid(auio), 0xd00dee01);
+                                               bzero(CAST_DOWN(caddr_t, uio_curriovbase(auio)), uio_resid(auio));
+                                       }
+                                       if (!error) {
+                                               /* update validoff/validend if necessary */
+                                               if ((bp->nb_validoff < 0) || (bp->nb_validoff > start))
+                                                       bp->nb_validoff = start;
+                                               if ((bp->nb_validend < 0) || (bp->nb_validend < on))
+                                                       bp->nb_validend = on;
+                                               if ((off_t)np->n_size > boff + bp->nb_validend)
+                                                       bp->nb_validend = min(np->n_size - (boff + start), biosize);
+                                               /* validate any pages before the write offset */
+                                               for (; start < on/PAGE_SIZE; start+=PAGE_SIZE)
+                                                       NBPGVALID_SET(bp, start/PAGE_SIZE);
+                                       }
+                                       /* adjust start to read any trailing data */
+                                       start = on+n;
+                               }
+
+                               /* if end is at end of page, try to */
+                               /* get any following pages as well. */
+                               if (!(end & PAGE_MASK)) {
+                                       /* stop at next valid page or end of block */
+                                       for (; end < biosize; end+=PAGE_SIZE)
+                                               if (NBPGVALID(bp,end/PAGE_SIZE))
+                                                       break;
+                               }
+
+                               if (((boff+start) >= (off_t)np->n_size) ||
+                                   ((start >= on) && ((boff + on + n) >= (off_t)np->n_size))) {
+                                       /*
+                                        * Either this entire read is beyond the current EOF
+                                        * or the range that we won't be modifying (on+n...end)
+                                        * is all beyond the current EOF.
+                                        * No need to make a trip across the network to
+                                        * read nothing.  So, just zero the buffer instead.
+                                        */
+                                       FSDBG(516, bp, start, end - start, 0xd00dee00);
+                                       bzero(bp->nb_data + start, end - start);
+                                       error = 0;
+                               } else if (!ISSET(bp->nb_flags, NB_NOCACHE)) {
+                                       /* now we'll read the (rest of the) data */
+                                       uio_reset(auio, boff + start, UIO_SYSSPACE, UIO_READ);
+                                       uio_addiov(auio, CAST_USER_ADDR_T(bp->nb_data + start), end - start);
+                                       error = nfs_read_rpc(np, auio, ctx);
+                                       if (error) /* couldn't read the data, so treat buffer as NOCACHE */
+                                               SET(bp->nb_flags, (NB_NOCACHE|NB_STABLE));
+                                       if (uio_resid(auio) > 0) {
+                                               FSDBG(516, bp, (caddr_t)uio_curriovbase(auio) - bp->nb_data, uio_resid(auio), 0xd00dee02);
+                                               bzero(CAST_DOWN(caddr_t, uio_curriovbase(auio)), uio_resid(auio));
+                                       }
+                               }
+                               if (!error) {
+                                       /* update validoff/validend if necessary */
+                                       if ((bp->nb_validoff < 0) || (bp->nb_validoff > start))
+                                               bp->nb_validoff = start;
+                                       if ((bp->nb_validend < 0) || (bp->nb_validend < end))
+                                               bp->nb_validend = end;
+                                       if ((off_t)np->n_size > boff + bp->nb_validend)
+                                               bp->nb_validend = min(np->n_size - (boff + start), biosize);
+                                       /* validate any pages before the write offset's page */
+                                       for (; start < (off_t)trunc_page_32(on); start+=PAGE_SIZE)
+                                               NBPGVALID_SET(bp, start/PAGE_SIZE);
+                                       /* validate any pages after the range of pages being written to */
+                                       for (; (end - 1) > (off_t)round_page_32(on+n-1); end-=PAGE_SIZE)
+                                               NBPGVALID_SET(bp, (end-1)/PAGE_SIZE);
+                               }
+                               /* Note: pages being written to will be validated when written */
                        }
-               } else
-                   nfsm_loadattr(vp, (struct vattr *)0, &xid);
+               }
+
+               if (ISSET(bp->nb_flags, NB_ERROR)) {
+                       error = bp->nb_error;
+                       nfs_buf_release(bp, 1);
+                       goto out;
+               }
+
+               nfs_node_lock_force(np);
+               np->n_flag |= NMODIFIED;
+               nfs_node_unlock(np);
+
+               NFS_BUF_MAP(bp);
+               error = uiomove((char *)bp->nb_data + on, n, uio);
+               if (error) {
+                       SET(bp->nb_flags, NB_ERROR);
+                       nfs_buf_release(bp, 1);
+                       goto out;
+               }
+
+               /* validate any pages written to */
+               start = on & ~PAGE_MASK;
+               for (; start < on+n; start += PAGE_SIZE) {
+                       NBPGVALID_SET(bp, start/PAGE_SIZE);
+                       /*
+                        * This may seem a little weird, but we don't actually set the
+                        * dirty bits for writes.  This is because we keep the dirty range
+                        * in the nb_dirtyoff/nb_dirtyend fields.  Also, particularly for
+                        * delayed writes, when we give the pages back to the VM we don't
+                        * want to keep them marked dirty, because when we later write the
+                        * buffer we won't be able to tell which pages were written dirty
+                        * and which pages were mmapped and dirtied.
+                        */
+               }
+               if (bp->nb_dirtyend > 0) {
+                       bp->nb_dirtyoff = min(on, bp->nb_dirtyoff);
+                       bp->nb_dirtyend = max((on + n), bp->nb_dirtyend);
+               } else {
+                       bp->nb_dirtyoff = on;
+                       bp->nb_dirtyend = on + n;
+               }
+               if (bp->nb_validend <= 0 || bp->nb_validend < bp->nb_dirtyoff ||
+                   bp->nb_validoff > bp->nb_dirtyend) {
+                       bp->nb_validoff = bp->nb_dirtyoff;
+                       bp->nb_validend = bp->nb_dirtyend;
+               } else {
+                       bp->nb_validoff = min(bp->nb_validoff, bp->nb_dirtyoff);
+                       bp->nb_validend = max(bp->nb_validend, bp->nb_dirtyend);
+               }
+               if (!ISSET(bp->nb_flags, NB_CACHE))
+                       nfs_buf_normalize_valid_range(np, bp);
 
-               if (wccflag)
-                   VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;
-               m_freem(mrep);
                /*
-                * we seem to have a case where we end up looping on shutdown
-                * and taking down nfs servers.  For V3, error cases, there is
-                * no way to terminate loop, if the len was 0, meaning,
-                * nmp->nm_wsize was trashed. FreeBSD has this fix in it.
-                * Let's try it.
+                * Since this block is being modified, it must be written
+                * again and not just committed.
                 */
+               if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
+                       nfs_node_lock_force(np);
+                       if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
+                               np->n_needcommitcnt--;
+                               CHECK_NEEDCOMMITCNT(np);
+                       }
+                       CLR(bp->nb_flags, NB_NEEDCOMMIT);
+                       nfs_node_unlock(np);
+               }
+
+               if (ioflag & IO_SYNC) {
+                       error = nfs_buf_write(bp);
+                       if (error)
+                               goto out;
+               } else if (((n + on) == biosize) || (ioflag & IO_APPEND) ||
+                          (ioflag & IO_NOCACHE) || ISSET(bp->nb_flags, NB_NOCACHE)) {
+                       SET(bp->nb_flags, NB_ASYNC);
+                       error = nfs_buf_write(bp);
+                       if (error)
+                               goto out;
+               } else {
+                       /* If the block wasn't already delayed: charge for the write */
+                       if (!ISSET(bp->nb_flags, NB_DELWRI)) {
+                               proc_t p = vfs_context_proc(ctx);
+                               if (p && p->p_stats)
+                                       OSIncrementAtomicLong(&p->p_stats->p_ru.ru_oublock);
+                       }
+                       nfs_buf_write_delayed(bp);
+               }
+               if (np->n_needcommitcnt >= NFS_A_LOT_OF_NEEDCOMMITS)
+                       nfs_flushcommits(np, 1);
+
+       } while (uio_resid(uio) > 0 && n > 0);
+
+out:
+       nfs_node_lock_force(np);
+       np->n_wrbusy--;
+       nfs_node_unlock(np);
+       nfs_data_unlock(np);
+       FSDBG_BOT(515, np, uio_offset(uio), uio_resid(uio), error);
+       return (error);
+}
+
+
+/*
+ * NFS write call
+ */
+int
+nfs_write_rpc(
+       nfsnode_t np,
+       uio_t uio,
+       vfs_context_t ctx,
+       int *iomodep,
+       uint64_t *wverfp)
+{
+       return nfs_write_rpc2(np, uio, vfs_context_thread(ctx), vfs_context_ucred(ctx), iomodep, wverfp);
+}
+
+int
+nfs_write_rpc2(
+       nfsnode_t np,
+       uio_t uio,
+       thread_t thd,
+       kauth_cred_t cred,
+       int *iomodep,
+       uint64_t *wverfp)
+{
+       struct nfsmount *nmp;
+       int error = 0, nfsvers;
+       int backup, wverfset, commit, committed;
+       uint64_t wverf = 0, wverf2;
+       size_t nmwsize, totalsize, tsiz, len, rlen;
+       struct nfsreq rq, *req = &rq;
+       uint32_t stategenid = 0, vrestart = 0, restart = 0;
+
+#if DIAGNOSTIC
+       /* XXX limitation based on need to back up uio on short write */
+       if (uio_iovcnt(uio) != 1)
+               panic("nfs3_write_rpc: iovcnt > 1");
+#endif
+       FSDBG_TOP(537, np, uio_offset(uio), uio_resid(uio), *iomodep);
+       nmp = NFSTONMP(np);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       nmwsize = nmp->nm_wsize;
+
+       wverfset = 0;
+       committed = NFS_WRITE_FILESYNC;
+
+       totalsize = tsiz = uio_resid(uio);
+       if ((nfsvers == NFS_VER2) && ((uint64_t)(uio_offset(uio) + tsiz) > 0xffffffffULL)) {
+               FSDBG_BOT(537, np, uio_offset(uio), uio_resid(uio), EFBIG);
+               return (EFBIG);
+       }
+
+       while (tsiz > 0) {
+               len = (tsiz > nmwsize) ? nmwsize : tsiz;
+               FSDBG(537, np, uio_offset(uio), len, 0);
+               if (nmp->nm_vers >= NFS_VER4)
+                       stategenid = nmp->nm_stategenid;
+               error = nmp->nm_funcs->nf_write_rpc_async(np, uio, len, thd, cred, *iomodep, NULL, &req);
+               if (!error)
+                       error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req, &commit, &rlen, &wverf2);
+               nmp = NFSTONMP(np);
+               if (!nmp)
+                       error = ENXIO;
+               if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error) &&
+                   (++restart <= nfs_mount_state_max_restarts(nmp))) { /* guard against no progress */
+                       lck_mtx_lock(&nmp->nm_lock);
+                       if ((error != NFSERR_GRACE) && (stategenid == nmp->nm_stategenid) && !(nmp->nm_state & NFSSTA_RECOVER)) {
+                               printf("nfs_write_rpc: error %d, initiating recovery\n", error);
+                               nmp->nm_state |= NFSSTA_RECOVER;
+                               nfs_mount_sock_thread_wake(nmp);
+                       }
+                       lck_mtx_unlock(&nmp->nm_lock);
+                       if (error == NFSERR_GRACE)
+                               tsleep(&nmp->nm_state, (PZERO-1), "nfsgrace", 2*hz);
+                       if (!(error = nfs_mount_state_wait_for_recovery(nmp)))
+                               continue;
+               }
                if (error)
                        break;
+               if (nfsvers == NFS_VER2) {
+                       tsiz -= len;
+                       continue;
+               }
+
+               /* check for a short write */
+               if (rlen < len) {
+                       backup = len - rlen;
+                       uio_pushback(uio, backup);
+                       len = rlen;
+               }
+
+               /* return lowest commit level returned */
+               if (commit < committed)
+                       committed = commit;
+
                tsiz -= len;
+
+               /* check write verifier */
+               if (!wverfset) {
+                       wverf = wverf2;
+                       wverfset = 1;
+               } else if (wverf != wverf2) {
+                       /* verifier changed, so we need to restart all the writes */
+                       if (++vrestart > 100) {
+                               /* give up after too many restarts */
+                               error = EIO;
+                               break;
+                       }
+                       backup = totalsize - tsiz;
+                       uio_pushback(uio, backup);
+                       committed = NFS_WRITE_FILESYNC;
+                       wverfset = 0;
+                       tsiz = totalsize;
+               }
        }
-nfsmout:
-        if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_ASYNC))
-               committed = NFSV3WRITE_FILESYNC;
-        *iomode = committed;
+       if (wverfset && wverfp)
+               *wverfp = wverf;
+       *iomodep = committed;
        if (error)
-               uiop->uio_resid = tsiz;
-       FSDBG_BOT(537, vp, committed, uiop->uio_resid, error);
+               uio_setresid(uio, tsiz);
+       FSDBG_BOT(537, np, committed, uio_resid(uio), error);
+       return (error);
+}
+
+int
+nfs3_write_rpc_async(
+       nfsnode_t np,
+       uio_t uio,
+       size_t len,
+       thread_t thd,
+       kauth_cred_t cred,
+       int iomode,
+       struct nfsreq_cbinfo *cb,
+       struct nfsreq **reqp)
+{
+       struct nfsmount *nmp;
+       int error = 0, nfsvers;
+       struct nfsm_chain nmreq;
+
+       nmp = NFSTONMP(np);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + 5 * NFSX_UNSIGNED + nfsm_rndup(len));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       if (nfsvers == NFS_VER3) {
+               nfsm_chain_add_64(error, &nmreq, uio_offset(uio));
+               nfsm_chain_add_32(error, &nmreq, len);
+               nfsm_chain_add_32(error, &nmreq, iomode);
+       } else {
+               nfsm_chain_add_32(error, &nmreq, 0);
+               nfsm_chain_add_32(error, &nmreq, uio_offset(uio));
+               nfsm_chain_add_32(error, &nmreq, 0);
+       }
+       nfsm_chain_add_32(error, &nmreq, len);
+       nfsmout_if(error);
+       error = nfsm_chain_add_uio(&nmreq, uio, len);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request_async(np, NULL, &nmreq, NFSPROC_WRITE, thd, cred, cb, reqp);
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       return (error);
+}
+
+int
+nfs3_write_rpc_async_finish(
+       nfsnode_t np,
+       struct nfsreq *req,
+       int *iomodep,
+       size_t *rlenp,
+       uint64_t *wverfp)
+{
+       struct nfsmount *nmp;
+       int error = 0, lockerror = ENOENT, nfsvers, status;
+       int updatemtime = 0, wccpostattr = 0, rlen, committed = NFS_WRITE_FILESYNC;
+       u_int64_t xid, wverf;
+       mount_t mp;
+       struct nfsm_chain nmrep;
+
+       nmp = NFSTONMP(np);
+       if (!nmp) {
+               nfs_request_async_cancel(req);
+               return (ENXIO);
+       }
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmrep);
+
+       error = nfs_request_async_finish(req, &nmrep, &xid, &status);
+       if (error == EINPROGRESS) /* async request restarted */
+               return (error);
+       nmp = NFSTONMP(np);
+       if (!nmp)
+               error = ENXIO;
+       if (!error && (lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3) {
+               struct timespec premtime = { 0, 0 };
+               nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
+               if (nfstimespeccmp(&np->n_mtime, &premtime, ==))
+                       updatemtime = 1;
+               if (!error)
+                       error = status;
+               nfsm_chain_get_32(error, &nmrep, rlen);
+               nfsmout_if(error);
+               *rlenp = rlen;
+               if (rlen <= 0)
+                       error = NFSERR_IO;
+               nfsm_chain_get_32(error, &nmrep, committed);
+               nfsm_chain_get_64(error, &nmrep, wverf);
+               nfsmout_if(error);
+               if (wverfp)
+                       *wverfp = wverf;
+               lck_mtx_lock(&nmp->nm_lock);
+               if (!(nmp->nm_state & NFSSTA_HASWRITEVERF)) {
+                       nmp->nm_verf = wverf;
+                       nmp->nm_state |= NFSSTA_HASWRITEVERF;
+               } else if (nmp->nm_verf != wverf) {
+                       nmp->nm_verf = wverf;
+               }
+               lck_mtx_unlock(&nmp->nm_lock);
+       } else {
+               if (!error)
+                       error = status;
+               nfsm_chain_loadattr(error, &nmrep, np, nfsvers, NULL, &xid);
+               nfsmout_if(error);
+       }
+       if (updatemtime)
+               NFS_CHANGED_UPDATE(nfsvers, np, &np->n_vattr);
+nfsmout:
+       if (!lockerror)
+               nfs_node_unlock(np);
+       nfsm_chain_cleanup(&nmrep);
+       if ((committed != NFS_WRITE_FILESYNC) && nfs_allow_async &&
+           ((mp = NFSTOMP(np))) && (vfs_flags(mp) & MNT_ASYNC))
+               committed = NFS_WRITE_FILESYNC;
+       *iomodep = committed;
        return (error);
 }
 
 /*
- * nfs mknod rpc
- * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
+ * NFS mknod vnode op
+ *
+ * For NFS v2 this is a kludge. Use a create RPC but with the IFMT bits of the
  * mode set to specify the file type and the size field for rdev.
  */
-static int
-nfs_mknodrpc(dvp, vpp, cnp, vap)
-       register struct vnode *dvp;
-       register struct vnode **vpp;
-       register struct componentname *cnp;
-       register struct vattr *vap;
+int
+nfs3_vnop_mknod(
+       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;
+       } */ *ap)
 {
-       register struct nfsv2_sattr *sp;
-       register struct nfsv3_sattr *sp3;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       struct vnode *newvp = (struct vnode *)0;
-       struct nfsnode *np = (struct nfsnode *)0;
-       struct vattr vattr;
-       char *cp2;
-       caddr_t bpos, dpos;
-       int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       u_long rdev;
-       u_int64_t xid;
-       int v3 = NFS_ISV3(dvp);
+       vnode_t dvp = ap->a_dvp;
+       vnode_t *vpp = ap->a_vpp;
+       struct componentname *cnp = ap->a_cnp;
+       struct vnode_attr *vap = ap->a_vap;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t newvp = NULL;
+       nfsnode_t np = NULL;
+       struct nfsmount *nmp;
+       nfsnode_t dnp = VTONFS(dvp);
+       struct nfs_vattr nvattr, dnvattr;
+       fhandle_t fh;
+       int error = 0, lockerror = ENOENT, busyerror = ENOENT, status, wccpostattr = 0;
+       struct timespec premtime = { 0, 0 };
+       u_int32_t rdev;
+       u_int64_t xid, dxid;
+       int nfsvers, gotuid, gotgid;
+       struct nfsm_chain nmreq, nmrep;
 
-       if (vap->va_type == VCHR || vap->va_type == VBLK)
-               rdev = txdr_unsigned(vap->va_rdev);
-       else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
+       nmp = VTONMP(dvp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       if (!VATTR_IS_ACTIVE(vap, va_type))
+               return (EINVAL);
+       if (vap->va_type == VCHR || vap->va_type == VBLK) {
+               if (!VATTR_IS_ACTIVE(vap, va_rdev))
+                       return (EINVAL);
+               rdev = vap->va_rdev;
+       } else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
                rdev = 0xffffffff;
        else {
-               VOP_ABORTOP(dvp, cnp);
-               vput(dvp);
-               return (EOPNOTSUPP);
+               return (ENOTSUP);
        }
-       if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) {
-               VOP_ABORTOP(dvp, cnp);
-               vput(dvp);
-               return (error);
-       }
-       nfsstats.rpccnt[NFSPROC_MKNOD]++;
-       nfsm_reqhead(dvp, NFSPROC_MKNOD, NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
-               + nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-       if (v3) {
-               nfsm_build(tl, u_long *, NFSX_UNSIGNED + NFSX_V3SRVSATTR);
-               *tl++ = vtonfsv3_type(vap->va_type);
-               sp3 = (struct nfsv3_sattr *)tl;
-               nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid, vattr.va_gid);
+       if ((nfsvers == NFS_VER2) && (cnp->cn_namelen > NFS_MAXNAMLEN))
+               return (ENAMETOOLONG);
+
+       VATTR_SET_SUPPORTED(vap, va_mode);
+       VATTR_SET_SUPPORTED(vap, va_uid);
+       VATTR_SET_SUPPORTED(vap, va_gid);
+       VATTR_SET_SUPPORTED(vap, va_data_size);
+       VATTR_SET_SUPPORTED(vap, va_access_time);
+       VATTR_SET_SUPPORTED(vap, va_modify_time);
+       gotuid = VATTR_IS_ACTIVE(vap, va_uid);
+       gotgid = VATTR_IS_ACTIVE(vap, va_gid);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + 4 * NFSX_UNSIGNED +
+               nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(nfsvers));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen);
+       if (nfsvers == NFS_VER3) {
+               nfsm_chain_add_32(error, &nmreq, vtonfs_type(vap->va_type, nfsvers));
+               nfsm_chain_add_v3sattr(error, &nmreq, vap);
                if (vap->va_type == VCHR || vap->va_type == VBLK) {
-                       nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       *tl++ = txdr_unsigned(major(vap->va_rdev));
-                       *tl = txdr_unsigned(minor(vap->va_rdev));
+                       nfsm_chain_add_32(error, &nmreq, major(vap->va_rdev));
+                       nfsm_chain_add_32(error, &nmreq, minor(vap->va_rdev));
                }
        } else {
-               nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
-               sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
-               sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
-               sp->sa_gid = txdr_unsigned(vattr.va_gid);
-               sp->sa_size = rdev;
-               txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-               txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-       }
-       nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_proc, cnp->cn_cred, &xid);
-       if (!error) {
-               nfsm_mtofh(dvp, newvp, v3, gotvp, &xid);
-               if (!gotvp) {
-                       if (newvp) {
-                               vput(newvp);
-                               newvp = (struct vnode *)0;
-                       }
-                       error = nfs_lookitup(dvp, cnp->cn_nameptr,
-                           cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np);
-                       if (!error)
-                               newvp = NFSTOV(np);
+               nfsm_chain_add_v2sattr(error, &nmreq, vap, rdev);
+       }
+       nfsm_chain_build_done(error, &nmreq);
+       if (!error)
+               error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
+       nfsmout_if(error);
+
+       error = nfs_request(dnp, NULL, &nmreq, NFSPROC_MKNOD, ctx, &nmrep, &xid, &status);
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
+       /* XXX no EEXIST kludge here? */
+       dxid = xid;
+       if (!error && !status) {
+               if (dnp->n_flag & NNEGNCENTRIES) {
+                       dnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(dvp);
                }
+               error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
+       }
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
+       if (!error)
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+
+       if (!lockerror) {
+               dnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
+               nfs_node_unlock(dnp);
+               /* nfs_getattr() will check changed and purge caches */
+               nfs_getattr(dnp, &dnvattr, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
+       }
+
+       if (!error && fh.fh_len)
+               error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
+       if (!error && !np)
+               error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
+       if (!error && np)
+               newvp = NFSTOV(np);
+       if (!busyerror)
+               nfs_node_clear_busy(dnp);
+
+       if (!error && (gotuid || gotgid) &&
+           (!newvp || nfs_getattrcache(np, &nvattr) ||
+            (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
+            (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
+               /* clear ID bits if server didn't use them (or we can't tell) */
+               VATTR_CLEAR_SUPPORTED(vap, va_uid);
+               VATTR_CLEAR_SUPPORTED(vap, va_gid);
        }
-       if (v3)
-               nfsm_wcc_data(dvp, wccflag, &xid);
-       nfsm_reqdone;
        if (error) {
-               if (newvp)
-                       vput(newvp);
+               if (newvp) {
+                       nfs_node_unlock(np);
+                       vnode_put(newvp);
+               }
        } else {
-               if (cnp->cn_flags & MAKEENTRY)
-                       cache_enter(dvp, newvp, cnp);
                *vpp = newvp;
+               nfs_node_unlock(np);
        }
-       VTONFS(dvp)->n_flag |= NMODIFIED;
-       if (!wccflag)
-               VTONFS(dvp)->n_attrstamp = 0;
-       vput(dvp);
-       NFS_FREE_PNBUF(cnp);
        return (error);
 }
 
+static uint32_t create_verf;
 /*
- * nfs mknod vop
- * just call nfs_mknodrpc() to do the work.
+ * NFS file create call
  */
-/* ARGSUSED */
-static int
-nfs_mknod(ap)
-       struct vop_mknod_args /* {
-               struct vnode *a_dvp;
-               struct vnode **a_vpp;
+int
+nfs3_vnop_create(
+       struct vnop_create_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_dvp;
+               vnode_t *a_vpp;
                struct componentname *a_cnp;
-               struct vattr *a_vap;
-       } */ *ap;
+               struct vnode_attr *a_vap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       struct vnode *newvp;
-       int error;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t dvp = ap->a_dvp;
+       struct vnode_attr *vap = ap->a_vap;
+       struct componentname *cnp = ap->a_cnp;
+       struct nfs_vattr nvattr, dnvattr;
+       fhandle_t fh;
+       nfsnode_t np = NULL;
+       struct nfsmount *nmp;
+       nfsnode_t dnp = VTONFS(dvp);
+       vnode_t newvp = NULL;
+       int error = 0, lockerror = ENOENT, busyerror = ENOENT, status, wccpostattr = 0, fmode = 0;
+       struct timespec premtime = { 0, 0 };
+       int nfsvers, gotuid, gotgid;
+       u_int64_t xid, dxid;
+       uint32_t val;
+       struct nfsm_chain nmreq, nmrep;
+       struct nfsreq *req;
+       struct nfs_dulookup dul;
 
-       error = nfs_mknodrpc(ap->a_dvp, &newvp, ap->a_cnp, ap->a_vap);
-       if (!error && newvp)
-               vput(newvp);
-       *ap->a_vpp = 0;
-       return (error);
-}
+       nmp = VTONMP(dvp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
 
-static u_long create_verf;
-/*
- * nfs file create call
- */
-static int
-nfs_create(ap)
-       struct vop_create_args /* {
-               struct vnode *a_dvp;
-               struct vnode **a_vpp;
-               struct componentname *a_cnp;
-               struct vattr *a_vap;
-       } */ *ap;
-{
-       register struct vnode *dvp = ap->a_dvp;
-       register struct vattr *vap = ap->a_vap;
-       register struct componentname *cnp = ap->a_cnp;
-       register struct nfsv2_sattr *sp;
-       register struct nfsv3_sattr *sp3;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       struct nfsnode *np = (struct nfsnode *)0;
-       struct vnode *newvp = (struct vnode *)0;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       struct vattr vattr;
-       int v3 = NFS_ISV3(dvp);
-       u_int64_t xid;
+       if ((nfsvers == NFS_VER2) && (cnp->cn_namelen > NFS_MAXNAMLEN))
+               return (ENAMETOOLONG);
 
-       /*
-        * Oops, not for me..
-        */
-       if (vap->va_type == VSOCK)
-               return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap));
+       VATTR_SET_SUPPORTED(vap, va_mode);
+       VATTR_SET_SUPPORTED(vap, va_uid);
+       VATTR_SET_SUPPORTED(vap, va_gid);
+       VATTR_SET_SUPPORTED(vap, va_data_size);
+       VATTR_SET_SUPPORTED(vap, va_access_time);
+       VATTR_SET_SUPPORTED(vap, va_modify_time);
+       gotuid = VATTR_IS_ACTIVE(vap, va_uid);
+       gotgid = VATTR_IS_ACTIVE(vap, va_gid);
 
-       if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) {
-               VOP_ABORTOP(dvp, cnp);
-               vput(dvp);
-               return (error);
-       }
        if (vap->va_vaflags & VA_EXCLUSIVE)
                fmode |= O_EXCL;
+
 again:
-       nfsstats.rpccnt[NFSPROC_CREATE]++;
-       nfsm_reqhead(dvp, NFSPROC_CREATE, NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
-               nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-       if (v3) {
-               nfsm_build(tl, u_long *, NFSX_UNSIGNED);
+       req = NULL;
+       error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
+       nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + 2 * NFSX_UNSIGNED +
+               nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(nfsvers));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen);
+       if (nfsvers == NFS_VER3) {
                if (fmode & O_EXCL) {
-                   *tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
-                   nfsm_build(tl, u_long *, NFSX_V3CREATEVERF);
-                   if (!TAILQ_EMPTY(&in_ifaddrhead))
-                       *tl++ = IA_SIN(in_ifaddrhead.tqh_first)->sin_addr.s_addr;
-                   else
-                       *tl++ = create_verf;
-                   *tl = ++create_verf;
+                       nfsm_chain_add_32(error, &nmreq, NFS_CREATE_EXCLUSIVE);
+                       lck_rw_lock_shared(in_ifaddr_rwlock);
+                       if (!TAILQ_EMPTY(&in_ifaddrhead))
+                               val = IA_SIN(in_ifaddrhead.tqh_first)->sin_addr.s_addr;
+                       else
+                               val = create_verf;
+                       lck_rw_done(in_ifaddr_rwlock);
+                       nfsm_chain_add_32(error, &nmreq, val);
+                       ++create_verf;
+                       nfsm_chain_add_32(error, &nmreq, create_verf);
                } else {
-                   *tl = txdr_unsigned(NFSV3CREATE_UNCHECKED);
-                   nfsm_build(tl, u_long *, NFSX_V3SRVSATTR);
-                   sp3 = (struct nfsv3_sattr *)tl;
-                   nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid, vattr.va_gid);
+                       nfsm_chain_add_32(error, &nmreq, NFS_CREATE_UNCHECKED);
+                       nfsm_chain_add_v3sattr(error, &nmreq, vap);
                }
        } else {
-               nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
-               sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
-               sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
-               sp->sa_gid = txdr_unsigned(vattr.va_gid);
-               sp->sa_size = 0;
-               txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-               txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-       }
-       nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred, &xid);
+               nfsm_chain_add_v2sattr(error, &nmreq, vap, 0);
+       }
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+
+       error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_CREATE,
+                       vfs_context_thread(ctx), vfs_context_ucred(ctx), NULL, &req);
        if (!error) {
-               nfsm_mtofh(dvp, newvp, v3, gotvp, &xid);
-               if (!gotvp) {
-                       if (newvp) {
-                               vput(newvp);
-                               newvp = (struct vnode *)0;
-                       }
-                       error = nfs_lookitup(dvp, cnp->cn_nameptr,
-                           cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np);
-                       if (!error)
-                               newvp = NFSTOV(np);
+               nfs_dulookup_start(&dul, dnp, ctx);
+               error = nfs_request_async_finish(req, &nmrep, &xid, &status);
+       }
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
+       dxid = xid;
+       if (!error && !status) {
+               if (dnp->n_flag & NNEGNCENTRIES) {
+                       dnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(dvp);
                }
+               error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
+       }
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
+       if (!error)
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+
+       if (!lockerror) {
+               dnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
+               nfs_node_unlock(dnp);
+               /* nfs_getattr() will check changed and purge caches */
+               nfs_getattr(dnp, &dnvattr, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
        }
-       if (v3)
-               nfsm_wcc_data(dvp, wccflag, &xid);
-       nfsm_reqdone;
+
+       if (!error && fh.fh_len)
+               error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
+       if (!error && !np)
+               error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
+       if (!error && np)
+               newvp = NFSTOV(np);
+
+       nfs_dulookup_finish(&dul, dnp, ctx);
+       if (!busyerror)
+               nfs_node_clear_busy(dnp);
+
        if (error) {
-               if (v3 && (fmode & O_EXCL) && error == NFSERR_NOTSUPP) {
+               if ((nfsvers == NFS_VER3) && (fmode & O_EXCL) && (error == NFSERR_NOTSUPP)) {
                        fmode &= ~O_EXCL;
                        goto again;
                }
-               if (newvp)
-                       vput(newvp);
-       } else if (v3 && (fmode & O_EXCL))
-               error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_proc);
-       if (!error) {
-               if (cnp->cn_flags & MAKEENTRY)
-                       cache_enter(dvp, newvp, cnp);
+               if (newvp) {
+                       nfs_node_unlock(np);
+                       vnode_put(newvp);
+               }
+       } else if ((nfsvers == NFS_VER3) && (fmode & O_EXCL)) {
+               nfs_node_unlock(np);
+               error = nfs3_setattr_rpc(np, vap, ctx);
+               if (error && (gotuid || gotgid)) {
+                       /* it's possible the server didn't like our attempt to set IDs. */
+                       /* so, let's try it again without those */
+                       VATTR_CLEAR_ACTIVE(vap, va_uid);
+                       VATTR_CLEAR_ACTIVE(vap, va_gid);
+                       error = nfs3_setattr_rpc(np, vap, ctx);
+               }
+               if (error)
+                       vnode_put(newvp);
+               else
+                       nfs_node_lock_force(np);
+       }
+       if (!error)
                *ap->a_vpp = newvp;
+       if (!error && (gotuid || gotgid) &&
+           (!newvp || nfs_getattrcache(np, &nvattr) ||
+            (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
+            (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
+               /* clear ID bits if server didn't use them (or we can't tell) */
+               VATTR_CLEAR_SUPPORTED(vap, va_uid);
+               VATTR_CLEAR_SUPPORTED(vap, va_gid);
        }
-       VTONFS(dvp)->n_flag |= NMODIFIED;
-       if (!wccflag)
-               VTONFS(dvp)->n_attrstamp = 0;
-       vput(dvp);
-       NFS_FREE_PNBUF(cnp);
+       if (!error)
+               nfs_node_unlock(np);
        return (error);
 }
 
 /*
- * nfs file remove call
- * To try and make nfs semantics closer to ufs semantics, a file that has
+ * NFS file remove call
+ * To try and make NFS semantics closer to UFS semantics, a file that has
  * other processes using the vnode is renamed instead of removed and then
  * removed later on the last close.
- * - If v_usecount > 1
+ * - If vnode_isinuse()
  *       If a rename is not already in the works
  *          call nfs_sillyrename() to set it up
  *     else
- *       do the remove rpc
+ *       do the remove RPC
  */
-static int
-nfs_remove(ap)
-       struct vop_remove_args /* {
+int
+nfs_vnop_remove(
+       struct vnop_remove_args /* {
                struct vnodeop_desc *a_desc;
-               struct vnode * a_dvp;
-               struct vnode * a_vp;
-               struct componentname * a_cnp;
-       } */ *ap;
+               vnode_t a_dvp;
+               vnode_t a_vp;
+               struct componentname *a_cnp;
+               int a_flags;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct vnode *dvp = ap->a_dvp;
-       register struct componentname *cnp = ap->a_cnp;
-       register struct nfsnode *np = VTONFS(vp);
-       int error = 0, gofree = 0;
-       struct vattr vattr;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       vnode_t dvp = ap->a_dvp;
+       struct componentname *cnp = ap->a_cnp;
+       nfsnode_t dnp = VTONFS(dvp);
+       nfsnode_t np = VTONFS(vp);
+       int error = 0, nfsvers, inuse, gotattr = 0, flushed = 0, setsize = 0;
+       struct nfs_vattr nvattr;
+       struct nfsmount *nmp;
+       struct nfs_dulookup dul;
 
-#if DIAGNOSTIC
-       if ((cnp->cn_flags & HASBUF) == 0)
-               panic("nfs_remove: no name");
-       if (vp->v_usecount < 1)
-               panic("nfs_remove: bad v_usecount");
-#endif
+       /* XXX prevent removing a sillyrenamed file? */
 
-       if (UBCISVALID(vp)) {
-               /* regular files */
-               if (UBCINFOEXISTS(vp))
-                       gofree = (ubc_isinuse(vp, 1)) ? 0 : 1;
-               else {
-                       /* dead or dying vnode.With vnode locking panic instead of error */
-                       vput(dvp);
-                       vput(vp);
-                       NFS_FREE_PNBUF(cnp);
-                       return (EIO);
-               }
-       } else {
-               /* UBC not in play */
-               if (vp->v_usecount == 1)
-                       gofree = 1;
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+again_relock:
+       error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx));
+       if (error)
+               return (error);
+
+       /* lock the node while we remove the file */
+       lck_mtx_lock(nfs_node_hash_mutex);
+       while (np->n_hflag & NHLOCKED) {
+               np->n_hflag |= NHLOCKWANT;
+               msleep(np, nfs_node_hash_mutex, PINOD, "nfs_remove", NULL);
        }
-       if ((ap->a_cnp->cn_flags & NODELETEBUSY) && !gofree) {
+       np->n_hflag |= NHLOCKED;
+       lck_mtx_unlock(nfs_node_hash_mutex);
+
+       nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
+again:
+       inuse = vnode_isinuse(vp, 0);
+       if ((ap->a_flags & VNODE_REMOVE_NODELETEBUSY) && inuse) {
                /* Caller requested Carbon delete semantics, but file is busy */
-               vput(dvp);
-               vput(vp);
-               NFS_FREE_PNBUF(cnp);
-               return (EBUSY);
-       }
-       if (gofree || (np->n_sillyrename &&
-               VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_proc) == 0 &&
-               vattr.va_nlink > 1)) {
+               error = EBUSY;
+               goto out;
+       }
+       if (inuse && !gotattr) {
+               if (nfs_getattr(np, &nvattr, ctx, NGA_CACHED))
+                       nvattr.nva_nlink = 1;
+               gotattr = 1;
+               goto again;
+       }
+       if (!inuse || (np->n_sillyrename && (nvattr.nva_nlink > 1))) {
+
+               if (!inuse && !flushed) { /* flush all the buffers first */
+                       /* unlock the node */
+                       lck_mtx_lock(nfs_node_hash_mutex);
+                       np->n_hflag &= ~NHLOCKED;
+                       if (np->n_hflag & NHLOCKWANT) {
+                               np->n_hflag &= ~NHLOCKWANT;
+                               wakeup(np);
+                       }
+                       lck_mtx_unlock(nfs_node_hash_mutex);
+                       nfs_node_clear_busy2(dnp, np);
+                       error = nfs_vinvalbuf(vp, V_SAVE, ctx, 1);
+                       FSDBG(260, np, np->n_size, np->n_vattr.nva_size, 0xf00d0011);
+                       flushed = 1;
+                       if (error == EINTR) {
+                               nfs_node_lock_force(np);
+                               NATTRINVALIDATE(np);
+                               nfs_node_unlock(np);
+                               return (error);
+                       }
+                       goto again_relock;
+               }
+
+               if ((nmp->nm_vers >= NFS_VER4) && (np->n_openflags & N_DELEG_MASK)) {
+                       lck_mtx_lock(&np->n_openlock);
+                       np->n_openflags &= ~N_DELEG_MASK;
+                       lck_mtx_unlock(&np->n_openlock);
+                       nfs4_delegreturn_rpc(nmp, np->n_fhp, np->n_fhsize, &np->n_dstateid,
+                               vfs_context_thread(ctx), vfs_context_ucred(ctx));
+               }
+
                /*
                 * Purge the name cache so that the chance of a lookup for
                 * the name succeeding while the remove is in progress is
-                * minimized. Without node locking it can still happen, such
-                * that an I/O op returns ESTALE, but since you get this if
-                * another host removes the file..
+                * minimized.
                 */
-               cache_purge(vp);
-               /*
-                * throw away biocache buffers, mainly to avoid
-                * unnecessary delayed writes later.
-                */
-               error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_proc, 1);
-               np->n_size = 0;
-               ubc_setsize(vp, (off_t)0); /* XXX check error */
+               nfs_name_cache_purge(dnp, np, cnp, ctx);
+
+               nfs_dulookup_start(&dul, dnp, ctx);
+
                /* Do the rpc */
-               if (error != EINTR)
-                       error = nfs_removerpc(dvp, cnp->cn_nameptr,
-                               cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc);
+               error = nmp->nm_funcs->nf_remove_rpc(dnp, cnp->cn_nameptr, cnp->cn_namelen,
+                               vfs_context_thread(ctx), vfs_context_ucred(ctx));
+
                /*
                 * Kludge City: If the first reply to the remove rpc is lost..
                 *   the reply to the retransmitted request will be ENOENT
@@ -2063,116 +3184,201 @@ nfs_remove(ap)
                 */
                if (error == ENOENT)
                        error = 0;
-               if (!error) {
+
+               if (!error && !inuse && !np->n_sillyrename) {
                        /*
+                        * removal succeeded, it's not in use, and not silly renamed so
                         * remove nfsnode from hash now so we can't accidentally find it
                         * again if another object gets created with the same filehandle
                         * before this vnode gets reclaimed
                         */
-                       LIST_REMOVE(np, n_hash);
-                       np->n_flag &= ~NHASHED;
+                       lck_mtx_lock(nfs_node_hash_mutex);
+                       if (np->n_hflag & NHHASHED) {
+                               LIST_REMOVE(np, n_hash);
+                               np->n_hflag &= ~NHHASHED;
+                               FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
+                       }
+                       lck_mtx_unlock(nfs_node_hash_mutex);
+                       /* clear flags now: won't get nfs_vnop_inactive for recycled vnode */
+                       /* clear all flags other than these */
+                       nfs_node_lock_force(np);
+                       np->n_flag &= (NMODIFIED);
+                       NATTRINVALIDATE(np);
+                       nfs_node_unlock(np);
+                       vnode_recycle(vp);
+                       setsize = 1;
+               } else {
+                       nfs_node_lock_force(np);
+                       NATTRINVALIDATE(np);
+                       nfs_node_unlock(np);
                }
        } else if (!np->n_sillyrename) {
-               error = nfs_sillyrename(dvp, vp, cnp);
+               nfs_dulookup_start(&dul, dnp, ctx);
+               error = nfs_sillyrename(dnp, np, cnp, ctx);
+               nfs_node_lock_force(np);
+               NATTRINVALIDATE(np);
+               nfs_node_unlock(np);
+       } else {
+               nfs_node_lock_force(np);
+               NATTRINVALIDATE(np);
+               nfs_node_unlock(np);
+               nfs_dulookup_start(&dul, dnp, ctx);
        }
-       np->n_attrstamp = 0;
-       vput(dvp);
-
-       VOP_UNLOCK(vp, 0, cnp->cn_proc);
-       NFS_FREE_PNBUF(cnp);
-       ubc_uncache(vp);
-       vrele(vp);
 
+       /* nfs_getattr() will check changed and purge caches */
+       nfs_getattr(dnp, &nvattr, ctx, NGA_CACHED);
+       nfs_dulookup_finish(&dul, dnp, ctx);
+out:
+       /* unlock the node */
+       lck_mtx_lock(nfs_node_hash_mutex);
+       np->n_hflag &= ~NHLOCKED;
+       if (np->n_hflag & NHLOCKWANT) {
+               np->n_hflag &= ~NHLOCKWANT;
+               wakeup(np);
+       }
+       lck_mtx_unlock(nfs_node_hash_mutex);
+       nfs_node_clear_busy2(dnp, np);
+       if (setsize)
+               ubc_setsize(vp, 0);
        return (error);
 }
 
 /*
- * nfs file remove rpc called from nfs_inactive
+ * NFS silly-renamed file removal function called from nfs_vnop_inactive
  */
 int
-nfs_removeit(sp)
-       register struct sillyrename *sp;
+nfs_removeit(struct nfs_sillyrename *nsp)
 {
-
-       return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
-               (struct proc *)0));
+       struct nfsmount *nmp = NFSTONMP(nsp->nsr_dnp);
+       if (!nmp)
+               return (ENXIO);
+       return nmp->nm_funcs->nf_remove_rpc(nsp->nsr_dnp, nsp->nsr_name, nsp->nsr_namlen, NULL, nsp->nsr_cred);
 }
 
 /*
- * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
+ * NFS remove rpc, called from nfs_remove() and nfs_removeit().
  */
-static int
-nfs_removerpc(dvp, name, namelen, cred, proc)
-       register struct vnode *dvp;
-       char *name;
-       int namelen;
-       struct ucred *cred;
-       struct proc *proc;
+int
+nfs3_remove_rpc(
+       nfsnode_t dnp,
+       char *name,
+       int namelen,
+       thread_t thd,
+       kauth_cred_t cred)
 {
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, wccflag = NFSV3_WCCRATTR;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3;
+       int error = 0, lockerror = ENOENT, status, wccpostattr = 0;
+       struct timespec premtime = { 0, 0 };
+       struct nfsmount *nmp;
+       int nfsvers;
        u_int64_t xid;
+       struct nfsm_chain nmreq, nmrep;
 
-       if (!VFSTONFS(dvp->v_mount))
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
                return (ENXIO);
-       v3 = NFS_ISV3(dvp);
-
-       nfsstats.rpccnt[NFSPROC_REMOVE]++;
-       nfsm_reqhead(dvp, NFSPROC_REMOVE,
-               NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
-       nfsm_request(dvp, NFSPROC_REMOVE, proc, cred, &xid);
-       if (v3)
-               nfsm_wcc_data(dvp, wccflag, &xid);
-       nfsm_reqdone;
-       VTONFS(dvp)->n_flag |= NMODIFIED;
-       if (!wccflag)
-               VTONFS(dvp)->n_attrstamp = 0;
+       nfsvers = nmp->nm_vers;
+       if ((nfsvers == NFS_VER2) && (namelen > NFS_MAXNAMLEN))
+               return (ENAMETOOLONG);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + NFSX_UNSIGNED + nfsm_rndup(namelen));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, name, namelen);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+
+       error = nfs_request2(dnp, NULL, &nmreq, NFSPROC_REMOVE, thd, cred, 0, &nmrep, &xid, &status);
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &xid);
+       nfsmout_if(error);
+       dnp->n_flag |= NMODIFIED;
+       /* if directory hadn't changed, update namecache mtime */
+       if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
+               NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
+       if (!wccpostattr)
+               NATTRINVALIDATE(dnp);
+       if (!error)
+               error = status;
+nfsmout:
+       if (!lockerror)
+               nfs_node_unlock(dnp);
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
        return (error);
 }
 
 /*
- * nfs file rename call
+ * NFS file rename call
  */
-static int
-nfs_rename(ap)
-       struct vop_rename_args  /* {
-               struct vnode *a_fdvp;
-               struct vnode *a_fvp;
+int
+nfs_vnop_rename(
+       struct vnop_rename_args  /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_fdvp;
+               vnode_t a_fvp;
                struct componentname *a_fcnp;
-               struct vnode *a_tdvp;
-               struct vnode *a_tvp;
+               vnode_t a_tdvp;
+               vnode_t a_tvp;
                struct componentname *a_tcnp;
-       } */ *ap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *fvp = ap->a_fvp;
-       register struct vnode *tvp = ap->a_tvp;
-       register struct vnode *fdvp = ap->a_fdvp;
-       register struct vnode *tdvp = ap->a_tdvp;
-       register struct componentname *tcnp = ap->a_tcnp;
-       register struct componentname *fcnp = ap->a_fcnp;
-       int error, purged=0, inuse=0;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t fdvp = ap->a_fdvp;
+       vnode_t fvp = ap->a_fvp;
+       vnode_t tdvp = ap->a_tdvp;
+       vnode_t tvp = ap->a_tvp;
+       nfsnode_t fdnp, fnp, tdnp, tnp;
+       struct componentname *tcnp = ap->a_tcnp;
+       struct componentname *fcnp = ap->a_fcnp;
+       int error, nfsvers, inuse=0, tvprecycle=0, locked=0;
+       mount_t fmp, tdmp, tmp;
+       struct nfs_vattr nvattr;
+       struct nfsmount *nmp;
+
+       fdnp = VTONFS(fdvp);
+       fnp = VTONFS(fvp);
+       tdnp = VTONFS(tdvp);
+       tnp = tvp ? VTONFS(tvp) : NULL;
+
+       nmp = NFSTONMP(fdnp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       error = nfs_node_set_busy4(fdnp, fnp, tdnp, tnp, vfs_context_thread(ctx));
+       if (error)
+               return (error);
+
+       if (tvp && (tvp != fvp)) {
+               /* lock the node while we rename over the existing file */
+               lck_mtx_lock(nfs_node_hash_mutex);
+               while (tnp->n_hflag & NHLOCKED) {
+                       tnp->n_hflag |= NHLOCKWANT;
+                       msleep(tnp, nfs_node_hash_mutex, PINOD, "nfs_rename", NULL);
+               }
+               tnp->n_hflag |= NHLOCKED;
+               lck_mtx_unlock(nfs_node_hash_mutex);
+               locked = 1;
+       }
 
-#if DIAGNOSTIC
-       if ((tcnp->cn_flags & HASBUF) == 0 ||
-           (fcnp->cn_flags & HASBUF) == 0)
-               panic("nfs_rename: no name");
-#endif
        /* Check for cross-device rename */
-       if ((fvp->v_mount != tdvp->v_mount) ||
-           (tvp && (fvp->v_mount != tvp->v_mount))) {
+       fmp = vnode_mount(fvp);
+       tmp = tvp ? vnode_mount(tvp) : NULL;
+       tdmp = vnode_mount(tdvp);
+       if ((fmp != tdmp) || (tvp && (fmp != tmp))) {
                error = EXDEV;
-               if (tvp)
-                       VOP_UNLOCK(tvp, 0, tcnp->cn_proc);
                goto out;
        }
 
+       /* XXX prevent renaming from/over a sillyrenamed file? */
+
        /*
         * If the tvp exists and is in use, sillyrename it before doing the
         * rename of the new file over it.
@@ -2180,227 +3386,273 @@ nfs_rename(ap)
         * Don't sillyrename if source and target are same vnode (hard
         * links or case-variants)
         */
-       if (tvp && tvp != fvp) {
-               if (UBCISVALID(tvp)) {
-                       /* regular files */
-                       if (UBCINFOEXISTS(tvp))
-                               inuse = (ubc_isinuse(tvp, 1)) ? 1 : 0;
-                       else {
-                               /* dead or dying vnode.With vnode locking panic instead of error */
-                               error = EIO;
-                               VOP_UNLOCK(tvp, 0, tcnp->cn_proc);
-                               goto out;  
-                       }
-               } else {
-                       /* UBC not in play */
-                       if (tvp->v_usecount > 1)
-                               inuse = 1;
-               }
-       }
-       if (inuse && !VTONFS(tvp)->n_sillyrename && tvp->v_type != VDIR) {
-               if  (error = nfs_sillyrename(tdvp, tvp, tcnp)) {
+       if (tvp && (tvp != fvp))
+               inuse = vnode_isinuse(tvp, 0);
+       if (inuse && !tnp->n_sillyrename && (vnode_vtype(tvp) != VDIR)) {
+               error = nfs_sillyrename(tdnp, tnp, tcnp, ctx);
+               if (error) {
                        /* sillyrename failed. Instead of pressing on, return error */
-                       VOP_UNLOCK(tvp, 0, tcnp->cn_proc);
                        goto out; /* should not be ENOENT. */
                } else {
                        /* sillyrename succeeded.*/
-                       VOP_UNLOCK(tvp, 0, tcnp->cn_proc);
-                       ubc_uncache(tvp); /* get the nfs turd file to disappear */
-                       vrele(tvp);
                        tvp = NULL;
                }
+       } else if (tvp && (nmp->nm_vers >= NFS_VER4) && (tnp->n_openflags & N_DELEG_MASK)) {
+               lck_mtx_lock(&tnp->n_openlock);
+               tnp->n_openflags &= ~N_DELEG_MASK;
+               lck_mtx_unlock(&tnp->n_openlock);
+               nfs4_delegreturn_rpc(nmp, tnp->n_fhp, tnp->n_fhsize, &tnp->n_dstateid,
+                       vfs_context_thread(ctx), vfs_context_ucred(ctx));
        }
 
-       error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
-               tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
-               tcnp->cn_proc);
+       error = nmp->nm_funcs->nf_rename_rpc(fdnp, fcnp->cn_nameptr, fcnp->cn_namelen,
+                       tdnp, tcnp->cn_nameptr, tcnp->cn_namelen, ctx);
 
-       if (!error && tvp && tvp != fvp && !VTONFS(tvp)->n_sillyrename) {
-               /*
-                * remove nfsnode from hash now so we can't accidentally find it
-                * again if another object gets created with the same filehandle
-                * before this vnode gets reclaimed
-                */
-               LIST_REMOVE(VTONFS(tvp), n_hash);
-               VTONFS(tvp)->n_flag &= ~NHASHED;
-       }
+       /*
+        * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
+        */
+       if (error == ENOENT)
+               error = 0;
 
-       if (fvp->v_type == VDIR) {
-               if (tvp != NULL && tvp->v_type == VDIR) {
-                       cache_purge(tdvp);
-                       if (tvp == tdvp) 
-                               purged = 1;
+       if (tvp && (tvp != fvp) && !tnp->n_sillyrename) {
+               nfs_node_lock_force(tnp);
+               tvprecycle = (!error && !vnode_isinuse(tvp, 0) &&
+                   (nfs_getattrcache(tnp, &nvattr) || (nvattr.nva_nlink == 1)));
+               nfs_node_unlock(tnp);
+               lck_mtx_lock(nfs_node_hash_mutex);
+               if (tvprecycle && (tnp->n_hflag & NHHASHED)) {
+                       /*
+                        * remove nfsnode from hash now so we can't accidentally find it
+                        * again if another object gets created with the same filehandle
+                        * before this vnode gets reclaimed
+                        */
+                       LIST_REMOVE(tnp, n_hash);
+                       tnp->n_hflag &= ~NHHASHED;
+                       FSDBG(266, 0, tnp, tnp->n_flag, 0xb1eb1e);
                }
-               cache_purge(fdvp);
+               lck_mtx_unlock(nfs_node_hash_mutex);
        }
-       
-       cache_purge(fvp);
+
+       /* purge the old name cache entries and enter the new one */
+       nfs_name_cache_purge(fdnp, fnp, fcnp, ctx);
        if (tvp) {
-               if (!purged)
-                       cache_purge(tvp);
-               VOP_UNLOCK(tvp, 0, tcnp->cn_proc);
-               ubc_uncache(tvp); /* get the nfs turd file to disappear */
+               nfs_name_cache_purge(tdnp, tnp, tcnp, ctx);
+               if (tvprecycle) {
+                       /* clear flags now: won't get nfs_vnop_inactive for recycled vnode */
+                       /* clear all flags other than these */
+                       nfs_node_lock_force(tnp);
+                       tnp->n_flag &= (NMODIFIED);
+                       nfs_node_unlock(tnp);
+                       vnode_recycle(tvp);
+               }
+       }
+       if (!error) {
+               nfs_node_lock_force(tdnp);
+               if (tdnp->n_flag & NNEGNCENTRIES) {
+                       tdnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(tdvp);
+               }
+               nfs_node_unlock(tdnp);
+               nfs_node_lock_force(fnp);
+               cache_enter(tdvp, fvp, tcnp);
+               if (tdvp != fdvp) {     /* update parent pointer */
+                       if (fnp->n_parent && !vnode_get(fnp->n_parent)) {
+                               /* remove ref from old parent */
+                               vnode_rele(fnp->n_parent);
+                               vnode_put(fnp->n_parent);
+                       }
+                       fnp->n_parent = tdvp;
+                       if (tdvp && !vnode_get(tdvp)) {
+                               /* add ref to new parent */
+                               vnode_ref(tdvp);
+                               vnode_put(tdvp);
+                       } else {
+                               fnp->n_parent = NULL;
+                       }
+               }
+               nfs_node_unlock(fnp);
        }
-       
 out:
-       if (tdvp == tvp)
-               vrele(tdvp);
-       else
-               vput(tdvp);
-       if (tvp)
-               vrele(tvp); /* already unlocked */
-       vrele(fdvp);
-       vrele(fvp);
-       /*
-        * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
-        */
-       if (error == ENOENT)
-               error = 0;
+       /* nfs_getattr() will check changed and purge caches */
+       nfs_getattr(fdnp, &nvattr, ctx, NGA_CACHED);
+       nfs_getattr(tdnp, &nvattr, ctx, NGA_CACHED);
+       if (locked) {
+               /* unlock node */
+               lck_mtx_lock(nfs_node_hash_mutex);
+               tnp->n_hflag &= ~NHLOCKED;
+               if (tnp->n_hflag & NHLOCKWANT) {
+                       tnp->n_hflag &= ~NHLOCKWANT;
+                       wakeup(tnp);
+               }
+               lck_mtx_unlock(nfs_node_hash_mutex);
+       }
+       nfs_node_clear_busy4(fdnp, fnp, tdnp, tnp);
        return (error);
 }
 
 /*
- * nfs file rename rpc called from nfs_remove() above
- */
-static int
-nfs_renameit(sdvp, scnp, sp)
-       struct vnode *sdvp;
-       struct componentname *scnp;
-       register struct sillyrename *sp;
-{
-       return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen,
-               sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_proc));
-}
-
-/*
- * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
+ * Do an NFS rename rpc. Called from nfs_vnop_rename() and nfs_sillyrename().
  */
-static int
-nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc)
-       register struct vnode *fdvp;
-       char *fnameptr;
-       int fnamelen;
-       register struct vnode *tdvp;
-       char *tnameptr;
-       int tnamelen;
-       struct ucred *cred;
-       struct proc *proc;
+int
+nfs3_rename_rpc(
+       nfsnode_t fdnp,
+       char *fnameptr,
+       int fnamelen,
+       nfsnode_t tdnp,
+       char *tnameptr,
+       int tnamelen,
+       vfs_context_t ctx)
 {
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3;
-       u_int64_t xid;
+       int error = 0, lockerror = ENOENT, status, fwccpostattr = 0, twccpostattr = 0;
+       struct timespec fpremtime = { 0, 0 }, tpremtime = { 0, 0 };
+       struct nfsmount *nmp;
+       int nfsvers;
+       u_int64_t xid, txid;
+       struct nfsm_chain nmreq, nmrep;
 
-       if (!VFSTONFS(fdvp->v_mount))
+       nmp = NFSTONMP(fdnp);
+       if (!nmp)
                return (ENXIO);
-       v3 = NFS_ISV3(fdvp);
-
-       nfsstats.rpccnt[NFSPROC_RENAME]++;
-       nfsm_reqhead(fdvp, NFSPROC_RENAME,
-                    (NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
-                     nfsm_rndup(tnamelen));
-       nfsm_fhtom(fdvp, v3);
-       nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN);
-       nfsm_fhtom(tdvp, v3);
-       nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN);
-       nfsm_request(fdvp, NFSPROC_RENAME, proc, cred, &xid);
-       if (v3) {
-               u_int64_t txid = xid;
-
-               nfsm_wcc_data(fdvp, fwccflag, &xid);
-               nfsm_wcc_data(tdvp, twccflag, &txid);
-       }
-       nfsm_reqdone;
-       VTONFS(fdvp)->n_flag |= NMODIFIED;
-       if (!fwccflag)
-               VTONFS(fdvp)->n_attrstamp = 0;
-       VTONFS(tdvp)->n_flag |= NMODIFIED;
-       if (!twccflag)
-               VTONFS(tdvp)->n_attrstamp = 0;
+       nfsvers = nmp->nm_vers;
+       if ((nfsvers == NFS_VER2) &&
+           ((fnamelen > NFS_MAXNAMLEN) || (tnamelen > NFS_MAXNAMLEN)))
+               return (ENAMETOOLONG);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               (NFSX_FH(nfsvers) + NFSX_UNSIGNED) * 2 +
+               nfsm_rndup(fnamelen) + nfsm_rndup(tnamelen));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, fdnp->n_fhp, fdnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, fnameptr, fnamelen);
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, tdnp->n_fhp, tdnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, tnameptr, tnamelen);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+
+       error = nfs_request(fdnp, NULL, &nmreq, NFSPROC_RENAME, ctx, &nmrep, &xid, &status);
+
+       if ((lockerror = nfs_node_lock2(fdnp, tdnp)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3) {
+               txid = xid;
+               nfsm_chain_get_wcc_data(error, &nmrep, fdnp, &fpremtime, &fwccpostattr, &xid);
+               nfsm_chain_get_wcc_data(error, &nmrep, tdnp, &tpremtime, &twccpostattr, &txid);
+       }
+       if (!error)
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       if (!lockerror) {
+               fdnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&fdnp->n_ncmtime, &fpremtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, fdnp, &fdnp->n_vattr);
+               if (!fwccpostattr)
+                       NATTRINVALIDATE(fdnp);
+               tdnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&tdnp->n_ncmtime, &tpremtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, tdnp, &tdnp->n_vattr);
+               if (!twccpostattr)
+                       NATTRINVALIDATE(tdnp);
+               nfs_node_unlock2(fdnp, tdnp);
+       }
        return (error);
 }
 
 /*
- * nfs hard link create call
+ * NFS hard link create call
  */
-static int
-nfs_link(ap)
-       struct vop_link_args /* {
-               struct vnode *a_vp;
-               struct vnode *a_tdvp;
+int
+nfs3_vnop_link(
+       struct vnop_link_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               vnode_t a_tdvp;
                struct componentname *a_cnp;
-       } */ *ap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct vnode *tdvp = ap->a_tdvp;
-       register struct componentname *cnp = ap->a_cnp;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3, didhold;
-       u_int64_t xid;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       vnode_t tdvp = ap->a_tdvp;
+       struct componentname *cnp = ap->a_cnp;
+       int error = 0, lockerror = ENOENT, status, wccpostattr = 0, attrflag = 0;
+       struct timespec premtime = { 0, 0 };
+       struct nfsmount *nmp;
+       nfsnode_t np = VTONFS(vp);
+       nfsnode_t tdnp = VTONFS(tdvp);
+       int nfsvers;
+       u_int64_t xid, txid;
+       struct nfsm_chain nmreq, nmrep;
 
-       if (vp->v_mount != tdvp->v_mount) {
-               VOP_ABORTOP(vp, cnp);
-               vput(tdvp);
+       if (vnode_mount(vp) != vnode_mount(tdvp))
                return (EXDEV);
-       }
-
-       /* need to get vnode lock for vp before calling VOP_FSYNC() */
-       if (error = vn_lock(vp, LK_EXCLUSIVE, cnp->cn_proc)) {
-               VOP_ABORTOP(vp, cnp);
-               vput(tdvp);
-               return (error);
-       }
 
-       if (!VFSTONFS(vp->v_mount)) {
-               VOP_UNLOCK(vp, 0, cnp->cn_proc);
-               VOP_ABORTOP(vp, cnp);
-               vput(tdvp);
+       nmp = VTONMP(vp);
+       if (!nmp)
                return (ENXIO);
-       }
-       v3 = NFS_ISV3(vp);
+       nfsvers = nmp->nm_vers;
+       if ((nfsvers == NFS_VER2) && (cnp->cn_namelen > NFS_MAXNAMLEN))
+               return (ENAMETOOLONG);
 
        /*
         * Push all writes to the server, so that the attribute cache
         * doesn't get "out of sync" with the server.
         * XXX There should be a better way!
         */
-       didhold = ubc_hold(vp);
-       VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_proc);
-       VOP_UNLOCK(vp, 0, cnp->cn_proc);
-
-       nfsstats.rpccnt[NFSPROC_LINK]++;
-       nfsm_reqhead(vp, NFSPROC_LINK,
-               NFSX_FH(v3)*2 + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
-       nfsm_fhtom(vp, v3);
-       nfsm_fhtom(tdvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-       nfsm_request(vp, NFSPROC_LINK, cnp->cn_proc, cnp->cn_cred, &xid);
-       if (v3) {
-               u_int64_t txid = xid;
-
-               nfsm_postop_attr(vp, attrflag, &xid);
-               nfsm_wcc_data(tdvp, wccflag, &txid);
-       }
-       nfsm_reqdone;
-
-       VTONFS(tdvp)->n_flag |= NMODIFIED;
-       if (!attrflag)
-               VTONFS(vp)->n_attrstamp = 0;
-       if (!wccflag)
-               VTONFS(tdvp)->n_attrstamp = 0;
-       if (didhold)
-               ubc_rele(vp);
-       vput(tdvp);
-       NFS_FREE_PNBUF(cnp);
+       nfs_flush(np, MNT_WAIT, vfs_context_thread(ctx), V_IGNORE_WRITEERR);
+
+       error = nfs_node_set_busy2(tdnp, np, vfs_context_thread(ctx));
+       if (error)
+               return (error);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers)*2 + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, tdnp->n_fhp, tdnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request(np, NULL, &nmreq, NFSPROC_LINK, ctx,
+                       &nmrep, &xid, &status);
+
+       if ((lockerror = nfs_node_lock2(tdnp, np))) {
+               error = lockerror;
+               goto nfsmout;
+       }
+       if (nfsvers == NFS_VER3) {
+               txid = xid;
+               nfsm_chain_postop_attr_update_flag(error, &nmrep, np, attrflag, &xid);
+               nfsm_chain_get_wcc_data(error, &nmrep, tdnp, &premtime, &wccpostattr, &txid);
+       }
+       if (!error)
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       if (!lockerror) {
+               if (!attrflag)
+                       NATTRINVALIDATE(np);
+               tdnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&tdnp->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, tdnp, &tdnp->n_vattr);
+               if (!wccpostattr)
+                       NATTRINVALIDATE(tdnp);
+               if (!error && (tdnp->n_flag & NNEGNCENTRIES)) {
+                       tdnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(tdvp);
+               }
+               nfs_node_unlock2(tdnp, np);
+       }
+       nfs_node_clear_busy2(tdnp, np);
        /*
         * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
         */
@@ -2410,1696 +3662,2182 @@ nfs_link(ap)
 }
 
 /*
- * nfs symbolic link create call
+ * NFS symbolic link create call
  */
-static int
-nfs_symlink(ap)
-       struct vop_symlink_args /* {
-               struct vnode *a_dvp;
-               struct vnode **a_vpp;
+int
+nfs3_vnop_symlink(
+       struct vnop_symlink_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_dvp;
+               vnode_t *a_vpp;
                struct componentname *a_cnp;
-               struct vattr *a_vap;
+               struct vnode_attr *a_vap;
                char *a_target;
-       } */ *ap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *dvp = ap->a_dvp;
-       register struct vattr *vap = ap->a_vap;
-       register struct componentname *cnp = ap->a_cnp;
-       register struct nfsv2_sattr *sp;
-       register struct nfsv3_sattr *sp3;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       struct vnode *newvp = (struct vnode *)0;
-       int v3 = NFS_ISV3(dvp);
-       u_int64_t xid;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t dvp = ap->a_dvp;
+       struct vnode_attr *vap = ap->a_vap;
+       struct componentname *cnp = ap->a_cnp;
+       struct nfs_vattr nvattr, dnvattr;
+       fhandle_t fh;
+       int slen, error = 0, lockerror = ENOENT, busyerror = ENOENT, status, wccpostattr = 0;
+       struct timespec premtime = { 0, 0 };
+       vnode_t newvp = NULL;
+       int nfsvers, gotuid, gotgid;
+       u_int64_t xid, dxid;
+       nfsnode_t np = NULL;
+       nfsnode_t dnp = VTONFS(dvp);
+       struct nfsmount *nmp;
+       struct nfsm_chain nmreq, nmrep;
+       struct nfsreq *req = NULL;
+       struct nfs_dulookup dul;
+
+       nmp = VTONMP(dvp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
 
-       nfsstats.rpccnt[NFSPROC_SYMLINK]++;
        slen = strlen(ap->a_target);
-       nfsm_reqhead(dvp, NFSPROC_SYMLINK, NFSX_FH(v3) + 2*NFSX_UNSIGNED +
-           nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-       if (v3) {
-               nfsm_build(sp3, struct nfsv3_sattr *, NFSX_V3SRVSATTR);
-               nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid,
-                       cnp->cn_cred->cr_gid);
-       }
-       nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
-       if (!v3) {
-               nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
-               sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
-               sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
-               sp->sa_gid = txdr_unsigned(cnp->cn_cred->cr_gid);
-               sp->sa_size = -1;
-               txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-               txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-       }
-       nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_proc, cnp->cn_cred, &xid);
-       if (v3) {
-               u_int64_t dxid = xid;
+       if ((nfsvers == NFS_VER2) &&
+           ((cnp->cn_namelen > NFS_MAXNAMLEN) || (slen > NFS_MAXPATHLEN)))
+               return (ENAMETOOLONG);
+
+       VATTR_SET_SUPPORTED(vap, va_mode);
+       VATTR_SET_SUPPORTED(vap, va_uid);
+       VATTR_SET_SUPPORTED(vap, va_gid);
+       VATTR_SET_SUPPORTED(vap, va_data_size);
+       VATTR_SET_SUPPORTED(vap, va_access_time);
+       VATTR_SET_SUPPORTED(vap, va_modify_time);
+       gotuid = VATTR_IS_ACTIVE(vap, va_uid);
+       gotgid = VATTR_IS_ACTIVE(vap, va_gid);
+
+       error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
+       nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + 2 * NFSX_UNSIGNED +
+               nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(nfsvers));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen);
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_add_v3sattr(error, &nmreq, vap);
+       nfsm_chain_add_string(error, &nmreq, ap->a_target, slen);
+       if (nfsvers == NFS_VER2)
+               nfsm_chain_add_v2sattr(error, &nmreq, vap, -1);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+
+       error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_SYMLINK,
+                       vfs_context_thread(ctx), vfs_context_ucred(ctx), NULL, &req);
+       if (!error) {
+               nfs_dulookup_start(&dul, dnp, ctx);
+               error = nfs_request_async_finish(req, &nmrep, &xid, &status);
+       }
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
+       dxid = xid;
+       if (!error && !status) {
+               if (dnp->n_flag & NNEGNCENTRIES) {
+                       dnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(dvp);
+               }
+               if (nfsvers == NFS_VER3)
+                       error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
+               else
+                       fh.fh_len = 0;
+       }
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
+       if (!error)
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+
+       if (!lockerror) {
+               dnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
+               nfs_node_unlock(dnp);
+               /* nfs_getattr() will check changed and purge caches */
+               nfs_getattr(dnp, &dnvattr, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
+       }
+
+       if (!error && fh.fh_len)
+               error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
+       if (!error && np)
+               newvp = NFSTOV(np);
+
+       nfs_dulookup_finish(&dul, dnp, ctx);
 
-               if (!error)
-                       nfsm_mtofh(dvp, newvp, v3, gotvp, &xid);
-               nfsm_wcc_data(dvp, wccflag, &dxid);
-       }
-       nfsm_reqdone;
-       if (newvp)
-               vput(newvp);
-
-       VTONFS(dvp)->n_flag |= NMODIFIED;
-       if (!wccflag)
-               VTONFS(dvp)->n_attrstamp = 0;
-       vput(dvp);
-       NFS_FREE_PNBUF(cnp);
        /*
-        * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
+        * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
+        * if we can succeed in looking up the symlink.
         */
-       if (error == EEXIST)
-               error = 0;
+       if ((error == EEXIST) || (!error && !newvp)) {
+               if (newvp) {
+                       nfs_node_unlock(np);
+                       vnode_put(newvp);
+                       newvp = NULL;
+               }
+               error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
+               if (!error) {
+                       newvp = NFSTOV(np);
+                       if (vnode_vtype(newvp) != VLNK)
+                               error = EEXIST;
+               }
+       }
+       if (!busyerror)
+               nfs_node_clear_busy(dnp);
+       if (!error && (gotuid || gotgid) &&
+           (!newvp || nfs_getattrcache(np, &nvattr) ||
+            (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
+            (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
+               /* clear ID bits if server didn't use them (or we can't tell) */
+               VATTR_CLEAR_SUPPORTED(vap, va_uid);
+               VATTR_CLEAR_SUPPORTED(vap, va_gid);
+       }
+       if (error) {
+               if (newvp) {
+                       nfs_node_unlock(np);
+                       vnode_put(newvp);
+               }
+       } else {
+               nfs_node_unlock(np);
+               *ap->a_vpp = newvp;
+       }
        return (error);
 }
 
 /*
- * nfs make dir call
+ * NFS make dir call
  */
-static int
-nfs_mkdir(ap)
-       struct vop_mkdir_args /* {
-               struct vnode *a_dvp;
-               struct vnode **a_vpp;
+int
+nfs3_vnop_mkdir(
+       struct vnop_mkdir_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_dvp;
+               vnode_t *a_vpp;
                struct componentname *a_cnp;
-               struct vattr *a_vap;
-       } */ *ap;
+               struct vnode_attr *a_vap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *dvp = ap->a_dvp;
-       register struct vattr *vap = ap->a_vap;
-       register struct componentname *cnp = ap->a_cnp;
-       register struct nfsv2_sattr *sp;
-       register struct nfsv3_sattr *sp3;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       register int len;
-       struct nfsnode *np = (struct nfsnode *)0;
-       struct vnode *newvp = (struct vnode *)0;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, wccflag = NFSV3_WCCRATTR;
-       int gotvp = 0;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       struct vattr vattr;
-       int v3 = NFS_ISV3(dvp);
+       vfs_context_t ctx = ap->a_context;
+       vnode_t dvp = ap->a_dvp;
+       struct vnode_attr *vap = ap->a_vap;
+       struct componentname *cnp = ap->a_cnp;
+       struct nfs_vattr nvattr, dnvattr;
+       nfsnode_t np = NULL;
+       struct nfsmount *nmp;
+       nfsnode_t dnp = VTONFS(dvp);
+       vnode_t newvp = NULL;
+       int error = 0, lockerror = ENOENT, busyerror = ENOENT, status, wccpostattr = 0;
+       struct timespec premtime = { 0, 0 };
+       int nfsvers, gotuid, gotgid;
        u_int64_t xid, dxid;
+       fhandle_t fh;
+       struct nfsm_chain nmreq, nmrep;
+       struct nfsreq *req = NULL;
+       struct nfs_dulookup dul;
 
-       if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) {
-               VOP_ABORTOP(dvp, cnp);
-               vput(dvp);
-               return (error);
+       nmp = VTONMP(dvp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       if ((nfsvers == NFS_VER2) && (cnp->cn_namelen > NFS_MAXNAMLEN))
+               return (ENAMETOOLONG);
+
+       VATTR_SET_SUPPORTED(vap, va_mode);
+       VATTR_SET_SUPPORTED(vap, va_uid);
+       VATTR_SET_SUPPORTED(vap, va_gid);
+       VATTR_SET_SUPPORTED(vap, va_data_size);
+       VATTR_SET_SUPPORTED(vap, va_access_time);
+       VATTR_SET_SUPPORTED(vap, va_modify_time);
+       gotuid = VATTR_IS_ACTIVE(vap, va_uid);
+       gotgid = VATTR_IS_ACTIVE(vap, va_gid);
+
+       error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
+       nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + NFSX_UNSIGNED +
+               nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(nfsvers));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen);
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_add_v3sattr(error, &nmreq, vap);
+       else
+               nfsm_chain_add_v2sattr(error, &nmreq, vap, -1);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+
+       error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_MKDIR,
+                       vfs_context_thread(ctx), vfs_context_ucred(ctx), NULL, &req);
+       if (!error) {
+               nfs_dulookup_start(&dul, dnp, ctx);
+               error = nfs_request_async_finish(req, &nmrep, &xid, &status);
        }
-       len = cnp->cn_namelen;
-       nfsstats.rpccnt[NFSPROC_MKDIR]++;
-       nfsm_reqhead(dvp, NFSPROC_MKDIR,
-         NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) + NFSX_SATTR(v3));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
-       if (v3) {
-               nfsm_build(sp3, struct nfsv3_sattr *, NFSX_V3SRVSATTR);
-               nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid, vattr.va_gid);
-       } else {
-               nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
-               sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
-               sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
-               sp->sa_gid = txdr_unsigned(vattr.va_gid);
-               sp->sa_size = -1;
-               txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-               txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-       }
-       nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_proc, cnp->cn_cred, &xid);
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
        dxid = xid;
+       if (!error && !status) {
+               if (dnp->n_flag & NNEGNCENTRIES) {
+                       dnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(dvp);
+               }
+               error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
+       }
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
        if (!error)
-               nfsm_mtofh(dvp, newvp, v3, gotvp, &xid);
-       if (v3)
-               nfsm_wcc_data(dvp, wccflag, &dxid);
-       nfsm_reqdone;
-       VTONFS(dvp)->n_flag |= NMODIFIED;
-       if (!wccflag)
-               VTONFS(dvp)->n_attrstamp = 0;
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+
+       if (!lockerror) {
+               dnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
+               nfs_node_unlock(dnp);
+               /* nfs_getattr() will check changed and purge caches */
+               nfs_getattr(dnp, &dnvattr, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
+       }
+
+       if (!error && fh.fh_len)
+               error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, NG_MAKEENTRY, &np);
+       if (!error && np)
+               newvp = NFSTOV(np);
+
+       nfs_dulookup_finish(&dul, dnp, ctx);
+
        /*
         * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
         * if we can succeed in looking up the directory.
         */
-       if (error == EEXIST || (!error && !gotvp)) {
+       if ((error == EEXIST) || (!error && !newvp)) {
                if (newvp) {
-                       vput(newvp);
-                       newvp = (struct vnode *)0;
+                       nfs_node_unlock(np);
+                       vnode_put(newvp);
+                       newvp = NULL;
                }
-               error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
-                                    cnp->cn_proc, &np);
+               error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
                if (!error) {
                        newvp = NFSTOV(np);
-                       if (newvp->v_type != VDIR)
+                       if (vnode_vtype(newvp) != VDIR)
                                error = EEXIST;
                }
        }
+       if (!busyerror)
+               nfs_node_clear_busy(dnp);
+       if (!error && (gotuid || gotgid) &&
+           (!newvp || nfs_getattrcache(np, &nvattr) ||
+            (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
+            (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
+               /* clear ID bits if server didn't use them (or we can't tell) */
+               VATTR_CLEAR_SUPPORTED(vap, va_uid);
+               VATTR_CLEAR_SUPPORTED(vap, va_gid);
+       }
        if (error) {
-               if (newvp)
-                       vput(newvp);
-       } else
+               if (newvp) {
+                       nfs_node_unlock(np);
+                       vnode_put(newvp);
+               }
+       } else {
+               nfs_node_unlock(np);
                *ap->a_vpp = newvp;
-       vput(dvp);
-       NFS_FREE_PNBUF(cnp);
+       }
        return (error);
 }
 
 /*
- * nfs remove directory call
+ * NFS remove directory call
  */
-static int
-nfs_rmdir(ap)
-       struct vop_rmdir_args /* {
-               struct vnode *a_dvp;
-               struct vnode *a_vp;
+int
+nfs3_vnop_rmdir(
+       struct vnop_rmdir_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_dvp;
+               vnode_t a_vp;
                struct componentname *a_cnp;
-       } */ *ap;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct vnode *dvp = ap->a_dvp;
-       register struct componentname *cnp = ap->a_cnp;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       caddr_t bpos, dpos, cp2;
-       int error = 0, wccflag = NFSV3_WCCRATTR;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       int v3 = NFS_ISV3(dvp);
+       vfs_context_t ctx = ap->a_context;
+       vnode_t vp = ap->a_vp;
+       vnode_t dvp = ap->a_dvp;
+       struct componentname *cnp = ap->a_cnp;
+       int error = 0, lockerror = ENOENT, status, wccpostattr = 0;
+       struct timespec premtime = { 0, 0 };
+       struct nfsmount *nmp;
+       nfsnode_t np = VTONFS(vp);
+       nfsnode_t dnp = VTONFS(dvp);
+       struct nfs_vattr dnvattr;
+       int nfsvers;
        u_int64_t xid;
+       struct nfsm_chain nmreq, nmrep;
+       struct nfsreq *req = NULL;
+       struct nfs_dulookup dul;
+
+       nmp = VTONMP(vp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       if ((nfsvers == NFS_VER2) && (cnp->cn_namelen > NFS_MAXNAMLEN))
+               return (ENAMETOOLONG);
+
+       if ((error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx))))
+               return (error);
+
+       nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, cnp->cn_nameptr, cnp->cn_namelen);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+
+       error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_RMDIR,
+                       vfs_context_thread(ctx), vfs_context_ucred(ctx), NULL, &req);
+       if (!error) {
+               nfs_dulookup_start(&dul, dnp, ctx);
+               error = nfs_request_async_finish(req, &nmrep, &xid, &status);
+       }
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
+       if (nfsvers == NFS_VER3)
+               nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &xid);
+       if (!error)
+               error = status;
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+
+       if (!lockerror) {
+               dnp->n_flag |= NMODIFIED;
+               /* if directory hadn't changed, update namecache mtime */
+               if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
+                       NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
+               nfs_node_unlock(dnp);
+               nfs_name_cache_purge(dnp, np, cnp, ctx);
+               /* nfs_getattr() will check changed and purge caches */
+               nfs_getattr(dnp, &dnvattr, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
+       }
+       nfs_dulookup_finish(&dul, dnp, ctx);
+       nfs_node_clear_busy2(dnp, np);
 
-       nfsstats.rpccnt[NFSPROC_RMDIR]++;
-       nfsm_reqhead(dvp, NFSPROC_RMDIR,
-               NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-       nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_proc, cnp->cn_cred, &xid);
-       if (v3)
-               nfsm_wcc_data(dvp, wccflag, &xid);
-       nfsm_reqdone;
-       VTONFS(dvp)->n_flag |= NMODIFIED;
-       if (!wccflag)
-               VTONFS(dvp)->n_attrstamp = 0;
-       cache_purge(dvp);
-       cache_purge(vp);
-       vput(vp);
-       vput(dvp);
-       NFS_FREE_PNBUF(cnp);
        /*
         * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
         */
        if (error == ENOENT)
                error = 0;
+       if (!error) {
+               /*
+                * remove nfsnode from hash now so we can't accidentally find it
+                * again if another object gets created with the same filehandle
+                * before this vnode gets reclaimed
+                */
+               lck_mtx_lock(nfs_node_hash_mutex);
+               if (np->n_hflag & NHHASHED) {
+                       LIST_REMOVE(np, n_hash);
+                       np->n_hflag &= ~NHHASHED;
+                       FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
+               }
+               lck_mtx_unlock(nfs_node_hash_mutex);
+       }
        return (error);
 }
 
 /*
- * nfs readdir call
+ * NFS readdir call
+ *
+ * The incoming "offset" is a directory cookie indicating where in the
+ * directory entries should be read from.  A zero cookie means start at
+ * the beginning of the directory.  Any other cookie will be a cookie
+ * returned from the server.  
+ *
+ * Using that cookie, determine which buffer (and where in that buffer)
+ * to start returning entries from.  Buffer logical block numbers are
+ * the cookies they start at.  If a buffer is found that is not full,
+ * call into the bio/RPC code to fill it.  The RPC code will probably
+ * fill several buffers (dropping the first, requiring a re-get).
+ *
+ * When done copying entries to the buffer, set the offset to the current
+ * entry's cookie and enter that cookie in the cookie cache.
+ *
+ * Note: because the getdirentries(2) API returns a long-typed offset,
+ * the incoming offset is a potentially truncated cookie (ptc).
+ * The cookie matching code is aware of this and will fall back to
+ * matching only 32 bits of the cookie.
  */
-static int
-nfs_readdir(ap)
-       struct vop_readdir_args /* {
-               struct vnode *a_vp;
+int
+nfs_vnop_readdir(
+       struct vnop_readdir_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               struct ucred *a_cred;
-       } */ *ap;
+               int a_flags;
+               int *a_eofflag;
+               int *a_numdirent;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
-       register struct uio *uio = ap->a_uio;
-       int tresid, error;
-       struct vattr vattr;
+       vfs_context_t ctx = ap->a_context;
+       vnode_t dvp = ap->a_vp;
+       nfsnode_t dnp = VTONFS(dvp);
+       struct nfsmount *nmp;
+       uio_t uio = ap->a_uio;
+       int error, nfsvers, extended, numdirent, bigcookies, ptc, done;
+       struct nfs_vattr nvattr;
+       uint16_t i, iptc, rlen, nlen;
+       uint64_t cookie, nextcookie, lbn = 0;
+       struct nfsbuf *bp = NULL;
+       struct nfs_dir_buf_header *ndbhp;
+       struct direntry *dp, *dpptc;
+       struct dirent dent;
+       char *cp = NULL;
+       thread_t thd;
+
+       nmp = VTONMP(dvp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       bigcookies = (nmp->nm_state & NFSSTA_BIGCOOKIES);
+       extended = (ap->a_flags & VNODE_READDIR_EXTENDED);
 
-       if (vp->v_type != VDIR)
+       if (vnode_vtype(dvp) != VDIR)
                return (EPERM);
+
+       if (ap->a_eofflag)
+               *ap->a_eofflag = 0;
+
+       if (uio_resid(uio) == 0)
+               return (0);
+
+       thd = vfs_context_thread(ctx);
+       numdirent = done = 0;
+       nextcookie = uio_offset(uio);
+       ptc = bigcookies && NFS_DIR_COOKIE_POTENTIALLY_TRUNCATED(nextcookie);
+
+       if ((error = nfs_node_lock(dnp)))
+               goto out;
+
+       if (dnp->n_flag & NNEEDINVALIDATE) {
+               dnp->n_flag &= ~NNEEDINVALIDATE;
+               nfs_invaldir(dnp);
+               nfs_node_unlock(dnp);
+               error = nfs_vinvalbuf(dvp, 0, ctx, 1);
+               if (!error)
+                       error = nfs_node_lock(dnp);
+               if (error)
+                       goto out;
+       }
+
        /*
-        * First, check for hit on the EOF offset cache
+        * check for need to invalidate when (re)starting at beginning
         */
-       if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
-           (np->n_flag & NMODIFIED) == 0) {
-               if (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) {
-                       if (NQNFS_CKCACHABLE(vp, ND_READ)) {
-                               nfsstats.direofcache_hits++;
-                               return (0);
+       if (!nextcookie) {
+               if (dnp->n_flag & NMODIFIED) {
+                       nfs_invaldir(dnp);
+                       nfs_node_unlock(dnp);
+                       if ((error = nfs_vinvalbuf(dvp, 0, ctx, 1)))
+                               goto out;
+               } else {
+                       nfs_node_unlock(dnp);
+               }
+               /* nfs_getattr() will check changed and purge caches */
+               if ((error = nfs_getattr(dnp, &nvattr, ctx, NGA_UNCACHED)))
+                       goto out;
+       } else {
+               nfs_node_unlock(dnp);
+       }
+
+       error = nfs_dir_cookie_to_lbn(dnp, nextcookie, &ptc, &lbn);
+       if (error) {
+               if (error < 0) { /* just hit EOF cookie */
+                       done = 1;
+                       error = 0;
+               }
+               if (ap->a_eofflag)
+                       *ap->a_eofflag = 1;
+       }
+
+       while (!error && !done) {
+               OSAddAtomic(1, &nfsstats.biocache_readdirs);
+               cookie = nextcookie;
+getbuffer:
+               error = nfs_buf_get(dnp, lbn, NFS_DIRBLKSIZ, thd, NBLK_READ, &bp);
+               if (error)
+                       goto out;
+               ndbhp = (struct nfs_dir_buf_header*)bp->nb_data;
+               if (!ISSET(bp->nb_flags, NB_CACHE) || !ISSET(ndbhp->ndbh_flags, NDB_FULL)) {
+                       if (!ISSET(bp->nb_flags, NB_CACHE)) { /* initialize the buffer */
+                               ndbhp->ndbh_flags = 0;
+                               ndbhp->ndbh_count = 0;
+                               ndbhp->ndbh_entry_end = sizeof(*ndbhp);
+                               ndbhp->ndbh_ncgen = dnp->n_ncgen;
                        }
-               } else if (!VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_procp)) {
-                       if (np->n_mtime == vattr.va_mtime.tv_sec) {
-                               nfsstats.direofcache_hits++;
-                               return (0);
+                       error = nfs_buf_readdir(bp, ctx);
+                       if (error == NFSERR_DIRBUFDROPPED)
+                               goto getbuffer;
+                       if (error)
+                               nfs_buf_release(bp, 1);
+                       if (error && (error != ENXIO) && (error != ETIMEDOUT) && (error != EINTR) && (error != ERESTART)) {
+                               if (!nfs_node_lock(dnp)) {
+                                       nfs_invaldir(dnp);
+                                       nfs_node_unlock(dnp);
+                               }
+                               nfs_vinvalbuf(dvp, 0, ctx, 1);
+                               if (error == NFSERR_BAD_COOKIE)
+                                       error = ENOENT;
+                       }
+                       if (error)
+                               goto out;
+               }
+
+               /* find next entry to return */
+               dp = NFS_DIR_BUF_FIRST_DIRENTRY(bp);
+               i = 0;
+               if ((lbn != cookie) && !(ptc && NFS_DIR_COOKIE_SAME32(lbn, cookie))) {
+                       dpptc = NULL;
+                       iptc = 0;
+                       for (; (i < ndbhp->ndbh_count) && (cookie != dp->d_seekoff); i++) {
+                               if (ptc && !dpptc && NFS_DIR_COOKIE_SAME32(cookie, dp->d_seekoff)) {
+                                       iptc = i;
+                                       dpptc = dp;
+                               }
+                               nextcookie = dp->d_seekoff;
+                               dp = NFS_DIRENTRY_NEXT(dp);
+                       }
+                       if ((i == ndbhp->ndbh_count) && dpptc) {
+                               i = iptc;
+                               dp = dpptc;
+                       }
+                       if (i < ndbhp->ndbh_count) {
+                               nextcookie = dp->d_seekoff;
+                               dp = NFS_DIRENTRY_NEXT(dp);
+                               i++;
+                       }
+               }
+               ptc = 0;  /* only have to deal with ptc on first cookie */
+
+               /* return as many entries as we can */
+               for (; i < ndbhp->ndbh_count; i++) {
+                       if (extended) {
+                               rlen = dp->d_reclen;
+                               cp = (char*)dp;
+                       } else {
+                               if (!cp) {
+                                       cp = (char*)&dent;
+                                       bzero(cp, sizeof(dent));
+                               }
+                               if (dp->d_namlen > (sizeof(dent.d_name) - 1))
+                                       nlen = sizeof(dent.d_name) - 1;
+                               else
+                                       nlen = dp->d_namlen;
+                               rlen = NFS_DIRENT_LEN(nlen);
+                               dent.d_reclen = rlen;
+                               dent.d_ino = dp->d_ino;
+                               dent.d_type = dp->d_type;
+                               dent.d_namlen = nlen;
+                               strlcpy(dent.d_name, dp->d_name, nlen + 1);
+                       }
+                       /* check that the record fits */
+                       if (rlen > uio_resid(uio)) {
+                               done = 1;
+                               break;
+                       }
+                       if ((error = uiomove(cp, rlen, uio)))
+                               break;
+                       numdirent++;
+                       nextcookie = dp->d_seekoff;
+                       dp = NFS_DIRENTRY_NEXT(dp);
+               }
+
+               if (i == ndbhp->ndbh_count) {
+                       /* hit end of buffer, move to next buffer */
+                       lbn = nextcookie;
+                       /* if we also hit EOF, we're done */
+                       if (ISSET(ndbhp->ndbh_flags, NDB_EOF)) {
+                               done = 1;
+                               if (ap->a_eofflag)
+                                       *ap->a_eofflag = 1;
                        }
-                       /* directory changed, purge any name cache entries */
-                       cache_purge(vp);
                }
+               if (!error)
+                       uio_setoffset(uio, nextcookie);
+               if (!error && !done && (nextcookie == cookie)) {
+                       printf("nfs readdir cookie didn't change 0x%llx, %d/%d\n", cookie, i, ndbhp->ndbh_count);
+                       error = EIO;
+               }
+               nfs_buf_release(bp, 1);
        }
 
-       /*
-        * Call nfs_bioread() to do the real work.
-        */
-       tresid = uio->uio_resid;
-       error = nfs_bioread(vp, uio, 0, ap->a_cred, 0);
+       if (!error)
+               nfs_dir_cookie_cache(dnp, nextcookie, lbn);
 
-       if (!error && uio->uio_resid == tresid)
-               nfsstats.direofcache_misses++;
+       if (ap->a_numdirent)
+               *ap->a_numdirent = numdirent;
+out:
        return (error);
 }
 
+
 /*
- * Readdir rpc call.
- * Called from below the buffer cache by nfs_doio().
+ * Invalidate cached directory information, except for the actual directory
+ * blocks (which are invalidated separately).
  */
-int
-nfs_readdirrpc(vp, uiop, cred)
-       struct vnode *vp;
-       register struct uio *uiop;
-       struct ucred *cred;
+void
+nfs_invaldir(nfsnode_t dnp)
+{
+       if (vnode_vtype(NFSTOV(dnp)) != VDIR)
+               return;
+       dnp->n_eofcookie = 0;
+       dnp->n_cookieverf = 0;
+       if (!dnp->n_cookiecache)
+               return;
+       dnp->n_cookiecache->free = 0;
+       dnp->n_cookiecache->mru = -1;
+       memset(dnp->n_cookiecache->next, -1, NFSNUMCOOKIES);
+}
+
+/*
+ * calculate how much space is available for additional directory entries.
+ */
+uint32_t
+nfs_dir_buf_freespace(struct nfsbuf *bp, int rdirplus)
+{
+       struct nfs_dir_buf_header *ndbhp = (struct nfs_dir_buf_header*)bp->nb_data;
+       uint32_t space;
+
+       if (!ndbhp)
+               return (0);
+       space = bp->nb_bufsize - ndbhp->ndbh_entry_end;
+       if (rdirplus)
+               space -= ndbhp->ndbh_count * sizeof(struct nfs_vattr);
+       return (space);
+}
 
+/*
+ * add/update a cookie->lbn entry in the directory cookie cache
+ */
+void
+nfs_dir_cookie_cache(nfsnode_t dnp, uint64_t cookie, uint64_t lbn)
 {
-       register int len, left;
-       register struct dirent *dp;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       register nfsuint64 *cookiep;
-       caddr_t bpos, dpos, cp2;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       nfsuint64 cookie;
-       struct nfsmount *nmp;
-       struct nfsnode *dnp = VTONFS(vp);
-       u_quad_t fileno;
-       int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
-       int attrflag;
-       int v3, nmreaddirsize;
-       u_int64_t xid;
+       struct nfsdmap *ndcc;
+       int8_t i, prev;
 
-#ifndef nolint
-       dp = (struct dirent *)0;
-#endif
-#if DIAGNOSTIC
-       if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (NFS_DIRBLKSIZ - 1)) ||
-               (uiop->uio_resid & (NFS_DIRBLKSIZ - 1)))
-               panic("nfs_readdirrpc: bad uio");
-#endif
-       nmp = VFSTONFS(vp->v_mount);
-       if (!nmp)
-               return (ENXIO);
-       v3 = NFS_ISV3(vp);
-       nmreaddirsize = nmp->nm_readdirsize;
+       if (!cookie)
+               return;
+
+       if (nfs_node_lock(dnp))
+               return;
 
-       /*
-        * If there is no cookie, assume directory was stale.
-        */
-       cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
-       if (cookiep)
-               cookie = *cookiep;
-       else
-               return (NFSERR_BAD_COOKIE);
-       /*
-        * Loop around doing readdir rpc's of size nm_readdirsize
-        * truncated to a multiple of DIRBLKSIZ.
-        * The stopping criteria is EOF or buffer full.
-        */
-       while (more_dirs && bigenough) {
-               nfsstats.rpccnt[NFSPROC_READDIR]++;
-               nfsm_reqhead(vp, NFSPROC_READDIR, NFSX_FH(v3) +
-                       NFSX_READDIR(v3));
-               nfsm_fhtom(vp, v3);
-               if (v3) {
-                       nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
-                       *tl++ = cookie.nfsuquad[0];
-                       *tl++ = cookie.nfsuquad[1];
-                       *tl++ = dnp->n_cookieverf.nfsuquad[0];
-                       *tl++ = dnp->n_cookieverf.nfsuquad[1];
-               } else {
-                       nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       *tl++ = cookie.nfsuquad[0];
-               }
-               *tl = txdr_unsigned(nmreaddirsize);
-               nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, cred, &xid);
-               if (v3) {
-                       nfsm_postop_attr(vp, attrflag, &xid);
-                       if (!error) {
-                               nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
-                               dnp->n_cookieverf.nfsuquad[0] = *tl++;
-                               dnp->n_cookieverf.nfsuquad[1] = *tl;
-                       } else {
-                               m_freem(mrep);
-                               goto nfsmout;
-                       }
-               }
-               nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-               more_dirs = fxdr_unsigned(int, *tl);
-       
-               /* loop thru the dir entries, doctoring them to 4bsd form */
-               while (more_dirs && bigenough) {
-                       if (v3) {
-                               nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
-                               fxdr_hyper(tl, &fileno);
-                               len = fxdr_unsigned(int, *(tl + 2));
-                       } else {
-                               nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
-                               fileno = fxdr_unsigned(u_quad_t, *tl++);
-                               len = fxdr_unsigned(int, *tl);
-                       }
-                       if (len <= 0 || len > NFS_MAXNAMLEN) {
-                               error = EBADRPC;
-                               m_freem(mrep);
-                               goto nfsmout;
-                       }
-                       tlen = nfsm_rndup(len);
-                       if (tlen == len)
-                               tlen += 4;      /* To ensure null termination */
-                       left = DIRBLKSIZ - blksiz;
-                       if ((tlen + DIRHDSIZ) > left) {
-                               dp->d_reclen += left;
-                               uiop->uio_iov->iov_base += left;
-                               uiop->uio_iov->iov_len -= left;
-                               uiop->uio_offset += left;
-                               uiop->uio_resid -= left;
-                               blksiz = 0;
-                       }
-                       if ((tlen + DIRHDSIZ) > uiop->uio_resid)
-                               bigenough = 0;
-                       if (bigenough) {
-                               dp = (struct dirent *)uiop->uio_iov->iov_base;
-                               dp->d_fileno = (int)fileno;
-                               dp->d_namlen = len;
-                               dp->d_reclen = tlen + DIRHDSIZ;
-                               dp->d_type = DT_UNKNOWN;
-                               blksiz += dp->d_reclen;
-                               if (blksiz == DIRBLKSIZ)
-                                       blksiz = 0;
-                               uiop->uio_offset += DIRHDSIZ;
-                               uiop->uio_resid -= DIRHDSIZ;
-                               uiop->uio_iov->iov_base += DIRHDSIZ;
-                               uiop->uio_iov->iov_len -= DIRHDSIZ;
-                               nfsm_mtouio(uiop, len);
-                               cp = uiop->uio_iov->iov_base;
-                               tlen -= len;
-                               *cp = '\0';     /* null terminate */
-                               uiop->uio_iov->iov_base += tlen;
-                               uiop->uio_iov->iov_len -= tlen;
-                               uiop->uio_offset += tlen;
-                               uiop->uio_resid -= tlen;
-                       } else
-                               nfsm_adv(nfsm_rndup(len));
-                       if (v3) {
-                               nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
-                       } else {
-                               nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
-                       }
-                       if (bigenough) {
-                               cookie.nfsuquad[0] = *tl++;
-                               if (v3)
-                                       cookie.nfsuquad[1] = *tl++;
-                       } else if (v3)
-                               tl += 2;
-                       else
-                               tl++;
-                       more_dirs = fxdr_unsigned(int, *tl);
-               }
-               /*
-                * If at end of rpc data, get the eof boolean
-                */
-               if (!more_dirs) {
-                       nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-                       more_dirs = (fxdr_unsigned(int, *tl) == 0);
-               }
-               m_freem(mrep);
+       if (cookie == dnp->n_eofcookie) { /* EOF cookie */
+               nfs_node_unlock(dnp);
+               return;
        }
-       /*
-        * Fill last record, iff any, out to a multiple of DIRBLKSIZ
-        * by increasing d_reclen for the last record.
-        */
-       if (blksiz > 0) {
-               left = DIRBLKSIZ - blksiz;
-               dp->d_reclen += left;
-               uiop->uio_iov->iov_base += left;
-               uiop->uio_iov->iov_len -= left;
-               uiop->uio_offset += left;
-               uiop->uio_resid -= left;
+
+       ndcc = dnp->n_cookiecache;
+       if (!ndcc) {
+               /* allocate the cookie cache structure */
+               MALLOC_ZONE(dnp->n_cookiecache, struct nfsdmap *,
+                       sizeof(struct nfsdmap), M_NFSDIROFF, M_WAITOK); 
+               if (!dnp->n_cookiecache) {
+                       nfs_node_unlock(dnp);
+                       return;
+               }
+               ndcc = dnp->n_cookiecache;
+               ndcc->free = 0;
+               ndcc->mru = -1;
+               memset(ndcc->next, -1, NFSNUMCOOKIES);
        }
 
        /*
-        * We are now either at the end of the directory or have filled the
-        * block.
+        * Search the list for this cookie.
+        * Keep track of previous and last entries.
         */
-       if (bigenough)
-               dnp->n_direofoffset = uiop->uio_offset;
-       else {
-               if (uiop->uio_resid > 0)
-                       printf("EEK! readdirrpc resid > 0\n");
-               cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
-               *cookiep = cookie;
+       prev = -1;
+       i = ndcc->mru;
+       while ((i != -1) && (cookie != ndcc->cookies[i].key)) {
+               if (ndcc->next[i] == -1) /* stop on last entry so we can reuse */
+                       break;
+               prev = i;
+               i = ndcc->next[i];
        }
-nfsmout:
-       return (error);
+       if ((i != -1) && (cookie == ndcc->cookies[i].key)) {
+               /* found it, remove from list */
+               if (prev != -1)
+                       ndcc->next[prev] = ndcc->next[i];
+               else
+                       ndcc->mru = ndcc->next[i];
+       } else {
+               /* not found, use next free entry or reuse last entry */
+               if (ndcc->free != NFSNUMCOOKIES)
+                       i = ndcc->free++;
+               else
+                       ndcc->next[prev] = -1;
+               ndcc->cookies[i].key = cookie;
+               ndcc->cookies[i].lbn = lbn;
+       }
+       /* insert cookie at head of MRU list */
+       ndcc->next[i] = ndcc->mru;
+       ndcc->mru = i;
+       nfs_node_unlock(dnp);
 }
 
 /*
- * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
+ * Try to map the given directory cookie to a directory buffer (return lbn).
+ * If we have a possibly truncated cookie (ptc), check for 32-bit matches too.
  */
 int
-nfs_readdirplusrpc(vp, uiop, cred)
-       struct vnode *vp;
-       register struct uio *uiop;
-       struct ucred *cred;
+nfs_dir_cookie_to_lbn(nfsnode_t dnp, uint64_t cookie, int *ptc, uint64_t *lbnp)
 {
-       register int len, left;
-       register struct dirent *dp;
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       register struct vnode *newvp;
-       register nfsuint64 *cookiep;
-       caddr_t bpos, dpos, cp2, dpossav1, dpossav2;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2, *mdsav1, *mdsav2;
-       struct nameidata nami, *ndp = &nami;
-       struct componentname *cnp = &ndp->ni_cnd;
-       nfsuint64 cookie;
+       struct nfsdmap *ndcc = dnp->n_cookiecache;
+       int8_t i, eofptc, iptc, found;
        struct nfsmount *nmp;
-       struct nfsnode *dnp = VTONFS(vp), *np;
-       nfsfh_t *fhp;
-       u_quad_t fileno;
-       int error = 0, tlen, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
-       int attrflag, fhsize, nmreaddirsize, nmrsize;
-       u_int64_t xid, savexid;
-
-#ifndef nolint
-       dp = (struct dirent *)0;
-#endif
-#if DIAGNOSTIC
-       if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (DIRBLKSIZ - 1)) ||
-               (uiop->uio_resid & (DIRBLKSIZ - 1)))
-               panic("nfs_readdirplusrpc: bad uio");
-#endif
-       nmp = VFSTONFS(vp->v_mount);
-       if (!nmp)
-               return (ENXIO);
-       nmreaddirsize = nmp->nm_readdirsize;
-       nmrsize = nmp->nm_rsize;
+       struct nfsbuf *bp, *lastbp;
+       struct nfsbuflists blist;
+       struct direntry *dp, *dpptc;
+       struct nfs_dir_buf_header *ndbhp;
+
+       if (!cookie) {  /* initial cookie */
+               *lbnp = 0;
+               *ptc = 0;
+               return (0);
+       }
 
-       ndp->ni_dvp = vp;
-       newvp = NULLVP;
+       if (nfs_node_lock(dnp))
+               return (ENOENT);
+
+       if (cookie == dnp->n_eofcookie) { /* EOF cookie */
+               nfs_node_unlock(dnp);
+               OSAddAtomic(1, &nfsstats.direofcache_hits);
+               *ptc = 0;
+               return (-1);
+       }
+       /* note if cookie is a 32-bit match with the EOF cookie */
+       eofptc = *ptc ? NFS_DIR_COOKIE_SAME32(cookie, dnp->n_eofcookie) : 0;
+       iptc = -1;
+
+       /* search the list for the cookie */
+       for (i = ndcc ? ndcc->mru : -1; i >= 0; i = ndcc->next[i]) {
+               if (ndcc->cookies[i].key == cookie) {
+                       /* found a match for this cookie */
+                       *lbnp = ndcc->cookies[i].lbn;
+                       nfs_node_unlock(dnp);
+                       OSAddAtomic(1, &nfsstats.direofcache_hits);
+                       *ptc = 0;
+                       return (0);
+               }
+               /* check for 32-bit match */
+               if (*ptc && (iptc == -1) && NFS_DIR_COOKIE_SAME32(ndcc->cookies[i].key, cookie))
+                       iptc = i;
+       }
+       /* exact match not found */
+       if (eofptc) {
+               /* but 32-bit match hit the EOF cookie */
+               nfs_node_unlock(dnp);
+               OSAddAtomic(1, &nfsstats.direofcache_hits);
+               return (-1);
+       }
+       if (iptc >= 0) {
+               /* but 32-bit match got a hit */
+               *lbnp = ndcc->cookies[iptc].lbn;
+               nfs_node_unlock(dnp);
+               OSAddAtomic(1, &nfsstats.direofcache_hits);
+               return (0);
+       }
+       nfs_node_unlock(dnp);
 
        /*
-        * If there is no cookie, assume directory was stale.
+        * No match found in the cookie cache... hmm...
+        * Let's search the directory's buffers for the cookie.
         */
-       cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
-       if (cookiep)
-               cookie = *cookiep;
-       else
-               return (NFSERR_BAD_COOKIE);
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
+               return (ENXIO);
+       dpptc = NULL;
+       found = 0;
+
+       lck_mtx_lock(nfs_buf_mutex);
        /*
-        * Loop around doing readdir rpc's of size nm_readdirsize
-        * truncated to a multiple of DIRBLKSIZ.
-        * The stopping criteria is EOF or buffer full.
+        * Scan the list of buffers, keeping them in order.
+        * Note that itercomplete inserts each of the remaining buffers
+        * into the head of list (thus reversing the elements).  So, we
+        * make sure to iterate through all buffers, inserting them after
+        * each other, to keep them in order.
+        * Also note: the LIST_INSERT_AFTER(lastbp) is only safe because
+        * we don't drop nfs_buf_mutex.
         */
-       while (more_dirs && bigenough) {
-               nfsstats.rpccnt[NFSPROC_READDIRPLUS]++;
-               nfsm_reqhead(vp, NFSPROC_READDIRPLUS,
-                       NFSX_FH(1) + 6 * NFSX_UNSIGNED);
-               nfsm_fhtom(vp, 1);
-               nfsm_build(tl, u_long *, 6 * NFSX_UNSIGNED);
-               *tl++ = cookie.nfsuquad[0];
-               *tl++ = cookie.nfsuquad[1];
-               *tl++ = dnp->n_cookieverf.nfsuquad[0];
-               *tl++ = dnp->n_cookieverf.nfsuquad[1];
-               *tl++ = txdr_unsigned(nmreaddirsize);
-               *tl = txdr_unsigned(nmrsize);
-               nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_procp, cred,
-                            &xid);
-               savexid = xid;
-               nfsm_postop_attr(vp, attrflag, &xid);
-               if (error) {
-                       m_freem(mrep);
-                       goto nfsmout;
-               }
-               nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
-               dnp->n_cookieverf.nfsuquad[0] = *tl++;
-               dnp->n_cookieverf.nfsuquad[1] = *tl++;
-               more_dirs = fxdr_unsigned(int, *tl);
-
-               /* loop thru the dir entries, doctoring them to 4bsd form */
-               while (more_dirs && bigenough) {
-                       nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
-                       fxdr_hyper(tl, &fileno);
-                       len = fxdr_unsigned(int, *(tl + 2));
-                       if (len <= 0 || len > NFS_MAXNAMLEN) {
-                               error = EBADRPC;
-                               m_freem(mrep);
-                               goto nfsmout;
-                       }
-                       tlen = nfsm_rndup(len);
-                       if (tlen == len)
-                               tlen += 4;      /* To ensure null termination*/
-                       left = DIRBLKSIZ - blksiz;
-                       if ((tlen + DIRHDSIZ) > left) {
-                               dp->d_reclen += left;
-                               uiop->uio_iov->iov_base += left;
-                               uiop->uio_iov->iov_len -= left;
-                               uiop->uio_offset += left;
-                               uiop->uio_resid -= left;
-                               blksiz = 0;
+       if (!nfs_buf_iterprepare(dnp, &blist, NBI_CLEAN)) {
+               lastbp = NULL;
+               while ((bp = LIST_FIRST(&blist))) {
+                       LIST_REMOVE(bp, nb_vnbufs);
+                       if (!lastbp)
+                               LIST_INSERT_HEAD(&dnp->n_cleanblkhd, bp, nb_vnbufs);
+                       else
+                               LIST_INSERT_AFTER(lastbp, bp, nb_vnbufs);
+                       lastbp = bp;
+                       if (found)
+                               continue;
+                       nfs_buf_refget(bp);
+                       if (nfs_buf_acquire(bp, NBAC_NOWAIT, 0, 0)) {
+                               /* just skip this buffer */
+                               nfs_buf_refrele(bp);
+                               continue;
                        }
-                       if ((tlen + DIRHDSIZ) > uiop->uio_resid)
-                               bigenough = 0;
-                       if (bigenough) {
-                               dp = (struct dirent *)uiop->uio_iov->iov_base;
-                               dp->d_fileno = (int)fileno;
-                               dp->d_namlen = len;
-                               dp->d_reclen = tlen + DIRHDSIZ;
-                               dp->d_type = DT_UNKNOWN;
-                               blksiz += dp->d_reclen;
-                               if (blksiz == DIRBLKSIZ)
-                                       blksiz = 0;
-                               uiop->uio_offset += DIRHDSIZ;
-                               uiop->uio_resid -= DIRHDSIZ;
-                               uiop->uio_iov->iov_base += DIRHDSIZ;
-                               uiop->uio_iov->iov_len -= DIRHDSIZ;
-                               cnp->cn_nameptr = uiop->uio_iov->iov_base;
-                               cnp->cn_namelen = len;
-                               nfsm_mtouio(uiop, len);
-                               cp = uiop->uio_iov->iov_base;
-                               tlen -= len;
-                               *cp = '\0';
-                               uiop->uio_iov->iov_base += tlen;
-                               uiop->uio_iov->iov_len -= tlen;
-                               uiop->uio_offset += tlen;
-                               uiop->uio_resid -= tlen;
-                       } else
-                               nfsm_adv(nfsm_rndup(len));
-                       nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
-                       if (bigenough) {
-                               cookie.nfsuquad[0] = *tl++;
-                               cookie.nfsuquad[1] = *tl++;
-                       } else
-                               tl += 2;
-
-                       /*
-                        * Since the attributes are before the file handle
-                        * (sigh), we must skip over the attributes and then
-                        * come back and get them.
-                        */
-                       attrflag = fxdr_unsigned(int, *tl);
-                       if (attrflag) {
-                           dpossav1 = dpos;
-                           mdsav1 = md;
-                           nfsm_adv(NFSX_V3FATTR);
-                           nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-                           doit = fxdr_unsigned(int, *tl);
-                           if (doit) {
-                               nfsm_getfh(fhp, fhsize, 1);
-                               if (NFS_CMPFH(dnp, fhp, fhsize)) {
-                                   VREF(vp);
-                                   newvp = vp;
-                                   np = dnp;
-                               } else if (!bigenough ||
-                                       (cnp->cn_namelen == 2 &&
-                                        cnp->cn_nameptr[1] == '.' &&
-                                        cnp->cn_nameptr[0] == '.')) {
-                                   /*
-                                    * don't doit if we can't guarantee
-                                    * that this entry is NOT ".." because
-                                    * we would have to drop the lock on
-                                    * the directory before getting the
-                                    * (lock on) the ".." vnode... and we
-                                    * don't want to drop the dvp lock in
-                                    * the middle of a readdirplus.
-                                    */
-                                   doit = 0;
-                               } else {
-                                   if ((error = nfs_nget(vp->v_mount, fhp,
-                                       fhsize, &np)))
-                                       doit = 0;
-                                   else
-                                       newvp = NFSTOV(np);
+                       nfs_buf_refrele(bp);
+
+                       /* scan the buffer for the cookie */
+                       ndbhp = (struct nfs_dir_buf_header*)bp->nb_data;
+                       dp = NFS_DIR_BUF_FIRST_DIRENTRY(bp);
+                       dpptc = NULL;
+                       for (i=0; (i < ndbhp->ndbh_count) && (cookie != dp->d_seekoff); i++) {
+                               if (*ptc && !dpptc && NFS_DIR_COOKIE_SAME32(cookie, dp->d_seekoff)) {
+                                       dpptc = dp;
+                                       iptc = i;
                                }
-                           }
-                           if (doit && bigenough) {
-                               dpossav2 = dpos;
-                               dpos = dpossav1;
-                               mdsav2 = md;
-                               md = mdsav1;
-                               xid = savexid;
-                               nfsm_loadattr(newvp, (struct vattr *)0, &xid);
-                               dpos = dpossav2;
-                               md = mdsav2;
-                               dp->d_type =
-                                   IFTODT(VTTOIF(np->n_vattr.va_type));
-                               ndp->ni_vp = newvp;
-                               cnp->cn_hash = 0;
-                               for (cp = cnp->cn_nameptr, i = 1; i <= len;
-                                   i++, cp++)
-                                   cnp->cn_hash += (unsigned char)*cp * i;
-                               if (cnp->cn_namelen <= NCHNAMLEN)
-                                   cache_enter(ndp->ni_dvp, ndp->ni_vp, cnp);
-                           }
-                       } else {
-                           /* Just skip over the file handle */
-                           nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-                           i = fxdr_unsigned(int, *tl);
-                           nfsm_adv(nfsm_rndup(i));
+                               dp = NFS_DIRENTRY_NEXT(dp);
                        }
-                       if (newvp != NULLVP) {
-                           if (newvp == vp)
-                               vrele(newvp);
-                           else
-                               vput(newvp);
-                           newvp = NULLVP;
+                       if ((i == ndbhp->ndbh_count) && dpptc) {
+                               /* found only a PTC match */
+                               dp = dpptc;
+                               i = iptc;
+                       } else if (i < ndbhp->ndbh_count) {
+                               *ptc = 0;
                        }
-                       nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-                       more_dirs = fxdr_unsigned(int, *tl);
-               }
-               /*
-                * If at end of rpc data, get the eof boolean
-                */
-               if (!more_dirs) {
-                       nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
-                       more_dirs = (fxdr_unsigned(int, *tl) == 0);
+                       if (i < (ndbhp->ndbh_count-1)) {
+                               /* next entry is *in* this buffer: return this block */
+                               *lbnp = bp->nb_lblkno;
+                               found = 1;
+                       } else if (i == (ndbhp->ndbh_count-1)) {
+                               /* next entry refers to *next* buffer: return next block */
+                               *lbnp = dp->d_seekoff;
+                               found = 1;
+                       }
+                       nfs_buf_drop(bp);
                }
-               m_freem(mrep);
+               nfs_buf_itercomplete(dnp, &blist, NBI_CLEAN);
        }
-       /*
-        * Fill last record, iff any, out to a multiple of NFS_DIRBLKSIZ
-        * by increasing d_reclen for the last record.
-        */
-       if (blksiz > 0) {
-               left = DIRBLKSIZ - blksiz;
-               dp->d_reclen += left;
-               uiop->uio_iov->iov_base += left;
-               uiop->uio_iov->iov_len -= left;
-               uiop->uio_offset += left;
-               uiop->uio_resid -= left;
+       lck_mtx_unlock(nfs_buf_mutex);
+       if (found) {
+               OSAddAtomic(1, &nfsstats.direofcache_hits);
+               return (0);
        }
 
-       /*
-        * We are now either at the end of the directory or have filled the
-        * block.
-        */
-       if (bigenough)
-               dnp->n_direofoffset = uiop->uio_offset;
-       else {
-               if (uiop->uio_resid > 0)
-                       printf("EEK! readdirplusrpc resid > 0\n");
-               cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
-               *cookiep = cookie;
-       }
-nfsmout:
-       if (newvp != NULLVP) {
-               if (newvp == vp)
-                       vrele(newvp);
-               else
-                       vput(newvp);
-               newvp = NULLVP;
-       }
-       return (error);
+       /* still not found... oh well, just start a new block */
+       *lbnp = cookie;
+       OSAddAtomic(1, &nfsstats.direofcache_misses);
+       return (0);
 }
 
 /*
- * Silly rename. To make the NFS filesystem that is stateless look a little
- * more like the "ufs" a remove of an active vnode is translated to a rename
- * to a funny looking filename that is removed by nfs_inactive on the
- * nfsnode. There is the potential for another process on a different client
- * to create the same funny name between the nfs_lookitup() fails and the
- * nfs_rename() completes, but...
+ * scan a directory buffer for the given name
+ * Returns: ESRCH if not found, ENOENT if found invalid, 0 if found
+ * Note: should only be called with RDIRPLUS directory buffers
  */
 
-/* format of "random" names and next name to try */
-/* (note: shouldn't exceed size of sillyrename.s_name) */
-static char sillyrename_name[] = ".nfsAAA%04x4.4";
+#define NDBS_PURGE     1
+#define NDBS_UPDATE    2
 
-static int
-nfs_sillyrename(dvp, vp, cnp)
-       struct vnode *dvp, *vp;
-       struct componentname *cnp;
+int
+nfs_dir_buf_search(
+       struct nfsbuf *bp,
+       struct componentname *cnp,
+       fhandle_t *fhp,
+       struct nfs_vattr *nvap,
+       uint64_t *xidp,
+       time_t *attrstampp,
+       daddr64_t *nextlbnp,
+       int flags)
 {
-       register struct sillyrename *sp;
-       struct nfsnode *np;
-       int error;
-       short pid;
-       struct ucred *cred;
-       int i, j, k;
-
-       cache_purge(dvp);
-       np = VTONFS(vp);
-#if DIAGNOSTIC
-       if (vp->v_type == VDIR)
-               panic("nfs_sillyrename: dir");
-#endif
-       MALLOC_ZONE(sp, struct sillyrename *,
-                       sizeof (struct sillyrename), M_NFSREQ, M_WAITOK);
-       sp->s_cred = crdup(cnp->cn_cred);
-       sp->s_dvp = dvp;
-       VREF(dvp);
-
-       /* Fudge together a funny name */
-       pid = cnp->cn_proc->p_pid;
-       sp->s_namlen = sprintf(sp->s_name, sillyrename_name, pid);
-
-       /* Try lookitups until we get one that isn't there */
-       i = j = k = 0;
-       while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
-               cnp->cn_proc, (struct nfsnode **)0) == 0) {
-               if (sp->s_name[4]++ >= 'z')
-                       sp->s_name[4] = 'A';
-               if (++i > ('z' - 'A' + 1)) {
-                       i = 0;
-                       if (sp->s_name[5]++ >= 'z')
-                               sp->s_name[5] = 'A';
-                       if (++j > ('z' - 'A' + 1)) {
-                               j = 0;
-                               if (sp->s_name[6]++ >= 'z')
-                                       sp->s_name[6] = 'A';
-                               if (++k > ('z' - 'A' + 1)) {
-                                       error = EINVAL;
-                                       goto bad;
+       struct direntry *dp;
+       struct nfs_dir_buf_header *ndbhp;
+       struct nfs_vattr *nvattrp;
+       daddr64_t nextlbn = 0;
+       int i, error = ESRCH, fhlen;
+
+       /* scan the buffer for the name */
+       ndbhp = (struct nfs_dir_buf_header*)bp->nb_data;
+       dp = NFS_DIR_BUF_FIRST_DIRENTRY(bp);
+       for (i=0; i < ndbhp->ndbh_count; i++) {
+               nextlbn = dp->d_seekoff;
+               if ((cnp->cn_namelen == dp->d_namlen) && !strcmp(cnp->cn_nameptr, dp->d_name)) {
+                       fhlen = dp->d_name[dp->d_namlen+1];
+                       nvattrp = NFS_DIR_BUF_NVATTR(bp, i);
+                       if ((ndbhp->ndbh_ncgen != bp->nb_np->n_ncgen) || (fhp->fh_len == 0) ||
+                           (nvattrp->nva_type == VNON) || (nvattrp->nva_fileid == 0)) {
+                               /* entry is no longer valid */
+                               error = ENOENT;
+                               break;
+                       }
+                       if (flags == NDBS_PURGE) {
+                               dp->d_fileno = 0;
+                               bzero(nvattrp, sizeof(*nvattrp));
+                               error = ENOENT;
+                               break;
+                       }
+                       if (flags == NDBS_UPDATE) {
+                               /* update direntry's attrs if fh matches */
+                               if ((fhp->fh_len == fhlen) && !bcmp(&dp->d_name[dp->d_namlen+2], fhp->fh_data, fhlen)) {
+                                       bcopy(nvap, nvattrp, sizeof(*nvap));
+                                       dp->d_fileno = nvattrp->nva_fileid;
+                                       nvattrp->nva_fileid = *xidp;
+                                       *(time_t*)(&dp->d_name[dp->d_namlen+2+fhp->fh_len]) = *attrstampp;
                                }
+                               error = 0;
+                               break;
                        }
+                       /* copy out fh, attrs, attrstamp, and xid */
+                       fhp->fh_len = fhlen;
+                       bcopy(&dp->d_name[dp->d_namlen+2], fhp->fh_data, MAX(fhp->fh_len, (int)sizeof(fhp->fh_data)));
+                       *attrstampp = *(time_t*)(&dp->d_name[dp->d_namlen+2+fhp->fh_len]);
+                       bcopy(nvattrp, nvap, sizeof(*nvap));
+                       *xidp = nvap->nva_fileid;
+                       nvap->nva_fileid = dp->d_fileno;
+                       error = 0;
+                       break;
                }
+               dp = NFS_DIRENTRY_NEXT(dp);
        }
-       /* make note of next "random" name to try */
-       if ((sillyrename_name[4] = (sp->s_name[4] + 1)) > 'z') {
-               sillyrename_name[4] = 'A';
-               if ((sillyrename_name[5] = (sp->s_name[5] + 1)) > 'z') {
-                       sillyrename_name[5] = 'A';
-                       if ((sillyrename_name[6] = (sp->s_name[6] + 1)) > 'z')
-                               sillyrename_name[6] = 'A';
-               }
-       }
-       /* now, do the rename */
-       if ((error = nfs_renameit(dvp, cnp, sp)))
-               goto bad;
-       error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
-               cnp->cn_proc, &np);
-#if DIAGNOSTIC
-       kprintf("sillyrename: %s, vp=%x, np=%x, dvp=%x\n",
-               &sp->s_name[0], (unsigned)vp, (unsigned)np, (unsigned)dvp);
-#endif
-       np->n_sillyrename = sp;
-       return (0);
-bad:
-       vrele(sp->s_dvp);
-       cred = sp->s_cred;
-       sp->s_cred = NOCRED;
-       crfree(cred);
-       FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ);
+       if (nextlbnp)
+               *nextlbnp = nextlbn;
        return (error);
 }
 
 /*
- * Look up a file name and optionally either update the file handle or
- * allocate an nfsnode, depending on the value of npp.
- * npp == NULL --> just do the lookup
- * *npp == NULL --> allocate a new nfsnode and make sure attributes are
- *                     handled too
- * *npp != NULL --> update the file handle in the vnode
+ * Look up a name in a directory's buffers.
+ * Note: should only be called with RDIRPLUS directory buffers
  */
-static int
-nfs_lookitup(dvp, name, len, cred, procp, npp)
-       register struct vnode *dvp;
-       char *name;
-       int len;
-       struct ucred *cred;
-       struct proc *procp;
-       struct nfsnode **npp;
+int
+nfs_dir_buf_cache_lookup(nfsnode_t dnp, nfsnode_t *npp, struct componentname *cnp, vfs_context_t ctx, int purge)
 {
-       register u_long *tl;
-       register caddr_t cp;
-       register long t1, t2;
-       struct vnode *newvp = (struct vnode *)0;
-       struct nfsnode *np, *dnp = VTONFS(dvp);
-       caddr_t bpos, dpos, cp2;
-       int error = 0, fhlen, attrflag;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       nfsfh_t *nfhp;
-       int v3;
+       nfsnode_t newnp;
+       struct nfsmount *nmp;
+       int error = 0, slpflag, slptimeo, i, found = 0, count = 0;
        u_int64_t xid;
-
-       if (!VFSTONFS(dvp->v_mount))
+       struct nfs_vattr nvattr;
+       fhandle_t fh;
+       time_t attrstamp = 0;
+       thread_t thd = vfs_context_thread(ctx);
+       struct nfsbuf *bp, *lastbp, *foundbp;
+       struct nfsbuflists blist;
+       daddr64_t lbn, nextlbn;
+       int dotunder = (cnp->cn_namelen > 2) && (cnp->cn_nameptr[0] == '.') && (cnp->cn_nameptr[1] == '_');
+
+       if (!(nmp = NFSTONMP(dnp)))
                return (ENXIO);
-       v3 = NFS_ISV3(dvp);
-
-       nfsstats.rpccnt[NFSPROC_LOOKUP]++;
-       nfsm_reqhead(dvp, NFSPROC_LOOKUP,
-               NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
-       nfsm_fhtom(dvp, v3);
-       nfsm_strtom(name, len, NFS_MAXNAMLEN);
-       nfsm_request(dvp, NFSPROC_LOOKUP, procp, cred, &xid);
-       if (npp && !error) {
-               nfsm_getfh(nfhp, fhlen, v3);
-               if (*npp) {
-                   np = *npp;
-                   if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
-                       FREE_ZONE((caddr_t)np->n_fhp,
-                                       np->n_fhsize, M_NFSBIGFH);
-                       np->n_fhp = &np->n_fh;
-                   } else if (np->n_fhsize <= NFS_SMALLFH && fhlen>NFS_SMALLFH)
-                       MALLOC_ZONE(np->n_fhp, nfsfh_t *,
-                                               fhlen, M_NFSBIGFH, M_WAITOK);
-                   bcopy((caddr_t)nfhp, (caddr_t)np->n_fhp, fhlen);
-                   np->n_fhsize = fhlen;
-                   newvp = NFSTOV(np);
-               } else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
-                   VREF(dvp);
-                   newvp = dvp;
-               } else {
-                   error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np);
-                   if (error) {
-                       m_freem(mrep);
+       slpflag = (nmp->nm_flag & NFSMNT_INT) ? PCATCH : 0;
+       slptimeo = 0;
+       if (!purge)
+               *npp = NULL;
+
+       /* first check most recent buffer (and next one too) */
+       lbn = dnp->n_lastdbl;
+       for (i=0; i < 2; i++) {
+               if ((error = nfs_buf_get(dnp, lbn, NFS_DIRBLKSIZ, thd, NBLK_READ|NBLK_ONLYVALID, &bp)))
                        return (error);
-                   }
-                   newvp = NFSTOV(np);
+               if (!bp)
+                       break;
+               count++;
+               error = nfs_dir_buf_search(bp, cnp, &fh, &nvattr, &xid, &attrstamp, &nextlbn, purge ? NDBS_PURGE : 0);
+               nfs_buf_release(bp, 0);
+               if (error == ESRCH) {
+                       error = 0;
+               } else {
+                       found = 1;
+                       break;
                }
-               if (v3) {
-                       nfsm_postop_attr(newvp, attrflag, &xid);
-                       if (!attrflag && *npp == NULL) {
-                               m_freem(mrep);
-                               if (newvp == dvp)
-                                       vrele(newvp);
-                               else
-                                       vput(newvp);
-                               return (ENOENT);
-                       }
-               } else
-                       nfsm_loadattr(newvp, (struct vattr *)0, &xid);
+               lbn = nextlbn;
        }
-       nfsm_reqdone;
-       if (npp && *npp == NULL) {
-               if (error) {
-                       if (newvp)
-                               if (newvp == dvp)
-                                       vrele(newvp);
-                               else
-                                       vput(newvp);
-               } else
-                       *npp = np;
+
+       lck_mtx_lock(nfs_buf_mutex);
+       if (found) {
+               dnp->n_lastdbl = lbn;
+               goto done;
        }
-       return (error);
-}
 
-/*
- * Nfs Version 3 commit rpc
- */
-int
-nfs_commit(vp, offset, cnt, cred, procp)
-       register struct vnode *vp;
-       u_quad_t offset;
-       int cnt;
-       struct ucred *cred;
-       struct proc *procp;
-{
-       register caddr_t cp;
-       register u_long *tl;
-       register int t1, t2;
-       register struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-       caddr_t bpos, dpos, cp2;
-       int error = 0, wccflag = NFSV3_WCCRATTR;
-       struct mbuf *mreq, *mrep, *md, *mb, *mb2;
-       u_int64_t xid;
-       
-       FSDBG(521, vp, offset, cnt, nmp->nm_state);
-       if (!nmp)
-               return (ENXIO);
-       if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0)
-               return (0);
-       nfsstats.rpccnt[NFSPROC_COMMIT]++;
-       nfsm_reqhead(vp, NFSPROC_COMMIT, NFSX_FH(1));
-       nfsm_fhtom(vp, 1);
-       nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
-       txdr_hyper(&offset, tl);
-       tl += 2;
-       *tl = txdr_unsigned(cnt);
-       nfsm_request(vp, NFSPROC_COMMIT, procp, cred, &xid);
-       nfsm_wcc_data(vp, wccflag, &xid);
-       if (!error) {
-               nfsm_dissect(tl, u_long *, NFSX_V3WRITEVERF);
-               if (bcmp((caddr_t)nmp->nm_verf, (caddr_t)tl,
-                        NFSX_V3WRITEVERF)) {
-                       bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
-                               NFSX_V3WRITEVERF);
-                       error = NFSERR_STALEWRITEVERF;
+       /*
+        * Scan the list of buffers, keeping them in order.
+        * Note that itercomplete inserts each of the remaining buffers
+        * into the head of list (thus reversing the elements).  So, we
+        * make sure to iterate through all buffers, inserting them after
+        * each other, to keep them in order.
+        * Also note: the LIST_INSERT_AFTER(lastbp) is only safe because
+        * we don't drop nfs_buf_mutex.
+        */
+       if (!nfs_buf_iterprepare(dnp, &blist, NBI_CLEAN)) {
+               lastbp = foundbp = NULL;
+               while ((bp = LIST_FIRST(&blist))) {
+                       LIST_REMOVE(bp, nb_vnbufs);
+                       if (!lastbp)
+                               LIST_INSERT_HEAD(&dnp->n_cleanblkhd, bp, nb_vnbufs);
+                       else
+                               LIST_INSERT_AFTER(lastbp, bp, nb_vnbufs);
+                       lastbp = bp;
+                       if (error || found)
+                               continue;
+                       if (!purge && dotunder && (count > 100)) /* don't waste too much time looking for ._ files */
+                               continue;
+                       nfs_buf_refget(bp);
+                       lbn = bp->nb_lblkno;
+                       if (nfs_buf_acquire(bp, NBAC_NOWAIT, 0, 0)) {
+                               /* just skip this buffer */
+                               nfs_buf_refrele(bp);
+                               continue;
+                       }
+                       nfs_buf_refrele(bp);
+                       count++;
+                       error = nfs_dir_buf_search(bp, cnp, &fh, &nvattr, &xid, &attrstamp, NULL, purge ? NDBS_PURGE : 0);
+                       if (error == ESRCH) {
+                               error = 0;
+                       } else {
+                               found = 1;
+                               foundbp = bp;
+                       }
+                       nfs_buf_drop(bp);
                }
+               if (found) {
+                       LIST_REMOVE(foundbp, nb_vnbufs);
+                       LIST_INSERT_HEAD(&dnp->n_cleanblkhd, foundbp, nb_vnbufs);
+                       dnp->n_lastdbl = foundbp->nb_lblkno;
+               }
+               nfs_buf_itercomplete(dnp, &blist, NBI_CLEAN);
        }
-       nfsm_reqdone;
-       return (error);
-}
+done:
+       lck_mtx_unlock(nfs_buf_mutex);
 
-static int
-nfs_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;
-               int *a_runb;
-       } */ *ap;
-{
-       register struct vnode *vp = ap->a_vp;
-       int devBlockSize = DEV_BSIZE;
+       if (!error && found && !purge) {
+               error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len,
+                               &nvattr, &xid, NG_MAKEENTRY, &newnp);
+               if (error)
+                       return (error);
+               newnp->n_attrstamp = attrstamp;
+               *npp = newnp;
+               nfs_node_unlock(newnp);
+               /* check if the dir buffer's attrs are out of date */
+               if (!nfs_getattr(newnp, &nvattr, ctx, NGA_CACHED) &&
+                   (newnp->n_attrstamp != attrstamp)) {
+                       /* they are, so update them */
+                       error = nfs_buf_get(dnp, lbn, NFS_DIRBLKSIZ, thd, NBLK_READ|NBLK_ONLYVALID, &bp);
+                       if (!error && bp) {
+                               attrstamp = newnp->n_attrstamp;
+                               xid = newnp->n_xid;
+                               nfs_dir_buf_search(bp, cnp, &fh, &nvattr, &xid, &attrstamp, NULL, NDBS_UPDATE);
+                               nfs_buf_release(bp, 0);
+                       }
+                       error = 0;
+               }
+       }
 
-       if (ap->a_vpp != NULL)
-               *ap->a_vpp = vp;
-       if (ap->a_bnp != NULL) {
-               if (!vp->v_mount)
-                       return (ENXIO);
-               *ap->a_bnp = ap->a_bn * btodb(vp->v_mount->mnt_stat.f_iosize,
-                                             devBlockSize);
-       }
-       if (ap->a_runp != NULL)
-               *ap->a_runp = 0;
-#ifdef notyet
-       if (ap->a_runb != NULL)
-               *ap->a_runb = 0;
-#endif
-       return (0);
+       return (error);
 }
 
 /*
- * Mmap a file
- *
- * NB Currently unsupported.
+ * Purge name cache entries for the given node.
+ * For RDIRPLUS, also invalidate the entry in the directory's buffers.
  */
-/* ARGSUSED */
-static int
-nfs_mmap(ap)
-       struct vop_mmap_args /* {
-               struct vnode *a_vp;
-               int  a_fflags;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+void
+nfs_name_cache_purge(nfsnode_t dnp, nfsnode_t np, struct componentname *cnp, vfs_context_t ctx)
 {
+       struct nfsmount *nmp = NFSTONMP(dnp);
 
-       return (EINVAL);
+       cache_purge(NFSTOV(np));
+       if (nmp && (nmp->nm_vers > NFS_VER2) && (nmp->nm_flag & NFSMNT_RDIRPLUS))
+               nfs_dir_buf_cache_lookup(dnp, NULL, cnp, ctx, 1);
 }
 
 /*
- * fsync vnode op. Just call nfs_flush() with commit == 1.
+ * NFS V3 readdir (plus) RPC.
  */
-/* ARGSUSED */
-static int
-nfs_fsync(ap)
-       struct vop_fsync_args /* {
-               struct vnodeop_desc *a_desc;
-               struct vnode * a_vp;
-               struct ucred * a_cred;
-               int  a_waitfor;
-               struct proc * a_p;
-       } */ *ap;
-{
-       return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p, 1));
-}
 int
-nfs_flushcommits(struct vnode *vp, struct proc *p)
+nfs3_readdir_rpc(nfsnode_t dnp, struct nfsbuf *bp, vfs_context_t ctx)
 {
-       struct nfsnode *np = VTONFS(vp);
-       struct nfsbuf *bp, *nbp;
-       int i, s, error = 0, retv, bvecpos, wcred_set;
-       u_quad_t off, endoff, toff;
-       struct ucred* wcred;
-       struct nfsbuf **bvec = NULL;
-#define NFS_COMMITBVECSIZ      20
-#define NFS_MAXCOMMITBVECSIZ   1024
-       struct nfsbuf *bvec_on_stack[NFS_COMMITBVECSIZ];
-       int bvecsize = NFS_MAXCOMMITBVECSIZ;
-
-       FSDBG_TOP(557, vp, np, 0, 0);
-
-       /*
-        * A nb_flags == (NB_DELWRI | NB_NEEDCOMMIT) block has been written to the
-        * server, but nas not been committed to stable storage on the server
-        * yet. The byte range is worked out for as many nfsbufs as we can handle
-        * and the commit rpc is done.
-        */
-       if (np->n_dirtyblkhd.lh_first)
-               np->n_flag |= NMODIFIED;
-
-       off = (u_quad_t)-1;
-       endoff = 0;
-       bvecpos = 0;
-       wcred_set = 0;
+       struct nfsmount *nmp;
+       int error = 0, lockerror, nfsvers, rdirplus, bigcookies;
+       int i, status, attrflag, fhflag, more_entries = 1, eof, bp_dropped = 0;
+       uint32_t nmreaddirsize, nmrsize;
+       uint32_t namlen, skiplen, fhlen, xlen, attrlen, reclen, space_free, space_needed;
+       uint64_t cookie, lastcookie, xid, savedxid, fileno;
+       struct nfsm_chain nmreq, nmrep, nmrepsave;
+       fhandle_t fh;
+       struct nfs_vattr *nvattrp;
+       struct nfs_dir_buf_header *ndbhp;
+       struct direntry *dp;
+       char *padstart, padlen;
+       struct timeval now;
 
-       if (!VFSTONFS(vp->v_mount)) {
-               error = ENXIO;
-               goto done;
-       }
-       if (!NFS_ISV3(vp)) {
-               error = EINVAL;
-               goto done;
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+       nmreaddirsize = nmp->nm_readdirsize;
+       nmrsize = nmp->nm_rsize;
+       bigcookies = nmp->nm_state & NFSSTA_BIGCOOKIES;
+noplus:
+       rdirplus = ((nfsvers > NFS_VER2) && (nmp->nm_flag & NFSMNT_RDIRPLUS)) ? 1 : 0;
+
+       if ((lockerror = nfs_node_lock(dnp)))
+               return (lockerror);
+
+       /* determine cookie to use, and move dp to the right offset */
+       ndbhp = (struct nfs_dir_buf_header*)bp->nb_data;
+       dp = NFS_DIR_BUF_FIRST_DIRENTRY(bp);
+       if (ndbhp->ndbh_count) {
+               for (i=0; i < ndbhp->ndbh_count-1; i++)
+                       dp = NFS_DIRENTRY_NEXT(dp);
+               cookie = dp->d_seekoff;
+               dp = NFS_DIRENTRY_NEXT(dp);
+       } else {
+               cookie = bp->nb_lblkno;
+               /* increment with every buffer read */
+               OSAddAtomic(1, &nfsstats.readdir_bios);
        }
-       s = splbio();
+       lastcookie = cookie;
 
        /*
-        * Allocate space to remember the list of bufs to commit.  It is
-        * important to use M_NOWAIT here to avoid a race with nfs_write
+        * Loop around doing readdir(plus) RPCs of size nm_readdirsize until
+        * the buffer is full (or we hit EOF).  Then put the remainder of the
+        * results in the next buffer(s).
         */
-       MALLOC(bvec, struct nfsbuf **,
-                      bvecsize * sizeof(struct nfsbuf *), M_TEMP,
-                      M_NOWAIT);
-       if (bvec == NULL) {
-               bvec = bvec_on_stack;
-               bvecsize = NFS_COMMITBVECSIZ;
-       }
-       for (bp = np->n_dirtyblkhd.lh_first; bp && bvecpos < bvecsize; bp = nbp) {
-               nbp = bp->nb_vnbufs.le_next;
-
-               if (((bp->nb_flags & (NB_BUSY | NB_DELWRI | NB_NEEDCOMMIT))
-                       != (NB_DELWRI | NB_NEEDCOMMIT)))
-                       continue;
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+       while (nfs_dir_buf_freespace(bp, rdirplus) && !(ndbhp->ndbh_flags & NDB_FULL)) {
+               nfsm_chain_build_alloc_init(error, &nmreq,
+                       NFSX_FH(nfsvers) + NFSX_READDIR(nfsvers) + NFSX_UNSIGNED);
+               nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+               if (nfsvers == NFS_VER3) {
+                       /* opaque values don't need swapping, but as long */
+                       /* as we are consistent about it, it should be ok */
+                       nfsm_chain_add_64(error, &nmreq, cookie);
+                       nfsm_chain_add_64(error, &nmreq, dnp->n_cookieverf);
+               } else {
+                       nfsm_chain_add_32(error, &nmreq, cookie);
+               }
+               nfsm_chain_add_32(error, &nmreq, nmreaddirsize);
+               if (rdirplus)
+                       nfsm_chain_add_32(error, &nmreq, nmrsize);
+               nfsm_chain_build_done(error, &nmreq);
+               nfs_node_unlock(dnp);
+               lockerror = ENOENT;
+               nfsmout_if(error);
+
+               error = nfs_request(dnp, NULL, &nmreq,
+                               rdirplus ? NFSPROC_READDIRPLUS : NFSPROC_READDIR,
+                               ctx, &nmrep, &xid, &status);
+
+               if ((lockerror = nfs_node_lock(dnp)))
+                       error = lockerror;
+
+               savedxid = xid;
+               if (nfsvers == NFS_VER3)
+                       nfsm_chain_postop_attr_update(error, &nmrep, dnp, &xid);
+               if (!error)
+                       error = status;
+               if (nfsvers == NFS_VER3)
+                       nfsm_chain_get_64(error, &nmrep, dnp->n_cookieverf);
+               nfsm_chain_get_32(error, &nmrep, more_entries);
+
+               if (!lockerror) {
+                       nfs_node_unlock(dnp);
+                       lockerror = ENOENT;
+               }
+               if (error == NFSERR_NOTSUPP) {
+                       /* oops... it doesn't look like readdirplus is supported */
+                       lck_mtx_lock(&nmp->nm_lock);
+                       nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
+                       lck_mtx_unlock(&nmp->nm_lock);
+                       goto noplus;
+               }
+               nfsmout_if(error);
 
-               nfs_buf_remfree(bp);
-               SET(bp->nb_flags, NB_BUSY);
-               /*
-                * we need a upl to see if the page has been
-                * dirtied (think mmap) since the unstable write, and
-                * also to prevent vm from paging it during our commit rpc
-                */
-               if (!ISSET(bp->nb_flags, NB_PAGELIST)) {
-                       retv = nfs_buf_upl_setup(bp);
-                       if (retv) {
-                               /* unable to create upl */
-                               /* vm object must no longer exist */
-                               /* this could be fatal if we need */
-                               /* to write the data again, we'll see...  */
-                               printf("nfs_flushcommits: upl create failed %d\n", retv);
-                               bp->nb_valid = bp->nb_dirty = 0;
+               if (rdirplus)
+                       microuptime(&now);
+
+               /* loop through the entries packing them into the buffer */
+               while (more_entries) {
+                       if (nfsvers == NFS_VER3)
+                               nfsm_chain_get_64(error, &nmrep, fileno);
+                       else
+                               nfsm_chain_get_32(error, &nmrep, fileno);
+                       nfsm_chain_get_32(error, &nmrep, namlen);
+                       nfsmout_if(error);
+                       /* just truncate names that don't fit in direntry.d_name */
+                       if (namlen <= 0) {
+                               error = EBADRPC;
+                               goto nfsmout;
+                       }
+                       if (namlen > (sizeof(dp->d_name)-1)) {
+                               skiplen = namlen - sizeof(dp->d_name) + 1;
+                               namlen = sizeof(dp->d_name) - 1;
+                       } else {
+                               skiplen = 0;
+                       }
+                       /* guess that fh size will be same as parent */
+                       fhlen = rdirplus ? (1 + dnp->n_fhsize) : 0;
+                       xlen = rdirplus ? (fhlen + sizeof(time_t)) : 0;
+                       attrlen = rdirplus ? sizeof(struct nfs_vattr) : 0;
+                       reclen = NFS_DIRENTRY_LEN(namlen + xlen);
+                       space_needed = reclen + attrlen;
+                       space_free = nfs_dir_buf_freespace(bp, rdirplus);
+                       if (space_needed > space_free) {
+                               /*
+                                * We still have entries to pack, but we've
+                                * run out of room in the current buffer.
+                                * So we need to move to the next buffer.
+                                * The block# for the next buffer is the
+                                * last cookie in the current buffer.
+                                */
+nextbuffer:
+                               ndbhp->ndbh_flags |= NDB_FULL;
+                               nfs_buf_release(bp, 0);
+                               bp_dropped = 1;
+                               bp = NULL;
+                               error = nfs_buf_get(dnp, lastcookie, NFS_DIRBLKSIZ, vfs_context_thread(ctx), NBLK_READ, &bp);
+                               nfsmout_if(error);
+                               /* initialize buffer */
+                               ndbhp = (struct nfs_dir_buf_header*)bp->nb_data;
+                               ndbhp->ndbh_flags = 0;
+                               ndbhp->ndbh_count = 0;
+                               ndbhp->ndbh_entry_end = sizeof(*ndbhp);
+                               ndbhp->ndbh_ncgen = dnp->n_ncgen;
+                               space_free = nfs_dir_buf_freespace(bp, rdirplus);
+                               dp = NFS_DIR_BUF_FIRST_DIRENTRY(bp);
+                               /* increment with every buffer read */
+                               OSAddAtomic(1, &nfsstats.readdir_bios);
                        }
+                       nmrepsave = nmrep;
+                       dp->d_fileno = fileno;
+                       dp->d_namlen = namlen;
+                       dp->d_reclen = reclen;
+                       dp->d_type = DT_UNKNOWN;
+                       nfsm_chain_get_opaque(error, &nmrep, namlen, dp->d_name);
+                       nfsmout_if(error);
+                       dp->d_name[namlen] = '\0';
+                       if (skiplen)
+                               nfsm_chain_adv(error, &nmrep,
+                                       nfsm_rndup(namlen + skiplen) - nfsm_rndup(namlen));
+                       if (nfsvers == NFS_VER3)
+                               nfsm_chain_get_64(error, &nmrep, cookie);
+                       else
+                               nfsm_chain_get_32(error, &nmrep, cookie);
+                       nfsmout_if(error);
+                       dp->d_seekoff = cookie;
+                       if (!bigcookies && (cookie >> 32) && (nmp == NFSTONMP(dnp))) {
+                               /* we've got a big cookie, make sure flag is set */
+                               lck_mtx_lock(&nmp->nm_lock);
+                               nmp->nm_state |= NFSSTA_BIGCOOKIES;
+                               lck_mtx_unlock(&nmp->nm_lock);
+                               bigcookies = 1;
+                       }
+                       if (rdirplus) {
+                               nvattrp = NFS_DIR_BUF_NVATTR(bp, ndbhp->ndbh_count);
+                               /* check for attributes */
+                               nfsm_chain_get_32(error, &nmrep, attrflag);
+                               nfsmout_if(error);
+                               if (attrflag) {
+                                       /* grab attributes */
+                                       error = nfs_parsefattr(&nmrep, NFS_VER3, nvattrp);
+                                       nfsmout_if(error);
+                                       dp->d_type = IFTODT(VTTOIF(nvattrp->nva_type));
+                                       /* fileid is already in d_fileno, so stash xid in attrs */
+                                       nvattrp->nva_fileid = savedxid;
+                               } else {
+                                       /* mark the attributes invalid */
+                                       bzero(nvattrp, sizeof(struct nfs_vattr));
+                               }
+                               /* check for file handle */
+                               nfsm_chain_get_32(error, &nmrep, fhflag);
+                               nfsmout_if(error);
+                               if (fhflag) {
+                                       nfsm_chain_get_fh(error, &nmrep, NFS_VER3, &fh);
+                                       nfsmout_if(error);
+                                       fhlen = fh.fh_len + 1;
+                                       xlen = fhlen + sizeof(time_t);
+                                       reclen = NFS_DIRENTRY_LEN(namlen + xlen);
+                                       space_needed = reclen + attrlen;
+                                       if (space_needed > space_free) {
+                                               /* didn't actually have the room... move on to next buffer */
+                                               nmrep = nmrepsave;
+                                               goto nextbuffer;
+                                       }
+                                       /* pack the file handle into the record */
+                                       dp->d_name[dp->d_namlen+1] = fh.fh_len;
+                                       bcopy(fh.fh_data, &dp->d_name[dp->d_namlen+2], fh.fh_len);
+                               } else {
+                                       /* mark the file handle invalid */
+                                       fh.fh_len = 0;
+                                       fhlen = fh.fh_len + 1;
+                                       xlen = fhlen + sizeof(time_t);
+                                       reclen = NFS_DIRENTRY_LEN(namlen + xlen);
+                                       bzero(&dp->d_name[dp->d_namlen+1], fhlen);
+                               }
+                               *(time_t*)(&dp->d_name[dp->d_namlen+1+fhlen]) = now.tv_sec;
+                               dp->d_reclen = reclen;
+                       }
+                       padstart = dp->d_name + dp->d_namlen + 1 + xlen;
+                       ndbhp->ndbh_count++;
+                       lastcookie = cookie;
+                       /* advance to next direntry in buffer */
+                       dp = NFS_DIRENTRY_NEXT(dp);
+                       ndbhp->ndbh_entry_end = (char*)dp - bp->nb_data;
+                       /* zero out the pad bytes */
+                       padlen = (char*)dp - padstart;
+                       if (padlen > 0)
+                               bzero(padstart, padlen);
+                       /* check for more entries */
+                       nfsm_chain_get_32(error, &nmrep, more_entries);
+                       nfsmout_if(error);
                }
-               nfs_buf_upl_check(bp);
+               /* Finally, get the eof boolean */
+               nfsm_chain_get_32(error, &nmrep, eof);
+               nfsmout_if(error);
+               if (eof) {
+                       ndbhp->ndbh_flags |= (NDB_FULL|NDB_EOF);
+                       nfs_node_lock_force(dnp);
+                       dnp->n_eofcookie = lastcookie;
+                       nfs_node_unlock(dnp);
+               } else {
+                       more_entries = 1;
+               }
+               if (bp_dropped) {
+                       nfs_buf_release(bp, 0);
+                       bp = NULL;
+                       break;
+               }
+               if ((lockerror = nfs_node_lock(dnp)))
+                       error = lockerror;
+               nfsmout_if(error);
+               nfsm_chain_cleanup(&nmrep);
+               nfsm_chain_null(&nmreq);
+       }
+nfsmout:
+       if (bp_dropped && bp)
+               nfs_buf_release(bp, 0);
+       if (!lockerror)
+               nfs_node_unlock(dnp);
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       return (bp_dropped ? NFSERR_DIRBUFDROPPED : error);
+}
+
+/*
+ * Silly rename. To make the NFS filesystem that is stateless look a little
+ * more like the "ufs" a remove of an active vnode is translated to a rename
+ * to a funny looking filename that is removed by nfs_vnop_inactive on the
+ * nfsnode. There is the potential for another process on a different client
+ * to create the same funny name between when the lookitup() fails and the
+ * rename() completes, but...
+ */
 
-               FSDBG(557, bp, bp->nb_flags, bp->nb_valid, bp->nb_dirty);
-               FSDBG(557, bp->nb_validoff, bp->nb_validend,
-                     bp->nb_dirtyoff, bp->nb_dirtyend);
+/* format of "random" silly names - includes a number and pid */
+/* (note: shouldn't exceed size of nfs_sillyrename.nsr_name) */
+#define NFS_SILLYNAME_FORMAT ".nfs.%08x.%04x"
+/* starting from zero isn't silly enough */
+static uint32_t nfs_sillyrename_number = 0x20051025;
 
-               /*
-                * We used to check for dirty pages here; if there were any
-                * we'd abort the commit and force the entire buffer to be
-                * written again.
-                *
-                * Instead of doing that, we now go ahead and commit the dirty
-                * range, and then leave the buffer around with dirty pages
-                * that will be written out later.
-                */
+int
+nfs_sillyrename(
+       nfsnode_t dnp,
+       nfsnode_t np,
+       struct componentname *cnp,
+       vfs_context_t ctx)
+{
+       struct nfs_sillyrename *nsp;
+       int error;
+       short pid;
+       kauth_cred_t cred;
+       uint32_t num;
+       struct nfsmount *nmp;
+
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
+               return (ENXIO);
 
-               /* in case blocking calls were made, re-evaluate nbp */
-               nbp = bp->nb_vnbufs.le_next;
+       nfs_name_cache_purge(dnp, np, cnp, ctx);
+
+       MALLOC_ZONE(nsp, struct nfs_sillyrename *,
+                       sizeof (struct nfs_sillyrename), M_NFSREQ, M_WAITOK);
+       if (!nsp)
+               return (ENOMEM);
+       cred = vfs_context_ucred(ctx);
+       kauth_cred_ref(cred);
+       nsp->nsr_cred = cred;
+       nsp->nsr_dnp = dnp;
+       error = vnode_ref(NFSTOV(dnp));
+       if (error)
+               goto bad_norele;
 
-               /*
-                * Work out if all buffers are using the same cred
-                * so we can deal with them all with one commit.
-                */
-               if (wcred_set == 0) {
-                       wcred = bp->nb_wcred;
-                       if (wcred == NOCRED)
-                               panic("nfs: needcommit w/out wcred");
-                       wcred_set = 1;
-               } else if ((wcred_set == 1) && crcmp(wcred, bp->nb_wcred)) {
-                       wcred_set = -1;
-               }
-               SET(bp->nb_flags, NB_WRITEINPROG);
+       /* Fudge together a funny name */
+       pid = vfs_context_pid(ctx);
+       num = OSAddAtomic(1, &nfs_sillyrename_number);
+       nsp->nsr_namlen = snprintf(nsp->nsr_name, sizeof(nsp->nsr_name),
+                               NFS_SILLYNAME_FORMAT, num, (pid & 0xffff));
+       if (nsp->nsr_namlen >= (int)sizeof(nsp->nsr_name))
+               nsp->nsr_namlen = sizeof(nsp->nsr_name) - 1;
 
-               /*
-                * A list of these buffers is kept so that the
-                * second loop knows which buffers have actually
-                * been committed. This is necessary, since there
-                * may be a race between the commit rpc and new
-                * uncommitted writes on the file.
-                */
-               bvec[bvecpos++] = bp;
-               toff = NBOFF(bp) + bp->nb_dirtyoff;
-               if (toff < off)
-                       off = toff;
-               toff += (u_quad_t)(bp->nb_dirtyend - bp->nb_dirtyoff);
-               if (toff > endoff)
-                       endoff = toff;
-       }
-       splx(s);
-
-       if (bvecpos == 0) {
-               error = ENOBUFS;
-               goto done;
+       /* Try lookitups until we get one that isn't there */
+       while (nfs_lookitup(dnp, nsp->nsr_name, nsp->nsr_namlen, ctx, NULL) == 0) {
+               num = OSAddAtomic(1, &nfs_sillyrename_number);
+               nsp->nsr_namlen = snprintf(nsp->nsr_name, sizeof(nsp->nsr_name),
+                                       NFS_SILLYNAME_FORMAT, num, (pid & 0xffff));
+               if (nsp->nsr_namlen >= (int)sizeof(nsp->nsr_name))
+                       nsp->nsr_namlen = sizeof(nsp->nsr_name) - 1;
        }
 
-       /*
-        * Commit data on the server, as required.
-        * If all bufs are using the same wcred, then use that with
-        * one call for all of them, otherwise commit each one
-        * separately.
-        */
-       if (wcred_set == 1)
-               retv = nfs_commit(vp, off, (int)(endoff - off), wcred, p);
-       else {
-               retv = 0;
-
-               for (i = 0; i < bvecpos; i++) {
-                       off_t off, size;
-                       bp = bvec[i];
-                       off = NBOFF(bp) + bp->nb_dirtyoff;
-                       size = (u_quad_t)(bp->nb_dirtyend - bp->nb_dirtyoff);
-                       retv = nfs_commit(vp, off, (int)size, bp->nb_wcred, p);
-                       if (retv) break;
+       /* now, do the rename */
+       error = nmp->nm_funcs->nf_rename_rpc(dnp, cnp->cn_nameptr, cnp->cn_namelen,
+                                       dnp, nsp->nsr_name, nsp->nsr_namlen, ctx);
+       if (!error) {
+               nfs_node_lock_force(dnp);
+               if (dnp->n_flag & NNEGNCENTRIES) {
+                       dnp->n_flag &= ~NNEGNCENTRIES;
+                       cache_purge_negatives(NFSTOV(dnp));
                }
+               nfs_node_unlock(dnp);
        }
-       if (retv == NFSERR_STALEWRITEVERF)
-               nfs_clearcommit(vp->v_mount);
+       FSDBG(267, dnp, np, num, error);
+       if (error)
+               goto bad;
+       error = nfs_lookitup(dnp, nsp->nsr_name, nsp->nsr_namlen, ctx, &np);
+       nfs_node_lock_force(np);
+       np->n_sillyrename = nsp;
+       nfs_node_unlock(np);
+       return (0);
+bad:
+       vnode_rele(NFSTOV(dnp));
+bad_norele:
+       nsp->nsr_cred = NOCRED;
+       kauth_cred_unref(&cred);
+       FREE_ZONE(nsp, sizeof(*nsp), M_NFSREQ);
+       return (error);
+}
 
-       /*
-        * Now, either mark the blocks I/O done or mark the
-        * blocks dirty, depending on whether the commit
-        * succeeded.
-        */
-       for (i = 0; i < bvecpos; i++) {
-               bp = bvec[i];
-               FSDBG(557, bp, retv, bp->nb_flags, bp->nb_dirty);
+int
+nfs3_lookup_rpc_async(
+       nfsnode_t dnp,
+       char *name,
+       int namelen,
+       vfs_context_t ctx,
+       struct nfsreq **reqp)
+{
+       struct nfsmount *nmp;
+       struct nfsm_chain nmreq;
+       int error = 0, nfsvers;
+
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmreq);
+
+       nfsm_chain_build_alloc_init(error, &nmreq,
+               NFSX_FH(nfsvers) + NFSX_UNSIGNED + nfsm_rndup(namelen));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
+       nfsm_chain_add_string(error, &nmreq, name, namelen);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_LOOKUP,
+                       vfs_context_thread(ctx), vfs_context_ucred(ctx), NULL, reqp);
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       return (error);
+}
+
+int
+nfs3_lookup_rpc_async_finish(
+       nfsnode_t dnp,
+       vfs_context_t ctx,
+       struct nfsreq *req,
+       u_int64_t *xidp,
+       fhandle_t *fhp,
+       struct nfs_vattr *nvap)
+{
+       int error = 0, lockerror = ENOENT, status, nfsvers, attrflag;
+       u_int64_t xid;
+       struct nfsmount *nmp;
+       struct nfsm_chain nmrep;
 
-               CLR(bp->nb_flags, (NB_NEEDCOMMIT | NB_WRITEINPROG));
+       nmp = NFSTONMP(dnp);
+       nfsvers = nmp->nm_vers;
 
-               np->n_needcommitcnt--;
-               CHECK_NEEDCOMMITCNT(np);
+       nfsm_chain_null(&nmrep);
 
-               if (retv) {
-                       nfs_buf_release(bp);
-               } else {
-                       s = splbio();
-                       vp->v_numoutput++;
+       error = nfs_request_async_finish(req, &nmrep, xidp, &status);
 
-                       if (ISSET(bp->nb_flags, NB_DELWRI)) {
-                               nfs_nbdwrite--;
-                               NFSBUFCNTCHK();
-                               wakeup((caddr_t)&nfs_nbdwrite);
-                       }
-                       CLR(bp->nb_flags, (NB_READ|NB_DONE|NB_ERROR|NB_DELWRI));
-                       /* if block still has dirty pages, we don't want it to */
-                       /* be released in nfs_buf_iodone().  So, don't set NB_ASYNC. */
-                       if (!bp->nb_dirty)
-                               SET(bp->nb_flags, NB_ASYNC);
-
-                       /* move to clean list */
-                       if (bp->nb_vnbufs.le_next != NFSNOLIST)
-                               LIST_REMOVE(bp, nb_vnbufs);
-                       LIST_INSERT_HEAD(&VTONFS(vp)->n_cleanblkhd, bp, nb_vnbufs);
-
-                       bp->nb_dirtyoff = bp->nb_dirtyend = 0;
-                       splx(s);
-
-                       nfs_buf_iodone(bp);
-                       if (bp->nb_dirty) {
-                               /* throw it back in as a delayed write buffer */
-                               CLR(bp->nb_flags, NB_DONE);
-                               nfs_buf_write_delayed(bp);
-                       }
-               }
+       if ((lockerror = nfs_node_lock(dnp)))
+               error = lockerror;
+       xid = *xidp;
+       if (error || status) {
+               if (nfsvers == NFS_VER3)
+                       nfsm_chain_postop_attr_update(error, &nmrep, dnp, &xid);
+               if (!error)
+                       error = status;
+               goto nfsmout;
        }
 
-done:
-       if (bvec != NULL && bvec != bvec_on_stack)
-               _FREE(bvec, M_TEMP);
-       FSDBG_BOT(557, vp, np, 0, error);
+       nfsmout_if(error || !fhp || !nvap);
+
+       /* get the file handle */
+       nfsm_chain_get_fh(error, &nmrep, nfsvers, fhp);
+
+       /* get the attributes */
+       if (nfsvers == NFS_VER3) {
+               nfsm_chain_postop_attr_get(error, &nmrep, attrflag, nvap);
+               nfsm_chain_postop_attr_update(error, &nmrep, dnp, &xid);
+               if (!error && !attrflag)
+                       error = nfs3_getattr_rpc(NULL, NFSTOMP(dnp), fhp->fh_data, fhp->fh_len, ctx, nvap, xidp);
+       } else {
+               error = nfs_parsefattr(&nmrep, nfsvers, nvap);
+       }
+nfsmout:
+       if (!lockerror)
+               nfs_node_unlock(dnp);
+       nfsm_chain_cleanup(&nmrep);
        return (error);
 }
 
 /*
- * Flush all the blocks associated with a vnode.
- *     Walk through the buffer pool and push any dirty pages
- *     associated with the vnode.
+ * Look up a file name and optionally either update the file handle or
+ * allocate an nfsnode, depending on the value of npp.
+ * npp == NULL --> just do the lookup
+ * *npp == NULL --> allocate a new nfsnode and make sure attributes are
+ *                     handled too
+ * *npp != NULL --> update the file handle in the vnode
  */
-static int
-nfs_flush(vp, cred, waitfor, p, commit)
-       register struct vnode *vp;
-       struct ucred *cred;
-       int waitfor;
-       struct proc *p;
-       int commit;
+int
+nfs_lookitup(
+       nfsnode_t dnp,
+       char *name,
+       int namelen,
+       vfs_context_t ctx,
+       nfsnode_t *npp)
 {
-       struct nfsnode *np = VTONFS(vp);
-       struct nfsbuf *bp, *nbp;
-       struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-       int i, s, error = 0, error2, slptimeo = 0, slpflag = 0;
-       int passone = 1;
+       int error = 0;
+       nfsnode_t np, newnp = NULL;
+       u_int64_t xid;
+       fhandle_t fh;
+       struct nfsmount *nmp;
+       struct nfs_vattr nvattr;
+       struct nfsreq rq, *req = &rq;
 
-       FSDBG_TOP(517, vp, np, waitfor, commit);
+       nmp = NFSTONMP(dnp);
+       if (!nmp)
+               return (ENXIO);
 
-       if (!nmp) {
-               error = ENXIO;
-               goto done;
-       }
-       if (nmp->nm_flag & NFSMNT_INT)
-               slpflag = PCATCH;
-       if (!commit)
-               passone = 0;
+       if (NFS_BITMAP_ISSET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXNAME) &&
+           (namelen > (int)nmp->nm_fsattr.nfsa_maxname))
+               return (ENAMETOOLONG);
 
-       /*
-        * On the first pass, commit all the bufs that can be.
-        * On the second pass, nfs_buf_write() is called to do the job.
-        */
-again:
-       FSDBG(518, np->n_dirtyblkhd.lh_first, np->n_flag, 0, 0);
-       if (np->n_dirtyblkhd.lh_first)
-               np->n_flag |= NMODIFIED;
-       if (!VFSTONFS(vp->v_mount)) {
-               error = ENXIO;
-               goto done;
-       }
-       if (NFS_ISV3(vp) && commit) {
-               /* loop while it looks like there are still buffers to be */
-               /* commited and nfs_flushcommits() seems to be handling them. */
-               while (np->n_needcommitcnt)
-                       if (nfs_flushcommits(vp, p))
-                               break;
+       /* check for lookup of "." */
+       if ((name[0] == '.') && (namelen == 1)) {
+               /* skip lookup, we know who we are */
+               fh.fh_len = 0;
+               newnp = dnp;
+               goto nfsmout;
        }
 
-       /* Start/do any write(s) that are required. */
-loop:
-       s = splbio();
-       for (bp = np->n_dirtyblkhd.lh_first; bp; bp = nbp) {
-               nbp = bp->nb_vnbufs.le_next;
-               if (ISSET(bp->nb_flags, NB_BUSY)) {
-                       FSDBG(524, bp, waitfor, passone, bp->nb_flags);
-                       if (waitfor != MNT_WAIT || passone)
-                               continue;
-                       SET(bp->nb_flags, NB_WANTED);
-                       error = tsleep((caddr_t)bp, slpflag | (PRIBIO + 1),
-                                      "nfsfsync", slptimeo);
-                       splx(s);
-                       if (error) {
-                               error2 = nfs_sigintr(VFSTONFS(vp->v_mount),
-                                   (struct nfsreq *)0, p);
-                               if (error2) {
-                                       error = error2;
-                                       goto done;
-                               }
-                               if (slpflag == PCATCH) {
-                                       slpflag = 0;
-                                       slptimeo = 2 * hz;
+       error = nmp->nm_funcs->nf_lookup_rpc_async(dnp, name, namelen, ctx, &req);
+       nfsmout_if(error);
+       error = nmp->nm_funcs->nf_lookup_rpc_async_finish(dnp, ctx, req, &xid, &fh, &nvattr);
+       nfsmout_if(!npp || error);
+
+       if (*npp) {
+               np = *npp;
+               if (fh.fh_len != np->n_fhsize) {
+                       u_char *oldbuf = (np->n_fhsize > NFS_SMALLFH) ? np->n_fhp : NULL;
+                       if (fh.fh_len > NFS_SMALLFH) {
+                               MALLOC_ZONE(np->n_fhp, u_char *, fh.fh_len, M_NFSBIGFH, M_WAITOK);
+                               if (!np->n_fhp) {
+                                   np->n_fhp = oldbuf;
+                                   error = ENOMEM;
+                                   goto nfsmout;
                                }
+                       } else {
+                               np->n_fhp = &np->n_fh[0];
                        }
-                       goto loop;
-               }
-               if (!ISSET(bp->nb_flags, NB_DELWRI))
-                       panic("nfs_fsync: not dirty");
-               FSDBG(525, bp, passone, commit, bp->nb_flags);
-               if ((passone || !commit) && ISSET(bp->nb_flags, NB_NEEDCOMMIT))
-                       continue;
-               nfs_buf_remfree(bp);
-               if (ISSET(bp->nb_flags, NB_ERROR)) {
-                       np->n_error = bp->nb_error ? bp->nb_error : EIO;
-                       np->n_flag |= NWRITEERR;
-                       nfs_buf_release(bp);
-                       continue;
-               }
-               if (passone || !commit)
-                       SET(bp->nb_flags, NB_BUSY|NB_ASYNC);
-               else {
-                       /* the NB_STABLE forces this to be written FILESYNC */
-                       SET(bp->nb_flags, NB_BUSY|NB_ASYNC|NB_STABLE);
+                       if (oldbuf)
+                               FREE_ZONE(oldbuf, np->n_fhsize, M_NFSBIGFH);
                }
-               splx(s);
-               nfs_buf_write(bp);
-               goto loop;
-       }
-       splx(s);
-
-       if (passone) {
-               passone = 0;
-               goto again;
+               bcopy(fh.fh_data, np->n_fhp, fh.fh_len);
+               np->n_fhsize = fh.fh_len;
+               nfs_node_lock_force(np);
+               error = nfs_loadattrcache(np, &nvattr, &xid, 0);
+               nfs_node_unlock(np);
+               nfsmout_if(error);
+               newnp = np;
+       } else if (NFS_CMPFH(dnp, fh.fh_data, fh.fh_len)) {
+               nfs_node_lock_force(dnp);
+               if (dnp->n_xid <= xid)
+                       error = nfs_loadattrcache(dnp, &nvattr, &xid, 0);
+               nfs_node_unlock(dnp);
+               nfsmout_if(error);
+               newnp = dnp;
+       } else {
+               struct componentname cn, *cnp = &cn;
+               bzero(cnp, sizeof(*cnp));
+               cnp->cn_nameptr = name;
+               cnp->cn_namelen = namelen;
+               error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len,
+                           &nvattr, &xid, NG_MAKEENTRY, &np);
+               nfsmout_if(error);
+               newnp = np;
        }
 
-       if (waitfor == MNT_WAIT) {
-               while (vp->v_numoutput) {
-                       vp->v_flag |= VBWAIT;
-                       error = tsleep((caddr_t)&vp->v_numoutput,
-                               slpflag | (PRIBIO + 1), "nfsfsync", slptimeo);
-                       if (error) {
-                               error2 = nfs_sigintr(VFSTONFS(vp->v_mount),
-                                   (struct nfsreq *)0, p);
-                           if (error2) {
-                               error = error2;
-                               goto done;
-                           }
-                           if (slpflag == PCATCH) {
-                               slpflag = 0;
-                               slptimeo = 2 * hz;
-                           }
-                       }
-               }
-               if (np->n_dirtyblkhd.lh_first && commit) {
-                       goto loop;
-               }
-       }
-       FSDBG(526, np->n_flag, np->n_error, 0, 0);
-       if (np->n_flag & NWRITEERR) {
-               error = np->n_error;
-               np->n_flag &= ~NWRITEERR;
-       }
-done:
-       FSDBG_BOT(517, vp, np, error, 0);
+nfsmout:
+       if (npp && !*npp && !error)
+               *npp = newnp;
        return (error);
 }
 
 /*
- * Return POSIX pathconf information applicable to nfs.
- *
- * The NFS V2 protocol doesn't support this, so just return EINVAL
- * for V2.
+ * set up and initialize a "._" file lookup structure used for
+ * performing async lookups.
  */
-/* ARGSUSED */
-static int
-nfs_pathconf(ap)
-       struct vop_pathconf_args /* {
-               struct vnode *a_vp;
-               int a_name;
-               int *a_retval;
-       } */ *ap;
+void
+nfs_dulookup_init(struct nfs_dulookup *dulp, nfsnode_t dnp, const char *name, int namelen, vfs_context_t ctx)
 {
-
-       return (EINVAL);
+       int error, du_namelen;
+       vnode_t du_vp;
+
+       /* check for ._ file in name cache */
+       dulp->du_flags = 0;
+       bzero(&dulp->du_cn, sizeof(dulp->du_cn));
+       du_namelen = namelen + 2;
+       if ((namelen >= 2) && (name[0] == '.') && (name[1] == '_'))
+               return;
+       if (du_namelen >= (int)sizeof(dulp->du_smallname))
+               MALLOC(dulp->du_cn.cn_nameptr, char *, du_namelen + 1, M_TEMP, M_WAITOK);
+       else
+               dulp->du_cn.cn_nameptr = dulp->du_smallname;
+       if (!dulp->du_cn.cn_nameptr)
+               return;
+       dulp->du_cn.cn_namelen = du_namelen;
+       snprintf(dulp->du_cn.cn_nameptr, du_namelen + 1, "._%s", name);
+       dulp->du_cn.cn_nameptr[du_namelen] = '\0';
+       dulp->du_cn.cn_nameiop = LOOKUP;
+       dulp->du_cn.cn_flags = MAKEENTRY;
+
+       error = cache_lookup(NFSTOV(dnp), &du_vp, &dulp->du_cn);
+       if (error == -1) {
+               vnode_put(du_vp);
+       } else if (!error) {
+               struct nfsmount *nmp = NFSTONMP(dnp);
+               if (nmp && (nmp->nm_vers > NFS_VER2) && (nmp->nm_flag & NFSMNT_RDIRPLUS)) {
+                       /* if rdirplus, try dir buf cache lookup */
+                       nfsnode_t du_np = NULL;
+                       if (!nfs_dir_buf_cache_lookup(dnp, &du_np, &dulp->du_cn, ctx, 0) && du_np) {
+                               /* dir buf cache hit */
+                               du_vp = NFSTOV(du_np);
+                               vnode_put(du_vp);
+                               error = -1;
+                       }
+               }
+               if (!error)
+                       dulp->du_flags |= NFS_DULOOKUP_DOIT;
+       }
 }
 
 /*
- * NFS advisory byte-level locks (client)
+ * start an async "._" file lookup request
  */
-static int
-nfs_advlock(ap)
-       struct vop_advlock_args /* {
-               struct vnode *a_vp;
-               caddr_t  a_id;
-               int  a_op;
-               struct flock *a_fl;
-               int  a_flags;
-       } */ *ap;
+void
+nfs_dulookup_start(struct nfs_dulookup *dulp, nfsnode_t dnp, vfs_context_t ctx)
 {
-       return (nfs_dolock(ap));
+       struct nfsmount *nmp = NFSTONMP(dnp);
+       struct nfsreq *req = &dulp->du_req;
+
+       if (!nmp || !(dulp->du_flags & NFS_DULOOKUP_DOIT))
+               return;
+       if (!nmp->nm_funcs->nf_lookup_rpc_async(dnp, dulp->du_cn.cn_nameptr,
+                       dulp->du_cn.cn_namelen, ctx, &req))
+               dulp->du_flags |= NFS_DULOOKUP_INPROG;
 }
 
 /*
- * Print out the contents of an nfsnode.
+ * finish an async "._" file lookup request and clean up the structure
  */
-static int
-nfs_print(ap)
-       struct vop_print_args /* {
-               struct vnode *a_vp;
-       } */ *ap;
+void
+nfs_dulookup_finish(struct nfs_dulookup *dulp, nfsnode_t dnp, vfs_context_t ctx)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
-
-       printf("tag VT_NFS, fileid %ld fsid 0x%lx",
-               np->n_vattr.va_fileid, np->n_vattr.va_fsid);
-       if (vp->v_type == VFIFO)
-               fifo_printinfo(vp);
-       printf("\n");
-       return (0);
+       struct nfsmount *nmp = NFSTONMP(dnp);
+       int error;
+       nfsnode_t du_np;
+       u_int64_t xid;
+       fhandle_t fh;
+       struct nfs_vattr nvattr;
+
+       if (!nmp || !(dulp->du_flags & NFS_DULOOKUP_INPROG))
+               goto out;
+
+       error = nmp->nm_funcs->nf_lookup_rpc_async_finish(dnp, ctx, &dulp->du_req, &xid, &fh, &nvattr);
+       dulp->du_flags &= ~NFS_DULOOKUP_INPROG;
+       if (error == ENOENT) {
+               /* add a negative entry in the name cache */
+               nfs_node_lock_force(dnp);
+               cache_enter(NFSTOV(dnp), NULL, &dulp->du_cn);
+               dnp->n_flag |= NNEGNCENTRIES;
+               nfs_node_unlock(dnp);
+       } else if (!error) {
+               error = nfs_nget(NFSTOMP(dnp), dnp, &dulp->du_cn, fh.fh_data, fh.fh_len,
+                           &nvattr, &xid, NG_MAKEENTRY, &du_np);
+               if (!error) {
+                       nfs_node_unlock(du_np);
+                       vnode_put(NFSTOV(du_np));
+               }
+       }
+out:
+       if (dulp->du_flags & NFS_DULOOKUP_INPROG)
+               nfs_request_async_cancel(&dulp->du_req);
+       if (dulp->du_cn.cn_nameptr && (dulp->du_cn.cn_nameptr != dulp->du_smallname))
+               FREE(dulp->du_cn.cn_nameptr, M_TEMP);
 }
 
+
 /*
- * NFS directory offset lookup.
- * Currently unsupported.
+ * NFS Version 3 commit RPC
  */
-static int
-nfs_blkatoff(ap)
-       struct vop_blkatoff_args /* {
-               struct vnode *a_vp;
-               off_t a_offset;
-               char **a_res;
-               struct buf **a_bpp;
-       } */ *ap;
+int
+nfs3_commit_rpc(
+       nfsnode_t np,
+       u_int64_t offset,
+       u_int64_t count,
+       kauth_cred_t cred)
 {
+       struct nfsmount *nmp;
+       int error = 0, lockerror, status, wccpostattr = 0, nfsvers;
+       struct timespec premtime = { 0, 0 };
+       u_int64_t xid, wverf;
+       uint32_t count32;
+       struct nfsm_chain nmreq, nmrep;
+
+       nmp = NFSTONMP(np);
+       FSDBG(521, np, offset, count, nmp ? nmp->nm_state : 0);
+       if (!nmp)
+               return (ENXIO);
+       if (!(nmp->nm_state & NFSSTA_HASWRITEVERF))
+               return (0);
+       nfsvers = nmp->nm_vers;
 
-#if DIAGNOSTIC
-       printf("nfs_blkatoff: unimplemented!!");
-#endif
-       return (EOPNOTSUPP);
+       if (count > UINT32_MAX)
+               count32 = 0;
+       else
+               count32 = count;
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(NFS_VER3));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       nfsm_chain_add_64(error, &nmreq, offset);
+       nfsm_chain_add_32(error, &nmreq, count32);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request2(np, NULL, &nmreq, NFSPROC_COMMIT,
+                       current_thread(), cred, 0, &nmrep, &xid, &status);
+       if ((lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       /* can we do anything useful with the wcc info? */
+       nfsm_chain_get_wcc_data(error, &nmrep, np, &premtime, &wccpostattr, &xid);
+       if (!lockerror)
+               nfs_node_unlock(np);
+       if (!error)
+               error = status;
+       nfsm_chain_get_64(error, &nmrep, wverf);
+       nfsmout_if(error);
+       lck_mtx_lock(&nmp->nm_lock);
+       if (nmp->nm_verf != wverf) {
+               nmp->nm_verf = wverf;
+               error = NFSERR_STALEWRITEVERF;
+       }
+       lck_mtx_unlock(&nmp->nm_lock);
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       return (error);
 }
 
-/*
- * NFS flat namespace allocation.
- * Currently unsupported.
- */
-static int
-nfs_valloc(ap)
-       struct vop_valloc_args /* {
-               struct vnode *a_pvp;
-               int a_mode;
-               struct ucred *a_cred;
-               struct vnode **a_vpp;
-       } */ *ap;
-{
 
-       return (EOPNOTSUPP);
+int
+nfs_vnop_blockmap(
+       __unused struct vnop_blockmap_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               off_t a_foffset;
+               size_t a_size;
+               daddr64_t *a_bpn;
+               size_t *a_run;
+               void *a_poff;
+               int a_flags;
+       } */ *ap)
+{
+       return (ENOTSUP);
 }
 
 /*
- * NFS flat namespace free.
- * Currently unsupported.
+ * Mmap a file
+ *
+ * NB Currently unsupported.
  */
-static int
-nfs_vfree(ap)
-       struct vop_vfree_args /* {
-               struct vnode *a_pvp;
-               ino_t a_ino;
-               int a_mode;
-       } */ *ap;
+/*ARGSUSED*/
+int
+nfs_vnop_mmap(
+       __unused struct vnop_mmap_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_fflags;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-
-#if DIAGNOSTIC
-       printf("nfs_vfree: unimplemented!!");
-#endif
-       return (EOPNOTSUPP);
+       return (EINVAL);
 }
 
 /*
- * NFS file truncation.
+ * fsync vnode op. Just call nfs_flush().
  */
-static int
-nfs_truncate(ap)
-       struct vop_truncate_args /* {
-               struct vnode *a_vp;
-               off_t a_length;
-               int a_flags;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+/* ARGSUSED */
+int
+nfs_vnop_fsync(
+       struct vnop_fsync_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_waitfor;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-
-       /* Use nfs_setattr */
-#if DIAGNOSTIC
-       printf("nfs_truncate: unimplemented!!");
-#endif
-       return (EOPNOTSUPP);
+       return (nfs_flush(VTONFS(ap->a_vp), ap->a_waitfor, vfs_context_thread(ap->a_context), 0));
 }
 
+
 /*
- * NFS update.
+ * Do an NFS pathconf RPC.
  */
-static int
-nfs_update(ap)
-       struct vop_update_args /* {
-               struct vnode *a_vp;
-               struct timeval *a_ta;
-               struct timeval *a_tm;
-               int a_waitfor;
-       } */ *ap;
+int
+nfs3_pathconf_rpc(
+       nfsnode_t np,
+       struct nfs_fsattr *nfsap,
+       vfs_context_t ctx)
 {
+       u_int64_t xid;
+       int error = 0, lockerror, status, nfsvers;
+       struct nfsm_chain nmreq, nmrep;
+       struct nfsmount *nmp = NFSTONMP(np);
+       uint32_t val = 0;
 
-       /* Use nfs_setattr */
-#if DIAGNOSTIC
-       printf("nfs_update: unimplemented!!");
-#endif
-       return (EOPNOTSUPP);
+       if (!nmp)
+               return (ENXIO);
+       nfsvers = nmp->nm_vers;
+
+       nfsm_chain_null(&nmreq);
+       nfsm_chain_null(&nmrep);
+
+       /* fetch pathconf info from server */
+       nfsm_chain_build_alloc_init(error, &nmreq, NFSX_FH(NFS_VER3));
+       nfsm_chain_add_fh(error, &nmreq, nfsvers, np->n_fhp, np->n_fhsize);
+       nfsm_chain_build_done(error, &nmreq);
+       nfsmout_if(error);
+       error = nfs_request(np, NULL, &nmreq, NFSPROC_PATHCONF, ctx,
+                       &nmrep, &xid, &status);
+       if ((lockerror = nfs_node_lock(np)))
+               error = lockerror;
+       nfsm_chain_postop_attr_update(error, &nmrep, np, &xid);
+       if (!lockerror)
+               nfs_node_unlock(np);
+       if (!error)
+               error = status;
+       nfsm_chain_get_32(error, &nmrep, nfsap->nfsa_maxlink);
+       nfsm_chain_get_32(error, &nmrep, nfsap->nfsa_maxname);
+       nfsm_chain_get_32(error, &nmrep, val);
+       if (val)
+               nfsap->nfsa_flags |= NFS_FSFLAG_NO_TRUNC;
+       nfsm_chain_get_32(error, &nmrep, val);
+       if (val)
+               nfsap->nfsa_flags |= NFS_FSFLAG_CHOWN_RESTRICTED;
+       nfsm_chain_get_32(error, &nmrep, val);
+       if (val)
+               nfsap->nfsa_flags |= NFS_FSFLAG_CASE_INSENSITIVE;
+       nfsm_chain_get_32(error, &nmrep, val);
+       if (val)
+               nfsap->nfsa_flags |= NFS_FSFLAG_CASE_PRESERVING;
+       NFS_BITMAP_SET(nfsap->nfsa_bitmap, NFS_FATTR_MAXLINK);
+       NFS_BITMAP_SET(nfsap->nfsa_bitmap, NFS_FATTR_MAXNAME);
+       NFS_BITMAP_SET(nfsap->nfsa_bitmap, NFS_FATTR_NO_TRUNC);
+       NFS_BITMAP_SET(nfsap->nfsa_bitmap, NFS_FATTR_CHOWN_RESTRICTED);
+       NFS_BITMAP_SET(nfsap->nfsa_bitmap, NFS_FATTR_CASE_INSENSITIVE);
+       NFS_BITMAP_SET(nfsap->nfsa_bitmap, NFS_FATTR_CASE_PRESERVING);
+nfsmout:
+       nfsm_chain_cleanup(&nmreq);
+       nfsm_chain_cleanup(&nmrep);
+       return (error);
+}
+
+/* save pathconf info for NFSv3 mount */
+void
+nfs3_pathconf_cache(struct nfsmount *nmp, struct nfs_fsattr *nfsap)
+{
+       nmp->nm_fsattr.nfsa_maxlink = nfsap->nfsa_maxlink;
+       nmp->nm_fsattr.nfsa_maxname = nfsap->nfsa_maxname;
+       nmp->nm_fsattr.nfsa_flags |= nfsap->nfsa_flags & NFS_FSFLAG_NO_TRUNC;
+       nmp->nm_fsattr.nfsa_flags |= nfsap->nfsa_flags & NFS_FSFLAG_CHOWN_RESTRICTED;
+       nmp->nm_fsattr.nfsa_flags |= nfsap->nfsa_flags & NFS_FSFLAG_CASE_INSENSITIVE;
+       nmp->nm_fsattr.nfsa_flags |= nfsap->nfsa_flags & NFS_FSFLAG_CASE_PRESERVING;
+       NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXLINK);
+       NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_MAXNAME);
+       NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_NO_TRUNC);
+       NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CHOWN_RESTRICTED);
+       NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CASE_INSENSITIVE);
+       NFS_BITMAP_SET(nmp->nm_fsattr.nfsa_bitmap, NFS_FATTR_CASE_PRESERVING);
+       nmp->nm_state |= NFSSTA_GOTPATHCONF;
 }
 
 /*
- * write (or commit) the given NFS buffer
+ * Return POSIX pathconf information applicable to nfs.
+ *
+ * The NFS V2 protocol doesn't support this, so just return EINVAL
+ * for V2.
  */
+/* ARGSUSED */
 int
-nfs_buf_write(struct nfsbuf *bp)
+nfs_vnop_pathconf(
+       struct vnop_pathconf_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_name;
+               int32_t *a_retval;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       int s;
-       int oldflags = bp->nb_flags, rv = 0;
-       off_t off;
-       struct vnode *vp = bp->nb_vp;
-       struct ucred *cr;
-       struct proc *p = current_proc();
-
-       FSDBG_TOP(553, bp, NBOFF(bp), bp->nb_flags, 0);
-
-       if (!ISSET(bp->nb_flags, NB_BUSY))
-               panic("nfs_buf_write: buffer is not busy???");
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
+       struct nfsmount *nmp;
+       struct nfs_fsattr nfsa, *nfsap;
+       int error = 0;
+       uint64_t maxFileSize;
+       uint nbits;
 
-       s = splbio();
-       CLR(bp->nb_flags, (NB_READ|NB_DONE|NB_ERROR|NB_DELWRI));
-       if (ISSET(oldflags, NB_DELWRI)) {
-               nfs_nbdwrite--;
-               NFSBUFCNTCHK();
-               wakeup((caddr_t)&nfs_nbdwrite);
-       }
+       nmp = VTONMP(vp);
+       if (!nmp)
+               return (ENXIO);
 
-       /* move to clean list */
-       if (ISSET(oldflags, (NB_ASYNC|NB_DELWRI))) {
-               if (bp->nb_vnbufs.le_next != NFSNOLIST)
-                       LIST_REMOVE(bp, nb_vnbufs);
-               LIST_INSERT_HEAD(&VTONFS(vp)->n_cleanblkhd, bp, nb_vnbufs);
+       switch (ap->a_name) {
+       case _PC_LINK_MAX:
+       case _PC_NAME_MAX:
+       case _PC_CHOWN_RESTRICTED:
+       case _PC_NO_TRUNC:
+       case _PC_CASE_SENSITIVE:
+       case _PC_CASE_PRESERVING:
+               break;
+       case _PC_FILESIZEBITS:
+               if (nmp->nm_vers == NFS_VER2) {
+                       *ap->a_retval = 32;
+                       return (0);
+               }
+               break;
+       default:
+               /* don't bother contacting the server if we know the answer */
+               return (EINVAL);
        }
 
-       vp->v_numoutput++;
-       if (p && p->p_stats)
-               p->p_stats->p_ru.ru_oublock++;
-       splx(s);
+       if (nmp->nm_vers == NFS_VER2)
+               return (EINVAL);
 
-       /*
-        * For async requests when nfsiod(s) are running, queue the request by
-        * calling nfs_asyncio(), otherwise just all nfs_doio() to do the request.
-        */
-       if (ISSET(bp->nb_flags, NB_ASYNC))
-               p = (struct proc *)0;
-       if (ISSET(bp->nb_flags, NB_READ))
-               cr = bp->nb_rcred;
-       else
-               cr = bp->nb_wcred;
-       if (!ISSET(bp->nb_flags, NB_ASYNC) || nfs_asyncio(bp, NOCRED))
-               rv = nfs_doio(bp, cr, p);
-
-       if ((oldflags & NB_ASYNC) == 0) {
-               rv = nfs_buf_iowait(bp);
-               /* move to clean list */
-               if (oldflags & NB_DELWRI) {
-                       s = splbio();
-                       if (bp->nb_vnbufs.le_next != NFSNOLIST)
-                               LIST_REMOVE(bp, nb_vnbufs);
-                       LIST_INSERT_HEAD(&VTONFS(vp)->n_cleanblkhd, bp, nb_vnbufs);
-                       splx(s);
+       lck_mtx_lock(&nmp->nm_lock);
+       if (nmp->nm_vers == NFS_VER3) {
+               if (!(nmp->nm_state & NFSSTA_GOTPATHCONF)) {
+                       /* no pathconf info cached */
+                       lck_mtx_unlock(&nmp->nm_lock);
+                       NFS_CLEAR_ATTRIBUTES(nfsa.nfsa_bitmap);
+                       error = nfs3_pathconf_rpc(np, &nfsa, ap->a_context);
+                       if (error)
+                               return (error);
+                       nmp = VTONMP(vp);
+                       if (!nmp)
+                               return (ENXIO);
+                       lck_mtx_lock(&nmp->nm_lock);
+                       if (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_HOMOGENEOUS) {
+                               /* all files have the same pathconf info, */
+                               /* so cache a copy of the results */
+                               nfs3_pathconf_cache(nmp, &nfsa);
+                       }
+                       nfsap = &nfsa;
+               } else {
+                       nfsap = &nmp->nm_fsattr;
                }
-               FSDBG_BOT(553, bp, NBOFF(bp), bp->nb_flags, rv);
-               nfs_buf_release(bp);
-               return (rv);
-       } 
-
-       FSDBG_BOT(553, bp, NBOFF(bp), bp->nb_flags, rv);
-       return (rv);
-}
-
-/*
- * nfs special file access vnode op.
- * Essentially just get vattr and then imitate iaccess() since the device is
- * local to the client.
- */
-static int
-nfsspec_access(ap)
-       struct vop_access_args /* {
-               struct vnode *a_vp;
-               int  a_mode;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
-{
-       register struct vattr *vap;
-       register gid_t *gp;
-       register struct ucred *cred = ap->a_cred;
-       struct vnode *vp = ap->a_vp;
-       mode_t mode = ap->a_mode;
-       struct vattr vattr;
-       register int i;
-       int error;
+       } else if (!(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_HOMOGENEOUS)) {
+               /* no pathconf info cached */
+               lck_mtx_unlock(&nmp->nm_lock);
+               NFS_CLEAR_ATTRIBUTES(nfsa.nfsa_bitmap);
+               error = nfs4_pathconf_rpc(np, &nfsa, ap->a_context);
+               if (error)
+                       return (error);
+               nmp = VTONMP(vp);
+               if (!nmp)
+                       return (ENXIO);
+               lck_mtx_lock(&nmp->nm_lock);
+               nfsap = &nfsa;
+       } else {
+               nfsap = &nmp->nm_fsattr;
+       }
 
-       /*
-        * Disallow write attempts on filesystems mounted read-only;
-        * unless the file is a socket, fifo, or a block or character
-        * device resident on the filesystem.
-        */
-       if ((mode & VWRITE) && vp->v_mount && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
-               switch (vp->v_type) {
-               case VREG: case VDIR: case VLNK:
-                       return (EROFS);
+       switch (ap->a_name) {
+       case _PC_LINK_MAX:
+               if (NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_MAXLINK))
+                       *ap->a_retval = nfsap->nfsa_maxlink;
+               else if ((nmp->nm_vers == NFS_VER4) && NFS_BITMAP_ISSET(np->n_vattr.nva_bitmap, NFS_FATTR_MAXLINK))
+                       *ap->a_retval = np->n_vattr.nva_maxlink;
+               else
+                       error = EINVAL;
+               break;
+       case _PC_NAME_MAX:
+               if (NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_MAXNAME))
+                       *ap->a_retval = nfsap->nfsa_maxname;
+               else
+                       error = EINVAL;
+               break;
+       case _PC_CHOWN_RESTRICTED:
+               if (NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_CHOWN_RESTRICTED))
+                       *ap->a_retval = (nfsap->nfsa_flags & NFS_FSFLAG_CHOWN_RESTRICTED) ? 200112 /* _POSIX_CHOWN_RESTRICTED */ : 0;
+               else
+                       error = EINVAL;
+               break;
+       case _PC_NO_TRUNC:
+               if (NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_NO_TRUNC))
+                       *ap->a_retval = (nfsap->nfsa_flags & NFS_FSFLAG_NO_TRUNC) ? 200112 /* _POSIX_NO_TRUNC */ : 0;
+               else
+                       error = EINVAL;
+               break;
+       case _PC_CASE_SENSITIVE:
+               if (NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_CASE_INSENSITIVE))
+                       *ap->a_retval = (nfsap->nfsa_flags & NFS_FSFLAG_CASE_INSENSITIVE) ? 0 : 1;
+               else
+                       error = EINVAL;
+               break;
+       case _PC_CASE_PRESERVING:
+               if (NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_CASE_PRESERVING))
+                       *ap->a_retval = (nfsap->nfsa_flags & NFS_FSFLAG_CASE_PRESERVING) ? 1 : 0;
+               else
+                       error = EINVAL;
+               break;
+       case _PC_FILESIZEBITS:
+               if (!NFS_BITMAP_ISSET(nfsap->nfsa_bitmap, NFS_FATTR_MAXFILESIZE)) {
+                       *ap->a_retval = 64;
+                       error = 0;
+                       break;
                }
+               maxFileSize = nfsap->nfsa_maxfilesize;
+               nbits = 1;
+               if (maxFileSize & 0xffffffff00000000ULL) {
+                       nbits += 32;
+                       maxFileSize >>= 32;
+               }
+               if (maxFileSize & 0xffff0000) {
+                       nbits += 16;
+                       maxFileSize >>= 16;
+               }
+               if (maxFileSize & 0xff00) {
+                       nbits += 8;
+                       maxFileSize >>= 8;
+               }
+               if (maxFileSize & 0xf0) {
+                       nbits += 4;
+                       maxFileSize >>= 4;
+               }
+               if (maxFileSize & 0xc) {
+                       nbits += 2;
+                       maxFileSize >>= 2;
+               }
+               if (maxFileSize & 0x2) {
+                       nbits += 1;
+               }
+               *ap->a_retval = nbits;
+               break;
+       default:
+               error = EINVAL;
        }
-       /*
-        * If you're the super-user,
-        * you always get access.
-        */
-       if (cred->cr_uid == 0)
-               return (0);
-       vap = &vattr;
-       error = VOP_GETATTR(vp, vap, cred, ap->a_p);
-       if (error)
-               return (error);
-       /*
-        * Access check is based on only one of owner, group, public.
-        * If not owner, then check group. If not a member of the
-        * group, then check public access.
-        */
-       if (cred->cr_uid != vap->va_uid) {
-               mode >>= 3;
-               gp = cred->cr_groups;
-               for (i = 0; i < cred->cr_ngroups; i++, gp++)
-                       if (vap->va_gid == *gp)
-                               goto found;
-               mode >>= 3;
-found:
-               ;
-       }
-       error = (vap->va_mode & mode) == mode ? 0 : EACCES;
+
+       lck_mtx_unlock(&nmp->nm_lock);
+
        return (error);
 }
 
 /*
  * Read wrapper for special devices.
  */
-static int
-nfsspec_read(ap)
-       struct vop_read_args /* {
-               struct vnode *a_vp;
+int
+nfsspec_vnop_read(
+       struct vnop_read_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               int  a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
+               int a_ioflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct nfsnode *np = VTONFS(ap->a_vp);
+       nfsnode_t np = VTONFS(ap->a_vp);
        struct timeval now;
+       int error;
 
        /*
         * Set access flag.
         */
+       if ((error = nfs_node_lock(np)))
+               return (error);
        np->n_flag |= NACC;
        microtime(&now);
        np->n_atim.tv_sec = now.tv_sec;
        np->n_atim.tv_nsec = now.tv_usec * 1000;
-       return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
+       nfs_node_unlock(np);
+       return (VOCALL(spec_vnodeop_p, VOFFSET(vnop_read), ap));
 }
 
 /*
  * Write wrapper for special devices.
  */
-static int
-nfsspec_write(ap)
-       struct vop_write_args /* {
-               struct vnode *a_vp;
+int
+nfsspec_vnop_write(
+       struct vnop_write_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               int  a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
+               int a_ioflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct nfsnode *np = VTONFS(ap->a_vp);
+       nfsnode_t np = VTONFS(ap->a_vp);
        struct timeval now;
+       int error;
 
        /*
         * Set update flag.
         */
+       if ((error = nfs_node_lock(np)))
+               return (error);
        np->n_flag |= NUPD;
        microtime(&now);
        np->n_mtim.tv_sec = now.tv_sec;
        np->n_mtim.tv_nsec = now.tv_usec * 1000;
-       return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
+       nfs_node_unlock(np);
+       return (VOCALL(spec_vnodeop_p, VOFFSET(vnop_write), ap));
 }
 
 /*
@@ -4107,84 +5845,107 @@ nfsspec_write(ap)
  *
  * Update the times on the nfsnode then do device close.
  */
-static int
-nfsspec_close(ap)
-       struct vop_close_args /* {
-               struct vnode *a_vp;
-               int  a_fflag;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+int
+nfsspec_vnop_close(
+       struct vnop_close_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_fflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
-       struct vattr vattr;
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
+       struct vnode_attr vattr;
+       mount_t mp;
+       int error;
 
+       if ((error = nfs_node_lock(np)))
+               return (error);
        if (np->n_flag & (NACC | NUPD)) {
                np->n_flag |= NCHG;
-               if (vp->v_usecount == 1 && vp->v_mount &&
-                   (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
-                       VATTR_NULL(&vattr);
-                       if (np->n_flag & NACC)
-                               vattr.va_atime = np->n_atim;
-                       if (np->n_flag & NUPD)
-                               vattr.va_mtime = np->n_mtim;
-                       (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
+               if (!vnode_isinuse(vp, 0) && (mp = vnode_mount(vp)) && !vfs_isrdonly(mp)) {
+                       VATTR_INIT(&vattr);
+                       if (np->n_flag & NACC) {
+                               vattr.va_access_time = np->n_atim;
+                               VATTR_SET_ACTIVE(&vattr, va_access_time);
+                       }
+                       if (np->n_flag & NUPD) {
+                               vattr.va_modify_time = np->n_mtim;
+                               VATTR_SET_ACTIVE(&vattr, va_modify_time);
+                       }
+                       nfs_node_unlock(np);
+                       vnode_setattr(vp, &vattr, ap->a_context);
+               } else {
+                       nfs_node_unlock(np);
                }
+       } else {
+               nfs_node_unlock(np);
        }
-       return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
+       return (VOCALL(spec_vnodeop_p, VOFFSET(vnop_close), ap));
 }
 
+#if FIFO
+extern vnop_t **fifo_vnodeop_p;
+
 /*
  * Read wrapper for fifos.
  */
-static int
-nfsfifo_read(ap)
-       struct vop_read_args /* {
-               struct vnode *a_vp;
+int
+nfsfifo_vnop_read(
+       struct vnop_read_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               int  a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
+               int a_ioflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-        extern vop_t **fifo_vnodeop_p;
-       register struct nfsnode *np = VTONFS(ap->a_vp);
+       nfsnode_t np = VTONFS(ap->a_vp);
        struct timeval now;
+       int error;
 
        /*
         * Set access flag.
         */
+       if ((error = nfs_node_lock(np)))
+               return (error);
        np->n_flag |= NACC;
        microtime(&now);
        np->n_atim.tv_sec = now.tv_sec;
        np->n_atim.tv_nsec = now.tv_usec * 1000;
-       return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
+       nfs_node_unlock(np);
+       return (VOCALL(fifo_vnodeop_p, VOFFSET(vnop_read), ap));
 }
 
 /*
  * Write wrapper for fifos.
  */
-static int
-nfsfifo_write(ap)
-       struct vop_write_args /* {
-               struct vnode *a_vp;
+int
+nfsfifo_vnop_write(
+       struct vnop_write_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
                struct uio *a_uio;
-               int  a_ioflag;
-               struct ucred *a_cred;
-       } */ *ap;
+               int a_ioflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-        extern vop_t **fifo_vnodeop_p;
-       register struct nfsnode *np = VTONFS(ap->a_vp);
+       nfsnode_t np = VTONFS(ap->a_vp);
        struct timeval now;
+       int error;
 
        /*
         * Set update flag.
         */
+       if ((error = nfs_node_lock(np)))
+               return (error);
        np->n_flag |= NUPD;
        microtime(&now);
        np->n_mtim.tv_sec = now.tv_sec;
        np->n_mtim.tv_nsec = now.tv_usec * 1000;
-       return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
+       nfs_node_unlock(np);
+       return (VOCALL(fifo_vnodeop_p, VOFFSET(vnop_write), ap));
 }
 
 /*
@@ -4192,21 +5953,24 @@ nfsfifo_write(ap)
  *
  * Update the times on the nfsnode then do fifo close.
  */
-static int
-nfsfifo_close(ap)
-       struct vop_close_args /* {
-               struct vnode *a_vp;
-               int  a_fflag;
-               struct ucred *a_cred;
-               struct proc *a_p;
-       } */ *ap;
+int
+nfsfifo_vnop_close(
+       struct vnop_close_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_fflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
-       register struct nfsnode *np = VTONFS(vp);
-       struct vattr vattr;
+       vnode_t vp = ap->a_vp;
+       nfsnode_t np = VTONFS(vp);
+       struct vnode_attr vattr;
        struct timeval now;
-        extern vop_t **fifo_vnodeop_p;
+       mount_t mp;
+       int error;
 
+       if ((error = nfs_node_lock(np)))
+               return (error);
        if (np->n_flag & (NACC | NUPD)) {
                microtime(&now);
                if (np->n_flag & NACC) {
@@ -4218,22 +5982,39 @@ nfsfifo_close(ap)
                        np->n_mtim.tv_nsec = now.tv_usec * 1000;
                }
                np->n_flag |= NCHG;
-               if (vp->v_usecount == 1 && vp->v_mount &&
-                   (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
-                       VATTR_NULL(&vattr);
-                       if (np->n_flag & NACC)
-                               vattr.va_atime = np->n_atim;
-                       if (np->n_flag & NUPD)
-                               vattr.va_mtime = np->n_mtim;
-                       (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
+               if (!vnode_isinuse(vp, 1) && (mp = vnode_mount(vp)) && !vfs_isrdonly(mp)) {
+                       VATTR_INIT(&vattr);
+                       if (np->n_flag & NACC) {
+                               vattr.va_access_time = np->n_atim;
+                               VATTR_SET_ACTIVE(&vattr, va_access_time);
+                       }
+                       if (np->n_flag & NUPD) {
+                               vattr.va_modify_time = np->n_mtim;
+                               VATTR_SET_ACTIVE(&vattr, va_modify_time);
+                       }
+                       nfs_node_unlock(np);
+                       vnode_setattr(vp, &vattr, ap->a_context);
+               } else {
+                       nfs_node_unlock(np);
                }
+       } else {
+               nfs_node_unlock(np);
        }
-       return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
+       return (VOCALL(fifo_vnodeop_p, VOFFSET(vnop_close), ap));
 }
+#endif /* FIFO */
 
-static int
-nfs_ioctl(ap)
-       struct vop_ioctl_args *ap;
+/*ARGSUSED*/
+int
+nfs_vnop_ioctl(
+       __unused struct vnop_ioctl_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               u_int32_t a_command;
+               caddr_t a_data;
+               int a_fflag;
+               vfs_context_t a_context;
+       } */ *ap)
 {
 
        /*
@@ -4243,9 +6024,17 @@ nfs_ioctl(ap)
        return (ENOTTY);
 }
 
-static int
-nfs_select(ap)
-       struct vop_select_args *ap;
+/*ARGSUSED*/
+int
+nfs_vnop_select(
+       __unused struct vnop_select_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               int a_which;
+               int a_fflags;
+               void *a_wql;
+               vfs_context_t a_context;
+       } */ *ap)
 {
 
        /*
@@ -4255,157 +6044,175 @@ nfs_select(ap)
 }
 
 /*
- * Vnode op for pagein using getblk_pages
- * derived from nfs_bioread()
- * No read aheads are started from pagein operation
+ * vnode OP for pagein using UPL
+ *
+ * No buffer I/O, just RPCs straight into the mapped pages.
  */
-static int
-nfs_pagein(ap)
-       struct vop_pagein_args /* {
-               struct vnode *a_vp,
-               upl_t   a_pl,
-               vm_offset_t   a_pl_offset,
-               off_t         a_f_offset,
-               size_t        a_size,
-               struct ucred *a_cred,
-               int           a_flags
-       } */ *ap;
+int
+nfs_vnop_pagein(
+       struct vnop_pagein_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               upl_t a_pl;
+               vm_offset_t a_pl_offset;
+               off_t a_f_offset;
+               size_t a_size;
+               int a_flags;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
+       vnode_t vp = ap->a_vp;
        upl_t pl = ap->a_pl;
-       size_t size= ap->a_size;
+       size_t size = ap->a_size;
        off_t f_offset = ap->a_f_offset;
        vm_offset_t pl_offset = ap->a_pl_offset;
-       int flags  = ap->a_flags;
-       struct ucred *cred;
-       struct nfsnode *np = VTONFS(vp);
-       int biosize, xsize, iosize;
-       struct vattr vattr;
-       struct proc *p = current_proc();
+       int flags = ap->a_flags;
+       thread_t thd;
+       kauth_cred_t cred;
+       nfsnode_t np = VTONFS(vp);
+       size_t nmrsize, iosize, txsize, rxsize, retsize;
+       off_t txoffset;
        struct nfsmount *nmp;
        int error = 0;
-       vm_offset_t ioaddr;
-       struct uio      auio;
-       struct iovec    aiov;
-       struct uio * uio = &auio;
+       vm_offset_t ioaddr, rxaddr;
+       uio_t uio;
+       char uio_buf [ UIO_SIZEOF(1) ];
        int nofreeupl = flags & UPL_NOCOMMIT;
        upl_page_info_t *plinfo;
+#define MAXPAGINGREQS  16      /* max outstanding RPCs for pagein/pageout */
+       struct nfsreq *req[MAXPAGINGREQS];
+       int nextsend, nextwait;
+       uint32_t stategenid = 0, restart = 0;
+       kern_return_t kret;
 
-       FSDBG(322, vp, f_offset, size, flags);
+       FSDBG(322, np, f_offset, size, flags);
        if (pl == (upl_t)NULL)
                panic("nfs_pagein: no upl");
 
-       if (UBCINVALID(vp)) {
-               printf("nfs_pagein: invalid vnode 0x%x", (int)vp);
-               if (!nofreeupl)
-                       (void) ubc_upl_abort(pl, NULL); 
-               return (EPERM);
-       }
-       UBCINFOCHECK("nfs_pagein", vp);
-
        if (size <= 0) {
-               printf("nfs_pagein: invalid size %d", size);
+               printf("nfs_pagein: invalid size %ld", size);
                if (!nofreeupl)
-                       (void) ubc_upl_abort(pl, NULL); 
+                       (void) ubc_upl_abort(pl, 0);
                return (EINVAL);
        }
-       if (f_offset < 0 || f_offset >= np->n_size || (f_offset & PAGE_MASK_64)) {
+       if (f_offset < 0 || f_offset >= (off_t)np->n_size || (f_offset & PAGE_MASK_64)) {
                if (!nofreeupl)
-                       ubc_upl_abort_range(pl, pl_offset, size, 
+                       ubc_upl_abort_range(pl, pl_offset, size,
                                UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
                return (EINVAL);
        }
+
+       thd = vfs_context_thread(ap->a_context);
        cred = ubc_getcred(vp);
-       if (cred == NOCRED)
-               cred = ap->a_cred;
+       if (!IS_VALID_CRED(cred))
+               cred = vfs_context_ucred(ap->a_context);
 
-       auio.uio_offset = f_offset;
-       auio.uio_segflg = UIO_SYSSPACE;
-       auio.uio_rw = UIO_READ;
-       auio.uio_procp = NULL;
+       uio = uio_createwithbuffer(1, f_offset, UIO_SYSSPACE, UIO_READ,
+               &uio_buf, sizeof(uio_buf));
 
-       nmp = VFSTONFS(vp->v_mount);
+       nmp = VTONMP(vp);
        if (!nmp) {
                if (!nofreeupl)
-                       ubc_upl_abort_range(pl, pl_offset, size, 
+                       ubc_upl_abort_range(pl, pl_offset, size,
                                UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
                return (ENXIO);
        }
-       if ((nmp->nm_flag & NFSMNT_NFSV3) && !(nmp->nm_state & NFSSTA_GOTFSINFO))
-               (void)nfs_fsinfo(nmp, vp, cred, p);
-       biosize = vp->v_mount->mnt_stat.f_iosize;
+       nmrsize = nmp->nm_rsize;
 
        plinfo = ubc_upl_pageinfo(pl);
-       ubc_upl_map(pl, &ioaddr);
+       kret = ubc_upl_map(pl, &ioaddr);
+       if (kret != KERN_SUCCESS)
+               panic("nfs_vnop_pagein: ubc_upl_map() failed with (%d)", kret);
        ioaddr += pl_offset;
-       xsize = size;
 
+tryagain:
+       if (nmp->nm_vers >= NFS_VER4)
+               stategenid = nmp->nm_stategenid;
+       txsize = rxsize = size;
+       txoffset = f_offset;
+       rxaddr = ioaddr;
+
+       bzero(req, sizeof(req));
+       nextsend = nextwait = 0;
        do {
-               /*
-                * It would be nice to be able to issue all these requests
-                * in parallel instead of waiting for each one to complete
-                * before sending the next one.
-                * XXX Should we align these requests to block boundaries?
-                */
-               iosize = min(biosize, xsize);
-               uio->uio_resid = iosize;
-               aiov.iov_len  = iosize;
-               aiov.iov_base = (caddr_t)ioaddr;
-               auio.uio_iov = &aiov;
-               auio.uio_iovcnt = 1;
-
-               FSDBG(322, uio->uio_offset, uio->uio_resid, ioaddr, xsize);
-// XXX #warning our nfs_pagein does not support NQNFS
-               /*
-                * With UBC we get here only when the file data is not in the VM
-                * page cache, so go ahead and read in.
-                */
-#ifdef UBC_DEBUG
-               upl_ubc_alias_set(pl, current_act(), 2);
-#endif /* UBC_DEBUG */
-               nfsstats.pageins++;
-
-               error = nfs_readrpc(vp, uio, cred);
-
-               if (!error) {
-                       if (uio->uio_resid) {
-                               /*
-                                * If uio_resid > 0, there is a hole in the file
-                                * and no writes after the hole have been pushed
-                                * to the server yet... or we're at the EOF
-                                * Just zero fill the rest of the valid area.
-                                */
-                               int zcnt = uio->uio_resid;
-                               int zoff = iosize - zcnt;
-                               bzero((char *)ioaddr + zoff, zcnt);
-
-                               FSDBG(324, uio->uio_offset, zoff, zcnt, ioaddr);
-                               uio->uio_offset += zcnt;
+               /* send requests while we need to and have available slots */
+               while ((txsize > 0) && (req[nextsend] == NULL)) {
+                       iosize = MIN(nmrsize, txsize);
+                       if ((error = nmp->nm_funcs->nf_read_rpc_async(np, txoffset, iosize, thd, cred, NULL, &req[nextsend]))) {
+                               req[nextsend] = NULL;
+                               break;
+                       }
+                       txoffset += iosize;
+                       txsize -= iosize;
+                       nextsend = (nextsend + 1) % MAXPAGINGREQS;
+               }
+               /* wait while we need to and break out if more requests to send */
+               while ((rxsize > 0) && req[nextwait]) {
+                       iosize = retsize = MIN(nmrsize, rxsize);
+                       uio_reset(uio, uio_offset(uio), UIO_SYSSPACE, UIO_READ);
+                       uio_addiov(uio, CAST_USER_ADDR_T(rxaddr), iosize);
+                       FSDBG(322, uio_offset(uio), uio_resid(uio), rxaddr, rxsize);
+#if UPL_DEBUG
+                       upl_ubc_alias_set(pl, (uintptr_t) current_thread(), (uintptr_t) 2);
+#endif /* UPL_DEBUG */
+                       OSAddAtomic(1, &nfsstats.pageins);
+                       error = nmp->nm_funcs->nf_read_rpc_async_finish(np, req[nextwait], uio, &retsize, NULL);
+                       req[nextwait] = NULL;
+                       nextwait = (nextwait + 1) % MAXPAGINGREQS;
+                       if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error)) {
+                               lck_mtx_lock(&nmp->nm_lock);
+                               if ((error != NFSERR_GRACE) && (stategenid == nmp->nm_stategenid) && !(nmp->nm_state & NFSSTA_RECOVER)) {
+                                       printf("nfs_vnop_pagein: error %d, initiating recovery\n", error);
+                                       nmp->nm_state |= NFSSTA_RECOVER;
+                                       nfs_mount_sock_thread_wake(nmp);
+                               }
+                               lck_mtx_unlock(&nmp->nm_lock);
+                               if (error == NFSERR_GRACE)
+                                       tsleep(&nmp->nm_state, (PZERO-1), "nfsgrace", 2*hz);
+                               restart++;
+                               goto cancel;
                        }
-                       ioaddr += iosize;       
-                       xsize  -= iosize;
-               } else
-                       FSDBG(322, uio->uio_offset, uio->uio_resid, error, -1);
-
-               nmp = VFSTONFS(vp->v_mount);
-               if (p && (vp->v_flag & VTEXT) && nmp &&
-                   ((nmp->nm_flag & NFSMNT_NQNFS &&
-                     NQNFS_CKINVALID(vp, np, ND_READ) &&
-                     np->n_lrev != np->n_brev) ||
-                    (!(nmp->nm_flag & NFSMNT_NQNFS) &&
-                     np->n_mtime != np->n_vattr.va_mtime.tv_sec))) {
-                       uprintf("Process killed due to text file modification\n");
-                       psignal(p, SIGKILL);
-                       p->p_flag |= P_NOSWAP;
+                       if (error) {
+                               FSDBG(322, uio_offset(uio), uio_resid(uio), error, -1);
+                               break;
+                       }
+                       if (retsize < iosize) {
+                               /* Just zero fill the rest of the valid area. */
+                               int zcnt = iosize - retsize;
+                               bzero((char *)rxaddr + retsize, zcnt);
+                               FSDBG(324, uio_offset(uio), retsize, zcnt, rxaddr);
+                               uio_update(uio, zcnt);
+                       }
+                       rxaddr += iosize;       
+                       rxsize -= iosize;
+                       if (txsize)
+                               break;
                }
+       } while (!error && (txsize || rxsize));
+
+       restart = 0;
 
-       } while (error == 0 && xsize > 0);
+       if (error) {
+cancel:
+               /* cancel any outstanding requests */
+               while (req[nextwait]) {
+                       nfs_request_async_cancel(req[nextwait]);
+                       req[nextwait] = NULL;
+                       nextwait = (nextwait + 1) % MAXPAGINGREQS;
+               }
+               if (restart) {
+                       if ((restart <= nfs_mount_state_max_restarts(nmp)) && /* guard against no progress */
+                           (!(error = nfs_mount_state_wait_for_recovery(nmp))))
+                               goto tryagain;
+                       printf("nfs_pagein: too many restarts, aborting.\n");
+               }
+       }
 
        ubc_upl_unmap(pl);
 
        if (!nofreeupl) {
-               if (error) 
-                       ubc_upl_abort_range(pl, pl_offset, size, 
+               if (error)
+                       ubc_upl_abort_range(pl, pl_offset, size,
                                            UPL_ABORT_ERROR |
                                            UPL_ABORT_FREE_ON_EMPTY);
                else
@@ -4418,60 +6225,180 @@ nfs_pagein(ap)
 
 
 /*
- * Vnode op for pageout using UPL
- * Derived from nfs_write()
+ * the following are needed only by nfs_pageout to know how to handle errors
+ * see nfs_pageout comments on explanation of actions.
+ * the errors here are copied from errno.h and errors returned by servers
+ * are expected to match the same numbers here. If not, our actions maybe
+ * erroneous.
+ */
+char nfs_pageouterrorhandler(int);
+enum actiontype {NOACTION, DUMP, DUMPANDLOG, RETRY, RETRYWITHSLEEP, SEVER};
+#define NFS_ELAST 88
+static u_char errorcount[NFS_ELAST+1]; /* better be zeros when initialized */
+static const char errortooutcome[NFS_ELAST+1] = {
+       NOACTION,
+       DUMP,                   /* EPERM        1       Operation not permitted */
+       DUMP,                   /* ENOENT       2       No such file or directory */
+       DUMPANDLOG,             /* ESRCH        3       No such process */
+       RETRY,                  /* EINTR        4       Interrupted system call */
+       DUMP,                   /* EIO          5       Input/output error */
+       DUMP,                   /* ENXIO        6       Device not configured */
+       DUMPANDLOG,             /* E2BIG        7       Argument list too long */
+       DUMPANDLOG,             /* ENOEXEC      8       Exec format error */
+       DUMPANDLOG,             /* EBADF        9       Bad file descriptor */
+       DUMPANDLOG,             /* ECHILD       10      No child processes */
+       DUMPANDLOG,             /* EDEADLK      11      Resource deadlock avoided - was EAGAIN */
+       RETRY,                  /* ENOMEM       12      Cannot allocate memory */
+       DUMP,                   /* EACCES       13      Permission denied */
+       DUMPANDLOG,             /* EFAULT       14      Bad address */
+       DUMPANDLOG,             /* ENOTBLK      15      POSIX - Block device required */
+       RETRY,                  /* EBUSY        16      Device busy */
+       DUMP,                   /* EEXIST       17      File exists */
+       DUMP,                   /* EXDEV        18      Cross-device link */
+       DUMP,                   /* ENODEV       19      Operation not supported by device */
+       DUMP,                   /* ENOTDIR      20      Not a directory */
+       DUMP,                   /* EISDIR       21      Is a directory */
+       DUMP,                   /* EINVAL       22      Invalid argument */
+       DUMPANDLOG,             /* ENFILE       23      Too many open files in system */
+       DUMPANDLOG,             /* EMFILE       24      Too many open files */
+       DUMPANDLOG,             /* ENOTTY       25      Inappropriate ioctl for device */
+       DUMPANDLOG,             /* ETXTBSY      26      Text file busy - POSIX */
+       DUMP,                   /* EFBIG        27      File too large */
+       DUMP,                   /* ENOSPC       28      No space left on device */
+       DUMPANDLOG,             /* ESPIPE       29      Illegal seek */
+       DUMP,                   /* EROFS        30      Read-only file system */
+       DUMP,                   /* EMLINK       31      Too many links */
+       RETRY,                  /* EPIPE        32      Broken pipe */
+       /* math software */
+       DUMPANDLOG,             /* EDOM                         33      Numerical argument out of domain */
+       DUMPANDLOG,             /* ERANGE                       34      Result too large */
+       RETRY,                  /* EAGAIN/EWOULDBLOCK   35      Resource temporarily unavailable */
+       DUMPANDLOG,             /* EINPROGRESS          36      Operation now in progress */
+       DUMPANDLOG,             /* EALREADY                     37      Operation already in progress */
+       /* ipc/network software -- argument errors */
+       DUMPANDLOG,             /* ENOTSOC                      38      Socket operation on non-socket */
+       DUMPANDLOG,             /* EDESTADDRREQ         39      Destination address required */
+       DUMPANDLOG,             /* EMSGSIZE                     40      Message too long */
+       DUMPANDLOG,             /* EPROTOTYPE           41      Protocol wrong type for socket */
+       DUMPANDLOG,             /* ENOPROTOOPT          42      Protocol not available */
+       DUMPANDLOG,             /* EPROTONOSUPPORT      43      Protocol not supported */
+       DUMPANDLOG,             /* ESOCKTNOSUPPORT      44      Socket type not supported */
+       DUMPANDLOG,             /* ENOTSUP                      45      Operation not supported */
+       DUMPANDLOG,             /* EPFNOSUPPORT         46      Protocol family not supported */
+       DUMPANDLOG,             /* EAFNOSUPPORT         47      Address family not supported by protocol family */
+       DUMPANDLOG,             /* EADDRINUSE           48      Address already in use */
+       DUMPANDLOG,             /* EADDRNOTAVAIL        49      Can't assign requested address */
+       /* ipc/network software -- operational errors */
+       RETRY,                  /* ENETDOWN                     50      Network is down */
+       RETRY,                  /* ENETUNREACH          51      Network is unreachable */
+       RETRY,                  /* ENETRESET            52      Network dropped connection on reset */
+       RETRY,                  /* ECONNABORTED         53      Software caused connection abort */
+       RETRY,                  /* ECONNRESET           54      Connection reset by peer */
+       RETRY,                  /* ENOBUFS                      55      No buffer space available */
+       RETRY,                  /* EISCONN                      56      Socket is already connected */
+       RETRY,                  /* ENOTCONN                     57      Socket is not connected */
+       RETRY,                  /* ESHUTDOWN            58      Can't send after socket shutdown */
+       RETRY,                  /* ETOOMANYREFS         59      Too many references: can't splice */
+       RETRY,                  /* ETIMEDOUT            60      Operation timed out */
+       RETRY,                  /* ECONNREFUSED         61      Connection refused */
+
+       DUMPANDLOG,             /* ELOOP                        62      Too many levels of symbolic links */
+       DUMP,                   /* ENAMETOOLONG         63      File name too long */
+       RETRY,                  /* EHOSTDOWN            64      Host is down */
+       RETRY,                  /* EHOSTUNREACH         65      No route to host */
+       DUMP,                   /* ENOTEMPTY            66      Directory not empty */
+       /* quotas & mush */
+       DUMPANDLOG,             /* PROCLIM                      67      Too many processes */
+       DUMPANDLOG,             /* EUSERS                       68      Too many users */
+       DUMPANDLOG,             /* EDQUOT                       69      Disc quota exceeded */
+       /* Network File System */
+       DUMP,                   /* ESTALE                       70      Stale NFS file handle */
+       DUMP,                   /* EREMOTE                      71      Too many levels of remote in path */
+       DUMPANDLOG,             /* EBADRPC                      72      RPC struct is bad */
+       DUMPANDLOG,             /* ERPCMISMATCH         73      RPC version wrong */
+       DUMPANDLOG,             /* EPROGUNAVAIL         74      RPC prog. not avail */
+       DUMPANDLOG,             /* EPROGMISMATCH        75      Program version wrong */
+       DUMPANDLOG,             /* EPROCUNAVAIL         76      Bad procedure for program */
+
+       DUMPANDLOG,             /* ENOLCK                       77      No locks available */
+       DUMPANDLOG,             /* ENOSYS                       78      Function not implemented */
+       DUMPANDLOG,             /* EFTYPE                       79      Inappropriate file type or format */
+       DUMPANDLOG,             /* EAUTH                        80      Authentication error */
+       DUMPANDLOG,             /* ENEEDAUTH            81      Need authenticator */
+       /* Intelligent device errors */
+       DUMPANDLOG,             /* EPWROFF                      82      Device power is off */
+       DUMPANDLOG,             /* EDEVERR                      83      Device error, e.g. paper out */
+       DUMPANDLOG,             /* EOVERFLOW            84      Value too large to be stored in data type */
+       /* Program loading errors */
+       DUMPANDLOG,             /* EBADEXEC                     85      Bad executable */
+       DUMPANDLOG,             /* EBADARCH                     86      Bad CPU type in executable */
+       DUMPANDLOG,             /* ESHLIBVERS           87      Shared library version mismatch */
+       DUMPANDLOG,             /* EBADMACHO            88      Malformed Macho file */
+};
+
+char
+nfs_pageouterrorhandler(int error)
+{
+       if (error > NFS_ELAST)
+               return(DUMP);
+       else
+               return(errortooutcome[error]);
+}
+
+
+/*
+ * vnode OP for pageout using UPL
+ *
+ * No buffer I/O, just RPCs straight from the mapped pages.
  * File size changes are not permitted in pageout.
  */
-static int
-nfs_pageout(ap)
-       struct vop_pageout_args /* {
-               struct vnode *a_vp,
-               upl_t   a_pl,
-               vm_offset_t   a_pl_offset,
-               off_t         a_f_offset,
-               size_t        a_size,
-               struct ucred *a_cred,
-               int           a_flags
-       } */ *ap;
+int
+nfs_vnop_pageout(
+       struct vnop_pageout_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               upl_t a_pl;
+               vm_offset_t a_pl_offset;
+               off_t a_f_offset;
+               size_t a_size;
+               int a_flags;
+               vfs_context_t a_context;
+       } */ *ap)
 {
-       register struct vnode *vp = ap->a_vp;
+       vnode_t vp = ap->a_vp;
        upl_t pl = ap->a_pl;
-       size_t size= ap->a_size;
+       size_t size = ap->a_size;
        off_t f_offset = ap->a_f_offset;
        vm_offset_t pl_offset = ap->a_pl_offset;
-       int flags  = ap->a_flags;
-       int ioflag = ap->a_flags;
-       struct proc *p = current_proc();
-       struct nfsnode *np = VTONFS(vp);
-       register struct ucred *cred;
+       int flags = ap->a_flags;
+       nfsnode_t np = VTONFS(vp);
+       thread_t thd;
+       kauth_cred_t cred;
        struct nfsbuf *bp;
-       struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-       daddr_t lbn;
-       int n = 0, on, error = 0, iomode, must_commit, s;
-       off_t off;
-       vm_offset_t ioaddr;
-       struct uio      auio;
-       struct iovec    aiov;
+       struct nfsmount *nmp = VTONMP(vp);
+       daddr64_t lbn;
+       int error = 0, iomode;
+       off_t off, txoffset, rxoffset;
+       vm_offset_t ioaddr, txaddr, rxaddr;
+       uio_t auio;
+       char uio_buf [ UIO_SIZEOF(1) ];
        int nofreeupl = flags & UPL_NOCOMMIT;
-       int biosize, iosize, pgsize, xsize;
+       size_t nmwsize, biosize, iosize, pgsize, txsize, rxsize, xsize, remsize;
+       struct nfsreq *req[MAXPAGINGREQS];
+       int nextsend, nextwait, wverfset, commit;
+       uint64_t wverf, wverf2;
+       uint32_t stategenid = 0, vrestart = 0, restart = 0, vrestarts = 0, restarts = 0;
+       kern_return_t kret;
 
        FSDBG(323, f_offset, size, pl, pl_offset);
 
        if (pl == (upl_t)NULL)
                panic("nfs_pageout: no upl");
 
-       if (UBCINVALID(vp)) {
-               printf("nfs_pageout: invalid vnode 0x%x", (int)vp);
-               if (!nofreeupl)
-                       ubc_upl_abort(pl, 0); 
-               return (EIO);
-       }
-       UBCINFOCHECK("nfs_pageout", vp);
-
        if (size <= 0) {
-               printf("nfs_pageout: invalid size %d", size);
+               printf("nfs_pageout: invalid size %ld", size);
                if (!nofreeupl)
-                       ubc_upl_abort(pl, 0); 
+                       ubc_upl_abort(pl, 0);
                return (EINVAL);
        }
 
@@ -4480,7 +6407,10 @@ nfs_pageout(ap)
                        ubc_upl_abort(pl, UPL_ABORT_DUMP_PAGES|UPL_ABORT_FREE_ON_EMPTY);
                return (ENXIO);
        }
-       biosize = vp->v_mount->mnt_stat.f_iosize;
+       biosize = nmp->nm_biosize;
+       nmwsize = nmp->nm_wsize;
+
+       nfs_data_lock_noupdate(np, NFS_DATA_LOCK_SHARED);
 
        /*
         * Check to see whether the buffer is incore.
@@ -4492,20 +6422,22 @@ nfs_pageout(ap)
                xsize = biosize - (off % biosize);
                if (off + xsize > f_offset + size)
                        xsize = f_offset + size - off;
-               lbn = ubc_offtoblk(vp, off);
-               s = splbio();
-               if (bp = nfs_buf_incore(vp, lbn)) {
-                       FSDBG(323, off, 1, bp, bp->nb_flags);
-                       if (ISSET(bp->nb_flags, NB_BUSY)) {
+               lbn = (daddr64_t)(off / biosize);
+               lck_mtx_lock(nfs_buf_mutex);
+               if ((bp = nfs_buf_incore(np, lbn))) {
+                       FSDBG(323, off, bp, bp->nb_lflags, bp->nb_flags);
+                       if (nfs_buf_acquire(bp, NBAC_NOWAIT, 0, 0)) {
+                               lck_mtx_unlock(nfs_buf_mutex);
+                               nfs_data_unlock_noupdate(np);
                                /* no panic. just tell vm we are busy */
                                if (!nofreeupl)
-                                       ubc_upl_abort(pl, 0); 
+                                       ubc_upl_abort(pl, 0);
                                return (EBUSY);
                        }
                        if (bp->nb_dirtyend > 0) {
                                /*
-                                * if there's a dirty range in the buffer, check to
-                                * see if it extends beyond the pageout region
+                                * if there's a dirty range in the buffer, check
+                                * to see if it extends beyond the pageout region
                                 *
                                 * if the dirty region lies completely within the
                                 * pageout region, we just invalidate the buffer
@@ -4523,16 +6455,30 @@ nfs_pageout(ap)
                                start = off;
                                end = off + xsize;
                                /* clip end to EOF */
-                               if (end > np->n_size)
+                               if (end > (off_t)np->n_size)
                                        end = np->n_size;
                                start -= boff;
                                end -= boff;
                                if ((bp->nb_dirtyoff < start) &&
                                    (bp->nb_dirtyend > end)) {
-                                   /* not gonna be able to clip the dirty region */
-                                   FSDBG(323, vp, bp, 0xd00deebc, EBUSY);
+                                   /*
+                                    * not gonna be able to clip the dirty region
+                                    *
+                                    * But before returning the bad news, move the
+                                    * buffer to the start of the delwri list and
+                                    * give the list a push to try to flush the
+                                    * buffer out.
+                                    */
+                                   FSDBG(323, np, bp, 0xd00deebc, EBUSY);
+                                   nfs_buf_remfree(bp);
+                                   TAILQ_INSERT_HEAD(&nfsbufdelwri, bp, nb_free);
+                                   nfsbufdelwricnt++;
+                                   nfs_buf_drop(bp);
+                                   nfs_buf_delwri_push(1);
+                                   lck_mtx_unlock(nfs_buf_mutex);
+                                   nfs_data_unlock_noupdate(np);
                                    if (!nofreeupl)
-                                       ubc_upl_abort(pl, 0); 
+                                       ubc_upl_abort(pl, 0);
                                    return (EBUSY);
                                }
                                if ((bp->nb_dirtyoff < start) ||
@@ -4544,121 +6490,252 @@ nfs_pageout(ap)
                                        bp->nb_dirtyoff = max(bp->nb_dirtyoff, end);
                                    FSDBG(323, bp, bp->nb_dirtyoff, bp->nb_dirtyend, 0xd00dee00);
                                    /* we're leaving this block dirty */
+                                   nfs_buf_drop(bp);
+                                   lck_mtx_unlock(nfs_buf_mutex);
                                    continue;
                                }
                        }
                        nfs_buf_remfree(bp);
-                       SET(bp->nb_flags, (NB_BUSY | NB_INVAL));
+                       lck_mtx_unlock(nfs_buf_mutex);
+                       SET(bp->nb_flags, NB_INVAL);
+                       nfs_node_lock_force(np);
                        if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
                                CLR(bp->nb_flags, NB_NEEDCOMMIT);
                                np->n_needcommitcnt--;
                                CHECK_NEEDCOMMITCNT(np);
                        }
-                       nfs_buf_release(bp);
+                       nfs_node_unlock(np);
+                       nfs_buf_release(bp, 1);
+               } else {
+                       lck_mtx_unlock(nfs_buf_mutex);
                }
-               splx(s);
        }
 
+       thd = vfs_context_thread(ap->a_context);
        cred = ubc_getcred(vp);
-       if (cred == NOCRED)
-               cred = ap->a_cred;
+       if (!IS_VALID_CRED(cred))
+               cred = vfs_context_ucred(ap->a_context);
 
+       nfs_node_lock_force(np);
        if (np->n_flag & NWRITEERR) {
-               np->n_flag &= ~NWRITEERR;
+               error = np->n_error;
+               nfs_node_unlock(np);
+               nfs_data_unlock_noupdate(np);
                if (!nofreeupl)
                        ubc_upl_abort_range(pl, pl_offset, size,
                                            UPL_ABORT_FREE_ON_EMPTY);
-               return (np->n_error);
+               return (error);
        }
-       if ((nmp->nm_flag & NFSMNT_NFSV3) &&
-               !(nmp->nm_state & NFSSTA_GOTFSINFO))
-               (void)nfs_fsinfo(nmp, vp, cred, p);
+       nfs_node_unlock(np);
 
-       if (f_offset < 0 || f_offset >= np->n_size ||
+       if (f_offset < 0 || f_offset >= (off_t)np->n_size ||
            f_offset & PAGE_MASK_64 || size & PAGE_MASK_64) {
+               nfs_data_unlock_noupdate(np);
                if (!nofreeupl)
                        ubc_upl_abort_range(pl, pl_offset, size,
                                            UPL_ABORT_FREE_ON_EMPTY);
                return (EINVAL);
        }
 
-       ubc_upl_map(pl, &ioaddr);
+       kret = ubc_upl_map(pl, &ioaddr);
+       if (kret != KERN_SUCCESS)
+               panic("nfs_vnop_pageout: ubc_upl_map() failed with (%d)", kret);
        ioaddr += pl_offset;
 
-       if (f_offset + size > np->n_size)
+       if ((u_quad_t)f_offset + size > np->n_size)
                xsize = np->n_size - f_offset;
        else
                xsize = size;
 
        pgsize = round_page_64(xsize);
-       if (size > pgsize) {
-               if (!nofreeupl)
-                       ubc_upl_abort_range(pl, pl_offset + pgsize,
-                                           size - pgsize,
-                                           UPL_ABORT_FREE_ON_EMPTY);
-       }
+       if ((size > pgsize) && !nofreeupl)
+               ubc_upl_abort_range(pl, pl_offset + pgsize, size - pgsize,
+                                   UPL_ABORT_FREE_ON_EMPTY);
 
-       /* 
+       /*
         * check for partial page and clear the
         * contents past end of the file before
         * releasing it in the VM page cache
         */
-       if (f_offset < np->n_size && f_offset + size > np->n_size) {
+       if ((u_quad_t)f_offset < np->n_size && (u_quad_t)f_offset + size > np->n_size) {
                size_t io = np->n_size - f_offset;
                bzero((caddr_t)(ioaddr + io), size - io);
                FSDBG(321, np->n_size, f_offset, f_offset + io, size - io);
        }
+       nfs_data_unlock_noupdate(np);
 
-       auio.uio_offset = f_offset;
-       auio.uio_segflg = UIO_SYSSPACE;
-       auio.uio_rw = UIO_READ;
-       auio.uio_procp = NULL;
+       auio = uio_createwithbuffer(1, 0, UIO_SYSSPACE, UIO_WRITE,
+               &uio_buf, sizeof(uio_buf));
 
+tryagain:
+       if (nmp->nm_vers >= NFS_VER4)
+               stategenid = nmp->nm_stategenid;
+       wverf = wverf2 = wverfset = 0;
+       txsize = rxsize = xsize;
+       txoffset = rxoffset = f_offset;
+       txaddr = rxaddr = ioaddr;
+       commit = NFS_WRITE_FILESYNC;
+
+       bzero(req, sizeof(req));
+       nextsend = nextwait = 0;
        do {
-               /*
-                * It would be nice to be able to issue all these requests
-                * in parallel instead of waiting for each one to complete
-                * before sending the next one.
-                * XXX Should we align these requests to block boundaries?
-                */
-               iosize = min(biosize, xsize);
-               auio.uio_resid = iosize;
-               aiov.iov_len = iosize;
-               aiov.iov_base = (caddr_t)ioaddr;
-               auio.uio_iov = &aiov;
-               auio.uio_iovcnt = 1;
-
-               FSDBG(323, auio.uio_offset, auio.uio_resid, ioaddr, xsize);
-// XXX #warning our nfs_pageout does not support NQNFS
-               nfsstats.pageouts++;
-
-               vp->v_numoutput++;
-               /* NMODIFIED would be set here if doing unstable writes */
-               iomode = NFSV3WRITE_FILESYNC;
-               error = nfs_writerpc(vp, &auio, cred, &iomode, &must_commit);
-               if (must_commit)
-                       nfs_clearcommit(vp->v_mount);
-               vpwakeup(vp);
-               if (error)
-                       goto cleanup;
-               /* Note: no need to check uio_resid, because */
-               /* it'll only be set if there was an error. */
-               ioaddr += iosize;
-               xsize -= iosize;
-       } while (xsize > 0);
-
-cleanup:
+               /* send requests while we need to and have available slots */
+               while ((txsize > 0) && (req[nextsend] == NULL)) {
+                       iosize = MIN(nmwsize, txsize);
+                       uio_reset(auio, txoffset, UIO_SYSSPACE, UIO_WRITE);
+                       uio_addiov(auio, CAST_USER_ADDR_T(txaddr), iosize);
+                       FSDBG(323, uio_offset(auio), iosize, txaddr, txsize);
+                       OSAddAtomic(1, &nfsstats.pageouts);
+                       nfs_node_lock_force(np);
+                       np->n_numoutput++;
+                       nfs_node_unlock(np);
+                       vnode_startwrite(vp);
+                       iomode = NFS_WRITE_UNSTABLE;
+                       if ((error = nmp->nm_funcs->nf_write_rpc_async(np, auio, iosize, thd, cred, iomode, NULL, &req[nextsend]))) {
+                               req[nextsend] = NULL;
+                               vnode_writedone(vp);
+                               nfs_node_lock_force(np);
+                               np->n_numoutput--;
+                               nfs_node_unlock(np);
+                               break;
+                       }
+                       txaddr += iosize;
+                       txoffset += iosize;
+                       txsize -= iosize;
+                       nextsend = (nextsend + 1) % MAXPAGINGREQS;
+               }
+               /* wait while we need to and break out if more requests to send */
+               while ((rxsize > 0) && req[nextwait]) {
+                       iosize = remsize = MIN(nmwsize, rxsize);
+                       error = nmp->nm_funcs->nf_write_rpc_async_finish(np, req[nextwait], &iomode, &iosize, &wverf2);
+                       req[nextwait] = NULL;
+                       nextwait = (nextwait + 1) % MAXPAGINGREQS;
+                       vnode_writedone(vp);
+                       nfs_node_lock_force(np);
+                       np->n_numoutput--;
+                       nfs_node_unlock(np);
+                       if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error)) {
+                               lck_mtx_lock(&nmp->nm_lock);
+                               if ((error != NFSERR_GRACE) && (stategenid == nmp->nm_stategenid) && !(nmp->nm_state & NFSSTA_RECOVER)) {
+                                       printf("nfs_vnop_pageout: error %d, initiating recovery\n", error);
+                                       nmp->nm_state |= NFSSTA_RECOVER;
+                                       nfs_mount_sock_thread_wake(nmp);
+                               }
+                               lck_mtx_unlock(&nmp->nm_lock);
+                               if (error == NFSERR_GRACE)
+                                       tsleep(&nmp->nm_state, (PZERO-1), "nfsgrace", 2*hz);
+                               restart = 1;
+                               goto cancel;
+                       }
+                       if (error) {
+                               FSDBG(323, rxoffset, rxsize, error, -1);
+                               break;
+                       }
+                       if (!wverfset) {
+                               wverf = wverf2;
+                               wverfset = 1;
+                       } else if (wverf != wverf2) {
+                               /* verifier changed, so we need to restart all the writes */
+                               vrestart = 1;
+                               goto cancel;
+                       }
+                       /* Retain the lowest commitment level returned. */
+                       if (iomode < commit)
+                               commit = iomode;
+                       rxaddr += iosize;       
+                       rxoffset += iosize;     
+                       rxsize -= iosize;
+                       remsize -= iosize;
+                       if (remsize > 0) {
+                               /* need to try sending the remainder */
+                               iosize = remsize;
+                               uio_reset(auio, rxoffset, UIO_SYSSPACE, UIO_WRITE);
+                               uio_addiov(auio, CAST_USER_ADDR_T(rxaddr), remsize);
+                               iomode = NFS_WRITE_UNSTABLE;
+                               error = nfs_write_rpc2(np, auio, thd, cred, &iomode, &wverf2);
+                               if ((nmp->nm_vers >= NFS_VER4) && nfs_mount_state_error_should_restart(error)) {
+                                       printf("nfs_vnop_pageout: restart: error %d\n", error);
+                                       lck_mtx_lock(&nmp->nm_lock);
+                                       if ((error != NFSERR_GRACE) && (stategenid == nmp->nm_stategenid) && !(nmp->nm_state & NFSSTA_RECOVER)) {
+                                               printf("nfs_vnop_pageout: error %d, initiating recovery\n", error);
+                                               nmp->nm_state |= NFSSTA_RECOVER;
+                                               nfs_mount_sock_thread_wake(nmp);
+                                       }
+                                       lck_mtx_unlock(&nmp->nm_lock);
+                                       if (error == NFSERR_GRACE)
+                                               tsleep(&nmp->nm_state, (PZERO-1), "nfsgrace", 2*hz);
+                                       restart = 1;
+                                       goto cancel;
+                               }
+                               if (error) {
+                                       FSDBG(323, rxoffset, rxsize, error, -1);
+                                       break;
+                               }
+                               if (wverf != wverf2) {
+                                       /* verifier changed, so we need to restart all the writes */
+                                       vrestart = 1;
+                                       goto cancel;
+                               }
+                               if (iomode < commit)
+                                       commit = iomode;
+                               rxaddr += iosize;       
+                               rxoffset += iosize;     
+                               rxsize -= iosize;
+                       }
+                       if (txsize)
+                               break;
+               }
+       } while (!error && (txsize || rxsize));
+
+       vrestart = 0;
+
+       if (!error && (commit != NFS_WRITE_FILESYNC)) {
+               error = nmp->nm_funcs->nf_commit_rpc(np, f_offset, xsize, cred);
+               if (error == NFSERR_STALEWRITEVERF) {
+                       vrestart = 1;
+                       error = EIO;
+               }
+       }
+
+       if (error) {
+cancel:
+               /* cancel any outstanding requests */
+               while (req[nextwait]) {
+                       nfs_request_async_cancel(req[nextwait]);
+                       req[nextwait] = NULL;
+                       nextwait = (nextwait + 1) % MAXPAGINGREQS;
+                       vnode_writedone(vp);
+                       nfs_node_lock_force(np);
+                       np->n_numoutput--;
+                       nfs_node_unlock(np);
+               }
+               if (vrestart) {
+                       if (++vrestarts <= 100) /* guard against no progress */
+                               goto tryagain;
+                       printf("nfs_pageout: too many restarts, aborting.\n");
+                       FSDBG(323, f_offset, xsize, ERESTART, -1);
+               }
+               if (restart) {
+                       if ((restarts <= nfs_mount_state_max_restarts(nmp)) && /* guard against no progress */
+                           (!(error = nfs_mount_state_wait_for_recovery(nmp))))
+                               goto tryagain;
+                       printf("nfs_pageout: too many restarts, aborting.\n");
+                       FSDBG(323, f_offset, xsize, ERESTART, -1);
+               }
+       }
+
        ubc_upl_unmap(pl);
+
        /*
         * We've had several different solutions on what to do when the pageout
-        * gets an error. If we don't handle it, and return an error to the 
-        * caller, vm, it will retry . This can end in endless looping 
+        * gets an error. If we don't handle it, and return an error to the
+        * caller, vm, it will retry . This can end in endless looping
         * between vm and here doing retries of the same page. Doing a dump
         * back to vm, will get it out of vm's knowledge and we lose whatever
         * data existed. This is risky, but in some cases necessary. For
         * example, the initial fix here was to do that for ESTALE. In that case
-        * the server is telling us that the file is no longer the same. We 
-        * would not want to keep paging out to that. We also saw some 151 
+        * the server is telling us that the file is no longer the same. We
+        * would not want to keep paging out to that. We also saw some 151
         * errors from Auspex server and NFSv3 can return errors higher than
         * ELAST. Those along with NFS known server errors we will "dump" from
         * vm.  Errors we don't expect to occur, we dump and log for further
@@ -4672,11 +6749,10 @@ cleanup:
         * have some kind of persistant store when the vm cannot dump nor keep
         * retrying as a solution, but this would be a file architectural change
         */
-         
        if (!nofreeupl) { /* otherwise stacked file system has to handle this */
                if (error) {
-                       int abortflags
-                       short action = nfs_pageouterrorhandler(error);
+                       int abortflags = 0;
+                       char action = nfs_pageouterrorhandler(error);
                        
                        switch (action) {
                                case DUMP:
@@ -4684,10 +6760,11 @@ cleanup:
                                        break;
                                case DUMPANDLOG:
                                        abortflags = UPL_ABORT_DUMP_PAGES|UPL_ABORT_FREE_ON_EMPTY;
-                                       if (error <= ELAST &&
-                                           (errorcount[error] % 100 == 0)) 
-                                               printf("nfs_pageout: unexpected error %d. dumping vm page\n", error);
-                                       errorcount[error]++;
+                                       if (error <= NFS_ELAST) {
+                                               if ((errorcount[error] % 100) == 0)
+                                                       printf("nfs_pageout: unexpected error %d. dumping vm page\n", error);
+                                               errorcount[error]++;
+                                       }
                                        break;
                                case RETRY:
                                        abortflags = UPL_ABORT_FREE_ON_EMPTY;
@@ -4695,78 +6772,68 @@ cleanup:
                                case RETRYWITHSLEEP:
                                        abortflags = UPL_ABORT_FREE_ON_EMPTY;
                                        /* pri unused. PSOCK for placeholder. */
-                                       (void) tsleep(&lbolt, PSOCK,
-                                                     "nfspageout", 0);
+                                       tsleep(&lbolt, PSOCK, "nfspageout", 0);
                                        break;
                                case SEVER: /* not implemented */
                                default:
                                        printf("nfs_pageout: action %d not expected\n", action);
                                        break;
                        }
-                               
-                       ubc_upl_abort_range(pl, pl_offset, size, abortflags);
+
+                       ubc_upl_abort_range(pl, pl_offset, pgsize, abortflags);
                        /* return error in all cases above */
-                       
-               } else 
+
+               } else {
                        ubc_upl_commit_range(pl, pl_offset, pgsize,
                                             UPL_COMMIT_CLEAR_DIRTY |
                                             UPL_COMMIT_FREE_ON_EMPTY);
+               }
        }
        return (error);
 }
 
 /* Blktooff derives file offset given a logical block number */
-static int
-nfs_blktooff(ap)
-       struct vop_blktooff_args /* {
-               struct vnode *a_vp;
-               daddr_t a_lblkno;
-               off_t *a_offset;    
-       } */ *ap;
+int
+nfs_vnop_blktooff(
+       struct vnop_blktooff_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               daddr64_t a_lblkno;
+               off_t *a_offset;
+       } */ *ap)
 {
        int biosize;
-       register struct vnode *vp = ap->a_vp;
+       vnode_t vp = ap->a_vp;
+       struct nfsmount *nmp = VTONMP(vp);
 
-       if (!vp->v_mount)
+       if (!nmp)
                return (ENXIO);
+       biosize = nmp->nm_biosize;
 
-       biosize = vp->v_mount->mnt_stat.f_iosize;
-
-       *ap->a_offset = (off_t)ap->a_lblkno * biosize;
+       *ap->a_offset = (off_t)(ap->a_lblkno * biosize);
 
        return (0);
 }
 
-static int
-nfs_offtoblk(ap)
-       struct vop_offtoblk_args /* {
-               struct vnode *a_vp;
-               off_t a_offset;    
-               daddr_t *a_lblkno;
-       } */ *ap;
+int
+nfs_vnop_offtoblk(
+       struct vnop_offtoblk_args /* {
+               struct vnodeop_desc *a_desc;
+               vnode_t a_vp;
+               off_t a_offset;
+               daddr64_t *a_lblkno;
+       } */ *ap)
 {
        int biosize;
-       register struct vnode *vp = ap->a_vp;
+       vnode_t vp = ap->a_vp;
+       struct nfsmount *nmp = VTONMP(vp);
 
-       if (!vp->v_mount)
+       if (!nmp)
                return (ENXIO);
+       biosize = nmp->nm_biosize;
 
-       biosize = vp->v_mount->mnt_stat.f_iosize;
-
-       *ap->a_lblkno = (daddr_t)(ap->a_offset / biosize);
+       *ap->a_lblkno = (daddr64_t)(ap->a_offset / biosize);
 
        return (0);
 }
-static int
-nfs_cmap(ap)
-       struct vop_cmap_args /* {
-               struct vnode *a_vp;
-               off_t a_offset;    
-               size_t a_size;
-               daddr_t *a_bpn;
-               size_t *a_run;
-               void *a_poff;
-       } */ *ap;
-{
-       return (EOPNOTSUPP);
-}
+