summaryrefslogtreecommitdiff
path: root/sys/kern
diff options
context:
space:
mode:
Diffstat (limited to 'sys/kern')
-rw-r--r--sys/kern/imgact_elf.c6
-rw-r--r--sys/kern/init_main.c7
-rw-r--r--sys/kern/kern_exit.c33
-rw-r--r--sys/kern/kern_fork.c8
-rw-r--r--sys/kern/kern_kthread.c8
-rw-r--r--sys/kern/kern_ktrace.c13
-rw-r--r--sys/kern/kern_proc.c31
-rw-r--r--sys/kern/kern_resource.c9
-rw-r--r--sys/kern/kern_sig.c7
-rw-r--r--sys/kern/kern_synch.c13
-rw-r--r--sys/kern/sys_process.c13
-rw-r--r--sys/kern/vfs_extattr.c5
-rw-r--r--sys/kern/vfs_syscalls.c5
13 files changed, 85 insertions, 73 deletions
diff --git a/sys/kern/imgact_elf.c b/sys/kern/imgact_elf.c
index 048f47888a0b..da7b9cb522ef 100644
--- a/sys/kern/imgact_elf.c
+++ b/sys/kern/imgact_elf.c
@@ -50,6 +50,7 @@
#include <sys/systm.h>
#include <sys/signalvar.h>
#include <sys/stat.h>
+#include <sys/sx.h>
#include <sys/syscall.h>
#include <sys/sysctl.h>
#include <sys/sysent.h>
@@ -59,7 +60,6 @@
#include <vm/vm_kern.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>
-#include <sys/lock.h>
#include <vm/vm_map.h>
#include <vm/vm_object.h>
#include <vm/vm_extern.h>
@@ -157,14 +157,14 @@ elf_brand_inuse(Elf_Brandinfo *entry)
struct proc *p;
int rval = FALSE;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
if (p->p_sysent == entry->sysvec) {
rval = TRUE;
break;
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
return (rval);
}
diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c
index 8ef28a1aa991..a882711e522b 100644
--- a/sys/kern/init_main.c
+++ b/sys/kern/init_main.c
@@ -49,6 +49,7 @@
#include <sys/filedesc.h>
#include <sys/kernel.h>
#include <sys/ktr.h>
+#include <sys/lock.h>
#include <sys/mount.h>
#include <sys/mutex.h>
#include <sys/sysctl.h>
@@ -59,6 +60,7 @@
#include <sys/vnode.h>
#include <sys/sysent.h>
#include <sys/reboot.h>
+#include <sys/sx.h>
#include <sys/sysproto.h>
#include <sys/vmmeter.h>
#include <sys/unistd.h>
@@ -70,7 +72,6 @@
#include <vm/vm.h>
#include <vm/vm_param.h>
-#include <sys/lock.h>
#include <vm/pmap.h>
#include <vm/vm_map.h>
#include <sys/user.h>
@@ -393,12 +394,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.
*/
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
microtime(&p->p_stats->p_start);
p->p_runtime = 0;
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
microuptime(PCPU_PTR(switchtime));
PCPU_SET(switchticks, ticks);
diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c
index dec02a57ca7b..3267b21b2574 100644
--- a/sys/kern/kern_exit.c
+++ b/sys/kern/kern_exit.c
@@ -56,6 +56,7 @@
#include <sys/vnode.h>
#include <sys/resourcevar.h>
#include <sys/signalvar.h>
+#include <sys/sx.h>
#include <sys/ptrace.h>
#include <sys/acct.h> /* for acct_process() function prototype */
#include <sys/filedesc.h>
@@ -279,13 +280,13 @@ exit1(p, rv)
* Remove proc from allproc queue and pidhash chain.
* Place onto zombproc. Unlink from parent's child list.
*/
- ALLPROC_LOCK(AP_EXCLUSIVE);
+ sx_xlock(&allproc_lock);
LIST_REMOVE(p, p_list);
LIST_INSERT_HEAD(&zombproc, p, p_list);
LIST_REMOVE(p, p_hash);
- ALLPROC_LOCK(AP_RELEASE);
+ sx_xunlock(&allproc_lock);
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
q = LIST_FIRST(&p->p_children);
if (q != NULL) /* only need this if any child is S_ZOMB */
wakeup((caddr_t) initproc);
@@ -357,7 +358,7 @@ exit1(p, rv)
psignal(p->p_pptr, SIGCHLD);
PROC_UNLOCK(p->p_pptr);
PROC_UNLOCK(p);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
/*
* Clear curproc after we've done all operations
@@ -435,7 +436,7 @@ wait1(q, uap, compat)
return (EINVAL);
loop:
nfound = 0;
- PROCTREE_LOCK(PT_SHARED);
+ sx_slock(&proctree_lock);
LIST_FOREACH(p, &q->p_children, p_sibling) {
if (uap->pid != WAIT_ANY &&
p->p_pid != uap->pid && p->p_pgid != -uap->pid)
@@ -467,7 +468,7 @@ loop:
mtx_unlock_spin(&sched_lock);
PROC_UNLOCK(p);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_sunlock(&proctree_lock);
q->p_retval[0] = p->p_pid;
#ifdef COMPAT_43
@@ -488,7 +489,7 @@ loop:
* If we got the child via a ptrace 'attach',
* we need to give it back to the old parent.
*/
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
if (p->p_oppid) {
if ((t = pfind(p->p_oppid)) != NULL) {
PROC_LOCK(p);
@@ -498,12 +499,12 @@ loop:
PROC_LOCK(t);
psignal(t, SIGCHLD);
PROC_UNLOCK(t);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
wakeup((caddr_t)t);
return (0);
}
}
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
PROC_LOCK(p);
p->p_xstat = 0;
PROC_UNLOCK(p);
@@ -546,13 +547,13 @@ loop:
*/
leavepgrp(p);
- ALLPROC_LOCK(AP_EXCLUSIVE);
+ sx_xlock(&allproc_lock);
LIST_REMOVE(p, p_list); /* off zombproc */
- ALLPROC_LOCK(AP_RELEASE);
+ sx_xunlock(&allproc_lock);
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
LIST_REMOVE(p, p_sibling);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
PROC_LOCK(p);
if (--p->p_procsig->ps_refcnt == 0) {
@@ -579,7 +580,7 @@ loop:
mtx_unlock_spin(&sched_lock);
p->p_flag |= P_WAITED;
PROC_UNLOCK(p);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_sunlock(&proctree_lock);
q->p_retval[0] = p->p_pid;
#ifdef COMPAT_43
if (compat) {
@@ -598,7 +599,7 @@ loop:
mtx_unlock_spin(&sched_lock);
PROC_UNLOCK(p);
}
- PROCTREE_LOCK(PT_RELEASE);
+ sx_sunlock(&proctree_lock);
if (nfound == 0)
return (ECHILD);
if (uap->options & WNOHANG) {
@@ -620,7 +621,7 @@ proc_reparent(child, parent)
register struct proc *parent;
{
- PROCTREE_ASSERT(PT_EXCLUSIVE);
+ SX_ASSERT_XLOCKED(&proctree_lock);
PROC_LOCK_ASSERT(child, MA_OWNED);
if (child->p_pptr == parent)
return;
diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c
index 8ae5bcf0e4dc..c9539bbb1f64 100644
--- a/sys/kern/kern_fork.c
+++ b/sys/kern/kern_fork.c
@@ -306,7 +306,7 @@ fork1(p1, flags, procp)
* If RFHIGHPID is set (used during system boot), do not allocate
* low-numbered pids.
*/
- ALLPROC_LOCK(AP_EXCLUSIVE);
+ sx_xlock(&allproc_lock);
trypid = nextpid + 1;
if (flags & RFHIGHPID) {
if (trypid < 10) {
@@ -376,7 +376,7 @@ again:
p2->p_pid = trypid;
LIST_INSERT_HEAD(&allproc, p2, p_list);
LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash);
- ALLPROC_LOCK(AP_RELEASE);
+ sx_xunlock(&allproc_lock);
/*
* Make a proc table entry for the new process.
@@ -516,12 +516,12 @@ again:
pptr = initproc;
else
pptr = p1;
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
PROC_LOCK(p2);
p2->p_pptr = pptr;
PROC_UNLOCK(p2);
LIST_INSERT_HEAD(&pptr->p_children, p2, p_sibling);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
PROC_LOCK(p2);
LIST_INIT(&p2->p_children);
LIST_INIT(&p2->p_contested);
diff --git a/sys/kern/kern_kthread.c b/sys/kern/kern_kthread.c
index 8dd9cd46606b..99eb7a4b4754 100644
--- a/sys/kern/kern_kthread.c
+++ b/sys/kern/kern_kthread.c
@@ -28,11 +28,13 @@
#include <sys/param.h>
#include <sys/systm.h>
-#include <sys/proc.h>
#include <sys/kthread.h>
#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/signalvar.h>
+#include <sys/sx.h>
#include <sys/unistd.h>
#include <sys/wait.h>
@@ -118,11 +120,11 @@ void
kthread_exit(int ecode)
{
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
PROC_LOCK(curproc);
proc_reparent(curproc, initproc);
PROC_UNLOCK(curproc);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
exit1(curproc, W_EXITCODE(ecode, 0));
}
diff --git a/sys/kern/kern_ktrace.c b/sys/kern/kern_ktrace.c
index 149bc4c6b6d2..93a2443fdd3a 100644
--- a/sys/kern/kern_ktrace.c
+++ b/sys/kern/kern_ktrace.c
@@ -47,6 +47,7 @@
#include <sys/vnode.h>
#include <sys/ktrace.h>
#include <sys/malloc.h>
+#include <sys/sx.h>
#include <sys/syslog.h>
#include <sys/jail.h>
@@ -279,7 +280,7 @@ ktrace(curp, uap)
* Clear all uses of the tracefile
*/
if (ops == KTROP_CLEARFILE) {
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
if (p->p_tracep == vp) {
if (ktrcanset(curp, p)) {
@@ -291,7 +292,7 @@ ktrace(curp, uap)
error = EPERM;
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
goto done;
}
/*
@@ -428,7 +429,7 @@ ktrsetchildren(curp, top, ops, facs, vp)
register int ret = 0;
p = top;
- PROCTREE_LOCK(PT_SHARED);
+ sx_slock(&proctree_lock);
for (;;) {
ret |= ktrops(curp, p, ops, facs, vp);
/*
@@ -440,7 +441,7 @@ ktrsetchildren(curp, top, ops, facs, vp)
p = LIST_FIRST(&p->p_children);
else for (;;) {
if (p == top) {
- PROCTREE_LOCK(PT_RELEASE);
+ sx_sunlock(&proctree_lock);
return (ret);
}
if (LIST_NEXT(p, p_sibling)) {
@@ -501,7 +502,7 @@ ktrwrite(vp, kth, uio)
*/
log(LOG_NOTICE, "ktrace write failed, errno %d, tracing stopped\n",
error);
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
if (p->p_tracep == vp) {
p->p_tracep = NULL;
@@ -509,7 +510,7 @@ ktrwrite(vp, kth, uio)
vrele(vp);
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
}
/*
diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c
index 36b01ef10369..67e78bba60fb 100644
--- a/sys/kern/kern_proc.c
+++ b/sys/kern/kern_proc.c
@@ -43,6 +43,7 @@
#include <sys/filedesc.h>
#include <sys/tty.h>
#include <sys/signalvar.h>
+#include <sys/sx.h>
#include <vm/vm.h>
#include <sys/lock.h>
#include <vm/pmap.h>
@@ -73,8 +74,8 @@ struct pgrphashhead *pgrphashtbl;
u_long pgrphash;
struct proclist allproc;
struct proclist zombproc;
-struct lock allproc_lock;
-struct lock proctree_lock;
+struct sx allproc_lock;
+struct sx proctree_lock;
vm_zone_t proc_zone;
vm_zone_t ithread_zone;
@@ -86,8 +87,8 @@ procinit()
{
int i, j;
- lockinit(&allproc_lock, PZERO, "allproc", 0, 0);
- lockinit(&proctree_lock, PZERO, "proctree", 0, 0);
+ sx_init(&allproc_lock, "allproc");
+ sx_init(&proctree_lock, "proctree");
LIST_INIT(&allproc);
LIST_INIT(&zombproc);
pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
@@ -120,13 +121,13 @@ inferior(p)
{
int rval = 1;
- PROCTREE_LOCK(PT_SHARED);
+ sx_slock(&proctree_lock);
for (; p != curproc; p = p->p_pptr)
if (p->p_pid == 0) {
rval = 0;
break;
}
- PROCTREE_LOCK(PT_RELEASE);
+ sx_sunlock(&proctree_lock);
return (rval);
}
@@ -139,11 +140,11 @@ pfind(pid)
{
register struct proc *p;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, PIDHASH(pid), p_hash)
if (p->p_pid == pid)
break;
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
return (p);
}
@@ -308,7 +309,7 @@ fixjobc(p, pgrp, entering)
* Check p's parent to see whether p qualifies its own process
* group; if so, adjust count for p's process group.
*/
- PROCTREE_LOCK(PT_SHARED);
+ sx_slock(&proctree_lock);
if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
hispgrp->pg_session == mysession) {
if (entering)
@@ -331,7 +332,7 @@ fixjobc(p, pgrp, entering)
else if (--hispgrp->pg_jobc == 0)
orphanpg(hispgrp);
}
- PROCTREE_LOCK(PT_RELEASE);
+ sx_sunlock(&proctree_lock);
}
/*
@@ -520,11 +521,11 @@ zpfind(pid_t pid)
{
struct proc *p;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &zombproc, p_list)
if (p->p_pid == pid)
break;
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
return (p);
}
@@ -580,7 +581,7 @@ sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
if (error)
return (error);
}
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
if (!doingzomb)
p = LIST_FIRST(&allproc);
@@ -637,12 +638,12 @@ sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
error = sysctl_out_proc(p, req, doingzomb);
if (error) {
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
return (error);
}
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
return (0);
}
diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c
index 61ec3300052f..fa1add18d109 100644
--- a/sys/kern/kern_resource.c
+++ b/sys/kern/kern_resource.c
@@ -52,6 +52,7 @@
#include <sys/mutex.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
+#include <sys/sx.h>
#include <sys/time.h>
#include <vm/vm.h>
@@ -120,13 +121,13 @@ getpriority(curp, uap)
case PRIO_USER:
if (uap->who == 0)
uap->who = curp->p_ucred->cr_uid;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
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;
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
break;
default:
@@ -188,14 +189,14 @@ setpriority(curp, uap)
case PRIO_USER:
if (uap->who == 0)
uap->who = curp->p_ucred->cr_uid;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
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++;
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
break;
default:
diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c
index 3fb860e497a9..c5294108951f 100644
--- a/sys/kern/kern_sig.c
+++ b/sys/kern/kern_sig.c
@@ -62,8 +62,9 @@
#include <sys/ktr.h>
#include <sys/ktrace.h>
#include <sys/resourcevar.h>
-#include <sys/syslog.h>
#include <sys/stat.h>
+#include <sys/sx.h>
+#include <sys/syslog.h>
#include <sys/sysent.h>
#include <sys/sysctl.h>
#include <sys/malloc.h>
@@ -897,7 +898,7 @@ killpg1(cp, sig, pgid, all)
/*
* broadcast
*/
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
PROC_LOCK(p);
if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || p == cp) {
@@ -918,7 +919,7 @@ killpg1(cp, sig, pgid, all)
PROC_UNLOCK(p);
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
} else {
if (pgid == 0)
/*
diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c
index 5a3cd80be27e..13bb1404de38 100644
--- a/sys/kern/kern_synch.c
+++ b/sys/kern/kern_synch.c
@@ -43,18 +43,19 @@
#include <sys/param.h>
#include <sys/systm.h>
-#include <sys/proc.h>
+#include <sys/condvar.h>
#include <sys/ipl.h>
#include <sys/kernel.h>
#include <sys/ktr.h>
-#include <sys/condvar.h>
#include <sys/lock.h>
#include <sys/mutex.h>
-#include <sys/signalvar.h>
+#include <sys/proc.h>
#include <sys/resourcevar.h>
-#include <sys/vmmeter.h>
+#include <sys/signalvar.h>
+#include <sys/sx.h>
#include <sys/sysctl.h>
#include <sys/sysproto.h>
+#include <sys/vmmeter.h>
#include <vm/vm.h>
#include <vm/vm_extern.h>
#ifdef KTRACE
@@ -241,7 +242,7 @@ schedcpu(arg)
register int realstathz, s;
realstathz = stathz ? stathz : hz;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
/*
* Increment time in/out of memory and sleep time
@@ -302,7 +303,7 @@ schedcpu(arg)
mtx_unlock_spin(&sched_lock);
splx(s);
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
vmmeter();
wakeup((caddr_t)&lbolt);
callout_reset(&schedcpu_callout, hz, schedcpu, NULL);
diff --git a/sys/kern/sys_process.c b/sys/kern/sys_process.c
index a0efa6fcefaf..4255c142c7a5 100644
--- a/sys/kern/sys_process.c
+++ b/sys/kern/sys_process.c
@@ -37,6 +37,7 @@
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/ptrace.h>
+#include <sys/sx.h>
#include <machine/reg.h>
#include <vm/vm.h>
@@ -320,24 +321,24 @@ ptrace(curp, uap)
switch (uap->req) {
case PT_TRACE_ME:
/* set my trace flag and "owner" so it can read/write me */
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
PROC_LOCK(p);
p->p_flag |= P_TRACED;
p->p_oppid = p->p_pptr->p_pid;
PROC_UNLOCK(p);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
return 0;
case PT_ATTACH:
/* security check done above */
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
PROC_LOCK(p);
p->p_flag |= P_TRACED;
p->p_oppid = p->p_pptr->p_pid;
if (p->p_pptr != curp)
proc_reparent(p, curp);
PROC_UNLOCK(p);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
uap->data = SIGSTOP;
goto sendsig; /* in PT_CONTINUE below */
@@ -368,7 +369,7 @@ ptrace(curp, uap)
if (uap->req == PT_DETACH) {
/* reset process parent */
- PROCTREE_LOCK(PT_EXCLUSIVE);
+ sx_xlock(&proctree_lock);
if (p->p_oppid != p->p_pptr->p_pid) {
struct proc *pp;
@@ -381,7 +382,7 @@ ptrace(curp, uap)
p->p_oppid = 0;
PROC_UNLOCK(p);
- PROCTREE_LOCK(PT_RELEASE);
+ sx_xunlock(&proctree_lock);
/* should we send SIGCHLD? */
diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c
index 88c9cb742714..407d6851449b 100644
--- a/sys/kern/vfs_extattr.c
+++ b/sys/kern/vfs_extattr.c
@@ -59,6 +59,7 @@
#include <sys/file.h>
#include <sys/linker.h>
#include <sys/stat.h>
+#include <sys/sx.h>
#include <sys/unistd.h>
#include <sys/vnode.h>
#include <sys/proc.h>
@@ -415,7 +416,7 @@ checkdirs(olddp, newdp)
if (olddp->v_usecount == 1)
return;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
fdp = p->p_fd;
if (fdp == NULL)
@@ -431,7 +432,7 @@ checkdirs(olddp, newdp)
fdp->fd_rdir = newdp;
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
if (rootvnode == olddp) {
vrele(rootvnode);
VREF(newdp);
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index 88c9cb742714..407d6851449b 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -59,6 +59,7 @@
#include <sys/file.h>
#include <sys/linker.h>
#include <sys/stat.h>
+#include <sys/sx.h>
#include <sys/unistd.h>
#include <sys/vnode.h>
#include <sys/proc.h>
@@ -415,7 +416,7 @@ checkdirs(olddp, newdp)
if (olddp->v_usecount == 1)
return;
- ALLPROC_LOCK(AP_SHARED);
+ sx_slock(&allproc_lock);
LIST_FOREACH(p, &allproc, p_list) {
fdp = p->p_fd;
if (fdp == NULL)
@@ -431,7 +432,7 @@ checkdirs(olddp, newdp)
fdp->fd_rdir = newdp;
}
}
- ALLPROC_LOCK(AP_RELEASE);
+ sx_sunlock(&allproc_lock);
if (rootvnode == olddp) {
vrele(rootvnode);
VREF(newdp);
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-07 05:27:39 +0000