Index: coda/coda_vnops.c
===================================================================
RCS file: /home/ncvs/src/sys/coda/coda_vnops.c,v
retrieving revision 1.20
diff -u -r1.20 coda_vnops.c
--- coda_vnops.c	1999/11/13 20:58:09	1.20
+++ coda_vnops.c	1999/12/07 21:54:09
@@ -1865,7 +1865,7 @@
     struct cnode *cp = VTOC(ap->a_vp);
     ENTRY;
 
-    return (lockstatus(&cp->c_lock));
+    return (lockstatus(&cp->c_lock, ap->a_p));
 }
 
 /* How one looks up a vnode given a device/inode pair: */
Index: contrib/softupdates/ffs_softdep.c
===================================================================
RCS file: /home/ncvs/src/sys/contrib/softupdates/ffs_softdep.c,v
retrieving revision 1.38
diff -u -r1.38 ffs_softdep.c
--- ffs_softdep.c	1999/11/22 10:33:55	1.38
+++ ffs_softdep.c	1999/12/07 19:48:38
@@ -3978,7 +3978,7 @@
 	 * way to accomplish this is to sync the entire filesystem (luckily
 	 * this happens rarely).
 	 */
-	if (vn_isdisk(vp) && vp->v_specmountpoint && !VOP_ISLOCKED(vp) &&
+	if (vn_isdisk(vp) && vp->v_specmountpoint && !VOP_ISLOCKED(vp, NULL) &&
 	    (error = VFS_SYNC(vp->v_specmountpoint, MNT_WAIT, ap->a_cred,
 	     ap->a_p)) != 0)
 		return (error);
Index: dev/vn/vn.c
===================================================================
RCS file: /home/ncvs/src/sys/dev/vn/vn.c,v
retrieving revision 1.102
diff -u -r1.102 vn.c
--- vn.c	1999/11/07 10:01:14	1.102
+++ vn.c	1999/12/07 19:48:46
@@ -362,7 +362,7 @@
 			auio.uio_rw = UIO_WRITE;
 		auio.uio_resid = bp->b_bcount;
 		auio.uio_procp = curproc;
-		if (!VOP_ISLOCKED(vn->sc_vp)) {
+		if (!VOP_ISLOCKED(vn->sc_vp, NULL)) {
 			isvplocked = 1;
 			vn_lock(vn->sc_vp, LK_EXCLUSIVE | LK_RETRY, curproc);
 		}
Index: i386/conf/LINT
===================================================================
RCS file: /home/ncvs/src/sys/i386/conf/LINT,v
retrieving revision 1.693
diff -u -r1.693 LINT
--- LINT	1999/12/07 17:39:00	1.693
+++ LINT	1999/12/07 22:24:18
@@ -465,7 +465,7 @@
 options 	PPP_FILTER		#enable bpf filtering (needs bpf)
 
 # for IPv6
-pseudo-device	gif	4		#IPv6 and IPv4 tunneling
+#pseudo-device	gif	4		#IPv6 and IPv4 tunneling
 pseudo-device	faith	1		#for IPv6 and IPv4 translation
 
 #
Index: kern/kern_lock.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/kern_lock.c,v
retrieving revision 1.30
diff -u -r1.30 kern_lock.c
--- kern_lock.c	1999/11/11 03:02:03	1.30
+++ kern_lock.c	1999/12/07 23:47:49
@@ -511,15 +511,19 @@
  * Determine the status of a lock.
  */
 int
-lockstatus(lkp)
+lockstatus(lkp, p)
 	struct lock *lkp;
+	struct proc *p;
 {
 	int lock_type = 0;
 
 	simple_lock(&lkp->lk_interlock);
-	if (lkp->lk_exclusivecount != 0)
-		lock_type = LK_EXCLUSIVE;
-	else if (lkp->lk_sharecount != 0)
+	if (lkp->lk_exclusivecount != 0) {
+		if (p == NULL || lkp->lk_lockholder == p->p_pid)
+			lock_type = LK_EXCLUSIVE;
+		else
+			lock_type = LK_EXCLOTHER;
+	} else if (lkp->lk_sharecount != 0)
 		lock_type = LK_SHARED;
 	simple_unlock(&lkp->lk_interlock);
 	return (lock_type);
Index: kern/vfs_default.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/vfs_default.c,v
retrieving revision 1.24
diff -u -r1.24 vfs_default.c
--- vfs_default.c	1999/11/07 15:09:49	1.24
+++ vfs_default.c	1999/12/07 23:49:01
@@ -255,6 +255,7 @@
 vop_stdislocked(ap)
 	struct vop_islocked_args /* {
 		struct vnode *a_vp;
+		struct proc *a_p;
 	} */ *ap;
 {
 	struct lock *l;
@@ -262,7 +263,7 @@
 	if ((l = (struct lock *)ap->a_vp->v_data) == NULL)
 		return 0;
 
-	return (lockstatus(l));
+	return (lockstatus(l, ap->a_p));
 }
 
 /*
@@ -484,13 +485,14 @@
 vop_noislocked(ap)
 	struct vop_islocked_args /* {
 		struct vnode *a_vp;
+		struct proc *a_p;
 	} */ *ap;
 {
 	struct vnode *vp = ap->a_vp;
 
 	if (vp->v_vnlock == NULL)
 		return (0);
-	return (lockstatus(vp->v_vnlock));
+	return (lockstatus(vp->v_vnlock, ap->a_p));
 }
 
 /* 
Index: kern/vfs_subr.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/vfs_subr.c,v
retrieving revision 1.237
diff -u -r1.237 vfs_subr.c
--- vfs_subr.c	1999/11/29 22:25:36	1.237
+++ vfs_subr.c	1999/12/07 19:49:40
@@ -990,7 +990,7 @@
 		splx(s);
 
 		while ((vp = LIST_FIRST(slp)) != NULL) {
-			if (VOP_ISLOCKED(vp) == 0) {
+			if (VOP_ISLOCKED(vp, NULL) == 0) {
 				vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 				(void) VOP_FSYNC(vp, p->p_ucred, MNT_LAZY, p);
 				VOP_UNLOCK(vp, 0, p);
@@ -1962,7 +1962,7 @@
 			continue;
 		}
 		LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
-			if (VOP_ISLOCKED(vp))
+			if (VOP_ISLOCKED(vp, NULL))
 				vprint((char *)0, vp);
 		}
 		simple_lock(&mountlist_slock);
@@ -2450,7 +2450,7 @@
 			obj = vp->v_object;
 			if (obj == NULL || (obj->flags & OBJ_MIGHTBEDIRTY) == 0)
 				continue;
-			if (VOP_ISLOCKED(vp))
+			if (VOP_ISLOCKED(vp, NULL))
 				continue;
 		}
 
Index: kern/vnode_if.src
===================================================================
RCS file: /home/ncvs/src/sys/kern/vnode_if.src,v
retrieving revision 1.25
diff -u -r1.25 vnode_if.src
--- vnode_if.src	1999/11/13 20:58:11	1.25
+++ vnode_if.src	1999/12/07 23:50:24
@@ -43,7 +43,11 @@
 # "error" column defines the locking state on error exit.
 #
 # The locking value can take the following values:
-# L: locked.
+# L: locked; not converted to type of lock.
+# A: any lock type.
+# S: locked with shared lock.
+# E: locked with exclusive lock for this process.
+# O: locked with exclusive lock for other process.
 # U: unlocked.
 # -: not applicable.  vnode does not yet (or no longer) exists.
 # =: the same on input and output, may be either L or U.
@@ -55,6 +59,7 @@
 #
 vop_islocked {
 	IN struct vnode *vp;
+	IN struct proc *p;
 };
 
 #
Index: miscfs/devfs/devfs_vfsops.c
===================================================================
RCS file: /home/ncvs/src/sys/miscfs/devfs/devfs_vfsops.c,v
retrieving revision 1.40
diff -u -r1.40 devfs_vfsops.c
--- devfs_vfsops.c	1999/11/20 10:00:42	1.40
+++ devfs_vfsops.c	1999/12/07 19:49:47
@@ -264,7 +264,7 @@
 		if (vp->v_mount != mp)
 			goto loop;
 		nvp = vp->v_mntvnodes.le_next;
-		if (VOP_ISLOCKED(vp))
+		if (VOP_ISLOCKED(vp, NULL))
 			continue;
 		if (TAILQ_EMPTY(&vp->v_dirtyblkhd))
 			continue;
Index: miscfs/nullfs/null_vfsops.c
===================================================================
RCS file: /home/ncvs/src/sys/miscfs/nullfs/null_vfsops.c,v
retrieving revision 1.31
diff -u -r1.31 null_vfsops.c
--- null_vfsops.c	1999/09/11 00:46:01	1.31
+++ null_vfsops.c	1999/12/07 19:50:47
@@ -119,7 +119,7 @@
 	 * (XXX) VOP_ISLOCKED is needed?
 	 */
 	if ((mp->mnt_vnodecovered->v_op == null_vnodeop_p) &&
-		VOP_ISLOCKED(mp->mnt_vnodecovered)) {
+		VOP_ISLOCKED(mp->mnt_vnodecovered, NULL)) {
 		VOP_UNLOCK(mp->mnt_vnodecovered, 0, p);
 		isvnunlocked = 1;
 	}
@@ -132,7 +132,7 @@
 	/*
 	 * Re-lock vnode.
 	 */
-	if (isvnunlocked && !VOP_ISLOCKED(mp->mnt_vnodecovered))
+	if (isvnunlocked && !VOP_ISLOCKED(mp->mnt_vnodecovered, NULL))
 		vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY, p);
 
 	if (error)
@@ -296,7 +296,7 @@
 	 */
 	vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
 	VREF(vp);
-	if (VOP_ISLOCKED(vp)) {
+	if (VOP_ISLOCKED(vp, NULL)) {
 		/*
 		 * XXX
 		 * Should we check type of node?
Index: miscfs/nullfs/null_vnops.c
===================================================================
RCS file: /home/ncvs/src/sys/miscfs/nullfs/null_vnops.c,v
retrieving revision 1.37
diff -u -r1.37 null_vnops.c
--- null_vnops.c	1999/09/04 12:35:09	1.37
+++ null_vnops.c	1999/12/07 19:51:01
@@ -372,13 +372,13 @@
 	vp = *ap->a_vpp;
 	if (dvp == vp)
 		return (error);
-	if (!VOP_ISLOCKED(dvp)) {
+	if (!VOP_ISLOCKED(dvp, NULL)) {
 		unlockargs.a_vp = dvp;
 		unlockargs.a_flags = 0;
 		unlockargs.a_p = p;
 		vop_nounlock(&unlockargs);
 	}
-	if (vp != NULLVP && VOP_ISLOCKED(vp)) {
+	if (vp != NULLVP && VOP_ISLOCKED(vp, NULL)) {
 		lockargs.a_vp = vp;
 		lockargs.a_flags = LK_SHARED;
 		lockargs.a_p = p;
Index: miscfs/union/union_vfsops.c
===================================================================
RCS file: /home/ncvs/src/sys/miscfs/union/union_vfsops.c,v
retrieving revision 1.36
diff -u -r1.36 union_vfsops.c
--- union_vfsops.c	1999/09/26 20:52:41	1.36
+++ union_vfsops.c	1999/12/07 19:51:38
@@ -148,7 +148,8 @@
 	vrele(ndp->ni_dvp);
 	ndp->ni_dvp = NULL;
 
-	UDEBUG(("mount_root UPPERVP %p locked = %d\n", upperrootvp, VOP_ISLOCKED(upperrootvp)));
+	UDEBUG(("mount_root UPPERVP %p locked = %d\n", upperrootvp,
+	    VOP_ISLOCKED(upperrootvp, NULL)));
 
 	/*
 	 * Check multi union mount to avoid `lock myself again' panic.
@@ -396,7 +397,8 @@
 	 * root union_node being locked.  We let union_allocvp() deal with
 	 * it.
 	 */
-	UDEBUG(("union_root UPPERVP %p locked = %d\n", um->um_uppervp, VOP_ISLOCKED(um->um_uppervp)));
+	UDEBUG(("union_root UPPERVP %p locked = %d\n", um->um_uppervp,
+	    VOP_ISLOCKED(um->um_uppervp, NULL)));
 
 	VREF(um->um_uppervp);
 	if (um->um_lowervp)
@@ -405,7 +407,8 @@
 	error = union_allocvp(vpp, mp, NULLVP, NULLVP, NULL, 
 		    um->um_uppervp, um->um_lowervp, 1);
 	UDEBUG(("error %d\n", error));
-	UDEBUG(("union_root2 UPPERVP %p locked = %d\n", um->um_uppervp, VOP_ISLOCKED(um->um_uppervp)));
+	UDEBUG(("union_root2 UPPERVP %p locked = %d\n", um->um_uppervp,
+	    VOP_ISLOCKED(um->um_uppervp, NULL)));
 
 	return (error);
 }
Index: miscfs/union/union_vnops.c
===================================================================
RCS file: /home/ncvs/src/sys/miscfs/union/union_vnops.c,v
retrieving revision 1.69
diff -u -r1.69 union_vnops.c
--- union_vnops.c	1999/11/18 09:07:30	1.69
+++ union_vnops.c	1999/12/07 21:55:03
@@ -365,10 +365,10 @@
 		    uerror,
 		    upperdvp,
 		    upperdvp->v_usecount,
-		    VOP_ISLOCKED(upperdvp),
+		    VOP_ISLOCKED(upperdvp, NULL),
 		    uppervp,
 		    (uppervp ? uppervp->v_usecount : -99),
-		    (uppervp ? VOP_ISLOCKED(uppervp) : -99)
+		    (uppervp ? VOP_ISLOCKED(uppervp, NULL) : -99)
 		));
 
 		/*
@@ -1700,7 +1700,7 @@
 	struct componentname *cnp = ap->a_cnp;
 	struct proc *p = cnp->cn_proc;
 	struct union_node *un = VTOUNION(ap->a_dvp);
-	int islocked = VOP_ISLOCKED(ap->a_dvp);
+	int islocked = VOP_ISLOCKED(ap->a_dvp, NULL);
 	struct vnode *vp;
 	int error;
 
@@ -1852,7 +1852,7 @@
 	 */
 
 	if ((un->un_flags & UN_ULOCK) && 
-	    lockstatus(&un->un_lock) != LK_EXCLUSIVE) {
+	    lockstatus(&un->un_lock, NULL) != LK_EXCLUSIVE) {
 		un->un_flags &= ~UN_ULOCK;
 		VOP_UNLOCK(un->un_uppervp, LK_EXCLUSIVE, p);
 	}
Index: nfs/nfs_node.c
===================================================================
RCS file: /home/ncvs/src/sys/nfs/nfs_node.c,v
retrieving revision 1.32
diff -u -r1.32 nfs_node.c
--- nfs_node.c	1999/08/28 00:49:57	1.32
+++ nfs_node.c	1999/12/07 23:52:11
@@ -380,6 +380,7 @@
 nfs_islocked(ap)
 	struct vop_islocked_args /* {
 		struct vnode *a_vp;
+		struct proc *a_p;
 	} */ *ap;
 {
 	return VTONFS(ap->a_vp)->n_flag & NLOCKED ? 1 : 0;
Index: nfs/nfs_vfsops.c
===================================================================
RCS file: /home/ncvs/src/sys/nfs/nfs_vfsops.c,v
retrieving revision 1.88
diff -u -r1.88 nfs_vfsops.c
--- nfs_vfsops.c	1999/11/01 23:55:38	1.88
+++ nfs_vfsops.c	1999/12/07 19:52:07
@@ -1062,7 +1062,7 @@
 		 */
 		if (vp->v_mount != mp)
 			goto loop;
-		if (VOP_ISLOCKED(vp) || TAILQ_EMPTY(&vp->v_dirtyblkhd) ||
+		if (VOP_ISLOCKED(vp, NULL) || TAILQ_EMPTY(&vp->v_dirtyblkhd) ||
 		    waitfor == MNT_LAZY)
 			continue;
 		if (vget(vp, LK_EXCLUSIVE, p))
Index: nwfs/nwfs_vfsops.c
===================================================================
RCS file: /home/ncvs/src/sys/nwfs/nwfs_vfsops.c,v
retrieving revision 1.3
diff -u -r1.3 nwfs_vfsops.c
--- nwfs_vfsops.c	1999/11/02 22:46:42	1.3
+++ nwfs_vfsops.c	1999/12/07 19:52:16
@@ -498,7 +498,7 @@
 		 */
 		if (vp->v_mount != mp)
 			goto loop;
-		if (VOP_ISLOCKED(vp) || TAILQ_EMPTY(&vp->v_dirtyblkhd) ||
+		if (VOP_ISLOCKED(vp, NULL) || TAILQ_EMPTY(&vp->v_dirtyblkhd) ||
 		    waitfor == MNT_LAZY)
 			continue;
 		if (vget(vp, LK_EXCLUSIVE, p))
Index: sys/lock.h
===================================================================
RCS file: /home/ncvs/src/sys/sys/lock.h,v
retrieving revision 1.16
diff -u -r1.16 lock.h
--- lock.h	1999/08/28 00:51:50	1.16
+++ lock.h	1999/12/08 00:24:13
@@ -95,6 +95,8 @@
  *   LK_DRAIN - wait for all activity on the lock to end, then mark it
  *	decommissioned. This feature is used before freeing a lock that
  *	is part of a piece of memory that is about to be freed.
+ *   LK_EXCLOTHER - return for lockstatus().  Used when another process
+ *	holds the lock exclusively.
  *
  * These are flags that are passed to the lockmgr routine.
  */
@@ -106,6 +108,7 @@
 #define LK_DOWNGRADE	0x00000005	/* exclusive-to-shared downgrade */
 #define LK_RELEASE	0x00000006	/* release any type of lock */
 #define LK_DRAIN	0x00000007	/* wait for all lock activity to end */
+#define LK_EXCLOTHER	0x00000008	/* other process holds lock */
 /*
  * External lock flags.
  *
@@ -187,7 +190,7 @@
 			struct simplelock *, struct proc *p));
 #endif
 void	lockmgr_printinfo __P((struct lock *));
-int	lockstatus __P((struct lock *));
+int	lockstatus __P((struct lock *, struct proc *));
 int	lockcount __P((struct lock *));
 
 #ifdef SIMPLELOCK_DEBUG
Index: sys/vnode.h
===================================================================
RCS file: /home/ncvs/src/sys/sys/vnode.h,v
retrieving revision 1.103
diff -u -r1.103 vnode.h
--- vnode.h	1999/10/04 11:23:10	1.103
+++ vnode.h	1999/12/08 00:14:12
@@ -420,15 +420,56 @@
 				 || (vp)->v_tag == VT_MSDOSFS	\
 				 || (vp)->v_tag == VT_DEVFS)
 
-#define ASSERT_VOP_LOCKED(vp, str)				\
-    if ((vp) && IS_LOCKING_VFS(vp) && !VOP_ISLOCKED(vp)) {	\
-	panic("%s: %p is not locked but should be", str, vp);	\
-    }
+#define ASSERT_VOP_LOCKED(vp, str)					\
+do {									\
+	struct vnode *_vp = (vp);					\
+									\
+	if (_vp && IS_LOCKING_VFS(_vp) && !VOP_ISLOCKED(_vp, NULL))	\
+		panic("%s: %p is not locked but should be", str, _vp);	\
+} while (0)
 
-#define ASSERT_VOP_UNLOCKED(vp, str)				\
-    if ((vp) && IS_LOCKING_VFS(vp) && VOP_ISLOCKED(vp)) {	\
-	panic("%s: %p is locked but shouldn't be", str, vp);	\
-    }
+#define ASSERT_VOP_UNLOCKED(vp, str)					\
+do {									\
+	struct vnode *_vp = (vp);					\
+	int lockstate;							\
+									\
+	if (_vp && IS_LOCKING_VFS(_vp)) {				\
+		lockstate = VOP_ISLOCKED(_vp, curproc);			\
+		if (lockstate == LK_EXCLUSIVE)				\
+			panic("%s: %p is locked but should not be",	\
+			    str, _vp);					\
+	}								\
+} while (0)
+
+#define ASSERT_VOP_ELOCKED(vp, str)					\
+do {									\
+	struct vnode *_vp = (vp);					\
+									\
+	if (_vp && IS_LOCKING_VFS(_vp) &&				\
+	    VOP_ISLOCKED(_vp, curproc) != LK_EXCLUSIVE)			\
+		panic("%s: %p is not exclusive locked but should be",	\
+		    str, _vp);						\
+} while (0)
+
+#define ASSERT_VOP_ELOCKED_OTHER(vp, str)				\
+do {									\
+	struct vnode *_vp = (vp);					\
+									\
+	if (_vp && IS_LOCKING_VFS(_vp) &&				\
+	    VOP_ISLOCKED(_vp, curproc) != LK_EXCLOTHER)			\
+		panic("%s: %p is not exclusive locked by another proc",	\
+		    str, _vp);						\
+} while (0)
+
+#define ASSERT_VOP_SLOCKED(vp, str)					\
+do {									\
+	struct vnode *_vp = (vp);					\
+									\
+	if (_vp && IS_LOCKING_VFS(_vp) &&				\
+	    VOP_ISLOCKED(_vp, NULL) != LK_SHARED)			\
+		panic("%s: %p is not locked shared but should be",	\
+		    str, _vp);						\
+} while (0)
 
 #else
 
Index: vm/vm_pageout.c
===================================================================
RCS file: /home/ncvs/src/sys/vm/vm_pageout.c,v
retrieving revision 1.150
diff -u -r1.150 vm_pageout.c
--- vm_pageout.c	1999/10/30 07:37:14	1.150
+++ vm_pageout.c	1999/12/07 21:30:31
@@ -852,7 +852,7 @@
 			if (object->type == OBJT_VNODE) {
 				vp = object->handle;
 
-				if (VOP_ISLOCKED(vp) ||
+				if (VOP_ISLOCKED(vp, NULL) ||
 				    vp->v_data == NULL ||
 				    vget(vp, LK_EXCLUSIVE|LK_NOOBJ, curproc)) {
 					if ((m->queue == PQ_INACTIVE) &&
Index: vm/vm_zone.c
===================================================================
RCS file: /home/ncvs/src/sys/vm/vm_zone.c,v
retrieving revision 1.29
diff -u -r1.29 vm_zone.c
--- vm_zone.c	1999/10/29 18:09:35	1.29
+++ vm_zone.c	1999/12/07 21:55:28
@@ -324,7 +324,7 @@
 		 * We can wait, so just do normal map allocation in the appropriate
 		 * map.
 		 */
-		if (lockstatus(&kernel_map->lock)) {
+		if (lockstatus(&kernel_map->lock, NULL)) {
 			int s;
 			s = splvm();
 #ifdef SMP