X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/f67785e515ae5e8e21668d01de75461cb696ba65..c7dd831e0e98cc04210de75f24255501efa8f2ad:/usr/src/sys/nfs/nfs_vnops.c

diff --git a/usr/src/sys/nfs/nfs_vnops.c b/usr/src/sys/nfs/nfs_vnops.c
index 4167e3fca2..570ab88b93 100644
--- a/usr/src/sys/nfs/nfs_vnops.c
+++ b/usr/src/sys/nfs/nfs_vnops.c
@@ -17,7 +17,7 @@
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- *	@(#)nfs_vnops.c	7.11 (Berkeley) %G%
+ *	@(#)nfs_vnops.c	7.29 (Berkeley) %G%
  */
 
 /*
@@ -26,24 +26,18 @@
 
 #include "machine/pte.h"
 #include "machine/mtpr.h"
-#include "strings.h"
 #include "param.h"
 #include "user.h"
 #include "proc.h"
 #include "mount.h"
 #include "buf.h"
 #include "vm.h"
-#include "../ufs/dir.h"
 #include "malloc.h"
 #include "mbuf.h"
-#include "uio.h"
-#include "ucred.h"
-#include "namei.h"
 #include "errno.h"
 #include "file.h"
 #include "conf.h"
 #include "vnode.h"
-#include "../ufs/inode.h"
 #include "map.h"
 #include "nfsv2.h"
 #include "nfs.h"
@@ -85,39 +79,43 @@ int	nfs_lookup(),
 	nfs_strategy(),
 	nfs_fsync(),
 	nfs_inactive(),
-	nfs_reclaim();
+	nfs_reclaim(),
+	nfs_print(),
+	nfs_islocked();
 
 struct vnodeops nfsv2_vnodeops = {
-	nfs_lookup,
-	nfs_create,
-	nfs_mknod,
-	nfs_open,
-	nfs_close,
-	nfs_access,
-	nfs_getattr,
-	nfs_setattr,
-	nfs_read,
-	nfs_write,
-	vfs_noop,
-	vfs_noop,
-	vfs_noop,
-	nfs_fsync,
-	vfs_nullop,
-	nfs_remove,
-	nfs_link,
-	nfs_rename,
-	nfs_mkdir,
-	nfs_rmdir,
-	nfs_symlink,
-	nfs_readdir,
-	nfs_readlink,
-	nfs_abortop,
-	nfs_inactive,
-	nfs_reclaim,
-	nfs_lock,
-	nfs_unlock,
-	nfs_bmap,
-	nfs_strategy,
+	nfs_lookup,		/* lookup */
+	nfs_create,		/* create */
+	nfs_mknod,		/* mknod */
+	nfs_open,		/* open */
+	nfs_close,		/* close */
+	nfs_access,		/* access */
+	nfs_getattr,		/* getattr */
+	nfs_setattr,		/* setattr */
+	nfs_read,		/* read */
+	nfs_write,		/* write */
+	vfs_noop,		/* ioctl */
+	vfs_noop,		/* select */
+	vfs_noop,		/* mmap */
+	nfs_fsync,		/* fsync */
+	vfs_nullop,		/* seek */
+	nfs_remove,		/* remove */
+	nfs_link,		/* link */
+	nfs_rename,		/* rename */
+	nfs_mkdir,		/* mkdir */
+	nfs_rmdir,		/* rmdir */
+	nfs_symlink,		/* symlink */
+	nfs_readdir,		/* readdir */
+	nfs_readlink,		/* readlink */
+	nfs_abortop,		/* abortop */
+	nfs_inactive,		/* inactive */
+	nfs_reclaim,		/* reclaim */
+	nfs_lock,		/* lock */
+	nfs_unlock,		/* unlock */
+	nfs_bmap,		/* bmap */
+	nfs_strategy,		/* strategy */
+	nfs_print,		/* print */
+	nfs_islocked,		/* islocked */
 };
 
 /* Special device vnode ops */
@@ -126,6 +124,7 @@ int	spec_lookup(),
 	spec_read(),
 	spec_write(),
 	spec_strategy(),
+	spec_bmap(),
 	spec_ioctl(),
 	spec_select(),
 	spec_close(),
@@ -133,41 +132,44 @@ int	spec_lookup(),
 	spec_nullop();
 
 struct vnodeops spec_nfsv2nodeops = {
-	spec_lookup,
-	spec_badop,
-	spec_badop,
-	spec_open,
-	spec_close,
-	nfs_access,
-	nfs_getattr,
-	nfs_setattr,
-	spec_read,
-	spec_write,
-	spec_ioctl,
-	spec_select,
-	spec_badop,
-	spec_nullop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	spec_badop,
-	nfs_inactive,
-	nfs_reclaim,
-	nfs_lock,
-	nfs_unlock,
-	spec_badop,
-	spec_strategy,
+	spec_lookup,		/* lookup */
+	spec_badop,		/* create */
+	spec_badop,		/* mknod */
+	spec_open,		/* open */
+	spec_close,		/* close */
+	nfs_access,		/* access */
+	nfs_getattr,		/* getattr */
+	nfs_setattr,		/* setattr */
+	spec_read,		/* read */
+	spec_write,		/* write */
+	spec_ioctl,		/* ioctl */
+	spec_select,		/* select */
+	spec_badop,		/* mmap */
+	spec_nullop,		/* fsync */
+	spec_badop,		/* seek */
+	spec_badop,		/* remove */
+	spec_badop,		/* link */
+	spec_badop,		/* rename */
+	spec_badop,		/* mkdir */
+	spec_badop,		/* rmdir */
+	spec_badop,		/* symlink */
+	spec_badop,		/* readdir */
+	spec_badop,		/* readlink */
+	spec_badop,		/* abortop */
+	nfs_inactive,		/* inactive */
+	nfs_reclaim,		/* reclaim */
+	nfs_lock,		/* lock */
+	nfs_unlock,		/* unlock */
+	spec_bmap,		/* bmap */
+	spec_strategy,		/* strategy */
+	nfs_print,		/* print */
+	nfs_islocked,		/* islocked */
 };
 
 extern u_long nfs_procids[NFS_NPROCS];
 extern u_long nfs_prog, nfs_vers;
 extern char nfsiobuf[MAXPHYS+NBPG];
+extern int nonidempotent[NFS_NPROCS];
 struct map nfsmap[NFS_MSIZ];
 enum vtype v_type[NFLNK+1];
 struct buf nfs_bqueue;		/* Queue head for nfsiod's */
@@ -182,10 +184,13 @@ nfs_null(vp, cred)
 	struct vnode *vp;
 	struct ucred *cred;
 {
-	nfsm_vars;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb;
 	
 	nfsm_reqhead(nfs_procids[NFSPROC_NULL], cred, 0);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_NULL]);
 	nfsm_reqdone;
 	return (error);
 }
@@ -238,6 +243,7 @@ found:
  * nfs open vnode op
  * Just check to see if the type is ok
  */
+/* ARGSUSED */
 nfs_open(vp, mode, cred)
 	struct vnode *vp;
 	int mode;
@@ -256,24 +262,23 @@ nfs_open(vp, mode, cred)
  * nfs close vnode op
  * For reg files, invalidate any buffer cache entries.
  */
+/* ARGSUSED */
 nfs_close(vp, fflags, cred)
 	register struct vnode *vp;
 	int fflags;
 	struct ucred *cred;
 {
-	struct nfsnode *np = VTONFS(vp);
-	dev_t dev;
+	register struct nfsnode *np = VTONFS(vp);
 	int error = 0;
 
 	if (vp->v_type == VREG && ((np->n_flag & NMODIFIED) ||
 	   ((np->n_flag & NBUFFERED) && np->n_sillyrename))) {
 		nfs_lock(vp);
 		np->n_flag &= ~(NMODIFIED|NBUFFERED);
-		error = nfs_blkflush(vp, (daddr_t)0, np->n_size, TRUE);
+		vinvalbuf(vp, TRUE);
 		if (np->n_flag & NWRITEERR) {
 			np->n_flag &= ~NWRITEERR;
-			if (!error)
-				error = np->n_error ? np->n_error : EIO;
+			error = np->n_error;
 		}
 		nfs_unlock(vp);
 	}
@@ -284,11 +289,16 @@ nfs_close(vp, fflags, cred)
  * nfs getattr call from vfs.
  */
 nfs_getattr(vp, vap, cred)
-	struct vnode *vp;
-	register struct vattr *vap;
+	register struct vnode *vp;
+	struct vattr *vap;
 	struct ucred *cred;
 {
-	nfsm_vars;
+	register caddr_t cp;
+	register long t1;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	
 	/* First look in the cache.. */
 	if (nfs_getattrcache(vp, vap) == 0)
@@ -296,7 +306,7 @@ nfs_getattr(vp, vap, cred)
 	nfsstats.rpccnt[NFSPROC_GETATTR]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_GETATTR], cred, NFSX_FH);
 	nfsm_fhtom(vp);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_GETATTR]);
 	nfsm_loadattr(vp, vap);
 	nfsm_reqdone;
 	return (error);
@@ -306,12 +316,17 @@ nfs_getattr(vp, vap, cred)
  * nfs setattr call.
  */
 nfs_setattr(vp, vap, cred)
-	struct vnode *vp;
+	register struct vnode *vp;
 	register struct vattr *vap;
 	struct ucred *cred;
 {
 	register struct nfsv2_sattr *sp;
-	nfsm_vars;
+	register caddr_t cp;
+	register long t1;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	struct nfsnode *np;
 
 	nfsstats.rpccnt[NFSPROC_SETATTR]++;
@@ -335,12 +350,13 @@ nfs_setattr(vp, vap, cred)
 		np = VTONFS(vp);
 		if (np->n_flag & NMODIFIED) {
 			np->n_flag &= ~NMODIFIED;
-			nfs_blkflush(vp, (daddr_t)0, np->n_size, TRUE);
+			vinvalbuf(vp, TRUE);
 		}
 	}
-	txdr_time(&vap->va_atime, &sp->sa_atime);
+	sp->sa_atime.tv_sec = txdr_unsigned(vap->va_atime.tv_sec);
+	sp->sa_atime.tv_usec = txdr_unsigned(vap->va_flags);
 	txdr_time(&vap->va_mtime, &sp->sa_mtime);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_SETATTR]);
 	nfsm_loadattr(vp, (struct vattr *)0);
 	/* should we fill in any vap fields ?? */
 	nfsm_reqdone;
@@ -357,13 +373,17 @@ nfs_lookup(vp, ndp)
 	register struct nameidata *ndp;
 {
 	register struct vnode *vdp;
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	struct vnode *newvp;
 	long len;
 	nfsv2fh_t *fhp;
 	struct nfsnode *np;
-	int lockparent, wantparent, flag;
-	dev_t rdev;
+	int lockparent, wantparent, flag, error = 0;
 
 	ndp->ni_dvp = vp;
 	ndp->ni_vp = NULL;
@@ -403,9 +423,9 @@ nfs_lookup(vp, ndp)
 				nfs_nput(vdp);
 			}
 		}
-		nfs_lock(vp);
 		ndp->ni_vp = (struct vnode *)0;
-	}
+	} else
+		nfs_unlock(vp);
 	error = 0;
 	nfsstats.lookupcache_misses++;
 	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
@@ -413,14 +433,12 @@ nfs_lookup(vp, ndp)
 	nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], ndp->ni_cred, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len));
 	nfsm_fhtom(vp);
 	nfsm_strtom(ndp->ni_ptr, len, NFS_MAXNAMLEN);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_LOOKUP]);
 nfsmout:
 	if (error) {
-		if ((flag == CREATE || flag == RENAME) &&
-			*ndp->ni_next == 0) {
-			if (!lockparent)
-				nfs_unlock(vp);
-		}
+		if (lockparent || (flag != CREATE && flag != RENAME) ||
+		    *ndp->ni_next != 0)
+			nfs_lock(vp);
 		return (ENOENT);
 	}
 	nfsm_disect(fhp,nfsv2fh_t *,NFSX_FH);
@@ -435,6 +453,7 @@ nfsmout:
 			np = VTONFS(vp);
 		} else {
 			if (error = nfs_nget(vp->v_mount, fhp, &np)) {
+				nfs_lock(vp);
 				m_freem(mrep);
 				return (error);
 			}
@@ -442,6 +461,7 @@ nfsmout:
 		}
 		if (error =
 		    nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) {
+			nfs_lock(vp);
 			if (newvp != vp)
 				nfs_nput(newvp);
 			else
@@ -450,31 +470,34 @@ nfsmout:
 			return (error);
 		}
 		ndp->ni_vp = newvp;
-		if (!lockparent)
-			nfs_unlock(vp);
+		if (lockparent || vp == newvp)
+			nfs_lock(vp);
 		m_freem(mrep);
 		return (0);
 	}
 
 	if (flag == RENAME && wantparent && *ndp->ni_next == 0) {
 		if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) {
+			nfs_lock(vp);
 			m_freem(mrep);
 			return (EISDIR);
 		}
 		if (error = nfs_nget(vp->v_mount, fhp, &np)) {
+			nfs_lock(vp);
 			m_freem(mrep);
 			return (error);
 		}
 		newvp = NFSTOV(np);
 		if (error =
 		    nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) {
+			nfs_lock(vp);
 			nfs_nput(newvp);
 			m_freem(mrep);
 			return (error);
 		}
 		ndp->ni_vp = newvp;
-		if (!lockparent)
-			nfs_unlock(vp);
+		if (lockparent)
+			nfs_lock(vp);
 		return (0);
 	}
 
@@ -483,22 +506,22 @@ nfsmout:
 		newvp = vp;
 		np = VTONFS(vp);
 	} else if (ndp->ni_isdotdot) {
-		nfs_unlock(vp);
 		if (error = nfs_nget(vp->v_mount, fhp, &np)) {
 			nfs_lock(vp);
 			m_freem(mrep);
 			return (error);
 		}
-		nfs_lock(vp);
 		newvp = NFSTOV(np);
 	} else {
 		if (error = nfs_nget(vp->v_mount, fhp, &np)) {
+			nfs_lock(vp);
 			m_freem(mrep);
 			return (error);
 		}
 		newvp = NFSTOV(np);
 	}
 	if (error = nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) {
+		nfs_lock(vp);
 		if (newvp != vp)
 			nfs_nput(newvp);
 		else
@@ -508,8 +531,8 @@ nfsmout:
 	}
 	m_freem(mrep);
 
-	if (vp != newvp && (!lockparent || *ndp->ni_next != '\0'))
-		nfs_unlock(vp);
+	if (vp == newvp || (lockparent && *ndp->ni_next == '\0'))
+		nfs_lock(vp);
 	ndp->ni_vp = newvp;
 	if (error == 0 && ndp->ni_makeentry)
 		cache_enter(ndp);
@@ -520,17 +543,23 @@ nfsmout:
  * nfs readlink call
  */
 nfs_readlink(vp, uiop, cred)
-	struct vnode *vp;
+	register struct vnode *vp;
 	struct uio *uiop;
 	struct ucred *cred;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	long len;
 
 	nfsstats.rpccnt[NFSPROC_READLINK]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_READLINK], cred, NFSX_FH);
 	nfsm_fhtom(vp);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_READLINK]);
 	nfsm_strsiz(len, NFS_MAXPATHLEN);
 	nfsm_mtouio(uiop, len);
 	nfsm_reqdone;
@@ -540,13 +569,18 @@ nfs_readlink(vp, uiop, cred)
 /*
  * nfs read call
  */
-nfs_readrpc(vp, uiop, offp, cred)
-	struct vnode *vp;
+nfs_readrpc(vp, uiop, cred)
+	register struct vnode *vp;
 	struct uio *uiop;
-	off_t *offp;
 	struct ucred *cred;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	struct nfsmount *nmp;
 	long len, retlen, tsiz;
 
@@ -558,15 +592,14 @@ nfs_readrpc(vp, uiop, offp, cred)
 		nfsm_reqhead(nfs_procids[NFSPROC_READ], cred, NFSX_FH+NFSX_UNSIGNED*3);
 		nfsm_fhtom(vp);
 		nfsm_build(p, u_long *, NFSX_UNSIGNED*3);
-		*p++ = txdr_unsigned(*offp);
+		*p++ = txdr_unsigned(uiop->uio_offset);
 		*p++ = txdr_unsigned(len);
 		*p = 0;
-		nfsm_request(vp);
+		nfsm_request(vp, nonidempotent[NFSPROC_READ]);
 		nfsm_loadattr(vp, (struct vattr *)0);
 		nfsm_strsiz(retlen, nmp->nm_rsize);
 		nfsm_mtouio(uiop, retlen);
 		m_freem(mrep);
-		*offp += retlen;
 		if (retlen < len)
 			tsiz = 0;
 		else
@@ -579,13 +612,18 @@ nfsmout:
 /*
  * nfs write call
  */
-nfs_writerpc(vp, uiop, offp, cred)
-	struct vnode *vp;
+nfs_writerpc(vp, uiop, cred)
+	register struct vnode *vp;
 	struct uio *uiop;
-	off_t *offp;
 	struct ucred *cred;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	struct nfsmount *nmp;
 	long len, tsiz;
 
@@ -598,14 +636,13 @@ nfs_writerpc(vp, uiop, offp, cred)
 			NFSX_FH+NFSX_UNSIGNED*4);
 		nfsm_fhtom(vp);
 		nfsm_build(p, u_long *, NFSX_UNSIGNED*4);
-		*(p+1) = txdr_unsigned(*offp);
+		*(p+1) = txdr_unsigned(uiop->uio_offset);
 		*(p+3) = txdr_unsigned(len);
 		nfsm_uiotom(uiop, len);
-		nfsm_request(vp);
+		nfsm_request(vp, nonidempotent[NFSPROC_WRITE]);
 		nfsm_loadattr(vp, (struct vattr *)0);
 		m_freem(mrep);
 		tsiz -= len;
-		*offp += len;
 	}
 nfsmout:
 	return (error);
@@ -634,7 +671,13 @@ nfs_create(ndp, vap)
 	register struct vattr *vap;
 {
 	register struct nfsv2_sattr *sp;
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	nfsstats.rpccnt[NFSPROC_CREATE]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_CREATE], ndp->ni_cred,
@@ -649,7 +692,7 @@ nfs_create(ndp, vap)
 	/* or should these be VNOVAL ?? */
 	txdr_time(&vap->va_atime, &sp->sa_atime);
 	txdr_time(&vap->va_mtime, &sp->sa_mtime);
-	nfsm_request(ndp->ni_dvp);
+	nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_CREATE]);
 	nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp);
 	nfsm_reqdone;
 	nfs_nput(ndp->ni_dvp);
@@ -668,7 +711,7 @@ nfs_create(ndp, vap)
  *	  mpurge the vnode to flush out cmap references
  *	  (This is necessary to update the vnode ref cnt as well as sensible
  *	   for actual removes, to free up the buffers)
- * 2 - If v_count > 1
+ * 2 - If v_usecount > 1
  *	  If a rename is not already in the works
  *	     call nfs_sillyrename() to set it up
  *     else
@@ -679,17 +722,25 @@ nfs_remove(ndp)
 {
 	register struct vnode *vp = ndp->ni_vp;
 	register struct nfsnode *np = VTONFS(ndp->ni_vp);
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	if (vp->v_type == VREG) {
 		if (np->n_flag & (NMODIFIED|NBUFFERED)) {
 			np->n_flag &= ~(NMODIFIED|NBUFFERED);
-			nfs_blkflush(vp, (daddr_t)0, np->n_size, TRUE);
+			vinvalbuf(vp, TRUE);
 		}
-		if (np->n_flag & NPAGEDON)
+		if (np->n_flag & NPAGEDON) {
+			np->n_flag &= ~NPAGEDON;
 			mpurge(vp);	/* In case cmap entries still ref it */
+		}
 	}
-	if (vp->v_count > 1) {
+	if (vp->v_usecount > 1) {
 		if (!np->n_sillyrename)
 			error = nfs_sillyrename(ndp, REMOVE);
 	} else {
@@ -698,14 +749,23 @@ nfs_remove(ndp)
 			NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen));
 		nfsm_fhtom(ndp->ni_dvp);
 		nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN);
-		nfsm_request(ndp->ni_dvp);
+		nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_REMOVE]);
 		nfsm_reqdone;
+		/*
+		 * 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;
 	}
-	if (ndp->ni_dvp == ndp->ni_vp)
-		vrele(ndp->ni_vp);
+	np->n_attrstamp = 0;
+	if (ndp->ni_dvp == vp)
+		vrele(vp);
 	else
-		nfs_nput(ndp->ni_vp);
-	nfs_nput(ndp->ni_dvp);
+		nfs_nput(ndp->ni_dvp);
+	nfs_nput(vp);
 	return (error);
 }
 
@@ -715,14 +775,20 @@ nfs_remove(ndp)
 nfs_removeit(ndp)
 	register struct nameidata *ndp;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	nfsstats.rpccnt[NFSPROC_REMOVE]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_REMOVE], ndp->ni_cred,
 		NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen));
 	nfsm_fhtom(ndp->ni_dvp);
 	nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN);
-	nfsm_request(ndp->ni_dvp);
+	nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_REMOVE]);
 	nfsm_reqdone;
 	return (error);
 }
@@ -733,7 +799,13 @@ nfs_removeit(ndp)
 nfs_rename(sndp, tndp)
 	register struct nameidata *sndp, *tndp;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	nfsstats.rpccnt[NFSPROC_RENAME]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_RENAME], tndp->ni_cred,
@@ -743,7 +815,7 @@ nfs_rename(sndp, tndp)
 	nfsm_strtom(sndp->ni_dent.d_name,sndp->ni_dent.d_namlen,NFS_MAXNAMLEN);
 	nfsm_fhtom(tndp->ni_dvp);
 	nfsm_strtom(tndp->ni_dent.d_name,tndp->ni_dent.d_namlen,NFS_MAXNAMLEN);
-	nfsm_request(sndp->ni_dvp);
+	nfsm_request(sndp->ni_dvp, nonidempotent[NFSPROC_RENAME]);
 	nfsm_reqdone;
 	if (sndp->ni_vp->v_type == VDIR) {
 		if (tndp->ni_vp != NULL && tndp->ni_vp->v_type == VDIR)
@@ -752,6 +824,11 @@ nfs_rename(sndp, tndp)
 	}
 	nfs_abortop(sndp);
 	nfs_abortop(tndp);
+	/*
+	 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
+	 */
+	if (error == ENOENT)
+		error = 0;
 	return (error);
 }
 
@@ -761,7 +838,13 @@ nfs_rename(sndp, tndp)
 nfs_renameit(sndp, tndp)
 	register struct nameidata *sndp, *tndp;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	nfsstats.rpccnt[NFSPROC_RENAME]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_RENAME], tndp->ni_cred,
@@ -771,7 +854,7 @@ nfs_renameit(sndp, tndp)
 	nfsm_strtom(sndp->ni_dent.d_name,sndp->ni_dent.d_namlen,NFS_MAXNAMLEN);
 	nfsm_fhtom(tndp->ni_dvp);
 	nfsm_strtom(tndp->ni_dent.d_name,tndp->ni_dent.d_namlen,NFS_MAXNAMLEN);
-	nfsm_request(sndp->ni_dvp);
+	nfsm_request(sndp->ni_dvp, nonidempotent[NFSPROC_RENAME]);
 	nfsm_reqdone;
 	return (error);
 }
@@ -780,10 +863,16 @@ nfs_renameit(sndp, tndp)
  * nfs hard link create call
  */
 nfs_link(vp, ndp)
-	struct vnode *vp;
+	register struct vnode *vp;
 	register struct nameidata *ndp;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	if (ndp->ni_dvp != vp)
 		nfs_lock(vp);
@@ -793,11 +882,17 @@ nfs_link(vp, ndp)
 	nfsm_fhtom(vp);
 	nfsm_fhtom(ndp->ni_dvp);
 	nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_LINK]);
 	nfsm_reqdone;
+	VTONFS(vp)->n_attrstamp = 0;
 	if (ndp->ni_dvp != vp)
 		nfs_unlock(vp);
 	nfs_nput(ndp->ni_dvp);
+	/*
+	 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
+	 */
+	if (error == EEXIST)
+		error = 0;
 	return (error);
 }
 
@@ -810,7 +905,13 @@ nfs_symlink(ndp, vap, nm)
 	char *nm;		/* is this the path ?? */
 {
 	register struct nfsv2_sattr *sp;
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	nfsstats.rpccnt[NFSPROC_SYMLINK]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_SYMLINK], ndp->ni_cred,
@@ -823,11 +924,16 @@ nfs_symlink(ndp, vap, nm)
 	sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid);
 	sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid);
 	sp->sa_size = txdr_unsigned(VNOVAL);
-	txdr_time(&vap->va_atime, &sp->sa_atime);		/* or VNOVAL ?? */
+	txdr_time(&vap->va_atime, &sp->sa_atime);	/* or VNOVAL ?? */
 	txdr_time(&vap->va_mtime, &sp->sa_mtime);	/* or VNOVAL ?? */
-	nfsm_request(ndp->ni_dvp);
+	nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_SYMLINK]);
 	nfsm_reqdone;
 	nfs_nput(ndp->ni_dvp);
+	/*
+	 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
+	 */
+	if (error == EEXIST)
+		error = 0;
 	return (error);
 }
 
@@ -835,11 +941,17 @@ nfs_symlink(ndp, vap, nm)
  * nfs make dir call
  */
 nfs_mkdir(ndp, vap)
-	struct nameidata *ndp;
+	register struct nameidata *ndp;
 	struct vattr *vap;
 {
 	register struct nfsv2_sattr *sp;
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	nfsstats.rpccnt[NFSPROC_MKDIR]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_MKDIR], ndp->ni_cred,
@@ -851,12 +963,17 @@ nfs_mkdir(ndp, vap)
 	sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid);
 	sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid);
 	sp->sa_size = txdr_unsigned(VNOVAL);
-	txdr_time(&vap->va_atime, &sp->sa_atime);		/* or VNOVAL ?? */
+	txdr_time(&vap->va_atime, &sp->sa_atime);	/* or VNOVAL ?? */
 	txdr_time(&vap->va_mtime, &sp->sa_mtime);	/* or VNOVAL ?? */
-	nfsm_request(ndp->ni_dvp);
+	nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_MKDIR]);
 	nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp);
 	nfsm_reqdone;
 	nfs_nput(ndp->ni_dvp);
+	/*
+	 * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry.
+	 */
+	if (error == EEXIST)
+		error = 0;
 	return (error);
 }
 
@@ -866,7 +983,13 @@ nfs_mkdir(ndp, vap)
 nfs_rmdir(ndp)
 	register struct nameidata *ndp;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 
 	if (ndp->ni_dvp == ndp->ni_vp) {
 		vrele(ndp->ni_dvp);
@@ -878,12 +1001,17 @@ nfs_rmdir(ndp)
 		NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen));
 	nfsm_fhtom(ndp->ni_dvp);
 	nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN);
-	nfsm_request(ndp->ni_dvp);
+	nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_RMDIR]);
 	nfsm_reqdone;
 	cache_purge(ndp->ni_dvp);
 	cache_purge(ndp->ni_vp);
 	nfs_nput(ndp->ni_vp);
 	nfs_nput(ndp->ni_dvp);
+	/*
+	 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
+	 */
+	if (error == ENOENT)
+		error = 0;
 	return (error);
 }
 
@@ -893,31 +1021,35 @@ nfs_rmdir(ndp)
  * order so that it looks more sensible. This appears consistent with the
  * Ultrix implementation of NFS.
  */
-nfs_readdir(vp, uiop, offp, cred)
-	struct vnode *vp;
+nfs_readdir(vp, uiop, cred)
+	register struct vnode *vp;
 	struct uio *uiop;
-	off_t *offp;
 	struct ucred *cred;
 {
 	register long len;
 	register struct direct *dp;
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1;
+	long tlen;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	struct mbuf *md2;
 	caddr_t dpos2;
 	int siz;
-	int more_dirs, eofflg;
+	int more_dirs;
 	off_t off, savoff;
 	struct direct *savdp;
 
-	nfs_lock(vp);
 	nfsstats.rpccnt[NFSPROC_READDIR]++;
 	nfsm_reqhead(nfs_procids[NFSPROC_READDIR], cred, xid);
 	nfsm_fhtom(vp);
 	nfsm_build(p, u_long *, 2*NFSX_UNSIGNED);
-	off = *offp;
-	*p++ = txdr_unsigned(off);
+	*p++ = txdr_unsigned(uiop->uio_offset);
 	*p = txdr_unsigned(uiop->uio_resid);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_READDIR]);
 	siz = 0;
 	nfsm_disect(p, u_long *, NFSX_UNSIGNED);
 	more_dirs = fxdr_unsigned(int, *p);
@@ -927,6 +1059,8 @@ nfs_readdir(vp, uiop, offp, cred)
 	md2 = md;
 
 	/* loop thru the dir entries, doctoring them to 4bsd form */
+	savoff = off = 0;
+	savdp = dp = NULL;
 	while (more_dirs && siz < uiop->uio_resid) {
 		savoff = off;		/* Hold onto offset and dp */
 		savdp = dp;
@@ -940,8 +1074,13 @@ nfs_readdir(vp, uiop, offp, cred)
 			goto nfsmout;
 		}
 		dp->d_namlen = (u_short)len;
-		len = nfsm_rndup(len);
-		nfsm_adv(len);
+		nfsm_adv(len);		/* Point past name */
+		tlen = nfsm_rndup(len);
+		if (tlen != len) {	/* If name not on rounded boundary */
+			*dpos = '\0';	/* Null-terminate */
+			nfsm_adv(tlen - len);
+			len = tlen;
+		}
 		nfsm_disecton(p, u_long *, 2*NFSX_UNSIGNED);
 		off = fxdr_unsigned(off_t, *p);
 		*p++ = 0;		/* Ensures null termination of name */
@@ -952,37 +1091,25 @@ nfs_readdir(vp, uiop, offp, cred)
 	/*
 	 * If at end of rpc data, get the eof boolean
 	 */
-	if (!more_dirs) {
+	if (!more_dirs)
 		nfsm_disecton(p, u_long *, NFSX_UNSIGNED);
-		eofflg = fxdr_unsigned(long, *p);
-	}
 	/*
 	 * If there is too much to fit in the data buffer, use savoff and
 	 * savdp to trim off the last record.
 	 * --> we are not at eof
 	 */
 	if (siz > uiop->uio_resid) {
-		eofflg = FALSE;
 		off = savoff;
 		siz -= dp->d_reclen;
 		dp = savdp;
 	}
 	if (siz > 0) {
-#ifdef notdef
-		if (!eofflg)
-			dp->d_reclen += (uiop->uio_resid-siz);
-#endif
 		md = md2;
 		dpos = dpos2;
 		nfsm_mtouio(uiop, siz);
-#ifdef notdef
-		if (!eofflg)
-			uiop->uio_resid = 0;
-#endif
-		*offp = off;
+		uiop->uio_offset = off;
 	}
 	nfsm_reqdone;
-	nfs_unlock(vp);
 	return (error);
 }
 
@@ -994,12 +1121,17 @@ nfs_statfs(mp, sbp)
 	struct mount *mp;
 	register struct statfs *sbp;
 {
+	register struct vnode *vp;
 	register struct nfsv2_statfs *sfp;
-	nfsm_vars;
+	register caddr_t cp;
+	register long t1;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	struct nfsmount *nmp;
 	struct ucred *cred;
 	struct nfsnode *np;
-	struct vnode *vp;
 
 	nmp = vfs_to_nfs(mp);
 	if (error = nfs_nget(mp, &nmp->nm_fh, &np))
@@ -1010,7 +1142,7 @@ nfs_statfs(mp, sbp)
 	cred->cr_ngroups = 1;
 	nfsm_reqhead(nfs_procids[NFSPROC_STATFS], cred, NFSX_FH);
 	nfsm_fhtom(vp);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_STATFS]);
 	nfsm_disect(sfp, struct nfsv2_statfs *, NFSX_STATFS);
 	sbp->f_type = MOUNT_NFS;
 	sbp->f_flags = nmp->nm_flag;
@@ -1031,7 +1163,7 @@ nfs_statfs(mp, sbp)
 	return (error);
 }
 
-#define	HEXTOASC(x)	"0123456789abcdef"[x]
+static char hextoasc[] = "0123456789abcdef";
 
 /*
  * Silly rename. To make the NFS filesystem that is stateless look a little
@@ -1042,7 +1174,7 @@ nfs_statfs(mp, sbp)
  * nfs_rename() completes, but...
  */
 nfs_sillyrename(ndp, flag)
-	struct nameidata *ndp;
+	register struct nameidata *ndp;
 	int flag;
 {
 	register struct nfsnode *np;
@@ -1065,10 +1197,10 @@ nfs_sillyrename(ndp, flag)
 	pid = u.u_procp->p_pid;
 	bcopy(".nfsAxxxx4.4", tndp->ni_dent.d_name, 13);
 	tndp->ni_dent.d_namlen = 12;
-	tndp->ni_dent.d_name[8] = HEXTOASC(pid & 0xf);
-	tndp->ni_dent.d_name[7] = HEXTOASC((pid >> 4) & 0xf);
-	tndp->ni_dent.d_name[6] = HEXTOASC((pid >> 8) & 0xf);
-	tndp->ni_dent.d_name[5] = HEXTOASC((pid >> 12) & 0xf);
+	tndp->ni_dent.d_name[8] = hextoasc[pid & 0xf];
+	tndp->ni_dent.d_name[7] = hextoasc[(pid >> 4) & 0xf];
+	tndp->ni_dent.d_name[6] = hextoasc[(pid >> 8) & 0xf];
+	tndp->ni_dent.d_name[5] = hextoasc[(pid >> 12) & 0xf];
 
 	/* Try lookitups until we get one that isn't there */
 	while (nfs_lookitup(ndp->ni_dvp, tndp, (nfsv2fh_t *)0) == 0) {
@@ -1100,7 +1232,13 @@ nfs_lookitup(vp, ndp, fhp)
 	register struct nameidata *ndp;
 	nfsv2fh_t *fhp;
 {
-	nfsm_vars;
+	register u_long *p;
+	register caddr_t cp;
+	register long t1, t2;
+	caddr_t bpos, dpos, cp2;
+	u_long xid;
+	int error = 0;
+	struct mbuf *mreq, *mrep, *md, *mb, *mb2;
 	long len;
 
 	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
@@ -1110,7 +1248,7 @@ nfs_lookitup(vp, ndp, fhp)
 	nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], ndp->ni_cred, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len));
 	nfsm_fhtom(vp);
 	nfsm_strtom(ndp->ni_dent.d_name, len, NFS_MAXNAMLEN);
-	nfsm_request(vp);
+	nfsm_request(vp, nonidempotent[NFSPROC_LOOKUP]);
 	if (fhp != NULL) {
 		nfsm_disect(cp, caddr_t, NFSX_FH);
 		bcopy(cp, (caddr_t)fhp, NFSX_FH);
@@ -1214,12 +1352,9 @@ nfs_doio(bp)
 	int npf, npf2;
 	int reg;
 	caddr_t vbase;
-	caddr_t addr;
 	unsigned v;
 	struct proc *rp;
 	int o, error;
-	int bcnt;
-	off_t off;
 	struct uio uio;
 	struct iovec io;
 
@@ -1228,17 +1363,7 @@ nfs_doio(bp)
 	uiop->uio_iov = &io;
 	uiop->uio_iovcnt = 1;
 	uiop->uio_segflg = UIO_SYSSPACE;
-	if (bp->b_flags & B_READ) {
-		io.iov_len = uiop->uio_resid = bp->b_bcount;
-		uiop->uio_offset = off = bp->b_blkno*DEV_BSIZE;
-		addr = bp->b_un.b_addr;
-		bcnt = bp->b_bcount;
-	} else {
-		io.iov_len = uiop->uio_resid = bp->b_dirtyend-bp->b_dirtyoff;
-		uiop->uio_offset = off = (bp->b_blkno*DEV_BSIZE)+bp->b_dirtyoff;
-		addr = bp->b_un.b_addr+bp->b_dirtyoff;
-		bcnt = bp->b_dirtyend-bp->b_dirtyoff;
-	}
+
 	/*
 	 * For phys i/o, map the b_addr into kernel virtual space using
 	 * the Nfsiomap pte's
@@ -1252,8 +1377,9 @@ nfs_doio(bp)
 		cr->cr_uid = rp->p_uid;
 		cr->cr_gid = 0;		/* Anything ?? */
 		cr->cr_ngroups = 1;
-		o = (int)addr & PGOFSET;
-		npf2 = npf = btoc(bcnt + o);
+		o = (int)bp->b_un.b_addr & PGOFSET;
+		npf2 = npf = btoc(bp->b_bcount + o);
+
 		/*
 		 * Get some mapping page table entries
 		 */
@@ -1262,10 +1388,7 @@ nfs_doio(bp)
 			sleep((caddr_t)&nfsmap_want, PZERO-1);
 		}
 		reg--;
-		/* I know it is always the else, but that may change someday */
-		if ((bp->b_flags & B_PHYS) == 0)
-			pte = kvtopte(bp->b_un.b_addr);
-		else if (bp->b_flags & B_PAGET)
+		if (bp->b_flags & B_PAGET)
 			pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)];
 		else {
 			v = btop(bp->b_un.b_addr);
@@ -1274,6 +1397,7 @@ nfs_doio(bp)
 			else
 				pte = vtopte(rp, v);
 		}
+
 		/*
 		 * Play vmaccess() but with the Nfsiomap page table
 		 */
@@ -1289,37 +1413,60 @@ nfs_doio(bp)
 			vaddr += NBPG;
 			--npf;
 		}
+
+		/*
+		 * And do the i/o rpc
+		 */
 		io.iov_base = vbase+o;
-	} else {
-		io.iov_base = addr;
-	}
-	if (bp->b_flags & B_READ) {
-		uiop->uio_rw = UIO_READ;
-		bp->b_error = error = nfs_readrpc(vp, uiop, &off, bp->b_rcred);
-	} else {
-		uiop->uio_rw = UIO_WRITE;
-		bp->b_error = error = nfs_writerpc(vp, uiop, &off, bp->b_wcred);
-		if (error) {
-			np = VTONFS(vp);
-			np->n_error = error;
-			np->n_flag |= NWRITEERR;
+		io.iov_len = uiop->uio_resid = bp->b_bcount;
+		uiop->uio_offset = bp->b_blkno * DEV_BSIZE;
+		if (bp->b_flags & B_READ) {
+			uiop->uio_rw = UIO_READ;
+			nfsstats.read_physios++;
+			bp->b_error = error = nfs_readrpc(vp, uiop, bp->b_rcred);
+		} else {
+			uiop->uio_rw = UIO_WRITE;
+			nfsstats.write_physios++;
+			bp->b_error = error = nfs_writerpc(vp, uiop, bp->b_wcred);
 		}
-		bp->b_dirtyoff = bp->b_dirtyend = 0;
-	}
-	if (error)
-		bp->b_flags |= B_ERROR;
-	bp->b_resid = uiop->uio_resid;
-	/*
-	 * Release pte's used by physical i/o
-	 */
-	if (bp->b_flags & B_PHYS) {
+
+		/*
+		 * Finally, release pte's used by physical i/o
+		 */
 		crfree(cr);
 		rmfree(nfsmap, (long)npf2, (long)++reg);
 		if (nfsmap_want) {
 			nfsmap_want = 0;
 			wakeup((caddr_t)&nfsmap_want);
 		}
+	} else {
+		if (bp->b_flags & B_READ) {
+			io.iov_len = uiop->uio_resid = bp->b_bcount;
+			uiop->uio_offset = bp->b_blkno * DEV_BSIZE;
+			io.iov_base = bp->b_un.b_addr;
+			uiop->uio_rw = UIO_READ;
+			nfsstats.read_bios++;
+			bp->b_error = error = nfs_readrpc(vp, uiop, bp->b_rcred);
+		} else {
+			io.iov_len = uiop->uio_resid = bp->b_dirtyend
+				- bp->b_dirtyoff;
+			uiop->uio_offset = (bp->b_blkno * DEV_BSIZE)
+				+ bp->b_dirtyoff;
+			io.iov_base = bp->b_un.b_addr + bp->b_dirtyoff;
+			uiop->uio_rw = UIO_WRITE;
+			nfsstats.write_bios++;
+			bp->b_error = error = nfs_writerpc(vp, uiop, bp->b_wcred);
+			if (error) {
+				np = VTONFS(vp);
+				np->n_error = error;
+				np->n_flag |= NWRITEERR;
+			}
+			bp->b_dirtyoff = bp->b_dirtyend = 0;
+		}
 	}
+	if (error)
+		bp->b_flags |= B_ERROR;
+	bp->b_resid = uiop->uio_resid;
 	biodone(bp);
 	return (error);
 }
@@ -1329,19 +1476,40 @@ nfs_doio(bp)
  * 	Walk through the buffer pool and push any dirty pages
  *	associated with the vnode.
  */
-nfs_fsync(vp, fflags, cred)
+/* ARGSUSED */
+nfs_fsync(vp, fflags, cred, waitfor)
 	register struct vnode *vp;
 	int fflags;
 	struct ucred *cred;
+	int waitfor;
 {
 	register struct nfsnode *np = VTONFS(vp);
-	int error;
+	int error = 0;
 
-	nfs_lock(vp);
 	if (np->n_flag & NMODIFIED) {
 		np->n_flag &= ~NMODIFIED;
-		error = nfs_blkflush(vp, (daddr_t)0, np->n_size, FALSE);
+		vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0);
 	}
-	nfs_unlock(vp);
+	if (!error && (np->n_flag & NWRITEERR))
+		error = np->n_error;
 	return (error);
 }
+
+/*
+ * Print out the contents of an nfsnode.
+ */
+nfs_print(vp)
+	struct vnode *vp;
+{
+	register struct nfsnode *np = VTONFS(vp);
+
+	printf("tag VT_NFS, fileid %d fsid 0x%x%s\n",
+		np->n_vattr.va_fileid, np->n_vattr.va_fsid,
+		(np->n_flag & NLOCKED) ? " (LOCKED)" : "");
+	if (np->n_lockholder == 0)
+		return;
+	printf("\towner pid %d", np->n_lockholder);
+	if (np->n_lockwaiter)
+		printf(" waiting pid %d", np->n_lockwaiter);
+	printf("\n");
+}