-/* $OpenBSD: kern_exit.c,v 1.220 2024/01/19 01:43:26 bluhm Exp $ */
+/* $OpenBSD: kern_exit.c,v 1.221 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: kern_exit.c,v 1.39 1996/04/22 01:38:25 christos Exp $ */
/*
/* nope, multi-threaded */
if (flags == EXIT_NORMAL)
single_thread_set(p, SINGLE_EXIT);
- else if (flags == EXIT_THREAD)
- single_thread_check(p, 0);
}
if (flags == EXIT_NORMAL && !(pr->ps_flags & PS_EXITING)) {
}
/* unlink ourselves from the active threads */
- SCHED_LOCK(s);
+ mtx_enter(&pr->ps_mtx);
TAILQ_REMOVE(&pr->ps_threads, p, p_thr_link);
- SCHED_UNLOCK(s);
+ pr->ps_threadcnt--;
+ pr->ps_exitcnt++;
+
+ /*
+ * if somebody else wants to take us to single threaded mode,
+ * count ourselves out.
+ */
+ if (pr->ps_single) {
+ if (--pr->ps_singlecnt == 0)
+ wakeup(&pr->ps_singlecnt);
+ }
if ((p->p_flag & P_THREAD) == 0) {
/* main thread gotta wait because it has the pid, et al */
- while (pr->ps_threadcnt > 1)
- tsleep_nsec(&pr->ps_threads, PWAIT, "thrdeath", INFSLP);
+ while (pr->ps_threadcnt + pr->ps_exitcnt > 1)
+ msleep_nsec(&pr->ps_threads, &pr->ps_mtx, PWAIT,
+ "thrdeath", INFSLP);
}
+ mtx_leave(&pr->ps_mtx);
rup = pr->ps_ru;
if (rup == NULL) {
/* just a thread? detach it from its process */
if (p->p_flag & P_THREAD) {
/* scheduler_wait_hook(pr->ps_mainproc, p); XXX */
- if (--pr->ps_threadcnt == 1)
+ mtx_enter(&pr->ps_mtx);
+ pr->ps_exitcnt--;
+ if (pr->ps_threadcnt + pr->ps_exitcnt == 1)
wakeup(&pr->ps_threads);
- KASSERT(pr->ps_threadcnt > 0);
+ mtx_leave(&pr->ps_mtx);
}
/*
if (otvp)
vrele(otvp);
- KASSERT(pr->ps_threadcnt == 1);
+ KASSERT(pr->ps_threadcnt == 0);
+ KASSERT(pr->ps_exitcnt == 1);
if (pr->ps_ptstat != NULL)
free(pr->ps_ptstat, M_SUBPROC, sizeof(*pr->ps_ptstat));
pool_put(&rusage_pool, pr->ps_ru);
-/* $OpenBSD: kern_fork.c,v 1.257 2024/01/24 19:23:38 cheloha Exp $ */
+/* $OpenBSD: kern_fork.c,v 1.258 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: kern_fork.c,v 1.29 1996/02/09 18:59:34 christos Exp $ */
/*
struct proc *p;
pid_t tid;
vaddr_t uaddr;
- int s, error;
+ int error;
if (stack == NULL)
return EINVAL;
/* other links */
p->p_p = pr;
- pr->ps_threadcnt++;
/* local copies */
p->p_fd = pr->ps_fd;
LIST_INSERT_HEAD(&allproc, p, p_list);
LIST_INSERT_HEAD(TIDHASH(p->p_tid), p, p_hash);
- SCHED_LOCK(s);
+ mtx_enter(&pr->ps_mtx);
TAILQ_INSERT_TAIL(&pr->ps_threads, p, p_thr_link);
+ pr->ps_threadcnt++;
/*
* if somebody else wants to take us to single threaded mode,
* count ourselves in.
*/
if (pr->ps_single) {
- atomic_inc_int(&pr->ps_singlecount);
+ pr->ps_singlecnt++;
atomic_setbits_int(&p->p_flag, P_SUSPSINGLE);
}
- SCHED_UNLOCK(s);
+ mtx_leave(&pr->ps_mtx);
/*
* Return tid to parent thread and copy it out to userspace
-/* $OpenBSD: kern_proc.c,v 1.97 2024/01/19 01:43:27 bluhm Exp $ */
+/* $OpenBSD: kern_proc.c,v 1.98 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: kern_proc.c,v 1.14 1996/02/09 18:59:41 christos Exp $ */
/*
p->p_p->ps_flags, PS_BITS, p->p_flag, P_BITS);
(*pr)(" runpri=%u, usrpri=%u, slppri=%u, nice=%d\n",
p->p_runpri, p->p_usrpri, p->p_slppri, p->p_p->ps_nice);
- (*pr)(" wchan=%p, wmesg=%s, ps_single=%p\n",
+ (*pr)(" wchan=%p, wmesg=%s, ps_single=%p scnt=%d ecnt=%d\n",
p->p_wchan, (p->p_wchan && p->p_wmesg) ? p->p_wmesg : "",
- p->p_p->ps_single);
+ p->p_p->ps_single, p->p_p->ps_singlecnt, p->p_p->ps_exitcnt);
(*pr)(" forw=%p, list=%p,%p\n",
TAILQ_NEXT(p, p_runq), p->p_list.le_next, p->p_list.le_prev);
(*pr)(" process=%p user=%p, vmspace=%p\n",
-/* $OpenBSD: kern_resource.c,v 1.81 2024/04/17 09:41:44 claudio Exp $ */
+/* $OpenBSD: kern_resource.c,v 1.82 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: kern_resource.c,v 1.38 1996/10/23 07:19:38 matthias Exp $ */
/*-
if (n < chgpr->ps_nice && suser(curp))
return (EACCES);
chgpr->ps_nice = n;
- SCHED_LOCK(s);
+ mtx_enter(&chgpr->ps_mtx);
TAILQ_FOREACH(p, &chgpr->ps_threads, p_thr_link) {
+ SCHED_LOCK(s);
setpriority(p, p->p_estcpu, n);
+ SCHED_UNLOCK(s);
}
- SCHED_UNLOCK(s);
+ mtx_leave(&chgpr->ps_mtx);
return (0);
}
-/* $OpenBSD: kern_sig.c,v 1.327 2024/05/08 13:05:33 claudio Exp $ */
+/* $OpenBSD: kern_sig.c,v 1.328 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: kern_sig.c,v 1.54 1996/04/22 01:38:32 christos Exp $ */
/*
}
int
-single_thread_check_locked(struct proc *p, int deep, int s)
+single_thread_check_locked(struct proc *p, int deep)
{
struct process *pr = p->p_p;
+ int s;
- SCHED_ASSERT_LOCKED();
+ MUTEX_ASSERT_LOCKED(&pr->ps_mtx);
if (pr->ps_single == NULL || pr->ps_single == p)
return (0);
return (EINTR);
}
- if (atomic_dec_int_nv(&pr->ps_singlecount) == 0)
- wakeup(&pr->ps_singlecount);
-
if (pr->ps_flags & PS_SINGLEEXIT) {
- SCHED_UNLOCK(s);
+ mtx_leave(&pr->ps_mtx);
KERNEL_LOCK();
exit1(p, 0, 0, EXIT_THREAD_NOCHECK);
/* NOTREACHED */
}
+ if (--pr->ps_singlecnt == 0)
+ wakeup(&pr->ps_singlecnt);
+
/* not exiting and don't need to unwind, so suspend */
+ mtx_leave(&pr->ps_mtx);
+
+ SCHED_LOCK(s);
p->p_stat = SSTOP;
mi_switch();
+ SCHED_UNLOCK(s);
+ mtx_enter(&pr->ps_mtx);
} while (pr->ps_single != NULL);
return (0);
int
single_thread_check(struct proc *p, int deep)
{
- int s, error;
+ int error;
- SCHED_LOCK(s);
- error = single_thread_check_locked(p, deep, s);
- SCHED_UNLOCK(s);
+ mtx_enter(&p->p_p->ps_mtx);
+ error = single_thread_check_locked(p, deep);
+ mtx_leave(&p->p_p->ps_mtx);
return error;
}
KASSERT(curproc == p);
- SCHED_LOCK(s);
- error = single_thread_check_locked(p, flags & SINGLE_DEEP, s);
+ mtx_enter(&pr->ps_mtx);
+ error = single_thread_check_locked(p, flags & SINGLE_DEEP);
if (error) {
- SCHED_UNLOCK(s);
+ mtx_leave(&pr->ps_mtx);
return error;
}
panic("single_thread_mode = %d", mode);
#endif
}
- pr->ps_singlecount = 0;
- membar_producer();
pr->ps_single = p;
+ pr->ps_singlecnt = pr->ps_threadcnt;
+
TAILQ_FOREACH(q, &pr->ps_threads, p_thr_link) {
if (q == p)
continue;
- if (q->p_flag & P_WEXIT) {
- if (mode == SINGLE_EXIT) {
- if (q->p_stat == SSTOP) {
- unsleep(q);
- setrunnable(q);
- atomic_inc_int(&pr->ps_singlecount);
- }
- }
- continue;
- }
+ SCHED_LOCK(s);
atomic_setbits_int(&q->p_flag, P_SUSPSINGLE);
switch (q->p_stat) {
case SIDL:
- case SRUN:
- atomic_inc_int(&pr->ps_singlecount);
+ case SDEAD:
break;
case SSLEEP:
/* if it's not interruptible, then just have to wait */
/* merely need to suspend? just stop it */
if (mode == SINGLE_SUSPEND) {
q->p_stat = SSTOP;
+ --pr->ps_singlecnt;
break;
}
/* need to unwind or exit, so wake it */
unsleep(q);
setrunnable(q);
}
- atomic_inc_int(&pr->ps_singlecount);
break;
case SSTOP:
if (mode == SINGLE_EXIT) {
unsleep(q);
setrunnable(q);
- atomic_inc_int(&pr->ps_singlecount);
- }
- break;
- case SDEAD:
+ } else
+ --pr->ps_singlecnt;
break;
case SONPROC:
- atomic_inc_int(&pr->ps_singlecount);
signotify(q);
+ /* FALLTHROUGH */
+ case SRUN:
break;
}
+ SCHED_UNLOCK(s);
}
- SCHED_UNLOCK(s);
+
+ /* count ourselfs out */
+ --pr->ps_singlecnt;
+ mtx_leave(&pr->ps_mtx);
if ((flags & SINGLE_NOWAIT) == 0)
single_thread_wait(pr, 1);
int wait;
/* wait until they're all suspended */
- wait = pr->ps_singlecount > 0;
- while (wait) {
- sleep_setup(&pr->ps_singlecount, PWAIT, "suspend");
- wait = pr->ps_singlecount > 0;
- sleep_finish(0, wait);
+ mtx_enter(&pr->ps_mtx);
+ while ((wait = pr->ps_singlecnt > 0)) {
+ msleep_nsec(&pr->ps_singlecnt, &pr->ps_mtx, PWAIT, "suspend",
+ INFSLP);
if (!recheck)
break;
}
+ mtx_leave(&pr->ps_mtx);
return wait;
}
KASSERT(pr->ps_single == p);
KASSERT(curproc == p);
- SCHED_LOCK(s);
+ mtx_enter(&pr->ps_mtx);
pr->ps_single = NULL;
atomic_clearbits_int(&pr->ps_flags, PS_SINGLEUNWIND | PS_SINGLEEXIT);
+
TAILQ_FOREACH(q, &pr->ps_threads, p_thr_link) {
if (q == p || (q->p_flag & P_SUSPSINGLE) == 0)
continue;
* then clearing that either makes it runnable or puts
* it back into some sleep queue
*/
+ SCHED_LOCK(s);
if (q->p_stat == SSTOP && (q->p_flag & flag) == 0) {
if (q->p_wchan == NULL)
setrunnable(q);
q->p_stat = SSLEEP;
}
}
+ SCHED_UNLOCK(s);
}
- SCHED_UNLOCK(s);
+ mtx_leave(&pr->ps_mtx);
}
void
-/* $OpenBSD: kern_synch.c,v 1.202 2024/04/18 08:59:38 claudio Exp $ */
+/* $OpenBSD: kern_synch.c,v 1.203 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: kern_synch.c,v 1.37 1996/04/22 01:38:37 christos Exp $ */
/*
uint8_t newprio;
int s;
- SCHED_LOCK(s);
/*
* If one of the threads of a multi-threaded process called
* sched_yield(2), drop its priority to ensure its siblings
* can make some progress.
*/
+ mtx_enter(&p->p_p->ps_mtx);
newprio = p->p_usrpri;
TAILQ_FOREACH(q, &p->p_p->ps_threads, p_thr_link)
newprio = max(newprio, q->p_runpri);
+ mtx_leave(&p->p_p->ps_mtx);
+
+ SCHED_LOCK(s);
setrunqueue(p->p_cpu, p, newprio);
p->p_ru.ru_nvcsw++;
mi_switch();
-/* $OpenBSD: proc.h,v 1.360 2024/04/18 10:29:39 claudio Exp $ */
+/* $OpenBSD: proc.h,v 1.361 2024/05/20 10:32:20 claudio Exp $ */
/* $NetBSD: proc.h,v 1.44 1996/04/22 01:23:21 christos Exp $ */
/*-
struct ucred *ps_ucred; /* Process owner's identity. */
LIST_ENTRY(process) ps_list; /* List of all processes. */
- TAILQ_HEAD(,proc) ps_threads; /* [K|S] Threads in this process. */
+ TAILQ_HEAD(,proc) ps_threads; /* [K|m] Threads in this process. */
LIST_ENTRY(process) ps_pglist; /* List of processes in pgrp. */
struct process *ps_pptr; /* Pointer to parent process. */
u_int ps_flags; /* [a] PS_* flags. */
int ps_siglist; /* Signals pending for the process. */
- struct proc *ps_single; /* [S] Thread for single-threading. */
- u_int ps_singlecount; /* [a] Not yet suspended threads. */
+ struct proc *ps_single; /* [m] Thread for single-threading. */
+ u_int ps_singlecnt; /* [m] Number of threads to suspend. */
+ u_int ps_exitcnt; /* [m] Number of threads in exit1. */
int ps_traceflag; /* Kernel trace points. */
struct vnode *ps_tracevp; /* Trace to vnode. */
/* End area that is copied on creation. */
#define ps_endcopy ps_threadcnt
- u_int ps_threadcnt; /* Number of threads. */
+ u_int ps_threadcnt; /* [m] Number of threads. */
struct timespec ps_start; /* starting uptime. */
struct timeout ps_realit_to; /* [m] ITIMER_REAL timeout */
* U uidinfolk
* l read only reference, see lim_read_enter()
* o owned (modified only) by this thread
+ * m this proc's' `p->p_p->ps_mtx'
*/
struct proc {
TAILQ_ENTRY(proc) p_runq; /* [S] current run/sleep queue */
LIST_ENTRY(proc) p_list; /* List of all threads. */
struct process *p_p; /* [I] The process of this thread. */
- TAILQ_ENTRY(proc) p_thr_link; /* Threads in a process linkage. */
+ TAILQ_ENTRY(proc) p_thr_link; /* [K|m] Threads in a process linkage. */
TAILQ_ENTRY(proc) p_fut_link; /* Threads in a futex linkage. */
struct futex *p_futex; /* Current sleeping futex. */
projects / openbsd / commitdiff