Regularize the vop_stdlock'ing protocol across all the filesystems

that use it. Specifically, vop_stdlock uses the lock pointed to by
vp->v_vnlock. By default, getnewvnode sets up vp->v_vnlock to
reference vp->v_lock. Filesystems that wish to use the default
do not need to allocate a lock at the front of their node structure
(as some still did) or do a lockinit. They can simply start using
vn_lock/VOP_UNLOCK. Filesystems that wish to manage their own locks,
but still use the vop_stdlock functions (such as nullfs) can simply
replace vp->v_vnlock with a pointer to the lock that they wish to
have used for the vnode. Such filesystems are responsible for
setting the vp->v_vnlock back to the default in their vop_reclaim
routine (e.g., vp->v_vnlock = &vp->v_lock).

In theory, this set of changes cleans up the existing filesystem
lock interface and should have no function change to the existing
locking scheme.

Sponsored by:	DARPA & NAI Labs.

20 files changed, 7 insertions, 121 deletions

diff --git a/sys/fs/cd9660/cd9660_node.c b/sys/fs/cd9660/cd9660_node.c
index 44e60fa..e120bc4 100644
--- a/sys/fs/cd9660/cd9660_node.c
+++ b/sys/fs/cd9660/cd9660_node.c
@@ -143,7 +143,7 @@ cd9660_ihashins(ip)
 	*ipp = ip;
 	mtx_unlock(&cd9660_ihash_mtx);
 
-	lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, curthread);
+	vn_lock(ITOV(ip), LK_EXCLUSIVE | LK_RETRY, curthread);
 }
 
 /*
@@ -223,7 +223,6 @@ cd9660_reclaim(ap)
 		vrele(ip->i_devvp);
 		ip->i_devvp = 0;
 	}
-	lockdestroy(&ip->i_vnode->v_lock);
 	FREE(vp->v_data, M_ISOFSNODE);
 	vp->v_data = NULL;
 	return (0);
diff --git a/sys/fs/cd9660/cd9660_vfsops.c b/sys/fs/cd9660/cd9660_vfsops.c
index 74608a6..c25d4bb 100644
--- a/sys/fs/cd9660/cd9660_vfsops.c
+++ b/sys/fs/cd9660/cd9660_vfsops.c
@@ -714,11 +714,6 @@ cd9660_vget_internal(mp, ino, flags, vpp, relocated, isodir)
 	}
 	MALLOC(ip, struct iso_node *, sizeof(struct iso_node), M_ISOFSNODE,
 	    M_WAITOK | M_ZERO);
-	lockinit(&vp->v_lock, PINOD, "isonode", 0, 0);
-	/*
-	 * ISOFS uses stdlock and can share lock structure
-	 */
-	vp->v_vnlock = &vp->v_lock;
 	vp->v_data = ip;
 	ip->i_vnode = vp;
 	ip->i_dev = dev;
diff --git a/sys/fs/hpfs/hpfs.h b/sys/fs/hpfs/hpfs.h
index 9a28562..9b4fd1d 100644
--- a/sys/fs/hpfs/hpfs.h
+++ b/sys/fs/hpfs/hpfs.h
@@ -333,7 +333,6 @@ struct hpfsmount {
 #define	H_PARCHANGE	0x0008		/* parent node date was changed */
 #define	H_INVAL		0x0010		/* Invalid node */
 struct hpfsnode {
-	struct lock	h_lock;		/* Must be first, for std vops */
 	struct mtx h_interlock;
 
 	LIST_ENTRY(hpfsnode)	h_hash;
diff --git a/sys/fs/hpfs/hpfs_vfsops.c b/sys/fs/hpfs/hpfs_vfsops.c
index a85a2a2..a4e1bb8 100644
--- a/sys/fs/hpfs/hpfs_vfsops.c
+++ b/sys/fs/hpfs/hpfs_vfsops.c
@@ -512,7 +512,6 @@ hpfs_vget(
 
 
 	mtx_init(&hp->h_interlock, "hpfsnode interlock", NULL, MTX_DEF);
-	lockinit(&hp->h_lock, PINOD, "hpnode", VLKTIMEOUT, 0);
 
 	hp->h_flag = H_INVAL;
 	hp->h_vp = vp;
diff --git a/sys/fs/hpfs/hpfs_vnops.c b/sys/fs/hpfs/hpfs_vnops.c
index 30a788d..5f144a8 100644
--- a/sys/fs/hpfs/hpfs_vnops.c
+++ b/sys/fs/hpfs/hpfs_vnops.c
@@ -643,7 +643,6 @@ hpfs_reclaim(ap)
 		hp->h_devvp = NULL;
 	}
 
-	lockdestroy(&hp->h_lock);
 	mtx_destroy(&hp->h_interlock);
 
 	vp->v_data = NULL;
diff --git a/sys/fs/msdosfs/msdosfs_denode.c b/sys/fs/msdosfs/msdosfs_denode.c
index 6a141bec..735e7df 100644
--- a/sys/fs/msdosfs/msdosfs_denode.c
+++ b/sys/fs/msdosfs/msdosfs_denode.c
@@ -260,8 +260,6 @@ deget(pmp, dirclust, diroffset, depp)
 		return error;
 	}
 	bzero((caddr_t)ldep, sizeof *ldep);
-	lockinit(&nvp->v_lock, PINOD, "denode", VLKTIMEOUT, 0);
-	nvp->v_vnlock = &nvp->v_lock;
 	nvp->v_data = ldep;
 	ldep->de_vnode = nvp;
 	ldep->de_flag = 0;
@@ -670,7 +668,6 @@ msdosfs_reclaim(ap)
 #if 0 /* XXX */
 	dep->de_flag = 0;
 #endif
-	lockdestroy(&vp->v_lock);
 	FREE(dep, M_MSDOSFSNODE);
 	vp->v_data = NULL;
 
diff --git a/sys/fs/ntfs/ntfs_inode.h b/sys/fs/ntfs/ntfs_inode.h
index 84cde59..13ed443 100644
--- a/sys/fs/ntfs/ntfs_inode.h
+++ b/sys/fs/ntfs/ntfs_inode.h
@@ -69,8 +69,6 @@ struct ntnode {
 #define	FN_VALID	0x0002
 #define	FN_AATTRNAME	0x0004	/* space allocated for f_attrname */
 struct fnode {
-	struct lock	f_lock;	/* fnode lock >Keep this first< */
-	
 	LIST_ENTRY(fnode) f_fnlist;
 	struct vnode   *f_vp;		/* Associatied vnode */
 	struct ntnode  *f_ip;		/* Associated ntnode */
diff --git a/sys/fs/ntfs/ntfs_subr.c b/sys/fs/ntfs/ntfs_subr.c
index afb1862..20b98a5 100644
--- a/sys/fs/ntfs/ntfs_subr.c
+++ b/sys/fs/ntfs/ntfs_subr.c
@@ -778,7 +778,6 @@ ntfs_frele(
 		FREE(fp->f_attrname, M_TEMP);
 	if (fp->f_dirblbuf)
 		FREE(fp->f_dirblbuf, M_NTFSDIR);
-	lockdestroy(&fp->f_lock);
 	FREE(fp, M_NTFSFNODE);
 	ntfs_ntrele(ip);
 }
diff --git a/sys/fs/ntfs/ntfs_vfsops.c b/sys/fs/ntfs/ntfs_vfsops.c
index 213813e..1e267a9 100644
--- a/sys/fs/ntfs/ntfs_vfsops.c
+++ b/sys/fs/ntfs/ntfs_vfsops.c
@@ -741,7 +741,6 @@ ntfs_vgetex(
 	}
 	dprintf(("ntfs_vget: vnode: %p for ntnode: %d\n", vp,ino));
 
-	lockinit(&fp->f_lock, PINOD, "fnode", VLKTIMEOUT, 0);
 	fp->f_vp = vp;
 	vp->v_data = fp;
 	vp->v_type = f_type;
diff --git a/sys/fs/nullfs/null_subr.c b/sys/fs/nullfs/null_subr.c
index 1fdd210..f2a43e0 100644
--- a/sys/fs/nullfs/null_subr.c
+++ b/sys/fs/nullfs/null_subr.c
@@ -226,9 +226,6 @@ null_nodeget(mp, lowervp, vpp)
 	vp->v_type = lowervp->v_type;
 	vp->v_data = xp;
 
-	/* Though v_lock is inited by getnewvnode(), we want our own wmesg */
-	lockinit(&vp->v_lock, PVFS, "nunode", VLKTIMEOUT, LK_NOPAUSE);
-
 	/*
 	 * From NetBSD:
 	 * Now lock the new node. We rely on the fact that we were passed
diff --git a/sys/fs/nullfs/null_vnops.c b/sys/fs/nullfs/null_vnops.c
index 5f46b2f..69d72bc 100644
--- a/sys/fs/nullfs/null_vnops.c
+++ b/sys/fs/nullfs/null_vnops.c
@@ -758,6 +758,7 @@ null_reclaim(ap)
 	}
 
 	vp->v_data = NULL;
+	vp->v_vnlock = &vp->v_lock;
 	FREE(xp, M_NULLFSNODE);
 
 	return (0);
diff --git a/sys/fs/nwfs/nwfs_node.c b/sys/fs/nwfs/nwfs_node.c
index 1d599fc..b92dd4c 100644
--- a/sys/fs/nwfs/nwfs_node.c
+++ b/sys/fs/nwfs/nwfs_node.c
@@ -185,7 +185,7 @@ rescan:
 	if (dvp) {
 		np->n_parent = VTONW(dvp)->n_fid;
 	}
-	lockinit(&vp->v_lock, PINOD, "nwnode", VLKTIMEOUT, LK_CANRECURSE);
+	vp->v_vnlock->lk_flags |= LK_CANRECURSE;
 	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
 	/*
 	 * Another process can create vnode while we blocked in malloc() or
diff --git a/sys/fs/pseudofs/pseudofs_vncache.c b/sys/fs/pseudofs/pseudofs_vncache.c
index 1239f12..59f61af 100644
--- a/sys/fs/pseudofs/pseudofs_vncache.c
+++ b/sys/fs/pseudofs/pseudofs_vncache.c
@@ -179,8 +179,7 @@ pfs_vncache_alloc(struct mount *mp, struct vnode **vpp,
 		pvd->pvd_next->pvd_prev = pvd;
 	pfs_vncache = pvd;
 	mtx_unlock(&pfs_vncache_mutex);
-        (*vpp)->v_vnlock = &(*vpp)->v_lock;
-        lockinit((*vpp)->v_vnlock, PINOD, "pfsnod", VLKTIMEOUT, LK_CANRECURSE);
+        (*vpp)->v_vnlock->lk_flags |= LK_CANRECURSE;
 	vn_lock(*vpp, LK_RETRY | LK_EXCLUSIVE, curthread);
 	return (0);
 }
diff --git a/sys/fs/smbfs/smbfs_io.c b/sys/fs/smbfs/smbfs_io.c
index 1baa384..21ccbab 100644
--- a/sys/fs/smbfs/smbfs_io.c
+++ b/sys/fs/smbfs/smbfs_io.c
@@ -203,7 +203,7 @@ smbfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred)
 		return EFBIG;*/
 	td = uiop->uio_td;
 	if (vp->v_type == VDIR) {
-		lks = LK_EXCLUSIVE;/*lockstatus(&vp->v_lock, td);*/
+		lks = LK_EXCLUSIVE;/*lockstatus(vp->v_vnlock, td);*/
 		if (lks == LK_SHARED)
 			vn_lock(vp, LK_UPGRADE | LK_RETRY, td);
 		error = smbfs_readvdir(vp, uiop, cred);
diff --git a/sys/fs/smbfs/smbfs_node.c b/sys/fs/smbfs/smbfs_node.c
index edd62b7..c94787d 100644
--- a/sys/fs/smbfs/smbfs_node.c
+++ b/sys/fs/smbfs/smbfs_node.c
@@ -244,7 +244,7 @@ loop:
 	} else if (vp->v_type == VREG)
 		SMBERROR("new vnode '%s' born without parent ?\n", np->n_name);
 
-	lockinit(&vp->v_lock, PINOD, "smbnode", VLKTIMEOUT, LK_CANRECURSE);
+	vp->v_vnlock->lk_flags |= LK_CANRECURSE;
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 
 	smbfs_hash_lock(smp, td);
diff --git a/sys/fs/udf/udf_vfsops.c b/sys/fs/udf/udf_vfsops.c
index b23e30f..b41b86b 100644
--- a/sys/fs/udf/udf_vfsops.c
+++ b/sys/fs/udf/udf_vfsops.c
@@ -613,8 +613,6 @@ udf_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp)
 	unode->i_dev = udfmp->im_dev;
 	unode->udfmp = udfmp;
 	vp->v_data = unode;
-	lockinit(&vp->v_lock, PINOD, "udfnode", 0, 0);
-	vp->v_vnlock = &vp->v_lock;
 	VREF(udfmp->im_devvp);
 	udf_hashins(unode);
 
diff --git a/sys/fs/udf/udf_vnops.c b/sys/fs/udf/udf_vnops.c
index 2f71d86..4e4a4b6 100644
--- a/sys/fs/udf/udf_vnops.c
+++ b/sys/fs/udf/udf_vnops.c
@@ -135,8 +135,7 @@ udf_hashins(struct udf_node *node)
 	mtx_lock(&udfmp->hash_mtx);
 	TAILQ_INSERT_TAIL(&udfmp->udf_tqh, node, tq);
 	mtx_unlock(&udfmp->hash_mtx);
-	lockmgr(&node->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0,
-		curthread);
+	vn_lock(node->i_vnode, LK_EXCLUSIVE | LK_RETRY, curthread);
 
 	return (0);
 }
@@ -1028,7 +1027,6 @@ udf_reclaim(struct vop_reclaim_args *a)
 
 		if (unode->fentry != NULL)
 			FREE(unode->fentry, M_UDFFENTRY);
-		lockdestroy(&unode->i_vnode->v_lock);
 		uma_zfree(udf_zone_node, unode);
 		vp->v_data = NULL;
 	}
diff --git a/sys/fs/unionfs/union.h b/sys/fs/unionfs/union.h
index 3a2ee2a..58afd21 100644
--- a/sys/fs/unionfs/union.h
+++ b/sys/fs/unionfs/union.h
@@ -66,13 +66,8 @@ struct union_mount {
 
 /*
  * A cache of vnode references	(hangs off v_data)
- *
- * Placing un_lock as the first elements theoretically allows us to
- * use the vop_stdlock functions.  However, we need to make sure of
- * certain side effects so we will still punch in our own code.
  */
 struct union_node {
-	struct lock		un_lock;
 	LIST_ENTRY(union_node)	un_cache;	/* Hash chain */
 	struct vnode		*un_vnode;	/* Back pointer */
 	struct vnode	        *un_uppervp;	/* overlaying object */
diff --git a/sys/fs/unionfs/union_subr.c b/sys/fs/unionfs/union_subr.c
index cc06e77..706977e 100644
--- a/sys/fs/unionfs/union_subr.c
+++ b/sys/fs/unionfs/union_subr.c
@@ -576,7 +576,6 @@ loop:
 	un = VTOUNION(*vpp);
 	bzero(un, sizeof(*un));
 
-	lockinit(&un->un_lock, PVFS, "unlock", VLKTIMEOUT, 0);
 	vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);
 
 	un->un_vnode = *vpp;
@@ -643,7 +642,6 @@ union_freevp(vp)
 		free(un->un_path, M_TEMP);
 		un->un_path = NULL;
 	}
-	lockdestroy(&un->un_lock);
 
 	FREE(vp->v_data, M_TEMP);
 	vp->v_data = 0;
diff --git a/sys/fs/unionfs/union_vnops.c b/sys/fs/unionfs/union_vnops.c
index 3ceb89f..a1b757e 100644
--- a/sys/fs/unionfs/union_vnops.c
+++ b/sys/fs/unionfs/union_vnops.c
@@ -80,7 +80,6 @@ static int	union_inactive(struct vop_inactive_args *ap);
 static int	union_ioctl(struct vop_ioctl_args *ap);
 static int	union_lease(struct vop_lease_args *ap);
 static int	union_link(struct vop_link_args *ap);
-static int	union_lock(struct vop_lock_args *ap);
 static int	union_lookup(struct vop_lookup_args *ap);
 static int	union_lookup1(struct vnode *udvp, struct vnode **dvp,
 				   struct vnode **vpp,
@@ -103,7 +102,6 @@ static int	union_poll(struct vop_poll_args *ap);
 static int	union_setattr(struct vop_setattr_args *ap);
 static int	union_strategy(struct vop_strategy_args *ap);
 static int	union_symlink(struct vop_symlink_args *ap);
-static int	union_unlock(struct vop_unlock_args *ap);
 static int	union_whiteout(struct vop_whiteout_args *ap);
 static int	union_write(struct vop_read_args *ap);
 
@@ -1700,86 +1698,6 @@ union_reclaim(ap)
 	return (0);
 }
 
-static int
-union_lock(ap)
-	struct vop_lock_args *ap;
-{
-#if 0
-	struct vnode *vp = ap->a_vp;
-	struct thread *td = ap->a_td;
-	int flags = ap->a_flags;
-	struct union_node *un;
-#endif
-	int error;
-
-	error = vop_stdlock(ap);
-#if 0
-	un = VTOUNION(vp);
-
-	if (error == 0) {
-		/*
-		 * Lock the upper if it exists and this is an exclusive lock
-		 * request.
-		 */
-		if (un->un_uppervp != NULLVP && 
-		    (flags & LK_TYPE_MASK) == LK_EXCLUSIVE) {
-			if ((un->un_flags & UN_ULOCK) == 0 && vrefcnt(vp)) {
-				error = vn_lock(un->un_uppervp, flags, td);
-				if (error) {
-					struct vop_unlock_args uap = { 0 };
-					uap.a_vp = ap->a_vp;
-					uap.a_flags = ap->a_flags;
-					uap.a_td = ap->a_td;
-					vop_stdunlock(&uap);
-					return (error);
-				}
-				un->un_flags |= UN_ULOCK;
-			}
-		}
-	}
-#endif
-	return (error);
-}
-
-/*
- *	union_unlock:
- *
- *	Unlock our union node.  This also unlocks uppervp.  
- */
-static int
-union_unlock(ap)
-	struct vop_unlock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct thread *a_td;
-	} */ *ap;
-{
-#if 0
-	struct union_node *un = VTOUNION(ap->a_vp);
-#endif
-	int error;
-
-#if 0
-	KASSERT((un->un_uppervp == NULL || vrefcnt(un->un_uppervp) > 0), ("uppervp usecount is 0"));
-#endif
-
-	error = vop_stdunlock(ap);
-#if 0
-
-	/*
-	 * If no exclusive locks remain and we are holding an uppervp lock,
-	 * remove the uppervp lock.
-	 */
-
-	if ((un->un_flags & UN_ULOCK) && 
-	    lockstatus(&un->un_lock, NULL) != LK_EXCLUSIVE) {
-		un->un_flags &= ~UN_ULOCK;
-		VOP_UNLOCK(un->un_uppervp, LK_EXCLUSIVE, td);
-	}
-#endif
-	return(error);
-}
-
 /*
  * unionvp do not hold a VM object and there is no need to create one for
  * upper or lower vp because it is done in the union_open()
@@ -1936,7 +1854,6 @@ static struct vnodeopv_entry_desc union_vnodeop_entries[] = {
 	{ &vop_islocked_desc,		(vop_t *) vop_stdislocked },
 	{ &vop_lease_desc,		(vop_t *) union_lease },
 	{ &vop_link_desc,		(vop_t *) union_link },
-	{ &vop_lock_desc,		(vop_t *) union_lock },
 	{ &vop_lookup_desc,		(vop_t *) union_lookup },
 	{ &vop_mkdir_desc,		(vop_t *) union_mkdir },
 	{ &vop_mknod_desc,		(vop_t *) union_mknod },
@@ -1956,7 +1873,6 @@ static struct vnodeopv_entry_desc union_vnodeop_entries[] = {
 	{ &vop_setattr_desc,		(vop_t *) union_setattr },
 	{ &vop_strategy_desc,		(vop_t *) union_strategy },
 	{ &vop_symlink_desc,		(vop_t *) union_symlink },
-	{ &vop_unlock_desc,		(vop_t *) union_unlock },
 	{ &vop_whiteout_desc,		(vop_t *) union_whiteout },
 	{ &vop_write_desc,		(vop_t *) union_write },
 	{ NULL, NULL }