From 406c9a0d31fabf51e9225be4f5c7d4121b821317 Mon Sep 17 00:00:00 2001
From: John Heidemann <heideman@ucbvax.Berkeley.EDU>
Date: Thu, 4 Jun 1992 16:51:35 -0800
Subject: [PATCH] registerized vnodeop ops after vnode interface conversion

SCCS-vsn: sys/miscfs/fifofs/fifo_vnops.c 7.15
SCCS-vsn: sys/miscfs/specfs/spec_vnops.c 7.45
SCCS-vsn: sys/ufs/ffs/ufs_inode.c 7.47
SCCS-vsn: sys/ufs/ufs/ufs_inode.c 7.47
SCCS-vsn: sys/ufs/ffs/ffs_alloc.c 7.37
SCCS-vsn: sys/ufs/ffs/ffs_balloc.c 7.21
SCCS-vsn: sys/ufs/ffs/ffs_inode.c 7.53
SCCS-vsn: sys/ufs/ffs/ffs_vnops.c 7.79
SCCS-vsn: sys/ufs/mfs/mfs_vnops.c 7.33
SCCS-vsn: sys/ufs/lfs/lfs_bio.c 7.11
SCCS-vsn: sys/ufs/lfs/lfs_vnops.c 7.83
SCCS-vsn: sys/ufs/lfs/lfs_inode.c 7.66
---
 usr/src/sys/miscfs/fifofs/fifo_vnops.c |  41 +++++-----
 usr/src/sys/miscfs/specfs/spec_vnops.c | 108 +++++++++++++------------
 usr/src/sys/ufs/ffs/ffs_alloc.c        |   9 ++-
 usr/src/sys/ufs/ffs/ffs_balloc.c       |  17 ++--
 usr/src/sys/ufs/ffs/ffs_inode.c        |  15 ++--
 usr/src/sys/ufs/ffs/ffs_vnops.c        |  17 ++--
 usr/src/sys/ufs/ffs/ufs_inode.c        |  19 ++---
 usr/src/sys/ufs/lfs/lfs_bio.c          |  17 ++--
 usr/src/sys/ufs/lfs/lfs_inode.c        |   9 ++-
 usr/src/sys/ufs/lfs/lfs_vnops.c        |  40 ++++-----
 usr/src/sys/ufs/mfs/mfs_vnops.c        |  36 +++++----
 usr/src/sys/ufs/ufs/ufs_inode.c        |  19 ++---
 12 files changed, 184 insertions(+), 163 deletions(-)

diff --git a/usr/src/sys/miscfs/fifofs/fifo_vnops.c b/usr/src/sys/miscfs/fifofs/fifo_vnops.c
index 6c5fb9cfa6..5325dcea22 100644
--- a/usr/src/sys/miscfs/fifofs/fifo_vnops.c
+++ b/usr/src/sys/miscfs/fifofs/fifo_vnops.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)fifo_vnops.c	7.14 (Berkeley) %G%
+ *	@(#)fifo_vnops.c	7.15 (Berkeley) %G%
  */
 
 #include "param.h"
@@ -104,6 +104,7 @@ fifo_open (ap)
 	USES_VOP_CLOSE;
 	USES_VOP_LOCK;
 	USES_VOP_UNLOCK;
+	register struct vnode *vp = ap->a_vp;
 	register struct fifoinfo *fip;
 	struct socket *rso, *wso;
 	int error;
@@ -111,19 +112,19 @@ fifo_open (ap)
 
 	if ((ap->a_mode & (FREAD|FWRITE)) == (FREAD|FWRITE))
 		return (EINVAL);
-	if ((fip = ap->a_vp->v_fifoinfo) == NULL) {
+	if ((fip = vp->v_fifoinfo) == NULL) {
 		MALLOC(fip, struct fifoinfo *, sizeof(*fip), M_VNODE, M_WAITOK);
-		ap->a_vp->v_fifoinfo = fip;
+		vp->v_fifoinfo = fip;
 		if (error = socreate(AF_UNIX, &rso, SOCK_STREAM, 0)) {
 			free(fip, M_VNODE);
-			ap->a_vp->v_fifoinfo = NULL;
+			vp->v_fifoinfo = NULL;
 			return (error);
 		}
 		fip->fi_readsock = rso;
 		if (error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0)) {
 			(void)soclose(rso);
 			free(fip, M_VNODE);
-			ap->a_vp->v_fifoinfo = NULL;
+			vp->v_fifoinfo = NULL;
 			return (error);
 		}
 		fip->fi_writesock = wso;
@@ -131,7 +132,7 @@ fifo_open (ap)
 			(void)soclose(wso);
 			(void)soclose(rso);
 			free(fip, M_VNODE);
-			ap->a_vp->v_fifoinfo = NULL;
+			vp->v_fifoinfo = NULL;
 			return (error);
 		}
 		fip->fi_readers = fip->fi_writers = 0;
@@ -149,10 +150,10 @@ fifo_open (ap)
 		if (ap->a_mode & O_NONBLOCK)
 			return (0);
 		while (fip->fi_writers == 0) {
-			VOP_UNLOCK(ap->a_vp);
+			VOP_UNLOCK(vp);
 			error = tsleep((caddr_t)&fip->fi_readers, PSOCK,
 				openstr, 0);
-			VOP_LOCK(ap->a_vp);
+			VOP_LOCK(vp);
 			if (error)
 				break;
 		}
@@ -167,17 +168,17 @@ fifo_open (ap)
 					wakeup((caddr_t)&fip->fi_readers);
 			}
 			while (fip->fi_readers == 0) {
-				VOP_UNLOCK(ap->a_vp);
+				VOP_UNLOCK(vp);
 				error = tsleep((caddr_t)&fip->fi_writers,
 					PSOCK, openstr, 0);
-				VOP_LOCK(ap->a_vp);
+				VOP_LOCK(vp);
 				if (error)
 					break;
 			}
 		}
 	}
 	if (error)
-		VOP_CLOSE(ap->a_vp, ap->a_mode, ap->a_cred, ap->a_p);
+		VOP_CLOSE(vp, ap->a_mode, ap->a_cred, ap->a_p);
 	return (error);
 }
 
@@ -190,26 +191,27 @@ fifo_read (ap)
 {
 	USES_VOP_LOCK;
 	USES_VOP_UNLOCK;
+	register struct uio *uio = ap->a_uio;
 	register struct socket *rso = ap->a_vp->v_fifoinfo->fi_readsock;
 	int error, startresid;
 
 #ifdef DIAGNOSTIC
-	if (ap->a_uio->uio_rw != UIO_READ)
+	if (uio->uio_rw != UIO_READ)
 		panic("fifo_read mode");
 #endif
-	if (ap->a_uio->uio_resid == 0)
+	if (uio->uio_resid == 0)
 		return (0);
 	if (ap->a_ioflag & IO_NDELAY)
 		rso->so_state |= SS_NBIO;
-	startresid = ap->a_uio->uio_resid;
+	startresid = uio->uio_resid;
 	VOP_UNLOCK(ap->a_vp);
-	error = soreceive(rso, (struct mbuf **)0, ap->a_uio, (int *)0,
+	error = soreceive(rso, (struct mbuf **)0, uio, (int *)0,
 		(struct mbuf **)0, (struct mbuf **)0);
 	VOP_LOCK(ap->a_vp);
 	/*
 	 * Clear EOF indication after first such return.
 	 */
-	if (ap->a_uio->uio_resid == startresid)
+	if (uio->uio_resid == startresid)
 		rso->so_state &= ~SS_CANTRCVMORE;
 	if (ap->a_ioflag & IO_NDELAY)
 		rso->so_state &= ~SS_NBIO;
@@ -315,7 +317,8 @@ fifo_unlock (ap)
 fifo_close (ap)
 	struct vop_close_args *ap;
 {
-	register struct fifoinfo *fip = ap->a_vp->v_fifoinfo;
+	register struct vnode *vp = ap->a_vp;
+	register struct fifoinfo *fip = vp->v_fifoinfo;
 	int error1, error2;
 
 	if (ap->a_fflag & FWRITE) {
@@ -327,12 +330,12 @@ fifo_close (ap)
 		if (fip->fi_readers == 0)
 			socantsendmore(fip->fi_writesock);
 	}
-	if (ap->a_vp->v_usecount > 1)
+	if (vp->v_usecount > 1)
 		return (0);
 	error1 = soclose(fip->fi_readsock);
 	error2 = soclose(fip->fi_writesock);
 	FREE(fip, M_VNODE);
-	ap->a_vp->v_fifoinfo = NULL;
+	vp->v_fifoinfo = NULL;
 	if (error1)
 		return (error1);
 	return (error2);
diff --git a/usr/src/sys/miscfs/specfs/spec_vnops.c b/usr/src/sys/miscfs/specfs/spec_vnops.c
index 172f96e281..f23107dfbc 100644
--- a/usr/src/sys/miscfs/specfs/spec_vnops.c
+++ b/usr/src/sys/miscfs/specfs/spec_vnops.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)spec_vnops.c	7.44 (Berkeley) %G%
+ *	@(#)spec_vnops.c	7.45 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -103,27 +103,28 @@ spec_open (ap)
 {
 	USES_VOP_LOCK;
 	USES_VOP_UNLOCK;
-	dev_t dev = (dev_t)ap->a_vp->v_rdev;
+	register struct vnode *vp = ap->a_vp;
+	dev_t dev = (dev_t)vp->v_rdev;
 	register int maj = major(dev);
 	int error;
 
-	if (ap->a_vp->v_mount && (ap->a_vp->v_mount->mnt_flag & MNT_NODEV))
+	if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV))
 		return (ENXIO);
 
-	switch (ap->a_vp->v_type) {
+	switch (vp->v_type) {
 
 	case VCHR:
 		if ((u_int)maj >= nchrdev)
 			return (ENXIO);
-		VOP_UNLOCK(ap->a_vp);
+		VOP_UNLOCK(vp);
 		error = (*cdevsw[maj].d_open)(dev, ap->a_mode, S_IFCHR, ap->a_p);
-		VOP_LOCK(ap->a_vp);
+		VOP_LOCK(vp);
 		return (error);
 
 	case VBLK:
 		if ((u_int)maj >= nblkdev)
 			return (ENXIO);
-		if (error = ufs_mountedon(ap->a_vp))
+		if (error = ufs_mountedon(vp))
 			return (error);
 		return ((*bdevsw[maj].d_open)(dev, ap->a_mode, S_IFBLK, ap->a_p));
 	}
@@ -139,7 +140,9 @@ spec_read (ap)
 {
 	USES_VOP_LOCK;
 	USES_VOP_UNLOCK;
-	struct proc *p = ap->a_uio->uio_procp;
+	register struct vnode *vp = ap->a_vp;
+	register struct uio *uio = ap->a_uio;
+ 	struct proc *p = uio->uio_procp;
 	struct buf *bp;
 	daddr_t bn, nextbn;
 	long bsize, bscale;
@@ -148,28 +151,28 @@ spec_read (ap)
 	int error = 0;
 
 #ifdef DIAGNOSTIC
-	if (ap->a_uio->uio_rw != UIO_READ)
+	if (uio->uio_rw != UIO_READ)
 		panic("spec_read mode");
-	if (ap->a_uio->uio_segflg == UIO_USERSPACE && ap->a_uio->uio_procp != curproc)
+	if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
 		panic("spec_read proc");
 #endif
-	if (ap->a_uio->uio_resid == 0)
+	if (uio->uio_resid == 0)
 		return (0);
 
-	switch (ap->a_vp->v_type) {
+	switch (vp->v_type) {
 
 	case VCHR:
-		VOP_UNLOCK(ap->a_vp);
-		error = (*cdevsw[major(ap->a_vp->v_rdev)].d_read)
-			(ap->a_vp->v_rdev, ap->a_uio, ap->a_ioflag);
-		VOP_LOCK(ap->a_vp);
+		VOP_UNLOCK(vp);
+		error = (*cdevsw[major(vp->v_rdev)].d_read)
+			(vp->v_rdev, uio, ap->a_ioflag);
+		VOP_LOCK(vp);
 		return (error);
 
 	case VBLK:
-		if (ap->a_uio->uio_offset < 0)
+		if (uio->uio_offset < 0)
 			return (EINVAL);
 		bsize = BLKDEV_IOSIZE;
-		if ((*bdevsw[major(ap->a_vp->v_rdev)].d_ioctl)(ap->a_vp->v_rdev, DIOCGPART,
+		if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART,
 		    (caddr_t)&dpart, FREAD, p) == 0) {
 			if (dpart.part->p_fstype == FS_BSDFFS &&
 			    dpart.part->p_frag != 0 && dpart.part->p_fsize != 0)
@@ -178,26 +181,26 @@ spec_read (ap)
 		}
 		bscale = bsize / DEV_BSIZE;
 		do {
-			bn = (ap->a_uio->uio_offset / DEV_BSIZE) &~ (bscale - 1);
-			on = ap->a_uio->uio_offset % bsize;
-			n = MIN((unsigned)(bsize - on), ap->a_uio->uio_resid);
-			if (ap->a_vp->v_lastr + bscale == bn) {
+			bn = (uio->uio_offset / DEV_BSIZE) &~ (bscale - 1);
+			on = uio->uio_offset % bsize;
+			n = MIN((unsigned)(bsize - on), uio->uio_resid);
+			if (vp->v_lastr + bscale == bn) {
 				nextbn = bn + bscale;
-				error = breadn(ap->a_vp, bn, (int)bsize, &nextbn,
+				error = breadn(vp, bn, (int)bsize, &nextbn,
 					(int *)&bsize, 1, NOCRED, &bp);
 			} else
-				error = bread(ap->a_vp, bn, (int)bsize, NOCRED, &bp);
-			ap->a_vp->v_lastr = bn;
+				error = bread(vp, bn, (int)bsize, NOCRED, &bp);
+			vp->v_lastr = bn;
 			n = MIN(n, bsize - bp->b_resid);
 			if (error) {
 				brelse(bp);
 				return (error);
 			}
-			error = uiomove(bp->b_un.b_addr + on, n, ap->a_uio);
+			error = uiomove(bp->b_un.b_addr + on, n, uio);
 			if (n + on == bsize)
 				bp->b_flags |= B_AGE;
 			brelse(bp);
-		} while (error == 0 && ap->a_uio->uio_resid > 0 && n != 0);
+		} while (error == 0 && uio->uio_resid > 0 && n != 0);
 		return (error);
 
 	default:
@@ -215,7 +218,9 @@ spec_write (ap)
 {
 	USES_VOP_LOCK;
 	USES_VOP_UNLOCK;
-	struct proc *p = ap->a_uio->uio_procp;
+	register struct vnode *vp = ap->a_vp;
+	register struct uio *uio = ap->a_uio;
+	struct proc *p = uio->uio_procp;
 	struct buf *bp;
 	daddr_t bn;
 	int bsize, blkmask;
@@ -224,28 +229,28 @@ spec_write (ap)
 	int error = 0;
 
 #ifdef DIAGNOSTIC
-	if (ap->a_uio->uio_rw != UIO_WRITE)
+	if (uio->uio_rw != UIO_WRITE)
 		panic("spec_write mode");
-	if (ap->a_uio->uio_segflg == UIO_USERSPACE && ap->a_uio->uio_procp != curproc)
+	if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
 		panic("spec_write proc");
 #endif
 
-	switch (ap->a_vp->v_type) {
+	switch (vp->v_type) {
 
 	case VCHR:
-		VOP_UNLOCK(ap->a_vp);
-		error = (*cdevsw[major(ap->a_vp->v_rdev)].d_write)
-			(ap->a_vp->v_rdev, ap->a_uio, ap->a_ioflag);
-		VOP_LOCK(ap->a_vp);
+		VOP_UNLOCK(vp);
+		error = (*cdevsw[major(vp->v_rdev)].d_write)
+			(vp->v_rdev, uio, ap->a_ioflag);
+		VOP_LOCK(vp);
 		return (error);
 
 	case VBLK:
-		if (ap->a_uio->uio_resid == 0)
+		if (uio->uio_resid == 0)
 			return (0);
-		if (ap->a_uio->uio_offset < 0)
+		if (uio->uio_offset < 0)
 			return (EINVAL);
 		bsize = BLKDEV_IOSIZE;
-		if ((*bdevsw[major(ap->a_vp->v_rdev)].d_ioctl)(ap->a_vp->v_rdev, DIOCGPART,
+		if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART,
 		    (caddr_t)&dpart, FREAD, p) == 0) {
 			if (dpart.part->p_fstype == FS_BSDFFS &&
 			    dpart.part->p_frag != 0 && dpart.part->p_fsize != 0)
@@ -254,25 +259,25 @@ spec_write (ap)
 		}
 		blkmask = (bsize / DEV_BSIZE) - 1;
 		do {
-			bn = (ap->a_uio->uio_offset / DEV_BSIZE) &~ blkmask;
-			on = ap->a_uio->uio_offset % bsize;
-			n = MIN((unsigned)(bsize - on), ap->a_uio->uio_resid);
+			bn = (uio->uio_offset / DEV_BSIZE) &~ blkmask;
+			on = uio->uio_offset % bsize;
+			n = MIN((unsigned)(bsize - on), uio->uio_resid);
 			if (n == bsize)
-				bp = getblk(ap->a_vp, bn, bsize);
+				bp = getblk(vp, bn, bsize);
 			else
-				error = bread(ap->a_vp, bn, bsize, NOCRED, &bp);
+				error = bread(vp, bn, bsize, NOCRED, &bp);
 			n = MIN(n, bsize - bp->b_resid);
 			if (error) {
 				brelse(bp);
 				return (error);
 			}
-			error = uiomove(bp->b_un.b_addr + on, n, ap->a_uio);
+			error = uiomove(bp->b_un.b_addr + on, n, uio);
 			if (n + on == bsize) {
 				bp->b_flags |= B_AGE;
 				bawrite(bp);
 			} else
 				bdwrite(bp);
-		} while (error == 0 && ap->a_uio->uio_resid > 0 && n != 0);
+		} while (error == 0 && uio->uio_resid > 0 && n != 0);
 		return (error);
 
 	default:
@@ -379,11 +384,12 @@ spec_unlock (ap)
 spec_close (ap)
 	struct vop_close_args *ap;
 {
-	dev_t dev = ap->a_vp->v_rdev;
+	register struct vnode *vp = ap->a_vp;
+	dev_t dev = vp->v_rdev;
 	int (*devclose) __P((dev_t, int, int, struct proc *));
 	int mode;
 
-	switch (ap->a_vp->v_type) {
+	switch (vp->v_type) {
 
 	case VCHR:
 		/*
@@ -391,7 +397,7 @@ spec_close (ap)
 		 * of forcably closing the device, otherwise we only
 		 * close on last reference.
 		 */
-		if (vcount(ap->a_vp) > 1 && (ap->a_vp->v_flag & VXLOCK) == 0)
+		if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0)
 			return (0);
 		devclose = cdevsw[major(dev)].d_close;
 		mode = S_IFCHR;
@@ -403,8 +409,8 @@ spec_close (ap)
 		 * we must invalidate any in core blocks, so that
 		 * we can, for instance, change floppy disks.
 		 */
-		vflushbuf(ap->a_vp, 0);
-		if (vinvalbuf(ap->a_vp, 1))
+		vflushbuf(vp, 0);
+		if (vinvalbuf(vp, 1))
 			return (0);
 		/*
 		 * We do not want to really close the device if it
@@ -415,7 +421,7 @@ spec_close (ap)
 		 * sum of the reference counts on all the aliased
 		 * vnodes descends to one, we are on last close.
 		 */
-		if (vcount(ap->a_vp) > 1 && (ap->a_vp->v_flag & VXLOCK) == 0)
+		if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0)
 			return (0);
 		devclose = bdevsw[major(dev)].d_close;
 		mode = S_IFBLK;
diff --git a/usr/src/sys/ufs/ffs/ffs_alloc.c b/usr/src/sys/ufs/ffs/ffs_alloc.c
index b04d639dc3..e0037ba988 100644
--- a/usr/src/sys/ufs/ffs/ffs_alloc.c
+++ b/usr/src/sys/ufs/ffs/ffs_alloc.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)ffs_alloc.c	7.36 (Berkeley) %G%
+ *	@(#)ffs_alloc.c	7.37 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -290,6 +290,7 @@ ffs_valloc (ap)
 {
 	USES_VOP_VFREE;
 	USES_VOP_VGET;
+	register struct vnode *pvp = ap->a_pvp;
 	register struct inode *pip;
 	register struct fs *fs;
 	register struct inode *ip;
@@ -297,7 +298,7 @@ ffs_valloc (ap)
 	int cg, error;
 	
 	*ap->a_vpp = NULL;
-	pip = VTOI(ap->a_pvp);
+	pip = VTOI(pvp);
 	fs = pip->i_fs;
 	if (fs->fs_cstotal.cs_nifree == 0)
 		goto noinodes;
@@ -312,9 +313,9 @@ ffs_valloc (ap)
 	ino = (ino_t)ffs_hashalloc(pip, cg, (long)ipref, ap->a_mode, ffs_ialloccg);
 	if (ino == 0)
 		goto noinodes;
-	error = FFS_VGET(ap->a_pvp->v_mount, ino, ap->a_vpp);
+	error = FFS_VGET(pvp->v_mount, ino, ap->a_vpp);
 	if (error) {
-		VOP_VFREE(ap->a_pvp, ino, ap->a_mode);
+		VOP_VFREE(pvp, ino, ap->a_mode);
 		return (error);
 	}
 	ip = VTOI(*ap->a_vpp);
diff --git a/usr/src/sys/ufs/ffs/ffs_balloc.c b/usr/src/sys/ufs/ffs/ffs_balloc.c
index 7b65df7671..aba8f81112 100644
--- a/usr/src/sys/ufs/ffs/ffs_balloc.c
+++ b/usr/src/sys/ufs/ffs/ffs_balloc.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)ffs_balloc.c	7.20 (Berkeley) %G%
+ *	@(#)ffs_balloc.c	7.21 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -32,6 +32,7 @@ int
 ffs_bmap (ap)
 	struct vop_bmap_args *ap;
 {
+	register daddr_t bn = ap->a_bn;
 	register struct inode *ip;
 	register struct fs *fs;
 	register daddr_t nb;
@@ -49,15 +50,15 @@ ffs_bmap (ap)
 		*ap->a_vpp = ip->i_devvp;
 	if (ap->a_bnp == NULL)
 		return (0);
-	if (ap->a_bn < 0)
+	if (bn < 0)
 		return (EFBIG);
 	fs = ip->i_fs;
 
 	/*
 	 * The first NDADDR blocks are direct blocks
 	 */
-	if (ap->a_bn < NDADDR) {
-		nb = ip->i_db[ap->a_bn];
+	if (bn < NDADDR) {
+		nb = ip->i_db[bn];
 		if (nb == 0) {
 			*ap->a_bnp = (daddr_t)-1;
 			return (0);
@@ -69,12 +70,12 @@ ffs_bmap (ap)
 	 * Determine the number of levels of indirection.
 	 */
 	sh = 1;
-	ap->a_bn -= NDADDR;
+	bn -= NDADDR;
 	for (j = NIADDR; j > 0; j--) {
 		sh *= NINDIR(fs);
-		if (ap->a_bn < sh)
+		if (bn < sh)
 			break;
-		ap->a_bn -= sh;
+		bn -= sh;
 	}
 	if (j == 0)
 		return (EFBIG);
@@ -94,7 +95,7 @@ ffs_bmap (ap)
 		}
 		bap = bp->b_un.b_daddr;
 		sh /= NINDIR(fs);
-		i = (ap->a_bn / sh) % NINDIR(fs);
+		i = (bn / sh) % NINDIR(fs);
 		nb = bap[i];
 		if (nb == 0) {
 			*ap->a_bnp = (daddr_t)-1;
diff --git a/usr/src/sys/ufs/ffs/ffs_inode.c b/usr/src/sys/ufs/ffs/ffs_inode.c
index 970b2c9ec1..cd58f49ca1 100644
--- a/usr/src/sys/ufs/ffs/ffs_inode.c
+++ b/usr/src/sys/ufs/ffs/ffs_inode.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)ffs_inode.c	7.52 (Berkeley) %G%
+ *	@(#)ffs_inode.c	7.53 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -218,6 +218,7 @@ ffs_truncate (ap)
 	struct vop_truncate_args *ap;
 {
 	USES_VOP_UPDATE;
+	register struct vnode *ovp = ap->a_vp;
 	register daddr_t lastblock;
 	register struct inode *oip;
 	daddr_t bn, lbn, lastiblock[NIADDR];
@@ -231,11 +232,11 @@ ffs_truncate (ap)
 	struct inode tip;
 	off_t osize;
 
-	vnode_pager_setsize(ap->a_vp, (u_long)ap->a_length);
-	oip = VTOI(ap->a_vp);
+	vnode_pager_setsize(ovp, (u_long)ap->a_length);
+	oip = VTOI(ovp);
 	if (oip->i_size <= ap->a_length) {
 		oip->i_flag |= ICHG|IUPD;
-		error = VOP_UPDATE(ap->a_vp, &time, &time, 1);
+		error = VOP_UPDATE(ovp, &time, &time, 1);
 		return (error);
 	}
 	/*
@@ -274,7 +275,7 @@ ffs_truncate (ap)
 			return (error);
 		oip->i_size = ap->a_length;
 		size = blksize(fs, oip, lbn);
-		(void) vnode_pager_uncache(ap->a_vp);
+		(void) vnode_pager_uncache(ovp);
 		bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
 		allocbuf(bp, size);
 		if (ap->a_flags & IO_SYNC)
@@ -298,8 +299,8 @@ ffs_truncate (ap)
 	for (i = NDADDR - 1; i > lastblock; i--)
 		oip->i_db[i] = 0;
 	oip->i_flag |= ICHG|IUPD;
-	vinvalbuf(ap->a_vp, (ap->a_length > 0));
-	allerror = VOP_UPDATE(ap->a_vp, &time, &time, MNT_WAIT);
+	vinvalbuf(ovp, (ap->a_length > 0));
+	allerror = VOP_UPDATE(ovp, &time, &time, MNT_WAIT);
 
 	/*
 	 * Indirect blocks first.
diff --git a/usr/src/sys/ufs/ffs/ffs_vnops.c b/usr/src/sys/ufs/ffs/ffs_vnops.c
index 38f58d62d3..0324b1a57d 100644
--- a/usr/src/sys/ufs/ffs/ffs_vnops.c
+++ b/usr/src/sys/ufs/ffs/ffs_vnops.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)ffs_vnops.c	7.78 (Berkeley) %G%
+ *	@(#)ffs_vnops.c	7.79 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -250,8 +250,9 @@ ffs_write (ap)
 {
 	USES_VOP_TRUNCATE;
 	USES_VOP_UPDATE;
+	register struct vnode *vp = ap->a_vp;
 	struct proc *p = ap->a_uio->uio_procp;
-	register struct inode *ip = VTOI(ap->a_vp);
+	register struct inode *ip = VTOI(vp);
 	register struct fs *fs;
 	struct buf *bp;
 	daddr_t lbn, bn;
@@ -263,7 +264,7 @@ ffs_write (ap)
 	if (ap->a_uio->uio_rw != UIO_WRITE)
 		panic("ffs_write mode");
 #endif
-	switch (ap->a_vp->v_type) {
+	switch (vp->v_type) {
 	case VREG:
 		if (ap->a_ioflag & IO_APPEND)
 			ap->a_uio->uio_offset = ip->i_size;
@@ -287,7 +288,7 @@ ffs_write (ap)
 	 * 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 (ap->a_vp->v_type == VREG && p &&
+	if (vp->v_type == VREG && p &&
 	    ap->a_uio->uio_offset + ap->a_uio->uio_resid >
 	      p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
 		psignal(p, SIGXFSZ);
@@ -312,10 +313,10 @@ ffs_write (ap)
 		bn = bp->b_blkno;
 		if (ap->a_uio->uio_offset + n > ip->i_size) {
 			ip->i_size = ap->a_uio->uio_offset + n;
-			vnode_pager_setsize(ap->a_vp, (u_long)ip->i_size);
+			vnode_pager_setsize(vp, (u_long)ip->i_size);
 		}
 		size = blksize(fs, ip, lbn);
-		(void) vnode_pager_uncache(ap->a_vp);
+		(void) vnode_pager_uncache(vp);
 		n = MIN(n, size - bp->b_resid);
 		error = uiomove(bp->b_un.b_addr + on, n, ap->a_uio);
 		if (ap->a_ioflag & IO_SYNC)
@@ -330,12 +331,12 @@ ffs_write (ap)
 			ip->i_mode &= ~(ISUID|ISGID);
 	} while (error == 0 && ap->a_uio->uio_resid > 0 && n != 0);
 	if (error && (ap->a_ioflag & IO_UNIT)) {
-		(void)VOP_TRUNCATE(ap->a_vp, osize, ap->a_ioflag & IO_SYNC, ap->a_cred);
+		(void)VOP_TRUNCATE(vp, osize, ap->a_ioflag & IO_SYNC, ap->a_cred);
 		ap->a_uio->uio_offset -= resid - ap->a_uio->uio_resid;
 		ap->a_uio->uio_resid = resid;
 	}
 	if (!error && (ap->a_ioflag & IO_SYNC))
-		error = VOP_UPDATE(ap->a_vp, &time, &time, 1);
+		error = VOP_UPDATE(vp, &time, &time, 1);
 	return (error);
 }
 
diff --git a/usr/src/sys/ufs/ffs/ufs_inode.c b/usr/src/sys/ufs/ffs/ufs_inode.c
index 06fa13a820..8d57aae6e1 100644
--- a/usr/src/sys/ufs/ffs/ufs_inode.c
+++ b/usr/src/sys/ufs/ffs/ufs_inode.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)ufs_inode.c	7.46 (Berkeley) %G%
+ *	@(#)ufs_inode.c	7.47 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -62,20 +62,21 @@ int
 ufs_reclaim (ap)
 	struct vop_reclaim_args *ap;
 {
+	register struct vnode *vp = ap->a_vp;
 	register struct inode *ip;
 	int i, type;
 
-	if (prtactive && ap->a_vp->v_usecount != 0)
-		vprint("ufs_reclaim: pushing active", ap->a_vp);
+	if (prtactive && vp->v_usecount != 0)
+		vprint("ufs_reclaim: pushing active", vp);
 	/*
 	 * Remove the inode from its hash chain.
 	 */
-	ip = VTOI(ap->a_vp);
+	ip = VTOI(vp);
 	remque(ip);
 	/*
 	 * Purge old data structures associated with the inode.
 	 */
-	cache_purge(ap->a_vp);
+	cache_purge(vp);
 	if (ip->i_devvp) {
 		vrele(ip->i_devvp);
 		ip->i_devvp = 0;
@@ -83,12 +84,12 @@ ufs_reclaim (ap)
 #ifdef QUOTA
 	for (i = 0; i < MAXQUOTAS; i++) {
 		if (ip->i_dquot[i] != NODQUOT) {
-			dqrele(ap->a_vp, ip->i_dquot[i]);
+			dqrele(vp, ip->i_dquot[i]);
 			ip->i_dquot[i] = NODQUOT;
 		}
 	}
 #endif
-	switch (ap->a_vp->v_mount->mnt_stat.f_type) {
+	switch (vp->v_mount->mnt_stat.f_type) {
 	case MOUNT_UFS:
 		type = M_FFSNODE;
 		break;
@@ -101,8 +102,8 @@ ufs_reclaim (ap)
 	default:
 		panic("ufs_reclaim: not ufs file");
 	}
-	FREE(ap->a_vp->v_data, type);
-	ap->a_vp->v_data = NULL;
+	FREE(vp->v_data, type);
+	vp->v_data = NULL;
 	return (0);
 }
 
diff --git a/usr/src/sys/ufs/lfs/lfs_bio.c b/usr/src/sys/ufs/lfs/lfs_bio.c
index ca8c8c7f72..6a14a61797 100644
--- a/usr/src/sys/ufs/lfs/lfs_bio.c
+++ b/usr/src/sys/ufs/lfs/lfs_bio.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)lfs_bio.c	7.10 (Berkeley) %G%
+ *	@(#)lfs_bio.c	7.11 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -34,6 +34,7 @@ int
 lfs_bwrite (ap)
 	struct vop_bwrite_args *ap;
 {
+	register struct buf *bp = ap->a_bp;
 	int s;
 #ifdef VERBOSE
 printf("lfs_bwrite\n");
@@ -47,21 +48,21 @@ printf("lfs_bwrite\n");
 	 * getnewbuf() would try to reclaim the buffers using bawrite, which
 	 * isn't going to work.
 	 */
-	if (!(ap->a_bp->b_flags & B_LOCKED)) {
+	if (!(bp->b_flags & B_LOCKED)) {
 		++locked_queue_count;
-		ap->a_bp->b_flags |= B_DELWRI | B_LOCKED;
-		ap->a_bp->b_flags &= ~(B_READ | B_DONE | B_ERROR);
+		bp->b_flags |= B_DELWRI | B_LOCKED;
+		bp->b_flags &= ~(B_READ | B_DONE | B_ERROR);
 		s = splbio();
 #define	PMAP_BUG_FIX_HACK
 #ifdef PMAP_BUG_FIX_HACK
 		if (((struct ufsmount *)
-		    (ap->a_bp->b_vp->v_mount->mnt_data))->um_lfs->lfs_ivnode !=
-		    ap->a_bp->b_vp)
+		    (bp->b_vp->v_mount->mnt_data))->um_lfs->lfs_ivnode !=
+		    bp->b_vp)
 #endif
-		reassignbuf(ap->a_bp, ap->a_bp->b_vp);
+		reassignbuf(bp, bp->b_vp);
 		splx(s);
 	}
-	brelse(ap->a_bp);
+	brelse(bp);
 	return (0);
 }
 
diff --git a/usr/src/sys/ufs/lfs/lfs_inode.c b/usr/src/sys/ufs/lfs/lfs_inode.c
index 3d8d0aa428..2e68b0a81d 100644
--- a/usr/src/sys/ufs/lfs/lfs_inode.c
+++ b/usr/src/sys/ufs/lfs/lfs_inode.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)lfs_inode.c	7.65 (Berkeley) %G%
+ *	@(#)lfs_inode.c	7.66 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -163,14 +163,15 @@ int
 lfs_update (ap)
 	struct vop_update_args *ap;
 {
+	struct vnode *vp = ap->a_vp;
 	struct inode *ip;
 
 #ifdef VERBOSE
 	printf("lfs_update\n");
 #endif
-	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
+	if (vp->v_mount->mnt_flag & MNT_RDONLY)
 		return (0);
-	ip = VTOI(ap->a_vp);
+	ip = VTOI(vp);
 	if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
 		return (0);
 	if (ip->i_flag&IACC)
@@ -184,7 +185,7 @@ lfs_update (ap)
 	ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
 
 	/* Push back the vnode and any dirty blocks it may have. */
-	return (ap->a_waitfor ? lfs_vflush(ap->a_vp) : 0);
+	return (ap->a_waitfor ? lfs_vflush(vp) : 0);
 }
 
 /* Update segment usage information when removing a block. */
diff --git a/usr/src/sys/ufs/lfs/lfs_vnops.c b/usr/src/sys/ufs/lfs/lfs_vnops.c
index 94c6fa9635..e5045ef566 100644
--- a/usr/src/sys/ufs/lfs/lfs_vnops.c
+++ b/usr/src/sys/ufs/lfs/lfs_vnops.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)lfs_vnops.c	7.82 (Berkeley) %G%
+ *	@(#)lfs_vnops.c	7.83 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -187,6 +187,7 @@ struct vnodeopv_desc lfs_fifoop_opv_desc =
 lfs_read (ap)
 	struct vop_read_args *ap;
 {
+	register struct uio *uio = ap->a_uio;
 	register struct inode *ip = VTOI(ap->a_vp);
 	register struct lfs *fs;				/* LFS */
 	struct buf *bp;
@@ -199,24 +200,24 @@ lfs_read (ap)
 	printf("lfs_read: ino %d\n", ip->i_number);
 #endif
 #ifdef DIAGNOSTIC
-	if (ap->a_uio->uio_rw != UIO_READ)
+	if (uio->uio_rw != UIO_READ)
 		panic("ufs_read mode");
 	type = ip->i_mode & IFMT;
 	if (type != IFDIR && type != IFREG && type != IFLNK)
 		panic("ufs_read type");
 #endif
-	if (ap->a_uio->uio_resid == 0)
+	if (uio->uio_resid == 0)
 		return (0);
-	if (ap->a_uio->uio_offset < 0)
+	if (uio->uio_offset < 0)
 		return (EINVAL);
 	ip->i_flag |= IACC;
 
 	fs = ip->i_lfs;						/* LFS */
 	do {
-		lbn = lblkno(fs, ap->a_uio->uio_offset);
-		on = blkoff(fs, ap->a_uio->uio_offset);
-		n = MIN((unsigned)(fs->lfs_bsize - on), ap->a_uio->uio_resid);
-		diff = ip->i_size - ap->a_uio->uio_offset;
+		lbn = lblkno(fs, uio->uio_offset);
+		on = blkoff(fs, uio->uio_offset);
+		n = MIN((unsigned)(fs->lfs_bsize - on), uio->uio_resid);
+		diff = ip->i_size - uio->uio_offset;
 		if (diff <= 0)
 			return (0);
 		if (diff < n)
@@ -235,11 +236,11 @@ lfs_read (ap)
 			brelse(bp);
 			return (error);
 		}
-		error = uiomove(bp->b_un.b_addr + on, (int)n, ap->a_uio);
-		if (n + on == fs->lfs_bsize || ap->a_uio->uio_offset == ip->i_size)
+		error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
+		if (n + on == fs->lfs_bsize || uio->uio_offset == ip->i_size)
 			bp->b_flags |= B_AGE;
 		brelse(bp);
-	} while (error == 0 && ap->a_uio->uio_resid > 0 && n != 0);
+	} while (error == 0 && uio->uio_resid > 0 && n != 0);
 	return (error);
 }
 
@@ -251,8 +252,9 @@ lfs_write (ap)
 {
 	USES_VOP_TRUNCATE;
 	USES_VOP_UPDATE;
+	register struct vnode *vp = ap->a_vp;
 	struct proc *p = ap->a_uio->uio_procp;
-	register struct inode *ip = VTOI(ap->a_vp);
+	register struct inode *ip = VTOI(vp);
 	register struct lfs *fs;
 	struct buf *bp;
 	daddr_t lbn;
@@ -267,7 +269,7 @@ lfs_write (ap)
 	if (ap->a_uio->uio_rw != UIO_WRITE)
 		panic("lfs_write mode");
 #endif
-	switch (ap->a_vp->v_type) {
+	switch (vp->v_type) {
 	case VREG:
 		if (ap->a_ioflag & IO_APPEND)
 			ap->a_uio->uio_offset = ip->i_size;
@@ -292,7 +294,7 @@ lfs_write (ap)
 	 * 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 (ap->a_vp->v_type == VREG && p &&
+	if (vp->v_type == VREG && p &&
 	    ap->a_uio->uio_offset + ap->a_uio->uio_resid >
 	      p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
 		psignal(p, SIGXFSZ);
@@ -310,14 +312,14 @@ lfs_write (ap)
 		lbn = lblkno(fs, ap->a_uio->uio_offset);
 		on = blkoff(fs, ap->a_uio->uio_offset);
 		n = MIN((unsigned)(fs->lfs_bsize - on), ap->a_uio->uio_resid);
-		if (error = lfs_balloc(ap->a_vp, n, lbn, &bp))
+		if (error = lfs_balloc(vp, n, lbn, &bp))
 			break;
 		if (ap->a_uio->uio_offset + n > ip->i_size) {
 			ip->i_size = ap->a_uio->uio_offset + n;
-			vnode_pager_setsize(ap->a_vp, (u_long)ip->i_size);
+			vnode_pager_setsize(vp, (u_long)ip->i_size);
 		}
 		size = blksize(fs);
-		(void) vnode_pager_uncache(ap->a_vp);
+		(void) vnode_pager_uncache(vp);
 		n = MIN(n, size - bp->b_resid);
 		error = uiomove(bp->b_un.b_addr + on, n, ap->a_uio);
 #ifdef NOTLFS							/* LFS */
@@ -337,12 +339,12 @@ lfs_write (ap)
 			ip->i_mode &= ~(ISUID|ISGID);
 	} while (error == 0 && ap->a_uio->uio_resid > 0 && n != 0);
 	if (error && (ap->a_ioflag & IO_UNIT)) {
-		(void)VOP_TRUNCATE(ap->a_vp, osize, ap->a_ioflag & IO_SYNC, ap->a_cred);
+		(void)VOP_TRUNCATE(vp, osize, ap->a_ioflag & IO_SYNC, ap->a_cred);
 		ap->a_uio->uio_offset -= resid - ap->a_uio->uio_resid;
 		ap->a_uio->uio_resid = resid;
 	}
 	if (!error && (ap->a_ioflag & IO_SYNC))
-		error = VOP_UPDATE(ap->a_vp, &time, &time, 1);
+		error = VOP_UPDATE(vp, &time, &time, 1);
 	return (error);
 }
 
diff --git a/usr/src/sys/ufs/mfs/mfs_vnops.c b/usr/src/sys/ufs/mfs/mfs_vnops.c
index 04555a7998..815e5122a5 100644
--- a/usr/src/sys/ufs/mfs/mfs_vnops.c
+++ b/usr/src/sys/ufs/mfs/mfs_vnops.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)mfs_vnops.c	7.32 (Berkeley) %G%
+ *	@(#)mfs_vnops.c	7.33 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -122,28 +122,29 @@ int
 mfs_strategy (ap)
 	struct vop_strategy_args *ap;
 {
+	register struct buf *bp = ap->a_bp;
 	register struct mfsnode *mfsp;
 	struct vnode *vp;
 	struct proc *p = curproc;		/* XXX */
 
-	if (vfinddev(ap->a_bp->b_dev, VBLK, &vp) || vp->v_usecount == 0)
+	if (vfinddev(bp->b_dev, VBLK, &vp) || vp->v_usecount == 0)
 		panic("mfs_strategy: bad dev");
 	mfsp = VTOMFS(vp);
 	/* check for mini-root access */
 	if (mfsp->mfs_pid == 0) {
 		caddr_t base;
 
-		base = mfsp->mfs_baseoff + (ap->a_bp->b_blkno << DEV_BSHIFT);
-		if (ap->a_bp->b_flags & B_READ)
-			bcopy(base, ap->a_bp->b_un.b_addr, ap->a_bp->b_bcount);
+		base = mfsp->mfs_baseoff + (bp->b_blkno << DEV_BSHIFT);
+		if (bp->b_flags & B_READ)
+			bcopy(base, bp->b_un.b_addr, bp->b_bcount);
 		else
-			bcopy(ap->a_bp->b_un.b_addr, base, ap->a_bp->b_bcount);
-		biodone(ap->a_bp);
+			bcopy(bp->b_un.b_addr, base, bp->b_bcount);
+		biodone(bp);
 	} else if (mfsp->mfs_pid == p->p_pid) {
-		mfs_doio(ap->a_bp, mfsp->mfs_baseoff);
+		mfs_doio(bp, mfsp->mfs_baseoff);
 	} else {
-		ap->a_bp->av_forw = mfsp->mfs_buflist;
-		mfsp->mfs_buflist = ap->a_bp;
+		bp->av_forw = mfsp->mfs_buflist;
+		mfsp->mfs_buflist = bp;
 		wakeup((caddr_t)vp);
 	}
 	return (0);
@@ -273,7 +274,8 @@ int
 mfs_close (ap)
 	struct vop_close_args *ap;
 {
-	register struct mfsnode *mfsp = VTOMFS(ap->a_vp);
+	register struct vnode *vp = ap->a_vp;
+	register struct mfsnode *mfsp = VTOMFS(vp);
 	register struct buf *bp;
 
 	/*
@@ -289,22 +291,22 @@ mfs_close (ap)
 	 * we must invalidate any in core blocks, so that
 	 * we can, free up its vnode.
 	 */
-	vflushbuf(ap->a_vp, 0);
-	if (vinvalbuf(ap->a_vp, 1))
+	vflushbuf(vp, 0);
+	if (vinvalbuf(vp, 1))
 		return (0);
 	/*
 	 * There should be no way to have any more uses of this
 	 * vnode, so if we find any other uses, it is a panic.
 	 */
-	if (ap->a_vp->v_usecount > 1)
-		printf("mfs_close: ref count %d > 1\n", ap->a_vp->v_usecount);
-	if (ap->a_vp->v_usecount > 1 || mfsp->mfs_buflist)
+	if (vp->v_usecount > 1)
+		printf("mfs_close: ref count %d > 1\n", vp->v_usecount);
+	if (vp->v_usecount > 1 || mfsp->mfs_buflist)
 		panic("mfs_close");
 	/*
 	 * Send a request to the filesystem server to exit.
 	 */
 	mfsp->mfs_buflist = (struct buf *)(-1);
-	wakeup((caddr_t)ap->a_vp);
+	wakeup((caddr_t)vp);
 	return (0);
 }
 
diff --git a/usr/src/sys/ufs/ufs/ufs_inode.c b/usr/src/sys/ufs/ufs/ufs_inode.c
index 06fa13a820..8d57aae6e1 100644
--- a/usr/src/sys/ufs/ufs/ufs_inode.c
+++ b/usr/src/sys/ufs/ufs/ufs_inode.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
- *	@(#)ufs_inode.c	7.46 (Berkeley) %G%
+ *	@(#)ufs_inode.c	7.47 (Berkeley) %G%
  */
 
 #include <sys/param.h>
@@ -62,20 +62,21 @@ int
 ufs_reclaim (ap)
 	struct vop_reclaim_args *ap;
 {
+	register struct vnode *vp = ap->a_vp;
 	register struct inode *ip;
 	int i, type;
 
-	if (prtactive && ap->a_vp->v_usecount != 0)
-		vprint("ufs_reclaim: pushing active", ap->a_vp);
+	if (prtactive && vp->v_usecount != 0)
+		vprint("ufs_reclaim: pushing active", vp);
 	/*
 	 * Remove the inode from its hash chain.
 	 */
-	ip = VTOI(ap->a_vp);
+	ip = VTOI(vp);
 	remque(ip);
 	/*
 	 * Purge old data structures associated with the inode.
 	 */
-	cache_purge(ap->a_vp);
+	cache_purge(vp);
 	if (ip->i_devvp) {
 		vrele(ip->i_devvp);
 		ip->i_devvp = 0;
@@ -83,12 +84,12 @@ ufs_reclaim (ap)
 #ifdef QUOTA
 	for (i = 0; i < MAXQUOTAS; i++) {
 		if (ip->i_dquot[i] != NODQUOT) {
-			dqrele(ap->a_vp, ip->i_dquot[i]);
+			dqrele(vp, ip->i_dquot[i]);
 			ip->i_dquot[i] = NODQUOT;
 		}
 	}
 #endif
-	switch (ap->a_vp->v_mount->mnt_stat.f_type) {
+	switch (vp->v_mount->mnt_stat.f_type) {
 	case MOUNT_UFS:
 		type = M_FFSNODE;
 		break;
@@ -101,8 +102,8 @@ ufs_reclaim (ap)
 	default:
 		panic("ufs_reclaim: not ufs file");
 	}
-	FREE(ap->a_vp->v_data, type);
-	ap->a_vp->v_data = NULL;
+	FREE(vp->v_data, type);
+	vp->v_data = NULL;
 	return (0);
 }
 
-- 
2.20.1