system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-09-20 08:44:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse source 
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.
This commit is contained in:
Jake Burkholder 2000-12-13 00:17:05 +00:00
parent 1b3335af6a
commit c0c2557090
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=69947
24 changed files with 99 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
sys/alpha/alpha/pmap.c
View file

@ -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

6
sys/amd64/amd64/pmap.c
View file

@ -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

11
sys/compat/svr4/svr4_misc.c
View file

@ -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 @@ svr4_sys_waitsys(p, uap)
*/
leavepgrp(q);
ALLPROC_LOCK(AP_EXCLUSIVE);
LIST_REMOVE(q, p_list); /* off zombproc */
ALLPROC_LOCK(AP_RELEASE);
LIST_REMOVE(q, p_sibling);

5
sys/fs/procfs/procfs_vnops.c
View file

@ -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;
}

6
sys/i386/i386/pmap.c
View file

@ -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

12
sys/i386/ibcs2/ibcs2_sysvec.c
View file

@ -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",

6
sys/ia64/ia64/pmap.c
View file

@ -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

4
sys/kern/imgact_elf.c
View file

@ -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);
}

4
sys/kern/init_main.c
View file

@ -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);

8
sys/kern/kern_exit.c
View file

@ -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 @@ wait1(q, uap, compat)
* 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) {

4
sys/kern/kern_fork.c
View file

@ -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 @@ fork1(p1, flags, procp)
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.

8
sys/kern/kern_ktrace.c
View file

@ -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);
}
/*

17
sys/kern/kern_proc.c
View file

@ -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);
}

8
sys/kern/kern_resource.c
View file

@ -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:

4
sys/kern/kern_sig.c
View file

@ -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)
/*

4
sys/kern/kern_synch.c
View file

@ -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);

4
sys/kern/vfs_extattr.c
View file

@ -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);

4
sys/kern/vfs_syscalls.c
View file

@ -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);

5
sys/miscfs/procfs/procfs_vnops.c
View file

@ -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;
}

8
sys/sys/proc.h
View file

@ -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); \

8
sys/vm/vm_glue.c
View file

@ -360,7 +360,7 @@ scheduler(dummy)
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 @@ scheduler(dummy)
}
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 @@ int action;
}
}
}
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.

8
sys/vm/vm_meter.c
View file

@ -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.
*/

6
sys/vm/vm_object.c
View file

@ -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))

8
sys/vm/vm_pageout.c
View file

@ -1132,7 +1132,7 @@ vm_pageout_scan()
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 @@ vm_pageout_scan()
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