- Change the allproc_lock to use a macro, ALLPROC_LOCK(how), instead

  of explicit calls to lockmgr.  Also provides macros for the flags
  pased to specify shared, exclusive or release which map to the
  lockmgr flags.  This is so that the use of lockmgr can be easily
  replaced with optimized reader-writer locks.
- Add some locking that I missed the first time.

24 files changed, 99 insertions, 75 deletions

diff --git a/sys/alpha/alpha/pmap.c b/sys/alpha/alpha/pmap.c
index 09cf8ec..ef32963 100644
--- a/sys/alpha/alpha/pmap.c
+++ b/sys/alpha/alpha/pmap.c
@@ -723,16 +723,14 @@ pmap_get_asn(pmap_t pmap)
 				printf("pmap_get_asn: generation rollover\n");
 #endif
 				PCPU_GET(current_asngen) = 1;
-				lockmgr(&allproc_lock, LK_SHARED, NULL,
-				    CURPROC);
+				ALLPROC_LOCK(AP_SHARED);
 				LIST_FOREACH(p, &allproc, p_list) {
 					if (p->p_vmspace) {
 						tpmap = vmspace_pmap(p->p_vmspace);
 						tpmap->pm_asn[PCPU_GET(cpuno)].gen = 0;
 					}
 				}
-				lockmgr(&allproc_lock, LK_RELEASE, NULL,
-				    CURPROC);
+				ALLPROC_LOCK(AP_RELEASE);
 			}
 
 			/*
@@ -1557,14 +1555,14 @@ pmap_growkernel(vm_offset_t addr)
 			newlev1 = pmap_phys_to_pte(pa)
 				| PG_V | PG_ASM | PG_KRE | PG_KWE;
 
-			lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+			ALLPROC_LOCK(AP_SHARED);
 			LIST_FOREACH(p, &allproc, p_list) {
 				if (p->p_vmspace) {
 					pmap = vmspace_pmap(p->p_vmspace);
 					*pmap_lev1pte(pmap, kernel_vm_end) = newlev1;
 				}
 			}
-			lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+			ALLPROC_LOCK(AP_RELEASE);
 			*pte = newlev1;
 			pmap_invalidate_all(kernel_pmap);
 		}
@@ -3063,7 +3061,7 @@ pmap_pid_dump(int pid)
 	struct proc *p;
 	int npte = 0;
 	int index;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		if (p->p_pid != pid)
 			continue;
@@ -3086,7 +3084,7 @@ pmap_pid_dump(int pid)
 								index = 0;
 								printf("\n");
 							}
-							lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+							ALLPROC_LOCK(AP_RELEASE);
 							return npte;
 						}
 						pte = pmap_pte_quick( pmap, va);
@@ -3111,7 +3109,7 @@ pmap_pid_dump(int pid)
 			}
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	return npte;
 }
 #endif
diff --git a/sys/amd64/amd64/pmap.c b/sys/amd64/amd64/pmap.c
index 12a702a..ef4d3f0 100644
--- a/sys/amd64/amd64/pmap.c
+++ b/sys/amd64/amd64/pmap.c
@@ -3324,7 +3324,7 @@ pmap_pid_dump(int pid)
 	struct proc *p;
 	int npte = 0;
 	int index;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		if (p->p_pid != pid)
 			continue;
@@ -3347,7 +3347,7 @@ pmap_pid_dump(int pid)
 								index = 0;
 								printf("\n");
 							}
-							lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+							ALLPROC_LOCK(AP_RELEASE);
 							return npte;
 						}
 						pte = pmap_pte_quick( pmap, va);
@@ -3372,7 +3372,7 @@ pmap_pid_dump(int pid)
 			}
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	return npte;
 }
 #endif
diff --git a/sys/compat/svr4/svr4_misc.c b/sys/compat/svr4/svr4_misc.c
index 4d921b5..601d205 100644
--- a/sys/compat/svr4/svr4_misc.c
+++ b/sys/compat/svr4/svr4_misc.c
@@ -953,16 +953,19 @@ svr4_pfind(pid)
 {
 	struct proc *p;
 
+	ALLPROC_LOCK(AP_SHARED);
 	/* look in the live processes */
 	if ((p = pfind(pid)) != NULL)
-		return p;
+		goto out;
 
 	/* look in the zombies */
 	for (p = zombproc.lh_first; p != 0; p = p->p_list.le_next)
 		if (p->p_pid == pid)
-			return p;
+			break;
+out:
+	ALLPROC_LOCK(AP_RELEASE);
 
-	return NULL;
+	return p;
 }
 
 
@@ -1253,7 +1256,9 @@ loop:
 			 */
 			leavepgrp(q);
 
+			ALLPROC_LOCK(AP_EXCLUSIVE);
 			LIST_REMOVE(q, p_list); /* off zombproc */
+			ALLPROC_LOCK(AP_RELEASE);
 
 			LIST_REMOVE(q, p_sibling);
 
diff --git a/sys/fs/procfs/procfs_vnops.c b/sys/fs/procfs/procfs_vnops.c
index e37f3c2..05ad13a 100644
--- a/sys/fs/procfs/procfs_vnops.c
+++ b/sys/fs/procfs/procfs_vnops.c
@@ -820,8 +820,10 @@ procfs_readdir(ap)
 		int doingzomb = 0;
 #endif
 		int pcnt = 0;
-		struct proc *p = allproc.lh_first;
+		struct proc *p;
 
+		ALLPROC_LOCK(AP_SHARED);
+		p = allproc.lh_first;
 		for (; p && uio->uio_resid >= delen; i++, pcnt++) {
 			bzero((char *) dp, delen);
 			dp->d_reclen = delen;
@@ -878,6 +880,7 @@ procfs_readdir(ap)
 		}
 #endif
 
+		ALLPROC_LOCK(AP_RELEASE);
 		break;
 
 	    }
diff --git a/sys/i386/i386/pmap.c b/sys/i386/i386/pmap.c
index 12a702a..ef4d3f0 100644
--- a/sys/i386/i386/pmap.c
+++ b/sys/i386/i386/pmap.c
@@ -3324,7 +3324,7 @@ pmap_pid_dump(int pid)
 	struct proc *p;
 	int npte = 0;
 	int index;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		if (p->p_pid != pid)
 			continue;
@@ -3347,7 +3347,7 @@ pmap_pid_dump(int pid)
 								index = 0;
 								printf("\n");
 							}
-							lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+							ALLPROC_LOCK(AP_RELEASE);
 							return npte;
 						}
 						pte = pmap_pte_quick( pmap, va);
@@ -3372,7 +3372,7 @@ pmap_pid_dump(int pid)
 			}
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	return npte;
 }
 #endif
diff --git a/sys/i386/ibcs2/ibcs2_sysvec.c b/sys/i386/ibcs2/ibcs2_sysvec.c
index 3f08212..8eb2987 100644
--- a/sys/i386/ibcs2/ibcs2_sysvec.c
+++ b/sys/i386/ibcs2/ibcs2_sysvec.c
@@ -32,6 +32,7 @@
 
 #include <sys/param.h>
 #include <sys/kernel.h>
+#include <sys/lock.h>
 #include <sys/module.h>
 #include <sys/sysent.h>
 #include <sys/signalvar.h>
@@ -75,18 +76,23 @@ static int
 ibcs2_modevent(module_t mod, int type, void *unused)
 {
 	struct proc *p = NULL;
+	int rval = 0;
 
 	switch(type) {
 	case MOD_UNLOAD:
 		/* if this was an ELF module we'd use elf_brand_inuse()... */
+		ALLPROC_LOCK(AP_SHARED);
 		for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
-			if (p->p_sysent == &ibcs2_svr3_sysvec)
-				return EBUSY;
+			if (p->p_sysent == &ibcs2_svr3_sysvec) {
+				rval = EBUSY;
+				break;
+			}
 		}
+		ALLPROC_LOCK(AP_RELEASE);
 	default:
 	        /* do not care */
 	}
-	return 0;
+	return (rval);
 }
 static moduledata_t ibcs2_mod = {
 	"ibcs2",
diff --git a/sys/ia64/ia64/pmap.c b/sys/ia64/ia64/pmap.c
index f01064c..46cfca9 100644
--- a/sys/ia64/ia64/pmap.c
+++ b/sys/ia64/ia64/pmap.c
@@ -2244,7 +2244,7 @@ pmap_pid_dump(int pid)
 	struct proc *p;
 	int npte = 0;
 	int index;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		if (p->p_pid != pid)
 			continue;
@@ -2267,7 +2267,7 @@ pmap_pid_dump(int pid)
 								index = 0;
 								printf("\n");
 							}
-							lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+							ALLPROC_LOCK(AP_RELEASE);
 							return npte;
 						}
 						pte = pmap_pte_quick( pmap, va);
@@ -2292,7 +2292,7 @@ pmap_pid_dump(int pid)
 			}
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	return npte;
 }
 #endif
diff --git a/sys/kern/imgact_elf.c b/sys/kern/imgact_elf.c
index 90c9716..96db3b3 100644
--- a/sys/kern/imgact_elf.c
+++ b/sys/kern/imgact_elf.c
@@ -154,14 +154,14 @@ elf_brand_inuse(Elf_Brandinfo *entry)
 	struct proc *p;
 	int rval = FALSE;
 
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		if (p->p_sysent == entry->sysvec) {
 			rval = TRUE;
 			break;
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 
 	return (rval);
 }
diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c
index 81cde0d..a147eae 100644
--- a/sys/kern/init_main.c
+++ b/sys/kern/init_main.c
@@ -409,12 +409,12 @@ proc0_post(void *dummy __unused)
 	 * Now we can look at the time, having had a chance to verify the
 	 * time from the file system.  Pretend that proc0 started now.
 	 */
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		microtime(&p->p_stats->p_start);
 		p->p_runtime = 0;
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	microuptime(&switchtime);
 	PCPU_SET(switchticks, ticks);
 
diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c
index 861f007..4d7c2b2 100644
--- a/sys/kern/kern_exit.c
+++ b/sys/kern/kern_exit.c
@@ -264,12 +264,12 @@ exit1(p, rv)
 	 * Remove proc from allproc queue and pidhash chain.
 	 * Place onto zombproc.  Unlink from parent's child list.
 	 */
-	lockmgr(&allproc_lock, LK_EXCLUSIVE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_EXCLUSIVE);
 	LIST_REMOVE(p, p_list);
 	LIST_INSERT_HEAD(&zombproc, p, p_list);
 
 	LIST_REMOVE(p, p_hash);
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	/*
 	 * We have to wait until after releasing this lock before
 	 * changing p_stat.  If we block on a mutex while waiting to
@@ -517,9 +517,9 @@ loop:
 			 * Unlink it from its process group and free it.
 			 */
 			leavepgrp(p);
-			lockmgr(&allproc_lock, LK_EXCLUSIVE, NULL, CURPROC);
+			ALLPROC_LOCK(AP_EXCLUSIVE);
 			LIST_REMOVE(p, p_list);	/* off zombproc */
-			lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+			ALLPROC_LOCK(AP_RELEASE);
 			LIST_REMOVE(p, p_sibling);
 
 			if (--p->p_procsig->ps_refcnt == 0) {
diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c
index c71e94b..60171a5 100644
--- a/sys/kern/kern_fork.c
+++ b/sys/kern/kern_fork.c
@@ -285,7 +285,7 @@ fork1(p1, flags, procp)
 	 * If RFHIGHPID is set (used during system boot), do not allocate
 	 * low-numbered pids.
 	 */
-	lockmgr(&allproc_lock, LK_EXCLUSIVE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_EXCLUSIVE);
 	trypid = nextpid + 1;
 	if (flags & RFHIGHPID) {
 		if (trypid < 10) {
@@ -355,7 +355,7 @@ again:
 	p2->p_pid = trypid;
 	LIST_INSERT_HEAD(&allproc, p2, p_list);
 	LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 
 	/*
 	 * Make a proc table entry for the new process.
diff --git a/sys/kern/kern_ktrace.c b/sys/kern/kern_ktrace.c
index 2d3b08d..59321fe 100644
--- a/sys/kern/kern_ktrace.c
+++ b/sys/kern/kern_ktrace.c
@@ -278,7 +278,7 @@ ktrace(curp, uap)
 	 * Clear all uses of the tracefile
 	 */
 	if (ops == KTROP_CLEARFILE) {
-		lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+		ALLPROC_LOCK(AP_SHARED);
 		LIST_FOREACH(p, &allproc, p_list) {
 			if (p->p_tracep == vp) {
 				if (ktrcanset(curp, p)) {
@@ -290,7 +290,7 @@ ktrace(curp, uap)
 					error = EPERM;
 			}
 		}
-		lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+		ALLPROC_LOCK(AP_RELEASE);
 		goto done;
 	}
 	/*
@@ -496,7 +496,7 @@ ktrwrite(vp, kth, uio)
 	 */
 	log(LOG_NOTICE, "ktrace write failed, errno %d, tracing stopped\n",
 	    error);
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		if (p->p_tracep == vp) {
 			p->p_tracep = NULL;
@@ -504,7 +504,7 @@ ktrwrite(vp, kth, uio)
 			vrele(vp);
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 }
 
 /*
diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c
index 793c068..814a29e 100644
--- a/sys/kern/kern_proc.c
+++ b/sys/kern/kern_proc.c
@@ -122,11 +122,11 @@ pfind(pid)
 {
 	register struct proc *p;
 
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, PIDHASH(pid), p_hash)
 		if (p->p_pid == pid)
 			break;
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	return (p);
 }
 
@@ -478,10 +478,12 @@ zpfind(pid_t pid)
 {
 	struct proc *p;
 
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &zombproc, p_list)
 		if (p->p_pid == pid)
-			return (p);
-	return (NULL);
+			break;
+	ALLPROC_LOCK(AP_RELEASE);
+	return (p);
 }
 
 
@@ -536,7 +538,7 @@ sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
 		if (error)
 			return (error);
 	}
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
 		if (!doingzomb)
 			p = LIST_FIRST(&allproc);
@@ -593,13 +595,12 @@ sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
 
 			error = sysctl_out_proc(p, req, doingzomb);
 			if (error) {
-				lockmgr(&allproc_lock, LK_RELEASE, NULL,
-				    CURPROC);
+				ALLPROC_LOCK(AP_RELEASE);
 				return (error);
 			}
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	return (0);
 }
 
diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c
index a10c2c9..b852cf6 100644
--- a/sys/kern/kern_resource.c
+++ b/sys/kern/kern_resource.c
@@ -121,13 +121,13 @@ getpriority(curp, uap)
 	case PRIO_USER:
 		if (uap->who == 0)
 			uap->who = curp->p_ucred->cr_uid;
-		lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+		ALLPROC_LOCK(AP_SHARED);
 		LIST_FOREACH(p, &allproc, p_list)
 			if (!p_can(curp, p, P_CAN_SEE, NULL) &&
 			    p->p_ucred->cr_uid == uap->who &&
 			    p->p_nice < low)
 				low = p->p_nice;
-		lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+		ALLPROC_LOCK(AP_RELEASE);
 		break;
 
 	default:
@@ -189,14 +189,14 @@ setpriority(curp, uap)
 	case PRIO_USER:
 		if (uap->who == 0)
 			uap->who = curp->p_ucred->cr_uid;
-		lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+		ALLPROC_LOCK(AP_SHARED);
 		LIST_FOREACH(p, &allproc, p_list)
 			if (p->p_ucred->cr_uid == uap->who &&
 			    !p_can(curp, p, P_CAN_SEE, NULL)) {
 				error = donice(curp, p, uap->prio);
 				found++;
 			}
-		lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+		ALLPROC_LOCK(AP_RELEASE);
 		break;
 
 	default:
diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c
index a6d9f75..c49c336 100644
--- a/sys/kern/kern_sig.c
+++ b/sys/kern/kern_sig.c
@@ -864,7 +864,7 @@ killpg1(cp, sig, pgid, all)
 		/*
 		 * broadcast
 		 */
-		lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+		ALLPROC_LOCK(AP_SHARED);
 		LIST_FOREACH(p, &allproc, p_list) {
 			if (p->p_pid <= 1 || p->p_flag & P_SYSTEM ||
 			    p == cp || !CANSIGNAL(cp, p, sig))
@@ -873,7 +873,7 @@ killpg1(cp, sig, pgid, all)
 			if (sig)
 				psignal(p, sig);
 		}
-		lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+		ALLPROC_LOCK(AP_RELEASE);
 	} else {
 		if (pgid == 0)
 			/*
diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c
index 7d98775..90b9fa3 100644
--- a/sys/kern/kern_synch.c
+++ b/sys/kern/kern_synch.c
@@ -287,7 +287,7 @@ schedcpu(arg)
 	register int realstathz, s;
 
 	realstathz = stathz ? stathz : hz;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		/*
 		 * Increment time in/out of memory and sleep time
@@ -347,7 +347,7 @@ schedcpu(arg)
 		mtx_exit(&sched_lock, MTX_SPIN);
 		splx(s);
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	vmmeter();
 	wakeup((caddr_t)&lbolt);
 	callout_reset(&schedcpu_callout, hz, schedcpu, NULL);
diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c
index 5f1a1d4..16e8984 100644
--- a/sys/kern/vfs_extattr.c
+++ b/sys/kern/vfs_extattr.c
@@ -365,7 +365,7 @@ checkdirs(olddp)
 		return;
 	if (VFS_ROOT(olddp->v_mountedhere, &newdp))
 		panic("mount: lost mount");
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		fdp = p->p_fd;
 		if (fdp->fd_cdir == olddp) {
@@ -379,7 +379,7 @@ checkdirs(olddp)
 			fdp->fd_rdir = newdp;
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	if (rootvnode == olddp) {
 		vrele(rootvnode);
 		VREF(newdp);
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index 5f1a1d4..16e8984 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -365,7 +365,7 @@ checkdirs(olddp)
 		return;
 	if (VFS_ROOT(olddp->v_mountedhere, &newdp))
 		panic("mount: lost mount");
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	LIST_FOREACH(p, &allproc, p_list) {
 		fdp = p->p_fd;
 		if (fdp->fd_cdir == olddp) {
@@ -379,7 +379,7 @@ checkdirs(olddp)
 			fdp->fd_rdir = newdp;
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	if (rootvnode == olddp) {
 		vrele(rootvnode);
 		VREF(newdp);
diff --git a/sys/miscfs/procfs/procfs_vnops.c b/sys/miscfs/procfs/procfs_vnops.c
index e37f3c2..05ad13a 100644
--- a/sys/miscfs/procfs/procfs_vnops.c
+++ b/sys/miscfs/procfs/procfs_vnops.c
@@ -820,8 +820,10 @@ procfs_readdir(ap)
 		int doingzomb = 0;
 #endif
 		int pcnt = 0;
-		struct proc *p = allproc.lh_first;
+		struct proc *p;
 
+		ALLPROC_LOCK(AP_SHARED);
+		p = allproc.lh_first;
 		for (; p && uio->uio_resid >= delen; i++, pcnt++) {
 			bzero((char *) dp, delen);
 			dp->d_reclen = delen;
@@ -878,6 +880,7 @@ procfs_readdir(ap)
 		}
 #endif
 
+		ALLPROC_LOCK(AP_RELEASE);
 		break;
 
 	    }
diff --git a/sys/sys/proc.h b/sys/sys/proc.h
index c1e1b20..4f94cd2 100644
--- a/sys/sys/proc.h
+++ b/sys/sys/proc.h
@@ -407,6 +407,14 @@ sigonstack(size_t sp)
 #define PROC_LOCK(p)	mtx_enter(&(p)->p_mtx, MTX_DEF)
 #define PROC_UNLOCK(p)	mtx_exit(&(p)->p_mtx, MTX_DEF)
 
+/* Lock and unlock the proc lists. */
+#define	ALLPROC_LOCK(how)						\
+	lockmgr(&allproc_lock, (how), NULL, CURPROC)
+
+#define	AP_SHARED	LK_SHARED
+#define	AP_EXCLUSIVE	LK_EXCLUSIVE
+#define	AP_RELEASE	LK_RELEASE
+
 /* Hold process U-area in memory, normally for ptrace/procfs work. */
 #define PHOLD(p) do {							\
 	PROC_LOCK(p);							\
diff --git a/sys/vm/vm_glue.c b/sys/vm/vm_glue.c
index 3bc4d11..b1da607 100644
--- a/sys/vm/vm_glue.c
+++ b/sys/vm/vm_glue.c
@@ -360,7 +360,7 @@ loop:
 
 	pp = NULL;
 	ppri = INT_MIN;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 		mtx_enter(&sched_lock, MTX_SPIN);
 		if (p->p_stat == SRUN &&
@@ -383,7 +383,7 @@ loop:
 		}
 		mtx_exit(&sched_lock, MTX_SPIN);
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 
 	/*
 	 * Nothing to do, back to sleep.
@@ -443,7 +443,7 @@ int action;
 
 	outp = outp2 = NULL;
 	outpri = outpri2 = INT_MIN;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 retry:
 	for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 		struct vmspace *vm;
@@ -516,7 +516,7 @@ retry:
 			}
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	/*
 	 * If we swapped something out, and another process needed memory,
 	 * then wakeup the sched process.
diff --git a/sys/vm/vm_meter.c b/sys/vm/vm_meter.c
index 9ed122e..3e573d7 100644
--- a/sys/vm/vm_meter.c
+++ b/sys/vm/vm_meter.c
@@ -78,7 +78,7 @@ loadav(struct loadavg *avg)
 	register int i, nrun;
 	register struct proc *p;
 
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	for (nrun = 0, p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 		switch (p->p_stat) {
 		case SSLEEP:
@@ -93,7 +93,7 @@ loadav(struct loadavg *avg)
 			nrun++;
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	for (i = 0; i < 3; i++)
 		avg->ldavg[i] = (cexp[i] * avg->ldavg[i] +
 		    nrun * FSCALE * (FSCALE - cexp[i])) >> FSHIFT;
@@ -151,7 +151,7 @@ vmtotal(SYSCTL_HANDLER_ARGS)
 	/*
 	 * Calculate process statistics.
 	 */
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 		if (p->p_flag & P_SYSTEM)
 			continue;
@@ -202,7 +202,7 @@ vmtotal(SYSCTL_HANDLER_ARGS)
 		if (paging)
 			totalp->t_pw++;
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	/*
 	 * Calculate object memory usage statistics.
 	 */
diff --git a/sys/vm/vm_object.c b/sys/vm/vm_object.c
index 0b079c3..ddb9ab7 100644
--- a/sys/vm/vm_object.c
+++ b/sys/vm/vm_object.c
@@ -1620,16 +1620,16 @@ vm_object_in_map( object)
 	vm_object_t object;
 {
 	struct proc *p;
-	lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+	ALLPROC_LOCK(AP_SHARED);
 	for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 		if( !p->p_vmspace /* || (p->p_flag & (P_SYSTEM|P_WEXIT)) */)
 			continue;
 		if( _vm_object_in_map(&p->p_vmspace->vm_map, object, 0)) {
-			lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+			ALLPROC_LOCK(AP_RELEASE);
 			return 1;
 		}
 	}
-	lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+	ALLPROC_LOCK(AP_RELEASE);
 	if( _vm_object_in_map( kernel_map, object, 0))
 		return 1;
 	if( _vm_object_in_map( kmem_map, object, 0))
diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c
index 90ab288..6a52166 100644
--- a/sys/vm/vm_pageout.c
+++ b/sys/vm/vm_pageout.c
@@ -1132,7 +1132,7 @@ rescan0:
 	if ((vm_swap_size < 64 || swap_pager_full) && vm_page_count_min()) {
 		bigproc = NULL;
 		bigsize = 0;
-		lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+		ALLPROC_LOCK(AP_SHARED);
 		for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 			/*
 			 * if this is a system process, skip it
@@ -1165,7 +1165,7 @@ rescan0:
 				bigsize = size;
 			}
 		}
-		lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+		ALLPROC_LOCK(AP_RELEASE);
 		if (bigproc != NULL) {
 			killproc(bigproc, "out of swap space");
 			bigproc->p_estcpu = 0;
@@ -1450,7 +1450,7 @@ vm_daemon()
 		 * process is swapped out -- deactivate pages
 		 */
 
-		lockmgr(&allproc_lock, LK_SHARED, NULL, CURPROC);
+		ALLPROC_LOCK(AP_SHARED);
 		for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
 			vm_pindex_t limit, size;
 
@@ -1492,7 +1492,7 @@ vm_daemon()
 				    &p->p_vmspace->vm_map, limit);
 			}
 		}
-		lockmgr(&allproc_lock, LK_RELEASE, NULL, CURPROC);
+		ALLPROC_LOCK(AP_RELEASE);
 	}
 }
 #endif