--- //depot/vendor/freebsd/src/sys/dev/usb/ehci.c	2007/08/12 18:47:51
+++ //depot/user/attilio/attilio_lockmgr/dev/usb/ehci.c	2007/12/06 00:08:38
@@ -1560,7 +1560,7 @@
 	}
 	DPRINTFN(2,("ehci_sync_hc: enter\n"));
 	/* get doorbell */
-	lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE, NULL, NULL);
+	lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE | LK_USEKPROC, NULL);
 	s = splhardusb();
 	/* ask for doorbell */
 	EOWRITE4(sc, EHCI_USBCMD, EOREAD4(sc, EHCI_USBCMD) | EHCI_CMD_IAAD);
@@ -1571,7 +1571,7 @@
 		    EOREAD4(sc, EHCI_USBCMD), EOREAD4(sc, EHCI_USBSTS)));
 	splx(s);
 	/* release doorbell */
-	lockmgr(&sc->sc_doorbell_lock, LK_RELEASE, NULL, NULL);
+	lockmgr(&sc->sc_doorbell_lock, LK_RELEASE | LK_USEKPROC, NULL);
 #ifdef DIAGNOSTIC
 	if (error)
 		printf("ehci_sync_hc: tsleep() = %d\n", error);
--- //depot/vendor/freebsd/src/sys/dev/usb/if_udav.c	2007/07/24 14:46:54
+++ //depot/user/attilio/attilio_lockmgr/dev/usb/if_udav.c	2007/12/06 00:08:38
@@ -1780,7 +1780,7 @@
 #if defined(__NetBSD__)
 	lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE, NULL);
 #elif defined(__FreeBSD__)
-	lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE, NULL, NULL);
+	lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE | LK_USEKPROC, NULL);
 #endif
 }
 
@@ -1793,7 +1793,7 @@
 #if defined(__NetBSD__)
 	lockmgr(&sc->sc_mii_lock, LK_RELEASE, NULL);
 #elif defined(__FreeBSD__)
-	lockmgr(&sc->sc_mii_lock, LK_RELEASE, NULL, NULL);
+	lockmgr(&sc->sc_mii_lock, LK_RELEASE | LK_USEKPROC, NULL);
 #endif
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeup(sc->sc_dev);
--- //depot/vendor/freebsd/src/sys/fs/cd9660/cd9660_vfsops.c	2007/10/16 10:57:02
+++ //depot/user/attilio/attilio_lockmgr/fs/cd9660/cd9660_vfsops.c	2007/12/06 00:08:38
@@ -684,7 +684,7 @@
 	ip->i_vnode = vp;
 	ip->i_number = ino;
 
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mp);
 	if (error != 0) {
 		free(ip, M_ISOFSNODE);
--- //depot/vendor/freebsd/src/sys/fs/hpfs/hpfs_subr.h	2004/12/06 20:16:39
+++ //depot/user/attilio/attilio_lockmgr/fs/hpfs/hpfs_subr.h	2007/12/06 00:08:38
@@ -78,8 +78,8 @@
 	hpfs_breadstruct(hpmp, lsn, D_BSIZE, D_MAGIC, bpp)
 
 #if 0
-#define	hpfs_hplock(hp, p)	lockmgr(&(hp)->h_intlock, LK_EXCLUSIVE, (p), NULL)
-#define	hpfs_hpunlock(hp, p)	lockmgr(&(hp)->h_intlock, LK_RELEASE, (p), NULL)
+#define	hpfs_hplock(hp, p)	lockmgr(&(hp)->h_intlock, LK_EXCLUSIVE | LK_USEKPROC, (p))
+#define	hpfs_hpunlock(hp, p)	lockmgr(&(hp)->h_intlock, LK_RELEASE | LK_USEKPROC, (p))
 #endif
 
 int		hpfs_hpbmap (struct hpfsnode *, daddr_t, daddr_t *, int *);
--- //depot/vendor/freebsd/src/sys/fs/hpfs/hpfs_vfsops.c	2007/10/16 10:57:02
+++ //depot/user/attilio/attilio_lockmgr/fs/hpfs/hpfs_vfsops.c	2007/12/06 00:08:38
@@ -445,7 +445,6 @@
 	struct hpfsnode *hp;
 	struct buf *bp;
 	int error;
-	struct thread *td;
 
 	dprintf(("hpfs_vget(0x%x): ",ino));
 
@@ -499,14 +498,13 @@
 	hp->h_mode = hpmp->hpm_mode;
 	hp->h_devvp = hpmp->hpm_devvp;
 
-	td = curthread;
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mp);
 	if (error != 0) {
 		free(hp, M_HPFSNO);
 		return (error);
 	}
-	error = vfs_hash_insert(vp, ino, flags, td, vpp, NULL, NULL);
+	error = vfs_hash_insert(vp, ino, flags, curthread, vpp, NULL, NULL);
 	if (error || *vpp != NULL)
 		return (error);
 
--- //depot/vendor/freebsd/src/sys/fs/msdosfs/msdosfs_denode.c	2007/10/19 12:27:18
+++ //depot/user/attilio/attilio_lockmgr/fs/msdosfs/msdosfs_denode.c	2007/12/06 00:08:38
@@ -171,15 +171,14 @@
 	ldep->de_inode = inode;
 	fc_purge(ldep, 0);	/* init the fat cache for this denode */
 
-	td = curthread;
-	lockmgr(nvp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(nvp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(nvp, mntp);
 	if (error != 0) {
 		FREE(ldep, M_MSDOSFSNODE);
 		*depp = NULL;
 		return (error);
 	}
-	error = vfs_hash_insert(nvp, inode, LK_EXCLUSIVE, td, &xvp,
+	error = vfs_hash_insert(nvp, inode, LK_EXCLUSIVE, curthread, &xvp,
 	    de_vncmpf, &inode);
 	if (error) {
 		*depp = NULL;
--- //depot/vendor/freebsd/src/sys/fs/ntfs/ntfs_subr.c	2006/11/20 19:32:14
+++ //depot/user/attilio/attilio_lockmgr/fs/ntfs/ntfs_subr.c	2007/12/06 00:08:38
@@ -358,8 +358,8 @@
 
 	mtx_lock(&ip->i_interlock);
 	ip->i_usecount++;
-	lockmgr(&ip->i_lock, LK_EXCLUSIVE | LK_INTERLOCK, &ip->i_interlock,
-	    NULL);
+	lockmgr(&ip->i_lock, LK_EXCLUSIVE | LK_INTERLOCK | LK_USEKPROC,
+	    &ip->i_interlock);
 
 	return 0;
 }
@@ -390,8 +390,8 @@
 			*ipp = ip;
 			return (0);
 		}
-	} while (lockmgr(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL, NULL,
-	    NULL));
+	} while (lockmgr(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL |
+	    LK_USEKPROC, NULL));
 
 	MALLOC(ip, struct ntnode *, sizeof(struct ntnode), M_NTFSNTNODE,
 		M_WAITOK | M_ZERO);
@@ -413,7 +413,7 @@
 
 	ntfs_nthashins(ip);
 
-	lockmgr(&ntfs_hashlock, LK_RELEASE, NULL, NULL);
+	lockmgr(&ntfs_hashlock, LK_RELEASE | LK_USEKPROC, NULL);
 
 	*ipp = ip;
 
@@ -449,8 +449,8 @@
 #endif
 
 	if (ip->i_usecount > 0) {
-		lockmgr(&ip->i_lock, LK_RELEASE|LK_INTERLOCK, &ip->i_interlock,
-		    NULL);
+		lockmgr(&ip->i_lock, LK_RELEASE | LK_INTERLOCK | LK_USEKPROC,
+		    &ip->i_interlock);
 		return;
 	}
 
@@ -1982,7 +1982,7 @@
 	struct vnode *vp;
 
 	/* get exclusive access */
-	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL, NULL);
+	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE | LK_USEKPROC, NULL);
 	
 	/* only read the translation data from a file if it hasn't been
 	 * read already */
@@ -2005,7 +2005,7 @@
 
     out:
 	ntfs_toupper_usecount++;
-	lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL, NULL);
+	lockmgr(&ntfs_toupper_lock, LK_RELEASE | LK_USEKPROC, NULL);
 	return (error);
 }
 
@@ -2017,7 +2017,7 @@
 ntfs_toupper_unuse()
 {
 	/* get exclusive access */
-	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL, NULL);
+	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE | LK_USEKPROC, NULL);
 
 	ntfs_toupper_usecount--;
 	if (ntfs_toupper_usecount == 0) {
@@ -2032,7 +2032,7 @@
 #endif
 	
 	/* release the lock */
-	lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL, NULL);
+	lockmgr(&ntfs_toupper_lock, LK_RELEASE | LK_USEKPROC, NULL);
 } 
 
 int
--- //depot/vendor/freebsd/src/sys/fs/nwfs/nwfs_node.c	2007/03/13 01:54:24
+++ //depot/user/attilio/attilio_lockmgr/fs/nwfs/nwfs_node.c	2007/12/06 00:08:38
@@ -145,12 +145,12 @@
 	int error;
 
 loop:
-	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL);
 rescan:
 	if (nwfs_hashlookup(nmp, fid, &np) == 0) {
 		vp = NWTOV(np);
 		mtx_lock(&vp->v_interlock);
-		lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+		lockmgr(&nwhashlock, LK_RELEASE, NULL);
 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td))
 			goto loop;
 		if (fap)
@@ -158,7 +158,7 @@
 		*vpp = vp;
 		return(0);
 	}
-	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+	lockmgr(&nwhashlock, LK_RELEASE, NULL);
 
 	if (fap == NULL || ((fap->attributes & aDIR) == 0 && dvp == NULL))
 		panic("nwfs_allocvp: fap = %p, dvp = %p\n", fap, dvp);
@@ -190,7 +190,7 @@
 		np->n_parent = VTONW(dvp)->n_fid;
 	}
 	vp->v_vnlock->lk_flags |= LK_CANRECURSE;
-	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL);
 	/*
 	 * Another process can create vnode while we blocked in malloc() or
 	 * getnewvnode(). Rescan list again.
@@ -206,7 +206,7 @@
 	nhpp = NWNOHASH(fid);
 	LIST_INSERT_HEAD(nhpp, np, n_hash);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
-	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+	lockmgr(&nwhashlock, LK_RELEASE, NULL);
 	
 	ASSERT_VOP_LOCKED(dvp, "nwfs_allocvp");
 	if (vp->v_type == VDIR && dvp && (dvp->v_vflag & VV_ROOT) == 0) {
@@ -239,9 +239,13 @@
 {
 	int error;
 
-	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
+	lockmgr(&nwhashlock, LK_EXCLUSIVE | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 	error = nwfs_hashlookup(nmp, fid, npp);
-	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+	lockmgr(&nwhashlock, LK_RELEASE | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 	return error;
 }
 
@@ -274,9 +278,13 @@
 			NCPVNDEBUG("%s: has no parent ?\n",np->n_name);
 		}
 	}
-	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
+	lockmgr(&nwhashlock, LK_EXCLUSIVE | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 	LIST_REMOVE(np, n_hash);
-	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+	lockmgr(&nwhashlock, LK_RELEASE | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 	if (nmp->n_root == np) {
 		nmp->n_root = NULL;
 	}
--- //depot/vendor/freebsd/src/sys/fs/udf/udf_vfsops.c	2007/10/16 10:57:02
+++ //depot/user/attilio/attilio_lockmgr/fs/udf/udf_vfsops.c	2007/12/06 00:08:38
@@ -613,7 +613,7 @@
 	unode->udfmp = udfmp;
 	vp->v_data = unode;
 
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mp);
 	if (error != 0) {
 		uma_zfree(udf_zone_node, unode);
--- //depot/vendor/freebsd/src/sys/fs/unionfs/union_subr.c	2007/10/24 19:06:35
+++ //depot/user/attilio/attilio_lockmgr/fs/unionfs/union_subr.c	2007/12/06 00:08:38
@@ -198,7 +198,10 @@
 
 	vp->v_vnlock = &(vp->v_lock);
 	vp->v_data = NULL;
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_INTERLOCK, VI_MTX(vp), td);
+	KASSERT(td == NULL || td == curthread,
+	    ("%s: invalid vnode lock", __func__));
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_INTERLOCK | ((td == NULL) ?
+	    LK_USEKPROC : 0), VI_MTX(vp));
 	if (lvp != NULLVP)
 		VOP_UNLOCK(lvp, 0, td);
 	if (uvp != NULLVP)
--- //depot/vendor/freebsd/src/sys/fs/unionfs/union_vnops.c	2007/10/14 13:57:39
+++ //depot/user/attilio/attilio_lockmgr/fs/unionfs/union_vnops.c	2007/12/05 22:42:15
@@ -81,7 +81,6 @@
 	{LK_SHARED, LK_RELEASE},
 	{LK_EXCLUSIVE, LK_RELEASE},
 	{LK_UPGRADE, LK_DOWNGRADE},
-	{LK_EXCLUPGRADE, LK_DOWNGRADE},
 	{LK_DOWNGRADE, LK_UPGRADE},
 	{0, 0}
 };
--- //depot/vendor/freebsd/src/sys/gnu/fs/ext2fs/ext2_vfsops.c	2007/10/27 16:16:47
+++ //depot/user/attilio/attilio_lockmgr/gnu/fs/ext2fs/ext2_vfsops.c	2007/12/06 00:08:38
@@ -984,7 +984,7 @@
 	ip->i_e2fs = fs = ump->um_e2fs;
 	ip->i_number = ino;
 
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mp);
 	if (error != 0) {
 		free(ip, M_EXT2NODE);
--- //depot/vendor/freebsd/src/sys/gnu/fs/reiserfs/reiserfs_inode.c	2007/03/13 01:54:24
+++ //depot/user/attilio/attilio_lockmgr/gnu/fs/reiserfs/reiserfs_inode.c	2007/12/06 00:08:38
@@ -806,16 +806,11 @@
 #if 0
 	if (VOP_LOCK(vp, LK_EXCLUSIVE, td) != 0)
 		panic("reiserfs/iget: unexpected lock failure");
-
-	/*
-	 * Exclusively lock the vnode before adding to hash. Note, that we
-	 * must not release nor downgrade the lock (despite flags argument
-	 * says) till it is fully initialized.
-	 */
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, (struct mtx *)0, td);
 #endif
 
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mp);
 	if (error != 0) {
 		free(ip, M_REISERFSNODE);
--- //depot/vendor/freebsd/src/sys/kern/kern_lock.c	2007/12/01 22:06:21
+++ //depot/user/attilio/attilio_lockmgr/kern/kern_lock.c	2007/12/06 01:46:46
@@ -105,7 +105,6 @@
 	panic("lockmgr locks do not support sleep interlocking");
 }
 
-#define	COUNT(td, x)	if ((td)) (td)->td_locks += (x)
 #define LK_ALL (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE | \
 	LK_SHARE_NONZERO | LK_WAIT_NONZERO)
 
@@ -113,18 +112,16 @@
 static int acquiredrain(struct lock *lkp, int extflags) ;
 
 static __inline void
-sharelock(struct thread *td, struct lock *lkp, int incr) {
+sharelock(struct lock *lkp, int incr) {
 	lkp->lk_flags |= LK_SHARE_NONZERO;
 	lkp->lk_sharecount += incr;
-	COUNT(td, incr);
 }
 
 static __inline void
-shareunlock(struct thread *td, struct lock *lkp, int decr) {
+shareunlock(struct lock *lkp, int decr) {
 
 	KASSERT(lkp->lk_sharecount >= decr, ("shareunlock: count < decr"));
 
-	COUNT(td, -decr);
 	if (lkp->lk_sharecount == decr) {
 		lkp->lk_flags &= ~LK_SHARE_NONZERO;
 		if (lkp->lk_flags & (LK_WANT_UPGRADE | LK_WANT_EXCL)) {
@@ -189,8 +186,8 @@
  * accepted shared locks and shared-to-exclusive upgrades to go away.
  */
 int
-_lockmgr(struct lock *lkp, u_int flags, struct mtx *interlkp, 
-	 struct thread *td, char *file, int line)
+_lockmgr(struct lock *lkp, u_int flags, struct mtx *interlkp, char *file,
+    int line)
 
 {
 	int error;
@@ -200,17 +197,17 @@
 	uint64_t waitstart = 0;
 	
 	error = 0;
-	if (td == NULL)
+	if (flags & LK_USEKPROC)
 		thr = LK_KERNPROC;
 	else
-		thr = td;
+		thr = curthread;
 
 	if ((flags & LK_INTERNAL) == 0)
 		mtx_lock(lkp->lk_interlock);
 	CTR6(KTR_LOCK,
 	    "lockmgr(): lkp == %p (lk_wmesg == \"%s\"), owner == %p, exclusivecount == %d, flags == 0x%x, "
 	    "td == %p", lkp, lkp->lk_wmesg, lkp->lk_lockholder,
-	    lkp->lk_exclusivecount, flags, td);
+	    lkp->lk_exclusivecount, flags, thr);
 #ifdef DEBUG_LOCKS
 	{
 		struct stack stack; /* XXX */
@@ -254,12 +251,12 @@
 		 */
 		if (lkp->lk_lockholder != thr) {
 			lockflags = LK_HAVE_EXCL;
-			if (td != NULL && !(td->td_pflags & TDP_DEADLKTREAT))
+			if (thr != NULL && !(thr->td_pflags & TDP_DEADLKTREAT))
 				lockflags |= LK_WANT_EXCL | LK_WANT_UPGRADE;
 			error = acquire(&lkp, extflags, lockflags, &contested, &waitstart);
 			if (error)
 				break;
-			sharelock(td, lkp, 1);
+			sharelock(lkp, 1);
 			if (lkp->lk_sharecount == 1)
 				lock_profile_obtain_lock_success(&lkp->lk_object, contested, waitstart, file, line);
 
@@ -272,7 +269,7 @@
 		 * We hold an exclusive lock, so downgrade it to shared.
 		 * An alternative would be to fail with EDEADLK.
 		 */
-		sharelock(td, lkp, 1);
+		sharelock(lkp, 1);
 		if (lkp->lk_sharecount == 1)
 			lock_profile_obtain_lock_success(&lkp->lk_object, contested, waitstart, file, line);
 		/* FALLTHROUGH downgrade */
@@ -282,8 +279,7 @@
 			("lockmgr: not holding exclusive lock "
 			"(owner thread (%p) != thread (%p), exlcnt (%d) != 0",
 			lkp->lk_lockholder, thr, lkp->lk_exclusivecount));
-		sharelock(td, lkp, lkp->lk_exclusivecount);
-		COUNT(td, -lkp->lk_exclusivecount);
+		sharelock(lkp, lkp->lk_exclusivecount);
 		lkp->lk_exclusivecount = 0;
 		lkp->lk_flags &= ~LK_HAVE_EXCL;
 		lkp->lk_lockholder = LK_NOPROC;
@@ -291,19 +287,6 @@
 			wakeup((void *)lkp);
 		break;
 
-	case LK_EXCLUPGRADE:
-		/*
-		 * If another process is ahead of us to get an upgrade,
-		 * then we want to fail rather than have an intervening
-		 * exclusive access.
-		 */
-		if (lkp->lk_flags & LK_WANT_UPGRADE) {
-			shareunlock(td, lkp, 1);
-			error = EBUSY;
-			break;
-		}
-		/* FALLTHROUGH normal upgrade */
-
 	case LK_UPGRADE:
 		/*
 		 * Upgrade a shared lock to an exclusive one. If another
@@ -317,7 +300,7 @@
 			panic("lockmgr: upgrade exclusive lock");
 		if (lkp->lk_sharecount <= 0)
 			panic("lockmgr: upgrade without shared");
-		shareunlock(td, lkp, 1);
+		shareunlock(lkp, 1);
 		if (lkp->lk_sharecount == 0)
 			lock_profile_release_lock(&lkp->lk_object);
 		/*
@@ -349,7 +332,6 @@
 			lkp->lk_flags |= LK_HAVE_EXCL;
 			lkp->lk_lockholder = thr;
 			lkp->lk_exclusivecount = 1;
-			COUNT(td, 1);
 			lock_profile_obtain_lock_success(&lkp->lk_object, contested, waitstart, file, line);
 #if defined(DEBUG_LOCKS)
 			stack_save(&lkp->lk_stack);
@@ -375,7 +357,6 @@
 				panic("lockmgr: locking against myself");
 			if ((extflags & LK_CANRECURSE) != 0) {
 				lkp->lk_exclusivecount++;
-				COUNT(td, 1);
 				break;
 			}
 		}
@@ -409,7 +390,6 @@
 		if (lkp->lk_exclusivecount != 0)
 			panic("lockmgr: non-zero exclusive count");
 		lkp->lk_exclusivecount = 1;
-		COUNT(td, 1);
 		lock_profile_obtain_lock_success(&lkp->lk_object, contested, waitstart, file, line);
 #if defined(DEBUG_LOCKS)
 		stack_save(&lkp->lk_stack);
@@ -424,8 +404,6 @@
 				    thr, "exclusive lock holder",
 				    lkp->lk_lockholder);
 			}
-			if (lkp->lk_lockholder != LK_KERNPROC)
-				COUNT(td, -1);
 			if (lkp->lk_exclusivecount == 1) {
 				lkp->lk_flags &= ~LK_HAVE_EXCL;
 				lkp->lk_lockholder = LK_NOPROC;
@@ -435,7 +413,7 @@
 				lkp->lk_exclusivecount--;
 			}
 		} else if (lkp->lk_flags & LK_SHARE_NONZERO)
-			shareunlock(td, lkp, 1);
+			shareunlock(lkp, 1);
 		else  {
 			printf("lockmgr: thread %p unlocking unheld lock\n",
 			    thr);
@@ -462,7 +440,6 @@
 		lkp->lk_flags |= LK_DRAINING | LK_HAVE_EXCL;
 		lkp->lk_lockholder = thr;
 		lkp->lk_exclusivecount = 1;
-		COUNT(td, 1);
 #if defined(DEBUG_LOCKS)
 		stack_save(&lkp->lk_stack);
 #endif
--- //depot/vendor/freebsd/src/sys/kern/vfs_default.c	2007/05/18 13:08:33
+++ //depot/user/attilio/attilio_lockmgr/kern/vfs_default.c	2007/12/06 01:46:46
@@ -262,8 +262,12 @@
 	} */ *ap;
 {
 	struct vnode *vp = ap->a_vp;
+	int oflag = ((ap->a_td == NULL) ? LK_USEKPROC : 0);
 
-	return (_lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), ap->a_td, ap->a_file, ap->a_line));
+	KASSERT(ap->a_td == NULL || ap->a_td == curthread,
+	    ("%s: invalid vnode lock", __func__));
+	return (_lockmgr(vp->v_vnlock, ap->a_flags | oflag, VI_MTX(vp),
+	    ap->a_file, ap->a_line));
 }
 
 /* See above. */
@@ -276,9 +280,12 @@
 	} */ *ap;
 {
 	struct vnode *vp = ap->a_vp;
+	int oflag = ((ap->a_td == NULL) ? LK_USEKPROC : 0);
 
-	return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp),
-	    ap->a_td));
+	KASSERT(ap->a_td == NULL || ap->a_td == curthread,
+	    ("%s: invalid vnode lock", __func__));
+	return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE | oflag,
+	    VI_MTX(vp)));
 }
 
 /* See above. */
--- //depot/vendor/freebsd/src/sys/kern/vfs_mount.c	2007/12/05 03:27:31
+++ //depot/user/attilio/attilio_lockmgr/kern/vfs_mount.c	2007/12/06 00:08:38
@@ -1238,8 +1238,11 @@
 	/* Allow filesystems to detect that a forced unmount is in progress. */
 	if (flags & MNT_FORCE)
 		mp->mnt_kern_flag |= MNTK_UNMOUNTF;
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
 	error = lockmgr(&mp->mnt_lock, LK_DRAIN | LK_INTERLOCK |
-	    ((flags & MNT_FORCE) ? 0 : LK_NOWAIT), MNT_MTX(mp), td);
+	    ((flags & MNT_FORCE) ? 0 : LK_NOWAIT) | ((td == NULL) ?
+	    LK_USEKPROC : 0), MNT_MTX(mp));
 	if (error) {
 		MNT_ILOCK(mp);
 		mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_NOINSMNTQ |
@@ -1309,7 +1312,8 @@
 		mp->mnt_flag |= async_flag;
 		if ((mp->mnt_flag & MNT_ASYNC) != 0 && mp->mnt_noasync == 0)
 			mp->mnt_kern_flag |= MNTK_ASYNC;
-		lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td);
+		lockmgr(&mp->mnt_lock, LK_RELEASE | ((td == NULL) ?
+		    LK_USEKPROC : 0), NULL);
 		if (mp->mnt_kern_flag & MNTK_MWAIT)
 			wakeup(mp);
 		MNT_IUNLOCK(mp);
@@ -1325,7 +1329,8 @@
 		vput(coveredvp);
 	}
 	vfs_event_signal(NULL, VQ_UNMOUNT, 0);
-	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td);
+	lockmgr(&mp->mnt_lock, LK_RELEASE | ((td == NULL) ?  LK_USEKPROC : 0),
+	    NULL);
 	vfs_mount_destroy(mp);
 	return (0);
 }
--- //depot/vendor/freebsd/src/sys/kern/vfs_subr.c	2007/12/05 09:35:47
+++ //depot/user/attilio/attilio_lockmgr/kern/vfs_subr.c	2007/12/06 00:08:38
@@ -360,8 +360,10 @@
 	}
 	if (interlkp)
 		mtx_unlock(interlkp);
-	lkflags = LK_SHARED | LK_INTERLOCK;
-	if (lockmgr(&mp->mnt_lock, lkflags, MNT_MTX(mp), td))
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
+	lkflags = LK_SHARED | LK_INTERLOCK | ((td == NULL) ? LK_USEKPROC : 0);
+	if (lockmgr(&mp->mnt_lock, lkflags, MNT_MTX(mp)))
 		panic("vfs_busy: unexpected lock failure");
 	return (0);
 }
@@ -373,7 +375,10 @@
 vfs_unbusy(struct mount *mp, struct thread *td)
 {
 
-	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
+	lockmgr(&mp->mnt_lock, LK_RELEASE | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 	vfs_rel(mp);
 }
 
@@ -2210,7 +2215,7 @@
 	v_decr_useonly(vp);
 	vp->v_iflag |= VI_OWEINACT;
 	if (VOP_ISLOCKED(vp, NULL) != LK_EXCLUSIVE) {
-		error = VOP_LOCK(vp, LK_EXCLUPGRADE|LK_INTERLOCK|LK_NOWAIT, td);
+		error = VOP_LOCK(vp, LK_UPGRADE|LK_INTERLOCK|LK_NOWAIT, td);
 		VI_LOCK(vp);
 		if (error) {
 			if (vp->v_usecount > 0)
--- //depot/vendor/freebsd/src/sys/netncp/ncp_conn.c	2007/05/27 17:17:53
+++ //depot/user/attilio/attilio_lockmgr/netncp/ncp_conn.c	2007/12/06 00:08:38
@@ -99,13 +99,19 @@
 int
 ncp_conn_locklist(int flags, struct thread *td)
 {
-	return lockmgr(&listlock, flags | LK_CANRECURSE, 0, td);
+
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__);
+	return lockmgr(&listlock, flags | LK_CANRECURSE | ((td == NULL) ?
+	    LK_USEKPROC : 0), NULL);
 }
 
 void
 ncp_conn_unlocklist(struct thread *td)
 {
-	lockmgr(&listlock, LK_RELEASE, 0, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__);
+	lockmgr(&listlock, LK_RELEASE | ((td == NULL) ? LK_USEKPROC : 0), NULL);
 }
 
 int
@@ -126,20 +132,24 @@
 int
 ncp_conn_lock_any(struct ncp_conn *conn, struct thread *td, struct ucred *cred)
 {
-	int error;
+	int error, oflag;
 
 	if (conn->nc_id == 0) return EACCES;
-	error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE, 0, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__);
+	oflag = ((td == NULL) ? LK_USEKPROC : 0);
+	error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE | oflag,
+	    NULL);
 	if (error == ERESTART)
 		return EINTR;
 	error = ncp_chkintr(conn, td);
 	if (error) {
-		lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
+		lockmgr(&conn->nc_lock, LK_RELEASE | oflag, NULL);
 		return error;
 	}
 
 	if (conn->nc_id == 0) {
-		lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
+		lockmgr(&conn->nc_lock, LK_RELEASE | oflag, NULL);
 		return EACCES;
 	}
 	conn->td = td;		/* who currently operates */
@@ -187,7 +197,10 @@
 	 * note, that LK_RELASE will do wakeup() instead of wakeup_one().
 	 * this will do a little overhead
 	 */
-	lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__);
+	lockmgr(&conn->nc_lock, LK_RELEASE | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 }
 
 int
@@ -301,7 +314,10 @@
 	/*
 	 * if signal is raised - how I do react ?
 	 */
-	lockmgr(&ncp->nc_lock, LK_DRAIN, 0, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__);
+	lockmgr(&ncp->nc_lock, LK_DRAIN | ((td == NULL) ? LK_USEKPROC : 0),
+	    NULL);
 	lockdestroy(&ncp->nc_lock);
 	while (ncp->nc_lwant) {
 		printf("lwant = %d\n", ncp->nc_lwant);
@@ -524,15 +540,19 @@
 ncp_conn_gethandle(struct ncp_conn *conn, struct thread *td, struct ncp_handle **handle)
 {
 	struct ncp_handle *refp;
+	int oflag;
 
-	lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__);
+	oflag = ((td == NULL) ? LK_USEKPROC : 0);
+	lockmgr(&lhlock, LK_EXCLUSIVE | oflag, NULL);
 	SLIST_FOREACH(refp, &lhlist, nh_next)
 		if (refp->nh_conn == conn && td == refp->nh_td) break;
 	if (refp) {
 		conn->ref_cnt++;
 		refp->nh_ref++;
 		*handle = refp;
-		lockmgr(&lhlock, LK_RELEASE, 0, td);
+		lockmgr(&lhlock, LK_RELEASE | oflag, 0, td);
 		return 0;
 	}
 	MALLOC(refp,struct ncp_handle *,sizeof(struct ncp_handle),M_NCPDATA,
@@ -544,7 +564,7 @@
 	refp->nh_id = ncp_next_handle++;
 	*handle = refp;
 	conn->ref_cnt++;
-	lockmgr(&lhlock, LK_RELEASE, 0, td);
+	lockmgr(&lhlock, LK_RELEASE | oflag, NULL);
 	return 0;
 }
 /*
@@ -554,8 +574,9 @@
 ncp_conn_puthandle(struct ncp_handle *handle, struct thread *td, int force)
 {
 	struct ncp_handle *refp = handle;
+	int oflag = ((td == NULL) ? LK_USEKPROC : 0);
 
-	lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
+	lockmgr(&lhlock, LK_EXCLUSIVE | oflag, NULL);
 	refp->nh_ref--;
 	refp->nh_conn->ref_cnt--;
 	if (force) {
@@ -566,7 +587,7 @@
 		SLIST_REMOVE(&lhlist, refp, ncp_handle, nh_next);
 		FREE(refp, M_NCPDATA);
 	}
-	lockmgr(&lhlock, LK_RELEASE, 0, td);
+	lockmgr(&lhlock, LK_RELEASE | oflag, NULL);
 	return 0;
 }
 /*
--- //depot/vendor/freebsd/src/sys/nfs4client/nfs4_idmap.c	2005/01/07 01:52:23
+++ //depot/user/attilio/attilio_lockmgr/nfs4client/nfs4_idmap.c	2007/12/06 00:08:38
@@ -74,9 +74,9 @@
 	struct lock hash_lock;
 };
 
-#define IDMAP_RLOCK(lock) lockmgr(lock, LK_SHARED, NULL, curthread)
-#define IDMAP_WLOCK(lock) lockmgr(lock, LK_EXCLUSIVE, NULL, curthread)
-#define IDMAP_UNLOCK(lock) lockmgr(lock, LK_RELEASE, NULL, curthread)
+#define IDMAP_RLOCK(lock) lockmgr(lock, LK_SHARED, NULL)
+#define IDMAP_WLOCK(lock) lockmgr(lock, LK_EXCLUSIVE, NULL)
+#define IDMAP_UNLOCK(lock) lockmgr(lock, LK_RELEASE, NULL)
 
 
 static struct idmap_hash idmap_uid_hash;
--- //depot/vendor/freebsd/src/sys/nfsclient/nfs_node.c	2007/03/13 01:54:24
+++ //depot/user/attilio/attilio_lockmgr/nfsclient/nfs_node.c	2007/12/06 00:08:38
@@ -166,7 +166,7 @@
 		np->n_fhp = &np->n_fh;
 	bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
 	np->n_fhsize = fhsize;
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mntp);
 	if (error != 0) {
 		*npp = NULL;
--- //depot/vendor/freebsd/src/sys/sys/buf.h	2007/03/08 06:46:41
+++ //depot/user/attilio/attilio_lockmgr/sys/buf.h	2007/12/06 01:46:46
@@ -277,7 +277,7 @@
 	locktype |= LK_INTERNAL;
 	bp->b_lock.lk_wmesg = buf_wmesg;
 	bp->b_lock.lk_prio = PRIBIO + 4;
-	ret = lockmgr(&(bp)->b_lock, locktype, interlock, curthread);
+	ret = lockmgr(&(bp)->b_lock, locktype, interlock);
 	splx(s);
 	return ret;
 }
@@ -298,7 +298,7 @@
 	bp->b_lock.lk_wmesg = wmesg;
 	bp->b_lock.lk_prio = (PRIBIO + 4) | catch;
 	bp->b_lock.lk_timo = timo;
-	ret = lockmgr(&(bp)->b_lock, (locktype), interlock, curthread);
+	ret = lockmgr(&(bp)->b_lock, (locktype), interlock);
 	splx(s);
 	return ret;
 }
@@ -315,7 +315,7 @@
 	s = splbio();
 	KASSERT((bp->b_flags & B_REMFREE) == 0,
 	    ("BUF_UNLOCK %p while B_REMFREE is still set.", bp));
-	lockmgr(&(bp)->b_lock, LK_RELEASE, NULL, curthread);
+	lockmgr(&(bp)->b_lock, LK_RELEASE, NULL);
 	splx(s);
 }
 
@@ -340,10 +340,6 @@
 static __inline void
 BUF_KERNPROC(struct buf *bp)
 {
-	struct thread *td = curthread;
-
-	if (!TD_IS_IDLETHREAD(td) && bp->b_lock.lk_lockholder == td)
-		td->td_locks--;
 	bp->b_lock.lk_lockholder = LK_KERNPROC;
 }
 #endif
--- //depot/vendor/freebsd/src/sys/sys/lockmgr.h	2007/11/24 04:26:49
+++ //depot/user/attilio/attilio_lockmgr/sys/lockmgr.h	2007/12/06 01:46:46
@@ -84,12 +84,6 @@
  *	have upgraded to an exclusive lock. Other processes may get
  *	exclusive access to the resource between the time that the upgrade
  *	is requested and the time that it is granted.
- *   LK_EXCLUPGRADE - the process must hold a shared lock that it wants to
- *	have upgraded to an exclusive lock. If the request succeeds, no
- *	other processes will have gotten exclusive access to the resource
- *	between the time that the upgrade is requested and the time that
- *	it is granted. However, if another process has already requested
- *	an upgrade, the request will fail (see error returns below).
  *   LK_DOWNGRADE - the process must hold an exclusive lock that it wants
  *	to have downgraded to a shared lock. If the process holds multiple
  *	(recursive) exclusive locks, they will all be downgraded to shared
@@ -107,7 +101,6 @@
 #define	LK_SHARED	0x00000001	/* shared lock */
 #define	LK_EXCLUSIVE	0x00000002	/* exclusive lock */
 #define	LK_UPGRADE	0x00000003	/* shared-to-exclusive upgrade */
-#define	LK_EXCLUPGRADE	0x00000004	/* first shared-to-exclusive upgrade */
 #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 */
@@ -124,6 +117,8 @@
 #define	LK_CANRECURSE	0x00000040	/* allow recursive exclusive lock */
 #define	LK_NOSHARE	0x00000080	/* Only allow exclusive locks */
 #define	LK_TIMELOCK	0x00000100	/* use lk_timo, else no timeout */
+#define	LK_USEKPROC	0x00000200	/* LK_KERNPROC as lock owner */
+
 /*
  * Nonpersistent external flags.
  */
@@ -202,14 +197,14 @@
 			int timo, int flags);
 void	lockdestroy(struct lock *);
 
-int	_lockmgr(struct lock *, u_int flags,
-		 struct mtx *, struct thread *p, char *file, int line);
+int	_lockmgr(struct lock *, u_int flags, struct mtx *, char *file,
+	    int line);
 void	lockmgr_printinfo(struct lock *);
 int	lockstatus(struct lock *, struct thread *);
 int	lockcount(struct lock *);
 int	lockwaiters(struct lock *);
 
-#define lockmgr(lock, flags, mtx, td) _lockmgr((lock), (flags), (mtx), (td), __FILE__, __LINE__)
+#define lockmgr(lock, flags, mtx) _lockmgr((lock), (flags), (mtx), __FILE__, __LINE__)
 #ifdef DDB
 int	lockmgr_chain(struct thread *td, struct thread **ownerp);
 #endif
--- //depot/vendor/freebsd/src/sys/ufs/ffs/ffs_snapshot.c	2007/11/08 17:23:44
+++ //depot/user/attilio/attilio_lockmgr/ufs/ffs/ffs_snapshot.c	2007/12/06 01:46:46
@@ -631,8 +631,8 @@
 		xp = NULL;
 	}
 	lockmgr(vp->v_vnlock, LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY,
-	    VI_MTX(vp), td);
-	lockmgr(&vp->v_lock, LK_RELEASE, NULL, td);
+	    VI_MTX(vp));
+	lockmgr(&vp->v_lock, LK_RELEASE, NULL);
 	/*
 	 * If this is the first snapshot on this filesystem, then we need
 	 * to allocate the space for the list of preallocated snapshot blocks.
@@ -1591,14 +1591,14 @@
 		TAILQ_REMOVE(&sn->sn_head, ip, i_nextsnap);
 		ip->i_nextsnap.tqe_prev = 0;
 		VI_UNLOCK(devvp);
-		lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL, td);
+		lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL);
 		VI_LOCK(vp);
 		KASSERT(vp->v_vnlock == &sn->sn_lock,
 			("ffs_snapremove: lost lock mutation")); 
 		vp->v_vnlock = &vp->v_lock;
 		VI_UNLOCK(vp);
 		VI_LOCK(devvp);
-		lockmgr(&sn->sn_lock, LK_RELEASE, NULL, td);
+		lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
 		try_free_snapdata(devvp, td);
 	} else
 		VI_UNLOCK(devvp);
@@ -1720,7 +1720,7 @@
 	}
 	if (lockmgr(&sn->sn_lock,
 		    LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
-		    VI_MTX(devvp), td) != 0)
+		    VI_MTX(devvp)) != 0)
 		goto retry;
 	TAILQ_FOREACH(ip, &sn->sn_head, i_nextsnap) {
 		vp = ITOV(ip);
@@ -1807,7 +1807,7 @@
 			}
 			DIP_SET(ip, i_blocks, DIP(ip, i_blocks) + btodb(size));
 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
-			lockmgr(vp->v_vnlock, LK_RELEASE, NULL, td);
+			lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
 			return (1);
 		}
 		if (lbn >= NDADDR)
@@ -1873,7 +1873,7 @@
 	 * not be freed. Although space will be lost, the snapshot
 	 * will stay consistent.
 	 */
-	lockmgr(vp->v_vnlock, LK_RELEASE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
 	return (error);
 }
 
@@ -1965,8 +1965,8 @@
 			devvp->v_rdev->si_snapdata = sn;
 		}
 		lockmgr(vp->v_vnlock, LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY,
-		    VI_MTX(vp), td);
-		lockmgr(&vp->v_lock, LK_RELEASE, NULL, td);
+		    VI_MTX(vp));
+		lockmgr(&vp->v_lock, LK_RELEASE, NULL);
 		/*
 		 * Link it onto the active snapshot list.
 		 */
@@ -2048,21 +2048,17 @@
 		vp = ITOV(xp);
 		TAILQ_REMOVE(&sn->sn_head, xp, i_nextsnap);
 		xp->i_nextsnap.tqe_prev = 0;
-		lockmgr(&sn->sn_lock, 
-			LK_INTERLOCK | LK_EXCLUSIVE,
-			VI_MTX(devvp),
-			td);
+		lockmgr(&sn->sn_lock, LK_INTERLOCK | LK_EXCLUSIVE,
+		    VI_MTX(devvp));
 		VI_LOCK(vp);
-		lockmgr(&vp->v_lock,
-			LK_INTERLOCK | LK_EXCLUSIVE,
-			VI_MTX(vp), td);
+		lockmgr(&vp->v_lock, LK_INTERLOCK | LK_EXCLUSIVE, VI_MTX(vp));
 		VI_LOCK(vp);
 		KASSERT(vp->v_vnlock == &sn->sn_lock,
 		("ffs_snapshot_unmount: lost lock mutation")); 
 		vp->v_vnlock = &vp->v_lock;
 		VI_UNLOCK(vp);
-		lockmgr(&vp->v_lock, LK_RELEASE, NULL, td);
-		lockmgr(&sn->sn_lock, LK_RELEASE, NULL, td);
+		lockmgr(&vp->v_lock, LK_RELEASE, NULL);
+		lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
 		if (xp->i_effnlink > 0)
 			vrele(vp);
 		VI_LOCK(devvp);
@@ -2252,9 +2248,8 @@
 	/*
 	 * Not in the precomputed list, so check the snapshots.
 	 */
-	while (lockmgr(&sn->sn_lock,
-		       LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
-		       VI_MTX(devvp), td) != 0) {
+	while (lockmgr(&sn->sn_lock, LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
+		       VI_MTX(devvp)) != 0) {
 		VI_LOCK(devvp);
 		sn = devvp->v_rdev->si_snapdata;
 		if (sn == NULL ||
@@ -2377,7 +2372,7 @@
 		else
 			launched_async_io = 1;
 	}
-	lockmgr(vp->v_vnlock, LK_RELEASE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_RELEASE, NULL);
 	td->td_pflags = (td->td_pflags & ~TDP_NORUNNINGBUF) |
 		prev_norunningbuf;
 	if (launched_async_io && (td->td_pflags & TDP_NORUNNINGBUF) == 0)
@@ -2517,8 +2512,8 @@
 	snapblklist = sn->sn_blklist;
 	sn->sn_blklist = NULL;
 	sn->sn_listsize = 0;
-	lockmgr(&sn->sn_lock, LK_DRAIN|LK_INTERLOCK, VI_MTX(devvp), td);
-	lockmgr(&sn->sn_lock, LK_RELEASE, NULL, td);
+	lockmgr(&sn->sn_lock, LK_DRAIN|LK_INTERLOCK, VI_MTX(devvp));
+	lockmgr(&sn->sn_lock, LK_RELEASE, NULL);
 	lockdestroy(&sn->sn_lock);
 	free(sn, M_UFSMNT);
 	if (snapblklist != NULL)
--- //depot/vendor/freebsd/src/sys/ufs/ffs/ffs_vnops.c	2007/11/08 17:23:44
+++ //depot/user/attilio/attilio_lockmgr/ufs/ffs/ffs_vnops.c	2007/12/06 01:46:46
@@ -370,7 +370,11 @@
 				flags |= LK_INTERLOCK;
 			}
 			lkp = vp->v_vnlock;
-			result = _lockmgr(lkp, flags, VI_MTX(vp), ap->a_td, ap->a_file, ap->a_line);
+			KASSERT(ap->a_td == NULL || ap->a_td == curthread,
+			    ("%s: invalid vnode lock", __func__));
+			flags |= (ap->a_td == NULL) ? LK_USEKPROC : 0;
+			result = _lockmgr(lkp, flags, VI_MTX(vp),
+			    ap->a_file, ap->a_line);
 			if (lkp == vp->v_vnlock || result != 0)
 				break;
 			/*
@@ -381,7 +385,9 @@
 			 * right lock.  Release it, and try to get the
 			 * new lock.
 			 */
-			(void) _lockmgr(lkp, LK_RELEASE, VI_MTX(vp), ap->a_td, ap->a_file, ap->a_line);
+			(void) _lockmgr(lkp, LK_RELEASE | ((ap->a_td == NULL) ?
+			    LK_USEKPROC : 0), VI_MTX(vp), ap->a_file,
+			    ap->a_line);
 			if ((flags & LK_TYPE_MASK) == LK_UPGRADE)
 				flags = (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE;
 			flags &= ~LK_INTERLOCK;
--- //depot/vendor/freebsd/src/sys/ufs/ufs/ufs_extattr.c	2007/06/01 14:37:18
+++ //depot/user/attilio/attilio_lockmgr/ufs/ufs/ufs_extattr.c	2007/12/06 01:46:46
@@ -103,15 +103,20 @@
 {
 
 	/* Ideally, LK_CANRECURSE would not be used, here. */
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
 	lockmgr(&ump->um_extattr.uepm_lock, LK_EXCLUSIVE | LK_RETRY |
-	    LK_CANRECURSE, 0, td);
+	    LK_CANRECURSE | ((td == NULL) ? LK_USEKPROC : 0), NULL);
 }
 
 static void
 ufs_extattr_uepm_unlock(struct ufsmount *ump, struct thread *td)
 {
 
-	lockmgr(&ump->um_extattr.uepm_lock, LK_RELEASE, 0, td);
+	KASSERT(td == NULL || td == curthread, ("%s: invalid vnode lock",
+	    __func__));
+	lockmgr(&ump->um_extattr.uepm_lock, LK_RELEASE | ((td == NULL) ?
+	    LK_USEKPROC : 0), NULL);
 }
 
 /*-