--- //depot/vendor/freebsd/src/sys/dev/usb/ehci.c	2008/01/08 23:51:30
+++ //depot/user/attilio/attilio_schedlock/dev/usb/ehci.c	2008/01/12 13:15:51
@@ -1560,7 +1560,7 @@
 	}
 	DPRINTFN(2,("ehci_sync_hc: enter\n"));
 	/* get doorbell */
-	lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE, NULL, curthread);
+	lockmgr(&sc->sc_doorbell_lock, LK_EXCLUSIVE, 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, curthread);
+	lockmgr(&sc->sc_doorbell_lock, LK_RELEASE, NULL);
 #ifdef DIAGNOSTIC
 	if (error)
 		printf("ehci_sync_hc: tsleep() = %d\n", error);
--- //depot/vendor/freebsd/src/sys/dev/usb/if_udav.c	2008/01/08 23:51:30
+++ //depot/user/attilio/attilio_schedlock/dev/usb/if_udav.c	2008/01/12 13:15:51
@@ -1777,11 +1777,7 @@
 			__func__));
 
 	sc->sc_refcnt++;
-#if defined(__NetBSD__)
 	lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE, NULL);
-#elif defined(__FreeBSD__)
-	lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE, NULL, curthread);
-#endif
 }
 
 static void
@@ -1790,11 +1786,7 @@
 	DPRINTFN(0xff, ("%s: %s: enter\n", device_get_nameunit(sc->sc_dev),
 		       __func__));
 
-#if defined(__NetBSD__)
 	lockmgr(&sc->sc_mii_lock, LK_RELEASE, NULL);
-#elif defined(__FreeBSD__)
-	lockmgr(&sc->sc_mii_lock, LK_RELEASE, NULL, curthread);
-#endif
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeup(sc->sc_dev);
 }
--- //depot/vendor/freebsd/src/sys/fs/cd9660/cd9660_vfsops.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/fs/cd9660/cd9660_vfsops.c	2008/01/13 17:10:15
@@ -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	2008/01/08 23:51:30
+++ //depot/user/attilio/attilio_schedlock/fs/hpfs/hpfs_subr.h	2008/01/12 13:15:51
@@ -79,9 +79,9 @@
 
 #if 0
 #define	hpfs_hplock(hp, p)						\
-	lockmgr(&(hp)->h_intlock, LK_EXCLUSIVE, (p), curthread)
+	lockmgr(&(hp)->h_intlock, LK_EXCLUSIVE, (p))
 #define	hpfs_hpunlock(hp, p)						\
-	lockmgr(&(hp)->h_intlock, LK_RELEASE, (p), curthread)
+	lockmgr(&(hp)->h_intlock, LK_RELEASE, (p))
 #endif
 
 int		hpfs_hpbmap (struct hpfsnode *, daddr_t, daddr_t *, int *);
--- //depot/vendor/freebsd/src/sys/fs/hpfs/hpfs_vfsops.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/fs/hpfs/hpfs_vfsops.c	2008/01/13 17:10:15
@@ -453,7 +453,6 @@
 	struct hpfsnode *hp;
 	struct buf *bp;
 	int error;
-	struct thread *td;
 
 	dprintf(("hpfs_vget(0x%x): ",ino));
 
@@ -507,14 +506,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_schedlock/fs/msdosfs/msdosfs_denode.c	2008/01/12 13:15:51
@@ -105,7 +105,6 @@
 	struct denode *ldep;
 	struct vnode *nvp, *xvp;
 	struct buf *bp;
-	struct thread *td;
 
 #ifdef MSDOSFS_DEBUG
 	printf("deget(pmp %p, dirclust %lu, diroffset %lx, depp %p)\n",
@@ -171,15 +170,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	2008/01/08 23:51:30
+++ //depot/user/attilio/attilio_schedlock/fs/ntfs/ntfs_subr.c	2008/01/19 14:02:55
@@ -358,8 +358,7 @@
 
 	mtx_lock(&ip->i_interlock);
 	ip->i_usecount++;
-	lockmgr(&ip->i_lock, LK_EXCLUSIVE | LK_INTERLOCK, &ip->i_interlock,
-	    curthread);
+	lockmgr(&ip->i_lock, LK_EXCLUSIVE | LK_INTERLOCK, &ip->i_interlock);
 
 	return 0;
 }
@@ -390,8 +389,7 @@
 			*ipp = ip;
 			return (0);
 		}
-	} while (lockmgr(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL, NULL,
-	    curthread));
+	} while (lockmgr(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL, NULL));
 
 	MALLOC(ip, struct ntnode *, sizeof(struct ntnode), M_NTFSNTNODE,
 		M_WAITOK | M_ZERO);
@@ -413,7 +411,7 @@
 
 	ntfs_nthashins(ip);
 
-	lockmgr(&ntfs_hashlock, LK_RELEASE, NULL, curthread);
+	lockmgr(&ntfs_hashlock, LK_RELEASE, NULL);
 
 	*ipp = ip;
 
@@ -449,8 +447,7 @@
 #endif
 
 	if (ip->i_usecount > 0) {
-		lockmgr(&ip->i_lock, LK_RELEASE|LK_INTERLOCK, &ip->i_interlock,
-		    curthread);
+		lockmgr(&ip->i_lock, LK_RELEASE|LK_INTERLOCK, &ip->i_interlock);
 		return;
 	}
 
@@ -1982,7 +1979,7 @@
 	struct vnode *vp;
 
 	/* get exclusive access */
-	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL, curthread);
+	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
 	
 	/* only read the translation data from a file if it hasn't been
 	 * read already */
@@ -2005,7 +2002,7 @@
 
     out:
 	ntfs_toupper_usecount++;
-	lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL, curthread);
+	lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL);
 	return (error);
 }
 
@@ -2017,7 +2014,7 @@
 ntfs_toupper_unuse()
 {
 	/* get exclusive access */
-	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL, curthread);
+	lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
 
 	ntfs_toupper_usecount--;
 	if (ntfs_toupper_usecount == 0) {
@@ -2032,7 +2029,7 @@
 #endif
 	
 	/* release the lock */
-	lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL, curthread);
+	lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL);
 } 
 
 int
--- //depot/vendor/freebsd/src/sys/fs/nullfs/null_vnops.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/fs/nullfs/null_vnops.c	2008/01/13 17:10:15
@@ -674,8 +674,7 @@
 	vnlock = vp->v_vnlock;
 	vp->v_vnlock = &vp->v_lock;
 	if (lowervp) {
-		lockmgr(vp->v_vnlock,
-		    LK_EXCLUSIVE|LK_INTERLOCK, VI_MTX(vp), curthread);
+		lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_INTERLOCK, VI_MTX(vp));
 		vput(lowervp);
 	} else
 		panic("null_reclaim: reclaiming an node with now lowervp");
--- //depot/vendor/freebsd/src/sys/fs/nwfs/nwfs_node.c	2008/01/10 01:16:12
+++ //depot/user/attilio/attilio_schedlock/fs/nwfs/nwfs_node.c	2008/01/12 13:15:51
@@ -137,7 +137,6 @@
 nwfs_allocvp(struct mount *mp, ncpfid fid, struct nw_entry_info *fap,
 	struct vnode *dvp, struct vnode **vpp)
 {
-	struct thread *td = curthread;	/* XXX */
 	struct nwnode *np;
 	struct nwnode_hash_head *nhpp;
 	struct nwmount *nmp = VFSTONWFS(mp);
@@ -145,20 +144,20 @@
 	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);
-		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td))
+		lockmgr(&nwhashlock, LK_RELEASE, NULL);
+		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, curthread))
 			goto loop;
 		if (fap)
 			np->n_attr = fap->attributes;
 		*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 +189,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 +205,7 @@
 	nhpp = NWNOHASH(fid);
 	LIST_INSERT_HEAD(nhpp, np, n_hash);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
-	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 +238,9 @@
 {
 	int error;
 
-	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL);
 	error = nwfs_hashlookup(nmp, fid, npp);
-	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+	lockmgr(&nwhashlock, LK_RELEASE, NULL);
 	return error;
 }
 
@@ -274,9 +273,9 @@
 			NCPVNDEBUG("%s: has no parent ?\n",np->n_name);
 		}
 	}
-	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL);
 	LIST_REMOVE(np, n_hash);
-	lockmgr(&nwhashlock, LK_RELEASE, NULL, td);
+	lockmgr(&nwhashlock, LK_RELEASE, NULL);
 	if (nmp->n_root == np) {
 		nmp->n_root = NULL;
 	}
--- //depot/vendor/freebsd/src/sys/fs/smbfs/smbfs_node.c	2008/01/10 01:16:12
+++ //depot/user/attilio/attilio_schedlock/fs/smbfs/smbfs_node.c	2008/01/19 14:02:55
@@ -58,8 +58,10 @@
 #include <fs/smbfs/smbfs_subr.h>
 
 #define	SMBFS_NOHASH(smp, hval)	(&(smp)->sm_hash[(hval) & (smp)->sm_hashlen])
-#define	smbfs_hash_lock(smp, td)	lockmgr(&smp->sm_hashlock, LK_EXCLUSIVE, NULL, td)
-#define	smbfs_hash_unlock(smp, td)	lockmgr(&smp->sm_hashlock, LK_RELEASE, NULL, td)
+#define	smbfs_hash_lock(smp, td)					\
+	lockmgr(&smp->sm_hashlock, LK_EXCLUSIVE, NULL)
+#define	smbfs_hash_unlock(smp, td)					\
+	lockmgr(&smp->sm_hashlock, LK_RELEASE, NULL)
 
 
 extern struct vop_vector smbfs_vnodeops;	/* XXX -> .h file */
@@ -308,7 +310,6 @@
         } */ *ap;
 {
 	struct vnode *vp = ap->a_vp;
-	struct thread *td = ap->a_td;
 	struct vnode *dvp;
 	struct smbnode *np = VTOSMB(vp);
 	struct smbmount *smp = VTOSMBFS(vp);
--- //depot/vendor/freebsd/src/sys/fs/udf/udf_vfsops.c	2008/01/18 12:11:53
+++ //depot/user/attilio/attilio_schedlock/fs/udf/udf_vfsops.c	2008/01/18 22:11:04
@@ -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	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/fs/unionfs/union_subr.c	2008/01/13 17:10:15
@@ -198,7 +198,7 @@
 
 	vp->v_vnlock = &(vp->v_lock);
 	vp->v_data = NULL;
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_INTERLOCK, VI_MTX(vp), td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_INTERLOCK, VI_MTX(vp));
 	if (lvp != NULLVP)
 		VOP_UNLOCK(lvp, 0);
 	if (uvp != NULLVP)
--- //depot/vendor/freebsd/src/sys/gnu/fs/ext2fs/ext2_vfsops.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/gnu/fs/ext2fs/ext2_vfsops.c	2008/01/13 17:10:15
@@ -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	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/gnu/fs/reiserfs/reiserfs_inode.c	2008/01/13 17:10:15
@@ -812,10 +812,10 @@
 	 * 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);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, (struct mtx *)0);
 #endif
 
-	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_REISERFSNODE);
--- //depot/vendor/freebsd/src/sys/kern/kern_lock.c	2008/01/11 17:04:45
+++ //depot/user/attilio/attilio_schedlock/kern/kern_lock.c	2008/01/22 16:54:30
@@ -189,23 +189,18 @@
  * 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)
 
 {
+	struct thread *td;
 	int error;
 	int extflags, lockflags;
 	int contested = 0;
 	uint64_t waitstart = 0;
 
-	/*
-	 * Lock owner can only be curthread in order to have a deadlock
-	 * free implementation of the primitive.
-	 */
-	KASSERT(td == curthread,
-	    ("lockmgr: owner thread (%p) cannot differ from curthread", td));
-
 	error = 0;
+	td = curthread;
 
 	if ((flags & LK_INTERNAL) == 0)
 		mtx_lock(lkp->lk_interlock);
@@ -576,6 +571,9 @@
 	int lock_type = 0;
 	int interlocked;
 
+	KASSERT(td == NULL || td == curthread,
+	    ("%s: thread passed argument (%p) is not valid", __func__, td));
+
 	if (!kdb_active) {
 		interlocked = 1;
 		mtx_lock(lkp->lk_interlock);
@@ -594,21 +592,6 @@
 }
 
 /*
- * Determine the number of holders of a lock.
- */
-int
-lockcount(lkp)
-	struct lock *lkp;
-{
-	int count;
-
-	mtx_lock(lkp->lk_interlock);
-	count = lkp->lk_exclusivecount + lkp->lk_sharecount;
-	mtx_unlock(lkp->lk_interlock);
-	return (count);
-}
-
-/*
  * Determine the number of waiters on a lock.
  */
 int
--- //depot/vendor/freebsd/src/sys/kern/vfs_default.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/kern/vfs_default.c	2008/01/13 17:10:15
@@ -263,8 +263,8 @@
 {
 	struct vnode *vp = ap->a_vp;
 
-	return (_lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), curthread,
-	     ap->a_file, ap->a_line));
+	return (_lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), ap->a_file,
+	    ap->a_line));
 }
 
 /* See above. */
@@ -278,8 +278,7 @@
 {
 	struct vnode *vp = ap->a_vp;
 
-	return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp),
-	    curthread));
+	return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp)));
 }
 
 /* See above. */
--- //depot/vendor/freebsd/src/sys/kern/vfs_mount.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/kern/vfs_mount.c	2008/01/13 17:10:15
@@ -1239,7 +1239,7 @@
 	if (flags & MNT_FORCE)
 		mp->mnt_kern_flag |= MNTK_UNMOUNTF;
 	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), MNT_MTX(mp));
 	if (error) {
 		MNT_ILOCK(mp);
 		mp->mnt_kern_flag &= ~(MNTK_UNMOUNT | MNTK_NOINSMNTQ |
@@ -1314,7 +1314,7 @@
 		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, NULL);
 		if (mp->mnt_kern_flag & MNTK_MWAIT)
 			wakeup(mp);
 		MNT_IUNLOCK(mp);
@@ -1330,7 +1330,7 @@
 		vput(coveredvp);
 	}
 	vfs_event_signal(NULL, VQ_UNMOUNT, 0);
-	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td);
+	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL);
 	vfs_mount_destroy(mp);
 	return (0);
 }
--- //depot/vendor/freebsd/src/sys/kern/vfs_subr.c	2008/01/19 17:39:46
+++ //depot/user/attilio/attilio_schedlock/kern/vfs_subr.c	2008/01/19 17:43:06
@@ -361,7 +361,7 @@
 	if (interlkp)
 		mtx_unlock(interlkp);
 	lkflags = LK_SHARED | LK_INTERLOCK;
-	if (lockmgr(&mp->mnt_lock, lkflags, MNT_MTX(mp), td))
+	if (lockmgr(&mp->mnt_lock, lkflags, MNT_MTX(mp)))
 		panic("vfs_busy: unexpected lock failure");
 	return (0);
 }
@@ -373,7 +373,7 @@
 vfs_unbusy(struct mount *mp, struct thread *td)
 {
 
-	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, td);
+	lockmgr(&mp->mnt_lock, LK_RELEASE, NULL);
 	vfs_rel(mp);
 }
 
--- //depot/vendor/freebsd/src/sys/netncp/ncp_conn.c	2007/05/27 17:17:53
+++ //depot/user/attilio/attilio_schedlock/netncp/ncp_conn.c	2008/01/12 13:15:51
@@ -99,13 +99,13 @@
 int
 ncp_conn_locklist(int flags, struct thread *td)
 {
-	return lockmgr(&listlock, flags | LK_CANRECURSE, 0, td);
+	return lockmgr(&listlock, flags | LK_CANRECURSE, 0);
 }
 
 void
 ncp_conn_unlocklist(struct thread *td)
 {
-	lockmgr(&listlock, LK_RELEASE, 0, td);
+	lockmgr(&listlock, LK_RELEASE, 0);
 }
 
 int
@@ -129,17 +129,17 @@
 	int error;
 
 	if (conn->nc_id == 0) return EACCES;
-	error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE, 0, td);
+	error = lockmgr(&conn->nc_lock, LK_EXCLUSIVE | LK_CANRECURSE, 0);
 	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, 0);
 		return error;
 	}
 
 	if (conn->nc_id == 0) {
-		lockmgr(&conn->nc_lock, LK_RELEASE, 0, td);
+		lockmgr(&conn->nc_lock, LK_RELEASE, 0);
 		return EACCES;
 	}
 	conn->td = td;		/* who currently operates */
@@ -187,7 +187,7 @@
 	 * 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);
+	lockmgr(&conn->nc_lock, LK_RELEASE, 0);
 }
 
 int
@@ -301,7 +301,7 @@
 	/*
 	 * if signal is raised - how I do react ?
 	 */
-	lockmgr(&ncp->nc_lock, LK_DRAIN, 0, td);
+	lockmgr(&ncp->nc_lock, LK_DRAIN, 0);
 	lockdestroy(&ncp->nc_lock);
 	while (ncp->nc_lwant) {
 		printf("lwant = %d\n", ncp->nc_lwant);
@@ -525,14 +525,14 @@
 {
 	struct ncp_handle *refp;
 
-	lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
+	lockmgr(&lhlock, LK_EXCLUSIVE, 0);
 	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, 0);
 		return 0;
 	}
 	MALLOC(refp,struct ncp_handle *,sizeof(struct ncp_handle),M_NCPDATA,
@@ -544,7 +544,7 @@
 	refp->nh_id = ncp_next_handle++;
 	*handle = refp;
 	conn->ref_cnt++;
-	lockmgr(&lhlock, LK_RELEASE, 0, td);
+	lockmgr(&lhlock, LK_RELEASE, 0);
 	return 0;
 }
 /*
@@ -555,7 +555,7 @@
 {
 	struct ncp_handle *refp = handle;
 
-	lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
+	lockmgr(&lhlock, LK_EXCLUSIVE, 0);
 	refp->nh_ref--;
 	refp->nh_conn->ref_cnt--;
 	if (force) {
@@ -566,7 +566,7 @@
 		SLIST_REMOVE(&lhlist, refp, ncp_handle, nh_next);
 		FREE(refp, M_NCPDATA);
 	}
-	lockmgr(&lhlock, LK_RELEASE, 0, td);
+	lockmgr(&lhlock, LK_RELEASE, 0);
 	return 0;
 }
 /*
@@ -576,10 +576,10 @@
 ncp_conn_findhandle(int connHandle, struct thread *td, struct ncp_handle **handle) {
 	struct ncp_handle *refp;
 
-	lockmgr(&lhlock, LK_SHARED, 0, td);
+	lockmgr(&lhlock, LK_SHARED, 0);
 	SLIST_FOREACH(refp, &lhlist, nh_next)
 		if (refp->nh_td == td && refp->nh_id == connHandle) break;
-	lockmgr(&lhlock, LK_RELEASE, 0, td);
+	lockmgr(&lhlock, LK_RELEASE, 0);
 	if (refp == NULL) {
 		return EBADF;
 	}
@@ -595,7 +595,7 @@
 	struct ncp_handle *hp, *nhp;
 	int haveone = 0;
 
-	lockmgr(&lhlock, LK_EXCLUSIVE, 0, td);
+	lockmgr(&lhlock, LK_EXCLUSIVE, 0);
 	for (hp = SLIST_FIRST(&lhlist); hp; hp = nhp) {
 		nhp = SLIST_NEXT(hp, nh_next);
 		if (hp->nh_td != td) continue;
@@ -604,7 +604,7 @@
 		SLIST_REMOVE(&lhlist, hp, ncp_handle, nh_next);
 		FREE(hp, M_NCPDATA);
 	}
-	lockmgr(&lhlock, LK_RELEASE, 0, td);
+	lockmgr(&lhlock, LK_RELEASE, 0);
 	return haveone;
 }
 /*
--- //depot/vendor/freebsd/src/sys/netsmb/smb_conn.c	2006/11/06 13:43:21
+++ //depot/user/attilio/attilio_schedlock/netsmb/smb_conn.c	2008/01/19 14:02:55
@@ -96,7 +96,7 @@
 		SMBERROR("%d connections still active\n", smb_vclist.co_usecount - 1);
 		return EBUSY;
 	}
-	lockmgr(&smb_vclist.co_lock, LK_DRAIN, 0, curthread);
+	lockmgr(&smb_vclist.co_lock, LK_DRAIN, 0);
 	smb_co_done(&smb_vclist);
 	return 0;
 }
@@ -242,7 +242,7 @@
 smb_co_done(struct smb_connobj *cp)
 {
 	smb_sl_destroy(&cp->co_interlock);
-	lockmgr(&cp->co_lock, LK_RELEASE, 0, curthread);
+	lockmgr(&cp->co_lock, LK_RELEASE, 0);
 	lockdestroy(&cp->co_lock);
 }
 
@@ -275,7 +275,6 @@
 void
 smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred)
 {
-	struct thread *td = scred->scr_td;
 
 	SMB_CO_LOCK(cp);
 	if (cp->co_usecount > 1) {
@@ -291,7 +290,7 @@
 	cp->co_usecount--;
 	cp->co_flags |= SMBO_GONE;
 
-	lockmgr(&cp->co_lock, LK_DRAIN | LK_INTERLOCK, &cp->co_interlock, td);
+	lockmgr(&cp->co_lock, LK_DRAIN | LK_INTERLOCK, &cp->co_interlock);
 	smb_co_gone(cp, scred);
 }
 
@@ -316,7 +315,6 @@
 void
 smb_co_put(struct smb_connobj *cp, struct smb_cred *scred)
 {
-	struct thread *td = scred->scr_td;
 
 	SMB_CO_LOCK(cp);
 	if (cp->co_usecount > 1) {
@@ -327,10 +325,10 @@
 	} else {
 		SMBERROR("negative usecount");
 	}
-	lockmgr(&cp->co_lock, LK_RELEASE | LK_INTERLOCK, &cp->co_interlock, td);
+	lockmgr(&cp->co_lock, LK_RELEASE | LK_INTERLOCK, &cp->co_interlock);
 	if ((cp->co_flags & SMBO_GONE) == 0)
 		return;
-	lockmgr(&cp->co_lock, LK_DRAIN, NULL, td);
+	lockmgr(&cp->co_lock, LK_DRAIN, NULL);
 	smb_co_gone(cp, scred);
 }
 
@@ -353,13 +351,13 @@
 		SMBERROR("recursive lock for object %d\n", cp->co_level);
 		return 0;
 	}
-	return lockmgr(&cp->co_lock, flags, &cp->co_interlock, td);
+	return lockmgr(&cp->co_lock, flags, &cp->co_interlock);
 }
 
 void
 smb_co_unlock(struct smb_connobj *cp, int flags, struct thread *td)
 {
-	(void)lockmgr(&cp->co_lock, flags | LK_RELEASE, &cp->co_interlock, td);
+	(void)lockmgr(&cp->co_lock, flags | LK_RELEASE, &cp->co_interlock);
 }
 
 static void
--- //depot/vendor/freebsd/src/sys/nfs4client/nfs4_idmap.c	2005/01/07 01:52:23
+++ //depot/user/attilio/attilio_schedlock/nfs4client/nfs4_idmap.c	2008/01/12 13:15:51
@@ -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_schedlock/nfsclient/nfs_node.c	2008/01/12 13:15:51
@@ -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	2008/01/19 17:39:46
+++ //depot/user/attilio/attilio_schedlock/sys/buf.h	2008/01/19 17:43:06
@@ -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);
 }
 
--- //depot/vendor/freebsd/src/sys/sys/lockmgr.h	2008/01/19 17:39:46
+++ //depot/user/attilio/attilio_schedlock/sys/lockmgr.h	2008/01/20 13:38:27
@@ -166,44 +166,21 @@
 #define LK_KERNPROC ((struct thread *)-2)
 #define LK_NOPROC ((struct thread *) -1)
 
-#ifdef INVARIANTS
-#define	LOCKMGR_ASSERT(lkp, what, p) do {				\
-	switch ((what)) {						\
-	case LK_SHARED:							\
-		if (lockstatus((lkp), (p)) == LK_SHARED)		\
-			break;						\
-		/* fall into exclusive */				\
-	case LK_EXCLUSIVE:						\
-		if (lockstatus((lkp), (p)) != LK_EXCLUSIVE)		\
-			panic("lock %s %s not held at %s:%d",		\
-			    (lkp)->lk_wmesg, #what, __FILE__,		\
-			    __LINE__);					\
-		break;							\
-	default:							\
-		panic("unknown LOCKMGR_ASSERT at %s:%d", __FILE__,	\
-		    __LINE__);						\
-	}								\
-} while (0)
-#else	/* INVARIANTS */
-#define	LOCKMGR_ASSERT(lkp, p, what)
-#endif	/* INVARIANTS */
-
-void dumplockinfo(struct lock *lkp);
 struct thread;
 
 void	lockinit(struct lock *, int prio, const char *wmesg,
 			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_disown(struct lock *);
 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__)
 #define	lockmgr_recursed(lkp)						\
 	((lkp)->lk_exclusivecount > 1)
 #ifdef DDB
--- //depot/vendor/freebsd/src/sys/ufs/ffs/ffs_snapshot.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/ufs/ffs/ffs_snapshot.c	2008/01/13 17:10:15
@@ -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);
@@ -1718,9 +1718,8 @@
 		VI_UNLOCK(devvp);
 		return (0);
 	}
-	if (lockmgr(&sn->sn_lock,
-		    LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
-		    VI_MTX(devvp), td) != 0)
+	if (lockmgr(&sn->sn_lock, LK_INTERLOCK | LK_EXCLUSIVE | LK_SLEEPFAIL,
+	    VI_MTX(devvp)) != 0)
 		goto retry;
 	TAILQ_FOREACH(ip, &sn->sn_head, i_nextsnap) {
 		vp = ITOV(ip);
@@ -1807,7 +1806,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 +1872,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 +1964,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 +2047,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 +2247,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 +2371,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 +2511,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_vfsops.c	2008/01/19 17:39:46
+++ //depot/user/attilio/attilio_schedlock/ufs/ffs/ffs_vfsops.c	2008/01/19 17:43:06
@@ -1381,7 +1381,7 @@
 #endif
 
 	td = curthread;
-	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL, td);
+	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
 	error = insmntque(vp, mp);
 	if (error != 0) {
 		uma_zfree(uma_inode, ip);
--- //depot/vendor/freebsd/src/sys/ufs/ffs/ffs_vnops.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/ufs/ffs/ffs_vnops.c	2008/01/13 17:10:15
@@ -370,8 +370,8 @@
 				flags |= LK_INTERLOCK;
 			}
 			lkp = vp->v_vnlock;
-			result = _lockmgr(lkp, flags, VI_MTX(vp), curthread,
-			    ap->a_file, ap->a_line);
+			result = _lockmgr(lkp, flags, VI_MTX(vp), ap->a_file,
+			    ap->a_line);
 			if (lkp == vp->v_vnlock || result != 0)
 				break;
 			/*
@@ -382,7 +382,7 @@
 			 * right lock.  Release it, and try to get the
 			 * new lock.
 			 */
-			(void) _lockmgr(lkp, LK_RELEASE, VI_MTX(vp), curthread,
+			(void) _lockmgr(lkp, LK_RELEASE, VI_MTX(vp),
 			    ap->a_file, ap->a_line);
 			if ((flags & LK_TYPE_MASK) == LK_UPGRADE)
 				flags = (flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE;
--- //depot/vendor/freebsd/src/sys/ufs/ufs/ufs_extattr.c	2008/01/13 14:45:30
+++ //depot/user/attilio/attilio_schedlock/ufs/ufs/ufs_extattr.c	2008/01/13 17:10:15
@@ -104,14 +104,14 @@
 
 	/* Ideally, LK_CANRECURSE would not be used, here. */
 	lockmgr(&ump->um_extattr.uepm_lock, LK_EXCLUSIVE | LK_RETRY |
-	    LK_CANRECURSE, 0, td);
+	    LK_CANRECURSE, 0);
 }
 
 static void
 ufs_extattr_uepm_unlock(struct ufsmount *ump, struct thread *td)
 {
 
-	lockmgr(&ump->um_extattr.uepm_lock, LK_RELEASE, 0, td);
+	lockmgr(&ump->um_extattr.uepm_lock, LK_RELEASE, 0);
 }
 
 /*-