? grep
? it
? dev/my
? i386/conf/!
? i386/conf/LINT
? i386/conf/MY
? i386/conf/REF3
? i386/conf/REF4
? modules/netgraph/device/device_if.h
? modules/netgraph/device/ng_device.kld
? modules/netgraph/device/ng_device.ko
? modules/netgraph/fec/.depend
? modules/netgraph/fec/ng_fec.kld
? modules/netgraph/fec/ng_fec.ko
? modules/netgraph/fec/opt_inet.h
? modules/netgraph/fec/opt_inet6.h
? sys/p
? sys/proc.hh
Index: kern/kern_lock.c
===================================================================
RCS file: /repos/projects/mirrored/freebsd/src/sys/kern/kern_lock.c,v
retrieving revision 1.62
diff -u -r1.62 kern_lock.c
--- kern/kern_lock.c	2003/02/01 12:17:07	1.62
+++ kern/kern_lock.c	2003/02/04 20:06:14
@@ -219,7 +219,7 @@
 #endif
 {
 	int error;
-	pid_t pid;
+	struct thread *thr;
 	int extflags, lockflags;
 
 	CTR5(KTR_LOCKMGR,
@@ -228,9 +228,9 @@
 
 	error = 0;
 	if (td == NULL)
-		pid = LK_KERNPROC;
+		thr = LK_KERNPROC;
 	else
-		pid = td->td_proc->p_pid;
+		thr = td;
 
 	mtx_lock(lkp->lk_interlock);
 	if (flags & LK_INTERLOCK) {
@@ -257,7 +257,7 @@
 		 * lock requests or upgrade requests ( but not the exclusive
 		 * lock itself ).
 		 */
-		if (lkp->lk_lockholder != pid) {
+		if (lkp->lk_lockholder != thr) {
 			lockflags = LK_HAVE_EXCL;
 			mtx_lock_spin(&sched_lock);
 			if (td != NULL && !(td->td_flags & TDF_DEADLKTREAT))
@@ -268,7 +268,7 @@
 				break;
 			sharelock(lkp, 1);
 #if defined(DEBUG_LOCKS)
-			lkp->lk_slockholder = pid;
+			lkp->lk_slockholder = thr;
 			lkp->lk_sfilename = file;
 			lkp->lk_slineno = line;
 			lkp->lk_slockername = name;
@@ -283,14 +283,14 @@
 		/* FALLTHROUGH downgrade */
 
 	case LK_DOWNGRADE:
-		KASSERT(lkp->lk_lockholder == pid && lkp->lk_exclusivecount != 0,
+		KASSERT(lkp->lk_lockholder == thr && lkp->lk_exclusivecount != 0,
 			("lockmgr: not holding exclusive lock "
-			"(owner pid (%d) != pid (%d), exlcnt (%d) != 0",
-			lkp->lk_lockholder, pid, lkp->lk_exclusivecount));
+			"(owner thread (%p) != thread (%p), exlcnt (%d) != 0",
+			lkp->lk_lockholder, thr, lkp->lk_exclusivecount));
 		sharelock(lkp, lkp->lk_exclusivecount);
 		lkp->lk_exclusivecount = 0;
 		lkp->lk_flags &= ~LK_HAVE_EXCL;
-		lkp->lk_lockholder = LK_NOPROC;
+		lkp->lk_lockholder = (struct thread *)LK_NOPROC;
 		if (lkp->lk_waitcount)
 			wakeup((void *)lkp);
 		break;
@@ -317,7 +317,7 @@
 		 * after the upgrade). If we return an error, the file
 		 * will always be unlocked.
 		 */
-		if ((lkp->lk_lockholder == pid) || (lkp->lk_sharecount <= 0))
+		if ((lkp->lk_lockholder == thr) || (lkp->lk_sharecount <= 0))
 			panic("lockmgr: upgrade exclusive lock");
 		shareunlock(lkp, 1);
 		/*
@@ -342,7 +342,7 @@
 			if (error)
 				break;
 			lkp->lk_flags |= LK_HAVE_EXCL;
-			lkp->lk_lockholder = pid;
+			lkp->lk_lockholder = thr;
 			if (lkp->lk_exclusivecount != 0)
 				panic("lockmgr: non-zero exclusive count");
 			lkp->lk_exclusivecount = 1;
@@ -364,7 +364,7 @@
 		/* FALLTHROUGH exclusive request */
 
 	case LK_EXCLUSIVE:
-		if (lkp->lk_lockholder == pid && pid != LK_KERNPROC) {
+		if (lkp->lk_lockholder == thr && thr != LK_KERNPROC) {
 			/*
 			 *	Recursive lock.
 			 */
@@ -398,7 +398,7 @@
 		if (error)
 			break;
 		lkp->lk_flags |= LK_HAVE_EXCL;
-		lkp->lk_lockholder = pid;
+		lkp->lk_lockholder = thr;
 		if (lkp->lk_exclusivecount != 0)
 			panic("lockmgr: non-zero exclusive count");
 		lkp->lk_exclusivecount = 1;
@@ -411,10 +411,10 @@
 
 	case LK_RELEASE:
 		if (lkp->lk_exclusivecount != 0) {
-			if (lkp->lk_lockholder != pid &&
+			if (lkp->lk_lockholder != thr &&
 			    lkp->lk_lockholder != LK_KERNPROC) {
-				panic("lockmgr: pid %d, not %s %d unlocking",
-				    pid, "exclusive lock holder",
+				panic("lockmgr: thread %p, not %s %p unlocking",
+				    thr, "exclusive lock holder",
 				    lkp->lk_lockholder);
 			}
 			if (lkp->lk_exclusivecount == 1) {
@@ -437,14 +437,14 @@
 		 * check for holding a shared lock, but at least we can
 		 * check for an exclusive one.
 		 */
-		if (lkp->lk_lockholder == pid)
+		if (lkp->lk_lockholder == thr)
 			panic("lockmgr: draining against myself");
 
 		error = acquiredrain(lkp, extflags);
 		if (error)
 			break;
 		lkp->lk_flags |= LK_DRAINING | LK_HAVE_EXCL;
-		lkp->lk_lockholder = pid;
+		lkp->lk_lockholder = thr;
 		lkp->lk_exclusivecount = 1;
 #if defined(DEBUG_LOCKS)
 			lkp->lk_filename = file;
@@ -589,7 +589,7 @@
 
 	mtx_lock(lkp->lk_interlock);
 	if (lkp->lk_exclusivecount != 0) {
-		if (td == NULL || lkp->lk_lockholder == td->td_proc->p_pid)
+		if (td == NULL || lkp->lk_lockholder == td)
 			lock_type = LK_EXCLUSIVE;
 		else
 			lock_type = LK_EXCLOTHER;
@@ -627,7 +627,7 @@
 		printf(" lock type %s: SHARED (count %d)", lkp->lk_wmesg,
 		    lkp->lk_sharecount);
 	else if (lkp->lk_flags & LK_HAVE_EXCL)
-		printf(" lock type %s: EXCL (count %d) by pid %d",
+		printf(" lock type %s: EXCL (count %d) by thread %p",
 		    lkp->lk_wmesg, lkp->lk_exclusivecount, lkp->lk_lockholder);
 	if (lkp->lk_waitcount > 0)
 		printf(" with %d pending", lkp->lk_waitcount);
Index: sys/buf.h
===================================================================
RCS file: /repos/projects/mirrored/freebsd/src/sys/sys/buf.h,v
retrieving revision 1.142
diff -u -r1.142 buf.h
--- sys/buf.h	2003/02/01 12:17:08	1.142
+++ sys/buf.h	2003/02/04 20:06:20
@@ -353,7 +353,7 @@
 	struct thread *td = curthread;
 
 	if ((td != PCPU_GET(idlethread))
-	&& bp->b_lock.lk_lockholder == td->td_proc->p_pid)
+	&& bp->b_lock.lk_lockholder == td)
 		td->td_locks--;
 	bp->b_lock.lk_lockholder = LK_KERNPROC;
 }
Index: sys/lockmgr.h
===================================================================
RCS file: /repos/projects/mirrored/freebsd/src/sys/sys/lockmgr.h,v
retrieving revision 1.37
diff -u -r1.37 lockmgr.h
--- sys/lockmgr.h	2003/02/01 12:17:09	1.37
+++ sys/lockmgr.h	2003/02/04 20:06:20
@@ -57,14 +57,14 @@
 	short	lk_prio;		/* priority at which to sleep */
 	const char *lk_wmesg;		/* resource sleeping (for tsleep) */
 	int	lk_timo;		/* maximum sleep time (for tsleep) */
-	pid_t	lk_lockholder;		/* pid of exclusive lock holder */
+	struct thread *lk_lockholder;	/* thread of exclusive lock holder */
 	struct	lock *lk_newlock;	/* lock taking over this lock */
 #ifdef	DEBUG_LOCKS
 	const char *lk_filename;
 	const char *lk_lockername;
 	int     lk_lineno;
 
-	pid_t	lk_slockholder;
+	struct thread *lk_slockholder;
 	const char *lk_sfilename;
 	const char *lk_slockername;
 	int     lk_slineno;
@@ -176,8 +176,8 @@
 /*
  * Indicator that no process holds exclusive lock
  */
-#define LK_KERNPROC ((pid_t) -2)
-#define LK_NOPROC ((pid_t) -1)
+#define LK_KERNPROC ((struct thread *)-2)
+#define LK_NOPROC ((struct thread *) -1)
 
 #ifdef INVARIANTS
 #define	LOCKMGR_ASSERT(lkp, what, p) do {				\