Index: sys/fs/nullfs/null_vnops.c
===================================================================
--- sys/fs/nullfs/null_vnops.c
+++ sys/fs/nullfs/null_vnops.c
@@ -752,10 +752,7 @@
 	struct vnode *lvp;
 	int error;
 
-	if ((ap->a_flags & LK_INTERLOCK) == 0)
-		VI_LOCK(vp);
-	else
-		ap->a_flags &= ~LK_INTERLOCK;
+	VI_LOCK(vp);
 	flags = ap->a_flags;
 	nn = VTONULL(vp);
 	/*
Index: sys/fs/unionfs/union_vnops.c
===================================================================
--- sys/fs/unionfs/union_vnops.c
+++ sys/fs/unionfs/union_vnops.c
@@ -1947,8 +1947,7 @@
 	if (LK_RELEASE == (flags & LK_TYPE_MASK) || !(flags & LK_TYPE_MASK))
 		return (VOP_UNLOCK_FLAGS(vp, flags | LK_RELEASE));
 
-	if ((flags & LK_INTERLOCK) == 0)
-		VI_LOCK(vp);
+	VI_LOCK(vp);
 
 	unp = VTOUNIONFS(vp);
 	if (unp == NULL)
@@ -1991,12 +1990,9 @@
 				return (EBUSY);
 			}
 		}
-		VI_LOCK_FLAGS(lvp, MTX_DUPOK);
-		flags |= LK_INTERLOCK;
-		vholdl(lvp);
+		vhold(lvp);
 
 		VI_UNLOCK(vp);
-		ap->a_flags &= ~LK_INTERLOCK;
 
 		error = VOP_LOCK(lvp, flags);
 
@@ -2019,15 +2015,12 @@
 			flags &= ~LK_TYPE_MASK;
 			flags |= LK_EXCLUSIVE;
 		}
-		VI_LOCK_FLAGS(uvp, MTX_DUPOK);
-		flags |= LK_INTERLOCK;
 		if (uhold == 0) {
-			vholdl(uvp);
+			vhold(uvp);
 			uhold = 1;
 		}
 
 		VI_UNLOCK(vp);
-		ap->a_flags &= ~LK_INTERLOCK;
 
 		error = VOP_LOCK(uvp, flags);
 
Index: sys/kern/vfs_default.c
===================================================================
--- sys/kern/vfs_default.c
+++ sys/kern/vfs_default.c
@@ -543,11 +543,9 @@
 	} */ *ap;
 {
 	struct vnode *vp = ap->a_vp;
-	struct mtx *ilk;
 
-	ilk = VI_MTX(vp);
-	return (lockmgr_lock_flags(vp->v_vnlock, ap->a_flags,
-	    &ilk->lock_object, ap->a_file, ap->a_line));
+	return (lockmgr_lock_flags(vp->v_vnlock, ap->a_flags, NULL, ap->a_file,
+	    ap->a_line));
 }
 
 /* See above. */
@@ -591,7 +589,6 @@
 {
 	struct vnode *vp = ap->a_vp;
 	int flags = ap->a_flags;
-	struct mtx *ilk;
 
 	MPASS(vp->v_vnlock == &vp->v_lock);
 
@@ -605,9 +602,8 @@
 		return (lockmgr_xlock(&vp->v_lock, flags, ap->a_file, ap->a_line));
 	}
 other:
-	ilk = VI_MTX(vp);
-	return (lockmgr_lock_flags(&vp->v_lock, flags,
-	    &ilk->lock_object, ap->a_file, ap->a_line));
+	return (lockmgr_lock_flags(&vp->v_lock, flags, NULL, ap->a_file,
+	    ap->a_line));
 }
 
 int
Index: sys/kern/vfs_mount.c
===================================================================
--- sys/kern/vfs_mount.c
+++ sys/kern/vfs_mount.c
@@ -2110,9 +2110,8 @@
 
 	if ((coveredvp = mp->mnt_vnodecovered) != NULL) {
 		mnt_gen_r = mp->mnt_gen;
-		VI_LOCK(coveredvp);
-		vholdl(coveredvp);
-		vn_lock(coveredvp, LK_EXCLUSIVE | LK_INTERLOCK | LK_RETRY);
+		vhold(coveredvp);
+		vn_lock(coveredvp, LK_EXCLUSIVE | LK_RETRY);
 		/*
 		 * Check for mp being unmounted while waiting for the
 		 * covered vnode lock.
Index: sys/kern/vfs_subr.c
===================================================================
--- sys/kern/vfs_subr.c
+++ sys/kern/vfs_subr.c
@@ -3010,6 +3010,10 @@
 	enum vgetstate vs;
 
 	vs = vget_prep(vp);
+	if ((flags & LK_INTERLOCK) != 0) {
+		VI_UNLOCK(vp);
+		flags &= ~LK_INTERLOCK;
+	}
 	return (vget_finish(vp, flags, vs));
 }
 
@@ -3018,10 +3022,7 @@
 {
 	int error;
 
-	if ((flags & LK_INTERLOCK) != 0)
-		ASSERT_VI_LOCKED(vp, __func__);
-	else
-		ASSERT_VI_UNLOCKED(vp, __func__);
+	MPASS((flags & LK_INTERLOCK) == 0);
 	VNPASS(vs == VGET_HOLDCNT || vs == VGET_USECOUNT, vp);
 	VNPASS(vp->v_holdcnt > 0, vp);
 	VNPASS(vs == VGET_HOLDCNT || vp->v_usecount > 0, vp);
@@ -3268,7 +3269,8 @@
 		case LK_EXCLOTHER:
 		case 0:
 			want_unlock = true;
-			error = vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK);
+			VI_UNLOCK(vp);
+			error = vn_lock(vp, LK_EXCLUSIVE);
 			VI_LOCK(vp);
 			break;
 		default:
@@ -3284,14 +3286,15 @@
 	case VPUT:
 		want_unlock = true;
 		if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
-			error = VOP_LOCK(vp, LK_UPGRADE | LK_INTERLOCK |
-			    LK_NOWAIT);
+			VI_UNLOCK(vp);
+			error = VOP_LOCK(vp, LK_UPGRADE | LK_NOWAIT);
 			VI_LOCK(vp);
 		}
 		break;
 	case VUNREF:
 		if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
-			error = VOP_LOCK(vp, LK_TRYUPGRADE | LK_INTERLOCK);
+			VI_UNLOCK(vp);
+			error = VOP_LOCK(vp, LK_TRYUPGRADE);
 			VI_LOCK(vp);
 		}
 		break;
@@ -3813,7 +3816,8 @@
 loop:
 	MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
 		vholdl(vp);
-		error = vn_lock(vp, LK_INTERLOCK | LK_EXCLUSIVE);
+		VI_UNLOCK(vp);
+		error = vn_lock(vp, LK_EXCLUSIVE);
 		if (error) {
 			vdrop(vp);
 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
@@ -3888,7 +3892,8 @@
 		    ("vflush: usecount %d < rootrefs %d",
 		     rootvp->v_usecount, rootrefs));
 		if (busy == 1 && rootvp->v_usecount == rootrefs) {
-			VOP_LOCK(rootvp, LK_EXCLUSIVE|LK_INTERLOCK);
+			VI_UNLOCK(vp);
+			VOP_LOCK(rootvp, LK_EXCLUSIVE);
 			vgone(rootvp);
 			VOP_UNLOCK(rootvp);
 			busy = 0;
@@ -4819,6 +4824,7 @@
 		vdropl(vp);
 		return;
 	}
+	VI_UNLOCK(vp);
 	if (vn_lock(vp, lkflags) == 0) {
 		VI_LOCK(vp);
 		vinactive(vp);
@@ -4842,7 +4848,7 @@
 	struct vnode *vp, *mvp;
 	int lkflags;
 
-	lkflags = LK_EXCLUSIVE | LK_INTERLOCK;
+	lkflags = LK_EXCLUSIVE;
 	if (flags != MNT_WAIT)
 		lkflags |= LK_NOWAIT;
 
@@ -4890,7 +4896,7 @@
 	int lkflags, objflags;
 	bool seen_defer;
 
-	lkflags = LK_EXCLUSIVE | LK_INTERLOCK;
+	lkflags = LK_EXCLUSIVE;
 	if (flags != MNT_WAIT) {
 		lkflags |= LK_NOWAIT;
 		objflags = OBJPC_NOSYNC;
@@ -5685,10 +5691,7 @@
 {
 	struct vop_lock1_args *a = ap;
 
-	if ((a->a_flags & LK_INTERLOCK) == 0)
-		ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
-	else
-		ASSERT_VI_LOCKED(a->a_vp, "VOP_LOCK");
+	MPASS((a->a_flags & LK_INTERLOCK) == 0);
 }
 
 void
Index: sys/kern/vfs_vnops.c
===================================================================
--- sys/kern/vfs_vnops.c
+++ sys/kern/vfs_vnops.c
@@ -1791,10 +1791,6 @@
 	if (error == 0)
 		return (0);
 
-	/*
-	 * Interlock was dropped by the call in _vn_lock.
-	 */
-	flags &= ~LK_INTERLOCK;
 	do {
 		error = VOP_LOCK1(vp, flags, file, line);
 	} while (error != 0);
Index: sys/ufs/ffs/ffs_snapshot.c
===================================================================
--- sys/ufs/ffs/ffs_snapshot.c
+++ sys/ufs/ffs/ffs_snapshot.c
@@ -564,7 +564,8 @@
 			continue;
 		}
 		vholdl(xvp);
-		if (vn_lock(xvp, LK_EXCLUSIVE | LK_INTERLOCK) != 0) {
+		VI_UNLOCK(xvp);
+		if (vn_lock(xvp, LK_EXCLUSIVE) != 0) {
 			MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
 			vdrop(xvp);
 			goto loop;
@@ -2556,8 +2557,9 @@
 			continue;
 		}
 		vholdl(vp);
+		VI_UNLOCK(vp);
 retry_vnode:
-		error = vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK);
+		error = vn_lock(vp, LK_EXCLUSIVE);
 		if (error != 0) {
 			vdrop(vp);
 			if (error == ENOENT)
Index: sys/ufs/ffs/ffs_softdep.c
===================================================================
--- sys/ufs/ffs/ffs_softdep.c
+++ sys/ufs/ffs/ffs_softdep.c
@@ -13537,7 +13537,8 @@
 	MNT_VNODE_FOREACH_LAZY(vp, mp, mvp, softdep_request_cleanup_filter,
 	    NULL) {
 		vholdl(vp);
-		vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK | LK_RETRY);
+		VI_UNLOCK(vp);
+		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 		VI_LOCK(vp);
 		if (IS_UFS(vp) && vp->v_usecount == 0) {
 			while ((vp->v_iflag & VI_OWEINACT) != 0) {
Index: sys/ufs/ffs/ffs_vnops.c
===================================================================
--- sys/ufs/ffs/ffs_vnops.c
+++ sys/ufs/ffs/ffs_vnops.c
@@ -520,12 +520,10 @@
 			 * new lock.
 			 */
 			lockmgr_unlock(lkp);
-			if ((flags & (LK_INTERLOCK | LK_NOWAIT)) ==
-			    (LK_INTERLOCK | LK_NOWAIT))
+			if ((flags & LK_NOWAIT) == LK_NOWAIT)
 				return (EBUSY);
 			if ((flags & LK_TYPE_MASK) == LK_UPGRADE)
 				flags = (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE;
-			flags &= ~LK_INTERLOCK;
 		}
 #ifdef DIAGNOSTIC
 		switch (ap->a_flags & LK_TYPE_MASK) {