Index: cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_znode.c
===================================================================
--- cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_znode.c	(revision 212258)
+++ cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_znode.c	(working copy)
@@ -618,11 +618,8 @@
 		vp->v_op = &zfs_fifoops;
 		break;
 	}
-	if (vp->v_type != VFIFO) {
-		VI_LOCK(vp);
+	if (vp->v_type != VFIFO)
 		VN_LOCK_ASHARE(vp);
-		VI_UNLOCK(vp);
-	}
 
 	mutex_enter(&zfsvfs->z_znodes_lock);
 	list_insert_tail(&zfsvfs->z_all_znodes, zp);
Index: fs/pseudofs/pseudofs_vncache.c
===================================================================
--- fs/pseudofs/pseudofs_vncache.c	(revision 212258)
+++ fs/pseudofs/pseudofs_vncache.c	(working copy)
@@ -189,7 +189,7 @@
 	if ((pn->pn_flags & PFS_PROCDEP) != 0)
 		(*vpp)->v_vflag |= VV_PROCDEP;
 	pvd->pvd_vnode = *vpp;
-	(*vpp)->v_vnlock->lk_flags |= LK_CANRECURSE;
+	VN_LOCK_AREC(*vpp);
 	vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, curthread);
 	error = insmntque(*vpp, mp);
 	if (error != 0) {
Index: fs/smbfs/smbfs_node.c
===================================================================
--- fs/smbfs/smbfs_node.c	(revision 212258)
+++ fs/smbfs/smbfs_node.c	(working copy)
@@ -259,7 +259,7 @@
 	} else if (vp->v_type == VREG)
 		SMBERROR("new vnode '%s' born without parent ?\n", np->n_name);
 
-	vp->v_vnlock->lk_flags |= LK_CANRECURSE;
+	VN_LOCK_AREC(vp);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
 
 	smbfs_hash_lock(smp);
Index: fs/cd9660/cd9660_vfsops.c
===================================================================
--- fs/cd9660/cd9660_vfsops.c	(revision 212258)
+++ fs/cd9660/cd9660_vfsops.c	(working copy)
@@ -821,9 +821,7 @@
 		vp->v_op = &cd9660_fifoops;
 		break;
 	default:
-		VI_LOCK(vp);
 		VN_LOCK_ASHARE(vp);
-		VI_UNLOCK(vp);
 		break;
 	}
 
Index: fs/udf/udf_vfsops.c
===================================================================
--- fs/udf/udf_vfsops.c	(revision 212258)
+++ fs/udf/udf_vfsops.c	(working copy)
@@ -709,11 +709,8 @@
 		break;
 	}
 
-	if (vp->v_type != VFIFO) {
-		VI_LOCK(vp);
+	if (vp->v_type != VFIFO)
 		VN_LOCK_ASHARE(vp);
-		VI_UNLOCK(vp);
-	}
 
 	if (ino == udf_getid(&udfmp->root_icb))
 		vp->v_vflag |= VV_ROOT;
Index: gnu/fs/xfs/FreeBSD/xfs_freebsd_iget.c
===================================================================
--- gnu/fs/xfs/FreeBSD/xfs_freebsd_iget.c	(revision 212258)
+++ gnu/fs/xfs/FreeBSD/xfs_freebsd_iget.c	(working copy)
@@ -389,7 +389,7 @@
 		return (error);
 	}
 
-	vp->v_vnlock->lk_flags |= LK_CANRECURSE;
+	VN_LOCK_AREC(vp);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread);
 	error = insmntque(vp, XVFSTOMNT(XFS_MTOVFS(mp)));
 	if (error != 0) {
Index: kern/vfs_lookup.c
===================================================================
--- kern/vfs_lookup.c	(revision 212258)
+++ kern/vfs_lookup.c	(working copy)
@@ -83,7 +83,7 @@
 	error = getnewvnode("crossmp", NULL, &dead_vnodeops, &vp_crossmp);
 	if (error != 0)
 		panic("nameiinit: getnewvnode");
-	vp_crossmp->v_vnlock->lk_flags &= ~LK_NOSHARE;
+	VN_LOCK_ASHARE(vp_crossmp);
 }
 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nameiinit, NULL);
 
Index: kern/kern_lock.c
===================================================================
--- kern/kern_lock.c	(revision 212258)
+++ kern/kern_lock.c	(working copy)
@@ -555,6 +555,40 @@
 }
 
 /*
+ * XXX: Gross hacks to manipulate external lock flags after
+ * initialization.  Used for certain vnode and buf locks.
+ */
+void
+lockallowshare(lkp)
+	struct lock *lkp;
+{
+
+	mtx_lock(lkp->lk_interlock);
+	lkp->lk_flags &= ~LK_NOSHARE;
+	mtx_unlock(lkp->lk_interlock);
+}
+
+void
+lockallowrecurse(lkp)
+	struct lock *lkp;
+{
+
+	mtx_lock(lkp->lk_interlock);
+	lkp->lk_flags |= LK_CANRECURSE;
+	mtx_unlock(lkp->lk_interlock);
+}
+
+void
+lockdisablerecurse(lkp)
+	struct lock *lkp;
+{
+
+	mtx_lock(lkp->lk_interlock);
+	lkp->lk_flags &= ~LK_CANRECURSE;
+	mtx_unlock(lkp->lk_interlock);
+}
+
+/*
  * Destroy a lock.
  */
 void
Index: ufs/ffs/ffs_vfsops.c
===================================================================
--- ufs/ffs/ffs_vfsops.c	(revision 212258)
+++ ufs/ffs/ffs_vfsops.c	(working copy)
@@ -1519,9 +1519,7 @@
 	 */
 	if (vp->v_type != VFIFO) {
 		/* FFS supports shared locking for all files except fifos. */
-		VI_LOCK(vp);
 		VN_LOCK_ASHARE(vp);
-		VI_UNLOCK(vp);
 	}
 
 	/*
Index: ufs/ffs/ffs_softdep.c
===================================================================
--- ufs/ffs/ffs_softdep.c	(revision 212258)
+++ ufs/ffs/ffs_softdep.c	(working copy)
@@ -5291,9 +5291,7 @@
 		return (0);
 loop:
 	/* While syncing snapshots, we must allow recursive lookups */
-	mtx_lock(bp->b_lock.lk_interlock);
-	bp->b_lock.lk_flags |= LK_CANRECURSE;
-	mtx_unlock(bp->b_lock.lk_interlock);
+	lockallowrecurse(&bp->b_lock);
 	ACQUIRE_LOCK(&lk);
 	/*
 	 * As we hold the buffer locked, none of its dependencies
@@ -5435,9 +5433,7 @@
 		/* We reach here only in error and unlocked */
 		if (error == 0)
 			panic("softdep_sync_metadata: zero error");
-		mtx_lock(bp->b_lock.lk_interlock);
-		bp->b_lock.lk_flags &= ~LK_CANRECURSE;
-		mtx_unlock(bp->b_lock.lk_interlock);
+		lockdisablerecurse(&bp->b_lock);
 		bawrite(bp);
 		return (error);
 	}
@@ -5449,9 +5445,7 @@
 			break;
 	}
 	VI_UNLOCK(vp);
-	mtx_lock(bp->b_lock.lk_interlock);
-	bp->b_lock.lk_flags &= ~LK_CANRECURSE;
-	mtx_unlock(bp->b_lock.lk_interlock);
+	lockdisablerecurse(&bp->b_lock);
 	bawrite(bp);
 	if (nbp != NULL) {
 		bp = nbp;
Index: sys/lockmgr.h
===================================================================
--- sys/lockmgr.h	(revision 212258)
+++ sys/lockmgr.h	(working copy)
@@ -214,6 +214,9 @@
 int	lockstatus(struct lock *, struct thread *);
 int	lockcount(struct lock *);
 int	lockwaiters(struct lock *);
+void	lockallowshare(struct lock *);
+void	lockallowrecurse(struct lock *);
+void	lockdisablerecurse(struct lock *);
 
 #define	lockmgr(lock, flags, mtx, td)					\
 	_lockmgr((lock), (flags), (mtx), (td), LOCK_FILE, LOCK_LINE)
Index: sys/vnode.h
===================================================================
--- sys/vnode.h	(revision 212258)
+++ sys/vnode.h	(working copy)
@@ -398,8 +398,8 @@
 #define	VI_UNLOCK(vp)	mtx_unlock(&(vp)->v_interlock)
 #define	VI_MTX(vp)	(&(vp)->v_interlock)
 
-#define	VN_LOCK_AREC(vp)	((vp)->v_vnlock->lk_flags |= LK_CANRECURSE)
-#define	VN_LOCK_ASHARE(vp)	((vp)->v_vnlock->lk_flags &= ~LK_NOSHARE)
+#define	VN_LOCK_AREC(vp)	lockallowrecurse((vp)->v_vnlock)
+#define	VN_LOCK_ASHARE(vp)	lockallowshare((vp)->v_vnlock)
 
 #endif /* _KERNEL */