Reintegrate head revisions r273096-r277147

Sponsored by:	The FreeBSD Foundation

8 files changed, 0 insertions, 10112 deletions

diff --git a/sys/nfsclient/nfs_bio.c b/sys/nfsclient/nfs_bio.c
deleted file mode 100644
index 1a5b156..0000000
--- a/sys/nfsclient/nfs_bio.c
+++ /dev/null
@@ -1,1794 +0,0 @@
-/*-
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_bio.c	8.9 (Berkeley) 3/30/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/kernel.h>
-#include <sys/mbuf.h>
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/rwlock.h>
-#include <sys/vmmeter.h>
-#include <sys/vnode.h>
-
-#include <vm/vm.h>
-#include <vm/vm_param.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_page.h>
-#include <vm/vm_object.h>
-#include <vm/vm_pager.h>
-#include <vm/vnode_pager.h>
-
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsmount.h>
-#include <nfsclient/nfsnode.h>
-#include <nfs/nfs_kdtrace.h>
-
-static struct buf *nfs_getcacheblk(struct vnode *vp, daddr_t bn, int size,
-		    struct thread *td);
-static int nfs_directio_write(struct vnode *vp, struct uio *uiop, 
-			      struct ucred *cred, int ioflag);
-
-extern int nfs_directio_enable;
-extern int nfs_directio_allow_mmap;
-
-/*
- * Vnode op for VM getpages.
- */
-int
-nfs_getpages(struct vop_getpages_args *ap)
-{
-	int i, error, nextoff, size, toff, count, npages;
-	struct uio uio;
-	struct iovec iov;
-	vm_offset_t kva;
-	struct buf *bp;
-	struct vnode *vp;
-	struct thread *td;
-	struct ucred *cred;
-	struct nfsmount *nmp;
-	vm_object_t object;
-	vm_page_t *pages;
-	struct nfsnode *np;
-
-	vp = ap->a_vp;
-	np = VTONFS(vp);
-	td = curthread;				/* XXX */
-	cred = curthread->td_ucred;		/* XXX */
-	nmp = VFSTONFS(vp->v_mount);
-	pages = ap->a_m;
-	count = ap->a_count;
-
-	if ((object = vp->v_object) == NULL) {
-		nfs_printf("nfs_getpages: called with non-merged cache vnode??\n");
-		return (VM_PAGER_ERROR);
-	}
-
-	if (nfs_directio_enable && !nfs_directio_allow_mmap) {
-		mtx_lock(&np->n_mtx);
-		if ((np->n_flag & NNONCACHE) && (vp->v_type == VREG)) {
-			mtx_unlock(&np->n_mtx);
-			nfs_printf("nfs_getpages: called on non-cacheable vnode??\n");
-			return (VM_PAGER_ERROR);
-		} else
-			mtx_unlock(&np->n_mtx);
-	}
-
-	mtx_lock(&nmp->nm_mtx);
-	if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
-	    (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {	
-		mtx_unlock(&nmp->nm_mtx);
-		/* We'll never get here for v4, because we always have fsinfo */
-		(void)nfs_fsinfo(nmp, vp, cred, td);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-
-	npages = btoc(count);
-
-	/*
-	 * Since the caller has busied the requested page, that page's valid
-	 * field will not be changed by other threads.
-	 */
-	vm_page_assert_xbusied(pages[ap->a_reqpage]);
-
-	/*
-	 * If the requested page is partially valid, just return it and
-	 * allow the pager to zero-out the blanks.  Partially valid pages
-	 * can only occur at the file EOF.
-	 */
-	if (pages[ap->a_reqpage]->valid != 0) {
-		vm_pager_free_nonreq(object, pages, ap->a_reqpage, npages);
-		return (VM_PAGER_OK);
-	}
-
-	/*
-	 * We use only the kva address for the buffer, but this is extremely
-	 * convienient and fast.
-	 */
-	bp = getpbuf(&nfs_pbuf_freecnt);
-
-	kva = (vm_offset_t) bp->b_data;
-	pmap_qenter(kva, pages, npages);
-	PCPU_INC(cnt.v_vnodein);
-	PCPU_ADD(cnt.v_vnodepgsin, npages);
-
-	iov.iov_base = (caddr_t) kva;
-	iov.iov_len = count;
-	uio.uio_iov = &iov;
-	uio.uio_iovcnt = 1;
-	uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
-	uio.uio_resid = count;
-	uio.uio_segflg = UIO_SYSSPACE;
-	uio.uio_rw = UIO_READ;
-	uio.uio_td = td;
-
-	error = (nmp->nm_rpcops->nr_readrpc)(vp, &uio, cred);
-	pmap_qremove(kva, npages);
-
-	relpbuf(bp, &nfs_pbuf_freecnt);
-
-	if (error && (uio.uio_resid == count)) {
-		nfs_printf("nfs_getpages: error %d\n", error);
-		vm_pager_free_nonreq(object, pages, ap->a_reqpage, npages);
-		return (VM_PAGER_ERROR);
-	}
-
-	/*
-	 * Calculate the number of bytes read and validate only that number
-	 * of bytes.  Note that due to pending writes, size may be 0.  This
-	 * does not mean that the remaining data is invalid!
-	 */
-
-	size = count - uio.uio_resid;
-	VM_OBJECT_WLOCK(object);
-	for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
-		vm_page_t m;
-		nextoff = toff + PAGE_SIZE;
-		m = pages[i];
-
-		if (nextoff <= size) {
-			/*
-			 * Read operation filled an entire page
-			 */
-			m->valid = VM_PAGE_BITS_ALL;
-			KASSERT(m->dirty == 0,
-			    ("nfs_getpages: page %p is dirty", m));
-		} else if (size > toff) {
-			/*
-			 * Read operation filled a partial page.
-			 */
-			m->valid = 0;
-			vm_page_set_valid_range(m, 0, size - toff);
-			KASSERT(m->dirty == 0,
-			    ("nfs_getpages: page %p is dirty", m));
-		} else {
-			/*
-			 * Read operation was short.  If no error
-			 * occured we may have hit a zero-fill
-			 * section.  We leave valid set to 0, and page
-			 * is freed by vm_page_readahead_finish() if
-			 * its index is not equal to requested, or
-			 * page is zeroed and set valid by
-			 * vm_pager_get_pages() for requested page.
-			 */
-			;
-		}
-		if (i != ap->a_reqpage)
-			vm_page_readahead_finish(m);
-	}
-	VM_OBJECT_WUNLOCK(object);
-	return (0);
-}
-
-/*
- * Vnode op for VM putpages.
- */
-int
-nfs_putpages(struct vop_putpages_args *ap)
-{
-	struct uio uio;
-	struct iovec iov;
-	vm_offset_t kva;
-	struct buf *bp;
-	int iomode, must_commit, i, error, npages, count;
-	off_t offset;
-	int *rtvals;
-	struct vnode *vp;
-	struct thread *td;
-	struct ucred *cred;
-	struct nfsmount *nmp;
-	struct nfsnode *np;
-	vm_page_t *pages;
-
-	vp = ap->a_vp;
-	np = VTONFS(vp);
-	td = curthread;				/* XXX */
-	/* Set the cred to n_writecred for the write rpcs. */
-	if (np->n_writecred != NULL)
-		cred = crhold(np->n_writecred);
-	else
-		cred = crhold(curthread->td_ucred);	/* XXX */
-	nmp = VFSTONFS(vp->v_mount);
-	pages = ap->a_m;
-	count = ap->a_count;
-	rtvals = ap->a_rtvals;
-	npages = btoc(count);
-	offset = IDX_TO_OFF(pages[0]->pindex);
-	
-	mtx_lock(&nmp->nm_mtx);
-	if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
-	    (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {
-		mtx_unlock(&nmp->nm_mtx);
-		(void)nfs_fsinfo(nmp, vp, cred, td);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-
-	mtx_lock(&np->n_mtx);
-	if (nfs_directio_enable && !nfs_directio_allow_mmap && 
-	    (np->n_flag & NNONCACHE) && (vp->v_type == VREG)) {
-		mtx_unlock(&np->n_mtx);		
-		nfs_printf("nfs_putpages: called on noncache-able vnode??\n");
-		mtx_lock(&np->n_mtx);
-	}
-
-	for (i = 0; i < npages; i++)
-		rtvals[i] = VM_PAGER_ERROR;
-
-	/*
-	 * When putting pages, do not extend file past EOF.
-	 */
-	if (offset + count > np->n_size) {
-		count = np->n_size - offset;
-		if (count < 0)
-			count = 0;
-	}
-	mtx_unlock(&np->n_mtx);
-
-	/*
-	 * We use only the kva address for the buffer, but this is extremely
-	 * convienient and fast.
-	 */
-	bp = getpbuf(&nfs_pbuf_freecnt);
-
-	kva = (vm_offset_t) bp->b_data;
-	pmap_qenter(kva, pages, npages);
-	PCPU_INC(cnt.v_vnodeout);
-	PCPU_ADD(cnt.v_vnodepgsout, count);
-
-	iov.iov_base = (caddr_t) kva;
-	iov.iov_len = count;
-	uio.uio_iov = &iov;
-	uio.uio_iovcnt = 1;
-	uio.uio_offset = offset;
-	uio.uio_resid = count;
-	uio.uio_segflg = UIO_SYSSPACE;
-	uio.uio_rw = UIO_WRITE;
-	uio.uio_td = td;
-
-	if ((ap->a_sync & VM_PAGER_PUT_SYNC) == 0)
-	    iomode = NFSV3WRITE_UNSTABLE;
-	else
-	    iomode = NFSV3WRITE_FILESYNC;
-
-	error = (nmp->nm_rpcops->nr_writerpc)(vp, &uio, cred, &iomode, &must_commit);
-	crfree(cred);
-
-	pmap_qremove(kva, npages);
-	relpbuf(bp, &nfs_pbuf_freecnt);
-
-	if (!error) {
-		vnode_pager_undirty_pages(pages, rtvals, count - uio.uio_resid);
-		if (must_commit) {
-			nfs_clearcommit(vp->v_mount);
-		}
-	}
-	return rtvals[0];
-}
-
-/*
- * For nfs, cache consistency can only be maintained approximately.
- * Although RFC1094 does not specify the criteria, the following is
- * believed to be compatible with the reference port.
- * For nfs:
- * If the file's modify time on the server has changed since the
- * last read rpc or you have written to the file,
- * you may have lost data cache consistency with the
- * server, so flush all of the file's data out of the cache.
- * Then force a getattr rpc to ensure that you have up to date
- * attributes.
- * NB: This implies that cache data can be read when up to
- * NFS_ATTRTIMEO seconds out of date. If you find that you need current
- * attributes this could be forced by setting n_attrstamp to 0 before
- * the VOP_GETATTR() call.
- */
-static inline int
-nfs_bioread_check_cons(struct vnode *vp, struct thread *td, struct ucred *cred)
-{
-	int error = 0;
-	struct vattr vattr;
-	struct nfsnode *np = VTONFS(vp);
-	int old_lock;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	
-	/*
-	 * Grab the exclusive lock before checking whether the cache is
-	 * consistent.
-	 * XXX - We can make this cheaper later (by acquiring cheaper locks).
-	 * But for now, this suffices.
-	 */
-	old_lock = nfs_upgrade_vnlock(vp);
-	if (vp->v_iflag & VI_DOOMED) {
-		nfs_downgrade_vnlock(vp, old_lock);
-		return (EBADF);
-	}
-		
-	mtx_lock(&np->n_mtx);
-	if (np->n_flag & NMODIFIED) {
-		mtx_unlock(&np->n_mtx);
-		if (vp->v_type != VREG) {
-			if (vp->v_type != VDIR)
-				panic("nfs: bioread, not dir");
-			(nmp->nm_rpcops->nr_invaldir)(vp);
-			error = nfs_vinvalbuf(vp, V_SAVE, td, 1);
-			if (error)
-				goto out;
-		}
-		np->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-		error = VOP_GETATTR(vp, &vattr, cred);
-		if (error)
-			goto out;
-		mtx_lock(&np->n_mtx);
-		np->n_mtime = vattr.va_mtime;
-		mtx_unlock(&np->n_mtx);
-	} else {
-		mtx_unlock(&np->n_mtx);
-		error = VOP_GETATTR(vp, &vattr, cred);
-		if (error)
-			return (error);
-		mtx_lock(&np->n_mtx);
-		if ((np->n_flag & NSIZECHANGED)
-		    || (NFS_TIMESPEC_COMPARE(&np->n_mtime, &vattr.va_mtime))) {
-			mtx_unlock(&np->n_mtx);
-			if (vp->v_type == VDIR)
-				(nmp->nm_rpcops->nr_invaldir)(vp);
-			error = nfs_vinvalbuf(vp, V_SAVE, td, 1);
-			if (error)
-				goto out;
-			mtx_lock(&np->n_mtx);
-			np->n_mtime = vattr.va_mtime;
-			np->n_flag &= ~NSIZECHANGED;
-		}
-		mtx_unlock(&np->n_mtx);
-	}
-out:	
-	nfs_downgrade_vnlock(vp, old_lock);
-	return error;
-}
-
-/*
- * Vnode op for read using bio
- */
-int
-nfs_bioread(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *cred)
-{
-	struct nfsnode *np = VTONFS(vp);
-	int biosize, i;
-	struct buf *bp, *rabp;
-	struct thread *td;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	daddr_t lbn, rabn;
-	off_t end;
-	int bcount;
-	int seqcount;
-	int nra, error = 0, n = 0, on = 0;
-
-	KASSERT(uio->uio_rw == UIO_READ, ("nfs_read mode"));
-	if (uio->uio_resid == 0)
-		return (0);
-	if (uio->uio_offset < 0)	/* XXX VDIR cookies can be negative */
-		return (EINVAL);
-	td = uio->uio_td;
-
-	mtx_lock(&nmp->nm_mtx);
-	if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
-	    (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {
-		mtx_unlock(&nmp->nm_mtx);
-		(void)nfs_fsinfo(nmp, vp, cred, td);
-	} else
-		mtx_unlock(&nmp->nm_mtx);		
-
-	end = uio->uio_offset + uio->uio_resid;
-	if (vp->v_type != VDIR &&
-	    (end > nmp->nm_maxfilesize || end < uio->uio_offset))
-		return (EFBIG);
-
-	if (nfs_directio_enable && (ioflag & IO_DIRECT) && (vp->v_type == VREG))
-		/* No caching/ no readaheads. Just read data into the user buffer */
-		return nfs_readrpc(vp, uio, cred);
-
-	biosize = vp->v_bufobj.bo_bsize;
-	seqcount = (int)((off_t)(ioflag >> IO_SEQSHIFT) * biosize / BKVASIZE);
-	
-	error = nfs_bioread_check_cons(vp, td, cred);
-	if (error)
-		return error;
-
-	do {
-	    u_quad_t nsize;
-			
-	    mtx_lock(&np->n_mtx);
-	    nsize = np->n_size;
-	    mtx_unlock(&np->n_mtx);		    
-
-	    switch (vp->v_type) {
-	    case VREG:
-		nfsstats.biocache_reads++;
-		lbn = uio->uio_offset / biosize;
-		on = uio->uio_offset - (lbn * biosize);
-
-		/*
-		 * Start the read ahead(s), as required.
-		 */
-		if (nmp->nm_readahead > 0) {
-		    for (nra = 0; nra < nmp->nm_readahead && nra < seqcount &&
-			(off_t)(lbn + 1 + nra) * biosize < nsize; nra++) {
-			rabn = lbn + 1 + nra;
-			if (incore(&vp->v_bufobj, rabn) == NULL) {
-			    rabp = nfs_getcacheblk(vp, rabn, biosize, td);
-			    if (!rabp) {
-				error = nfs_sigintr(nmp, td);
-				return (error ? error : EINTR);
-			    }
-			    if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
-				rabp->b_flags |= B_ASYNC;
-				rabp->b_iocmd = BIO_READ;
-				vfs_busy_pages(rabp, 0);
-				if (nfs_asyncio(nmp, rabp, cred, td)) {
-				    rabp->b_flags |= B_INVAL;
-				    rabp->b_ioflags |= BIO_ERROR;
-				    vfs_unbusy_pages(rabp);
-				    brelse(rabp);
-				    break;
-				}
-			    } else {
-				brelse(rabp);
-			    }
-			}
-		    }
-		}
-
-		/* Note that bcount is *not* DEV_BSIZE aligned. */
-		bcount = biosize;
-		if ((off_t)lbn * biosize >= nsize) {
-			bcount = 0;
-		} else if ((off_t)(lbn + 1) * biosize > nsize) {
-			bcount = nsize - (off_t)lbn * biosize;
-		}
-		bp = nfs_getcacheblk(vp, lbn, bcount, td);
-
-		if (!bp) {
-			error = nfs_sigintr(nmp, td);
-			return (error ? error : EINTR);
-		}
-
-		/*
-		 * If B_CACHE is not set, we must issue the read.  If this
-		 * fails, we return an error.
-		 */
-
-		if ((bp->b_flags & B_CACHE) == 0) {
-		    bp->b_iocmd = BIO_READ;
-		    vfs_busy_pages(bp, 0);
-		    error = nfs_doio(vp, bp, cred, td);
-		    if (error) {
-			brelse(bp);
-			return (error);
-		    }
-		}
-
-		/*
-		 * on is the offset into the current bp.  Figure out how many
-		 * bytes we can copy out of the bp.  Note that bcount is
-		 * NOT DEV_BSIZE aligned.
-		 *
-		 * Then figure out how many bytes we can copy into the uio.
-		 */
-
-		n = 0;
-		if (on < bcount)
-			n = MIN((unsigned)(bcount - on), uio->uio_resid);
-		break;
-	    case VLNK:
-		nfsstats.biocache_readlinks++;
-		bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, td);
-		if (!bp) {
-			error = nfs_sigintr(nmp, td);
-			return (error ? error : EINTR);
-		}
-		if ((bp->b_flags & B_CACHE) == 0) {
-		    bp->b_iocmd = BIO_READ;
-		    vfs_busy_pages(bp, 0);
-		    error = nfs_doio(vp, bp, cred, td);
-		    if (error) {
-			bp->b_ioflags |= BIO_ERROR;
-			brelse(bp);
-			return (error);
-		    }
-		}
-		n = MIN(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
-		on = 0;
-		break;
-	    case VDIR:
-		nfsstats.biocache_readdirs++;
-		if (np->n_direofoffset
-		    && uio->uio_offset >= np->n_direofoffset) {
-		    return (0);
-		}
-		lbn = (uoff_t)uio->uio_offset / NFS_DIRBLKSIZ;
-		on = uio->uio_offset & (NFS_DIRBLKSIZ - 1);
-		bp = nfs_getcacheblk(vp, lbn, NFS_DIRBLKSIZ, td);
-		if (!bp) {
-		    error = nfs_sigintr(nmp, td);
-		    return (error ? error : EINTR);
-		}
-		if ((bp->b_flags & B_CACHE) == 0) {
-		    bp->b_iocmd = BIO_READ;
-		    vfs_busy_pages(bp, 0);
-		    error = nfs_doio(vp, bp, cred, td);
-		    if (error) {
-			    brelse(bp);
-		    }
-		    while (error == NFSERR_BAD_COOKIE) {
-			(nmp->nm_rpcops->nr_invaldir)(vp);
-			error = nfs_vinvalbuf(vp, 0, td, 1);
-			/*
-			 * Yuck! The directory has been modified on the
-			 * server. The only way to get the block is by
-			 * reading from the beginning to get all the
-			 * offset cookies.
-			 *
-			 * Leave the last bp intact unless there is an error.
-			 * Loop back up to the while if the error is another
-			 * NFSERR_BAD_COOKIE (double yuch!).
-			 */
-			for (i = 0; i <= lbn && !error; i++) {
-			    if (np->n_direofoffset
-				&& (i * NFS_DIRBLKSIZ) >= np->n_direofoffset)
-				    return (0);
-			    bp = nfs_getcacheblk(vp, i, NFS_DIRBLKSIZ, td);
-			    if (!bp) {
-				error = nfs_sigintr(nmp, td);
-				return (error ? error : EINTR);
-			    }
-			    if ((bp->b_flags & B_CACHE) == 0) {
-				    bp->b_iocmd = BIO_READ;
-				    vfs_busy_pages(bp, 0);
-				    error = nfs_doio(vp, bp, cred, td);
-				    /*
-				     * no error + B_INVAL == directory EOF,
-				     * use the block.
-				     */
-				    if (error == 0 && (bp->b_flags & B_INVAL))
-					    break;
-			    }
-			    /*
-			     * An error will throw away the block and the
-			     * for loop will break out.  If no error and this
-			     * is not the block we want, we throw away the
-			     * block and go for the next one via the for loop.
-			     */
-			    if (error || i < lbn)
-				    brelse(bp);
-			}
-		    }
-		    /*
-		     * The above while is repeated if we hit another cookie
-		     * error.  If we hit an error and it wasn't a cookie error,
-		     * we give up.
-		     */
-		    if (error)
-			    return (error);
-		}
-
-		/*
-		 * If not eof and read aheads are enabled, start one.
-		 * (You need the current block first, so that you have the
-		 *  directory offset cookie of the next block.)
-		 */
-		if (nmp->nm_readahead > 0 &&
-		    (bp->b_flags & B_INVAL) == 0 &&
-		    (np->n_direofoffset == 0 ||
-		    (lbn + 1) * NFS_DIRBLKSIZ < np->n_direofoffset) &&
-		    incore(&vp->v_bufobj, lbn + 1) == NULL) {
-			rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, td);
-			if (rabp) {
-			    if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
-				rabp->b_flags |= B_ASYNC;
-				rabp->b_iocmd = BIO_READ;
-				vfs_busy_pages(rabp, 0);
-				if (nfs_asyncio(nmp, rabp, cred, td)) {
-				    rabp->b_flags |= B_INVAL;
-				    rabp->b_ioflags |= BIO_ERROR;
-				    vfs_unbusy_pages(rabp);
-				    brelse(rabp);
-				}
-			    } else {
-				brelse(rabp);
-			    }
-			}
-		}
-		/*
-		 * Unlike VREG files, whos buffer size ( bp->b_bcount ) is
-		 * chopped for the EOF condition, we cannot tell how large
-		 * NFS directories are going to be until we hit EOF.  So
-		 * an NFS directory buffer is *not* chopped to its EOF.  Now,
-		 * it just so happens that b_resid will effectively chop it
-		 * to EOF.  *BUT* this information is lost if the buffer goes
-		 * away and is reconstituted into a B_CACHE state ( due to
-		 * being VMIO ) later.  So we keep track of the directory eof
-		 * in np->n_direofoffset and chop it off as an extra step
-		 * right here.
-		 */
-		n = lmin(uio->uio_resid, NFS_DIRBLKSIZ - bp->b_resid - on);
-		if (np->n_direofoffset && n > np->n_direofoffset - uio->uio_offset)
-			n = np->n_direofoffset - uio->uio_offset;
-		break;
-	    default:
-		nfs_printf(" nfs_bioread: type %x unexpected\n", vp->v_type);
-		bp = NULL;
-		break;
-	    };
-
-	    if (n > 0) {
-		    error = uiomove(bp->b_data + on, (int)n, uio);
-	    }
-	    if (vp->v_type == VLNK)
-		n = 0;
-	    if (bp != NULL)
-		brelse(bp);
-	} while (error == 0 && uio->uio_resid > 0 && n > 0);
-	return (error);
-}
-
-/*
- * The NFS write path cannot handle iovecs with len > 1. So we need to 
- * break up iovecs accordingly (restricting them to wsize).
- * For the SYNC case, we can do this with 1 copy (user buffer -> mbuf). 
- * For the ASYNC case, 2 copies are needed. The first a copy from the 
- * user buffer to a staging buffer and then a second copy from the staging
- * buffer to mbufs. This can be optimized by copying from the user buffer
- * directly into mbufs and passing the chain down, but that requires a 
- * fair amount of re-working of the relevant codepaths (and can be done
- * later).
- */
-static int
-nfs_directio_write(vp, uiop, cred, ioflag)
-	struct vnode *vp;
-	struct uio *uiop;
-	struct ucred *cred;
-	int ioflag;
-{
-	int error;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	struct thread *td = uiop->uio_td;
-	int size;
-	int wsize;
-	
-	mtx_lock(&nmp->nm_mtx);
-	wsize = nmp->nm_wsize;
-	mtx_unlock(&nmp->nm_mtx);
-	if (ioflag & IO_SYNC) {
-		int iomode, must_commit;
-		struct uio uio;
-		struct iovec iov;
-do_sync:
-		while (uiop->uio_resid > 0) {
-			size = MIN(uiop->uio_resid, wsize);
-			size = MIN(uiop->uio_iov->iov_len, size);
-			iov.iov_base = uiop->uio_iov->iov_base;
-			iov.iov_len = size;
-			uio.uio_iov = &iov;
-			uio.uio_iovcnt = 1;
-			uio.uio_offset = uiop->uio_offset;
-			uio.uio_resid = size;
-			uio.uio_segflg = UIO_USERSPACE;
-			uio.uio_rw = UIO_WRITE;
-			uio.uio_td = td;
-			iomode = NFSV3WRITE_FILESYNC;
-			error = (nmp->nm_rpcops->nr_writerpc)(vp, &uio, cred, 
-						      &iomode, &must_commit);
-			KASSERT((must_commit == 0), 
-				("nfs_directio_write: Did not commit write"));
-			if (error)
-				return (error);
-			uiop->uio_offset += size;
-			uiop->uio_resid -= size;
-			if (uiop->uio_iov->iov_len <= size) {
-				uiop->uio_iovcnt--;
-				uiop->uio_iov++;
-			} else {
-				uiop->uio_iov->iov_base = 
-					(char *)uiop->uio_iov->iov_base + size;
-				uiop->uio_iov->iov_len -= size;
-			}
-		}
-	} else {
-		struct uio *t_uio;
-		struct iovec *t_iov;
-		struct buf *bp;
-		
-		/*
-		 * Break up the write into blocksize chunks and hand these
-		 * over to nfsiod's for write back.
-		 * Unfortunately, this incurs a copy of the data. Since 
-		 * the user could modify the buffer before the write is 
-		 * initiated.
-		 * 
-		 * The obvious optimization here is that one of the 2 copies
-		 * in the async write path can be eliminated by copying the
-		 * data here directly into mbufs and passing the mbuf chain
-		 * down. But that will require a fair amount of re-working
-		 * of the code and can be done if there's enough interest
-		 * in NFS directio access.
-		 */
-		while (uiop->uio_resid > 0) {
-			size = MIN(uiop->uio_resid, wsize);
-			size = MIN(uiop->uio_iov->iov_len, size);
-			bp = getpbuf(&nfs_pbuf_freecnt);
-			t_uio = malloc(sizeof(struct uio), M_NFSDIRECTIO, M_WAITOK);
-			t_iov = malloc(sizeof(struct iovec), M_NFSDIRECTIO, M_WAITOK);
-			t_iov->iov_base = malloc(size, M_NFSDIRECTIO, M_WAITOK);
-			t_iov->iov_len = size;
-			t_uio->uio_iov = t_iov;
-			t_uio->uio_iovcnt = 1;
-			t_uio->uio_offset = uiop->uio_offset;
-			t_uio->uio_resid = size;
-			t_uio->uio_segflg = UIO_SYSSPACE;
-			t_uio->uio_rw = UIO_WRITE;
-			t_uio->uio_td = td;
-			KASSERT(uiop->uio_segflg == UIO_USERSPACE ||
-			    uiop->uio_segflg == UIO_SYSSPACE,
-			    ("nfs_directio_write: Bad uio_segflg"));
-			if (uiop->uio_segflg == UIO_USERSPACE) {
-				error = copyin(uiop->uio_iov->iov_base,
-				    t_iov->iov_base, size);
-				if (error != 0)
-					goto err_free;
-			} else
-				/*
-				 * UIO_SYSSPACE may never happen, but handle
-				 * it just in case it does.
-				 */
-				bcopy(uiop->uio_iov->iov_base, t_iov->iov_base,
-				    size);
-			bp->b_flags |= B_DIRECT;
-			bp->b_iocmd = BIO_WRITE;
-			if (cred != NOCRED) {
-				crhold(cred);
-				bp->b_wcred = cred;
-			} else 
-				bp->b_wcred = NOCRED;			
-			bp->b_caller1 = (void *)t_uio;
-			bp->b_vp = vp;
-			error = nfs_asyncio(nmp, bp, NOCRED, td);
-err_free:
-			if (error) {
-				free(t_iov->iov_base, M_NFSDIRECTIO);
-				free(t_iov, M_NFSDIRECTIO);
-				free(t_uio, M_NFSDIRECTIO);
-				bp->b_vp = NULL;
-				relpbuf(bp, &nfs_pbuf_freecnt);
-				if (error == EINTR)
-					return (error);
-				goto do_sync;
-			}
-			uiop->uio_offset += size;
-			uiop->uio_resid -= size;
-			if (uiop->uio_iov->iov_len <= size) {
-				uiop->uio_iovcnt--;
-				uiop->uio_iov++;
-			} else {
-				uiop->uio_iov->iov_base = 
-					(char *)uiop->uio_iov->iov_base + size;
-				uiop->uio_iov->iov_len -= size;
-			}
-		}
-	}
-	return (0);
-}
-
-/*
- * Vnode op for write using bio
- */
-int
-nfs_write(struct vop_write_args *ap)
-{
-	int biosize;
-	struct uio *uio = ap->a_uio;
-	struct thread *td = uio->uio_td;
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct ucred *cred = ap->a_cred;
-	int ioflag = ap->a_ioflag;
-	struct buf *bp;
-	struct vattr vattr;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	daddr_t lbn;
-	off_t end;
-	int bcount;
-	int n, on, error = 0;
-
-	KASSERT(uio->uio_rw == UIO_WRITE, ("nfs_write mode"));
-	KASSERT(uio->uio_segflg != UIO_USERSPACE || uio->uio_td == curthread,
-	    ("nfs_write proc"));
-	if (vp->v_type != VREG)
-		return (EIO);
-	mtx_lock(&np->n_mtx);
-	if (np->n_flag & NWRITEERR) {
-		np->n_flag &= ~NWRITEERR;
-		mtx_unlock(&np->n_mtx);
-		return (np->n_error);
-	} else
-		mtx_unlock(&np->n_mtx);
-	mtx_lock(&nmp->nm_mtx);
-	if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
-	    (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {
-		mtx_unlock(&nmp->nm_mtx);
-		(void)nfs_fsinfo(nmp, vp, cred, td);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-
-	/*
-	 * Synchronously flush pending buffers if we are in synchronous
-	 * mode or if we are appending.
-	 */
-	if (ioflag & (IO_APPEND | IO_SYNC)) {
-		mtx_lock(&np->n_mtx);
-		if (np->n_flag & NMODIFIED) {
-			mtx_unlock(&np->n_mtx);
-#ifdef notyet /* Needs matching nonblock semantics elsewhere, too. */
-			/*
-			 * Require non-blocking, synchronous writes to
-			 * dirty files to inform the program it needs
-			 * to fsync(2) explicitly.
-			 */
-			if (ioflag & IO_NDELAY)
-				return (EAGAIN);
-#endif
-flush_and_restart:
-			np->n_attrstamp = 0;
-			KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-			error = nfs_vinvalbuf(vp, V_SAVE, td, 1);
-			if (error)
-				return (error);
-		} else
-			mtx_unlock(&np->n_mtx);
-	}
-
-	/*
-	 * If IO_APPEND then load uio_offset.  We restart here if we cannot
-	 * get the append lock.
-	 */
-	if (ioflag & IO_APPEND) {
-		np->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-		error = VOP_GETATTR(vp, &vattr, cred);
-		if (error)
-			return (error);
-		mtx_lock(&np->n_mtx);
-		uio->uio_offset = np->n_size;
-		mtx_unlock(&np->n_mtx);
-	}
-
-	if (uio->uio_offset < 0)
-		return (EINVAL);
-	end = uio->uio_offset + uio->uio_resid;
-	if (end > nmp->nm_maxfilesize || end < uio->uio_offset)
-		return (EFBIG);
-	if (uio->uio_resid == 0)
-		return (0);
-
-	if (nfs_directio_enable && (ioflag & IO_DIRECT) && vp->v_type == VREG)
-		return nfs_directio_write(vp, uio, cred, ioflag);
-
-	/*
-	 * Maybe this should be above the vnode op call, but so long as
-	 * file servers have no limits, i don't think it matters
-	 */
-	if (vn_rlimit_fsize(vp, uio, td))
-		return (EFBIG);
-
-	biosize = vp->v_bufobj.bo_bsize;
-	/*
-	 * Find all of this file's B_NEEDCOMMIT buffers.  If our writes
-	 * would exceed the local maximum per-file write commit size when
-	 * combined with those, we must decide whether to flush,
-	 * go synchronous, or return error.  We don't bother checking
-	 * IO_UNIT -- we just make all writes atomic anyway, as there's
-	 * no point optimizing for something that really won't ever happen.
-	 */
-	if (!(ioflag & IO_SYNC)) {
-		int nflag;
-
-		mtx_lock(&np->n_mtx);
-		nflag = np->n_flag;
-		mtx_unlock(&np->n_mtx);		
-		int needrestart = 0;
-		if (nmp->nm_wcommitsize < uio->uio_resid) {
-			/*
-			 * If this request could not possibly be completed
-			 * without exceeding the maximum outstanding write
-			 * commit size, see if we can convert it into a
-			 * synchronous write operation.
-			 */
-			if (ioflag & IO_NDELAY)
-				return (EAGAIN);
-			ioflag |= IO_SYNC;
-			if (nflag & NMODIFIED)
-				needrestart = 1;
-		} else if (nflag & NMODIFIED) {
-			int wouldcommit = 0;
-			BO_LOCK(&vp->v_bufobj);
-			if (vp->v_bufobj.bo_dirty.bv_cnt != 0) {
-				TAILQ_FOREACH(bp, &vp->v_bufobj.bo_dirty.bv_hd,
-				    b_bobufs) {
-					if (bp->b_flags & B_NEEDCOMMIT)
-						wouldcommit += bp->b_bcount;
-				}
-			}
-			BO_UNLOCK(&vp->v_bufobj);
-			/*
-			 * Since we're not operating synchronously and
-			 * bypassing the buffer cache, we are in a commit
-			 * and holding all of these buffers whether
-			 * transmitted or not.  If not limited, this
-			 * will lead to the buffer cache deadlocking,
-			 * as no one else can flush our uncommitted buffers.
-			 */
-			wouldcommit += uio->uio_resid;
-			/*
-			 * If we would initially exceed the maximum
-			 * outstanding write commit size, flush and restart.
-			 */
-			if (wouldcommit > nmp->nm_wcommitsize)
-				needrestart = 1;
-		}
-		if (needrestart)
-			goto flush_and_restart;
-	}
-
-	do {
-		nfsstats.biocache_writes++;
-		lbn = uio->uio_offset / biosize;
-		on = uio->uio_offset - (lbn * biosize);
-		n = MIN((unsigned)(biosize - on), uio->uio_resid);
-again:
-		/*
-		 * Handle direct append and file extension cases, calculate
-		 * unaligned buffer size.
-		 */
-		mtx_lock(&np->n_mtx);
-		if (uio->uio_offset == np->n_size && n) {
-			mtx_unlock(&np->n_mtx);
-			/*
-			 * Get the buffer (in its pre-append state to maintain
-			 * B_CACHE if it was previously set).  Resize the
-			 * nfsnode after we have locked the buffer to prevent
-			 * readers from reading garbage.
-			 */
-			bcount = on;
-			bp = nfs_getcacheblk(vp, lbn, bcount, td);
-
-			if (bp != NULL) {
-				long save;
-
-				mtx_lock(&np->n_mtx);
-				np->n_size = uio->uio_offset + n;
-				np->n_flag |= NMODIFIED;
-				vnode_pager_setsize(vp, np->n_size);
-				mtx_unlock(&np->n_mtx);
-
-				save = bp->b_flags & B_CACHE;
-				bcount += n;
-				allocbuf(bp, bcount);
-				bp->b_flags |= save;
-			}
-		} else {
-			/*
-			 * Obtain the locked cache block first, and then
-			 * adjust the file's size as appropriate.
-			 */
-			bcount = on + n;
-			if ((off_t)lbn * biosize + bcount < np->n_size) {
-				if ((off_t)(lbn + 1) * biosize < np->n_size)
-					bcount = biosize;
-				else
-					bcount = np->n_size - (off_t)lbn * biosize;
-			}
-			mtx_unlock(&np->n_mtx);
-			bp = nfs_getcacheblk(vp, lbn, bcount, td);
-			mtx_lock(&np->n_mtx);
-			if (uio->uio_offset + n > np->n_size) {
-				np->n_size = uio->uio_offset + n;
-				np->n_flag |= NMODIFIED;
-				vnode_pager_setsize(vp, np->n_size);
-			}
-			mtx_unlock(&np->n_mtx);
-		}
-
-		if (!bp) {
-			error = nfs_sigintr(nmp, td);
-			if (!error)
-				error = EINTR;
-			break;
-		}
-
-		/*
-		 * Issue a READ if B_CACHE is not set.  In special-append
-		 * mode, B_CACHE is based on the buffer prior to the write
-		 * op and is typically set, avoiding the read.  If a read
-		 * is required in special append mode, the server will
-		 * probably send us a short-read since we extended the file
-		 * on our end, resulting in b_resid == 0 and, thusly,
-		 * B_CACHE getting set.
-		 *
-		 * We can also avoid issuing the read if the write covers
-		 * the entire buffer.  We have to make sure the buffer state
-		 * is reasonable in this case since we will not be initiating
-		 * I/O.  See the comments in kern/vfs_bio.c's getblk() for
-		 * more information.
-		 *
-		 * B_CACHE may also be set due to the buffer being cached
-		 * normally.
-		 */
-
-		if (on == 0 && n == bcount) {
-			bp->b_flags |= B_CACHE;
-			bp->b_flags &= ~B_INVAL;
-			bp->b_ioflags &= ~BIO_ERROR;
-		}
-
-		if ((bp->b_flags & B_CACHE) == 0) {
-			bp->b_iocmd = BIO_READ;
-			vfs_busy_pages(bp, 0);
-			error = nfs_doio(vp, bp, cred, td);
-			if (error) {
-				brelse(bp);
-				break;
-			}
-		}
-		if (bp->b_wcred == NOCRED)
-			bp->b_wcred = crhold(cred);
-		mtx_lock(&np->n_mtx);
-		np->n_flag |= NMODIFIED;
-		mtx_unlock(&np->n_mtx);
-
-		/*
-		 * If dirtyend exceeds file size, chop it down.  This should
-		 * not normally occur but there is an append race where it
-		 * might occur XXX, so we log it.
-		 *
-		 * If the chopping creates a reverse-indexed or degenerate
-		 * situation with dirtyoff/end, we 0 both of them.
-		 */
-
-		if (bp->b_dirtyend > bcount) {
-			nfs_printf("NFS append race @%lx:%d\n",
-			    (long)bp->b_blkno * DEV_BSIZE,
-			    bp->b_dirtyend - bcount);
-			bp->b_dirtyend = bcount;
-		}
-
-		if (bp->b_dirtyoff >= bp->b_dirtyend)
-			bp->b_dirtyoff = bp->b_dirtyend = 0;
-
-		/*
-		 * If the new write will leave a contiguous dirty
-		 * area, just update the b_dirtyoff and b_dirtyend,
-		 * otherwise force a write rpc of the old dirty area.
-		 *
-		 * While it is possible to merge discontiguous writes due to
-		 * our having a B_CACHE buffer ( and thus valid read data
-		 * for the hole), we don't because it could lead to
-		 * significant cache coherency problems with multiple clients,
-		 * especially if locking is implemented later on.
-		 *
-		 * as an optimization we could theoretically maintain
-		 * a linked list of discontinuous areas, but we would still
-		 * have to commit them separately so there isn't much
-		 * advantage to it except perhaps a bit of asynchronization.
-		 */
-
-		if (bp->b_dirtyend > 0 &&
-		    (on > bp->b_dirtyend || (on + n) < bp->b_dirtyoff)) {
-			if (bwrite(bp) == EINTR) {
-				error = EINTR;
-				break;
-			}
-			goto again;
-		}
-
-		error = uiomove((char *)bp->b_data + on, n, uio);
-
-		/*
-		 * Since this block is being modified, it must be written
-		 * again and not just committed.  Since write clustering does
-		 * not work for the stage 1 data write, only the stage 2
-		 * commit rpc, we have to clear B_CLUSTEROK as well.
-		 */
-		bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
-
-		if (error) {
-			bp->b_ioflags |= BIO_ERROR;
-			brelse(bp);
-			break;
-		}
-
-		/*
-		 * Only update dirtyoff/dirtyend if not a degenerate
-		 * condition.
-		 */
-		if (n) {
-			if (bp->b_dirtyend > 0) {
-				bp->b_dirtyoff = min(on, bp->b_dirtyoff);
-				bp->b_dirtyend = max((on + n), bp->b_dirtyend);
-			} else {
-				bp->b_dirtyoff = on;
-				bp->b_dirtyend = on + n;
-			}
-			vfs_bio_set_valid(bp, on, n);
-		}
-
-		/*
-		 * If IO_SYNC do bwrite().
-		 *
-		 * IO_INVAL appears to be unused.  The idea appears to be
-		 * to turn off caching in this case.  Very odd.  XXX
-		 */
-		if ((ioflag & IO_SYNC)) {
-			if (ioflag & IO_INVAL)
-				bp->b_flags |= B_NOCACHE;
-			error = bwrite(bp);
-			if (error)
-				break;
-		} else if ((n + on) == biosize) {
-			bp->b_flags |= B_ASYNC;
-			(void) (nmp->nm_rpcops->nr_writebp)(bp, 0, NULL);
-		} else {
-			bdwrite(bp);
-		}
-	} while (uio->uio_resid > 0 && n > 0);
-
-	return (error);
-}
-
-/*
- * Get an nfs cache block.
- *
- * Allocate a new one if the block isn't currently in the cache
- * and return the block marked busy. If the calling process is
- * interrupted by a signal for an interruptible mount point, return
- * NULL.
- *
- * The caller must carefully deal with the possible B_INVAL state of
- * the buffer.  nfs_doio() clears B_INVAL (and nfs_asyncio() clears it
- * indirectly), so synchronous reads can be issued without worrying about
- * the B_INVAL state.  We have to be a little more careful when dealing
- * with writes (see comments in nfs_write()) when extending a file past
- * its EOF.
- */
-static struct buf *
-nfs_getcacheblk(struct vnode *vp, daddr_t bn, int size, struct thread *td)
-{
-	struct buf *bp;
-	struct mount *mp;
-	struct nfsmount *nmp;
-
-	mp = vp->v_mount;
-	nmp = VFSTONFS(mp);
-
-	if (nmp->nm_flag & NFSMNT_INT) {
- 		sigset_t oldset;
-
- 		nfs_set_sigmask(td, &oldset);
-		bp = getblk(vp, bn, size, PCATCH, 0, 0);
- 		nfs_restore_sigmask(td, &oldset);
-		while (bp == NULL) {
-			if (nfs_sigintr(nmp, td))
-				return (NULL);
-			bp = getblk(vp, bn, size, 0, 2 * hz, 0);
-		}
-	} else {
-		bp = getblk(vp, bn, size, 0, 0, 0);
-	}
-
-	if (vp->v_type == VREG)
-		bp->b_blkno = bn * (vp->v_bufobj.bo_bsize / DEV_BSIZE);
-	return (bp);
-}
-
-/*
- * Flush and invalidate all dirty buffers. If another process is already
- * doing the flush, just wait for completion.
- */
-int
-nfs_vinvalbuf(struct vnode *vp, int flags, struct thread *td, int intrflg)
-{
-	struct nfsnode *np = VTONFS(vp);
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	int error = 0, slpflag, slptimeo;
- 	int old_lock = 0;
-
-	ASSERT_VOP_LOCKED(vp, "nfs_vinvalbuf");
-
-	if ((nmp->nm_flag & NFSMNT_INT) == 0)
-		intrflg = 0;
-	if (intrflg) {
-		slpflag = PCATCH;
-		slptimeo = 2 * hz;
-	} else {
-		slpflag = 0;
-		slptimeo = 0;
-	}
-
-	old_lock = nfs_upgrade_vnlock(vp);
-	if (vp->v_iflag & VI_DOOMED) {
-		/*
-		 * Since vgonel() uses the generic vinvalbuf() to flush
-		 * dirty buffers and it does not call this function, it
-		 * is safe to just return OK when VI_DOOMED is set.
-		 */
-		nfs_downgrade_vnlock(vp, old_lock);
-		return (0);
-	}
-
-	/*
-	 * Now, flush as required.
-	 */
-	if ((flags & V_SAVE) && (vp->v_bufobj.bo_object != NULL)) {
-		VM_OBJECT_WLOCK(vp->v_bufobj.bo_object);
-		vm_object_page_clean(vp->v_bufobj.bo_object, 0, 0, OBJPC_SYNC);
-		VM_OBJECT_WUNLOCK(vp->v_bufobj.bo_object);
-		/*
-		 * If the page clean was interrupted, fail the invalidation.
-		 * Not doing so, we run the risk of losing dirty pages in the 
-		 * vinvalbuf() call below.
-		 */
-		if (intrflg && (error = nfs_sigintr(nmp, td)))
-			goto out;
-	}
-
-	error = vinvalbuf(vp, flags, slpflag, 0);
-	while (error) {
-		if (intrflg && (error = nfs_sigintr(nmp, td)))
-			goto out;
-		error = vinvalbuf(vp, flags, 0, slptimeo);
-	}
-	mtx_lock(&np->n_mtx);
-	if (np->n_directio_asyncwr == 0)
-		np->n_flag &= ~NMODIFIED;
-	mtx_unlock(&np->n_mtx);
-out:
-	nfs_downgrade_vnlock(vp, old_lock);
-	return error;
-}
-
-/*
- * Initiate asynchronous I/O. Return an error if no nfsiods are available.
- * This is mainly to avoid queueing async I/O requests when the nfsiods
- * are all hung on a dead server.
- *
- * Note: nfs_asyncio() does not clear (BIO_ERROR|B_INVAL) but when the bp
- * is eventually dequeued by the async daemon, nfs_doio() *will*.
- */
-int
-nfs_asyncio(struct nfsmount *nmp, struct buf *bp, struct ucred *cred, struct thread *td)
-{
-	int iod;
-	int gotiod;
-	int slpflag = 0;
-	int slptimeo = 0;
-	int error, error2;
-
-	/*
-	 * Commits are usually short and sweet so lets save some cpu and
-	 * leave the async daemons for more important rpc's (such as reads
-	 * and writes).
-	 *
-	 * Readdirplus RPCs do vget()s to acquire the vnodes for entries
-	 * in the directory in order to update attributes. This can deadlock
-	 * with another thread that is waiting for async I/O to be done by
-	 * an nfsiod thread while holding a lock on one of these vnodes.
-	 * To avoid this deadlock, don't allow the async nfsiod threads to
-	 * perform Readdirplus RPCs.
-	 */
-	mtx_lock(&nfs_iod_mtx);
-	if ((bp->b_iocmd == BIO_WRITE && (bp->b_flags & B_NEEDCOMMIT) &&
-	     (nmp->nm_bufqiods > nfs_numasync / 2)) ||
-	    (bp->b_vp->v_type == VDIR && (nmp->nm_flag & NFSMNT_RDIRPLUS))) {
-		mtx_unlock(&nfs_iod_mtx);
-		return(EIO);
-	}
-again:
-	if (nmp->nm_flag & NFSMNT_INT)
-		slpflag = PCATCH;
-	gotiod = FALSE;
-
-	/*
-	 * Find a free iod to process this request.
-	 */
-	for (iod = 0; iod < nfs_numasync; iod++)
-		if (nfs_iodwant[iod] == NFSIOD_AVAILABLE) {
-			gotiod = TRUE;
-			break;
-		}
-
-	/*
-	 * Try to create one if none are free.
-	 */
-	if (!gotiod)
-		nfs_nfsiodnew();
-	else {
-		/*
-		 * Found one, so wake it up and tell it which
-		 * mount to process.
-		 */
-		NFS_DPF(ASYNCIO, ("nfs_asyncio: waking iod %d for mount %p\n",
-		    iod, nmp));
-		nfs_iodwant[iod] = NFSIOD_NOT_AVAILABLE;
-		nfs_iodmount[iod] = nmp;
-		nmp->nm_bufqiods++;
-		wakeup(&nfs_iodwant[iod]);
-	}
-
-	/*
-	 * If none are free, we may already have an iod working on this mount
-	 * point.  If so, it will process our request.
-	 */
-	if (!gotiod) {
-		if (nmp->nm_bufqiods > 0) {
-			NFS_DPF(ASYNCIO,
-		("nfs_asyncio: %d iods are already processing mount %p\n",
-				 nmp->nm_bufqiods, nmp));
-			gotiod = TRUE;
-		}
-	}
-
-	/*
-	 * If we have an iod which can process the request, then queue
-	 * the buffer.
-	 */
-	if (gotiod) {
-		/*
-		 * Ensure that the queue never grows too large.  We still want
-		 * to asynchronize so we block rather then return EIO.
-		 */
-		while (nmp->nm_bufqlen >= 2 * nfs_numasync) {
-			NFS_DPF(ASYNCIO,
-		("nfs_asyncio: waiting for mount %p queue to drain\n", nmp));
-			nmp->nm_bufqwant = TRUE;
- 			error = nfs_msleep(td, &nmp->nm_bufq, &nfs_iod_mtx, 
-					   slpflag | PRIBIO,
- 					   "nfsaio", slptimeo);
-			if (error) {
-				error2 = nfs_sigintr(nmp, td);
-				if (error2) {
-					mtx_unlock(&nfs_iod_mtx);
-					return (error2);
-				}
-				if (slpflag == PCATCH) {
-					slpflag = 0;
-					slptimeo = 2 * hz;
-				}
-			}
-			/*
-			 * We might have lost our iod while sleeping,
-			 * so check and loop if nescessary.
-			 */
-			goto again;
-		}
-
-		/* We might have lost our nfsiod */
-		if (nmp->nm_bufqiods == 0) {
-			NFS_DPF(ASYNCIO,
-("nfs_asyncio: no iods after mount %p queue was drained, looping\n", nmp));
-			goto again;
-		}
-
-		if (bp->b_iocmd == BIO_READ) {
-			if (bp->b_rcred == NOCRED && cred != NOCRED)
-				bp->b_rcred = crhold(cred);
-		} else {
-			if (bp->b_wcred == NOCRED && cred != NOCRED)
-				bp->b_wcred = crhold(cred);
-		}
-
-		if (bp->b_flags & B_REMFREE)
-			bremfreef(bp);
-		BUF_KERNPROC(bp);
-		TAILQ_INSERT_TAIL(&nmp->nm_bufq, bp, b_freelist);
-		nmp->nm_bufqlen++;
-		if ((bp->b_flags & B_DIRECT) && bp->b_iocmd == BIO_WRITE) {
-			mtx_lock(&(VTONFS(bp->b_vp))->n_mtx);			
-			VTONFS(bp->b_vp)->n_flag |= NMODIFIED;
-			VTONFS(bp->b_vp)->n_directio_asyncwr++;
-			mtx_unlock(&(VTONFS(bp->b_vp))->n_mtx);
-		}
-		mtx_unlock(&nfs_iod_mtx);
-		return (0);
-	}
-
-	mtx_unlock(&nfs_iod_mtx);
-
-	/*
-	 * All the iods are busy on other mounts, so return EIO to
-	 * force the caller to process the i/o synchronously.
-	 */
-	NFS_DPF(ASYNCIO, ("nfs_asyncio: no iods available, i/o is synchronous\n"));
-	return (EIO);
-}
-
-void
-nfs_doio_directwrite(struct buf *bp)
-{
-	int iomode, must_commit;
-	struct uio *uiop = (struct uio *)bp->b_caller1;
-	char *iov_base = uiop->uio_iov->iov_base;
-	struct nfsmount *nmp = VFSTONFS(bp->b_vp->v_mount);
-	
-	iomode = NFSV3WRITE_FILESYNC;
-	uiop->uio_td = NULL; /* NULL since we're in nfsiod */
-	(nmp->nm_rpcops->nr_writerpc)(bp->b_vp, uiop, bp->b_wcred, &iomode, &must_commit);
-	KASSERT((must_commit == 0), ("nfs_doio_directwrite: Did not commit write"));
-	free(iov_base, M_NFSDIRECTIO);
-	free(uiop->uio_iov, M_NFSDIRECTIO);
-	free(uiop, M_NFSDIRECTIO);
-	if ((bp->b_flags & B_DIRECT) && bp->b_iocmd == BIO_WRITE) {
-		struct nfsnode *np = VTONFS(bp->b_vp);
-		mtx_lock(&np->n_mtx);
-		np->n_directio_asyncwr--;
-		if (np->n_directio_asyncwr == 0) {
-			VTONFS(bp->b_vp)->n_flag &= ~NMODIFIED;
-			if ((np->n_flag & NFSYNCWAIT)) {
-				np->n_flag &= ~NFSYNCWAIT;
-				wakeup((caddr_t)&np->n_directio_asyncwr);
-			}
-		}
-		mtx_unlock(&np->n_mtx);
-	}
-	bp->b_vp = NULL;
-	relpbuf(bp, &nfs_pbuf_freecnt);
-}
-
-/*
- * Do an I/O operation to/from a cache block. This may be called
- * synchronously or from an nfsiod.
- */
-int
-nfs_doio(struct vnode *vp, struct buf *bp, struct ucred *cr, struct thread *td)
-{
-	struct uio *uiop;
-	struct nfsnode *np;
-	struct nfsmount *nmp;
-	int error = 0, iomode, must_commit = 0;
-	struct uio uio;
-	struct iovec io;
-	struct proc *p = td ? td->td_proc : NULL;
-	uint8_t	iocmd;
-	
-	np = VTONFS(vp);
-	nmp = VFSTONFS(vp->v_mount);
-	uiop = &uio;
-	uiop->uio_iov = &io;
-	uiop->uio_iovcnt = 1;
-	uiop->uio_segflg = UIO_SYSSPACE;
-	uiop->uio_td = td;
-
-	/*
-	 * clear BIO_ERROR and B_INVAL state prior to initiating the I/O.  We
-	 * do this here so we do not have to do it in all the code that
-	 * calls us.
-	 */
-	bp->b_flags &= ~B_INVAL;
-	bp->b_ioflags &= ~BIO_ERROR;
-
-	KASSERT(!(bp->b_flags & B_DONE), ("nfs_doio: bp %p already marked done", bp));
-	iocmd = bp->b_iocmd;
-	if (iocmd == BIO_READ) {
-	    io.iov_len = uiop->uio_resid = bp->b_bcount;
-	    io.iov_base = bp->b_data;
-	    uiop->uio_rw = UIO_READ;
-
-	    switch (vp->v_type) {
-	    case VREG:
-		uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
-		nfsstats.read_bios++;
-		error = (nmp->nm_rpcops->nr_readrpc)(vp, uiop, cr);
-
-		if (!error) {
-		    if (uiop->uio_resid) {
-			/*
-			 * If we had a short read with no error, we must have
-			 * hit a file hole.  We should zero-fill the remainder.
-			 * This can also occur if the server hits the file EOF.
-			 *
-			 * Holes used to be able to occur due to pending
-			 * writes, but that is not possible any longer.
-			 */
-			int nread = bp->b_bcount - uiop->uio_resid;
-			int left  = uiop->uio_resid;
-
-			if (left > 0)
-				bzero((char *)bp->b_data + nread, left);
-			uiop->uio_resid = 0;
-		    }
-		}
-		/* ASSERT_VOP_LOCKED(vp, "nfs_doio"); */
-		if (p && (vp->v_vflag & VV_TEXT)) {
-			mtx_lock(&np->n_mtx);
-			if (NFS_TIMESPEC_COMPARE(&np->n_mtime, &np->n_vattr.va_mtime)) {
-				mtx_unlock(&np->n_mtx);
-				PROC_LOCK(p);
-				killproc(p, "text file modification");
-				PROC_UNLOCK(p);
-			} else
-				mtx_unlock(&np->n_mtx);
-		}
-		break;
-	    case VLNK:
-		uiop->uio_offset = (off_t)0;
-		nfsstats.readlink_bios++;
-		error = (nmp->nm_rpcops->nr_readlinkrpc)(vp, uiop, cr);
-		break;
-	    case VDIR:
-		nfsstats.readdir_bios++;
-		uiop->uio_offset = ((u_quad_t)bp->b_lblkno) * NFS_DIRBLKSIZ;
-		if ((nmp->nm_flag & NFSMNT_RDIRPLUS) != 0) {
-			error = nfs_readdirplusrpc(vp, uiop, cr);
-			if (error == NFSERR_NOTSUPP)
-				nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
-		}
-		if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
-			error = nfs_readdirrpc(vp, uiop, cr);
-		/*
-		 * end-of-directory sets B_INVAL but does not generate an
-		 * error.
-		 */
-		if (error == 0 && uiop->uio_resid == bp->b_bcount)
-			bp->b_flags |= B_INVAL;
-		break;
-	    default:
-		nfs_printf("nfs_doio:  type %x unexpected\n", vp->v_type);
-		break;
-	    };
-	    if (error) {
-		bp->b_ioflags |= BIO_ERROR;
-		bp->b_error = error;
-	    }
-	} else {
-	    /*
-	     * If we only need to commit, try to commit
-	     */
-	    if (bp->b_flags & B_NEEDCOMMIT) {
-		    int retv;
-		    off_t off;
-
-		    off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;
-		    retv = (nmp->nm_rpcops->nr_commit)(
-				vp, off, bp->b_dirtyend-bp->b_dirtyoff,
-				bp->b_wcred, td);
-		    if (retv == 0) {
-			    bp->b_dirtyoff = bp->b_dirtyend = 0;
-			    bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
-			    bp->b_resid = 0;
-			    bufdone(bp);
-			    return (0);
-		    }
-		    if (retv == NFSERR_STALEWRITEVERF) {
-			    nfs_clearcommit(vp->v_mount);
-		    }
-	    }
-
-	    /*
-	     * Setup for actual write
-	     */
-	    mtx_lock(&np->n_mtx);
-	    if ((off_t)bp->b_blkno * DEV_BSIZE + bp->b_dirtyend > np->n_size)
-		bp->b_dirtyend = np->n_size - (off_t)bp->b_blkno * DEV_BSIZE;
-	    mtx_unlock(&np->n_mtx);
-
-	    if (bp->b_dirtyend > bp->b_dirtyoff) {
-		io.iov_len = uiop->uio_resid = bp->b_dirtyend
-		    - bp->b_dirtyoff;
-		uiop->uio_offset = (off_t)bp->b_blkno * DEV_BSIZE
-		    + bp->b_dirtyoff;
-		io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
-		uiop->uio_rw = UIO_WRITE;
-		nfsstats.write_bios++;
-
-		if ((bp->b_flags & (B_ASYNC | B_NEEDCOMMIT | B_NOCACHE | B_CLUSTER)) == B_ASYNC)
-		    iomode = NFSV3WRITE_UNSTABLE;
-		else
-		    iomode = NFSV3WRITE_FILESYNC;
-
-		error = (nmp->nm_rpcops->nr_writerpc)(vp, uiop, cr, &iomode, &must_commit);
-
-		/*
-		 * When setting B_NEEDCOMMIT also set B_CLUSTEROK to try
-		 * to cluster the buffers needing commit.  This will allow
-		 * the system to submit a single commit rpc for the whole
-		 * cluster.  We can do this even if the buffer is not 100%
-		 * dirty (relative to the NFS blocksize), so we optimize the
-		 * append-to-file-case.
-		 *
-		 * (when clearing B_NEEDCOMMIT, B_CLUSTEROK must also be
-		 * cleared because write clustering only works for commit
-		 * rpc's, not for the data portion of the write).
-		 */
-
-		if (!error && iomode == NFSV3WRITE_UNSTABLE) {
-		    bp->b_flags |= B_NEEDCOMMIT;
-		    if (bp->b_dirtyoff == 0
-			&& bp->b_dirtyend == bp->b_bcount)
-			bp->b_flags |= B_CLUSTEROK;
-		} else {
-		    bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
-		}
-
-		/*
-		 * For an interrupted write, the buffer is still valid
-		 * and the write hasn't been pushed to the server yet,
-		 * so we can't set BIO_ERROR and report the interruption
-		 * by setting B_EINTR. For the B_ASYNC case, B_EINTR
-		 * is not relevant, so the rpc attempt is essentially
-		 * a noop.  For the case of a V3 write rpc not being
-		 * committed to stable storage, the block is still
-		 * dirty and requires either a commit rpc or another
-		 * write rpc with iomode == NFSV3WRITE_FILESYNC before
-		 * the block is reused. This is indicated by setting
-		 * the B_DELWRI and B_NEEDCOMMIT flags.
-		 *
-		 * If the buffer is marked B_PAGING, it does not reside on
-		 * the vp's paging queues so we cannot call bdirty().  The
-		 * bp in this case is not an NFS cache block so we should
-		 * be safe. XXX
-		 *
-		 * The logic below breaks up errors into recoverable and 
-		 * unrecoverable. For the former, we clear B_INVAL|B_NOCACHE
-		 * and keep the buffer around for potential write retries.
-		 * For the latter (eg ESTALE), we toss the buffer away (B_INVAL)
-		 * and save the error in the nfsnode. This is less than ideal 
-		 * but necessary. Keeping such buffers around could potentially
-		 * cause buffer exhaustion eventually (they can never be written
-		 * out, so will get constantly be re-dirtied). It also causes
-		 * all sorts of vfs panics. For non-recoverable write errors, 
-		 * also invalidate the attrcache, so we'll be forced to go over
-		 * the wire for this object, returning an error to user on next
-		 * call (most of the time).
-		 */
-    		if (error == EINTR || error == EIO || error == ETIMEDOUT
-		    || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
-			int s;
-
-			s = splbio();
-			bp->b_flags &= ~(B_INVAL|B_NOCACHE);
-			if ((bp->b_flags & B_PAGING) == 0) {
-			    bdirty(bp);
-			    bp->b_flags &= ~B_DONE;
-			}
-			if (error && (bp->b_flags & B_ASYNC) == 0)
-			    bp->b_flags |= B_EINTR;
-			splx(s);
-	    	} else {
-		    if (error) {
-			bp->b_ioflags |= BIO_ERROR;
-			bp->b_flags |= B_INVAL;
-			bp->b_error = np->n_error = error;
-			mtx_lock(&np->n_mtx);
-			np->n_flag |= NWRITEERR;
-			np->n_attrstamp = 0;
-			KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-			mtx_unlock(&np->n_mtx);
-		    }
-		    bp->b_dirtyoff = bp->b_dirtyend = 0;
-		}
-	    } else {
-		bp->b_resid = 0;
-		bufdone(bp);
-		return (0);
-	    }
-	}
-	bp->b_resid = uiop->uio_resid;
-	if (must_commit)
-	    nfs_clearcommit(vp->v_mount);
-	bufdone(bp);
-	return (error);
-}
-
-/*
- * Used to aid in handling ftruncate() operations on the NFS client side.
- * Truncation creates a number of special problems for NFS.  We have to
- * throw away VM pages and buffer cache buffers that are beyond EOF, and
- * we have to properly handle VM pages or (potentially dirty) buffers
- * that straddle the truncation point.
- */
-
-int
-nfs_meta_setsize(struct vnode *vp, struct ucred *cred, struct thread *td, u_quad_t nsize)
-{
-	struct nfsnode *np = VTONFS(vp);
-	u_quad_t tsize;
-	int biosize = vp->v_bufobj.bo_bsize;
-	int error = 0;
-
-	mtx_lock(&np->n_mtx);
-	tsize = np->n_size;
-	np->n_size = nsize;
-	mtx_unlock(&np->n_mtx);
-
-	if (nsize < tsize) {
-		struct buf *bp;
-		daddr_t lbn;
-		int bufsize;
-
-		/*
-		 * vtruncbuf() doesn't get the buffer overlapping the 
-		 * truncation point.  We may have a B_DELWRI and/or B_CACHE
-		 * buffer that now needs to be truncated.
-		 */
-		error = vtruncbuf(vp, cred, nsize, biosize);
-		lbn = nsize / biosize;
-		bufsize = nsize - (lbn * biosize);
-		bp = nfs_getcacheblk(vp, lbn, bufsize, td);
- 		if (!bp)
- 			return EINTR;
-		if (bp->b_dirtyoff > bp->b_bcount)
-			bp->b_dirtyoff = bp->b_bcount;
-		if (bp->b_dirtyend > bp->b_bcount)
-			bp->b_dirtyend = bp->b_bcount;
-		bp->b_flags |= B_RELBUF;  /* don't leave garbage around */
-		brelse(bp);
-	} else {
-		vnode_pager_setsize(vp, nsize);
-	}
-	return(error);
-}
-
diff --git a/sys/nfsclient/nfs_kdtrace.c b/sys/nfsclient/nfs_kdtrace.c
deleted file mode 100644
index 429dbc3..0000000
--- a/sys/nfsclient/nfs_kdtrace.c
+++ /dev/null
@@ -1,542 +0,0 @@
-/*-
- * Copyright (c) 2009 Robert N. M. Watson
- * All rights reserved.
- *
- * This software was developed at the University of Cambridge Computer
- * Laboratory with support from a grant from Google, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/conf.h>
-#include <sys/kernel.h>
-#include <sys/malloc.h>
-#include <sys/module.h>
-
-#include <sys/dtrace.h>
-#include <sys/dtrace_bsd.h>
-
-#include <nfs/nfsproto.h>
-
-/*
- * dtnfsclient is a DTrace provider that tracks the intent to perform RPCs
- * in the NFS client, as well as acess to and maintenance of the access and
- * attribute caches.  This is not quite the same as RPCs, because NFS may
- * issue multiple RPC transactions in the event that authentication fails,
- * there's a jukebox error, or none at all if the access or attribute cache
- * hits.  However, it cleanly represents the logical layer between RPC
- * transmission and vnode/vfs operations, providing access to state linking
- * the two.
- */
-
-static int	dtnfsclient_unload(void);
-static void	dtnfsclient_getargdesc(void *, dtrace_id_t, void *,
-		    dtrace_argdesc_t *);
-static void	dtnfsclient_provide(void *, dtrace_probedesc_t *);
-static void	dtnfsclient_destroy(void *, dtrace_id_t, void *);
-static void	dtnfsclient_enable(void *, dtrace_id_t, void *);
-static void	dtnfsclient_disable(void *, dtrace_id_t, void *);
-static void	dtnfsclient_load(void *);
-
-static dtrace_pattr_t dtnfsclient_attr = {
-{ DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
-{ DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
-{ DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
-};
-
-/*
- * Description of NFSv3 and (optional) NFSv2 probes for a procedure.
- */
-struct dtnfsclient_rpc {
-	char		*nr_v3_name;
-	char		*nr_v2_name;	/* Or NULL if none. */
-
-	/*
-	 * IDs for the start and done cases, for both NFSv2 and NFSv3.
-	 */
-	uint32_t	 nr_v2_id_start, nr_v2_id_done;
-	uint32_t	 nr_v3_id_start, nr_v3_id_done;
-};
-
-/*
- * This table is indexed by NFSv3 procedure number, but also used for NFSv2
- * procedure names.
- */
-static struct dtnfsclient_rpc	dtnfsclient_rpcs[NFS_NPROCS] = {
-	{ "null", "null" },
-	{ "getattr", "getattr" },
-	{ "setattr", "setattr" },
-	{ "lookup", "lookup" },
-	{ "access" },
-	{ "readlink", "readlink" },
-	{ "read", "read" },
-	{ "write", "write" },
-	{ "create", "create" },
-	{ "mkdir", "mkdir" },
-	{ "symlink", "symlink" },
-	{ "mknod" },
-	{ "remove", "remove" },
-	{ "rmdir", "rmdir" },
-	{ "rename", "rename" },
-	{ "link", "link" },
-	{ "readdir", "readdir" },
-	{ "readdirplus" },
-	{ "fsstat", "statfs" },
-	{ "fsinfo" },
-	{ "pathconf" },
-	{ "commit" },
-	{ "noop" },
-};
-
-/*
- * Module name strings.
- */
-static char	*dtnfsclient_accesscache_str = "accesscache";
-static char	*dtnfsclient_attrcache_str = "attrcache";
-static char	*dtnfsclient_nfs2_str = "nfs2";
-static char	*dtnfsclient_nfs3_str = "nfs3";
-
-/*
- * Function name strings.
- */
-static char	*dtnfsclient_flush_str = "flush";
-static char	*dtnfsclient_load_str = "load";
-static char	*dtnfsclient_get_str = "get";
-
-/*
- * Name strings.
- */
-static char	*dtnfsclient_done_str = "done";
-static char	*dtnfsclient_hit_str = "hit";
-static char	*dtnfsclient_miss_str = "miss";
-static char	*dtnfsclient_start_str = "start";
-
-static dtrace_pops_t dtnfsclient_pops = {
-	dtnfsclient_provide,
-	NULL,
-	dtnfsclient_enable,
-	dtnfsclient_disable,
-	NULL,
-	NULL,
-	dtnfsclient_getargdesc,
-	NULL,
-	NULL,
-	dtnfsclient_destroy
-};
-
-static dtrace_provider_id_t	dtnfsclient_id;
-
-/*
- * Most probes are generated from the above RPC table, but for access and
- * attribute caches, we have specific IDs we recognize and handle specially
- * in various spots.
- */
-extern uint32_t	nfsclient_accesscache_flush_done_id;
-extern uint32_t	nfsclient_accesscache_get_hit_id;
-extern uint32_t	nfsclient_accesscache_get_miss_id;
-extern uint32_t	nfsclient_accesscache_load_done_id;
-
-extern uint32_t	nfsclient_attrcache_flush_done_id;
-extern uint32_t	nfsclient_attrcache_get_hit_id;
-extern uint32_t	nfsclient_attrcache_get_miss_id;
-extern uint32_t	nfsclient_attrcache_load_done_id;
-
-/*
- * When tracing on a procedure is enabled, the DTrace ID for an RPC event is
- * stored in one of these two NFS client-allocated arrays; 0 indicates that
- * the event is not being traced so probes should not be called.
- *
- * For simplicity, we allocate both v2 and v3 arrays as NFS_NPROCS, and the
- * v2 array is simply sparse.
- */
-extern uint32_t			nfsclient_nfs2_start_probes[NFS_NPROCS];
-extern uint32_t			nfsclient_nfs2_done_probes[NFS_NPROCS];
-
-extern uint32_t			nfsclient_nfs3_start_probes[NFS_NPROCS];
-extern uint32_t			nfsclient_nfs3_done_probes[NFS_NPROCS];
-
-/*
- * Look up a DTrace probe ID to see if it's associated with a "done" event --
- * if so, we will return a fourth argument type of "int".
- */
-static int
-dtnfs23_isdoneprobe(dtrace_id_t id)
-{
-	int i;
-
-	for (i = 0; i < NFS_NPROCS; i++) {
-		if (dtnfsclient_rpcs[i].nr_v3_id_done == id ||
-		    dtnfsclient_rpcs[i].nr_v2_id_done == id)
-			return (1);
-	}
-	return (0);
-}
-
-static void
-dtnfsclient_getargdesc(void *arg, dtrace_id_t id, void *parg,
-    dtrace_argdesc_t *desc)
-{
-	const char *p = NULL;
-
-	if (id == nfsclient_accesscache_flush_done_id ||
-	    id == nfsclient_attrcache_flush_done_id ||
-	    id == nfsclient_attrcache_get_miss_id) {
-		switch (desc->dtargd_ndx) {
-		case 0:
-			p = "struct vnode *";
-			break;
-		default:
-			desc->dtargd_ndx = DTRACE_ARGNONE;
-			break;
-		}
-	} else if (id == nfsclient_accesscache_get_hit_id ||
-	    id == nfsclient_accesscache_get_miss_id) {
-		switch (desc->dtargd_ndx) {
-		case 0:
-			p = "struct vnode *";
-			break;
-		case 1:
-			p = "uid_t";
-			break;
-		case 2:
-			p = "uint32_t";
-			break;
-		default:
-			desc->dtargd_ndx = DTRACE_ARGNONE;
-			break;
-		}
-	} else if (id == nfsclient_accesscache_load_done_id) {
-		switch (desc->dtargd_ndx) {
-		case 0:
-			p = "struct vnode *";
-			break;
-		case 1:
-			p = "uid_t";
-			break;
-		case 2:
-			p = "uint32_t";
-			break;
-		case 3:
-			p = "int";
-			break;
-		default:
-			desc->dtargd_ndx = DTRACE_ARGNONE;
-			break;
-		}
-	} else if (id == nfsclient_attrcache_get_hit_id) {
-		switch (desc->dtargd_ndx) {
-		case 0:
-			p = "struct vnode *";
-			break;
-		case 1:
-			p = "struct vattr *";
-			break;
-		default:
-			desc->dtargd_ndx = DTRACE_ARGNONE;
-			break;
-		}
-	} else if (id == nfsclient_attrcache_load_done_id) {
-		switch (desc->dtargd_ndx) {
-		case 0:
-			p = "struct vnode *";
-			break;
-		case 1:
-			p = "struct vattr *";
-			break;
-		case 2:
-			p = "int";
-			break;
-		default:
-			desc->dtargd_ndx = DTRACE_ARGNONE;
-			break;
-		}
-	} else {
-		switch (desc->dtargd_ndx) {
-		case 0:
-			p = "struct vnode *";
-			break;
-		case 1:
-			p = "struct mbuf *";
-			break;
-		case 2:
-			p = "struct ucred *";
-			break;
-		case 3:
-			p = "int";
-			break;
-		case 4:
-			if (dtnfs23_isdoneprobe(id)) {
-				p = "int";
-				break;
-			}
-			/* FALLSTHROUGH */
-		default:
-			desc->dtargd_ndx = DTRACE_ARGNONE;
-			break;
-		}
-	}
-	if (p != NULL)
-		strlcpy(desc->dtargd_native, p, sizeof(desc->dtargd_native));
-}
-
-static void
-dtnfsclient_provide(void *arg, dtrace_probedesc_t *desc)
-{
-	int i;
-
-	if (desc != NULL)
-		return;
-
-	/*
-	 * Register access cache probes.
-	 */
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
-	    dtnfsclient_flush_str, dtnfsclient_done_str) == 0) {
-		nfsclient_accesscache_flush_done_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_accesscache_str,
-		    dtnfsclient_flush_str, dtnfsclient_done_str, 0, NULL);
-	}
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
-	    dtnfsclient_get_str, dtnfsclient_hit_str) == 0) {
-		nfsclient_accesscache_get_hit_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_accesscache_str,
-		    dtnfsclient_get_str, dtnfsclient_hit_str, 0, NULL);
-	}
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
-	    dtnfsclient_get_str, dtnfsclient_miss_str) == 0) {
-		nfsclient_accesscache_get_miss_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_accesscache_str,
-		    dtnfsclient_get_str, dtnfsclient_miss_str, 0, NULL);
-	}
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
-	    dtnfsclient_load_str, dtnfsclient_done_str) == 0) {
-		nfsclient_accesscache_load_done_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_accesscache_str,
-		    dtnfsclient_load_str, dtnfsclient_done_str, 0, NULL);
-	}
-
-	/*
-	 * Register attribute cache probes.
-	 */
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
-	    dtnfsclient_flush_str, dtnfsclient_done_str) == 0) {
-		nfsclient_attrcache_flush_done_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_attrcache_str,
-		    dtnfsclient_flush_str, dtnfsclient_done_str, 0, NULL);
-	}
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
-	    dtnfsclient_get_str, dtnfsclient_hit_str) == 0) {
-		nfsclient_attrcache_get_hit_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_attrcache_str,
-		    dtnfsclient_get_str, dtnfsclient_hit_str, 0, NULL);
-	}
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
-	    dtnfsclient_get_str, dtnfsclient_miss_str) == 0) {
-		nfsclient_attrcache_get_miss_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_attrcache_str,
-		    dtnfsclient_get_str, dtnfsclient_miss_str, 0, NULL);
-	}
-	if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
-	    dtnfsclient_load_str, dtnfsclient_done_str) == 0) {
-		nfsclient_attrcache_load_done_id = dtrace_probe_create(
-		    dtnfsclient_id, dtnfsclient_attrcache_str,
-		    dtnfsclient_load_str, dtnfsclient_done_str, 0, NULL);
-	}
-
-	/*
-	 * Register NFSv2 RPC procedures; note sparseness check for each slot
-	 * in the NFSv3 procnum-indexed array.
-	 */
-	for (i = 0; i < NFS_NPROCS; i++) {
-		if (dtnfsclient_rpcs[i].nr_v2_name != NULL &&
-		    dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs2_str,
-		    dtnfsclient_rpcs[i].nr_v2_name, dtnfsclient_start_str) ==
-		    0) {
-			dtnfsclient_rpcs[i].nr_v2_id_start =
-			    dtrace_probe_create(dtnfsclient_id,
-			    dtnfsclient_nfs2_str,
-			    dtnfsclient_rpcs[i].nr_v2_name,
-			    dtnfsclient_start_str, 0,
-			    &nfsclient_nfs2_start_probes[i]);
-		}
-		if (dtnfsclient_rpcs[i].nr_v2_name != NULL &&
-		    dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs2_str,
-		    dtnfsclient_rpcs[i].nr_v2_name, dtnfsclient_done_str) ==
-		    0) {
-			dtnfsclient_rpcs[i].nr_v2_id_done = 
-			    dtrace_probe_create(dtnfsclient_id,
-			    dtnfsclient_nfs2_str,
-			    dtnfsclient_rpcs[i].nr_v2_name,
-			    dtnfsclient_done_str, 0,
-			    &nfsclient_nfs2_done_probes[i]);
-		}
-	}
-
-	/*
-	 * Register NFSv3 RPC procedures.
-	 */
-	for (i = 0; i < NFS_NPROCS; i++) {
-		if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs3_str,
-		    dtnfsclient_rpcs[i].nr_v3_name, dtnfsclient_start_str) ==
-		    0) {
-			dtnfsclient_rpcs[i].nr_v3_id_start =
-			    dtrace_probe_create(dtnfsclient_id,
-			    dtnfsclient_nfs3_str,
-			    dtnfsclient_rpcs[i].nr_v3_name,
-			    dtnfsclient_start_str, 0,
-			    &nfsclient_nfs3_start_probes[i]);
-		}
-		if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs3_str,
-		    dtnfsclient_rpcs[i].nr_v3_name, dtnfsclient_done_str) ==
-		    0) {
-			dtnfsclient_rpcs[i].nr_v3_id_done = 
-			    dtrace_probe_create(dtnfsclient_id,
-			    dtnfsclient_nfs3_str,
-			    dtnfsclient_rpcs[i].nr_v3_name,
-			    dtnfsclient_done_str, 0,
-			    &nfsclient_nfs3_done_probes[i]);
-		}
-	}
-}
-
-static void
-dtnfsclient_destroy(void *arg, dtrace_id_t id, void *parg)
-{
-}
-
-static void
-dtnfsclient_enable(void *arg, dtrace_id_t id, void *parg)
-{
-	uint32_t *p = parg;
-	void *f = dtrace_probe;
-
-	if (id == nfsclient_accesscache_flush_done_id)
-		dtrace_nfsclient_accesscache_flush_done_probe = f;
-	else if (id == nfsclient_accesscache_get_hit_id)
-		dtrace_nfsclient_accesscache_get_hit_probe = f;
-	else if (id == nfsclient_accesscache_get_miss_id)
-		dtrace_nfsclient_accesscache_get_miss_probe = f;
-	else if (id == nfsclient_accesscache_load_done_id)
-		dtrace_nfsclient_accesscache_load_done_probe = f;
-	else if (id == nfsclient_attrcache_flush_done_id)
-		dtrace_nfsclient_attrcache_flush_done_probe = f;
-	else if (id == nfsclient_attrcache_get_hit_id)
-		dtrace_nfsclient_attrcache_get_hit_probe = f;
-	else if (id == nfsclient_attrcache_get_miss_id)
-		dtrace_nfsclient_attrcache_get_miss_probe = f;
-	else if (id == nfsclient_attrcache_load_done_id)
-		dtrace_nfsclient_attrcache_load_done_probe = f;
-	else
-		*p = id;
-}
-
-static void
-dtnfsclient_disable(void *arg, dtrace_id_t id, void *parg)
-{
-	uint32_t *p = parg;
-
-	if (id == nfsclient_accesscache_flush_done_id)
-		dtrace_nfsclient_accesscache_flush_done_probe = NULL;
-	else if (id == nfsclient_accesscache_get_hit_id)
-		dtrace_nfsclient_accesscache_get_hit_probe = NULL;
-	else if (id == nfsclient_accesscache_get_miss_id)
-		dtrace_nfsclient_accesscache_get_miss_probe = NULL;
-	else if (id == nfsclient_accesscache_load_done_id)
-		dtrace_nfsclient_accesscache_load_done_probe = NULL;
-	else if (id == nfsclient_attrcache_flush_done_id)
-		dtrace_nfsclient_attrcache_flush_done_probe = NULL;
-	else if (id == nfsclient_attrcache_get_hit_id)
-		dtrace_nfsclient_attrcache_get_hit_probe = NULL;
-	else if (id == nfsclient_attrcache_get_miss_id)
-		dtrace_nfsclient_attrcache_get_miss_probe = NULL;
-	else if (id == nfsclient_attrcache_load_done_id)
-		dtrace_nfsclient_attrcache_load_done_probe = NULL;
-	else
-		*p = 0;
-}
-
-static void
-dtnfsclient_load(void *dummy)
-{
-
-	if (dtrace_register("nfsclient", &dtnfsclient_attr,
-	    DTRACE_PRIV_USER, NULL, &dtnfsclient_pops, NULL,
-	    &dtnfsclient_id) != 0)
-		return;
-
-	dtrace_nfsclient_nfs23_start_probe =
-	    (dtrace_nfsclient_nfs23_start_probe_func_t)dtrace_probe;
-	dtrace_nfsclient_nfs23_done_probe =
-	    (dtrace_nfsclient_nfs23_done_probe_func_t)dtrace_probe;
-}
-
-
-static int
-dtnfsclient_unload()
-{
-
-	dtrace_nfsclient_nfs23_start_probe = NULL;
-	dtrace_nfsclient_nfs23_done_probe = NULL;
-
-	return (dtrace_unregister(dtnfsclient_id));
-}
-
-static int
-dtnfsclient_modevent(module_t mod __unused, int type, void *data __unused)
-{
-	int error = 0;
-
-	switch (type) {
-	case MOD_LOAD:
-		break;
-
-	case MOD_UNLOAD:
-		break;
-
-	case MOD_SHUTDOWN:
-		break;
-
-	default:
-		error = EOPNOTSUPP;
-		break;
-	}
-
-	return (error);
-}
-
-SYSINIT(dtnfsclient_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY,
-    dtnfsclient_load, NULL);
-SYSUNINIT(dtnfsclient_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY,
-    dtnfsclient_unload, NULL);
-
-DEV_MODULE(dtnfsclient, dtnfsclient_modevent, NULL);
-MODULE_VERSION(dtnfsclient, 1);
-MODULE_DEPEND(dtnfsclient, dtrace, 1, 1, 1);
-MODULE_DEPEND(dtnfsclient, opensolaris, 1, 1, 1);
-MODULE_DEPEND(dtnfsclient, oldnfs, 1, 1, 1);
diff --git a/sys/nfsclient/nfs_krpc.c b/sys/nfsclient/nfs_krpc.c
deleted file mode 100644
index f88e47f..0000000
--- a/sys/nfsclient/nfs_krpc.c
+++ /dev/null
@@ -1,887 +0,0 @@
-/*-
- * Copyright (c) 1989, 1991, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_socket.c	8.5 (Berkeley) 3/30/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-/*
- * Socket operations for use by nfs
- */
-
-#include "opt_inet6.h"
-#include "opt_kgssapi.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/limits.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mbuf.h>
-#include <sys/mount.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/signalvar.h>
-#include <sys/syscallsubr.h>
-#include <sys/sysctl.h>
-#include <sys/syslog.h>
-#include <sys/vnode.h>
-
-#include <rpc/rpc.h>
-
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfs/xdr_subs.h>
-#include <nfsclient/nfsm_subs.h>
-#include <nfsclient/nfsmount.h>
-#include <nfsclient/nfsnode.h>
-
-#ifdef KDTRACE_HOOKS
-#include <sys/dtrace_bsd.h>
-
-dtrace_nfsclient_nfs23_start_probe_func_t
-    dtrace_nfsclient_nfs23_start_probe;
-
-dtrace_nfsclient_nfs23_done_probe_func_t
-    dtrace_nfsclient_nfs23_done_probe;
-
-/*
- * Registered probes by RPC type.
- */
-uint32_t	nfsclient_nfs2_start_probes[NFS_NPROCS];
-uint32_t	nfsclient_nfs2_done_probes[NFS_NPROCS];
-
-uint32_t	nfsclient_nfs3_start_probes[NFS_NPROCS];
-uint32_t	nfsclient_nfs3_done_probes[NFS_NPROCS];
-#endif
-
-static int	nfs_bufpackets = 4;
-static int	nfs_reconnects;
-static int	nfs3_jukebox_delay = 10;
-static int	nfs_skip_wcc_data_onerr = 1;
-static int	fake_wchan;
-
-SYSCTL_DECL(_vfs_oldnfs);
-
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, bufpackets, CTLFLAG_RW, &nfs_bufpackets, 0,
-    "Buffer reservation size 2 < x < 64");
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, reconnects, CTLFLAG_RD, &nfs_reconnects, 0,
-    "Number of times the nfs client has had to reconnect");
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs3_jukebox_delay, CTLFLAG_RW,
-    &nfs3_jukebox_delay, 0,
-    "Number of seconds to delay a retry after receiving EJUKEBOX");
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, skip_wcc_data_onerr, CTLFLAG_RW,
-    &nfs_skip_wcc_data_onerr, 0,
-    "Disable weak cache consistency checking when server returns an error");
-
-static void	nfs_down(struct nfsmount *, struct thread *, const char *,
-    int, int);
-static void	nfs_up(struct nfsmount *, struct thread *, const char *,
-    int, int);
-static int	nfs_msg(struct thread *, const char *, const char *, int);
-
-extern int nfsv2_procid[];
-
-struct nfs_cached_auth {
-	int		ca_refs; /* refcount, including 1 from the cache */
-	uid_t		ca_uid;	 /* uid that corresponds to this auth */
-	AUTH		*ca_auth; /* RPC auth handle */
-};
-
-/*
- * RTT estimator
- */
-
-static enum nfs_rto_timer_t nfs_proct[NFS_NPROCS] = {
-	NFS_DEFAULT_TIMER,	/* NULL */
-	NFS_GETATTR_TIMER,	/* GETATTR */
-	NFS_DEFAULT_TIMER,	/* SETATTR */
-	NFS_LOOKUP_TIMER,	/* LOOKUP */
-	NFS_GETATTR_TIMER,	/* ACCESS */
-	NFS_READ_TIMER,		/* READLINK */
-	NFS_READ_TIMER,		/* READ */
-	NFS_WRITE_TIMER,	/* WRITE */
-	NFS_DEFAULT_TIMER,	/* CREATE */
-	NFS_DEFAULT_TIMER,	/* MKDIR */
-	NFS_DEFAULT_TIMER,	/* SYMLINK */
-	NFS_DEFAULT_TIMER,	/* MKNOD */
-	NFS_DEFAULT_TIMER,	/* REMOVE */
-	NFS_DEFAULT_TIMER,	/* RMDIR */
-	NFS_DEFAULT_TIMER,	/* RENAME */
-	NFS_DEFAULT_TIMER,	/* LINK */
-	NFS_READ_TIMER,		/* READDIR */
-	NFS_READ_TIMER,		/* READDIRPLUS */
-	NFS_DEFAULT_TIMER,	/* FSSTAT */
-	NFS_DEFAULT_TIMER,	/* FSINFO */
-	NFS_DEFAULT_TIMER,	/* PATHCONF */
-	NFS_DEFAULT_TIMER,	/* COMMIT */
-	NFS_DEFAULT_TIMER,	/* NOOP */
-};
-
-/*
- * Choose the correct RTT timer for this NFS procedure.
- */
-static inline enum nfs_rto_timer_t
-nfs_rto_timer(u_int32_t procnum)
-{
-
-	return (nfs_proct[procnum]);
-}
-
-/*
- * Initialize the RTT estimator state for a new mount point.
- */
-static void
-nfs_init_rtt(struct nfsmount *nmp)
-{
-	int i;
-
-	for (i = 0; i < NFS_MAX_TIMER; i++) {
-		nmp->nm_timers[i].rt_srtt = hz;
-		nmp->nm_timers[i].rt_deviate = 0;
-		nmp->nm_timers[i].rt_rtxcur = hz;
-	}
-}
-
-/*
- * Initialize sockets and congestion for a new NFS connection.
- * We do not free the sockaddr if error.
- */
-int
-nfs_connect(struct nfsmount *nmp)
-{
-	int rcvreserve, sndreserve;
-	int pktscale;
-	struct sockaddr *saddr;
-	struct ucred *origcred;
-	struct thread *td = curthread;
-	CLIENT *client;
-	struct netconfig *nconf;
-	rpcvers_t vers;
-	int one = 1, retries;
-	struct timeval timo;
-
-	/*
-	 * We need to establish the socket using the credentials of
-	 * the mountpoint.  Some parts of this process (such as
-	 * sobind() and soconnect()) will use the curent thread's
-	 * credential instead of the socket credential.  To work
-	 * around this, temporarily change the current thread's
-	 * credential to that of the mountpoint.
-	 *
-	 * XXX: It would be better to explicitly pass the correct
-	 * credential to sobind() and soconnect().
-	 */
-	origcred = td->td_ucred;
-	td->td_ucred = nmp->nm_mountp->mnt_cred;
-	saddr = nmp->nm_nam;
-
-	vers = NFS_VER2;
-	if (nmp->nm_flag & NFSMNT_NFSV3)
-		vers = NFS_VER3;
-	else if (nmp->nm_flag & NFSMNT_NFSV4)
-		vers = NFS_VER4;
-	if (saddr->sa_family == AF_INET)
-		if (nmp->nm_sotype == SOCK_DGRAM)
-			nconf = getnetconfigent("udp");
-		else
-			nconf = getnetconfigent("tcp");
-	else
-		if (nmp->nm_sotype == SOCK_DGRAM)
-			nconf = getnetconfigent("udp6");
-		else
-			nconf = getnetconfigent("tcp6");
-
-	/*
-	 * Get buffer reservation size from sysctl, but impose reasonable
-	 * limits.
-	 */
-	pktscale = nfs_bufpackets;
-	if (pktscale < 2)
-		pktscale = 2;
-	if (pktscale > 64)
-		pktscale = 64;
-	mtx_lock(&nmp->nm_mtx);
-	if (nmp->nm_sotype == SOCK_DGRAM) {
-		sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * pktscale;
-		rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize) +
-		    NFS_MAXPKTHDR) * pktscale;
-	} else if (nmp->nm_sotype == SOCK_SEQPACKET) {
-		sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR) * pktscale;
-		rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize) +
-		    NFS_MAXPKTHDR) * pktscale;
-	} else {
-		if (nmp->nm_sotype != SOCK_STREAM)
-			panic("nfscon sotype");
-		sndreserve = (nmp->nm_wsize + NFS_MAXPKTHDR +
-		    sizeof (u_int32_t)) * pktscale;
-		rcvreserve = (nmp->nm_rsize + NFS_MAXPKTHDR +
-		    sizeof (u_int32_t)) * pktscale;
-	}
-	mtx_unlock(&nmp->nm_mtx);
-
-	client = clnt_reconnect_create(nconf, saddr, NFS_PROG, vers,
-	    sndreserve, rcvreserve);
-	CLNT_CONTROL(client, CLSET_WAITCHAN, "nfsreq");
-	if (nmp->nm_flag & NFSMNT_INT)
-		CLNT_CONTROL(client, CLSET_INTERRUPTIBLE, &one);
-	if (nmp->nm_flag & NFSMNT_RESVPORT)
-		CLNT_CONTROL(client, CLSET_PRIVPORT, &one);
-	if ((nmp->nm_flag & NFSMNT_SOFT) != 0) {
-		if (nmp->nm_sotype == SOCK_DGRAM)
-			/*
-			 * For UDP, the large timeout for a reconnect will
-			 * be set to "nm_retry * nm_timeo / 2", so we only
-			 * want to do 2 reconnect timeout retries.
-			 */
-			retries = 2;
-		else
-			retries = nmp->nm_retry;
-	} else
-		retries = INT_MAX;
-	CLNT_CONTROL(client, CLSET_RETRIES, &retries);
-
-	/*
-	 * For UDP, there are 2 timeouts:
-	 * - CLSET_RETRY_TIMEOUT sets the initial timeout for the timer
-	 *   that does a retransmit of an RPC request using the same socket
-	 *   and xid. This is what you normally want to do, since NFS
-	 *   servers depend on "same xid" for their Duplicate Request Cache.
-	 * - timeout specified in CLNT_CALL_MBUF(), which specifies when
-	 *   retransmits on the same socket should fail and a fresh socket
-	 *   created. Each of these timeouts counts as one CLSET_RETRIES,
-	 *   as set above.
-	 * Set the initial retransmit timeout for UDP. This timeout doesn't
-	 * exist for TCP and the following call just fails, which is ok.
-	 */
-	timo.tv_sec = nmp->nm_timeo / NFS_HZ;
-	timo.tv_usec = (nmp->nm_timeo % NFS_HZ) * 1000000 / NFS_HZ;
-	CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, &timo);
-
-	mtx_lock(&nmp->nm_mtx);
-	if (nmp->nm_client) {
-		/*
-		 * Someone else already connected.
-		 */
-		CLNT_RELEASE(client);
-	} else
-		nmp->nm_client = client;
-
-	/*
-	 * Protocols that do not require connections may be optionally left
-	 * unconnected for servers that reply from a port other than NFS_PORT.
-	 */
-	if (!(nmp->nm_flag & NFSMNT_NOCONN)) {
-		mtx_unlock(&nmp->nm_mtx);
-		CLNT_CONTROL(client, CLSET_CONNECT, &one);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-
-	/* Restore current thread's credentials. */
-	td->td_ucred = origcred;
-
-	mtx_lock(&nmp->nm_mtx);
-	/* Initialize other non-zero congestion variables. */
-	nfs_init_rtt(nmp);
-	mtx_unlock(&nmp->nm_mtx);
-	return (0);
-}
-
-/*
- * NFS disconnect.  Clean up and unlink.
- */
-void
-nfs_disconnect(struct nfsmount *nmp)
-{
-	CLIENT *client;
-
-	mtx_lock(&nmp->nm_mtx);
-	if (nmp->nm_client) {
-		client = nmp->nm_client;
-		nmp->nm_client = NULL;
-		mtx_unlock(&nmp->nm_mtx);
-		rpc_gss_secpurge_call(client);
-		CLNT_CLOSE(client);
-		CLNT_RELEASE(client);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-}
-
-void
-nfs_safedisconnect(struct nfsmount *nmp)
-{
-
-	nfs_disconnect(nmp);
-}
-
-static AUTH *
-nfs_getauth(struct nfsmount *nmp, struct ucred *cred)
-{
-	rpc_gss_service_t svc;
-	AUTH *auth;
-
-	switch (nmp->nm_secflavor) {
-	case RPCSEC_GSS_KRB5:
-	case RPCSEC_GSS_KRB5I:
-	case RPCSEC_GSS_KRB5P:
-		if (!nmp->nm_mech_oid)
-			if (!rpc_gss_mech_to_oid_call("kerberosv5",
-			    &nmp->nm_mech_oid))
-				return (NULL);
-		if (nmp->nm_secflavor == RPCSEC_GSS_KRB5)
-			svc = rpc_gss_svc_none;
-		else if (nmp->nm_secflavor == RPCSEC_GSS_KRB5I)
-			svc = rpc_gss_svc_integrity;
-		else
-			svc = rpc_gss_svc_privacy;
-		auth = rpc_gss_secfind_call(nmp->nm_client, cred,
-		    nmp->nm_principal, nmp->nm_mech_oid, svc);
-		if (auth)
-			return (auth);
-		/* fallthrough */
-	case AUTH_SYS:
-	default:
-		return (authunix_create(cred));
-
-	}
-}
-
-/*
- * Callback from the RPC code to generate up/down notifications.
- */
-
-struct nfs_feedback_arg {
-	struct nfsmount *nf_mount;
-	int		nf_lastmsg;	/* last tprintf */
-	int		nf_tprintfmsg;
-	struct thread	*nf_td;
-};
-
-static void
-nfs_feedback(int type, int proc, void *arg)
-{
-	struct nfs_feedback_arg *nf = (struct nfs_feedback_arg *) arg;
-	struct nfsmount *nmp = nf->nf_mount;
-	time_t now;
-
-	switch (type) {
-	case FEEDBACK_REXMIT2:
-	case FEEDBACK_RECONNECT:
-		now = time_uptime;
-		if (nf->nf_lastmsg + nmp->nm_tprintf_delay < now) {
-			nfs_down(nmp, nf->nf_td,
-			    "not responding", 0, NFSSTA_TIMEO);
-			nf->nf_tprintfmsg = TRUE;
-			nf->nf_lastmsg = now;
-		}
-		break;
-
-	case FEEDBACK_OK:
-		nfs_up(nf->nf_mount, nf->nf_td,
-		    "is alive again", NFSSTA_TIMEO, nf->nf_tprintfmsg);
-		break;
-	}
-}
-
-/*
- * nfs_request - goes something like this
- *	- fill in request struct
- *	- links it into list
- *	- calls nfs_send() for first transmit
- *	- calls nfs_receive() to get reply
- *	- break down rpc header and return with nfs reply pointed to
- *	  by mrep or error
- * nb: always frees up mreq mbuf list
- */
-int
-nfs_request(struct vnode *vp, struct mbuf *mreq, int procnum,
-    struct thread *td, struct ucred *cred, struct mbuf **mrp,
-    struct mbuf **mdp, caddr_t *dposp)
-{
-	struct mbuf *mrep;
-	u_int32_t *tl;
-	struct nfsmount *nmp;
-	struct mbuf *md;
-	time_t waituntil;
-	caddr_t dpos;
-	int error = 0, timeo;
-	AUTH *auth = NULL;
-	enum nfs_rto_timer_t timer;
-	struct nfs_feedback_arg nf;
-	struct rpc_callextra ext;
-	enum clnt_stat stat;
-	struct timeval timo;
-
-	/* Reject requests while attempting a forced unmount. */
-	if (vp->v_mount->mnt_kern_flag & MNTK_UNMOUNTF) {
-		m_freem(mreq);
-		return (ESTALE);
-	}
-	nmp = VFSTONFS(vp->v_mount);
-	bzero(&nf, sizeof(struct nfs_feedback_arg));
-	nf.nf_mount = nmp;
-	nf.nf_td = td;
-	nf.nf_lastmsg = time_uptime -
-	    ((nmp->nm_tprintf_delay) - (nmp->nm_tprintf_initial_delay));
-
-	/*
-	 * XXX if not already connected call nfs_connect now.  Longer
-	 * term, change nfs_mount to call nfs_connect unconditionally
-	 * and let clnt_reconnect_create handle reconnects.
-	 */
-	if (!nmp->nm_client)
-		nfs_connect(nmp);
-
-	auth = nfs_getauth(nmp, cred);
-	if (!auth) {
-		m_freem(mreq);
-		return (EACCES);
-	}
-	bzero(&ext, sizeof(ext));
-	ext.rc_auth = auth;
-
-	ext.rc_feedback = nfs_feedback;
-	ext.rc_feedback_arg = &nf;
-
-	/*
-	 * Use a conservative timeout for RPCs other than getattr,
-	 * lookup, read or write.  The justification for doing "other"
-	 * this way is that these RPCs happen so infrequently that
-	 * timer est. would probably be stale.  Also, since many of
-	 * these RPCs are non-idempotent, a conservative timeout is
-	 * desired.
-	 */
-	timer = nfs_rto_timer(procnum);
-	if (timer != NFS_DEFAULT_TIMER)
-		ext.rc_timers = &nmp->nm_timers[timer - 1];
-	else
-		ext.rc_timers = NULL;
-
-#ifdef KDTRACE_HOOKS
-	if (dtrace_nfsclient_nfs23_start_probe != NULL) {
-		uint32_t probe_id;
-		int probe_procnum;
-
-		if (nmp->nm_flag & NFSMNT_NFSV3) {
-			probe_id = nfsclient_nfs3_start_probes[procnum];
-			probe_procnum = procnum;
-		} else {
-			probe_id = nfsclient_nfs2_start_probes[procnum];
-			probe_procnum = nfsv2_procid[procnum];
-		}
-		if (probe_id != 0)
-			(dtrace_nfsclient_nfs23_start_probe)(probe_id, vp,
-			    mreq, cred, probe_procnum);
-	}
-#endif
-
-	nfsstats.rpcrequests++;
-tryagain:
-	/*
-	 * This timeout specifies when a new socket should be created,
-	 * along with new xid values. For UDP, this should be done
-	 * infrequently, since retransmits of RPC requests should normally
-	 * use the same xid.
-	 */
-	if (nmp->nm_sotype == SOCK_DGRAM) {
-		if ((nmp->nm_flag & NFSMNT_SOFT) != 0) {
-			/*
-			 * CLSET_RETRIES is set to 2, so this should be half
-			 * of the total timeout required.
-			 */
-			timeo = nmp->nm_retry * nmp->nm_timeo / 2;
-			if (timeo < 1)
-				timeo = 1;
-			timo.tv_sec = timeo / NFS_HZ;
-			timo.tv_usec = (timeo % NFS_HZ) * 1000000 / NFS_HZ;
-		} else {
-			/* For UDP hard mounts, use a large value. */
-			timo.tv_sec = NFS_MAXTIMEO / NFS_HZ;
-			timo.tv_usec = 0;
-		}
-	} else {
-		timo.tv_sec = nmp->nm_timeo / NFS_HZ;
-		timo.tv_usec = (nmp->nm_timeo % NFS_HZ) * 1000000 / NFS_HZ;
-	}
-	mrep = NULL;
-	stat = CLNT_CALL_MBUF(nmp->nm_client, &ext,
-	    (nmp->nm_flag & NFSMNT_NFSV3) ? procnum : nfsv2_procid[procnum],
-	    mreq, &mrep, timo);
-
-	/*
-	 * If there was a successful reply and a tprintf msg.
-	 * tprintf a response.
-	 */
-	if (stat == RPC_SUCCESS)
-		error = 0;
-	else if (stat == RPC_TIMEDOUT) {
-		nfsstats.rpctimeouts++;
-		error = ETIMEDOUT;
-	} else if (stat == RPC_VERSMISMATCH) {
-		nfsstats.rpcinvalid++;
-		error = EOPNOTSUPP;
-	} else if (stat == RPC_PROGVERSMISMATCH) {
-		nfsstats.rpcinvalid++;
-		error = EPROTONOSUPPORT;
-	} else if (stat == RPC_INTR) {
-		error = EINTR;
-	} else {
-		nfsstats.rpcinvalid++;
-		error = EACCES;
-	}
-	if (error)
-		goto nfsmout;
-
-	KASSERT(mrep != NULL, ("mrep shouldn't be NULL if no error\n"));
-
-	/*
-	 * Search for any mbufs that are not a multiple of 4 bytes long
-	 * or with m_data not longword aligned.
-	 * These could cause pointer alignment problems, so copy them to
-	 * well aligned mbufs.
-	 */
-	error = nfs_realign(&mrep, M_NOWAIT);
-	if (error == ENOMEM) {
-		m_freem(mrep);
-		AUTH_DESTROY(auth);
-		nfsstats.rpcinvalid++;
-		return (error);
-	}
-
-	md = mrep;
-	dpos = mtod(mrep, caddr_t);
-	tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-	if (*tl != 0) {
-		error = fxdr_unsigned(int, *tl);
-		if ((nmp->nm_flag & NFSMNT_NFSV3) &&
-		    error == NFSERR_TRYLATER) {
-			m_freem(mrep);
-			error = 0;
-			waituntil = time_second + nfs3_jukebox_delay;
-			while (time_second < waituntil)
-				(void)tsleep(&fake_wchan, PSOCK, "nqnfstry",
-				    hz);
-			goto tryagain;
-		}
-		/*
-		 * Make sure NFSERR_RETERR isn't bogusly set by a server
-		 * such as amd. (No actual NFS error has bit 31 set.)
-		 */
-		error &= ~NFSERR_RETERR;
-
-		/*
-		 * If the File Handle was stale, invalidate the lookup
-		 * cache, just in case.
-		 */
-		if (error == ESTALE)
-			nfs_purgecache(vp);
-		/*
-		 * Skip wcc data on non-ENOENT NFS errors for now.
-		 * NetApp filers return corrupt postop attrs in the
-		 * wcc data for NFS err EROFS.  Not sure if they could
-		 * return corrupt postop attrs for others errors.
-		 * Blocking ENOENT post-op attributes breaks negative
-		 * name caching, so always allow it through.
-		 */
-		if ((nmp->nm_flag & NFSMNT_NFSV3) &&
-		    (!nfs_skip_wcc_data_onerr || error == ENOENT)) {
-			*mrp = mrep;
-			*mdp = md;
-			*dposp = dpos;
-			error |= NFSERR_RETERR;
-		} else
-			m_freem(mrep);
-		goto nfsmout;
-	}
-
-#ifdef KDTRACE_HOOKS
-	if (dtrace_nfsclient_nfs23_done_probe != NULL) {
-		uint32_t probe_id;
-		int probe_procnum;
-
-		if (nmp->nm_flag & NFSMNT_NFSV3) {
-			probe_id = nfsclient_nfs3_done_probes[procnum];
-			probe_procnum = procnum;
-		} else {
-			probe_id = nfsclient_nfs2_done_probes[procnum];
-			probe_procnum = (nmp->nm_flag & NFSMNT_NFSV3) ?
-			    procnum : nfsv2_procid[procnum];
-		}
-		if (probe_id != 0)
-			(dtrace_nfsclient_nfs23_done_probe)(probe_id, vp,
-			    mreq, cred, probe_procnum, 0);
-	}
-#endif
-	m_freem(mreq);
-	*mrp = mrep;
-	*mdp = md;
-	*dposp = dpos;
-	AUTH_DESTROY(auth);
-	return (0);
-
-nfsmout:
-#ifdef KDTRACE_HOOKS
-	if (dtrace_nfsclient_nfs23_done_probe != NULL) {
-		uint32_t probe_id;
-		int probe_procnum;
-
-		if (nmp->nm_flag & NFSMNT_NFSV3) {
-			probe_id = nfsclient_nfs3_done_probes[procnum];
-			probe_procnum = procnum;
-		} else {
-			probe_id = nfsclient_nfs2_done_probes[procnum];
-			probe_procnum = (nmp->nm_flag & NFSMNT_NFSV3) ?
-			    procnum : nfsv2_procid[procnum];
-		}
-		if (probe_id != 0)
-			(dtrace_nfsclient_nfs23_done_probe)(probe_id, vp,
-			    mreq, cred, probe_procnum, error);
-	}
-#endif
-	m_freem(mreq);
-	if (auth)
-		AUTH_DESTROY(auth);
-	return (error);
-}
-
-/*
- * Mark all of an nfs mount's outstanding requests with R_SOFTTERM and
- * wait for all requests to complete.  This is used by forced unmounts
- * to terminate any outstanding RPCs.
- */
-int
-nfs_nmcancelreqs(struct nfsmount *nmp)
-{
-
-	if (nmp->nm_client)
-		CLNT_CLOSE(nmp->nm_client);
-	return (0);
-}
-
-/*
- * Any signal that can interrupt an NFS operation in an intr mount
- * should be added to this set.  SIGSTOP and SIGKILL cannot be masked.
- */
-int nfs_sig_set[] = {
-	SIGINT,
-	SIGTERM,
-	SIGHUP,
-	SIGKILL,
-	SIGQUIT
-};
-
-/*
- * Check to see if one of the signals in our subset is pending on
- * the process (in an intr mount).
- */
-static int
-nfs_sig_pending(sigset_t set)
-{
-	int i;
-
-	for (i = 0 ; i < sizeof(nfs_sig_set)/sizeof(int) ; i++)
-		if (SIGISMEMBER(set, nfs_sig_set[i]))
-			return (1);
-	return (0);
-}
-
-/*
- * The set/restore sigmask functions are used to (temporarily) overwrite
- * the thread td_sigmask during an RPC call (for example).  These are also
- * used in other places in the NFS client that might tsleep().
- */
-void
-nfs_set_sigmask(struct thread *td, sigset_t *oldset)
-{
-	sigset_t newset;
-	int i;
-	struct proc *p;
-
-	SIGFILLSET(newset);
-	if (td == NULL)
-		td = curthread; /* XXX */
-	p = td->td_proc;
-	/* Remove the NFS set of signals from newset. */
-	PROC_LOCK(p);
-	mtx_lock(&p->p_sigacts->ps_mtx);
-	for (i = 0 ; i < sizeof(nfs_sig_set)/sizeof(int) ; i++) {
-		/*
-		 * But make sure we leave the ones already masked
-		 * by the process, i.e. remove the signal from the
-		 * temporary signalmask only if it wasn't already
-		 * in p_sigmask.
-		 */
-		if (!SIGISMEMBER(td->td_sigmask, nfs_sig_set[i]) &&
-		    !SIGISMEMBER(p->p_sigacts->ps_sigignore, nfs_sig_set[i]))
-			SIGDELSET(newset, nfs_sig_set[i]);
-	}
-	mtx_unlock(&p->p_sigacts->ps_mtx);
-	kern_sigprocmask(td, SIG_SETMASK, &newset, oldset,
-	    SIGPROCMASK_PROC_LOCKED);
-	PROC_UNLOCK(p);
-}
-
-void
-nfs_restore_sigmask(struct thread *td, sigset_t *set)
-{
-	if (td == NULL)
-		td = curthread; /* XXX */
-	kern_sigprocmask(td, SIG_SETMASK, set, NULL, 0);
-}
-
-/*
- * NFS wrapper to msleep(), that shoves a new p_sigmask and restores the
- * old one after msleep() returns.
- */
-int
-nfs_msleep(struct thread *td, void *ident, struct mtx *mtx, int priority,
-    char *wmesg, int timo)
-{
-	sigset_t oldset;
-	int error;
-	struct proc *p;
-
-	if ((priority & PCATCH) == 0)
-		return msleep(ident, mtx, priority, wmesg, timo);
-	if (td == NULL)
-		td = curthread; /* XXX */
-	nfs_set_sigmask(td, &oldset);
-	error = msleep(ident, mtx, priority, wmesg, timo);
-	nfs_restore_sigmask(td, &oldset);
-	p = td->td_proc;
-	return (error);
-}
-
-/*
- * Test for a termination condition pending on the process.
- * This is used for NFSMNT_INT mounts.
- */
-int
-nfs_sigintr(struct nfsmount *nmp, struct thread *td)
-{
-	struct proc *p;
-	sigset_t tmpset;
-
-	/* Terminate all requests while attempting a forced unmount. */
-	if (nmp->nm_mountp->mnt_kern_flag & MNTK_UNMOUNTF)
-		return (EIO);
-	if (!(nmp->nm_flag & NFSMNT_INT))
-		return (0);
-	if (td == NULL)
-		return (0);
-	p = td->td_proc;
-	PROC_LOCK(p);
-	tmpset = p->p_siglist;
-	SIGSETOR(tmpset, td->td_siglist);
-	SIGSETNAND(tmpset, td->td_sigmask);
-	mtx_lock(&p->p_sigacts->ps_mtx);
-	SIGSETNAND(tmpset, p->p_sigacts->ps_sigignore);
-	mtx_unlock(&p->p_sigacts->ps_mtx);
-	if ((SIGNOTEMPTY(p->p_siglist) || SIGNOTEMPTY(td->td_siglist))
-	    && nfs_sig_pending(tmpset)) {
-		PROC_UNLOCK(p);
-		return (EINTR);
-	}
-	PROC_UNLOCK(p);
-	return (0);
-}
-
-static int
-nfs_msg(struct thread *td, const char *server, const char *msg, int error)
-{
-	struct proc *p;
-
-	p = td ? td->td_proc : NULL;
-	if (error)
-		tprintf(p, LOG_INFO, "nfs server %s: %s, error %d\n", server,
-		    msg, error);
-	else
-		tprintf(p, LOG_INFO, "nfs server %s: %s\n", server, msg);
-	return (0);
-}
-
-static void
-nfs_down(struct nfsmount *nmp, struct thread *td, const char *msg,
-    int error, int flags)
-{
-	if (nmp == NULL)
-		return;
-	mtx_lock(&nmp->nm_mtx);
-	if ((flags & NFSSTA_TIMEO) && !(nmp->nm_state & NFSSTA_TIMEO)) {
-		nmp->nm_state |= NFSSTA_TIMEO;
-		mtx_unlock(&nmp->nm_mtx);
-		vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
-		    VQ_NOTRESP, 0);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-	mtx_lock(&nmp->nm_mtx);
-	if ((flags & NFSSTA_LOCKTIMEO) &&
-	    !(nmp->nm_state & NFSSTA_LOCKTIMEO)) {
-		nmp->nm_state |= NFSSTA_LOCKTIMEO;
-		mtx_unlock(&nmp->nm_mtx);
-		vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
-		    VQ_NOTRESPLOCK, 0);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-	nfs_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, error);
-}
-
-static void
-nfs_up(struct nfsmount *nmp, struct thread *td, const char *msg,
-    int flags, int tprintfmsg)
-{
-	if (nmp == NULL)
-		return;
-	if (tprintfmsg)
-		nfs_msg(td, nmp->nm_mountp->mnt_stat.f_mntfromname, msg, 0);
-
-	mtx_lock(&nmp->nm_mtx);
-	if ((flags & NFSSTA_TIMEO) && (nmp->nm_state & NFSSTA_TIMEO)) {
-		nmp->nm_state &= ~NFSSTA_TIMEO;
-		mtx_unlock(&nmp->nm_mtx);
-		vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
-		    VQ_NOTRESP, 1);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-
-	mtx_lock(&nmp->nm_mtx);
-	if ((flags & NFSSTA_LOCKTIMEO) &&
-	    (nmp->nm_state & NFSSTA_LOCKTIMEO)) {
-		nmp->nm_state &= ~NFSSTA_LOCKTIMEO;
-		mtx_unlock(&nmp->nm_mtx);
-		vfs_event_signal(&nmp->nm_mountp->mnt_stat.f_fsid,
-		    VQ_NOTRESPLOCK, 1);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-}
diff --git a/sys/nfsclient/nfs_nfsiod.c b/sys/nfsclient/nfs_nfsiod.c
deleted file mode 100644
index 2fb2c88..0000000
--- a/sys/nfsclient/nfs_nfsiod.c
+++ /dev/null
@@ -1,346 +0,0 @@
-/*-
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_syscalls.c	8.5 (Berkeley) 3/30/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/sysproto.h>
-#include <sys/kernel.h>
-#include <sys/sysctl.h>
-#include <sys/file.h>
-#include <sys/filedesc.h>
-#include <sys/vnode.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/mbuf.h>
-#include <sys/socket.h>
-#include <sys/socketvar.h>
-#include <sys/domain.h>
-#include <sys/protosw.h>
-#include <sys/namei.h>
-#include <sys/unistd.h>
-#include <sys/kthread.h>
-#include <sys/fcntl.h>
-#include <sys/lockf.h>
-#include <sys/mutex.h>
-#include <sys/taskqueue.h>
-
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-
-#include <nfs/xdr_subs.h>
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsm_subs.h>
-#include <nfsclient/nfsmount.h>
-#include <nfsclient/nfsnode.h>
-#include <nfs/nfs_lock.h>
-
-static MALLOC_DEFINE(M_NFSSVC, "nfsclient_srvsock", "Nfs server structure");
-
-static void	nfssvc_iod(void *);
-
-static int nfs_asyncdaemon[NFS_MAXASYNCDAEMON];
-
-SYSCTL_DECL(_vfs_oldnfs);
-
-/* Maximum number of seconds a nfsiod kthread will sleep before exiting */
-static unsigned int nfs_iodmaxidle = 120;
-SYSCTL_UINT(_vfs_oldnfs, OID_AUTO, iodmaxidle, CTLFLAG_RW, &nfs_iodmaxidle, 0,
-    "Max number of seconds an nfsiod kthread will sleep before exiting");
-
-/* Maximum number of nfsiod kthreads */
-unsigned int nfs_iodmax = 20;
-
-/* Minimum number of nfsiod kthreads to keep as spares */
-static unsigned int nfs_iodmin = 0;
-
-static int nfs_nfsiodnew_sync(void);
-
-static int
-sysctl_iodmin(SYSCTL_HANDLER_ARGS)
-{
-	int error, i;
-	int newmin;
-
-	newmin = nfs_iodmin;
-	error = sysctl_handle_int(oidp, &newmin, 0, req);
-	if (error || (req->newptr == NULL))
-		return (error);
-	mtx_lock(&nfs_iod_mtx);
-	if (newmin > nfs_iodmax) {
-		error = EINVAL;
-		goto out;
-	}
-	nfs_iodmin = newmin;
-	if (nfs_numasync >= nfs_iodmin)
-		goto out;
-	/*
-	 * If the current number of nfsiod is lower
-	 * than the new minimum, create some more.
-	 */
-	for (i = nfs_iodmin - nfs_numasync; i > 0; i--)
-		nfs_nfsiodnew_sync();
-out:
-	mtx_unlock(&nfs_iod_mtx);	
-	return (0);
-}
-SYSCTL_PROC(_vfs_oldnfs, OID_AUTO, iodmin, CTLTYPE_UINT | CTLFLAG_RW, 0,
-    sizeof (nfs_iodmin), sysctl_iodmin, "IU",
-    "Min number of nfsiod kthreads to keep as spares");
-
-
-static int
-sysctl_iodmax(SYSCTL_HANDLER_ARGS)
-{
-	int error, i;
-	int iod, newmax;
-
-	newmax = nfs_iodmax;
-	error = sysctl_handle_int(oidp, &newmax, 0, req);
-	if (error || (req->newptr == NULL))
-		return (error);
-	if (newmax > NFS_MAXASYNCDAEMON)
-		return (EINVAL);
-	mtx_lock(&nfs_iod_mtx);
-	nfs_iodmax = newmax;
-	if (nfs_numasync <= nfs_iodmax)
-		goto out;
-	/*
-	 * If there are some asleep nfsiods that should
-	 * exit, wakeup() them so that they check nfs_iodmax
-	 * and exit.  Those who are active will exit as
-	 * soon as they finish I/O.
-	 */
-	iod = nfs_numasync - 1;
-	for (i = 0; i < nfs_numasync - nfs_iodmax; i++) {
-		if (nfs_iodwant[iod] == NFSIOD_AVAILABLE)
-			wakeup(&nfs_iodwant[iod]);
-		iod--;
-	}
-out:
-	mtx_unlock(&nfs_iod_mtx);
-	return (0);
-}
-SYSCTL_PROC(_vfs_oldnfs, OID_AUTO, iodmax, CTLTYPE_UINT | CTLFLAG_RW, 0,
-    sizeof (nfs_iodmax), sysctl_iodmax, "IU",
-    "Max number of nfsiod kthreads");
-
-static int
-nfs_nfsiodnew_sync(void)
-{
-	int error, i;
-
-	mtx_assert(&nfs_iod_mtx, MA_OWNED);
-	for (i = 0; i < nfs_iodmax; i++) {
-		if (nfs_asyncdaemon[i] == 0) {
-			nfs_asyncdaemon[i] = 1;
-			break;
-		}
-	}
-	if (i == nfs_iodmax)
-		return (0);
-	mtx_unlock(&nfs_iod_mtx);
-	error = kproc_create(nfssvc_iod, nfs_asyncdaemon + i, NULL,
-	    RFHIGHPID, 0, "nfsiod %d", i);
-	mtx_lock(&nfs_iod_mtx);
-	if (error == 0) {
-		nfs_numasync++;
-		nfs_iodwant[i] = NFSIOD_AVAILABLE;
-	} else
-		nfs_asyncdaemon[i] = 0;
-	return (error);
-}
-
-void
-nfs_nfsiodnew_tq(__unused void *arg, int pending)
-{
-
-	mtx_lock(&nfs_iod_mtx);
-	while (pending > 0) {
-		pending--;
-		nfs_nfsiodnew_sync();
-	}
-	mtx_unlock(&nfs_iod_mtx);
-}
-
-void
-nfs_nfsiodnew(void)
-{
-
-	mtx_assert(&nfs_iod_mtx, MA_OWNED);
-	taskqueue_enqueue(taskqueue_thread, &nfs_nfsiodnew_task);
-}
-
-static void
-nfsiod_setup(void *dummy)
-{
-	int error;
-
-	TUNABLE_INT_FETCH("vfs.oldnfs.iodmin", &nfs_iodmin);
-	mtx_lock(&nfs_iod_mtx);
-	/* Silently limit the start number of nfsiod's */
-	if (nfs_iodmin > NFS_MAXASYNCDAEMON)
-		nfs_iodmin = NFS_MAXASYNCDAEMON;
-
-	while (nfs_numasync < nfs_iodmin) {
-		error = nfs_nfsiodnew_sync();
-		if (error == -1)
-			panic("nfsiod_setup: nfs_nfsiodnew failed");
-	}
-	mtx_unlock(&nfs_iod_mtx);
-}
-SYSINIT(nfsiod, SI_SUB_KTHREAD_IDLE, SI_ORDER_ANY, nfsiod_setup, NULL);
-
-static int nfs_defect = 0;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, defect, CTLFLAG_RW, &nfs_defect, 0,
-    "Allow nfsiods to migrate serving different mounts");
-
-/*
- * Asynchronous I/O daemons for client nfs.
- * They do read-ahead and write-behind operations on the block I/O cache.
- * Returns if we hit the timeout defined by the iodmaxidle sysctl.
- */
-static void
-nfssvc_iod(void *instance)
-{
-	struct buf *bp;
-	struct nfsmount *nmp;
-	int myiod, timo;
-	int error = 0;
-
-	mtx_lock(&nfs_iod_mtx);
-	myiod = (int *)instance - nfs_asyncdaemon;
-	/*
-	 * Main loop
-	 */
-	for (;;) {
-	    while (((nmp = nfs_iodmount[myiod]) == NULL)
-		   || !TAILQ_FIRST(&nmp->nm_bufq)) {
-		if (myiod >= nfs_iodmax)
-			goto finish;
-		if (nmp)
-			nmp->nm_bufqiods--;
-		if (nfs_iodwant[myiod] == NFSIOD_NOT_AVAILABLE)
-			nfs_iodwant[myiod] = NFSIOD_AVAILABLE;
-		nfs_iodmount[myiod] = NULL;
-		/*
-		 * Always keep at least nfs_iodmin kthreads.
-		 */
-		timo = (myiod < nfs_iodmin) ? 0 : nfs_iodmaxidle * hz;
-		error = msleep(&nfs_iodwant[myiod], &nfs_iod_mtx, PWAIT | PCATCH,
-		    "-", timo);
-		if (error) {
-			nmp = nfs_iodmount[myiod];
-			/*
-			 * Rechecking the nm_bufq closes a rare race where the 
-			 * nfsiod is woken up at the exact time the idle timeout
-			 * fires
-			 */
-			if (nmp && TAILQ_FIRST(&nmp->nm_bufq))
-				error = 0;
-			break;
-		}
-	    }
-	    if (error)
-		    break;
-	    while ((bp = TAILQ_FIRST(&nmp->nm_bufq)) != NULL) {
-	        int giant_locked = 0;
-		    
-		/* Take one off the front of the list */
-		TAILQ_REMOVE(&nmp->nm_bufq, bp, b_freelist);
-		nmp->nm_bufqlen--;
-		if (nmp->nm_bufqwant && nmp->nm_bufqlen <= nfs_numasync) {
-		    nmp->nm_bufqwant = 0;
-		    wakeup(&nmp->nm_bufq);
-		}
-		mtx_unlock(&nfs_iod_mtx);
-		if (NFS_ISV4(bp->b_vp)) {
-			giant_locked = 1;
-			mtx_lock(&Giant);
-		}
-		if (bp->b_flags & B_DIRECT) {
-			KASSERT((bp->b_iocmd == BIO_WRITE), ("nfscvs_iod: BIO_WRITE not set"));
-			(void)nfs_doio_directwrite(bp);
-		} else {
-			if (bp->b_iocmd == BIO_READ)
-				(void) nfs_doio(bp->b_vp, bp, bp->b_rcred, NULL);
-			else
-				(void) nfs_doio(bp->b_vp, bp, bp->b_wcred, NULL);
-		}
-		if (giant_locked)
-			mtx_unlock(&Giant);
-		mtx_lock(&nfs_iod_mtx);
-		/*
-		 * Make sure the nmp hasn't been dismounted as soon as
-		 * nfs_doio() completes for the last buffer.
-		 */
-		nmp = nfs_iodmount[myiod];
-		if (nmp == NULL)
-			break;
-
-		/*
-		 * If there are more than one iod on this mount, then defect
-		 * so that the iods can be shared out fairly between the mounts
-		 */
-		if (nfs_defect && nmp->nm_bufqiods > 1) {
-		    NFS_DPF(ASYNCIO,
-			    ("nfssvc_iod: iod %d defecting from mount %p\n",
-			     myiod, nmp));
-		    nfs_iodmount[myiod] = NULL;
-		    nmp->nm_bufqiods--;
-		    break;
-		}
-	    }
-	}
-finish:
-	nfs_asyncdaemon[myiod] = 0;
-	if (nmp)
-	    nmp->nm_bufqiods--;
-	nfs_iodwant[myiod] = NFSIOD_NOT_AVAILABLE;
-	nfs_iodmount[myiod] = NULL;
-	/* Someone may be waiting for the last nfsiod to terminate. */
-	if (--nfs_numasync == 0)
-		wakeup(&nfs_numasync);
-	mtx_unlock(&nfs_iod_mtx);
-	if ((error == 0) || (error == EWOULDBLOCK))
-		kproc_exit(0);
-	/* Abnormal termination */
-	kproc_exit(1);
-}
diff --git a/sys/nfsclient/nfs_node.c b/sys/nfsclient/nfs_node.c
deleted file mode 100644
index cee4343..0000000
--- a/sys/nfsclient/nfs_node.c
+++ /dev/null
@@ -1,276 +0,0 @@
-/*-
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_node.c	8.6 (Berkeley) 5/22/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/fcntl.h>
-#include <sys/fnv_hash.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mbuf.h>
-#include <sys/mount.h>
-#include <sys/namei.h>
-#include <sys/proc.h>
-#include <sys/socket.h>
-#include <sys/sysctl.h>
-#include <sys/taskqueue.h>
-#include <sys/vnode.h>
-
-#include <vm/uma.h>
-
-#include <nfs/nfsproto.h>
-#include <nfs/nfs_lock.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsnode.h>
-#include <nfsclient/nfsmount.h>
-
-static uma_zone_t nfsnode_zone;
-
-static void	nfs_freesillyrename(void *arg, __unused int pending);
-
-#define TRUE	1
-#define	FALSE	0
-
-void
-nfs_nhinit(void)
-{
-
-	nfsnode_zone = uma_zcreate("NFSNODE", sizeof(struct nfsnode), NULL,
-	    NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
-}
-
-void
-nfs_nhuninit(void)
-{
-	uma_zdestroy(nfsnode_zone);
-}
-
-struct nfs_vncmp {
-	int	fhsize;
-	void	*fh;
-};
-
-static int
-nfs_vncmpf(struct vnode *vp, void *arg)
-{
-	struct nfs_vncmp *a;
-	struct nfsnode *np;
-
-	a = arg;
-	np = VTONFS(vp);
-	return (bcmp(a->fh, np->n_fhp, a->fhsize));
-}
-
-/*
- * Look up a vnode/nfsnode by file handle.
- * Callers must check for mount points!!
- * In all cases, a pointer to a
- * nfsnode structure is returned.
- */
-int
-nfs_nget(struct mount *mntp, nfsfh_t *fhp, int fhsize, struct nfsnode **npp, int flags)
-{
-	struct thread *td = curthread;	/* XXX */
-	struct nfsnode *np;
-	struct vnode *vp;
-	struct vnode *nvp;
-	int error;
-	u_int hash;
-	struct nfsmount *nmp;
-	struct nfs_vncmp ncmp;
-
-	nmp = VFSTONFS(mntp);
-	*npp = NULL;
-
-	hash = fnv_32_buf(fhp->fh_bytes, fhsize, FNV1_32_INIT);
-	ncmp.fhsize = fhsize;
-	ncmp.fh = fhp;
-
-	error = vfs_hash_get(mntp, hash, flags,
-	    td, &nvp, nfs_vncmpf, &ncmp);
-	if (error)
-		return (error);
-	if (nvp != NULL) {
-		*npp = VTONFS(nvp);
-		return (0);
-	}
-	np = uma_zalloc(nfsnode_zone, M_WAITOK | M_ZERO);
-
-	error = getnewvnode("nfs", mntp, &nfs_vnodeops, &nvp);
-	if (error) {
-		uma_zfree(nfsnode_zone, np);
-		return (error);
-	}
-	vp = nvp;
-	vp->v_bufobj.bo_ops = &buf_ops_nfs;
-	vp->v_data = np;
-	np->n_vnode = vp;
-	/* 
-	 * Initialize the mutex even if the vnode is going to be a loser.
-	 * This simplifies the logic in reclaim, which can then unconditionally
-	 * destroy the mutex (in the case of the loser, or if hash_insert happened
-	 * to return an error no special casing is needed).
-	 */
-	mtx_init(&np->n_mtx, "NFSnode lock", NULL, MTX_DEF);
-	/*
-	 * NFS supports recursive and shared locking.
-	 */
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_NOWITNESS, NULL);
-	VN_LOCK_AREC(vp);
-	VN_LOCK_ASHARE(vp);
-	if (fhsize > NFS_SMALLFH) {
-		np->n_fhp = malloc(fhsize, M_NFSBIGFH, M_WAITOK);
-	} else
-		np->n_fhp = &np->n_fh;
-	bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
-	np->n_fhsize = fhsize;
-	error = insmntque(vp, mntp);
-	if (error != 0) {
-		*npp = NULL;
-		if (np->n_fhsize > NFS_SMALLFH) {
-			free((caddr_t)np->n_fhp, M_NFSBIGFH);
-		}
-		mtx_destroy(&np->n_mtx);
-		uma_zfree(nfsnode_zone, np);
-		return (error);
-	}
-	error = vfs_hash_insert(vp, hash, flags, 
-	    td, &nvp, nfs_vncmpf, &ncmp);
-	if (error)
-		return (error);
-	if (nvp != NULL) {
-		*npp = VTONFS(nvp);
-		/* vfs_hash_insert() vput()'s the losing vnode */
-		return (0);
-	}
-	*npp = np;
-
-	return (0);
-}
-
-/*
- * Do the vrele(sp->s_dvp) as a separate task in order to avoid a
- * deadlock because of a LOR when vrele() locks the directory vnode.
- */
-static void
-nfs_freesillyrename(void *arg, __unused int pending)
-{
-	struct sillyrename *sp;
-
-	sp = arg;
-	vrele(sp->s_dvp);
-	free(sp, M_NFSREQ);
-}
-
-int
-nfs_inactive(struct vop_inactive_args *ap)
-{
-	struct nfsnode *np;
-	struct sillyrename *sp;
-	struct thread *td = curthread;	/* XXX */
-
-	np = VTONFS(ap->a_vp);
-	mtx_lock(&np->n_mtx);
-	if (ap->a_vp->v_type != VDIR) {
-		sp = np->n_sillyrename;
-		np->n_sillyrename = NULL;
-	} else
-		sp = NULL;
-	if (sp) {
-		mtx_unlock(&np->n_mtx);
-		(void)nfs_vinvalbuf(ap->a_vp, 0, td, 1);
-		/*
-		 * Remove the silly file that was rename'd earlier
-		 */
-		(sp->s_removeit)(sp);
-		crfree(sp->s_cred);
-		TASK_INIT(&sp->s_task, 0, nfs_freesillyrename, sp);
-		taskqueue_enqueue(taskqueue_thread, &sp->s_task);
-		mtx_lock(&np->n_mtx);
-	}
-	np->n_flag &= NMODIFIED;
-	mtx_unlock(&np->n_mtx);
-	return (0);
-}
-
-/*
- * Reclaim an nfsnode so that it can be used for other purposes.
- */
-int
-nfs_reclaim(struct vop_reclaim_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct nfsdmap *dp, *dp2;
-
-	/*
-	 * If the NLM is running, give it a chance to abort pending
-	 * locks.
-	 */
-	if (nfs_reclaim_p)
-		nfs_reclaim_p(ap);
-
-	/*
-	 * Destroy the vm object and flush associated pages.
-	 */
-	vnode_destroy_vobject(vp);
-
-	vfs_hash_remove(vp);
-
-	/*
-	 * Free up any directory cookie structures and
-	 * large file handle structures that might be associated with
-	 * this nfs node.
-	 */
-	if (vp->v_type == VDIR) {
-		dp = LIST_FIRST(&np->n_cookies);
-		while (dp) {
-			dp2 = dp;
-			dp = LIST_NEXT(dp, ndm_list);
-			free((caddr_t)dp2, M_NFSDIROFF);
-		}
-	}
-	if (np->n_writecred != NULL)
-		crfree(np->n_writecred);
-	if (np->n_fhsize > NFS_SMALLFH) {
-		free((caddr_t)np->n_fhp, M_NFSBIGFH);
-	}
-	mtx_destroy(&np->n_mtx);
-	uma_zfree(nfsnode_zone, vp->v_data);
-	vp->v_data = NULL;
-	return (0);
-}
diff --git a/sys/nfsclient/nfs_subs.c b/sys/nfsclient/nfs_subs.c
deleted file mode 100644
index d4fd5eb..0000000
--- a/sys/nfsclient/nfs_subs.c
+++ /dev/null
@@ -1,1140 +0,0 @@
-/*-
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_subs.c  8.8 (Berkeley) 5/22/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-/*
- * These functions support the macros and help fiddle mbuf chains for
- * the nfs op functions. They do things like create the rpc header and
- * copy data between mbuf chains and uio lists.
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/proc.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-#include <sys/namei.h>
-#include <sys/mbuf.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/malloc.h>
-#include <sys/rwlock.h>
-#include <sys/sysent.h>
-#include <sys/syscall.h>
-#include <sys/sysproto.h>
-#include <sys/taskqueue.h>
-
-#include <vm/vm.h>
-#include <vm/vm_object.h>
-#include <vm/vm_extern.h>
-#include <vm/uma.h>
-
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsnode.h>
-#include <nfs/nfs_kdtrace.h>
-#include <nfs/xdr_subs.h>
-#include <nfsclient/nfsm_subs.h>
-#include <nfsclient/nfsmount.h>
-
-#include <netinet/in.h>
-
-/*
- * Note that stdarg.h and the ANSI style va_start macro is used for both
- * ANSI and traditional C compilers.
- */
-#include <machine/stdarg.h>
-
-#ifdef KDTRACE_HOOKS
-dtrace_nfsclient_attrcache_flush_probe_func_t
-    dtrace_nfsclient_attrcache_flush_done_probe;
-uint32_t nfsclient_attrcache_flush_done_id;
-
-dtrace_nfsclient_attrcache_get_hit_probe_func_t
-    dtrace_nfsclient_attrcache_get_hit_probe;
-uint32_t nfsclient_attrcache_get_hit_id;
-
-dtrace_nfsclient_attrcache_get_miss_probe_func_t
-    dtrace_nfsclient_attrcache_get_miss_probe;
-uint32_t nfsclient_attrcache_get_miss_id;
-
-dtrace_nfsclient_attrcache_load_probe_func_t
-    dtrace_nfsclient_attrcache_load_done_probe;
-uint32_t nfsclient_attrcache_load_done_id;
-#endif /* !KDTRACE_HOOKS */
-
-/*
- * Data items converted to xdr at startup, since they are constant
- * This is kinda hokey, but may save a little time doing byte swaps
- */
-u_int32_t	nfs_xdrneg1;
-u_int32_t	nfs_true, nfs_false;
-
-/* And other global data */
-static u_int32_t nfs_xid = 0;
-static enum vtype nv2tov_type[8]= {
-	VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON,  VNON
-};
-
-int		nfs_ticks;
-int		nfs_pbuf_freecnt = -1;	/* start out unlimited */
-
-struct nfs_bufq	nfs_bufq;
-static struct mtx nfs_xid_mtx;
-struct task	nfs_nfsiodnew_task;
-
-/*
- * and the reverse mapping from generic to Version 2 procedure numbers
- */
-int nfsv2_procid[NFS_NPROCS] = {
-	NFSV2PROC_NULL,
-	NFSV2PROC_GETATTR,
-	NFSV2PROC_SETATTR,
-	NFSV2PROC_LOOKUP,
-	NFSV2PROC_NOOP,
-	NFSV2PROC_READLINK,
-	NFSV2PROC_READ,
-	NFSV2PROC_WRITE,
-	NFSV2PROC_CREATE,
-	NFSV2PROC_MKDIR,
-	NFSV2PROC_SYMLINK,
-	NFSV2PROC_CREATE,
-	NFSV2PROC_REMOVE,
-	NFSV2PROC_RMDIR,
-	NFSV2PROC_RENAME,
-	NFSV2PROC_LINK,
-	NFSV2PROC_READDIR,
-	NFSV2PROC_NOOP,
-	NFSV2PROC_STATFS,
-	NFSV2PROC_NOOP,
-	NFSV2PROC_NOOP,
-	NFSV2PROC_NOOP,
-	NFSV2PROC_NOOP,
-};
-
-LIST_HEAD(nfsnodehashhead, nfsnode);
-
-u_int32_t
-nfs_xid_gen(void)
-{
-	uint32_t xid;
-
-	mtx_lock(&nfs_xid_mtx);
-
-	/* Get a pretty random xid to start with */
-	if (!nfs_xid)
-		nfs_xid = random();
-	/*
-	 * Skip zero xid if it should ever happen.
-	 */
-	if (++nfs_xid == 0)
-		nfs_xid++;
-	xid = nfs_xid;
-	mtx_unlock(&nfs_xid_mtx);
-	return xid;
-}
-
-/*
- * copies a uio scatter/gather list to an mbuf chain.
- * NOTE: can ony handle iovcnt == 1
- */
-int
-nfsm_uiotombuf(struct uio *uiop, struct mbuf **mq, int siz, caddr_t *bpos)
-{
-	char *uiocp;
-	struct mbuf *mp, *mp2;
-	int xfer, left, mlen;
-	int uiosiz, clflg, rem;
-	char *cp;
-
-	KASSERT(uiop->uio_iovcnt == 1, ("nfsm_uiotombuf: iovcnt != 1"));
-
-	if (siz > MLEN)		/* or should it >= MCLBYTES ?? */
-		clflg = 1;
-	else
-		clflg = 0;
-	rem = nfsm_rndup(siz)-siz;
-	mp = mp2 = *mq;
-	while (siz > 0) {
-		left = uiop->uio_iov->iov_len;
-		uiocp = uiop->uio_iov->iov_base;
-		if (left > siz)
-			left = siz;
-		uiosiz = left;
-		while (left > 0) {
-			mlen = M_TRAILINGSPACE(mp);
-			if (mlen == 0) {
-				if (clflg)
-					mp = m_getcl(M_WAITOK, MT_DATA, 0);
-				else
-					mp = m_get(M_WAITOK, MT_DATA);
-				mp2->m_next = mp;
-				mp2 = mp;
-				mlen = M_TRAILINGSPACE(mp);
-			}
-			xfer = (left > mlen) ? mlen : left;
-#ifdef notdef
-			/* Not Yet.. */
-			if (uiop->uio_iov->iov_op != NULL)
-				(*(uiop->uio_iov->iov_op))
-				(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
-			else
-#endif
-			if (uiop->uio_segflg == UIO_SYSSPACE)
-				bcopy(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
-			else
-				copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
-			mp->m_len += xfer;
-			left -= xfer;
-			uiocp += xfer;
-			uiop->uio_offset += xfer;
-			uiop->uio_resid -= xfer;
-		}
-		uiop->uio_iov->iov_base =
-		    (char *)uiop->uio_iov->iov_base + uiosiz;
-		uiop->uio_iov->iov_len -= uiosiz;
-		siz -= uiosiz;
-	}
-	if (rem > 0) {
-		if (rem > M_TRAILINGSPACE(mp)) {
-			mp = m_get(M_WAITOK, MT_DATA);
-			mp2->m_next = mp;
-		}
-		cp = mtod(mp, caddr_t)+mp->m_len;
-		for (left = 0; left < rem; left++)
-			*cp++ = '\0';
-		mp->m_len += rem;
-		*bpos = cp;
-	} else
-		*bpos = mtod(mp, caddr_t)+mp->m_len;
-	*mq = mp;
-	return (0);
-}
-
-/*
- * Copy a string into mbufs for the hard cases...
- */
-int
-nfsm_strtmbuf(struct mbuf **mb, char **bpos, const char *cp, long siz)
-{
-	struct mbuf *m1 = NULL, *m2;
-	long left, xfer, len, tlen;
-	u_int32_t *tl;
-	int putsize;
-
-	putsize = 1;
-	m2 = *mb;
-	left = M_TRAILINGSPACE(m2);
-	if (left > 0) {
-		tl = ((u_int32_t *)(*bpos));
-		*tl++ = txdr_unsigned(siz);
-		putsize = 0;
-		left -= NFSX_UNSIGNED;
-		m2->m_len += NFSX_UNSIGNED;
-		if (left > 0) {
-			bcopy(cp, (caddr_t) tl, left);
-			siz -= left;
-			cp += left;
-			m2->m_len += left;
-			left = 0;
-		}
-	}
-	/* Loop around adding mbufs */
-	while (siz > 0) {
-		if (siz > MLEN) {
-			m1 = m_getcl(M_WAITOK, MT_DATA, 0);
-			m1->m_len = MCLBYTES;
-		} else {
-			m1 = m_get(M_WAITOK, MT_DATA);
-			m1->m_len = MLEN;
-		}
-		m2->m_next = m1;
-		m2 = m1;
-		tl = mtod(m1, u_int32_t *);
-		tlen = 0;
-		if (putsize) {
-			*tl++ = txdr_unsigned(siz);
-			m1->m_len -= NFSX_UNSIGNED;
-			tlen = NFSX_UNSIGNED;
-			putsize = 0;
-		}
-		if (siz < m1->m_len) {
-			len = nfsm_rndup(siz);
-			xfer = siz;
-			if (xfer < len)
-				*(tl+(xfer>>2)) = 0;
-		} else {
-			xfer = len = m1->m_len;
-		}
-		bcopy(cp, (caddr_t) tl, xfer);
-		m1->m_len = len+tlen;
-		siz -= xfer;
-		cp += xfer;
-	}
-	*mb = m1;
-	*bpos = mtod(m1, caddr_t)+m1->m_len;
-	return (0);
-}
-
-/*
- * Called once to initialize data structures...
- */
-int
-nfs_init(struct vfsconf *vfsp)
-{
-	int i;
-
-	nfsmount_zone = uma_zcreate("NFSMOUNT", sizeof(struct nfsmount),
-	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
-	nfs_true = txdr_unsigned(TRUE);
-	nfs_false = txdr_unsigned(FALSE);
-	nfs_xdrneg1 = txdr_unsigned(-1);
-	nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000;
-	if (nfs_ticks < 1)
-		nfs_ticks = 1;
-	/* Ensure async daemons disabled */
-	for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
-		nfs_iodwant[i] = NFSIOD_NOT_AVAILABLE;
-		nfs_iodmount[i] = NULL;
-	}
-	nfs_nhinit();			/* Init the nfsnode table */
-
-	/*
-	 * Initialize reply list and start timer
-	 */
-	mtx_init(&nfs_iod_mtx, "NFS iod lock", NULL, MTX_DEF);
-	mtx_init(&nfs_xid_mtx, "NFS xid lock", NULL, MTX_DEF);
-	TASK_INIT(&nfs_nfsiodnew_task, 0, nfs_nfsiodnew_tq, NULL);
-
-	nfs_pbuf_freecnt = nswbuf / 2 + 1;
-
-	return (0);
-}
-
-int
-nfs_uninit(struct vfsconf *vfsp)
-{
-	int i;
-
-	/*
-	 * Tell all nfsiod processes to exit. Clear nfs_iodmax, and wakeup
-	 * any sleeping nfsiods so they check nfs_iodmax and exit.
-	 * Drain nfsiodnew task before we wait for them to finish.
-	 */
-	mtx_lock(&nfs_iod_mtx);
-	nfs_iodmax = 0;
-	mtx_unlock(&nfs_iod_mtx);
-	taskqueue_drain(taskqueue_thread, &nfs_nfsiodnew_task);
-	mtx_lock(&nfs_iod_mtx);
-	for (i = 0; i < nfs_numasync; i++)
-		if (nfs_iodwant[i] == NFSIOD_AVAILABLE)
-			wakeup(&nfs_iodwant[i]);
-	/* The last nfsiod to exit will wake us up when nfs_numasync hits 0 */
-	while (nfs_numasync)
-		msleep(&nfs_numasync, &nfs_iod_mtx, PWAIT, "ioddie", 0);
-	mtx_unlock(&nfs_iod_mtx);
-	nfs_nhuninit();
-	uma_zdestroy(nfsmount_zone);
-	return (0);
-}
-
-void 
-nfs_dircookie_lock(struct nfsnode *np)
-{
-	mtx_lock(&np->n_mtx);
-	while (np->n_flag & NDIRCOOKIELK)
-		(void) msleep(&np->n_flag, &np->n_mtx, PZERO, "nfsdirlk", 0);
-	np->n_flag |= NDIRCOOKIELK;
-	mtx_unlock(&np->n_mtx);
-}
-
-void 
-nfs_dircookie_unlock(struct nfsnode *np)
-{
-	mtx_lock(&np->n_mtx);
-	np->n_flag &= ~NDIRCOOKIELK;
-	wakeup(&np->n_flag);
-	mtx_unlock(&np->n_mtx);
-}
-
-int
-nfs_upgrade_vnlock(struct vnode *vp)
-{
-	int old_lock;
-
-	ASSERT_VOP_LOCKED(vp, "nfs_upgrade_vnlock");
-	old_lock = VOP_ISLOCKED(vp);
-	if (old_lock != LK_EXCLUSIVE) {
-		KASSERT(old_lock == LK_SHARED,
-		    ("nfs_upgrade_vnlock: wrong old_lock %d", old_lock));
-		/* Upgrade to exclusive lock, this might block */
-		vn_lock(vp, LK_UPGRADE | LK_RETRY);
-  	}
-	return (old_lock);
-}
-
-void
-nfs_downgrade_vnlock(struct vnode *vp, int old_lock)
-{
-	if (old_lock != LK_EXCLUSIVE) {
-		KASSERT(old_lock == LK_SHARED, ("wrong old_lock %d", old_lock));
-		/* Downgrade from exclusive lock. */
-		vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
-  	}
-}
-
-void
-nfs_printf(const char *fmt, ...)
-{
-	va_list ap;
-
-	mtx_lock(&Giant);
-	va_start(ap, fmt);
-	vprintf(fmt, ap);
-	va_end(ap);
-	mtx_unlock(&Giant);
-}
-
-/*
- * Attribute cache routines.
- * nfs_loadattrcache() - loads or updates the cache contents from attributes
- *	that are on the mbuf list
- * nfs_getattrcache() - returns valid attributes if found in cache, returns
- *	error otherwise
- */
-
-/*
- * Load the attribute cache (that lives in the nfsnode entry) with
- * the values on the mbuf list and
- * Iff vap not NULL
- *    copy the attributes to *vaper
- */
-int
-nfs_loadattrcache(struct vnode **vpp, struct mbuf **mdp, caddr_t *dposp,
-		  struct vattr *vaper, int dontshrink)
-{
-	struct vnode *vp = *vpp;
-	struct vattr *vap;
-	struct nfs_fattr *fp;
-	struct nfsnode *np = NULL;
-	int32_t t1;
-	caddr_t cp2;
-	int rdev;
-	struct mbuf *md;
-	enum vtype vtyp;
-	u_short vmode;
-	struct timespec mtime, mtime_save;
-	int v3 = NFS_ISV3(vp);
-	int error = 0;
-	u_quad_t nsize;
-	int setnsize;
-
-	md = *mdp;
-	t1 = (mtod(md, caddr_t) + md->m_len) - *dposp;
-	cp2 = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, M_WAITOK);
-	if (cp2 == NULL) {
-		error = EBADRPC;
-		goto out;
-	}
-	fp = (struct nfs_fattr *)cp2;
-	if (v3) {
-		vtyp = nfsv3tov_type(fp->fa_type);
-		vmode = fxdr_unsigned(u_short, fp->fa_mode);
-		rdev = makedev(fxdr_unsigned(int, fp->fa3_rdev.specdata1),
-			fxdr_unsigned(int, fp->fa3_rdev.specdata2));
-		fxdr_nfsv3time(&fp->fa3_mtime, &mtime);
-	} else {
-		vtyp = nfsv2tov_type(fp->fa_type);
-		vmode = fxdr_unsigned(u_short, fp->fa_mode);
-		/*
-		 * XXX
-		 *
-		 * The duplicate information returned in fa_type and fa_mode
-		 * is an ambiguity in the NFS version 2 protocol.
-		 *
-		 * VREG should be taken literally as a regular file.  If a
-		 * server intents to return some type information differently
-		 * in the upper bits of the mode field (e.g. for sockets, or
-		 * FIFOs), NFSv2 mandates fa_type to be VNON.  Anyway, we
-		 * leave the examination of the mode bits even in the VREG
-		 * case to avoid breakage for bogus servers, but we make sure
-		 * that there are actually type bits set in the upper part of
-		 * fa_mode (and failing that, trust the va_type field).
-		 *
-		 * NFSv3 cleared the issue, and requires fa_mode to not
-		 * contain any type information (while also introduing sockets
-		 * and FIFOs for fa_type).
-		 */
-		if (vtyp == VNON || (vtyp == VREG && (vmode & S_IFMT) != 0))
-			vtyp = IFTOVT(vmode);
-		rdev = fxdr_unsigned(int32_t, fp->fa2_rdev);
-		fxdr_nfsv2time(&fp->fa2_mtime, &mtime);
-
-		/*
-		 * Really ugly NFSv2 kludge.
-		 */
-		if (vtyp == VCHR && rdev == 0xffffffff)
-			vtyp = VFIFO;
-	}
-
-	/*
-	 * If v_type == VNON it is a new node, so fill in the v_type,
-	 * n_mtime fields. Check to see if it represents a special
-	 * device, and if so, check for a possible alias. Once the
-	 * correct vnode has been obtained, fill in the rest of the
-	 * information.
-	 */
-	np = VTONFS(vp);
-	mtx_lock(&np->n_mtx);
-	if (vp->v_type != vtyp) {
-		vp->v_type = vtyp;
-		if (vp->v_type == VFIFO)
-			vp->v_op = &nfs_fifoops;
-		np->n_mtime = mtime;
-	}
-	vap = &np->n_vattr;
-	vap->va_type = vtyp;
-	vap->va_mode = (vmode & 07777);
-	vap->va_rdev = rdev;
-	mtime_save = vap->va_mtime;
-	vap->va_mtime = mtime;
-	vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
-	if (v3) {
-		vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
-		vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
-		vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
-		vap->va_size = fxdr_hyper(&fp->fa3_size);
-		vap->va_blocksize = NFS_FABLKSIZE;
-		vap->va_bytes = fxdr_hyper(&fp->fa3_used);
-		vap->va_fileid = fxdr_unsigned(int32_t,
-		    fp->fa3_fileid.nfsuquad[1]);
-		fxdr_nfsv3time(&fp->fa3_atime, &vap->va_atime);
-		fxdr_nfsv3time(&fp->fa3_ctime, &vap->va_ctime);
-		vap->va_flags = 0;
-		vap->va_filerev = 0;
-	} else {
-		vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
-		vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
-		vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
-		vap->va_size = fxdr_unsigned(u_int32_t, fp->fa2_size);
-		vap->va_blocksize = fxdr_unsigned(int32_t, fp->fa2_blocksize);
-		vap->va_bytes = (u_quad_t)fxdr_unsigned(int32_t, fp->fa2_blocks)
-		    * NFS_FABLKSIZE;
-		vap->va_fileid = fxdr_unsigned(int32_t, fp->fa2_fileid);
-		fxdr_nfsv2time(&fp->fa2_atime, &vap->va_atime);
-		vap->va_flags = 0;
-		vap->va_ctime.tv_sec = fxdr_unsigned(u_int32_t,
-		    fp->fa2_ctime.nfsv2_sec);
-		vap->va_ctime.tv_nsec = 0;
-		vap->va_gen = fxdr_unsigned(u_int32_t, fp->fa2_ctime.nfsv2_usec);
-		vap->va_filerev = 0;
-	}
-	np->n_attrstamp = time_second;
-	setnsize = 0;
-	nsize = 0;
-	if (vap->va_size != np->n_size) {
-		if (vap->va_type == VREG) {
-			if (dontshrink && vap->va_size < np->n_size) {
-				/*
-				 * We've been told not to shrink the file;
-				 * zero np->n_attrstamp to indicate that
-				 * the attributes are stale.
-				 */
-				vap->va_size = np->n_size;
-				np->n_attrstamp = 0;
-				KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-				vnode_pager_setsize(vp, np->n_size);
-			} else if (np->n_flag & NMODIFIED) {
-				/*
-				 * We've modified the file: Use the larger
-				 * of our size, and the server's size.
-				 */
-				if (vap->va_size < np->n_size) {
-					vap->va_size = np->n_size;
-				} else {
-					np->n_size = vap->va_size;
-					np->n_flag |= NSIZECHANGED;
-				}
-				vnode_pager_setsize(vp, np->n_size);
-			} else if (vap->va_size < np->n_size) {
-				/*
-				 * When shrinking the size, the call to
-				 * vnode_pager_setsize() cannot be done
-				 * with the mutex held, so delay it until
-				 * after the mtx_unlock call.
-				 */
-				nsize = np->n_size = vap->va_size;
-				np->n_flag |= NSIZECHANGED;
-				setnsize = 1;
-			} else {
-				np->n_size = vap->va_size;
-				np->n_flag |= NSIZECHANGED;
-				vnode_pager_setsize(vp, np->n_size);
-			}
-		} else {
-			np->n_size = vap->va_size;
-		}
-	}
-	/*
-	 * The following checks are added to prevent a race between (say)
-	 * a READDIR+ and a WRITE. 
-	 * READDIR+, WRITE requests sent out.
-	 * READDIR+ resp, WRITE resp received on client.
-	 * However, the WRITE resp was handled before the READDIR+ resp
-	 * causing the post op attrs from the write to be loaded first
-	 * and the attrs from the READDIR+ to be loaded later. If this 
-	 * happens, we have stale attrs loaded into the attrcache.
-	 * We detect this by for the mtime moving back. We invalidate the 
-	 * attrcache when this happens.
-	 */
-	if (timespeccmp(&mtime_save, &vap->va_mtime, >)) {
-		/* Size changed or mtime went backwards */
-		np->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-	}
-	if (vaper != NULL) {
-		bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
-		if (np->n_flag & NCHG) {
-			if (np->n_flag & NACC)
-				vaper->va_atime = np->n_atim;
-			if (np->n_flag & NUPD)
-				vaper->va_mtime = np->n_mtim;
-		}
-	}
-
-#ifdef KDTRACE_HOOKS
-	if (np->n_attrstamp != 0)
-		KDTRACE_NFS_ATTRCACHE_LOAD_DONE(vp, &np->n_vattr, 0);
-#endif
-	mtx_unlock(&np->n_mtx);
-	if (setnsize)
-		vnode_pager_setsize(vp, nsize);
-out:
-#ifdef KDTRACE_HOOKS
-	if (error)
-		KDTRACE_NFS_ATTRCACHE_LOAD_DONE(vp, NULL, error);
-#endif
-	return (error);
-}
-
-#ifdef NFS_ACDEBUG
-#include <sys/sysctl.h>
-SYSCTL_DECL(_vfs_oldnfs);
-static int nfs_acdebug;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, acdebug, CTLFLAG_RW, &nfs_acdebug, 0,
-    "Toggle acdebug (attribute cache debug) flag");
-#endif
-
-/*
- * Check the time stamp
- * If the cache is valid, copy contents to *vap and return 0
- * otherwise return an error
- */
-int
-nfs_getattrcache(struct vnode *vp, struct vattr *vaper)
-{
-	struct nfsnode *np;
-	struct vattr *vap;
-	struct nfsmount *nmp;
-	int timeo;
-	
-	np = VTONFS(vp);
-	vap = &np->n_vattr;
-	nmp = VFSTONFS(vp->v_mount);
-#ifdef NFS_ACDEBUG
-	mtx_lock(&Giant);	/* nfs_printf() */
-#endif
-	mtx_lock(&np->n_mtx);
-	/* XXX n_mtime doesn't seem to be updated on a miss-and-reload */
-	timeo = (time_second - np->n_mtime.tv_sec) / 10;
-
-#ifdef NFS_ACDEBUG
-	if (nfs_acdebug>1)
-		nfs_printf("nfs_getattrcache: initial timeo = %d\n", timeo);
-#endif
-
-	if (vap->va_type == VDIR) {
-		if ((np->n_flag & NMODIFIED) || timeo < nmp->nm_acdirmin)
-			timeo = nmp->nm_acdirmin;
-		else if (timeo > nmp->nm_acdirmax)
-			timeo = nmp->nm_acdirmax;
-	} else {
-		if ((np->n_flag & NMODIFIED) || timeo < nmp->nm_acregmin)
-			timeo = nmp->nm_acregmin;
-		else if (timeo > nmp->nm_acregmax)
-			timeo = nmp->nm_acregmax;
-	}
-
-#ifdef NFS_ACDEBUG
-	if (nfs_acdebug > 2)
-		nfs_printf("acregmin %d; acregmax %d; acdirmin %d; acdirmax %d\n",
-			   nmp->nm_acregmin, nmp->nm_acregmax,
-			   nmp->nm_acdirmin, nmp->nm_acdirmax);
-
-	if (nfs_acdebug)
-		nfs_printf("nfs_getattrcache: age = %d; final timeo = %d\n",
-			   (time_second - np->n_attrstamp), timeo);
-#endif
-
-	if ((time_second - np->n_attrstamp) >= timeo) {
-		nfsstats.attrcache_misses++;
-		mtx_unlock(&np->n_mtx);
-#ifdef NFS_ACDEBUG
-		mtx_unlock(&Giant);	/* nfs_printf() */
-#endif
-		KDTRACE_NFS_ATTRCACHE_GET_MISS(vp);
-		return (ENOENT);
-	}
-	nfsstats.attrcache_hits++;
-	if (vap->va_size != np->n_size) {
-		if (vap->va_type == VREG) {
-			if (np->n_flag & NMODIFIED) {
-				if (vap->va_size < np->n_size)
-					vap->va_size = np->n_size;
-				else
-					np->n_size = vap->va_size;
-			} else {
-				np->n_size = vap->va_size;
-			}
-			vnode_pager_setsize(vp, np->n_size);
-		} else {
-			np->n_size = vap->va_size;
-		}
-	}
-	bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(struct vattr));
-	if (np->n_flag & NCHG) {
-		if (np->n_flag & NACC)
-			vaper->va_atime = np->n_atim;
-		if (np->n_flag & NUPD)
-			vaper->va_mtime = np->n_mtim;
-	}
-	mtx_unlock(&np->n_mtx);
-#ifdef NFS_ACDEBUG
-	mtx_unlock(&Giant);	/* nfs_printf() */
-#endif
-	KDTRACE_NFS_ATTRCACHE_GET_HIT(vp, vap);
-	return (0);
-}
-
-/*
- * Purge all cached information about an NFS vnode including name
- * cache entries, the attribute cache, and the access cache.  This is
- * called when an NFS request for a node fails with a stale
- * filehandle.
- */
-void
-nfs_purgecache(struct vnode *vp)
-{
-	struct nfsnode *np;
-	int i;
-
-	np = VTONFS(vp);
-	cache_purge(vp);
-	mtx_lock(&np->n_mtx);
-	np->n_attrstamp = 0;
-	KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-	for (i = 0; i < NFS_ACCESSCACHESIZE; i++)
-		np->n_accesscache[i].stamp = 0;
-	KDTRACE_NFS_ACCESSCACHE_FLUSH_DONE(vp);
-	mtx_unlock(&np->n_mtx);
-}
-
-static nfsuint64 nfs_nullcookie = { { 0, 0 } };
-/*
- * This function finds the directory cookie that corresponds to the
- * logical byte offset given.
- */
-nfsuint64 *
-nfs_getcookie(struct nfsnode *np, off_t off, int add)
-{
-	struct nfsdmap *dp, *dp2;
-	int pos;
-	nfsuint64 *retval = NULL;
-	
-	pos = (uoff_t)off / NFS_DIRBLKSIZ;
-	if (pos == 0 || off < 0) {
-		KASSERT(!add, ("nfs getcookie add at <= 0"));
-		return (&nfs_nullcookie);
-	}
-	pos--;
-	dp = LIST_FIRST(&np->n_cookies);
-	if (!dp) {
-		if (add) {
-			dp = malloc(sizeof (struct nfsdmap),
-				M_NFSDIROFF, M_WAITOK);
-			dp->ndm_eocookie = 0;
-			LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);
-		} else
-			goto out;
-	}
-	while (pos >= NFSNUMCOOKIES) {
-		pos -= NFSNUMCOOKIES;
-		if (LIST_NEXT(dp, ndm_list)) {
-			if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&
-			    pos >= dp->ndm_eocookie)
-				goto out;
-			dp = LIST_NEXT(dp, ndm_list);
-		} else if (add) {
-			dp2 = malloc(sizeof (struct nfsdmap),
-				M_NFSDIROFF, M_WAITOK);
-			dp2->ndm_eocookie = 0;
-			LIST_INSERT_AFTER(dp, dp2, ndm_list);
-			dp = dp2;
-		} else
-			goto out;
-	}
-	if (pos >= dp->ndm_eocookie) {
-		if (add)
-			dp->ndm_eocookie = pos + 1;
-		else
-			goto out;
-	}
-	retval = &dp->ndm_cookies[pos];
-out:
-	return (retval);
-}
-
-/*
- * Invalidate cached directory information, except for the actual directory
- * blocks (which are invalidated separately).
- * Done mainly to avoid the use of stale offset cookies.
- */
-void
-nfs_invaldir(struct vnode *vp)
-{
-	struct nfsnode *np = VTONFS(vp);
-
-	KASSERT(vp->v_type == VDIR, ("nfs: invaldir not dir"));
-	nfs_dircookie_lock(np);
-	np->n_direofoffset = 0;
-	np->n_cookieverf.nfsuquad[0] = 0;
-	np->n_cookieverf.nfsuquad[1] = 0;
-	if (LIST_FIRST(&np->n_cookies))
-		LIST_FIRST(&np->n_cookies)->ndm_eocookie = 0;
-	nfs_dircookie_unlock(np);
-}
-
-/*
- * The write verifier has changed (probably due to a server reboot), so all
- * B_NEEDCOMMIT blocks will have to be written again. Since they are on the
- * dirty block list as B_DELWRI, all this takes is clearing the B_NEEDCOMMIT
- * and B_CLUSTEROK flags.  Once done the new write verifier can be set for the
- * mount point.
- *
- * B_CLUSTEROK must be cleared along with B_NEEDCOMMIT because stage 1 data
- * writes are not clusterable.
- */
-void
-nfs_clearcommit(struct mount *mp)
-{
-	struct vnode *vp, *nvp;
-	struct buf *bp, *nbp;
-	struct bufobj *bo;
-
-	MNT_VNODE_FOREACH_ALL(vp, mp, nvp) {
-		bo = &vp->v_bufobj;
-		vholdl(vp);
-		VI_UNLOCK(vp);
-		BO_LOCK(bo);
-		TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
-			if (!BUF_ISLOCKED(bp) &&
-			    (bp->b_flags & (B_DELWRI | B_NEEDCOMMIT))
-				== (B_DELWRI | B_NEEDCOMMIT))
-				bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
-		}
-		BO_UNLOCK(bo);
-		vdrop(vp);
-	}
-}
-
-/*
- * Helper functions for former macros.  Some of these should be
- * moved to their callers.
- */
-
-int
-nfsm_mtofh_xx(struct vnode *d, struct vnode **v, int v3, int *f,
-    struct mbuf **md, caddr_t *dpos)
-{
-	struct nfsnode *ttnp;
-	struct vnode *ttvp;
-	nfsfh_t *ttfhp;
-	u_int32_t *tl;
-	int ttfhsize;
-	int t1;
-
-	if (v3) {
-		tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
-		if (tl == NULL)
-			return EBADRPC;
-		*f = fxdr_unsigned(int, *tl);
-	} else
-		*f = 1;
-	if (*f) {
-		t1 = nfsm_getfh_xx(&ttfhp, &ttfhsize, (v3), md, dpos);
-		if (t1 != 0)
-			return t1;
-		t1 = nfs_nget(d->v_mount, ttfhp, ttfhsize, &ttnp, LK_EXCLUSIVE);
-		if (t1 != 0)
-			return t1;
-		*v = NFSTOV(ttnp);
-	}
-	if (v3) {
-		tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
-		if (tl == NULL)
-			return EBADRPC;
-		if (*f)
-			*f = fxdr_unsigned(int, *tl);
-		else if (fxdr_unsigned(int, *tl))
-			nfsm_adv_xx(NFSX_V3FATTR, md, dpos);
-	}
-	if (*f) {
-		ttvp = *v;
-		t1 = nfs_loadattrcache(&ttvp, md, dpos, NULL, 0);
-		if (t1)
-			return t1;
-		*v = ttvp;
-	}
-	return 0;
-}
-
-int
-nfsm_getfh_xx(nfsfh_t **f, int *s, int v3, struct mbuf **md, caddr_t *dpos)
-{
-	u_int32_t *tl;
-
-	if (v3) {
-		tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
-		if (tl == NULL)
-			return EBADRPC;
-		*s = fxdr_unsigned(int, *tl);
-		if (*s <= 0 || *s > NFSX_V3FHMAX)
-			return EBADRPC;
-	} else
-		*s = NFSX_V2FH;
-	*f = nfsm_dissect_xx(nfsm_rndup(*s), md, dpos);
-	if (*f == NULL)
-		return EBADRPC;
-	else
-		return 0;
-}
-
-
-int
-nfsm_loadattr_xx(struct vnode **v, struct vattr *va, struct mbuf **md,
-		 caddr_t *dpos)
-{
-	int t1;
-
-	struct vnode *ttvp = *v;
-	t1 = nfs_loadattrcache(&ttvp, md, dpos, va, 0);
-	if (t1 != 0)
-		return t1;
-	*v = ttvp;
-	return 0;
-}
-
-int
-nfsm_postop_attr_xx(struct vnode **v, int *f, struct vattr *va,
-		    struct mbuf **md, caddr_t *dpos)
-{
-	u_int32_t *tl;
-	int t1;
-
-	struct vnode *ttvp = *v;
-	tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
-	if (tl == NULL)
-		return EBADRPC;
-	*f = fxdr_unsigned(int, *tl);
-	if (*f != 0) {
-		t1 = nfs_loadattrcache(&ttvp, md, dpos, va, 1);
-		if (t1 != 0) {
-			*f = 0;
-			return t1;
-		}
-		*v = ttvp;
-	}
-	return 0;
-}
-
-int
-nfsm_wcc_data_xx(struct vnode **v, int *f, struct mbuf **md, caddr_t *dpos)
-{
-	u_int32_t *tl;
-	int ttattrf, ttretf = 0;
-	int t1;
-
-	tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
-	if (tl == NULL)
-		return EBADRPC;
-	if (*tl == nfs_true) {
-		tl = nfsm_dissect_xx(6 * NFSX_UNSIGNED, md, dpos);
-		if (tl == NULL)
-			return EBADRPC;
-		mtx_lock(&(VTONFS(*v))->n_mtx);
-		if (*f)
- 			ttretf = (VTONFS(*v)->n_mtime.tv_sec == fxdr_unsigned(u_int32_t, *(tl + 2)) && 
-				  VTONFS(*v)->n_mtime.tv_nsec == fxdr_unsigned(u_int32_t, *(tl + 3))); 
-		mtx_unlock(&(VTONFS(*v))->n_mtx);
-	}
-	t1 = nfsm_postop_attr_xx(v, &ttattrf, NULL, md, dpos);
-	if (t1)
-		return t1;
-	if (*f)
-		*f = ttretf;
-	else
-		*f = ttattrf;
-	return 0;
-}
-
-int
-nfsm_strtom_xx(const char *a, int s, int m, struct mbuf **mb, caddr_t *bpos)
-{
-	u_int32_t *tl;
-	int t1;
-
-	if (s > m)
-		return ENAMETOOLONG;
-	t1 = nfsm_rndup(s) + NFSX_UNSIGNED;
-	if (t1 <= M_TRAILINGSPACE(*mb)) {
-		tl = nfsm_build_xx(t1, mb, bpos);
-		*tl++ = txdr_unsigned(s);
-		*(tl + ((t1 >> 2) - 2)) = 0;
-		bcopy(a, tl, s);
-	} else {
-		t1 = nfsm_strtmbuf(mb, bpos, a, s);
-		if (t1 != 0)
-			return t1;
-	}
-	return 0;
-}
-
-int
-nfsm_fhtom_xx(struct vnode *v, int v3, struct mbuf **mb, caddr_t *bpos)
-{
-	u_int32_t *tl;
-	int t1;
-	caddr_t cp;
-
-	if (v3) {
-		t1 = nfsm_rndup(VTONFS(v)->n_fhsize) + NFSX_UNSIGNED;
-		if (t1 < M_TRAILINGSPACE(*mb)) {
-			tl = nfsm_build_xx(t1, mb, bpos);
-			*tl++ = txdr_unsigned(VTONFS(v)->n_fhsize);
-			*(tl + ((t1 >> 2) - 2)) = 0;
-			bcopy(VTONFS(v)->n_fhp, tl, VTONFS(v)->n_fhsize);
-		} else {
-			t1 = nfsm_strtmbuf(mb, bpos,
-			    (const char *)VTONFS(v)->n_fhp,
-			    VTONFS(v)->n_fhsize);
-			if (t1 != 0)
-				return t1;
-		}
-	} else {
-		cp = nfsm_build_xx(NFSX_V2FH, mb, bpos);
-		bcopy(VTONFS(v)->n_fhp, cp, NFSX_V2FH);
-	}
-	return 0;
-}
-
-void
-nfsm_v3attrbuild_xx(struct vattr *va, int full, struct mbuf **mb,
-    caddr_t *bpos)
-{
-	u_int32_t *tl;
-
-	if (va->va_mode != (mode_t)VNOVAL) {
-		tl = nfsm_build_xx(2 * NFSX_UNSIGNED, mb, bpos);
-		*tl++ = nfs_true;
-		*tl = txdr_unsigned(va->va_mode);
-	} else {
-		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-		*tl = nfs_false;
-	}
-	if (full && va->va_uid != (uid_t)VNOVAL) {
-		tl = nfsm_build_xx(2 * NFSX_UNSIGNED, mb, bpos);
-		*tl++ = nfs_true;
-		*tl = txdr_unsigned(va->va_uid);
-	} else {
-		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-		*tl = nfs_false;
-	}
-	if (full && va->va_gid != (gid_t)VNOVAL) {
-		tl = nfsm_build_xx(2 * NFSX_UNSIGNED, mb, bpos);
-		*tl++ = nfs_true;
-		*tl = txdr_unsigned(va->va_gid);
-	} else {
-		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-		*tl = nfs_false;
-	}
-	if (full && va->va_size != VNOVAL) {
-		tl = nfsm_build_xx(3 * NFSX_UNSIGNED, mb, bpos);
-		*tl++ = nfs_true;
-		txdr_hyper(va->va_size, tl);
-	} else {
-		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-		*tl = nfs_false;
-	}
-	if (va->va_atime.tv_sec != VNOVAL) {
-		if ((va->va_vaflags & VA_UTIMES_NULL) == 0) {
-			tl = nfsm_build_xx(3 * NFSX_UNSIGNED, mb, bpos);
-			*tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
-			txdr_nfsv3time(&va->va_atime, tl);
-		} else {
-			tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-			*tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
-		}
-	} else {
-		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-		*tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
-	}
-	if (va->va_mtime.tv_sec != VNOVAL) {
-		if ((va->va_vaflags & VA_UTIMES_NULL) == 0) {
-			tl = nfsm_build_xx(3 * NFSX_UNSIGNED, mb, bpos);
-			*tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
-			txdr_nfsv3time(&va->va_mtime, tl);
-		} else {
-			tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-			*tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
-		}
-	} else {
-		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
-		*tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
-	}
-}
diff --git a/sys/nfsclient/nfs_vfsops.c b/sys/nfsclient/nfs_vfsops.c
deleted file mode 100644
index cf63c5e..0000000
--- a/sys/nfsclient/nfs_vfsops.c
+++ /dev/null
@@ -1,1582 +0,0 @@
-/*-
- * Copyright (c) 1989, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_vfsops.c	8.12 (Berkeley) 5/20/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-
-#include "opt_bootp.h"
-#include "opt_nfsroot.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/jail.h>
-#include <sys/limits.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mbuf.h>
-#include <sys/module.h>
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/socket.h>
-#include <sys/socketvar.h>
-#include <sys/sockio.h>
-#include <sys/sysctl.h>
-#include <sys/syslog.h>
-#include <sys/vnode.h>
-#include <sys/signalvar.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-#include <vm/uma.h>
-
-#include <net/if.h>
-#include <net/if_var.h>
-#include <net/route.h>
-#include <net/vnet.h>
-
-#include <netinet/in.h>
-
-#include <rpc/rpc.h>
-
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsnode.h>
-#include <nfsclient/nfsmount.h>
-#include <nfs/xdr_subs.h>
-#include <nfsclient/nfsm_subs.h>
-#include <nfs/nfsdiskless.h>
-
-FEATURE(nfsclient, "NFS client");
-
-MALLOC_DEFINE(M_NFSREQ, "nfsclient_req", "NFS request header");
-MALLOC_DEFINE(M_NFSBIGFH, "nfsclient_bigfh", "NFS version 3 file handle");
-MALLOC_DEFINE(M_NFSDIROFF, "nfsclient_diroff", "NFS directory offset data");
-MALLOC_DEFINE(M_NFSHASH, "nfsclient_hash", "NFS hash tables");
-MALLOC_DEFINE(M_NFSDIRECTIO, "nfsclient_directio", "NFS Direct IO async write state");
-
-uma_zone_t nfsmount_zone;
-
-struct nfsstats	nfsstats;
-
-SYSCTL_NODE(_vfs, OID_AUTO, oldnfs, CTLFLAG_RW, 0, "Old NFS filesystem");
-SYSCTL_STRUCT(_vfs_oldnfs, NFS_NFSSTATS, nfsstats, CTLFLAG_RW,
-	&nfsstats, nfsstats, "S,nfsstats");
-static int nfs_ip_paranoia = 1;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW,
-    &nfs_ip_paranoia, 0,
-    "Disallow accepting replies from IPs which differ from those sent");
-#ifdef NFS_DEBUG
-int nfs_debug;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0,
-    "Toggle debug flag");
-#endif
-static int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY;
-SYSCTL_INT(_vfs_oldnfs, NFS_TPRINTF_INITIAL_DELAY,
-    downdelayinitial, CTLFLAG_RW, &nfs_tprintf_initial_delay, 0,
-    "Delay before printing \"nfs server not responding\" messages");
-/* how long between console messages "nfs server foo not responding" */
-static int nfs_tprintf_delay = NFS_TPRINTF_DELAY;
-SYSCTL_INT(_vfs_oldnfs, NFS_TPRINTF_DELAY,
-    downdelayinterval, CTLFLAG_RW, &nfs_tprintf_delay, 0,
-    "Delay between printing \"nfs server not responding\" messages");
-
-static void	nfs_decode_args(struct mount *mp, struct nfsmount *nmp,
-		    struct nfs_args *argp, const char *hostname);
-static int	mountnfs(struct nfs_args *, struct mount *,
-		    struct sockaddr *, char *, struct vnode **,
-		    struct ucred *cred, int, int);
-static void	nfs_getnlminfo(struct vnode *, uint8_t *, size_t *,
-		    struct sockaddr_storage *, int *, off_t *,
-		    struct timeval *);
-static vfs_mount_t nfs_mount;
-static vfs_cmount_t nfs_cmount;
-static vfs_unmount_t nfs_unmount;
-static vfs_root_t nfs_root;
-static vfs_statfs_t nfs_statfs;
-static vfs_sync_t nfs_sync;
-static vfs_sysctl_t nfs_sysctl;
-
-static int	fake_wchan;
-
-/*
- * nfs vfs operations.
- */
-static struct vfsops nfs_vfsops = {
-	.vfs_init =		nfs_init,
-	.vfs_mount =		nfs_mount,
-	.vfs_cmount =		nfs_cmount,
-	.vfs_root =		nfs_root,
-	.vfs_statfs =		nfs_statfs,
-	.vfs_sync =		nfs_sync,
-	.vfs_uninit =		nfs_uninit,
-	.vfs_unmount =		nfs_unmount,
-	.vfs_sysctl =		nfs_sysctl,
-};
-VFS_SET(nfs_vfsops, oldnfs, VFCF_NETWORK | VFCF_SBDRY);
-
-/* So that loader and kldload(2) can find us, wherever we are.. */
-MODULE_VERSION(oldnfs, 1);
-MODULE_DEPEND(oldnfs, krpc, 1, 1, 1);
-#ifdef KGSSAPI
-MODULE_DEPEND(oldnfs, kgssapi, 1, 1, 1);
-#endif
-MODULE_DEPEND(oldnfs, nfs_common, 1, 1, 1);
-MODULE_DEPEND(oldnfs, nfslock, 1, 1, 1);
-
-static struct nfs_rpcops nfs_rpcops = {
-	nfs_readrpc,
-	nfs_writerpc,
-	nfs_writebp,
-	nfs_readlinkrpc,
-	nfs_invaldir,
-	nfs_commit,
-};
-
-/*
- * This structure is now defined in sys/nfs/nfs_diskless.c so that it
- * can be shared by both NFS clients. It is declared here so that it
- * will be defined for kernels built without NFS_ROOT, although it
- * isn't used in that case.
- */
-#ifndef NFS_ROOT
-struct nfs_diskless	nfs_diskless = { { { 0 } } };
-struct nfsv3_diskless	nfsv3_diskless = { { { 0 } } };
-int			nfs_diskless_valid = 0;
-#endif
-
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, diskless_valid, CTLFLAG_RD,
-    &nfs_diskless_valid, 0,
-    "Has the diskless struct been filled correctly");
-
-SYSCTL_STRING(_vfs_oldnfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD,
-    nfsv3_diskless.root_hostnam, 0, "Path to nfs root");
-
-SYSCTL_OPAQUE(_vfs_oldnfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD,
-    &nfsv3_diskless.root_saddr, sizeof nfsv3_diskless.root_saddr,
-    "%Ssockaddr_in", "Diskless root nfs address");
-
-
-void		nfsargs_ntoh(struct nfs_args *);
-static int	nfs_mountdiskless(char *,
-		    struct sockaddr_in *, struct nfs_args *,
-		    struct thread *, struct vnode **, struct mount *);
-static void	nfs_convert_diskless(void);
-static void	nfs_convert_oargs(struct nfs_args *args,
-		    struct onfs_args *oargs);
-
-int
-nfs_iosize(struct nfsmount *nmp)
-{
-	int iosize;
-
-	/*
-	 * Calculate the size used for io buffers.  Use the larger
-	 * of the two sizes to minimise nfs requests but make sure
-	 * that it is at least one VM page to avoid wasting buffer
-	 * space.
-	 */
-	iosize = imax(nmp->nm_rsize, nmp->nm_wsize);
-	iosize = imax(iosize, PAGE_SIZE);
-	return (iosize);
-}
-
-static void
-nfs_convert_oargs(struct nfs_args *args, struct onfs_args *oargs)
-{
-
-	args->version = NFS_ARGSVERSION;
-	args->addr = oargs->addr;
-	args->addrlen = oargs->addrlen;
-	args->sotype = oargs->sotype;
-	args->proto = oargs->proto;
-	args->fh = oargs->fh;
-	args->fhsize = oargs->fhsize;
-	args->flags = oargs->flags;
-	args->wsize = oargs->wsize;
-	args->rsize = oargs->rsize;
-	args->readdirsize = oargs->readdirsize;
-	args->timeo = oargs->timeo;
-	args->retrans = oargs->retrans;
-	args->maxgrouplist = oargs->maxgrouplist;
-	args->readahead = oargs->readahead;
-	args->deadthresh = oargs->deadthresh;
-	args->hostname = oargs->hostname;
-}
-
-static void
-nfs_convert_diskless(void)
-{
-
-	bcopy(&nfs_diskless.myif, &nfsv3_diskless.myif,
-		sizeof(struct ifaliasreq));
-	bcopy(&nfs_diskless.mygateway, &nfsv3_diskless.mygateway,
-		sizeof(struct sockaddr_in));
-	nfs_convert_oargs(&nfsv3_diskless.root_args,&nfs_diskless.root_args);
-	if (nfsv3_diskless.root_args.flags & NFSMNT_NFSV3) {
-		nfsv3_diskless.root_fhsize = NFSX_V3FH;
-		bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V3FH);
-	} else {
-		nfsv3_diskless.root_fhsize = NFSX_V2FH;
-		bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V2FH);
-	}
-	bcopy(&nfs_diskless.root_saddr,&nfsv3_diskless.root_saddr,
-		sizeof(struct sockaddr_in));
-	bcopy(nfs_diskless.root_hostnam, nfsv3_diskless.root_hostnam, MNAMELEN);
-	nfsv3_diskless.root_time = nfs_diskless.root_time;
-	bcopy(nfs_diskless.my_hostnam, nfsv3_diskless.my_hostnam,
-		MAXHOSTNAMELEN);
-	nfs_diskless_valid = 3;
-}
-
-/*
- * nfs statfs call
- */
-static int
-nfs_statfs(struct mount *mp, struct statfs *sbp)
-{
-	struct vnode *vp;
-	struct thread *td;
-	struct nfs_statfs *sfp;
-	caddr_t bpos, dpos;
-	struct nfsmount *nmp = VFSTONFS(mp);
-	int error = 0, v3 = (nmp->nm_flag & NFSMNT_NFSV3), retattr;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	struct nfsnode *np;
-	u_quad_t tquad;
-
-	td = curthread;
-#ifndef nolint
-	sfp = NULL;
-#endif
-	error = vfs_busy(mp, MBF_NOWAIT);
-	if (error)
-		return (error);
-	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);
-	if (error) {
-		vfs_unbusy(mp);
-		return (error);
-	}
-	vp = NFSTOV(np);
-	mtx_lock(&nmp->nm_mtx);
-	if (v3 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {
-		mtx_unlock(&nmp->nm_mtx);		
-		(void)nfs_fsinfo(nmp, vp, td->td_ucred, td);
-	} else
-		mtx_unlock(&nmp->nm_mtx);
-	nfsstats.rpccnt[NFSPROC_FSSTAT]++;
-	mreq = m_get2(NFSX_FH(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, v3);
-	nfsm_request(vp, NFSPROC_FSSTAT, td, td->td_ucred);
-	if (v3)
-		nfsm_postop_attr(vp, retattr);
-	if (error) {
-		if (mrep != NULL)
-			m_freem(mrep);
-		goto nfsmout;
-	}
-	sfp = nfsm_dissect(struct nfs_statfs *, NFSX_STATFS(v3));
-	mtx_lock(&nmp->nm_mtx);
-	sbp->f_iosize = nfs_iosize(nmp);
-	mtx_unlock(&nmp->nm_mtx);
-	if (v3) {
-		sbp->f_bsize = NFS_FABLKSIZE;
-		tquad = fxdr_hyper(&sfp->sf_tbytes);
-		sbp->f_blocks = tquad / NFS_FABLKSIZE;
-		tquad = fxdr_hyper(&sfp->sf_fbytes);
-		sbp->f_bfree = tquad / NFS_FABLKSIZE;
-		tquad = fxdr_hyper(&sfp->sf_abytes);
-		sbp->f_bavail = tquad / NFS_FABLKSIZE;
-		sbp->f_files = (fxdr_unsigned(int32_t,
-		    sfp->sf_tfiles.nfsuquad[1]) & 0x7fffffff);
-		sbp->f_ffree = (fxdr_unsigned(int32_t,
-		    sfp->sf_ffiles.nfsuquad[1]) & 0x7fffffff);
-	} else {
-		sbp->f_bsize = fxdr_unsigned(int32_t, sfp->sf_bsize);
-		sbp->f_blocks = fxdr_unsigned(int32_t, sfp->sf_blocks);
-		sbp->f_bfree = fxdr_unsigned(int32_t, sfp->sf_bfree);
-		sbp->f_bavail = fxdr_unsigned(int32_t, sfp->sf_bavail);
-		sbp->f_files = 0;
-		sbp->f_ffree = 0;
-	}
-	m_freem(mrep);
-nfsmout:
-	vput(vp);
-	vfs_unbusy(mp);
-	return (error);
-}
-
-/*
- * nfs version 3 fsinfo rpc call
- */
-int
-nfs_fsinfo(struct nfsmount *nmp, struct vnode *vp, struct ucred *cred,
-    struct thread *td)
-{
-	struct nfsv3_fsinfo *fsp;
-	u_int32_t pref, max;
-	caddr_t bpos, dpos;
-	int error = 0, retattr;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	u_int64_t maxfsize;
-	
-	nfsstats.rpccnt[NFSPROC_FSINFO]++;
-	mreq = m_get2(NFSX_FH(1), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, 1);
-	nfsm_request(vp, NFSPROC_FSINFO, td, cred);
-	nfsm_postop_attr(vp, retattr);
-	if (!error) {
-		fsp = nfsm_dissect(struct nfsv3_fsinfo *, NFSX_V3FSINFO);
-		pref = fxdr_unsigned(u_int32_t, fsp->fs_wtpref);
-		mtx_lock(&nmp->nm_mtx);
-		if (pref < nmp->nm_wsize && pref >= NFS_FABLKSIZE)
-			nmp->nm_wsize = (pref + NFS_FABLKSIZE - 1) &
-				~(NFS_FABLKSIZE - 1);
-		max = fxdr_unsigned(u_int32_t, fsp->fs_wtmax);
-		if (max < nmp->nm_wsize && max > 0) {
-			nmp->nm_wsize = max & ~(NFS_FABLKSIZE - 1);
-			if (nmp->nm_wsize == 0)
-				nmp->nm_wsize = max;
-		}
-		pref = fxdr_unsigned(u_int32_t, fsp->fs_rtpref);
-		if (pref < nmp->nm_rsize && pref >= NFS_FABLKSIZE)
-			nmp->nm_rsize = (pref + NFS_FABLKSIZE - 1) &
-				~(NFS_FABLKSIZE - 1);
-		max = fxdr_unsigned(u_int32_t, fsp->fs_rtmax);
-		if (max < nmp->nm_rsize && max > 0) {
-			nmp->nm_rsize = max & ~(NFS_FABLKSIZE - 1);
-			if (nmp->nm_rsize == 0)
-				nmp->nm_rsize = max;
-		}
-		pref = fxdr_unsigned(u_int32_t, fsp->fs_dtpref);
-		if (pref < nmp->nm_readdirsize && pref >= NFS_DIRBLKSIZ)
-			nmp->nm_readdirsize = (pref + NFS_DIRBLKSIZ - 1) &
-				~(NFS_DIRBLKSIZ - 1);
-		if (max < nmp->nm_readdirsize && max > 0) {
-			nmp->nm_readdirsize = max & ~(NFS_DIRBLKSIZ - 1);
-			if (nmp->nm_readdirsize == 0)
-				nmp->nm_readdirsize = max;
-		}
-		maxfsize = fxdr_hyper(&fsp->fs_maxfilesize);
-		if (maxfsize > 0 && maxfsize < nmp->nm_maxfilesize)
-			nmp->nm_maxfilesize = maxfsize;
-		nmp->nm_mountp->mnt_stat.f_iosize = nfs_iosize(nmp);
-		nmp->nm_state |= NFSSTA_GOTFSINFO;
-		mtx_unlock(&nmp->nm_mtx);
-	}
-	m_freem(mrep);
-nfsmout:
-	return (error);
-}
-
-/*
- * Mount a remote root fs via. nfs. This depends on the info in the
- * nfs_diskless structure that has been filled in properly by some primary
- * bootstrap.
- * It goes something like this:
- * - do enough of "ifconfig" by calling ifioctl() so that the system
- *   can talk to the server
- * - If nfs_diskless.mygateway is filled in, use that address as
- *   a default gateway.
- * - build the rootfs mount point and call mountnfs() to do the rest.
- *
- * It is assumed to be safe to read, modify, and write the nfsv3_diskless
- * structure, as well as other global NFS client variables here, as
- * nfs_mountroot() will be called once in the boot before any other NFS
- * client activity occurs.
- */
-int
-nfs_mountroot(struct mount *mp)
-{
-	struct thread *td = curthread;
-	struct nfsv3_diskless *nd = &nfsv3_diskless;
-	struct socket *so;
-	struct vnode *vp;
-	struct ifreq ir;
-	int error;
-	u_long l;
-	char buf[128];
-	char *cp;
-
-
-#if defined(BOOTP_NFSROOT) && defined(BOOTP)
-	bootpc_init();		/* use bootp to get nfs_diskless filled in */
-#elif defined(NFS_ROOT)
-	nfs_setup_diskless();
-#endif
-
-	if (nfs_diskless_valid == 0) {
-		return (-1);
-	}
-	if (nfs_diskless_valid == 1)
-		nfs_convert_diskless();
-
-	/*
-	 * XXX splnet, so networks will receive...
-	 */
-	splnet();
-
-	/*
-	 * Do enough of ifconfig(8) so that the critical net interface can
-	 * talk to the server.
-	 */
-	error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0,
-	    td->td_ucred, td);
-	if (error)
-		panic("nfs_mountroot: socreate(%04x): %d",
-			nd->myif.ifra_addr.sa_family, error);
-
-#if 0 /* XXX Bad idea */
-	/*
-	 * We might not have been told the right interface, so we pass
-	 * over the first ten interfaces of the same kind, until we get
-	 * one of them configured.
-	 */
-
-	for (i = strlen(nd->myif.ifra_name) - 1;
-		nd->myif.ifra_name[i] >= '0' &&
-		nd->myif.ifra_name[i] <= '9';
-		nd->myif.ifra_name[i] ++) {
-		error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
-		if(!error)
-			break;
-	}
-#endif
-
-	error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
-	if (error)
-		panic("nfs_mountroot: SIOCAIFADDR: %d", error);
-
-	if ((cp = getenv("boot.netif.mtu")) != NULL) {
-		ir.ifr_mtu = strtol(cp, NULL, 10);
-		bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ);
-		freeenv(cp);
-		error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td);
-		if (error)
-			printf("nfs_mountroot: SIOCSIFMTU: %d", error);
-	}
-	soclose(so);
-
-	/*
-	 * If the gateway field is filled in, set it as the default route.
-	 * Note that pxeboot will set a default route of 0 if the route
-	 * is not set by the DHCP server.  Check also for a value of 0
-	 * to avoid panicking inappropriately in that situation.
-	 */
-	if (nd->mygateway.sin_len != 0 &&
-	    nd->mygateway.sin_addr.s_addr != 0) {
-		struct sockaddr_in mask, sin;
-
-		bzero((caddr_t)&mask, sizeof(mask));
-		sin = mask;
-		sin.sin_family = AF_INET;
-		sin.sin_len = sizeof(sin);
-                /* XXX MRT use table 0 for this sort of thing */
-		CURVNET_SET(TD_TO_VNET(td));
-		error = rtrequest_fib(RTM_ADD, (struct sockaddr *)&sin,
-		    (struct sockaddr *)&nd->mygateway,
-		    (struct sockaddr *)&mask,
-		    RTF_UP | RTF_GATEWAY, NULL, RT_DEFAULT_FIB);
-		CURVNET_RESTORE();
-		if (error)
-			panic("nfs_mountroot: RTM_ADD: %d", error);
-	}
-
-	/*
-	 * Create the rootfs mount point.
-	 */
-	nd->root_args.fh = nd->root_fh;
-	nd->root_args.fhsize = nd->root_fhsize;
-	l = ntohl(nd->root_saddr.sin_addr.s_addr);
-	snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s",
-		(l >> 24) & 0xff, (l >> 16) & 0xff,
-		(l >>  8) & 0xff, (l >>  0) & 0xff, nd->root_hostnam);
-	printf("NFS ROOT: %s\n", buf);
-	nd->root_args.hostname = buf;
-	if ((error = nfs_mountdiskless(buf,
-	    &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) {
-		return (error);
-	}
-
-	/*
-	 * This is not really an nfs issue, but it is much easier to
-	 * set hostname here and then let the "/etc/rc.xxx" files
-	 * mount the right /var based upon its preset value.
-	 */
-	mtx_lock(&prison0.pr_mtx);
-	strlcpy(prison0.pr_hostname, nd->my_hostnam,
-	    sizeof (prison0.pr_hostname));
-	mtx_unlock(&prison0.pr_mtx);
-	inittodr(ntohl(nd->root_time));
-	return (0);
-}
-
-/*
- * Internal version of mount system call for diskless setup.
- */
-static int
-nfs_mountdiskless(char *path,
-    struct sockaddr_in *sin, struct nfs_args *args, struct thread *td,
-    struct vnode **vpp, struct mount *mp)
-{
-	struct sockaddr *nam;
-	int error;
-
-	nam = sodupsockaddr((struct sockaddr *)sin, M_WAITOK);
-	if ((error = mountnfs(args, mp, nam, path, vpp, td->td_ucred,
-	    NFS_DEFAULT_NAMETIMEO, NFS_DEFAULT_NEGNAMETIMEO)) != 0) {
-		printf("nfs_mountroot: mount %s on /: %d\n", path, error);
-		return (error);
-	}
-	return (0);
-}
-
-static int
-nfs_sec_name_to_num(char *sec)
-{
-	if (!strcmp(sec, "krb5"))
-		return (RPCSEC_GSS_KRB5);
-	if (!strcmp(sec, "krb5i"))
-		return (RPCSEC_GSS_KRB5I);
-	if (!strcmp(sec, "krb5p"))
-		return (RPCSEC_GSS_KRB5P);
-	if (!strcmp(sec, "sys"))
-		return (AUTH_SYS);
-	/*
-	 * Userland should validate the string but we will try and
-	 * cope with unexpected values.
-	 */
-	return (AUTH_SYS);
-}
-
-static void
-nfs_decode_args(struct mount *mp, struct nfsmount *nmp, struct nfs_args *argp,
-	const char *hostname)
-{
-	int s;
-	int adjsock;
-	int maxio;
-	char *p;
-	char *secname;
-	char *principal;
-
-	s = splnet();
-
-	/*
-	 * Set read-only flag if requested; otherwise, clear it if this is
-	 * an update.  If this is not an update, then either the read-only
-	 * flag is already clear, or this is a root mount and it was set
-	 * intentionally at some previous point.
-	 */
-	if (vfs_getopt(mp->mnt_optnew, "ro", NULL, NULL) == 0) {
-		MNT_ILOCK(mp);
-		mp->mnt_flag |= MNT_RDONLY;
-		MNT_IUNLOCK(mp);
-	} else if (mp->mnt_flag & MNT_UPDATE) {
-		MNT_ILOCK(mp);
-		mp->mnt_flag &= ~MNT_RDONLY;
-		MNT_IUNLOCK(mp);
-	}
-
-	/*
-	 * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
-	 * no sense in that context.  Also, set up appropriate retransmit
-	 * and soft timeout behavior.
-	 */
-	if (argp->sotype == SOCK_STREAM) {
-		nmp->nm_flag &= ~NFSMNT_NOCONN;
-		nmp->nm_flag |= NFSMNT_DUMBTIMR;
-		nmp->nm_timeo = NFS_MAXTIMEO;
-		nmp->nm_retry = NFS_RETRANS_TCP;
-	}
-
-	/* Also clear RDIRPLUS if not NFSv3, it crashes some servers */
-	if ((argp->flags & NFSMNT_NFSV3) == 0)
-		nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
-
-	/* Re-bind if rsrvd port requested and wasn't on one */
-	adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
-		  && (argp->flags & NFSMNT_RESVPORT);
-	/* Also re-bind if we're switching to/from a connected UDP socket */
-	adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
-		    (argp->flags & NFSMNT_NOCONN));
-
-	/* Update flags atomically.  Don't change the lock bits. */
-	nmp->nm_flag = argp->flags | nmp->nm_flag;
-	splx(s);
-
-	if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
-		nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
-		if (nmp->nm_timeo < NFS_MINTIMEO)
-			nmp->nm_timeo = NFS_MINTIMEO;
-		else if (nmp->nm_timeo > NFS_MAXTIMEO)
-			nmp->nm_timeo = NFS_MAXTIMEO;
-	}
-
-	if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
-		nmp->nm_retry = argp->retrans;
-		if (nmp->nm_retry > NFS_MAXREXMIT)
-			nmp->nm_retry = NFS_MAXREXMIT;
-	}
-
-	if (argp->flags & NFSMNT_NFSV3) {
-		if (argp->sotype == SOCK_DGRAM)
-			maxio = NFS_MAXDGRAMDATA;
-		else
-			maxio = NFS_MAXDATA;
-	} else
-		maxio = NFS_V2MAXDATA;
-
-	if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
-		nmp->nm_wsize = argp->wsize;
-		/* Round down to multiple of blocksize */
-		nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1);
-		if (nmp->nm_wsize <= 0)
-			nmp->nm_wsize = NFS_FABLKSIZE;
-	}
-	if (nmp->nm_wsize > maxio)
-		nmp->nm_wsize = maxio;
-	if (nmp->nm_wsize > MAXBSIZE)
-		nmp->nm_wsize = MAXBSIZE;
-
-	if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
-		nmp->nm_rsize = argp->rsize;
-		/* Round down to multiple of blocksize */
-		nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1);
-		if (nmp->nm_rsize <= 0)
-			nmp->nm_rsize = NFS_FABLKSIZE;
-	}
-	if (nmp->nm_rsize > maxio)
-		nmp->nm_rsize = maxio;
-	if (nmp->nm_rsize > MAXBSIZE)
-		nmp->nm_rsize = MAXBSIZE;
-
-	if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
-		nmp->nm_readdirsize = argp->readdirsize;
-	}
-	if (nmp->nm_readdirsize > maxio)
-		nmp->nm_readdirsize = maxio;
-	if (nmp->nm_readdirsize > nmp->nm_rsize)
-		nmp->nm_readdirsize = nmp->nm_rsize;
-
-	if ((argp->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0)
-		nmp->nm_acregmin = argp->acregmin;
-	else
-		nmp->nm_acregmin = NFS_MINATTRTIMO;
-	if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0)
-		nmp->nm_acregmax = argp->acregmax;
-	else
-		nmp->nm_acregmax = NFS_MAXATTRTIMO;
-	if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0)
-		nmp->nm_acdirmin = argp->acdirmin;
-	else
-		nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
-	if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0)
-		nmp->nm_acdirmax = argp->acdirmax;
-	else
-		nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
-	if (nmp->nm_acdirmin > nmp->nm_acdirmax)
-		nmp->nm_acdirmin = nmp->nm_acdirmax;
-	if (nmp->nm_acregmin > nmp->nm_acregmax)
-		nmp->nm_acregmin = nmp->nm_acregmax;
-
-	if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0) {
-		if (argp->maxgrouplist <= NFS_MAXGRPS)
-			nmp->nm_numgrps = argp->maxgrouplist;
-		else
-			nmp->nm_numgrps = NFS_MAXGRPS;
-	}
-	if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) {
-		if (argp->readahead <= NFS_MAXRAHEAD)
-			nmp->nm_readahead = argp->readahead;
-		else
-			nmp->nm_readahead = NFS_MAXRAHEAD;
-	}
-	if ((argp->flags & NFSMNT_WCOMMITSIZE) && argp->wcommitsize >= 0) {
-		if (argp->wcommitsize < nmp->nm_wsize)
-			nmp->nm_wcommitsize = nmp->nm_wsize;
-		else
-			nmp->nm_wcommitsize = argp->wcommitsize;
-	}
-	if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 0) {
-		if (argp->deadthresh <= NFS_MAXDEADTHRESH)
-			nmp->nm_deadthresh = argp->deadthresh;
-		else
-			nmp->nm_deadthresh = NFS_MAXDEADTHRESH;
-	}
-
-	adjsock |= ((nmp->nm_sotype != argp->sotype) ||
-		    (nmp->nm_soproto != argp->proto));
-	nmp->nm_sotype = argp->sotype;
-	nmp->nm_soproto = argp->proto;
-
-	if (nmp->nm_client && adjsock) {
-		nfs_safedisconnect(nmp);
-		if (nmp->nm_sotype == SOCK_DGRAM)
-			while (nfs_connect(nmp)) {
-				printf("nfs_args: retrying connect\n");
-				(void) tsleep(&fake_wchan, PSOCK, "nfscon", hz);
-			}
-	}
-
-	if (hostname) {
-		strlcpy(nmp->nm_hostname, hostname,
-		    sizeof(nmp->nm_hostname));
-		p = strchr(nmp->nm_hostname, ':');
-		if (p)
-			*p = '\0';
-	}
-
-	if (vfs_getopt(mp->mnt_optnew, "sec",
-		(void **) &secname, NULL) == 0) {
-		nmp->nm_secflavor = nfs_sec_name_to_num(secname);
-	} else {
-		nmp->nm_secflavor = AUTH_SYS;
-	}
-
-	if (vfs_getopt(mp->mnt_optnew, "principal",
-		(void **) &principal, NULL) == 0) {
-		strlcpy(nmp->nm_principal, principal,
-		    sizeof(nmp->nm_principal));
-	} else {
-		snprintf(nmp->nm_principal, sizeof(nmp->nm_principal),
-		    "nfs@%s", nmp->nm_hostname);
-	}
-}
-
-static const char *nfs_opts[] = { "from", "nfs_args",
-    "noatime", "noexec", "suiddir", "nosuid", "nosymfollow", "union",
-    "noclusterr", "noclusterw", "multilabel", "acls", "force", "update",
-    "async", "dumbtimer", "noconn", "nolockd", "intr", "rdirplus", "resvport",
-    "readahead", "readdirsize", "soft", "hard", "mntudp", "tcp", "udp",
-    "wsize", "rsize", "retrans", "acregmin", "acregmax", "acdirmin",
-    "acdirmax", "deadthresh", "hostname", "timeout", "addr", "fh", "nfsv3",
-    "sec", "maxgroups", "principal", "negnametimeo", "nocto", "wcommitsize",
-    "nametimeo",
-    NULL };
-
-/*
- * VFS Operations.
- *
- * mount system call
- * It seems a bit dumb to copyinstr() the host and path here and then
- * bcopy() them in mountnfs(), but I wanted to detect errors before
- * doing the sockargs() call because sockargs() allocates an mbuf and
- * an error after that means that I have to release the mbuf.
- */
-/* ARGSUSED */
-static int
-nfs_mount(struct mount *mp)
-{
-	struct nfs_args args = {
-	    .version = NFS_ARGSVERSION,
-	    .addr = NULL,
-	    .addrlen = sizeof (struct sockaddr_in),
-	    .sotype = SOCK_STREAM,
-	    .proto = 0,
-	    .fh = NULL,
-	    .fhsize = 0,
-	    .flags = NFSMNT_RESVPORT,
-	    .wsize = NFS_WSIZE,
-	    .rsize = NFS_RSIZE,
-	    .readdirsize = NFS_READDIRSIZE,
-	    .timeo = 10,
-	    .retrans = NFS_RETRANS,
-	    .maxgrouplist = NFS_MAXGRPS,
-	    .readahead = NFS_DEFRAHEAD,
-	    .wcommitsize = 0,			/* was: NQ_DEFLEASE */
-	    .deadthresh = NFS_MAXDEADTHRESH,	/* was: NQ_DEADTHRESH */
-	    .hostname = NULL,
-	    /* args version 4 */
-	    .acregmin = NFS_MINATTRTIMO,
-	    .acregmax = NFS_MAXATTRTIMO,
-	    .acdirmin = NFS_MINDIRATTRTIMO,
-	    .acdirmax = NFS_MAXDIRATTRTIMO,
-	};
-	int error, ret, has_nfs_args_opt;
-	int has_addr_opt, has_fh_opt, has_hostname_opt;
-	struct sockaddr *nam;
-	struct vnode *vp;
-	char hst[MNAMELEN];
-	size_t len;
-	u_char nfh[NFSX_V3FHMAX];
-	char *opt;
-	int nametimeo = NFS_DEFAULT_NAMETIMEO;
-	int negnametimeo = NFS_DEFAULT_NEGNAMETIMEO;
-
-	has_nfs_args_opt = 0;
-	has_addr_opt = 0;
-	has_fh_opt = 0;
-	has_hostname_opt = 0;
-
-	if (vfs_filteropt(mp->mnt_optnew, nfs_opts)) {
-		error = EINVAL;
-		goto out;
-	}
-
-	if ((mp->mnt_flag & (MNT_ROOTFS | MNT_UPDATE)) == MNT_ROOTFS) {
-		error = nfs_mountroot(mp);
-		goto out;
-	}
-
-	/*
-	 * The old mount_nfs program passed the struct nfs_args
-	 * from userspace to kernel.  The new mount_nfs program
-	 * passes string options via nmount() from userspace to kernel
-	 * and we populate the struct nfs_args in the kernel.
-	 */
-	if (vfs_getopt(mp->mnt_optnew, "nfs_args", NULL, NULL) == 0) {
-		error = vfs_copyopt(mp->mnt_optnew, "nfs_args", &args,
-		    sizeof args);
-		if (error)
-			goto out;
-
-		if (args.version != NFS_ARGSVERSION) {
-			error = EPROGMISMATCH;
-			goto out;
-		}
-		has_nfs_args_opt = 1;
-	}
-
-	if (vfs_getopt(mp->mnt_optnew, "dumbtimer", NULL, NULL) == 0)
-		args.flags |= NFSMNT_DUMBTIMR;
-	if (vfs_getopt(mp->mnt_optnew, "noconn", NULL, NULL) == 0)
-		args.flags |= NFSMNT_NOCONN;
-	if (vfs_getopt(mp->mnt_optnew, "conn", NULL, NULL) == 0)
-		args.flags |= NFSMNT_NOCONN;
-	if (vfs_getopt(mp->mnt_optnew, "nolockd", NULL, NULL) == 0)
-		args.flags |= NFSMNT_NOLOCKD;
-	if (vfs_getopt(mp->mnt_optnew, "lockd", NULL, NULL) == 0)
-		args.flags &= ~NFSMNT_NOLOCKD;
-	if (vfs_getopt(mp->mnt_optnew, "intr", NULL, NULL) == 0)
-		args.flags |= NFSMNT_INT;
-	if (vfs_getopt(mp->mnt_optnew, "rdirplus", NULL, NULL) == 0)
-		args.flags |= NFSMNT_RDIRPLUS;
-	if (vfs_getopt(mp->mnt_optnew, "resvport", NULL, NULL) == 0)
-		args.flags |= NFSMNT_RESVPORT;
-	if (vfs_getopt(mp->mnt_optnew, "noresvport", NULL, NULL) == 0)
-		args.flags &= ~NFSMNT_RESVPORT;
-	if (vfs_getopt(mp->mnt_optnew, "soft", NULL, NULL) == 0)
-		args.flags |= NFSMNT_SOFT;
-	if (vfs_getopt(mp->mnt_optnew, "hard", NULL, NULL) == 0)
-		args.flags &= ~NFSMNT_SOFT;
-	if (vfs_getopt(mp->mnt_optnew, "mntudp", NULL, NULL) == 0)
-		args.sotype = SOCK_DGRAM;
-	if (vfs_getopt(mp->mnt_optnew, "udp", NULL, NULL) == 0)
-		args.sotype = SOCK_DGRAM;
-	if (vfs_getopt(mp->mnt_optnew, "tcp", NULL, NULL) == 0)
-		args.sotype = SOCK_STREAM;
-	if (vfs_getopt(mp->mnt_optnew, "nfsv3", NULL, NULL) == 0)
-		args.flags |= NFSMNT_NFSV3;
-	if (vfs_getopt(mp->mnt_optnew, "nocto", NULL, NULL) == 0)
-		args.flags |= NFSMNT_NOCTO;
-	if (vfs_getopt(mp->mnt_optnew, "readdirsize", (void **)&opt, NULL) == 0) {
-		if (opt == NULL) { 
-			vfs_mount_error(mp, "illegal readdirsize");
-			error = EINVAL;
-			goto out;
-		}
-		ret = sscanf(opt, "%d", &args.readdirsize);
-		if (ret != 1 || args.readdirsize <= 0) {
-			vfs_mount_error(mp, "illegal readdirsize: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_READDIRSIZE;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "readahead", (void **)&opt, NULL) == 0) {
-		if (opt == NULL) { 
-			vfs_mount_error(mp, "illegal readahead");
-			error = EINVAL;
-			goto out;
-		}
-		ret = sscanf(opt, "%d", &args.readahead);
-		if (ret != 1 || args.readahead <= 0) {
-			vfs_mount_error(mp, "illegal readahead: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_READAHEAD;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "wsize", (void **)&opt, NULL) == 0) {
-		if (opt == NULL) { 
-			vfs_mount_error(mp, "illegal wsize");
-			error = EINVAL;
-			goto out;
-		}
-		ret = sscanf(opt, "%d", &args.wsize);
-		if (ret != 1 || args.wsize <= 0) {
-			vfs_mount_error(mp, "illegal wsize: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_WSIZE;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "rsize", (void **)&opt, NULL) == 0) {
-		if (opt == NULL) { 
-			vfs_mount_error(mp, "illegal rsize");
-			error = EINVAL;
-			goto out;
-		}
-		ret = sscanf(opt, "%d", &args.rsize);
-		if (ret != 1 || args.rsize <= 0) {
-			vfs_mount_error(mp, "illegal wsize: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_RSIZE;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "retrans", (void **)&opt, NULL) == 0) {
-		if (opt == NULL) { 
-			vfs_mount_error(mp, "illegal retrans");
-			error = EINVAL;
-			goto out;
-		}
-		ret = sscanf(opt, "%d", &args.retrans);
-		if (ret != 1 || args.retrans <= 0) {
-			vfs_mount_error(mp, "illegal retrans: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_RETRANS;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "acregmin", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.acregmin);
-		if (ret != 1 || args.acregmin < 0) {
-			vfs_mount_error(mp, "illegal acregmin: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_ACREGMIN;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "acregmax", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.acregmax);
-		if (ret != 1 || args.acregmax < 0) {
-			vfs_mount_error(mp, "illegal acregmax: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_ACREGMAX;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "acdirmin", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.acdirmin);
-		if (ret != 1 || args.acdirmin < 0) {
-			vfs_mount_error(mp, "illegal acdirmin: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_ACDIRMIN;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "acdirmax", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.acdirmax);
-		if (ret != 1 || args.acdirmax < 0) {
-			vfs_mount_error(mp, "illegal acdirmax: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_ACDIRMAX;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "wcommitsize", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.wcommitsize);
-		if (ret != 1 || args.wcommitsize < 0) {
-			vfs_mount_error(mp, "illegal wcommitsize: %s", opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_WCOMMITSIZE;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "deadthresh", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.deadthresh);
-		if (ret != 1 || args.deadthresh <= 0) {
-			vfs_mount_error(mp, "illegal deadthresh: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_DEADTHRESH;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "timeout", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.timeo);
-		if (ret != 1 || args.timeo <= 0) {
-			vfs_mount_error(mp, "illegal timeout: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_TIMEO;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "maxgroups", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &args.maxgrouplist);
-		if (ret != 1 || args.maxgrouplist <= 0) {
-			vfs_mount_error(mp, "illegal maxgroups: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-		args.flags |= NFSMNT_MAXGRPS;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "nametimeo", (void **)&opt, NULL) == 0) {
-		ret = sscanf(opt, "%d", &nametimeo);
-		if (ret != 1 || nametimeo < 0) {
-			vfs_mount_error(mp, "illegal nametimeo: %s", opt);
-			error = EINVAL;
-			goto out;
-		}
-	}
-	if (vfs_getopt(mp->mnt_optnew, "negnametimeo", (void **)&opt, NULL)
-	    == 0) {
-		ret = sscanf(opt, "%d", &negnametimeo);
-		if (ret != 1 || negnametimeo < 0) {
-			vfs_mount_error(mp, "illegal negnametimeo: %s",
-			    opt);
-			error = EINVAL;
-			goto out;
-		}
-	}
-	if (vfs_getopt(mp->mnt_optnew, "addr", (void **)&args.addr,
-		&args.addrlen) == 0) {
-		has_addr_opt = 1;
-		if (args.addrlen > SOCK_MAXADDRLEN) {
-			error = ENAMETOOLONG;
-			goto out;
-		}
-		nam = malloc(args.addrlen, M_SONAME,
-		    M_WAITOK);
-		bcopy(args.addr, nam, args.addrlen);
-		nam->sa_len = args.addrlen;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "fh", (void **)&args.fh,
-		&args.fhsize) == 0) {
-		has_fh_opt = 1;
-	}
-	if (vfs_getopt(mp->mnt_optnew, "hostname", (void **)&args.hostname,
-		NULL) == 0) {
-		has_hostname_opt = 1;
-	}
-	if (args.hostname == NULL) {
-		vfs_mount_error(mp, "Invalid hostname");
-		error = EINVAL;
-		goto out;
-	}
-	if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX) {
-		vfs_mount_error(mp, "Bad file handle");
-		error = EINVAL;
-		goto out;
-	}
-
-	if (mp->mnt_flag & MNT_UPDATE) {
-		struct nfsmount *nmp = VFSTONFS(mp);
-
-		if (nmp == NULL) {
-			error = EIO;
-			goto out;
-		}
-
-		/*
-		 * If a change from TCP->UDP is done and there are thread(s)
-		 * that have I/O RPC(s) in progress with a tranfer size
-		 * greater than NFS_MAXDGRAMDATA, those thread(s) will be
-		 * hung, retrying the RPC(s) forever. Usually these threads
-		 * will be seen doing an uninterruptible sleep on wait channel
-		 * "newnfsreq" (truncated to "newnfsre" by procstat).
-		 */
-		if (args.sotype == SOCK_DGRAM && nmp->nm_sotype == SOCK_STREAM)
-			tprintf(curthread->td_proc, LOG_WARNING,
-	"Warning: mount -u that changes TCP->UDP can result in hung threads\n");
-
-		/*
-		 * When doing an update, we can't change from or to
-		 * v3, switch lockd strategies or change cookie translation
-		 */
-		args.flags = (args.flags &
-		    ~(NFSMNT_NFSV3 | NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)) |
-		    (nmp->nm_flag &
-			(NFSMNT_NFSV3 | NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/));
-		nfs_decode_args(mp, nmp, &args, NULL);
-		goto out;
-	}
-
-	/*
-	 * Make the nfs_ip_paranoia sysctl serve as the default connection
-	 * or no-connection mode for those protocols that support 
-	 * no-connection mode (the flag will be cleared later for protocols
-	 * that do not support no-connection mode).  This will allow a client
-	 * to receive replies from a different IP then the request was
-	 * sent to.  Note: default value for nfs_ip_paranoia is 1 (paranoid),
-	 * not 0.
-	 */
-	if (nfs_ip_paranoia == 0)
-		args.flags |= NFSMNT_NOCONN;
-
-	if (has_nfs_args_opt) {
-		/*
-		 * In the 'nfs_args' case, the pointers in the args
-		 * structure are in userland - we copy them in here.
-		 */
-		if (!has_fh_opt) {
-			error = copyin((caddr_t)args.fh, (caddr_t)nfh,
-			    args.fhsize);
-			if (error) {
-				goto out;
-			}
-			args.fh = nfh;
-		}
-		if (!has_hostname_opt) {
-			error = copyinstr(args.hostname, hst, MNAMELEN-1, &len);
-			if (error) {
-				goto out;
-			}
-			bzero(&hst[len], MNAMELEN - len);
-			args.hostname = hst;
-		}
-		if (!has_addr_opt) {
-			/* sockargs() call must be after above copyin() calls */
-			error = getsockaddr(&nam, (caddr_t)args.addr,
-			    args.addrlen);
-			if (error) {
-				goto out;
-			}
-		}
-	} else if (has_addr_opt == 0) {
-		vfs_mount_error(mp, "No server address");
-		error = EINVAL;
-		goto out;
-	}
-	error = mountnfs(&args, mp, nam, args.hostname, &vp,
-	    curthread->td_ucred, nametimeo, negnametimeo);
-out:
-	if (!error) {
-		MNT_ILOCK(mp);
-		mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED;
-		MNT_IUNLOCK(mp);
-	}
-	return (error);
-}
-
-
-/*
- * VFS Operations.
- *
- * mount system call
- * It seems a bit dumb to copyinstr() the host and path here and then
- * bcopy() them in mountnfs(), but I wanted to detect errors before
- * doing the sockargs() call because sockargs() allocates an mbuf and
- * an error after that means that I have to release the mbuf.
- */
-/* ARGSUSED */
-static int
-nfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
-{
-	int error;
-	struct nfs_args args;
-
-	error = copyin(data, &args, sizeof (struct nfs_args));
-	if (error)
-		return error;
-
-	ma = mount_arg(ma, "nfs_args", &args, sizeof args);
-
-	error = kernel_mount(ma, flags);
-	return (error);
-}
-
-/*
- * Common code for mount and mountroot
- */
-static int
-mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
-    char *hst, struct vnode **vpp, struct ucred *cred, int nametimeo,
-    int negnametimeo)
-{
-	struct nfsmount *nmp;
-	struct nfsnode *np;
-	int error;
-	struct vattr attrs;
-
-	if (mp->mnt_flag & MNT_UPDATE) {
-		nmp = VFSTONFS(mp);
-		printf("%s: MNT_UPDATE is no longer handled here\n", __func__);
-		free(nam, M_SONAME);
-		return (0);
-	} else {
-		nmp = uma_zalloc(nfsmount_zone, M_WAITOK);
-		bzero((caddr_t)nmp, sizeof (struct nfsmount));
-		TAILQ_INIT(&nmp->nm_bufq);
-		mp->mnt_data = nmp;
-		nmp->nm_getinfo = nfs_getnlminfo;
-		nmp->nm_vinvalbuf = nfs_vinvalbuf;
-	}
-	vfs_getnewfsid(mp);
-	nmp->nm_mountp = mp;
-	mtx_init(&nmp->nm_mtx, "NFSmount lock", NULL, MTX_DEF);			
-
-	/*
-	 * V2 can only handle 32 bit filesizes.  A 4GB-1 limit may be too
-	 * high, depending on whether we end up with negative offsets in
-	 * the client or server somewhere.  2GB-1 may be safer.
-	 *
-	 * For V3, nfs_fsinfo will adjust this as necessary.  Assume maximum
-	 * that we can handle until we find out otherwise.
-	 */
-	if ((argp->flags & NFSMNT_NFSV3) == 0)
-		nmp->nm_maxfilesize = 0xffffffffLL;
-	else
-		nmp->nm_maxfilesize = OFF_MAX;
-
-	nmp->nm_timeo = NFS_TIMEO;
-	nmp->nm_retry = NFS_RETRANS;
-	if ((argp->flags & NFSMNT_NFSV3) && argp->sotype == SOCK_STREAM) {
-		nmp->nm_wsize = nmp->nm_rsize = NFS_MAXDATA;
-	} else {
-		nmp->nm_wsize = NFS_WSIZE;
-		nmp->nm_rsize = NFS_RSIZE;
-	}
-	nmp->nm_wcommitsize = hibufspace / (desiredvnodes / 1000);
-	nmp->nm_readdirsize = NFS_READDIRSIZE;
-	nmp->nm_numgrps = NFS_MAXGRPS;
-	nmp->nm_readahead = NFS_DEFRAHEAD;
-	nmp->nm_deadthresh = NFS_MAXDEADTHRESH;
-	nmp->nm_nametimeo = nametimeo;
-	nmp->nm_negnametimeo = negnametimeo;
-	nmp->nm_tprintf_delay = nfs_tprintf_delay;
-	if (nmp->nm_tprintf_delay < 0)
-		nmp->nm_tprintf_delay = 0;
-	nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay;
-	if (nmp->nm_tprintf_initial_delay < 0)
-		nmp->nm_tprintf_initial_delay = 0;
-	nmp->nm_fhsize = argp->fhsize;
-	bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
-	bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
-	nmp->nm_nam = nam;
-	/* Set up the sockets and per-host congestion */
-	nmp->nm_sotype = argp->sotype;
-	nmp->nm_soproto = argp->proto;
-	nmp->nm_rpcops = &nfs_rpcops;
-
-	nfs_decode_args(mp, nmp, argp, hst);
-
-	/*
-	 * For Connection based sockets (TCP,...) defer the connect until
-	 * the first request, in case the server is not responding.
-	 */
-	if (nmp->nm_sotype == SOCK_DGRAM &&
-		(error = nfs_connect(nmp)))
-		goto bad;
-
-	/*
-	 * This is silly, but it has to be set so that vinifod() works.
-	 * We do not want to do an nfs_statfs() here since we can get
-	 * stuck on a dead server and we are holding a lock on the mount
-	 * point.
-	 */
-	mtx_lock(&nmp->nm_mtx);
-	mp->mnt_stat.f_iosize = nfs_iosize(nmp);
-	mtx_unlock(&nmp->nm_mtx);
-	/*
-	 * A reference count is needed on the nfsnode representing the
-	 * remote root.  If this object is not persistent, then backward
-	 * traversals of the mount point (i.e. "..") will not work if
-	 * the nfsnode gets flushed out of the cache. Ufs does not have
-	 * this problem, because one can identify root inodes by their
-	 * number == ROOTINO (2).
-	 */
-	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);
-	if (error)
-		goto bad;
-	*vpp = NFSTOV(np);
-
-	/*
-	 * Get file attributes and transfer parameters for the
-	 * mountpoint.  This has the side effect of filling in
-	 * (*vpp)->v_type with the correct value.
-	 */
-	if (argp->flags & NFSMNT_NFSV3)
-		nfs_fsinfo(nmp, *vpp, curthread->td_ucred, curthread);
-	else
-		VOP_GETATTR(*vpp, &attrs, curthread->td_ucred);
-
-	/*
-	 * Lose the lock but keep the ref.
-	 */
-	VOP_UNLOCK(*vpp, 0);
-
-	return (0);
-bad:
-	nfs_disconnect(nmp);
-	mtx_destroy(&nmp->nm_mtx);
-	uma_zfree(nfsmount_zone, nmp);
-	free(nam, M_SONAME);
-	return (error);
-}
-
-/*
- * unmount system call
- */
-static int
-nfs_unmount(struct mount *mp, int mntflags)
-{
-	struct nfsmount *nmp;
-	int error, flags = 0, i;
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-	nmp = VFSTONFS(mp);
-	/*
-	 * Goes something like this..
-	 * - Call vflush() to clear out vnodes for this filesystem
-	 * - Close the socket
-	 * - Free up the data structures
-	 */
-	/* In the forced case, cancel any outstanding requests. */
-	if (flags & FORCECLOSE) {
-		error = nfs_nmcancelreqs(nmp);
-		if (error)
-			goto out;
-	}
-	/* We hold 1 extra ref on the root vnode; see comment in mountnfs(). */
-	error = vflush(mp, 1, flags, curthread);
-	if (error)
-		goto out;
-
-	/*
-	 * We are now committed to the unmount.
-	 */
-	/* Make sure no nfsiods are assigned to this mount. */
-	mtx_lock(&nfs_iod_mtx);
-	for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
-		if (nfs_iodmount[i] == nmp) {
-			nfs_iodwant[i] = NFSIOD_AVAILABLE;
-			nfs_iodmount[i] = NULL;
-		}
-	mtx_unlock(&nfs_iod_mtx);
-	nfs_disconnect(nmp);
-	free(nmp->nm_nam, M_SONAME);
-
-	mtx_destroy(&nmp->nm_mtx);
-	uma_zfree(nfsmount_zone, nmp);
-out:
-	return (error);
-}
-
-/*
- * Return root of a filesystem
- */
-static int
-nfs_root(struct mount *mp, int flags, struct vnode **vpp)
-{
-	struct vnode *vp;
-	struct nfsmount *nmp;
-	struct nfsnode *np;
-	int error;
-
-	nmp = VFSTONFS(mp);
-	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, flags);
-	if (error)
-		return error;
-	vp = NFSTOV(np);
-	/*
-	 * Get transfer parameters and attributes for root vnode once.
-	 */
-	mtx_lock(&nmp->nm_mtx);
-	if ((nmp->nm_state & NFSSTA_GOTFSINFO) == 0 &&
-	    (nmp->nm_flag & NFSMNT_NFSV3)) {
-		mtx_unlock(&nmp->nm_mtx);
-		nfs_fsinfo(nmp, vp, curthread->td_ucred, curthread);
-	} else 
-		mtx_unlock(&nmp->nm_mtx);
-	if (vp->v_type == VNON)
-	    vp->v_type = VDIR;
-	vp->v_vflag |= VV_ROOT;
-	*vpp = vp;
-	return (0);
-}
-
-/*
- * Flush out the buffer cache
- */
-/* ARGSUSED */
-static int
-nfs_sync(struct mount *mp, int waitfor)
-{
-	struct vnode *vp, *mvp;
-	struct thread *td;
-	int error, allerror = 0;
-
-	td = curthread;
-
-	MNT_ILOCK(mp);
-	/*
-	 * If a forced dismount is in progress, return from here so that
-	 * the umount(2) syscall doesn't get stuck in VFS_SYNC() before
-	 * calling VFS_UNMOUNT().
-	 */
-	if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
-		MNT_IUNLOCK(mp);
-		return (EBADF);
-	}
-	MNT_IUNLOCK(mp);
-
-	/*
-	 * Force stale buffer cache information to be flushed.
-	 */
-loop:
-	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
-		/* XXX Racy bv_cnt check. */
-		if (VOP_ISLOCKED(vp) || vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
-		    waitfor == MNT_LAZY) {
-			VI_UNLOCK(vp);
-			continue;
-		}
-		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
-			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
-			goto loop;
-		}
-		error = VOP_FSYNC(vp, waitfor, td);
-		if (error)
-			allerror = error;
-		VOP_UNLOCK(vp, 0);
-		vrele(vp);
-	}
-	return (allerror);
-}
-
-static int
-nfs_sysctl(struct mount *mp, fsctlop_t op, struct sysctl_req *req)
-{
-	struct nfsmount *nmp = VFSTONFS(mp);
-	struct vfsquery vq;
-	int error;
-
-	bzero(&vq, sizeof(vq));
-	switch (op) {
-#if 0
-	case VFS_CTL_NOLOCKS:
-		val = (nmp->nm_flag & NFSMNT_NOLOCKS) ? 1 : 0;
- 		if (req->oldptr != NULL) {
- 			error = SYSCTL_OUT(req, &val, sizeof(val));
- 			if (error)
- 				return (error);
- 		}
- 		if (req->newptr != NULL) {
- 			error = SYSCTL_IN(req, &val, sizeof(val));
- 			if (error)
- 				return (error);
-			if (val)
-				nmp->nm_flag |= NFSMNT_NOLOCKS;
-			else
-				nmp->nm_flag &= ~NFSMNT_NOLOCKS;
- 		}
-		break;
-#endif
-	case VFS_CTL_QUERY:
-		mtx_lock(&nmp->nm_mtx);
-		if (nmp->nm_state & NFSSTA_TIMEO)
-			vq.vq_flags |= VQ_NOTRESP;
-		mtx_unlock(&nmp->nm_mtx);
-#if 0
-		if (!(nmp->nm_flag & NFSMNT_NOLOCKS) &&
-		    (nmp->nm_state & NFSSTA_LOCKTIMEO))
-			vq.vq_flags |= VQ_NOTRESPLOCK;
-#endif
-		error = SYSCTL_OUT(req, &vq, sizeof(vq));
-		break;
- 	case VFS_CTL_TIMEO:
- 		if (req->oldptr != NULL) {
- 			error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay,
- 			    sizeof(nmp->nm_tprintf_initial_delay));
- 			if (error)
- 				return (error);
- 		}
- 		if (req->newptr != NULL) {
-			error = vfs_suser(mp, req->td);
-			if (error)
-				return (error);
- 			error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay,
- 			    sizeof(nmp->nm_tprintf_initial_delay));
- 			if (error)
- 				return (error);
- 			if (nmp->nm_tprintf_initial_delay < 0)
- 				nmp->nm_tprintf_initial_delay = 0;
- 		}
-		break;
-	default:
-		return (ENOTSUP);
-	}
-	return (0);
-}
-
-/*
- * Extract the information needed by the nlm from the nfs vnode.
- */
-static void
-nfs_getnlminfo(struct vnode *vp, uint8_t *fhp, size_t *fhlenp,
-    struct sockaddr_storage *sp, int *is_v3p, off_t *sizep,
-    struct timeval *timeop)
-{
-	struct nfsmount *nmp;
-	struct nfsnode *np = VTONFS(vp);
-
-	nmp = VFSTONFS(vp->v_mount);
-	if (fhlenp != NULL)
-		*fhlenp = (size_t)np->n_fhsize;
-	if (fhp != NULL)
-		bcopy(np->n_fhp, fhp, np->n_fhsize);
-	if (sp != NULL)
-		bcopy(nmp->nm_nam, sp, min(nmp->nm_nam->sa_len, sizeof(*sp)));
-	if (is_v3p != NULL)
-		*is_v3p = NFS_ISV3(vp);
-	if (sizep != NULL)
-		*sizep = np->n_size;
-	if (timeop != NULL) {
-		timeop->tv_sec = nmp->nm_timeo / NFS_HZ;
-		timeop->tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ);
-	}
-}
-
diff --git a/sys/nfsclient/nfs_vnops.c b/sys/nfsclient/nfs_vnops.c
deleted file mode 100644
index a841f65..0000000
--- a/sys/nfsclient/nfs_vnops.c
+++ /dev/null
@@ -1,3545 +0,0 @@
-/*-
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Rick Macklem at The University of Guelph.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)nfs_vnops.c	8.16 (Berkeley) 5/27/95
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-/*
- * vnode op calls for Sun NFS version 2 and 3
- */
-
-#include "opt_inet.h"
-
-#include <sys/param.h>
-#include <sys/kernel.h>
-#include <sys/systm.h>
-#include <sys/resourcevar.h>
-#include <sys/proc.h>
-#include <sys/mount.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/jail.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mbuf.h>
-#include <sys/namei.h>
-#include <sys/socket.h>
-#include <sys/vnode.h>
-#include <sys/dirent.h>
-#include <sys/fcntl.h>
-#include <sys/lockf.h>
-#include <sys/rwlock.h>
-#include <sys/stat.h>
-#include <sys/sysctl.h>
-#include <sys/signalvar.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_object.h>
-
-#include <nfs/nfsproto.h>
-#include <nfsclient/nfs.h>
-#include <nfsclient/nfsnode.h>
-#include <nfsclient/nfsmount.h>
-#include <nfs/nfs_kdtrace.h>
-#include <nfs/nfs_lock.h>
-#include <nfs/xdr_subs.h>
-#include <nfsclient/nfsm_subs.h>
-
-#include <net/if.h>
-#include <net/if_var.h>
-#include <net/vnet.h>
-#include <netinet/in.h>
-#include <netinet/in_var.h>
-
-#include <machine/stdarg.h>
-
-#ifdef KDTRACE_HOOKS
-#include <sys/dtrace_bsd.h>
-
-dtrace_nfsclient_accesscache_flush_probe_func_t
-    dtrace_nfsclient_accesscache_flush_done_probe;
-uint32_t nfsclient_accesscache_flush_done_id;
-
-dtrace_nfsclient_accesscache_get_probe_func_t
-    dtrace_nfsclient_accesscache_get_hit_probe,
-    dtrace_nfsclient_accesscache_get_miss_probe;
-uint32_t nfsclient_accesscache_get_hit_id;
-uint32_t nfsclient_accesscache_get_miss_id;
-
-dtrace_nfsclient_accesscache_load_probe_func_t
-    dtrace_nfsclient_accesscache_load_done_probe;
-uint32_t nfsclient_accesscache_load_done_id;
-#endif /* !KDTRACE_HOOKS */
-
-/* Defs */
-#define	TRUE	1
-#define	FALSE	0
-
-/*
- * Ifdef for FreeBSD-current merged buffer cache. It is unfortunate that these
- * calls are not in getblk() and brelse() so that they would not be necessary
- * here.
- */
-#ifndef B_VMIO
-#define vfs_busy_pages(bp, f)
-#endif
-
-static vop_read_t	nfsfifo_read;
-static vop_write_t	nfsfifo_write;
-static vop_close_t	nfsfifo_close;
-static int	nfs_flush(struct vnode *, int, int);
-static int	nfs_setattrrpc(struct vnode *, struct vattr *, struct ucred *);
-static vop_lookup_t	nfs_lookup;
-static vop_create_t	nfs_create;
-static vop_mknod_t	nfs_mknod;
-static vop_open_t	nfs_open;
-static vop_close_t	nfs_close;
-static vop_access_t	nfs_access;
-static vop_getattr_t	nfs_getattr;
-static vop_setattr_t	nfs_setattr;
-static vop_read_t	nfs_read;
-static vop_fsync_t	nfs_fsync;
-static vop_remove_t	nfs_remove;
-static vop_link_t	nfs_link;
-static vop_rename_t	nfs_rename;
-static vop_mkdir_t	nfs_mkdir;
-static vop_rmdir_t	nfs_rmdir;
-static vop_symlink_t	nfs_symlink;
-static vop_readdir_t	nfs_readdir;
-static vop_strategy_t	nfs_strategy;
-static	int	nfs_lookitup(struct vnode *, const char *, int,
-		    struct ucred *, struct thread *, struct nfsnode **);
-static	int	nfs_sillyrename(struct vnode *, struct vnode *,
-		    struct componentname *);
-static vop_access_t	nfsspec_access;
-static vop_readlink_t	nfs_readlink;
-static vop_print_t	nfs_print;
-static vop_advlock_t	nfs_advlock;
-static vop_advlockasync_t nfs_advlockasync;
-
-/*
- * Global vfs data structures for nfs
- */
-struct vop_vector nfs_vnodeops = {
-	.vop_default =		&default_vnodeops,
-	.vop_access =		nfs_access,
-	.vop_advlock =		nfs_advlock,
-	.vop_advlockasync =	nfs_advlockasync,
-	.vop_close =		nfs_close,
-	.vop_create =		nfs_create,
-	.vop_fsync =		nfs_fsync,
-	.vop_getattr =		nfs_getattr,
-	.vop_getpages =		nfs_getpages,
-	.vop_putpages =		nfs_putpages,
-	.vop_inactive =		nfs_inactive,
-	.vop_link =		nfs_link,
-	.vop_lookup =		nfs_lookup,
-	.vop_mkdir =		nfs_mkdir,
-	.vop_mknod =		nfs_mknod,
-	.vop_open =		nfs_open,
-	.vop_print =		nfs_print,
-	.vop_read =		nfs_read,
-	.vop_readdir =		nfs_readdir,
-	.vop_readlink =		nfs_readlink,
-	.vop_reclaim =		nfs_reclaim,
-	.vop_remove =		nfs_remove,
-	.vop_rename =		nfs_rename,
-	.vop_rmdir =		nfs_rmdir,
-	.vop_setattr =		nfs_setattr,
-	.vop_strategy =		nfs_strategy,
-	.vop_symlink =		nfs_symlink,
-	.vop_write =		nfs_write,
-};
-
-struct vop_vector nfs_fifoops = {
-	.vop_default =		&fifo_specops,
-	.vop_access =		nfsspec_access,
-	.vop_close =		nfsfifo_close,
-	.vop_fsync =		nfs_fsync,
-	.vop_getattr =		nfs_getattr,
-	.vop_inactive =		nfs_inactive,
-	.vop_print =		nfs_print,
-	.vop_read =		nfsfifo_read,
-	.vop_reclaim =		nfs_reclaim,
-	.vop_setattr =		nfs_setattr,
-	.vop_write =		nfsfifo_write,
-};
-
-static int	nfs_mknodrpc(struct vnode *dvp, struct vnode **vpp,
-			     struct componentname *cnp, struct vattr *vap);
-static int	nfs_removerpc(struct vnode *dvp, const char *name, int namelen,
-			      struct ucred *cred, struct thread *td);
-static int	nfs_renamerpc(struct vnode *fdvp, const char *fnameptr,
-			      int fnamelen, struct vnode *tdvp,
-			      const char *tnameptr, int tnamelen,
-			      struct ucred *cred, struct thread *td);
-static int	nfs_renameit(struct vnode *sdvp, struct componentname *scnp,
-			     struct sillyrename *sp);
-
-/*
- * Global variables
- */
-struct mtx 	nfs_iod_mtx;
-enum nfsiod_state nfs_iodwant[NFS_MAXASYNCDAEMON];
-struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON];
-int		 nfs_numasync = 0;
-#define	DIRHDSIZ	(sizeof (struct dirent) - (MAXNAMLEN + 1))
-
-SYSCTL_DECL(_vfs_oldnfs);
-
-static int	nfsaccess_cache_timeout = NFS_MAXATTRTIMO;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, access_cache_timeout, CTLFLAG_RW,
-	   &nfsaccess_cache_timeout, 0, "NFS ACCESS cache timeout");
-
-static int	nfs_prime_access_cache = 0;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, prime_access_cache, CTLFLAG_RW,
-	   &nfs_prime_access_cache, 0,
-	   "Prime NFS ACCESS cache when fetching attributes");
-
-static int	nfsv3_commit_on_close = 0;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfsv3_commit_on_close, CTLFLAG_RW,
-	   &nfsv3_commit_on_close, 0, "write+commit on close, else only write");
-
-static int	nfs_clean_pages_on_close = 1;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, clean_pages_on_close, CTLFLAG_RW,
-	   &nfs_clean_pages_on_close, 0, "NFS clean dirty pages on close");
-
-int nfs_directio_enable = 0;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs_directio_enable, CTLFLAG_RW,
-	   &nfs_directio_enable, 0, "Enable NFS directio");
-
-/*
- * This sysctl allows other processes to mmap a file that has been opened
- * O_DIRECT by a process.  In general, having processes mmap the file while
- * Direct IO is in progress can lead to Data Inconsistencies.  But, we allow
- * this by default to prevent DoS attacks - to prevent a malicious user from
- * opening up files O_DIRECT preventing other users from mmap'ing these
- * files.  "Protected" environments where stricter consistency guarantees are
- * required can disable this knob.  The process that opened the file O_DIRECT
- * cannot mmap() the file, because mmap'ed IO on an O_DIRECT open() is not
- * meaningful.
- */
-int nfs_directio_allow_mmap = 1;
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs_directio_allow_mmap, CTLFLAG_RW,
-	   &nfs_directio_allow_mmap, 0, "Enable mmaped IO on file with O_DIRECT opens");
-
-#if 0
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, access_cache_hits, CTLFLAG_RD,
-	   &nfsstats.accesscache_hits, 0, "NFS ACCESS cache hit count");
-
-SYSCTL_INT(_vfs_oldnfs, OID_AUTO, access_cache_misses, CTLFLAG_RD,
-	   &nfsstats.accesscache_misses, 0, "NFS ACCESS cache miss count");
-#endif
-
-#define	NFSV3ACCESS_ALL (NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY		\
-			 | NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE	\
-			 | NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP)
-
-/*
- * SMP Locking Note :
- * The list of locks after the description of the lock is the ordering
- * of other locks acquired with the lock held.
- * np->n_mtx : Protects the fields in the nfsnode.
-       VM Object Lock
-       VI_MTX (acquired indirectly)
- * nmp->nm_mtx : Protects the fields in the nfsmount.
-       rep->r_mtx
- * nfs_iod_mtx : Global lock, protects shared nfsiod state.
- * nfs_reqq_mtx : Global lock, protects the nfs_reqq list.
-       nmp->nm_mtx
-       rep->r_mtx
- * rep->r_mtx : Protects the fields in an nfsreq.
- */
-
-static int
-nfs3_access_otw(struct vnode *vp, int wmode, struct thread *td,
-    struct ucred *cred, uint32_t *retmode)
-{
-	const int v3 = 1;
-	u_int32_t *tl;
-	int error = 0, attrflag, i, lrupos;
-
-	struct mbuf *mreq, *mrep, *md, *mb;
-	caddr_t bpos, dpos;
-	u_int32_t rmode;
-	struct nfsnode *np = VTONFS(vp);
-
-	nfsstats.rpccnt[NFSPROC_ACCESS]++;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED, M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, v3);
-	tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
-	*tl = txdr_unsigned(wmode);
-	nfsm_request(vp, NFSPROC_ACCESS, td, cred);
-	nfsm_postop_attr(vp, attrflag);
-	if (!error) {
-		lrupos = 0;
-		tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-		rmode = fxdr_unsigned(u_int32_t, *tl);
-		mtx_lock(&np->n_mtx);
-		for (i = 0; i < NFS_ACCESSCACHESIZE; i++) {
-			if (np->n_accesscache[i].uid == cred->cr_uid) {
-				np->n_accesscache[i].mode = rmode;
-				np->n_accesscache[i].stamp = time_second;
-				break;
-			}
-			if (i > 0 && np->n_accesscache[i].stamp <
-			    np->n_accesscache[lrupos].stamp)
-				lrupos = i;
-		}
-		if (i == NFS_ACCESSCACHESIZE) {
-			np->n_accesscache[lrupos].uid = cred->cr_uid;
-			np->n_accesscache[lrupos].mode = rmode;
-			np->n_accesscache[lrupos].stamp = time_second;
-		}
-		mtx_unlock(&np->n_mtx);
-		if (retmode != NULL)
-			*retmode = rmode;
-		KDTRACE_NFS_ACCESSCACHE_LOAD_DONE(vp, cred->cr_uid, rmode, 0);
-	}
-	m_freem(mrep);
-nfsmout:
-#ifdef KDTRACE_HOOKS
-	if (error) {
-		KDTRACE_NFS_ACCESSCACHE_LOAD_DONE(vp, cred->cr_uid, 0,
-		    error);
-	}
-#endif
-	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
- * are changed on the server, accesses might still fail later.
- */
-static int
-nfs_access(struct vop_access_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	int error = 0, i, gotahit;
-	u_int32_t mode, rmode, wmode;
-	int v3 = NFS_ISV3(vp);
-	struct nfsnode *np = VTONFS(vp);
-
-	/*
-	 * 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 ((ap->a_accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
-		switch (vp->v_type) {
-		case VREG:
-		case VDIR:
-		case VLNK:
-			return (EROFS);
-		default:
-			break;
-		}
-	}
-	/*
-	 * For nfs v3, check to see if we have done this recently, and if
-	 * so return our cached result instead of making an ACCESS call.
-	 * If not, 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.
-	 */
-	if (v3) {
-		if (ap->a_accmode & VREAD)
-			mode = NFSV3ACCESS_READ;
-		else
-			mode = 0;
-		if (vp->v_type != VDIR) {
-			if (ap->a_accmode & VWRITE)
-				mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
-			if (ap->a_accmode & VEXEC)
-				mode |= NFSV3ACCESS_EXECUTE;
-		} else {
-			if (ap->a_accmode & VWRITE)
-				mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
-					 NFSV3ACCESS_DELETE);
-			if (ap->a_accmode & VEXEC)
-				mode |= NFSV3ACCESS_LOOKUP;
-		}
-		/* 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?
-		 */
-		gotahit = 0;
-		mtx_lock(&np->n_mtx);
-		for (i = 0; i < NFS_ACCESSCACHESIZE; i++) {
-			if (ap->a_cred->cr_uid == np->n_accesscache[i].uid) {
-				if (time_second < (np->n_accesscache[i].stamp +
-				    nfsaccess_cache_timeout) &&
-				    (np->n_accesscache[i].mode & mode) == mode) {
-					nfsstats.accesscache_hits++;
-					gotahit = 1;
-				}
-				break;
-			}
-		}
-		mtx_unlock(&np->n_mtx);
-#ifdef KDTRACE_HOOKS
-		if (gotahit)
-			KDTRACE_NFS_ACCESSCACHE_GET_HIT(vp,
-			    ap->a_cred->cr_uid, mode);
-		else
-			KDTRACE_NFS_ACCESSCACHE_GET_MISS(vp,
-			    ap->a_cred->cr_uid, mode);
-#endif
-		if (gotahit == 0) {
-			/*
-			 * Either a no, or a don't know.  Go to the wire.
-			 */
-			nfsstats.accesscache_misses++;
-		        error = nfs3_access_otw(vp, wmode, ap->a_td, ap->a_cred,
-			    &rmode);
-			if (!error) {
-				if ((rmode & mode) != mode)
-					error = EACCES;
-			}
-		}
-		return (error);
-	} else {
-		if ((error = nfsspec_access(ap)) != 0) {
-			return (error);
-		}
-		/*
-		 * Attempt to prevent a mapped root from accessing a file
-		 * which it shouldn't.  We try to read a byte from the file
-		 * if the user is root and the file is not zero length.
-		 * After calling nfsspec_access, we should have the correct
-		 * file size cached.
-		 */
-		mtx_lock(&np->n_mtx);
-		if (ap->a_cred->cr_uid == 0 && (ap->a_accmode & VREAD)
-		    && VTONFS(vp)->n_size > 0) {
-			struct iovec aiov;
-			struct uio auio;
-			char buf[1];
-
-			mtx_unlock(&np->n_mtx);
-			aiov.iov_base = buf;
-			aiov.iov_len = 1;
-			auio.uio_iov = &aiov;
-			auio.uio_iovcnt = 1;
-			auio.uio_offset = 0;
-			auio.uio_resid = 1;
-			auio.uio_segflg = UIO_SYSSPACE;
-			auio.uio_rw = UIO_READ;
-			auio.uio_td = ap->a_td;
-
-			if (vp->v_type == VREG)
-				error = nfs_readrpc(vp, &auio, ap->a_cred);
-			else if (vp->v_type == VDIR) {
-				char* bp;
-				bp = malloc(NFS_DIRBLKSIZ, M_TEMP, M_WAITOK);
-				aiov.iov_base = bp;
-				aiov.iov_len = auio.uio_resid = NFS_DIRBLKSIZ;
-				error = nfs_readdirrpc(vp, &auio, ap->a_cred);
-				free(bp, M_TEMP);
-			} else if (vp->v_type == VLNK)
-				error = nfs_readlinkrpc(vp, &auio, ap->a_cred);
-			else
-				error = EACCES;
-		} else
-			mtx_unlock(&np->n_mtx);
-		return (error);
-	}
-}
-
-int nfs_otw_getattr_avoid = 0;
-
-/*
- * 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.
- */
-/* ARGSUSED */
-static int
-nfs_open(struct vop_open_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct vattr vattr;
-	int error;
-	int fmode = ap->a_mode;
-	struct ucred *cred;
-
-	if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK)
-		return (EOPNOTSUPP);
-
-	/*
-	 * Get a valid lease. If cached data is stale, flush it.
-	 */
-	mtx_lock(&np->n_mtx);
-	if (np->n_flag & NMODIFIED) {
-		mtx_unlock(&np->n_mtx);
-		error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
-		if (error == EINTR || error == EIO)
-			return (error);
-		mtx_lock(&np->n_mtx);
-		np->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-		if (vp->v_type == VDIR)
-			np->n_direofoffset = 0;
-		mtx_unlock(&np->n_mtx);
-		error = VOP_GETATTR(vp, &vattr, ap->a_cred);
-		if (error)
-			return (error);
-		mtx_lock(&np->n_mtx);
-		np->n_mtime = vattr.va_mtime;
-	} else {
-		mtx_unlock(&np->n_mtx);
-		error = VOP_GETATTR(vp, &vattr, ap->a_cred);
-		if (error)
-			return (error);
-		mtx_lock(&np->n_mtx);
-		if (NFS_TIMESPEC_COMPARE(&np->n_mtime, &vattr.va_mtime)) {
-			if (vp->v_type == VDIR)
-				np->n_direofoffset = 0;
-			mtx_unlock(&np->n_mtx);
-			error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
-			if (error == EINTR || error == EIO) {
-				return (error);
-			}
-			mtx_lock(&np->n_mtx);
-			np->n_mtime = vattr.va_mtime;
-		}
-	}
-	/*
-	 * If the object has >= 1 O_DIRECT active opens, we disable caching.
-	 */
-	if (nfs_directio_enable && (fmode & O_DIRECT) && (vp->v_type == VREG)) {
-		if (np->n_directio_opens == 0) {
-			mtx_unlock(&np->n_mtx);
-			error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
-			if (error)
-				return (error);
-			mtx_lock(&np->n_mtx);
-			np->n_flag |= NNONCACHE;
-		}
-		np->n_directio_opens++;
-	}
-
-	/*
-	 * If this is an open for writing, capture a reference to the
-	 * credentials, so they can be used by nfs_putpages(). Using
-	 * these write credentials is preferable to the credentials of
-	 * whatever thread happens to be doing the VOP_PUTPAGES() since
-	 * the write RPCs are less likely to fail with EACCES.
-	 */
-	if ((fmode & FWRITE) != 0) {
-		cred = np->n_writecred;
-		np->n_writecred = crhold(ap->a_cred);
-	} else
-		cred = NULL;
-	mtx_unlock(&np->n_mtx);
-	if (cred != NULL)
-		crfree(cred);
-	vnode_create_vobject(vp, vattr.va_size, ap->a_td);
-	return (0);
-}
-
-/*
- * 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:
- * 1 - So that any write errors may be reported back to the client process
- *     doing the close system call. By far the two most likely errors are
- *     NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
- * 2 - To put a worst case upper bound on cache inconsistency between
- *     multiple clients for the file.
- * There is also a consistency problem for Version 2 of the protocol w.r.t.
- * not being able to tell if other clients are writing a file concurrently,
- * since there is no way of knowing if the changed modify time in the reply
- * is only due to the write for this client.
- * (NFS Version 3 provides weak cache consistency data in the reply that
- *  should be sufficient to detect and handle this case.)
- *
- * 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.
- */
-/* ARGSUSED */
-static int
-nfs_close(struct vop_close_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	int error = 0;
-	int fmode = ap->a_fflag;
-
-	if (vp->v_type == VREG) {
-	    /*
-	     * Examine and clean dirty pages, regardless of NMODIFIED.
-	     * This closes a major hole in close-to-open consistency.
-	     * We want to push out all dirty pages (and buffers) on
-	     * close, regardless of whether they were dirtied by
-	     * mmap'ed writes or via write().
-	     */
-	    if (nfs_clean_pages_on_close && vp->v_object) {
-		VM_OBJECT_WLOCK(vp->v_object);
-		vm_object_page_clean(vp->v_object, 0, 0, 0);
-		VM_OBJECT_WUNLOCK(vp->v_object);
-	    }
-	    mtx_lock(&np->n_mtx);
-	    if (np->n_flag & NMODIFIED) {
-		mtx_unlock(&np->n_mtx);
-		if (NFS_ISV3(vp)) {
-		    /*
-		     * Under NFSv3 we have dirty buffers to dispose of.  We
-		     * must flush them to the NFS server.  We have the option
-		     * of waiting all the way through the commit rpc or just
-		     * waiting for the initial write.  The default is to only
-		     * wait through the initial write so the data is in the
-		     * server's cache, which is roughly similar to the state
-		     * a standard disk subsystem leaves the file in on close().
-		     *
-		     * We cannot clear the NMODIFIED bit in np->n_flag due to
-		     * potential races with other processes, and certainly
-		     * cannot clear it if we don't commit.
-		     */
-		    int cm = nfsv3_commit_on_close ? 1 : 0;
-		    error = nfs_flush(vp, MNT_WAIT, cm);
-		    /* np->n_flag &= ~NMODIFIED; */
-		} else
-		    error = nfs_vinvalbuf(vp, V_SAVE, ap->a_td, 1);
-		mtx_lock(&np->n_mtx);
-	    }
-	    if (np->n_flag & NWRITEERR) {
-		np->n_flag &= ~NWRITEERR;
-		error = np->n_error;
-	    }
-	    mtx_unlock(&np->n_mtx);
-	}
-	if (nfs_directio_enable)
-		KASSERT((np->n_directio_asyncwr == 0),
-			("nfs_close: dirty unflushed (%d) directio buffers\n",
-			 np->n_directio_asyncwr));
-	if (nfs_directio_enable && (fmode & O_DIRECT) && (vp->v_type == VREG)) {
-		mtx_lock(&np->n_mtx);
-		KASSERT((np->n_directio_opens > 0), 
-			("nfs_close: unexpectedly value (0) of n_directio_opens\n"));
-		np->n_directio_opens--;
-		if (np->n_directio_opens == 0)
-			np->n_flag &= ~NNONCACHE;
-		mtx_unlock(&np->n_mtx);
-	}
-	return (error);
-}
-
-/*
- * nfs getattr call from vfs.
- */
-static int
-nfs_getattr(struct vop_getattr_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct thread *td = curthread;
-	struct vattr *vap = ap->a_vap;
-	struct vattr vattr;
-	caddr_t bpos, dpos;
-	int error = 0;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3 = NFS_ISV3(vp);
-
-	/*
-	 * Update local times for special files.
-	 */
-	mtx_lock(&np->n_mtx);
-	if (np->n_flag & (NACC | NUPD))
-		np->n_flag |= NCHG;
-	mtx_unlock(&np->n_mtx);
-	/*
-	 * First look in the cache.
-	 */
-	if (nfs_getattrcache(vp, &vattr) == 0)
-		goto nfsmout;
-	if (v3 && nfs_prime_access_cache && nfsaccess_cache_timeout > 0) {
-		nfsstats.accesscache_misses++;
-		nfs3_access_otw(vp, NFSV3ACCESS_ALL, td, ap->a_cred, NULL);
-		if (nfs_getattrcache(vp, &vattr) == 0)
-			goto nfsmout;
-	}
-	nfsstats.rpccnt[NFSPROC_GETATTR]++;
-	mreq = m_get2(NFSX_FH(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, v3);
-	nfsm_request(vp, NFSPROC_GETATTR, td, ap->a_cred);
-	if (!error) {
-		nfsm_loadattr(vp, &vattr);
-	}
-	m_freem(mrep);
-nfsmout:
-	vap->va_type = vattr.va_type;
-	vap->va_mode = vattr.va_mode;
-	vap->va_nlink = vattr.va_nlink;
-	vap->va_uid = vattr.va_uid;
-	vap->va_gid = vattr.va_gid;
-	vap->va_fsid = vattr.va_fsid;
-	vap->va_fileid = vattr.va_fileid;
-	vap->va_size = vattr.va_size;
-	vap->va_blocksize = vattr.va_blocksize;
-	vap->va_atime = vattr.va_atime;
-	vap->va_mtime = vattr.va_mtime;
-	vap->va_ctime = vattr.va_ctime;
-	vap->va_gen = vattr.va_gen;
-	vap->va_flags = vattr.va_flags;
-	vap->va_rdev = vattr.va_rdev;
-	vap->va_bytes = vattr.va_bytes;
-	vap->va_filerev = vattr.va_filerev;
-
-	return (error);
-}
-
-/*
- * nfs setattr call.
- */
-static int
-nfs_setattr(struct vop_setattr_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct vattr *vap = ap->a_vap;
-	struct thread *td = curthread;
-	int error = 0;
-	u_quad_t tsize;
-
-#ifndef nolint
-	tsize = (u_quad_t)0;
-#endif
-
-	/*
-	 * Setting of flags is not supported.
-	 */
-	if (vap->va_flags != VNOVAL)
-		return (EOPNOTSUPP);
-
-	/*
-	 * 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)) {
-		error = EROFS;
-		goto out;
-	}
-	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 == (mode_t)VNOVAL &&
-			    vap->va_uid == (uid_t)VNOVAL &&
-			    vap->va_gid == (gid_t)VNOVAL)
-				return (0);		
- 			vap->va_size = VNOVAL;
- 			break;
- 		default:
-			/*
-			 * Disallow write attempts if the filesystem is
-			 * mounted read-only.
-			 */
-			if (vp->v_mount->mnt_flag & MNT_RDONLY)
-				return (EROFS);
-			/*
-			 *  We run vnode_pager_setsize() early (why?),
-			 * we must set np->n_size now to avoid vinvalbuf
-			 * V_SAVE races that might setsize a lower
-			 * value.
-			 */
-			mtx_lock(&np->n_mtx);
-			tsize = np->n_size;
-			mtx_unlock(&np->n_mtx);
-			error = nfs_meta_setsize(vp, ap->a_cred, td,
-			    vap->va_size);
-			mtx_lock(&np->n_mtx);
- 			if (np->n_flag & NMODIFIED) {
-			    tsize = np->n_size;
-			    mtx_unlock(&np->n_mtx);
- 			    if (vap->va_size == 0)
- 				error = nfs_vinvalbuf(vp, 0, td, 1);
- 			    else
- 				error = nfs_vinvalbuf(vp, V_SAVE, td, 1);
- 			    if (error) {
-				vnode_pager_setsize(vp, tsize);
-				goto out;
-			    }
- 			} else
-			    mtx_unlock(&np->n_mtx);
-			/*
-			 * np->n_size has already been set to vap->va_size
-			 * in nfs_meta_setsize(). We must set it again since
-			 * nfs_loadattrcache() could be called through
-			 * nfs_meta_setsize() and could modify np->n_size.
-			 */
-			mtx_lock(&np->n_mtx);
- 			np->n_vattr.va_size = np->n_size = vap->va_size;
-			mtx_unlock(&np->n_mtx);
-  		};
-  	} else {
-		mtx_lock(&np->n_mtx);
-		if ((vap->va_mtime.tv_sec != VNOVAL || vap->va_atime.tv_sec != VNOVAL) && 
-		    (np->n_flag & NMODIFIED) && vp->v_type == VREG) {
-			mtx_unlock(&np->n_mtx);
-			if ((error = nfs_vinvalbuf(vp, V_SAVE, td, 1)) != 0 &&
-			    (error == EINTR || error == EIO))
-				return error;
-		} else
-			mtx_unlock(&np->n_mtx);
-	}
-	error = nfs_setattrrpc(vp, vap, ap->a_cred);
-	if (error && vap->va_size != VNOVAL) {
-		mtx_lock(&np->n_mtx);
-		np->n_size = np->n_vattr.va_size = tsize;
-		vnode_pager_setsize(vp, tsize);
-		mtx_unlock(&np->n_mtx);
-	}
-out:
-	return (error);
-}
-
-/*
- * Do an nfs setattr rpc.
- */
-static int
-nfs_setattrrpc(struct vnode *vp, struct vattr *vap, struct ucred *cred)
-{
-	struct nfsv2_sattr *sp;
-	struct nfsnode *np = VTONFS(vp);
-	caddr_t bpos, dpos;
-	u_int32_t *tl;
-	int error = 0, i, wccflag = NFSV3_WCCRATTR;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3 = NFS_ISV3(vp);
-
-	nfsstats.rpccnt[NFSPROC_SETATTR]++;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, v3);
-	if (v3) {
-		nfsm_v3attrbuild(vap, TRUE);
-		tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
-		*tl = nfs_false;
-	} else {
-		sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
-		if (vap->va_mode == (mode_t)VNOVAL)
-			sp->sa_mode = nfs_xdrneg1;
-		else
-			sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
-		if (vap->va_uid == (uid_t)VNOVAL)
-			sp->sa_uid = nfs_xdrneg1;
-		else
-			sp->sa_uid = txdr_unsigned(vap->va_uid);
-		if (vap->va_gid == (gid_t)VNOVAL)
-			sp->sa_gid = nfs_xdrneg1;
-		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, curthread, cred);
-	if (v3) {
-		mtx_lock(&np->n_mtx);
-		for (i = 0; i < NFS_ACCESSCACHESIZE; i++)
-			np->n_accesscache[i].stamp = 0;
-		mtx_unlock(&np->n_mtx);
-		KDTRACE_NFS_ACCESSCACHE_FLUSH_DONE(vp);
-		nfsm_wcc_data(vp, wccflag);
-	} else
-		nfsm_loadattr(vp, NULL);
-	m_freem(mrep);
-nfsmout:
-	return (error);
-}
-
-/*
- * nfs lookup call, one step at a time...
- * First look in cache
- * If not found, unlock the directory nfsnode and do the rpc
- */
-static int
-nfs_lookup(struct vop_lookup_args *ap)
-{
-	struct componentname *cnp = ap->a_cnp;
-	struct vnode *dvp = ap->a_dvp;
-	struct vnode **vpp = ap->a_vpp;
-	struct mount *mp = dvp->v_mount;
-	struct vattr dvattr, vattr;
-	struct timespec nctime;
-	int flags = cnp->cn_flags;
-	struct vnode *newvp;
-	struct nfsmount *nmp;
-	caddr_t bpos, dpos;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	long len;
-	nfsfh_t *fhp;
-	struct nfsnode *np, *newnp;
-	int error = 0, attrflag, dattrflag, fhsize, ltype, ncticks;
-	int v3 = NFS_ISV3(dvp);
-	struct thread *td = cnp->cn_thread;
-
-	*vpp = NULLVP;
-	if ((flags & ISLASTCN) && (mp->mnt_flag & MNT_RDONLY) &&
-	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
-		return (EROFS);
-	if (dvp->v_type != VDIR)
-		return (ENOTDIR);
-	nmp = VFSTONFS(mp);
-	np = VTONFS(dvp);
-	if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td)) != 0) {
-		*vpp = NULLVP;
-		return (error);
-	}
-	error = cache_lookup(dvp, vpp, cnp, &nctime, &ncticks);
-	if (error > 0 && error != ENOENT)
-		return (error);
-	if (error == -1) {
-		/*
-		 * Lookups of "." are special and always return the
-		 * current directory.  cache_lookup() already handles
-		 * associated locking bookkeeping, etc.
-		 */
-		if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
-			/* XXX: Is this really correct? */
-			if (cnp->cn_nameiop != LOOKUP &&
-			    (flags & ISLASTCN))
-				cnp->cn_flags |= SAVENAME;
-			return (0);
-		}
-
-		/*
-		 * We only accept a positive hit in the cache if the
-		 * change time of the file matches our cached copy.
-		 * Otherwise, we discard the cache entry and fallback
-		 * to doing a lookup RPC.  We also only trust cache
-		 * entries for less than nm_nametimeo seconds.
-		 *
-		 * To better handle stale file handles and attributes,
-		 * clear the attribute cache of this node if it is a
-		 * leaf component, part of an open() call, and not
-		 * locally modified before fetching the attributes.
-		 * This should allow stale file handles to be detected
-		 * here where we can fall back to a LOOKUP RPC to
-		 * recover rather than having nfs_open() detect the
-		 * stale file handle and failing open(2) with ESTALE.
-		 */
-		newvp = *vpp;
-		newnp = VTONFS(newvp);
-		if (!(nmp->nm_flag & NFSMNT_NOCTO) &&
-		    (flags & (ISLASTCN | ISOPEN)) == (ISLASTCN | ISOPEN) &&
-		    !(newnp->n_flag & NMODIFIED)) {
-			mtx_lock(&newnp->n_mtx);
-			newnp->n_attrstamp = 0;
-			KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(newvp);
-			mtx_unlock(&newnp->n_mtx);
-		}
-		if ((u_int)(ticks - ncticks) < (nmp->nm_nametimeo * hz) &&
-		    VOP_GETATTR(newvp, &vattr, cnp->cn_cred) == 0 &&
-		    timespeccmp(&vattr.va_ctime, &nctime, ==)) {
-			nfsstats.lookupcache_hits++;
-			if (cnp->cn_nameiop != LOOKUP &&
-			    (flags & ISLASTCN))
-				cnp->cn_flags |= SAVENAME;
-			return (0);
-		}
-		cache_purge(newvp);
-		if (dvp != newvp)
-			vput(newvp);
-		else 
-			vrele(newvp);
-		*vpp = NULLVP;
-	} else if (error == ENOENT) {
-		if (dvp->v_iflag & VI_DOOMED)
-			return (ENOENT);
-		/*
-		 * We only accept a negative hit in the cache if the
-		 * modification time of the parent directory matches
-		 * the cached copy in the name cache entry.
-		 * Otherwise, we discard all of the negative cache
-		 * entries for this directory.  We also only trust
-		 * negative cache entries for up to nm_negnametimeo
-		 * seconds.
-		 */
-		if ((u_int)(ticks - ncticks) < (nmp->nm_negnametimeo * hz) &&
-		    VOP_GETATTR(dvp, &vattr, cnp->cn_cred) == 0 &&
-		    timespeccmp(&vattr.va_mtime, &nctime, ==)) {
-			nfsstats.lookupcache_hits++;
-			return (ENOENT);
-		}
-		cache_purge_negative(dvp);
-	}
-
-	attrflag = dattrflag = 0;
-	error = 0;
-	newvp = NULLVP;
-	nfsstats.lookupcache_misses++;
-	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
-	len = cnp->cn_namelen;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len), M_WAITOK,
-	    MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
-	nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_thread, cnp->cn_cred);
-	if (error) {
-		if (v3) {
-			nfsm_postop_attr_va(dvp, dattrflag, &vattr);
-			m_freem(mrep);
-		}
-		goto nfsmout;
-	}
-	nfsm_getfh(fhp, fhsize, v3);
-
-	/*
-	 * Handle RENAME case...
-	 */
-	if (cnp->cn_nameiop == RENAME && (flags & ISLASTCN)) {
-		if (NFS_CMPFH(np, fhp, fhsize)) {
-			m_freem(mrep);
-			return (EISDIR);
-		}
-		error = nfs_nget(mp, fhp, fhsize, &np, LK_EXCLUSIVE);
-		if (error) {
-			m_freem(mrep);
-			return (error);
-		}
-		newvp = NFSTOV(np);
-		if (v3) {
-			nfsm_postop_attr(newvp, attrflag);
-			nfsm_postop_attr(dvp, attrflag);
-		} else
-			nfsm_loadattr(newvp, NULL);
-		*vpp = newvp;
-		m_freem(mrep);
-		cnp->cn_flags |= SAVENAME;
-		return (0);
-	}
-
-	if (flags & ISDOTDOT) {
-		ltype = VOP_ISLOCKED(dvp);
-		error = vfs_busy(mp, MBF_NOWAIT);
-		if (error != 0) {
-			vfs_ref(mp);
-			VOP_UNLOCK(dvp, 0);
-			error = vfs_busy(mp, 0);
-			vn_lock(dvp, ltype | LK_RETRY);
-			vfs_rel(mp);
-			if (error == 0 && (dvp->v_iflag & VI_DOOMED)) {
-				vfs_unbusy(mp);
-				error = ENOENT;
-			}
-			if (error != 0) {
-				m_freem(mrep);
-				return (error);
-			}
-		}
-		VOP_UNLOCK(dvp, 0);
-		error = nfs_nget(mp, fhp, fhsize, &np, cnp->cn_lkflags);
-		if (error == 0)
-			newvp = NFSTOV(np);
-		vfs_unbusy(mp);
-		if (newvp != dvp)
-			vn_lock(dvp, ltype | LK_RETRY);
-		if (dvp->v_iflag & VI_DOOMED) {
-			if (error == 0) {
-				if (newvp == dvp)
-					vrele(newvp);
-				else
-					vput(newvp);
-			}
-			error = ENOENT;
-		}
-		if (error) {
-			m_freem(mrep);
-			return (error);
-		}
-	} else if (NFS_CMPFH(np, fhp, fhsize)) {
-		VREF(dvp);
-		newvp = dvp;
-	} else {
-		error = nfs_nget(mp, fhp, fhsize, &np, cnp->cn_lkflags);
-		if (error) {
-			m_freem(mrep);
-			return (error);
-		}
-		newvp = NFSTOV(np);
-
-		/*
-		 * Flush the attribute cache when opening a leaf node
-		 * to ensure that fresh attributes are fetched in
-		 * nfs_open() if we are unable to fetch attributes
-		 * from the LOOKUP reply.
-		 */
-		if ((flags & (ISLASTCN | ISOPEN)) == (ISLASTCN | ISOPEN) &&
-		    !(np->n_flag & NMODIFIED)) {
-			mtx_lock(&np->n_mtx);
-			np->n_attrstamp = 0;
-			KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(newvp);
-			mtx_unlock(&np->n_mtx);
-		}
-	}
-	if (v3) {
-		nfsm_postop_attr_va(newvp, attrflag, &vattr);
-		nfsm_postop_attr_va(dvp, dattrflag, &dvattr);
-	} else {
-		nfsm_loadattr(newvp, &vattr);
-		attrflag = 1;
-	}
-	if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
-		cnp->cn_flags |= SAVENAME;
-	if ((cnp->cn_flags & MAKEENTRY) &&
-	    (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN)) &&
-	    attrflag != 0 && (newvp->v_type != VDIR || dattrflag != 0))
-		cache_enter_time(dvp, newvp, cnp, &vattr.va_ctime,
-		    newvp->v_type != VDIR ? NULL : &dvattr.va_ctime);
-	*vpp = newvp;
-	m_freem(mrep);
-nfsmout:
-	if (error) {
-		if (newvp != NULLVP) {
-			vput(newvp);
-			*vpp = NULLVP;
-		}
-
-		if (error != ENOENT)
-			goto done;
-
-		/* The requested file was not found. */
-		if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
-		    (flags & ISLASTCN)) {
-			/*
-			 * XXX: UFS does a full VOP_ACCESS(dvp,
-			 * VWRITE) here instead of just checking
-			 * MNT_RDONLY.
-			 */
-			if (mp->mnt_flag & MNT_RDONLY)
-				return (EROFS);
-			cnp->cn_flags |= SAVENAME;
-			return (EJUSTRETURN);
-		}
-
-		if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE &&
-		    dattrflag) {
-			/*
-			 * Cache the modification time of the parent
-			 * directory from the post-op attributes in
-			 * the name cache entry.  The negative cache
-			 * entry will be ignored once the directory
-			 * has changed.  Don't bother adding the entry
-			 * if the directory has already changed.
-			 */
-			mtx_lock(&np->n_mtx);
-			if (timespeccmp(&np->n_vattr.va_mtime,
-			    &vattr.va_mtime, ==)) {
-				mtx_unlock(&np->n_mtx);
-				cache_enter_time(dvp, NULL, cnp,
-				    &vattr.va_mtime, NULL);
-			} else
-				mtx_unlock(&np->n_mtx);
-		}
-		return (ENOENT);
-	}
-done:
-	return (error);
-}
-
-/*
- * nfs read call.
- * Just call nfs_bioread() to do the work.
- */
-static int
-nfs_read(struct vop_read_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-
-	switch (vp->v_type) {
-	case VREG:
-		return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
-	case VDIR:
-		return (EISDIR);
-	default:
-		return (EOPNOTSUPP);
-	}
-}
-
-/*
- * nfs readlink call
- */
-static int
-nfs_readlink(struct vop_readlink_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-
-	if (vp->v_type != VLNK)
-		return (EINVAL);
-	return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred));
-}
-
-/*
- * Do a readlink rpc.
- * Called by nfs_doio() from below the buffer cache.
- */
-int
-nfs_readlinkrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
-{
-	caddr_t bpos, dpos;
-	int error = 0, len, attrflag;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3 = NFS_ISV3(vp);
-
-	nfsstats.rpccnt[NFSPROC_READLINK]++;
-	mreq = m_get2(NFSX_FH(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, v3);
-	nfsm_request(vp, NFSPROC_READLINK, uiop->uio_td, cred);
-	if (v3)
-		nfsm_postop_attr(vp, attrflag);
-	if (!error) {
-		nfsm_strsiz(len, NFS_MAXPATHLEN);
-		if (len == NFS_MAXPATHLEN) {
-			struct nfsnode *np = VTONFS(vp);
-			mtx_lock(&np->n_mtx);
-			if (np->n_size && np->n_size < NFS_MAXPATHLEN)
-				len = np->n_size;
-			mtx_unlock(&np->n_mtx);
-		}
-		nfsm_mtouio(uiop, len);
-	}
-	m_freem(mrep);
-nfsmout:
-	return (error);
-}
-
-/*
- * nfs read rpc call
- * Ditto above
- */
-int
-nfs_readrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
-{
-	u_int32_t *tl;
-	caddr_t bpos, dpos;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	struct nfsmount *nmp;
-	off_t end;
-	int error = 0, len, retlen, tsiz, eof, attrflag;
-	int v3 = NFS_ISV3(vp);
-	int rsize;
-
-#ifndef nolint
-	eof = 0;
-#endif
-	nmp = VFSTONFS(vp->v_mount);
-	tsiz = uiop->uio_resid;
-	mtx_lock(&nmp->nm_mtx);
-	end = uiop->uio_offset + tsiz;
-	if (end > nmp->nm_maxfilesize || end < uiop->uio_offset) {
-		mtx_unlock(&nmp->nm_mtx);
-		return (EFBIG);
-	}
-	rsize = nmp->nm_rsize;
-	mtx_unlock(&nmp->nm_mtx);
-	while (tsiz > 0) {
-		nfsstats.rpccnt[NFSPROC_READ]++;
-		len = (tsiz > rsize) ? rsize : tsiz;
-		mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED * 3, M_WAITOK,
-		    MT_DATA, 0);
-		mb = mreq;
-		bpos = mtod(mb, caddr_t);
-		nfsm_fhtom(vp, v3);
-		tl = nfsm_build(u_int32_t *, 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;
-		}
-		nfsm_request(vp, NFSPROC_READ, uiop->uio_td, cred);
-		if (v3) {
-			nfsm_postop_attr(vp, attrflag);
-			if (error) {
-				m_freem(mrep);
-				goto nfsmout;
-			}
-			tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
-			eof = fxdr_unsigned(int, *(tl + 1));
-		} else {
-			nfsm_loadattr(vp, NULL);
-		}
-		nfsm_strsiz(retlen, rsize);
-		nfsm_mtouio(uiop, retlen);
-		m_freem(mrep);
-		tsiz -= retlen;
-		if (v3) {
-			if (eof || retlen == 0) {
-				tsiz = 0;
-			}
-		} else if (retlen < len) {
-			tsiz = 0;
-		}
-	}
-nfsmout:
-	return (error);
-}
-
-/*
- * nfs write call
- */
-int
-nfs_writerpc(struct vnode *vp, struct uio *uiop, struct ucred *cred,
-	     int *iomode, int *must_commit)
-{
-	u_int32_t *tl;
-	int32_t backup;
-	caddr_t bpos, dpos;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	off_t end;
-	int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR, rlen, commit;
-	int v3 = NFS_ISV3(vp), committed = NFSV3WRITE_FILESYNC;
-	int wsize;
-	
-	KASSERT(uiop->uio_iovcnt == 1, ("nfs: writerpc iovcnt > 1"));
-	*must_commit = 0;
-	tsiz = uiop->uio_resid;
-	mtx_lock(&nmp->nm_mtx);
-	end = uiop->uio_offset + tsiz;
-	if (end > nmp->nm_maxfilesize || end < uiop->uio_offset) {
-		mtx_unlock(&nmp->nm_mtx);		
-		return (EFBIG);
-	}
-	wsize = nmp->nm_wsize;
-	mtx_unlock(&nmp->nm_mtx);
-	while (tsiz > 0) {
-		nfsstats.rpccnt[NFSPROC_WRITE]++;
-		len = (tsiz > wsize) ? wsize : tsiz;
-		mreq = m_get2(NFSX_FH(v3) + 5 * NFSX_UNSIGNED, M_WAITOK,
-		    MT_DATA, 0);
-		mb = mreq;
-		bpos = mtod(mb, caddr_t);
-		nfsm_fhtom(vp, v3);
-		if (v3) {
-			tl = nfsm_build(u_int32_t *, 5 * NFSX_UNSIGNED);
-			txdr_hyper(uiop->uio_offset, tl);
-			tl += 2;
-			*tl++ = txdr_unsigned(len);
-			*tl++ = txdr_unsigned(*iomode);
-			*tl = txdr_unsigned(len);
-		} else {
-			u_int32_t x;
-
-			tl = nfsm_build(u_int32_t *, 4 * NFSX_UNSIGNED);
-			/* Set both "begin" and "current" to non-garbage. */
-			x = txdr_unsigned((u_int32_t)uiop->uio_offset);
-			*tl++ = x;	/* "begin offset" */
-			*tl++ = x;	/* "current offset" */
-			x = txdr_unsigned(len);
-			*tl++ = x;	/* total to this offset */
-			*tl = x;	/* size of this write */
-		}
-		nfsm_uiotom(uiop, len);
-		nfsm_request(vp, NFSPROC_WRITE, uiop->uio_td, cred);
-		if (v3) {
-			wccflag = NFSV3_WCCCHK;
-			nfsm_wcc_data(vp, wccflag);
-			if (!error) {
-				tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED
-					+ NFSX_V3WRITEVERF);
-				rlen = fxdr_unsigned(int, *tl++);
-				if (rlen == 0) {
-					error = NFSERR_IO;
-					m_freem(mrep);
-					break;
-				} else if (rlen < len) {
-					backup = len - rlen;
-					uiop->uio_iov->iov_base =
-					    (char *)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++);
-
-				/*
-				 * Return the lowest committment level
-				 * obtained by any of the RPCs.
-				 */
-				if (committed == NFSV3WRITE_FILESYNC)
-					committed = commit;
-				else if (committed == NFSV3WRITE_DATASYNC &&
-					commit == NFSV3WRITE_UNSTABLE)
-					committed = commit;
-				mtx_lock(&nmp->nm_mtx);
-				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);
-				}
-				mtx_unlock(&nmp->nm_mtx);
-			}
-		} else {
-			nfsm_loadattr(vp, NULL);
-		}
-		if (wccflag) {
-			mtx_lock(&(VTONFS(vp))->n_mtx);
-			VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime;
-			mtx_unlock(&(VTONFS(vp))->n_mtx);
-		}
-		m_freem(mrep);
-		if (error)
-			break;
-		tsiz -= len;
-	}
-nfsmout:
-	if (DOINGASYNC(vp))
-		committed = NFSV3WRITE_FILESYNC;
-	*iomode = committed;
-	if (error)
-		uiop->uio_resid = tsiz;
-	return (error);
-}
-
-/*
- * nfs mknod rpc
- * 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(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
-    struct vattr *vap)
-{
-	struct nfsv2_sattr *sp;
-	u_int32_t *tl;
-	struct vnode *newvp = NULL;
-	struct nfsnode *np = NULL;
-	struct vattr vattr;
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	u_int32_t rdev;
-	int v3 = NFS_ISV3(dvp);
-
-	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)
-		rdev = nfs_xdrneg1;
-	else {
-		return (EOPNOTSUPP);
-	}
-	if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)) != 0)
-		return (error);
-	nfsstats.rpccnt[NFSPROC_MKNOD]++;
-	mreq = m_get2(NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
-	    nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-	if (v3) {
-		tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
-		*tl++ = vtonfsv3_type(vap->va_type);
-		nfsm_v3attrbuild(vap, FALSE);
-		if (vap->va_type == VCHR || vap->va_type == VBLK) {
-			tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
-			*tl++ = txdr_unsigned(major(vap->va_rdev));
-			*tl = txdr_unsigned(minor(vap->va_rdev));
-		}
-	} else {
-		sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
-		sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
-		sp->sa_uid = nfs_xdrneg1;
-		sp->sa_gid = nfs_xdrneg1;
-		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_thread, cnp->cn_cred);
-	if (!error) {
-		nfsm_mtofh(dvp, newvp, v3, gotvp);
-		if (!gotvp) {
-			if (newvp) {
-				vput(newvp);
-				newvp = NULL;
-			}
-			error = nfs_lookitup(dvp, cnp->cn_nameptr,
-			    cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);
-			if (!error)
-				newvp = NFSTOV(np);
-		}
-	}
-	if (v3)
-		nfsm_wcc_data(dvp, wccflag);
-	m_freem(mrep);
-nfsmout:
-	if (error) {
-		if (newvp)
-			vput(newvp);
-	} else {
-		*vpp = newvp;
-	}
-	mtx_lock(&(VTONFS(dvp))->n_mtx);
-	VTONFS(dvp)->n_flag |= NMODIFIED;
-	if (!wccflag) {
-		VTONFS(dvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
-	}
-	mtx_unlock(&(VTONFS(dvp))->n_mtx);
-	return (error);
-}
-
-/*
- * nfs mknod vop
- * just call nfs_mknodrpc() to do the work.
- */
-/* ARGSUSED */
-static int
-nfs_mknod(struct vop_mknod_args *ap)
-{
-	return (nfs_mknodrpc(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap));
-}
-
-static u_long create_verf;
-/*
- * nfs file create call
- */
-static int
-nfs_create(struct vop_create_args *ap)
-{
-	struct vnode *dvp = ap->a_dvp;
-	struct vattr *vap = ap->a_vap;
-	struct componentname *cnp = ap->a_cnp;
-	struct nfsv2_sattr *sp;
-	u_int32_t *tl;
-	struct nfsnode *np = NULL;
-	struct vnode *newvp = NULL;
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	struct vattr vattr;
-	int v3 = NFS_ISV3(dvp);
-
-	/*
-	 * Oops, not for me..
-	 */
-	if (vap->va_type == VSOCK) {
-		error = nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap);
-		return (error);
-	}
-
-	if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)) != 0) {
-		return (error);
-	}
-	if (vap->va_vaflags & VA_EXCLUSIVE)
-		fmode |= O_EXCL;
-again:
-	nfsstats.rpccnt[NFSPROC_CREATE]++;
-	mreq = m_get2(NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
-	    nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-	if (v3) {
-		tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
-		if (fmode & O_EXCL) {
-			*tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
-			tl = nfsm_build(u_int32_t *, NFSX_V3CREATEVERF);
-#ifdef INET
-			CURVNET_SET(CRED_TO_VNET(cnp->cn_cred));
-			IN_IFADDR_RLOCK();
-			if (!TAILQ_EMPTY(&V_in_ifaddrhead))
-				*tl++ = IA_SIN(TAILQ_FIRST(&V_in_ifaddrhead))->sin_addr.s_addr;
-			else
-#endif
-				*tl++ = create_verf;
-#ifdef INET
-			IN_IFADDR_RUNLOCK();
-			CURVNET_RESTORE();
-#endif
-			*tl = ++create_verf;
-		} else {
-			*tl = txdr_unsigned(NFSV3CREATE_UNCHECKED);
-			nfsm_v3attrbuild(vap, FALSE);
-		}
-	} else {
-		sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
-		sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
-		sp->sa_uid = nfs_xdrneg1;
-		sp->sa_gid = nfs_xdrneg1;
-		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_thread, cnp->cn_cred);
-	if (!error) {
-		nfsm_mtofh(dvp, newvp, v3, gotvp);
-		if (!gotvp) {
-			if (newvp) {
-				vput(newvp);
-				newvp = NULL;
-			}
-			error = nfs_lookitup(dvp, cnp->cn_nameptr,
-			    cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);
-			if (!error)
-				newvp = NFSTOV(np);
-		}
-	}
-	if (v3)
-		nfsm_wcc_data(dvp, wccflag);
-	m_freem(mrep);
-nfsmout:
-	if (error) {
-		if (v3 && (fmode & O_EXCL) && error == NFSERR_NOTSUPP) {
-			fmode &= ~O_EXCL;
-			goto again;
-		}
-		if (newvp)
-			vput(newvp);
-	} else if (v3 && (fmode & O_EXCL)) {
-		/*
-		 * We are normally called with only a partially initialized
-		 * VAP.  Since the NFSv3 spec says that server may use the
-		 * file attributes to store the verifier, the spec requires
-		 * us to do a SETATTR RPC. FreeBSD servers store the verifier
-		 * in atime, but we can't really assume that all servers will
-		 * so we ensure that our SETATTR sets both atime and mtime.
-		 */
-		if (vap->va_mtime.tv_sec == VNOVAL)
-			vfs_timestamp(&vap->va_mtime);
-		if (vap->va_atime.tv_sec == VNOVAL)
-			vap->va_atime = vap->va_mtime;
-		error = nfs_setattrrpc(newvp, vap, cnp->cn_cred);
-		if (error)
-			vput(newvp);
-	}
-	if (!error) {
-		*ap->a_vpp = newvp;
-	}
-	mtx_lock(&(VTONFS(dvp))->n_mtx);
-	VTONFS(dvp)->n_flag |= NMODIFIED;
-	if (!wccflag) {
-		VTONFS(dvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
-	}
-	mtx_unlock(&(VTONFS(dvp))->n_mtx);
-	return (error);
-}
-
-/*
- * 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 a rename is not already in the works
- *	     call nfs_sillyrename() to set it up
- *     else
- *	  do the remove rpc
- */
-static int
-nfs_remove(struct vop_remove_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *dvp = ap->a_dvp;
-	struct componentname *cnp = ap->a_cnp;
-	struct nfsnode *np = VTONFS(vp);
-	int error = 0;
-	struct vattr vattr;
-
-	KASSERT((cnp->cn_flags & HASBUF) != 0, ("nfs_remove: no name"));
-	KASSERT(vrefcnt(vp) > 0, ("nfs_remove: bad v_usecount"));
-	if (vp->v_type == VDIR)
-		error = EPERM;
-	else if (vrefcnt(vp) == 1 || (np->n_sillyrename &&
-	    !VOP_GETATTR(vp, &vattr, cnp->cn_cred) && vattr.va_nlink > 1)) {
-		/*
-		 * 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..
-		 */
-		cache_purge(vp);
-		/*
-		 * throw away biocache buffers, mainly to avoid
-		 * unnecessary delayed writes later.
-		 */
-		error = nfs_vinvalbuf(vp, 0, cnp->cn_thread, 1);
-		/* Do the rpc */
-		if (error != EINTR && error != EIO)
-			error = nfs_removerpc(dvp, cnp->cn_nameptr,
-				cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread);
-		/*
-		 * Kludge City: If the first reply to the remove rpc is lost..
-		 *   the reply to the retransmitted request will be ENOENT
-		 *   since the file was in fact removed
-		 *   Therefore, we cheat and return success.
-		 */
-		if (error == ENOENT)
-			error = 0;
-	} else if (!np->n_sillyrename)
-		error = nfs_sillyrename(dvp, vp, cnp);
-	mtx_lock(&np->n_mtx);
-	np->n_attrstamp = 0;
-	mtx_unlock(&np->n_mtx);
-	KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-	return (error);
-}
-
-/*
- * nfs file remove rpc called from nfs_inactive
- */
-int
-nfs_removeit(struct sillyrename *sp)
-{
-	/*
-	 * Make sure that the directory vnode is still valid.
-	 * XXX we should lock sp->s_dvp here.
-	 */
-	if (sp->s_dvp->v_type == VBAD)
-		return (0);
-	return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
-		NULL));
-}
-
-/*
- * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
- */
-static int
-nfs_removerpc(struct vnode *dvp, const char *name, int namelen,
-    struct ucred *cred, struct thread *td)
-{
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3 = NFS_ISV3(dvp);
-
-	nfsstats.rpccnt[NFSPROC_REMOVE]++;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen),
-	    M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
-	nfsm_request(dvp, NFSPROC_REMOVE, td, cred);
-	if (v3)
-		nfsm_wcc_data(dvp, wccflag);
-	m_freem(mrep);
-nfsmout:
-	mtx_lock(&(VTONFS(dvp))->n_mtx);
-	VTONFS(dvp)->n_flag |= NMODIFIED;
-	if (!wccflag) {
-		VTONFS(dvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
-	}
-	mtx_unlock(&(VTONFS(dvp))->n_mtx);
-	return (error);
-}
-
-/*
- * nfs file rename call
- */
-static int
-nfs_rename(struct vop_rename_args *ap)
-{
-	struct vnode *fvp = ap->a_fvp;
-	struct vnode *tvp = ap->a_tvp;
-	struct vnode *fdvp = ap->a_fdvp;
-	struct vnode *tdvp = ap->a_tdvp;
-	struct componentname *tcnp = ap->a_tcnp;
-	struct componentname *fcnp = ap->a_fcnp;
-	int error;
-
-	KASSERT((tcnp->cn_flags & HASBUF) != 0 &&
-	    (fcnp->cn_flags & HASBUF) != 0, ("nfs_rename: no name"));
-	/* Check for cross-device rename */
-	if ((fvp->v_mount != tdvp->v_mount) ||
-	    (tvp && (fvp->v_mount != tvp->v_mount))) {
-		error = EXDEV;
-		goto out;
-	}
-
-	if (fvp == tvp) {
-		nfs_printf("nfs_rename: fvp == tvp (can't happen)\n");
-		error = 0;
-		goto out;
-	}
-	if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
-		goto out;
-
-	/*
-	 * We have to flush B_DELWRI data prior to renaming
-	 * the file.  If we don't, the delayed-write buffers
-	 * can be flushed out later after the file has gone stale
-	 * under NFSV3.  NFSV2 does not have this problem because
-	 * ( as far as I can tell ) it flushes dirty buffers more
-	 * often.
-	 * 
-	 * Skip the rename operation if the fsync fails, this can happen
-	 * due to the server's volume being full, when we pushed out data
-	 * that was written back to our cache earlier. Not checking for
-	 * this condition can result in potential (silent) data loss.
-	 */
-	error = VOP_FSYNC(fvp, MNT_WAIT, fcnp->cn_thread);
-	VOP_UNLOCK(fvp, 0);
-	if (!error && tvp)
-		error = VOP_FSYNC(tvp, MNT_WAIT, tcnp->cn_thread);
-	if (error)
-		goto out;
-
-	/*
-	 * If the tvp exists and is in use, sillyrename it before doing the
-	 * rename of the new file over it.
-	 * XXX Can't sillyrename a directory.
-	 */
-	if (tvp && vrefcnt(tvp) > 1 && !VTONFS(tvp)->n_sillyrename &&
-		tvp->v_type != VDIR && !nfs_sillyrename(tdvp, tvp, tcnp)) {
-		vput(tvp);
-		tvp = NULL;
-	}
-
-	error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
-		tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
-		tcnp->cn_thread);
-
-	if (fvp->v_type == VDIR) {
-		if (tvp != NULL && tvp->v_type == VDIR)
-			cache_purge(tdvp);
-		cache_purge(fdvp);
-	}
-
-out:
-	if (tdvp == tvp)
-		vrele(tdvp);
-	else
-		vput(tdvp);
-	if (tvp)
-		vput(tvp);
-	vrele(fdvp);
-	vrele(fvp);
-	/*
-	 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
-	 */
-	if (error == ENOENT)
-		error = 0;
-	return (error);
-}
-
-/*
- * nfs file rename rpc called from nfs_remove() above
- */
-static int
-nfs_renameit(struct vnode *sdvp, struct componentname *scnp,
-    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_thread));
-}
-
-/*
- * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
- */
-static int
-nfs_renamerpc(struct vnode *fdvp, const char *fnameptr, int fnamelen,
-    struct vnode *tdvp, const char *tnameptr, int tnamelen, struct ucred *cred,
-    struct thread *td)
-{
-	caddr_t bpos, dpos;
-	int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3 = NFS_ISV3(fdvp);
-
-	nfsstats.rpccnt[NFSPROC_RENAME]++;
-	mreq = m_get2((NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
-	    nfsm_rndup(tnamelen), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	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, td, cred);
-	if (v3) {
-		nfsm_wcc_data(fdvp, fwccflag);
-		nfsm_wcc_data(tdvp, twccflag);
-	}
-	m_freem(mrep);
-nfsmout:
-	mtx_lock(&(VTONFS(fdvp))->n_mtx);
-	VTONFS(fdvp)->n_flag |= NMODIFIED;
-	mtx_unlock(&(VTONFS(fdvp))->n_mtx);
-	mtx_lock(&(VTONFS(tdvp))->n_mtx);
-	VTONFS(tdvp)->n_flag |= NMODIFIED;
-	mtx_unlock(&(VTONFS(tdvp))->n_mtx);
-	if (!fwccflag) {
-		VTONFS(fdvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(fdvp);
-	}
-	if (!twccflag) {
-		VTONFS(tdvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(tdvp);
-	}
-	return (error);
-}
-
-/*
- * nfs hard link create call
- */
-static int
-nfs_link(struct vop_link_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *tdvp = ap->a_tdvp;
-	struct componentname *cnp = ap->a_cnp;
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3;
-
-	if (vp->v_mount != tdvp->v_mount) {
-		return (EXDEV);
-	}
-
-	/*
-	 * 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!
-	 */
-	VOP_FSYNC(vp, MNT_WAIT, cnp->cn_thread);
-
-	v3 = NFS_ISV3(vp);
-	nfsstats.rpccnt[NFSPROC_LINK]++;
-	mreq = m_get2(NFSX_FH(v3)*2 + NFSX_UNSIGNED +
-	    nfsm_rndup(cnp->cn_namelen), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	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_thread, cnp->cn_cred);
-	if (v3) {
-		nfsm_postop_attr(vp, attrflag);
-		nfsm_wcc_data(tdvp, wccflag);
-	}
-	m_freem(mrep);
-nfsmout:
-	mtx_lock(&(VTONFS(tdvp))->n_mtx);
-	VTONFS(tdvp)->n_flag |= NMODIFIED;
-	mtx_unlock(&(VTONFS(tdvp))->n_mtx);
-	if (!attrflag) {
-		VTONFS(vp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(vp);
-	}
-	if (!wccflag) {
-		VTONFS(tdvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(tdvp);
-	}
-	return (error);
-}
-
-/*
- * nfs symbolic link create call
- */
-static int
-nfs_symlink(struct vop_symlink_args *ap)
-{
-	struct vnode *dvp = ap->a_dvp;
-	struct vattr *vap = ap->a_vap;
-	struct componentname *cnp = ap->a_cnp;
-	struct nfsv2_sattr *sp;
-	caddr_t bpos, dpos;
-	int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	struct vnode *newvp = NULL;
-	int v3 = NFS_ISV3(dvp);
-
-	nfsstats.rpccnt[NFSPROC_SYMLINK]++;
-	slen = strlen(ap->a_target);
-	mreq = m_get2(NFSX_FH(v3) + 2*NFSX_UNSIGNED +
-	    nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3),
-	    M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-	if (v3) {
-		nfsm_v3attrbuild(vap, FALSE);
-	}
-	nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
-	if (!v3) {
-		sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
-		sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
-		sp->sa_uid = nfs_xdrneg1;
-		sp->sa_gid = nfs_xdrneg1;
-		sp->sa_size = nfs_xdrneg1;
-		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-	}
-
-	/*
-	 * Issue the NFS request and get the rpc response.
-	 *
-	 * Only NFSv3 responses returning an error of 0 actually return
-	 * a file handle that can be converted into newvp without having
-	 * to do an extra lookup rpc.
-	 */
-	nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_thread, cnp->cn_cred);
-	if (v3) {
-		if (error == 0)
-			nfsm_mtofh(dvp, newvp, v3, gotvp);
-		nfsm_wcc_data(dvp, wccflag);
-	}
-
-	/*
-	 * out code jumps -> here, mrep is also freed.
-	 */
-
-	m_freem(mrep);
-nfsmout:
-
-	/*
-	 * If we do not have an error and we could not extract the newvp from
-	 * the response due to the request being NFSv2, we have to do a
-	 * lookup in order to obtain a newvp to return.
-	 */
-	if (error == 0 && newvp == NULL) {
-		struct nfsnode *np = NULL;
-
-		error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
-		    cnp->cn_cred, cnp->cn_thread, &np);
-		if (!error)
-			newvp = NFSTOV(np);
-	}
-	if (error) {
-		if (newvp)
-			vput(newvp);
-	} else {
-		*ap->a_vpp = newvp;
-	}
-	mtx_lock(&(VTONFS(dvp))->n_mtx);
-	VTONFS(dvp)->n_flag |= NMODIFIED;
-	mtx_unlock(&(VTONFS(dvp))->n_mtx);
-	if (!wccflag) {
-		VTONFS(dvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
-	}
-	return (error);
-}
-
-/*
- * nfs make dir call
- */
-static int
-nfs_mkdir(struct vop_mkdir_args *ap)
-{
-	struct vnode *dvp = ap->a_dvp;
-	struct vattr *vap = ap->a_vap;
-	struct componentname *cnp = ap->a_cnp;
-	struct nfsv2_sattr *sp;
-	int len;
-	struct nfsnode *np = NULL;
-	struct vnode *newvp = NULL;
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR;
-	int gotvp = 0;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	struct vattr vattr;
-	int v3 = NFS_ISV3(dvp);
-
-	if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)) != 0)
-		return (error);
-	len = cnp->cn_namelen;
-	nfsstats.rpccnt[NFSPROC_MKDIR]++;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) +
-	    NFSX_SATTR(v3), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
-	if (v3) {
-		nfsm_v3attrbuild(vap, FALSE);
-	} else {
-		sp = nfsm_build(struct nfsv2_sattr *, NFSX_V2SATTR);
-		sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
-		sp->sa_uid = nfs_xdrneg1;
-		sp->sa_gid = nfs_xdrneg1;
-		sp->sa_size = nfs_xdrneg1;
-		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
-		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
-	}
-	nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_thread, cnp->cn_cred);
-	if (!error)
-		nfsm_mtofh(dvp, newvp, v3, gotvp);
-	if (v3)
-		nfsm_wcc_data(dvp, wccflag);
-	m_freem(mrep);
-nfsmout:
-	mtx_lock(&(VTONFS(dvp))->n_mtx);
-	VTONFS(dvp)->n_flag |= NMODIFIED;
-	mtx_unlock(&(VTONFS(dvp))->n_mtx);
-	if (!wccflag) {
-		VTONFS(dvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
-	}
-	if (error == 0 && newvp == NULL) {
-		error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
-			cnp->cn_thread, &np);
-		if (!error) {
-			newvp = NFSTOV(np);
-			if (newvp->v_type != VDIR)
-				error = EEXIST;
-		}
-	}
-	if (error) {
-		if (newvp)
-			vput(newvp);
-	} else
-		*ap->a_vpp = newvp;
-	return (error);
-}
-
-/*
- * nfs remove directory call
- */
-static int
-nfs_rmdir(struct vop_rmdir_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *dvp = ap->a_dvp;
-	struct componentname *cnp = ap->a_cnp;
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	int v3 = NFS_ISV3(dvp);
-
-	if (dvp == vp)
-		return (EINVAL);
-	nfsstats.rpccnt[NFSPROC_RMDIR]++;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED +
-	    nfsm_rndup(cnp->cn_namelen), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
-	nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_thread, cnp->cn_cred);
-	if (v3)
-		nfsm_wcc_data(dvp, wccflag);
-	m_freem(mrep);
-nfsmout:
-	mtx_lock(&(VTONFS(dvp))->n_mtx);
-	VTONFS(dvp)->n_flag |= NMODIFIED;
-	mtx_unlock(&(VTONFS(dvp))->n_mtx);
-	if (!wccflag) {
-		VTONFS(dvp)->n_attrstamp = 0;
-		KDTRACE_NFS_ATTRCACHE_FLUSH_DONE(dvp);
-	}
-	cache_purge(dvp);
-	cache_purge(vp);
-	/*
-	 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
-	 */
-	if (error == ENOENT)
-		error = 0;
-	return (error);
-}
-
-/*
- * nfs readdir call
- */
-static int
-nfs_readdir(struct vop_readdir_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct uio *uio = ap->a_uio;
-	int tresid, error = 0;
-	struct vattr vattr;
-	
-	if (vp->v_type != VDIR) 
-		return(EPERM);
-
-	/*
-	 * First, check for hit on the EOF offset cache
-	 */
-	if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
-	    (np->n_flag & NMODIFIED) == 0) {
-		if (VOP_GETATTR(vp, &vattr, ap->a_cred) == 0) {
-			mtx_lock(&np->n_mtx);
-			if (!NFS_TIMESPEC_COMPARE(&np->n_mtime, &vattr.va_mtime)) {
-				mtx_unlock(&np->n_mtx);
-				nfsstats.direofcache_hits++;
-				goto out;
-			} else
-				mtx_unlock(&np->n_mtx);
-		}
-	}
-
-	/*
-	 * Call nfs_bioread() to do the real work.
-	 */
-	tresid = uio->uio_resid;
-	error = nfs_bioread(vp, uio, 0, ap->a_cred);
-
-	if (!error && uio->uio_resid == tresid) {
-		nfsstats.direofcache_misses++;
-	}
-out:
-	return (error);
-}
-
-/*
- * Readdir rpc call.
- * Called from below the buffer cache by nfs_doio().
- */
-int
-nfs_readdirrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
-{
-	int len, left;
-	struct dirent *dp = NULL;
-	u_int32_t *tl;
-	caddr_t cp;
-	nfsuint64 *cookiep;
-	caddr_t bpos, dpos;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	nfsuint64 cookie;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	struct nfsnode *dnp = VTONFS(vp);
-	u_quad_t fileno;
-	int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
-	int attrflag;
-	int v3 = NFS_ISV3(vp);
-
-	KASSERT(uiop->uio_iovcnt == 1 &&
-	    (uiop->uio_offset & (DIRBLKSIZ - 1)) == 0 &&
-	    (uiop->uio_resid & (DIRBLKSIZ - 1)) == 0,
-	    ("nfs readdirrpc bad uio"));
-
-	/*
-	 * If there is no cookie, assume directory was stale.
-	 */
-	nfs_dircookie_lock(dnp);
-	cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
-	if (cookiep) {
-		cookie = *cookiep;
-		nfs_dircookie_unlock(dnp);
-	} else {
-		nfs_dircookie_unlock(dnp);		
-		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]++;
-		mreq = m_get2(NFSX_FH(v3) + NFSX_READDIR(v3), M_WAITOK,
-		    MT_DATA, 0);
-		mb = mreq;
-		bpos = mtod(mb, caddr_t);
-		nfsm_fhtom(vp, v3);
-		if (v3) {
-			tl = nfsm_build(u_int32_t *, 5 * NFSX_UNSIGNED);
-			*tl++ = cookie.nfsuquad[0];
-			*tl++ = cookie.nfsuquad[1];
-			mtx_lock(&dnp->n_mtx);
-			*tl++ = dnp->n_cookieverf.nfsuquad[0];
-			*tl++ = dnp->n_cookieverf.nfsuquad[1];
-			mtx_unlock(&dnp->n_mtx);
-		} else {
-			tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
-			*tl++ = cookie.nfsuquad[0];
-		}
-		*tl = txdr_unsigned(nmp->nm_readdirsize);
-		nfsm_request(vp, NFSPROC_READDIR, uiop->uio_td, cred);
-		if (v3) {
-			nfsm_postop_attr(vp, attrflag);
-			if (!error) {
-				tl = nfsm_dissect(u_int32_t *,
-				    2 * NFSX_UNSIGNED);
-				mtx_lock(&dnp->n_mtx);
-				dnp->n_cookieverf.nfsuquad[0] = *tl++;
-				dnp->n_cookieverf.nfsuquad[1] = *tl;
-				mtx_unlock(&dnp->n_mtx);
-			} else {
-				m_freem(mrep);
-				goto nfsmout;
-			}
-		}
-		tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-		more_dirs = fxdr_unsigned(int, *tl);
-
-		/* loop thru the dir entries, doctoring them to 4bsd form */
-		while (more_dirs && bigenough) {
-			if (v3) {
-				tl = nfsm_dissect(u_int32_t *,
-				    3 * NFSX_UNSIGNED);
-				fileno = fxdr_hyper(tl);
-				len = fxdr_unsigned(int, *(tl + 2));
-			} else {
-				tl = nfsm_dissect(u_int32_t *,
-				    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 =
-				    (char *)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 =
-				    (char *)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 =
-				    (char *)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) {
-				tl = nfsm_dissect(u_int32_t *,
-				    3 * NFSX_UNSIGNED);
-			} else {
-				tl = nfsm_dissect(u_int32_t *,
-				    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) {
-			tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-			more_dirs = (fxdr_unsigned(int, *tl) == 0);
-		}
-		m_freem(mrep);
-	}
-	/*
-	 * 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 =
-		    (char *)uiop->uio_iov->iov_base + left;
-		uiop->uio_iov->iov_len -= left;
-		uiop->uio_offset += left;
-		uiop->uio_resid -= left;
-	}
-
-	/*
-	 * 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)
-			nfs_printf("EEK! readdirrpc resid > 0\n");
-		nfs_dircookie_lock(dnp);
-		cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
-		*cookiep = cookie;
-		nfs_dircookie_unlock(dnp);
-	}
-nfsmout:
-	return (error);
-}
-
-/*
- * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
- */
-int
-nfs_readdirplusrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
-{
-	int len, left;
-	struct dirent *dp;
-	u_int32_t *tl;
-	caddr_t cp;
-	struct vnode *newvp;
-	nfsuint64 *cookiep;
-	caddr_t bpos, dpos, dpossav1, dpossav2;
-	struct mbuf *mreq, *mrep, *md, *mb, *mdsav1, *mdsav2;
-	struct nameidata nami, *ndp = &nami;
-	struct componentname *cnp = &ndp->ni_cnd;
-	nfsuint64 cookie;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	struct nfsnode *dnp = VTONFS(vp), *np;
-	struct vattr vattr, dvattr;
-	nfsfh_t *fhp;
-	u_quad_t fileno;
-	int error = 0, tlen, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
-	int attrflag, dattrflag, fhsize;
-
-#ifndef nolint
-	dp = NULL;
-#endif
-	KASSERT(uiop->uio_iovcnt == 1 &&
-	    (uiop->uio_offset & (DIRBLKSIZ - 1)) == 0 &&
-	    (uiop->uio_resid & (DIRBLKSIZ - 1)) == 0,
-	    ("nfs readdirplusrpc bad uio"));
-	ndp->ni_dvp = vp;
-	newvp = NULLVP;
-
-	/*
-	 * If there is no cookie, assume directory was stale.
-	 */
-	nfs_dircookie_lock(dnp);
-	cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
-	if (cookiep) {
-		cookie = *cookiep;
-		nfs_dircookie_unlock(dnp);
-	} else {
-		nfs_dircookie_unlock(dnp);
-		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_READDIRPLUS]++;
-		mreq = m_get2(NFSX_FH(1) + 6 * NFSX_UNSIGNED, M_WAITOK,
-		    MT_DATA, 0);
-		mb = mreq;
-		bpos = mtod(mb, caddr_t);
-		nfsm_fhtom(vp, 1);
- 		tl = nfsm_build(u_int32_t *, 6 * NFSX_UNSIGNED);
-		*tl++ = cookie.nfsuquad[0];
-		*tl++ = cookie.nfsuquad[1];
-		mtx_lock(&dnp->n_mtx);
-		*tl++ = dnp->n_cookieverf.nfsuquad[0];
-		*tl++ = dnp->n_cookieverf.nfsuquad[1];
-		mtx_unlock(&dnp->n_mtx);
-		*tl++ = txdr_unsigned(nmp->nm_readdirsize);
-		*tl = txdr_unsigned(nmp->nm_rsize);
-		nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_td, cred);
-		nfsm_postop_attr_va(vp, dattrflag, &dvattr);
-		if (error) {
-			m_freem(mrep);
-			goto nfsmout;
-		}
-		tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
-		mtx_lock(&dnp->n_mtx);
-		dnp->n_cookieverf.nfsuquad[0] = *tl++;
-		dnp->n_cookieverf.nfsuquad[1] = *tl++;
-		mtx_unlock(&dnp->n_mtx);
-		more_dirs = fxdr_unsigned(int, *tl);
-
-		/* loop thru the dir entries, doctoring them to 4bsd form */
-		while (more_dirs && bigenough) {
-			tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
-			fileno = fxdr_hyper(tl);
-			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 =
-				    (char *)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 =
-				    (char *)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 =
-				    (char *)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));
-			tl = nfsm_dissect(u_int32_t *, 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);
-			    tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-			    doit = fxdr_unsigned(int, *tl);
-			    /*
- 			     * Skip loading the attrs for "..". There's a 
- 			     * race between loading the attrs here and 
- 			     * lookups that look for the directory currently
- 			     * being read (in the parent). We try to acquire
- 			     * the exclusive lock on ".." here, owning the 
- 			     * lock on the directory being read. Lookup will
- 			     * hold the lock on ".." and try to acquire the 
- 			     * lock on the directory being read.
- 			     * 
- 			     * There are other ways of fixing this, one would
- 			     * be to do a trylock on the ".." vnode and skip
- 			     * loading the attrs on ".." if it happens to be 
- 			     * locked by another process. But skipping the
- 			     * attrload on ".." seems the easiest option.
- 			     */
- 			    if (strcmp(dp->d_name, "..") == 0) {
- 				    doit = 0;
- 				    /*
- 				     * We've already skipped over the attrs, 
- 				     * skip over the filehandle. And store d_type
- 				     * as VDIR.
- 				     */
- 				    tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
- 				    i = fxdr_unsigned(int, *tl);
- 				    nfsm_adv(nfsm_rndup(i));
- 				    dp->d_type = IFTODT(VTTOIF(VDIR));
- 			    }	    
-			    if (doit) {
-				nfsm_getfh(fhp, fhsize, 1);
-				if (NFS_CMPFH(dnp, fhp, fhsize)) {
-				    VREF(vp);
-				    newvp = vp;
-				    np = dnp;
-				} else {
-				    error = nfs_nget(vp->v_mount, fhp,
-					fhsize, &np, LK_EXCLUSIVE);
-				    if (error)
-					doit = 0;
-				    else
-					newvp = NFSTOV(np);
-				}
-			    }
-			    if (doit && bigenough) {
-				dpossav2 = dpos;
-				dpos = dpossav1;
-				mdsav2 = md;
-				md = mdsav1;
-				nfsm_loadattr(newvp, &vattr);
-				dpos = dpossav2;
-				md = mdsav2;
-				dp->d_type = IFTODT(VTTOIF(vattr.va_type));
-				ndp->ni_vp = newvp;
-				if (newvp->v_type != VDIR || dattrflag != 0)
-				    cache_enter_time(ndp->ni_dvp, ndp->ni_vp,
-					cnp, &vattr.va_ctime,
-					newvp->v_type != VDIR ? NULL :
-					&dvattr.va_ctime);
-			    }
-			} else {
-			    /* Just skip over the file handle */
-			    tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-			    i = fxdr_unsigned(int, *tl);
-			    if (i) {
-				    tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-				    fhsize = fxdr_unsigned(int, *tl);
-				    nfsm_adv(nfsm_rndup(fhsize));
-			    }
-			}
-			if (newvp != NULLVP) {
-			    if (newvp == vp)
-				vrele(newvp);
-			    else
-				vput(newvp);
-			    newvp = NULLVP;
-			}
-			tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-			more_dirs = fxdr_unsigned(int, *tl);
-		}
-		/*
-		 * If at end of rpc data, get the eof boolean
-		 */
-		if (!more_dirs) {
-			tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
-			more_dirs = (fxdr_unsigned(int, *tl) == 0);
-		}
-		m_freem(mrep);
-	}
-	/*
-	 * 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 =
-		    (char *)uiop->uio_iov->iov_base + left;
-		uiop->uio_iov->iov_len -= left;
-		uiop->uio_offset += left;
-		uiop->uio_resid -= left;
-	}
-
-	/*
-	 * 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)
-			nfs_printf("EEK! readdirplusrpc resid > 0\n");
-		nfs_dircookie_lock(dnp);
-		cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
-		*cookiep = cookie;
-		nfs_dircookie_unlock(dnp);
-	}
-nfsmout:
-	if (newvp != NULLVP) {
-	        if (newvp == vp)
-			vrele(newvp);
-		else
-			vput(newvp);
-		newvp = NULLVP;
-	}
-	return (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_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...
- */
-static int
-nfs_sillyrename(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
-{
-	struct sillyrename *sp;
-	struct nfsnode *np;
-	int error;
-	short pid;
-	unsigned int lticks;
-
-	cache_purge(dvp);
-	np = VTONFS(vp);
-	KASSERT(vp->v_type != VDIR, ("nfs: sillyrename dir"));
-	sp = malloc(sizeof (struct sillyrename),
-		M_NFSREQ, M_WAITOK);
-	sp->s_cred = crhold(cnp->cn_cred);
-	sp->s_dvp = dvp;
-	sp->s_removeit = nfs_removeit;
-	VREF(dvp);
-
-	/* 
-	 * Fudge together a funny name.
-	 * Changing the format of the funny name to accomodate more 
-	 * sillynames per directory.
-	 * The name is now changed to .nfs.<ticks>.<pid>.4, where ticks is 
-	 * CPU ticks since boot.
-	 */
-	pid = cnp->cn_thread->td_proc->p_pid;
-	lticks = (unsigned int)ticks;
-	for ( ; ; ) {
-		sp->s_namlen = sprintf(sp->s_name, 
-				       ".nfs.%08x.%04x4.4", lticks, 
-				       pid);
-		if (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
-				 cnp->cn_thread, NULL))
-			break;
-		lticks++;
-	}
-	error = nfs_renameit(dvp, cnp, sp);
-	if (error)
-		goto bad;
-	error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
-		cnp->cn_thread, &np);
-	np->n_sillyrename = sp;
-	return (0);
-bad:
-	vrele(sp->s_dvp);
-	crfree(sp->s_cred);
-	free((caddr_t)sp, M_NFSREQ);
-	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
- */
-static int
-nfs_lookitup(struct vnode *dvp, const char *name, int len, struct ucred *cred,
-    struct thread *td, struct nfsnode **npp)
-{
-	struct vnode *newvp = NULL;
-	struct nfsnode *np, *dnp = VTONFS(dvp);
-	caddr_t bpos, dpos;
-	int error = 0, fhlen, attrflag;
-	struct mbuf *mreq, *mrep, *md, *mb;
-	nfsfh_t *nfhp;
-	int v3 = NFS_ISV3(dvp);
-
-	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
-	mreq = m_get2(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len),
-	    M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(dvp, v3);
-	nfsm_strtom(name, len, NFS_MAXNAMLEN);
-	nfsm_request(dvp, NFSPROC_LOOKUP, td, cred);
-	if (npp && !error) {
-		nfsm_getfh(nfhp, fhlen, v3);
-		if (*npp) {
-		    np = *npp;
-		    if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
-			free((caddr_t)np->n_fhp, M_NFSBIGFH);
-			np->n_fhp = &np->n_fh;
-		    } else if (np->n_fhsize <= NFS_SMALLFH && fhlen>NFS_SMALLFH)
-			np->n_fhp =(nfsfh_t *)malloc(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, LK_EXCLUSIVE);
-		    if (error) {
-			m_freem(mrep);
-			return (error);
-		    }
-		    newvp = NFSTOV(np);
-		}
-		if (v3) {
-			nfsm_postop_attr(newvp, attrflag);
-			if (!attrflag && *npp == NULL) {
-				m_freem(mrep);
-				if (newvp == dvp)
-					vrele(newvp);
-				else
-					vput(newvp);
-				return (ENOENT);
-			}
-		} else
-			nfsm_loadattr(newvp, NULL);
-	}
-	m_freem(mrep);
-nfsmout:
-	if (npp && *npp == NULL) {
-		if (error) {
-			if (newvp) {
-				if (newvp == dvp)
-					vrele(newvp);
-				else
-					vput(newvp);
-			}
-		} else
-			*npp = np;
-	}
-	return (error);
-}
-
-/*
- * Nfs Version 3 commit rpc
- */
-int
-nfs_commit(struct vnode *vp, u_quad_t offset, int cnt, struct ucred *cred,
-	   struct thread *td)
-{
-	u_int32_t *tl;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	caddr_t bpos, dpos;
-	int error = 0, wccflag = NFSV3_WCCRATTR;
-	struct mbuf *mreq, *mrep, *md, *mb;
-
-	mtx_lock(&nmp->nm_mtx);
-	if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0) {
-		mtx_unlock(&nmp->nm_mtx);
-		return (0);
-	}
-	mtx_unlock(&nmp->nm_mtx);
-	nfsstats.rpccnt[NFSPROC_COMMIT]++;
-	mreq = m_get2(NFSX_FH(1), M_WAITOK, MT_DATA, 0);
-	mb = mreq;
-	bpos = mtod(mb, caddr_t);
-	nfsm_fhtom(vp, 1);
-	tl = nfsm_build(u_int32_t *, 3 * NFSX_UNSIGNED);
-	txdr_hyper(offset, tl);
-	tl += 2;
-	*tl = txdr_unsigned(cnt);
-	nfsm_request(vp, NFSPROC_COMMIT, td, cred);
-	nfsm_wcc_data(vp, wccflag);
-	if (!error) {
-		tl = nfsm_dissect(u_int32_t *, 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;
-		}
-	}
-	m_freem(mrep);
-nfsmout:
-	return (error);
-}
-
-/*
- * Strategy routine.
- * For async requests when nfsiod(s) are running, queue the request by
- * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
- * request.
- */
-static int
-nfs_strategy(struct vop_strategy_args *ap)
-{
-	struct buf *bp = ap->a_bp;
-	struct ucred *cr;
-
-	KASSERT(!(bp->b_flags & B_DONE),
-	    ("nfs_strategy: buffer %p unexpectedly marked B_DONE", bp));
-	BUF_ASSERT_HELD(bp);
-
-	if (bp->b_iocmd == BIO_READ)
-		cr = bp->b_rcred;
-	else
-		cr = bp->b_wcred;
-
-	/*
-	 * If the op is asynchronous and an i/o daemon is waiting
-	 * queue the request, wake it up and wait for completion
-	 * otherwise just do it ourselves.
-	 */
-	if ((bp->b_flags & B_ASYNC) == 0 ||
-	    nfs_asyncio(VFSTONFS(ap->a_vp->v_mount), bp, NOCRED, curthread))
-		(void)nfs_doio(ap->a_vp, bp, cr, curthread);
-	return (0);
-}
-
-/*
- * fsync vnode op. Just call nfs_flush() with commit == 1.
- */
-/* ARGSUSED */
-static int
-nfs_fsync(struct vop_fsync_args *ap)
-{
-
-	return (nfs_flush(ap->a_vp, ap->a_waitfor, 1));
-}
-
-/*
- * Flush all the blocks associated with a vnode.
- * 	Walk through the buffer pool and push any dirty pages
- *	associated with the vnode.
- */
-static int
-nfs_flush(struct vnode *vp, int waitfor, int commit)
-{
-	struct nfsnode *np = VTONFS(vp);
-	struct buf *bp;
-	int i;
-	struct buf *nbp;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	int error = 0, slptimeo = 0, slpflag = 0, retv, bvecpos;
-	int passone = 1;
-	u_quad_t off, endoff, toff;
-	struct ucred* wcred = NULL;
-	struct buf **bvec = NULL;
-	struct bufobj *bo;
-	struct thread *td = curthread;
-#ifndef NFS_COMMITBVECSIZ
-#define NFS_COMMITBVECSIZ	20
-#endif
-	struct buf *bvec_on_stack[NFS_COMMITBVECSIZ];
-	int bvecsize = 0, bveccount;
-
-	if (nmp->nm_flag & NFSMNT_INT)
-		slpflag = PCATCH;
-	if (!commit)
-		passone = 0;
-	bo = &vp->v_bufobj;
-	/*
-	 * A b_flags == (B_DELWRI | B_NEEDCOMMIT) block has been written to the
-	 * server, but has not been committed to stable storage on the server
-	 * yet. On the first pass, the byte range is worked out and the commit
-	 * rpc is done. On the second pass, nfs_writebp() is called to do the
-	 * job.
-	 */
-again:
-	off = (u_quad_t)-1;
-	endoff = 0;
-	bvecpos = 0;
-	if (NFS_ISV3(vp) && commit) {
-		if (bvec != NULL && bvec != bvec_on_stack)
-			free(bvec, M_TEMP);
-		/*
-		 * Count up how many buffers waiting for a commit.
-		 */
-		bveccount = 0;
-		BO_LOCK(bo);
-		TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
-			if (!BUF_ISLOCKED(bp) &&
-			    (bp->b_flags & (B_DELWRI | B_NEEDCOMMIT))
-				== (B_DELWRI | B_NEEDCOMMIT))
-				bveccount++;
-		}
-		/*
-		 * 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.
-		 * If we can't get memory (for whatever reason), we will end up
-		 * committing the buffers one-by-one in the loop below.
-		 */
-		if (bveccount > NFS_COMMITBVECSIZ) {
-			/*
-			 * Release the vnode interlock to avoid a lock
-			 * order reversal.
-			 */
-			BO_UNLOCK(bo);
-			bvec = (struct buf **)
-				malloc(bveccount * sizeof(struct buf *),
-				       M_TEMP, M_NOWAIT);
-			BO_LOCK(bo);
-			if (bvec == NULL) {
-				bvec = bvec_on_stack;
-				bvecsize = NFS_COMMITBVECSIZ;
-			} else
-				bvecsize = bveccount;
-		} else {
-			bvec = bvec_on_stack;
-			bvecsize = NFS_COMMITBVECSIZ;
-		}
-		TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
-			if (bvecpos >= bvecsize)
-				break;
-			if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
-				nbp = TAILQ_NEXT(bp, b_bobufs);
-				continue;
-			}
-			if ((bp->b_flags & (B_DELWRI | B_NEEDCOMMIT)) !=
-			    (B_DELWRI | B_NEEDCOMMIT)) {
-				BUF_UNLOCK(bp);
-				nbp = TAILQ_NEXT(bp, b_bobufs);
-				continue;
-			}
-			BO_UNLOCK(bo);
-			bremfree(bp);
-			/*
-			 * Work out if all buffers are using the same cred
-			 * so we can deal with them all with one commit.
-			 *
-			 * NOTE: we are not clearing B_DONE here, so we have
-			 * to do it later on in this routine if we intend to
-			 * initiate I/O on the bp.
-			 *
-			 * Note: to avoid loopback deadlocks, we do not
-			 * assign b_runningbufspace.
-			 */
-			if (wcred == NULL)
-				wcred = bp->b_wcred;
-			else if (wcred != bp->b_wcred)
-				wcred = NOCRED;
-			vfs_busy_pages(bp, 1);
-
-			BO_LOCK(bo);
-			/*
-			 * bp is protected by being locked, but nbp is not
-			 * and vfs_busy_pages() may sleep.  We have to
-			 * recalculate nbp.
-			 */
-			nbp = TAILQ_NEXT(bp, b_bobufs);
-
-			/*
-			 * 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 = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
-				bp->b_dirtyoff;
-			if (toff < off)
-				off = toff;
-			toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
-			if (toff > endoff)
-				endoff = toff;
-		}
-		BO_UNLOCK(bo);
-	}
-	if (bvecpos > 0) {
-		/*
-		 * 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 != NOCRED)
-			retv = nfs_commit(vp, off, (int)(endoff - off),
-					  wcred, td);
-		else {
-			retv = 0;
-			for (i = 0; i < bvecpos; i++) {
-				off_t off, size;
-				bp = bvec[i];
-				off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
-					bp->b_dirtyoff;
-				size = (u_quad_t)(bp->b_dirtyend
-						  - bp->b_dirtyoff);
-				retv = nfs_commit(vp, off, (int)size,
-						  bp->b_wcred, td);
-				if (retv) break;
-			}
-		}
-
-		if (retv == NFSERR_STALEWRITEVERF)
-			nfs_clearcommit(vp->v_mount);
-
-		/*
-		 * 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];
-			bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
-			if (retv) {
-				/*
-				 * Error, leave B_DELWRI intact
-				 */
-				vfs_unbusy_pages(bp);
-				brelse(bp);
-			} else {
-				/*
-				 * Success, remove B_DELWRI ( bundirty() ).
-				 *
-				 * b_dirtyoff/b_dirtyend seem to be NFS
-				 * specific.  We should probably move that
-				 * into bundirty(). XXX
-				 */
-				bufobj_wref(bo);
-				bp->b_flags |= B_ASYNC;
-				bundirty(bp);
-				bp->b_flags &= ~B_DONE;
-				bp->b_ioflags &= ~BIO_ERROR;
-				bp->b_dirtyoff = bp->b_dirtyend = 0;
-				bufdone(bp);
-			}
-		}
-	}
-
-	/*
-	 * Start/do any write(s) that are required.
-	 */
-loop:
-	BO_LOCK(bo);
-	TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
-		if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
-			if (waitfor != MNT_WAIT || passone)
-				continue;
-
-			error = BUF_TIMELOCK(bp,
-			    LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
-			    BO_LOCKPTR(bo), "nfsfsync", slpflag, slptimeo);
-			if (error == 0) {
-				BUF_UNLOCK(bp);
-				goto loop;
-			}
-			if (error == ENOLCK) {
-				error = 0;
-				goto loop;
-			}
-			if (nfs_sigintr(nmp, td)) {
-				error = EINTR;
-				goto done;
-			}
-			if (slpflag == PCATCH) {
-				slpflag = 0;
-				slptimeo = 2 * hz;
-			}
-			goto loop;
-		}
-		if ((bp->b_flags & B_DELWRI) == 0)
-			panic("nfs_fsync: not dirty");
-		if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT)) {
-			BUF_UNLOCK(bp);
-			continue;
-		}
-		BO_UNLOCK(bo);
-		bremfree(bp);
-		if (passone || !commit)
-		    bp->b_flags |= B_ASYNC;
-		else
-		    bp->b_flags |= B_ASYNC;
-		bwrite(bp);
-		if (nfs_sigintr(nmp, td)) {
-			error = EINTR;
-			goto done;
-		}
-		goto loop;
-	}
-	if (passone) {
-		passone = 0;
-		BO_UNLOCK(bo);
-		goto again;
-	}
-	if (waitfor == MNT_WAIT) {
-		while (bo->bo_numoutput) {
-			error = bufobj_wwait(bo, slpflag, slptimeo);
-			if (error) {
-			    BO_UNLOCK(bo);
-			    error = nfs_sigintr(nmp, td);
-			    if (error)
-				goto done;
-			    if (slpflag == PCATCH) {
-				slpflag = 0;
-				slptimeo = 2 * hz;
-			    }
-			    BO_LOCK(bo);
-			}
-		}
-		if (bo->bo_dirty.bv_cnt != 0 && commit) {
-			BO_UNLOCK(bo);
-			goto loop;
-		}
-		/*
-		 * Wait for all the async IO requests to drain
-		 */
-		BO_UNLOCK(bo);
-		mtx_lock(&np->n_mtx);
-		while (np->n_directio_asyncwr > 0) {
-			np->n_flag |= NFSYNCWAIT;
-			error = nfs_msleep(td, (caddr_t)&np->n_directio_asyncwr,
-					   &np->n_mtx, slpflag | (PRIBIO + 1), 
-					   "nfsfsync", 0);
-			if (error) {
-				if (nfs_sigintr(nmp, td)) {
-					mtx_unlock(&np->n_mtx);
-					error = EINTR;	
-					goto done;
-				}
-			}
-		}
-		mtx_unlock(&np->n_mtx);
-	} else
-		BO_UNLOCK(bo);
-	mtx_lock(&np->n_mtx);
-	if (np->n_flag & NWRITEERR) {
-		error = np->n_error;
-		np->n_flag &= ~NWRITEERR;
-	}
-  	if (commit && bo->bo_dirty.bv_cnt == 0 &&
-	    bo->bo_numoutput == 0 && np->n_directio_asyncwr == 0)
-  		np->n_flag &= ~NMODIFIED;
-	mtx_unlock(&np->n_mtx);
-done:
-	if (bvec != NULL && bvec != bvec_on_stack)
-		free(bvec, M_TEMP);
-	return (error);
-}
-
-/*
- * NFS advisory byte-level locks.
- */
-static int
-nfs_advlock(struct vop_advlock_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	u_quad_t size;
-	int error;
-
-	error = vn_lock(vp, LK_SHARED);
-	if (error)
-		return (error);
-	if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NOLOCKD) != 0) {
-		size = VTONFS(vp)->n_size;
-		VOP_UNLOCK(vp, 0);
-		error = lf_advlock(ap, &(vp->v_lockf), size);
-	} else {
-		if (nfs_advlock_p)
-			error = nfs_advlock_p(ap);
-		else
-			error = ENOLCK;
-	}
-
-	return (error);
-}
-
-/*
- * NFS advisory byte-level locks.
- */
-static int
-nfs_advlockasync(struct vop_advlockasync_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	u_quad_t size;
-	int error;
-	
-	error = vn_lock(vp, LK_SHARED);
-	if (error)
-		return (error);
-	if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NOLOCKD) != 0) {
-		size = VTONFS(vp)->n_size;
-		VOP_UNLOCK(vp, 0);
-		error = lf_advlockasync(ap, &(vp->v_lockf), size);
-	} else {
-		VOP_UNLOCK(vp, 0);
-		error = EOPNOTSUPP;
-	}
-	return (error);
-}
-
-/*
- * Print out the contents of an nfsnode.
- */
-static int
-nfs_print(struct vop_print_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-
-	nfs_printf("\tfileid %ld fsid 0x%x",
-	   np->n_vattr.va_fileid, np->n_vattr.va_fsid);
-	if (vp->v_type == VFIFO)
-		fifo_printinfo(vp);
-	printf("\n");
-	return (0);
-}
-
-/*
- * This is the "real" nfs::bwrite(struct buf*).
- * We set B_CACHE if this is a VMIO buffer.
- */
-int
-nfs_writebp(struct buf *bp, int force __unused, struct thread *td)
-{
-	int s;
-	int oldflags = bp->b_flags;
-#if 0
-	int retv = 1;
-	off_t off;
-#endif
-
-	BUF_ASSERT_HELD(bp);
-
-	if (bp->b_flags & B_INVAL) {
-		brelse(bp);
-		return(0);
-	}
-
-	bp->b_flags |= B_CACHE;
-
-	/*
-	 * Undirty the bp.  We will redirty it later if the I/O fails.
-	 */
-
-	s = splbio();
-	bundirty(bp);
-	bp->b_flags &= ~B_DONE;
-	bp->b_ioflags &= ~BIO_ERROR;
-	bp->b_iocmd = BIO_WRITE;
-
-	bufobj_wref(bp->b_bufobj);
-	curthread->td_ru.ru_oublock++;
-	splx(s);
-
-	/*
-	 * Note: to avoid loopback deadlocks, we do not
-	 * assign b_runningbufspace.
-	 */
-	vfs_busy_pages(bp, 1);
-
-	BUF_KERNPROC(bp);
-	bp->b_iooffset = dbtob(bp->b_blkno);
-	bstrategy(bp);
-
-	if( (oldflags & B_ASYNC) == 0) {
-		int rtval = bufwait(bp);
-
-		if (oldflags & B_DELWRI) {
-			s = splbio();
-			reassignbuf(bp);
-			splx(s);
-		}
-		brelse(bp);
-		return (rtval);
-	}
-
-	return (0);
-}
-
-/*
- * 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(struct vop_access_args *ap)
-{
-	struct vattr *vap;
-	struct ucred *cred = ap->a_cred;
-	struct vnode *vp = ap->a_vp;
-	accmode_t accmode = ap->a_accmode;
-	struct vattr vattr;
-	int error;
-
-	/*
-	 * 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 ((accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
-		switch (vp->v_type) {
-		case VREG:
-		case VDIR:
-		case VLNK:
-			return (EROFS);
-		default:
-			break;
-		}
-	}
-	vap = &vattr;
-	error = VOP_GETATTR(vp, vap, cred);
-	if (error)
-		goto out;
-	error  = vaccess(vp->v_type, vap->va_mode, vap->va_uid, vap->va_gid,
-			 accmode, cred, NULL);
-out:
-	return error;
-}
-
-/*
- * Read wrapper for fifos.
- */
-static int
-nfsfifo_read(struct vop_read_args *ap)
-{
-	struct nfsnode *np = VTONFS(ap->a_vp);
-	int error;
-
-	/*
-	 * Set access flag.
-	 */
-	mtx_lock(&np->n_mtx);
-	np->n_flag |= NACC;
-	vfs_timestamp(&np->n_atim);
-	mtx_unlock(&np->n_mtx);
-	error = fifo_specops.vop_read(ap);
-	return error;	
-}
-
-/*
- * Write wrapper for fifos.
- */
-static int
-nfsfifo_write(struct vop_write_args *ap)
-{
-	struct nfsnode *np = VTONFS(ap->a_vp);
-
-	/*
-	 * Set update flag.
-	 */
-	mtx_lock(&np->n_mtx);
-	np->n_flag |= NUPD;
-	vfs_timestamp(&np->n_mtim);
-	mtx_unlock(&np->n_mtx);
-	return(fifo_specops.vop_write(ap));
-}
-
-/*
- * Close wrapper for fifos.
- *
- * Update the times on the nfsnode then do fifo close.
- */
-static int
-nfsfifo_close(struct vop_close_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct nfsnode *np = VTONFS(vp);
-	struct vattr vattr;
-	struct timespec ts;
-
-	mtx_lock(&np->n_mtx);
-	if (np->n_flag & (NACC | NUPD)) {
-		vfs_timestamp(&ts);
-		if (np->n_flag & NACC)
-			np->n_atim = ts;
-		if (np->n_flag & NUPD)
-			np->n_mtim = ts;
-		np->n_flag |= NCHG;
-		if (vrefcnt(vp) == 1 &&
-		    (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;
-			mtx_unlock(&np->n_mtx);
-			(void)VOP_SETATTR(vp, &vattr, ap->a_cred);
-			goto out;
-		}
-	}
-	mtx_unlock(&np->n_mtx);
-out:
-	return (fifo_specops.vop_close(ap));
-}
-
-/*
- * Just call nfs_writebp() with the force argument set to 1.
- *
- * NOTE: B_DONE may or may not be set in a_bp on call.
- */
-static int
-nfs_bwrite(struct buf *bp)
-{
-
-	return (nfs_writebp(bp, 1, curthread));
-}
-
-struct buf_ops buf_ops_nfs = {
-	.bop_name	=	"buf_ops_nfs",
-	.bop_write	=	nfs_bwrite,
-	.bop_strategy	=	bufstrategy,
-	.bop_sync	=	bufsync,
-	.bop_bdflush	=	bufbdflush,
-};