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
@@ -1954,8 +1954,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)
@@ -1990,12 +1989,9 @@
 			uhold = 1;
 			VOP_UNLOCK(uvp);
 		}
-		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);
 
@@ -2018,15 +2014,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
@@ -526,12 +526,9 @@
 int
 vop_stdlock(struct vop_lock1_args *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(ap->a_vp->v_vnlock, ap->a_flags, NULL,
+	    ap->a_file, ap->a_line));
 }
 
 /* See above. */
@@ -563,7 +560,6 @@
 {
 	struct vnode *vp = ap->a_vp;
 	int flags = ap->a_flags;
-	struct mtx *ilk;
 
 	MPASS(vp->v_vnlock == &vp->v_lock);
 
@@ -577,9 +573,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
@@ -2237,9 +2237,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
@@ -3038,6 +3038,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));
 }
 
@@ -3046,10 +3050,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);
@@ -3295,7 +3296,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:
@@ -3311,15 +3313,12 @@
 	case VPUT:
 		want_unlock = true;
 		if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
-			error = VOP_LOCK(vp, LK_UPGRADE | LK_INTERLOCK |
-			    LK_NOWAIT);
-			VI_LOCK(vp);
+			error = VOP_LOCK(vp, LK_UPGRADE | LK_NOWAIT);
 		}
 		break;
 	case VUNREF:
 		if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
-			error = VOP_LOCK(vp, LK_TRYUPGRADE | LK_INTERLOCK);
-			VI_LOCK(vp);
+			error = VOP_LOCK(vp, LK_TRYUPGRADE);
 		}
 		break;
 	}
@@ -3842,7 +3841,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);
@@ -3917,7 +3917,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(rootvp);
+			VOP_LOCK(rootvp, LK_EXCLUSIVE);
 			vgone(rootvp);
 			VOP_UNLOCK(rootvp);
 			busy = 0;
@@ -4777,6 +4778,7 @@
 		vdropl(vp);
 		return;
 	}
+	VI_UNLOCK(vp);
 	if (vn_lock(vp, lkflags) == 0) {
 		VI_LOCK(vp);
 		vinactive(vp);
@@ -4800,7 +4802,7 @@
 	struct vnode *vp, *mvp;
 	int lkflags;
 
-	lkflags = LK_EXCLUSIVE | LK_INTERLOCK;
+	lkflags = LK_EXCLUSIVE;
 	if (flags != MNT_WAIT)
 		lkflags |= LK_NOWAIT;
 
@@ -4848,7 +4850,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;
@@ -4869,7 +4871,7 @@
 				VI_UNLOCK(vp);
 			continue;
 		}
-		if (vget(vp, lkflags) == 0) {
+		if (vget(vp, lkflags | LK_INTERLOCK) == 0) {
 			obj = vp->v_object;
 			if (obj != NULL && (vp->v_vflag & VV_NOSYNC) == 0) {
 				VM_OBJECT_WLOCK(obj);
@@ -5661,11 +5663,17 @@
 vop_lock_debugpre(void *ap)
 {
 	struct vop_lock1_args *a = ap;
+	int flags = a->a_flags;
 
-	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((flags & LK_INTERLOCK) == 0);
+	if ((flags & LK_TRYUPGRADE) == LK_TRYUPGRADE)
+		return;
+	if ((flags & LK_NOWAIT) == LK_NOWAIT)
+		return;
+	/*
+	 * Not trylocking, make sure the interlock is not held.
+	 */
+	ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
 }
 
 void
@@ -5673,7 +5681,6 @@
 {
 	struct vop_lock1_args *a = ap;
 
-	ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
 	if (rc == 0 && (a->a_flags & LK_EXCLOTHER) == 0)
 		ASSERT_VOP_LOCKED(a->a_vp, "VOP_LOCK");
 }
Index: sys/kern/vfs_vnops.c
===================================================================
--- sys/kern/vfs_vnops.c
+++ sys/kern/vfs_vnops.c
@@ -1789,10 +1789,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
@@ -555,7 +555,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;
@@ -2547,8 +2548,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
@@ -13549,7 +13549,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_vfsops.c
===================================================================
--- sys/ufs/ffs/ffs_vfsops.c
+++ sys/ufs/ffs/ffs_vfsops.c
@@ -1711,7 +1711,7 @@
 	}
 	if (waitfor == MNT_WAIT)
 		lockreq = LK_EXCLUSIVE;
-	lockreq |= LK_INTERLOCK | LK_SLEEPFAIL;
+	lockreq |= LK_INTERLOCK;
 loop:
 	/* Grab snapshot of secondary write counts */
 	MNT_ILOCK(mp);
Index: sys/ufs/ffs/ffs_vnops.c
===================================================================
--- sys/ufs/ffs/ffs_vnops.c
+++ sys/ufs/ffs/ffs_vnops.c
@@ -528,12 +528,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) {