sync with OpenBSD -current
This commit is contained in:
parent
0d61274b26
commit
bef867f8da
GPG key ID:
F42C07F07E2E35B7
81 changed files with 6365 additions and 372 deletions
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: acpi.c,v 1.429 2024/05/29 12:21:33 kettenis Exp $ */
|
||||
/* $OpenBSD: acpi.c,v 1.430 2024/06/02 11:08:41 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2005 Thorsten Lockert <tholo@sigmasoft.com>
|
||||
* Copyright (c) 2005 Jordan Hargrave <jordan@openbsd.org>
|
||||
|
|
@ -611,6 +611,10 @@ acpi_getpci(struct aml_node *node, void *arg)
|
|||
aml_nodename(node));
|
||||
|
||||
/* Collect device power state information. */
|
||||
if (aml_evalinteger(sc, node, "_S0W", 0, NULL, &val) == 0)
|
||||
pci->_s0w = val;
|
||||
else
|
||||
pci->_s0w = -1;
|
||||
if (aml_evalinteger(sc, node, "_S3D", 0, NULL, &val) == 0)
|
||||
pci->_s3d = val;
|
||||
else
|
||||
|
|
@ -721,6 +725,10 @@ acpi_pci_min_powerstate(pci_chipset_tag_t pc, pcitag_t tag)
|
|||
TAILQ_FOREACH(pdev, &acpi_pcidevs, next) {
|
||||
if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun) {
|
||||
switch (acpi_softc->sc_state) {
|
||||
case ACPI_STATE_S0:
|
||||
defaultstate = PCI_PMCSR_STATE_D3;
|
||||
state = pdev->_s0w;
|
||||
break;
|
||||
case ACPI_STATE_S3:
|
||||
defaultstate = PCI_PMCSR_STATE_D3;
|
||||
state = MAX(pdev->_s3d, pdev->_s3w);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: amltypes.h,v 1.49 2022/09/12 17:42:31 kettenis Exp $ */
|
||||
/* $OpenBSD: amltypes.h,v 1.50 2024/06/02 11:08:41 kettenis Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2005 Jordan Hargrave <jordan@openbsd.org>
|
||||
*
|
||||
|
|
@ -358,6 +358,7 @@ struct acpi_pci {
|
|||
int dev;
|
||||
int fun;
|
||||
|
||||
int _s0w;
|
||||
int _s3d;
|
||||
int _s3w;
|
||||
int _s4d;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: nvme.c,v 1.115 2024/05/28 00:24:44 jsg Exp $ */
|
||||
/* $OpenBSD: nvme.c,v 1.116 2024/06/03 12:01:57 mglocker Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2014 David Gwynne <dlg@openbsd.org>
|
||||
|
|
@ -1742,8 +1742,6 @@ nvme_hibernate_io(dev_t dev, daddr_t blkno, vaddr_t addr, size_t size,
|
|||
my->cq_head = 0;
|
||||
my->cqe_phase = NVME_CQE_PHASE;
|
||||
|
||||
pmap_extract(pmap_kernel(), (vaddr_t)page, &page_phys);
|
||||
|
||||
memset(&qsqe, 0, sizeof(qsqe));
|
||||
qsqe.opcode = NVM_ADMIN_ADD_IOCQ;
|
||||
htolem64(&qsqe.prp1,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: drm_linux.c,v 1.112 2024/03/30 13:33:20 mpi Exp $ */
|
||||
/* $OpenBSD: drm_linux.c,v 1.113 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2013 Jonathan Gray <jsg@openbsd.org>
|
||||
* Copyright (c) 2015, 2016 Mark Kettenis <kettenis@openbsd.org>
|
||||
|
|
@ -114,14 +114,13 @@ void
|
|||
__set_current_state(int state)
|
||||
{
|
||||
struct proc *p = curproc;
|
||||
int s;
|
||||
|
||||
KASSERT(state == TASK_RUNNING);
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
unsleep(p);
|
||||
p->p_stat = SONPROC;
|
||||
atomic_clearbits_int(&p->p_flag, P_WSLEEP);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -159,11 +158,11 @@ schedule_timeout_uninterruptible(long timeout)
|
|||
int
|
||||
wake_up_process(struct proc *p)
|
||||
{
|
||||
int s, rv;
|
||||
int rv;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
rv = wakeup_proc(p, 0);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_exit.c,v 1.221 2024/05/20 10:32:20 claudio Exp $ */
|
||||
/* $OpenBSD: kern_exit.c,v 1.222 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: kern_exit.c,v 1.39 1996/04/22 01:38:25 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
|
@ -119,7 +119,6 @@ exit1(struct proc *p, int xexit, int xsig, int flags)
|
|||
struct process *pr, *qr, *nqr;
|
||||
struct rusage *rup;
|
||||
struct timespec ts;
|
||||
int s;
|
||||
|
||||
atomic_setbits_int(&p->p_flag, P_WEXIT);
|
||||
|
||||
|
|
@ -329,9 +328,9 @@ exit1(struct proc *p, int xexit, int xsig, int flags)
|
|||
timespecclear(&ts);
|
||||
else
|
||||
timespecsub(&ts, &curcpu()->ci_schedstate.spc_runtime, &ts);
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
tuagg_locked(pr, p, &ts);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
/*
|
||||
* clear %cpu usage during swap
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_fork.c,v 1.259 2024/05/29 18:55:45 claudio Exp $ */
|
||||
/* $OpenBSD: kern_fork.c,v 1.260 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: kern_fork.c,v 1.29 1996/02/09 18:59:34 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
|
@ -329,14 +329,13 @@ static inline void
|
|||
fork_thread_start(struct proc *p, struct proc *parent, int flags)
|
||||
{
|
||||
struct cpu_info *ci;
|
||||
int s;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
ci = sched_choosecpu_fork(parent, flags);
|
||||
TRACEPOINT(sched, fork, p->p_tid + THREAD_PID_OFFSET,
|
||||
p->p_p->ps_pid, CPU_INFO_UNIT(ci));
|
||||
setrunqueue(ci, p, p->p_usrpri);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
int
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_pledge.c,v 1.314 2024/05/18 05:20:22 guenther Exp $ */
|
||||
/* $OpenBSD: kern_pledge.c,v 1.316 2024/06/03 03:41:47 deraadt Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2015 Nicholas Marriott <nicm@openbsd.org>
|
||||
|
|
@ -574,7 +574,7 @@ pledge_fail(struct proc *p, int error, uint64_t code)
|
|||
return (ENOSYS);
|
||||
|
||||
KERNEL_LOCK();
|
||||
log(LOG_ERR, "%s[%d]: pledge \"%s\", syscall %d\n",
|
||||
uprintf("%s[%d]: pledge \"%s\", syscall %d\n",
|
||||
p->p_p->ps_comm, p->p_p->ps_pid, codes, p->p_pledge_syscall);
|
||||
p->p_p->ps_acflag |= APLEDGE;
|
||||
|
||||
|
|
@ -1002,10 +1002,10 @@ pledge_sysctl(struct proc *p, int miblen, int *mib, void *new)
|
|||
snprintf(buf, sizeof(buf), "%s(%d): pledge sysctl %d:",
|
||||
p->p_p->ps_comm, p->p_p->ps_pid, miblen);
|
||||
for (i = 0; i < miblen; i++) {
|
||||
char *p = buf + strlen(buf);
|
||||
snprintf(p, sizeof(buf) - (p - buf), " %d", mib[i]);
|
||||
char *s = buf + strlen(buf);
|
||||
snprintf(s, sizeof(buf) - (s - buf), " %d", mib[i]);
|
||||
}
|
||||
log(LOG_ERR, "%s\n", buf);
|
||||
uprintf("%s\n", buf);
|
||||
|
||||
return pledge_fail(p, EINVAL, 0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_resource.c,v 1.83 2024/05/22 09:20:22 claudio Exp $ */
|
||||
/* $OpenBSD: kern_resource.c,v 1.84 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: kern_resource.c,v 1.38 1996/10/23 07:19:38 matthias Exp $ */
|
||||
|
||||
/*-
|
||||
|
|
@ -198,7 +198,6 @@ donice(struct proc *curp, struct process *chgpr, int n)
|
|||
{
|
||||
struct ucred *ucred = curp->p_ucred;
|
||||
struct proc *p;
|
||||
int s;
|
||||
|
||||
if (ucred->cr_uid != 0 && ucred->cr_ruid != 0 &&
|
||||
ucred->cr_uid != chgpr->ps_ucred->cr_uid &&
|
||||
|
|
@ -213,11 +212,11 @@ donice(struct proc *curp, struct process *chgpr, int n)
|
|||
return (EACCES);
|
||||
chgpr->ps_nice = n;
|
||||
mtx_enter(&chgpr->ps_mtx);
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
TAILQ_FOREACH(p, &chgpr->ps_threads, p_thr_link) {
|
||||
setpriority(p, p->p_estcpu, n);
|
||||
}
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
mtx_leave(&chgpr->ps_mtx);
|
||||
return (0);
|
||||
}
|
||||
|
|
@ -396,11 +395,9 @@ tuagg_locked(struct process *pr, struct proc *p, const struct timespec *ts)
|
|||
void
|
||||
tuagg(struct process *pr, struct proc *p)
|
||||
{
|
||||
int s;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
tuagg_locked(pr, p, NULL);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -537,13 +534,12 @@ rucheck(void *arg)
|
|||
struct rlimit rlim;
|
||||
struct process *pr = arg;
|
||||
time_t runtime;
|
||||
int s;
|
||||
|
||||
KERNEL_ASSERT_LOCKED();
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
runtime = pr->ps_tu.tu_runtime.tv_sec;
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
mtx_enter(&pr->ps_mtx);
|
||||
rlim = pr->ps_limit->pl_rlimit[RLIMIT_CPU];
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_sched.c,v 1.95 2024/02/28 13:43:44 mpi Exp $ */
|
||||
/* $OpenBSD: kern_sched.c,v 1.96 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/*
|
||||
* Copyright (c) 2007, 2008 Artur Grabowski <art@openbsd.org>
|
||||
*
|
||||
|
|
@ -137,7 +137,6 @@ sched_idle(void *v)
|
|||
struct schedstate_percpu *spc;
|
||||
struct proc *p = curproc;
|
||||
struct cpu_info *ci = v;
|
||||
int s;
|
||||
|
||||
KERNEL_UNLOCK();
|
||||
|
||||
|
|
@ -147,14 +146,14 @@ sched_idle(void *v)
|
|||
* First time we enter here, we're not supposed to idle,
|
||||
* just go away for a while.
|
||||
*/
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
cpuset_add(&sched_idle_cpus, ci);
|
||||
p->p_stat = SSLEEP;
|
||||
p->p_cpu = ci;
|
||||
atomic_setbits_int(&p->p_flag, P_CPUPEG);
|
||||
mi_switch();
|
||||
cpuset_del(&sched_idle_cpus, ci);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
KASSERT(ci == curcpu());
|
||||
KASSERT(curproc == spc->spc_idleproc);
|
||||
|
|
@ -163,10 +162,10 @@ sched_idle(void *v)
|
|||
while (!cpu_is_idle(curcpu())) {
|
||||
struct proc *dead;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
p->p_stat = SSLEEP;
|
||||
mi_switch();
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
while ((dead = LIST_FIRST(&spc->spc_deadproc))) {
|
||||
LIST_REMOVE(dead, p_hash);
|
||||
|
|
@ -185,10 +184,10 @@ sched_idle(void *v)
|
|||
if (spc->spc_schedflags & SPCF_SHOULDHALT &&
|
||||
(spc->spc_schedflags & SPCF_HALTED) == 0) {
|
||||
cpuset_del(&sched_idle_cpus, ci);
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
atomic_setbits_int(&spc->spc_schedflags,
|
||||
spc->spc_whichqs ? 0 : SPCF_HALTED);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
wakeup(spc);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -226,7 +225,6 @@ sched_toidle(void)
|
|||
{
|
||||
struct schedstate_percpu *spc = &curcpu()->ci_schedstate;
|
||||
struct proc *idle;
|
||||
int s;
|
||||
|
||||
#ifdef MULTIPROCESSOR
|
||||
/* This process no longer needs to hold the kernel lock. */
|
||||
|
|
@ -245,8 +243,7 @@ sched_toidle(void)
|
|||
|
||||
atomic_clearbits_int(&spc->spc_schedflags, SPCF_SWITCHCLEAR);
|
||||
|
||||
SCHED_LOCK(s);
|
||||
|
||||
SCHED_LOCK();
|
||||
idle = spc->spc_idleproc;
|
||||
idle->p_stat = SRUN;
|
||||
|
||||
|
|
@ -627,14 +624,13 @@ void
|
|||
sched_peg_curproc(struct cpu_info *ci)
|
||||
{
|
||||
struct proc *p = curproc;
|
||||
int s;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
atomic_setbits_int(&p->p_flag, P_CPUPEG);
|
||||
setrunqueue(ci, p, p->p_usrpri);
|
||||
p->p_ru.ru_nvcsw++;
|
||||
mi_switch();
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
#ifdef MULTIPROCESSOR
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_sig.c,v 1.329 2024/05/22 09:22:55 claudio Exp $ */
|
||||
/* $OpenBSD: kern_sig.c,v 1.330 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: kern_sig.c,v 1.54 1996/04/22 01:38:32 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
|
@ -843,14 +843,12 @@ trapsignal(struct proc *p, int signum, u_long trapno, int code,
|
|||
*/
|
||||
if (((pr->ps_flags & (PS_TRACED | PS_PPWAIT)) == PS_TRACED) &&
|
||||
signum != SIGKILL && (p->p_sigmask & mask) != 0) {
|
||||
int s;
|
||||
|
||||
single_thread_set(p, SINGLE_SUSPEND | SINGLE_NOWAIT);
|
||||
pr->ps_xsig = signum;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
proc_stop(p, 1);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
signum = pr->ps_xsig;
|
||||
single_thread_clear(p, 0);
|
||||
|
|
@ -920,7 +918,7 @@ psignal(struct proc *p, int signum)
|
|||
void
|
||||
ptsignal(struct proc *p, int signum, enum signal_type type)
|
||||
{
|
||||
int s, prop;
|
||||
int prop;
|
||||
sig_t action, altaction = SIG_DFL;
|
||||
sigset_t mask, sigmask;
|
||||
int *siglist;
|
||||
|
|
@ -1063,7 +1061,7 @@ ptsignal(struct proc *p, int signum, enum signal_type type)
|
|||
if (q != p)
|
||||
ptsignal(q, signum, SPROPAGATED);
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
|
||||
switch (p->p_stat) {
|
||||
|
||||
|
|
@ -1252,7 +1250,7 @@ out:
|
|||
atomic_clearbits_int(&p->p_flag, P_CONTINUED);
|
||||
}
|
||||
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
if (wakeparent)
|
||||
wakeup(pr->ps_pptr);
|
||||
}
|
||||
|
|
@ -1299,7 +1297,6 @@ cursig(struct proc *p, struct sigctx *sctx)
|
|||
struct process *pr = p->p_p;
|
||||
int signum, mask, prop;
|
||||
sigset_t ps_siglist;
|
||||
int s;
|
||||
|
||||
KASSERT(p == curproc);
|
||||
|
||||
|
|
@ -1340,9 +1337,9 @@ cursig(struct proc *p, struct sigctx *sctx)
|
|||
single_thread_set(p, SINGLE_SUSPEND | SINGLE_NOWAIT);
|
||||
pr->ps_xsig = signum;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
proc_stop(p, 1);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
/*
|
||||
* re-take the signal before releasing
|
||||
|
|
@ -1415,9 +1412,9 @@ cursig(struct proc *p, struct sigctx *sctx)
|
|||
prop & SA_TTYSTOP))
|
||||
break; /* == ignore */
|
||||
pr->ps_xsig = signum;
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
proc_stop(p, 1);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
break;
|
||||
} else if (prop & SA_IGNORE) {
|
||||
/*
|
||||
|
|
@ -2064,7 +2061,6 @@ int
|
|||
single_thread_check_locked(struct proc *p, int deep)
|
||||
{
|
||||
struct process *pr = p->p_p;
|
||||
int s;
|
||||
|
||||
MUTEX_ASSERT_LOCKED(&pr->ps_mtx);
|
||||
|
||||
|
|
@ -2093,10 +2089,10 @@ single_thread_check_locked(struct proc *p, int deep)
|
|||
/* not exiting and don't need to unwind, so suspend */
|
||||
mtx_leave(&pr->ps_mtx);
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
p->p_stat = SSTOP;
|
||||
mi_switch();
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
mtx_enter(&pr->ps_mtx);
|
||||
} while (pr->ps_single != NULL);
|
||||
|
||||
|
|
@ -2129,7 +2125,7 @@ single_thread_set(struct proc *p, int flags)
|
|||
{
|
||||
struct process *pr = p->p_p;
|
||||
struct proc *q;
|
||||
int error, s, mode = flags & SINGLE_MASK;
|
||||
int error, mode = flags & SINGLE_MASK;
|
||||
|
||||
KASSERT(curproc == p);
|
||||
|
||||
|
|
@ -2161,7 +2157,7 @@ single_thread_set(struct proc *p, int flags)
|
|||
TAILQ_FOREACH(q, &pr->ps_threads, p_thr_link) {
|
||||
if (q == p)
|
||||
continue;
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
atomic_setbits_int(&q->p_flag, P_SUSPSINGLE);
|
||||
switch (q->p_stat) {
|
||||
case SIDL:
|
||||
|
|
@ -2194,7 +2190,7 @@ single_thread_set(struct proc *p, int flags)
|
|||
case SRUN:
|
||||
break;
|
||||
}
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
/* count ourselfs out */
|
||||
|
|
@ -2235,7 +2231,6 @@ single_thread_clear(struct proc *p, int flag)
|
|||
{
|
||||
struct process *pr = p->p_p;
|
||||
struct proc *q;
|
||||
int s;
|
||||
|
||||
KASSERT(pr->ps_single == p);
|
||||
KASSERT(curproc == p);
|
||||
|
|
@ -2254,7 +2249,7 @@ single_thread_clear(struct proc *p, int flag)
|
|||
* then clearing that either makes it runnable or puts
|
||||
* it back into some sleep queue
|
||||
*/
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
if (q->p_stat == SSTOP && (q->p_flag & flag) == 0) {
|
||||
if (q->p_wchan == NULL)
|
||||
setrunnable(q);
|
||||
|
|
@ -2263,7 +2258,7 @@ single_thread_clear(struct proc *p, int flag)
|
|||
q->p_stat = SSLEEP;
|
||||
}
|
||||
}
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
mtx_leave(&pr->ps_mtx);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: kern_synch.c,v 1.204 2024/05/22 09:24:11 claudio Exp $ */
|
||||
/* $OpenBSD: kern_synch.c,v 1.205 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: kern_synch.c,v 1.37 1996/04/22 01:38:37 christos Exp $ */
|
||||
|
||||
/*
|
||||
|
|
@ -332,7 +332,6 @@ void
|
|||
sleep_setup(const volatile void *ident, int prio, const char *wmesg)
|
||||
{
|
||||
struct proc *p = curproc;
|
||||
int s;
|
||||
|
||||
#ifdef DIAGNOSTIC
|
||||
if (p->p_flag & P_CANTSLEEP)
|
||||
|
|
@ -346,7 +345,7 @@ sleep_setup(const volatile void *ident, int prio, const char *wmesg)
|
|||
if (p->p_flag & P_WEXIT)
|
||||
CLR(prio, PCATCH);
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
|
||||
TRACEPOINT(sched, sleep, NULL);
|
||||
|
||||
|
|
@ -360,14 +359,14 @@ sleep_setup(const volatile void *ident, int prio, const char *wmesg)
|
|||
atomic_setbits_int(&p->p_flag, P_SINTR);
|
||||
p->p_stat = SSLEEP;
|
||||
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
int
|
||||
sleep_finish(int timo, int do_sleep)
|
||||
{
|
||||
struct proc *p = curproc;
|
||||
int s, catch, error = 0, error1 = 0;
|
||||
int catch, error = 0, error1 = 0;
|
||||
|
||||
catch = p->p_flag & P_SINTR;
|
||||
|
||||
|
|
@ -392,7 +391,7 @@ sleep_finish(int timo, int do_sleep)
|
|||
}
|
||||
}
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
/*
|
||||
* If the wakeup happens while going to sleep, p->p_wchan
|
||||
* will be NULL. In that case unwind immediately but still
|
||||
|
|
@ -419,7 +418,7 @@ sleep_finish(int timo, int do_sleep)
|
|||
#endif
|
||||
|
||||
p->p_cpu->ci_schedstate.spc_curpriority = p->p_usrpri;
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
/*
|
||||
* Even though this belongs to the signal handling part of sleep,
|
||||
|
|
@ -503,11 +502,10 @@ void
|
|||
endtsleep(void *arg)
|
||||
{
|
||||
struct proc *p = arg;
|
||||
int s;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
wakeup_proc(p, P_TIMEOUT);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -536,11 +534,10 @@ wakeup_n(const volatile void *ident, int n)
|
|||
struct slpque *qp, wakeq;
|
||||
struct proc *p;
|
||||
struct proc *pnext;
|
||||
int s;
|
||||
|
||||
TAILQ_INIT(&wakeq);
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
qp = &slpque[LOOKUP(ident)];
|
||||
for (p = TAILQ_FIRST(qp); p != NULL && n != 0; p = pnext) {
|
||||
pnext = TAILQ_NEXT(p, p_runq);
|
||||
|
|
@ -564,7 +561,7 @@ wakeup_n(const volatile void *ident, int n)
|
|||
if (p->p_stat == SSLEEP)
|
||||
setrunnable(p);
|
||||
}
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -581,7 +578,6 @@ sys_sched_yield(struct proc *p, void *v, register_t *retval)
|
|||
{
|
||||
struct proc *q;
|
||||
uint8_t newprio;
|
||||
int s;
|
||||
|
||||
/*
|
||||
* If one of the threads of a multi-threaded process called
|
||||
|
|
@ -594,11 +590,11 @@ sys_sched_yield(struct proc *p, void *v, register_t *retval)
|
|||
newprio = max(newprio, q->p_runpri);
|
||||
mtx_leave(&p->p_p->ps_mtx);
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
setrunqueue(p->p_cpu, p, newprio);
|
||||
p->p_ru.ru_nvcsw++;
|
||||
mi_switch();
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: sched_bsd.c,v 1.92 2024/05/29 18:55:45 claudio Exp $ */
|
||||
/* $OpenBSD: sched_bsd.c,v 1.93 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: kern_synch.c,v 1.37 1996/04/22 01:38:37 christos Exp $ */
|
||||
|
||||
/*-
|
||||
|
|
@ -230,7 +230,6 @@ schedcpu(void *unused)
|
|||
static struct timeout to = TIMEOUT_INITIALIZER(schedcpu, NULL);
|
||||
fixpt_t loadfac = loadfactor(averunnable.ldavg[0]);
|
||||
struct proc *p;
|
||||
int s;
|
||||
unsigned int newcpu;
|
||||
|
||||
LIST_FOREACH(p, &allproc, p_list) {
|
||||
|
|
@ -253,7 +252,7 @@ schedcpu(void *unused)
|
|||
*/
|
||||
if (p->p_slptime > 1)
|
||||
continue;
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
/*
|
||||
* p_pctcpu is only for diagnostic tools such as ps.
|
||||
*/
|
||||
|
|
@ -275,7 +274,7 @@ schedcpu(void *unused)
|
|||
remrunqueue(p);
|
||||
setrunqueue(p->p_cpu, p, p->p_usrpri);
|
||||
}
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
wakeup(&lbolt);
|
||||
timeout_add_sec(&to, 1);
|
||||
|
|
@ -313,13 +312,12 @@ void
|
|||
yield(void)
|
||||
{
|
||||
struct proc *p = curproc;
|
||||
int s;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
setrunqueue(p->p_cpu, p, p->p_usrpri);
|
||||
p->p_ru.ru_nvcsw++;
|
||||
mi_switch();
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -332,13 +330,12 @@ void
|
|||
preempt(void)
|
||||
{
|
||||
struct proc *p = curproc;
|
||||
int s;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
setrunqueue(p->p_cpu, p, p->p_usrpri);
|
||||
p->p_ru.ru_nivcsw++;
|
||||
mi_switch();
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -349,7 +346,7 @@ mi_switch(void)
|
|||
struct proc *nextproc;
|
||||
struct process *pr = p->p_p;
|
||||
struct timespec ts;
|
||||
int oldipl, s;
|
||||
int oldipl;
|
||||
#ifdef MULTIPROCESSOR
|
||||
int hold_count;
|
||||
#endif
|
||||
|
|
@ -427,7 +424,7 @@ mi_switch(void)
|
|||
|
||||
/* Restore proc's IPL. */
|
||||
MUTEX_OLDIPL(&sched_lock) = oldipl;
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
|
||||
SCHED_ASSERT_UNLOCKED();
|
||||
|
||||
|
|
@ -463,7 +460,7 @@ mi_switch(void)
|
|||
if (hold_count)
|
||||
__mp_acquire_count(&kernel_lock, hold_count);
|
||||
#endif
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -551,15 +548,14 @@ schedclock(struct proc *p)
|
|||
struct cpu_info *ci = curcpu();
|
||||
struct schedstate_percpu *spc = &ci->ci_schedstate;
|
||||
uint32_t newcpu;
|
||||
int s;
|
||||
|
||||
if (p == spc->spc_idleproc || spc->spc_spinning)
|
||||
return;
|
||||
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
newcpu = ESTCPULIM(p->p_estcpu + 1);
|
||||
setpriority(p, newcpu, p->p_p->ps_nice);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
}
|
||||
|
||||
void (*cpu_setperf)(int);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: subr_witness.c,v 1.52 2024/05/03 13:47:31 visa Exp $ */
|
||||
/* $OpenBSD: subr_witness.c,v 1.53 2024/06/03 14:34:19 claudio Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 2008 Isilon Systems, Inc.
|
||||
|
|
@ -438,11 +438,6 @@ static struct lock_class lock_class_kernel_lock = {
|
|||
.lc_flags = LC_SLEEPLOCK | LC_RECURSABLE | LC_SLEEPABLE
|
||||
};
|
||||
|
||||
static struct lock_class lock_class_sched_lock = {
|
||||
.lc_name = "sched_lock",
|
||||
.lc_flags = LC_SPINLOCK | LC_RECURSABLE
|
||||
};
|
||||
|
||||
static struct lock_class lock_class_mutex = {
|
||||
.lc_name = "mutex",
|
||||
.lc_flags = LC_SPINLOCK
|
||||
|
|
@ -461,7 +456,6 @@ static struct lock_class lock_class_rrwlock = {
|
|||
|
||||
static struct lock_class *lock_classes[] = {
|
||||
&lock_class_kernel_lock,
|
||||
&lock_class_sched_lock,
|
||||
&lock_class_mutex,
|
||||
&lock_class_rwlock,
|
||||
&lock_class_rrwlock,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: sys_process.c,v 1.97 2024/04/02 08:27:22 deraadt Exp $ */
|
||||
/* $OpenBSD: sys_process.c,v 1.98 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: sys_process.c,v 1.55 1996/05/15 06:17:47 tls Exp $ */
|
||||
|
||||
/*-
|
||||
|
|
@ -283,7 +283,6 @@ ptrace_ctrl(struct proc *p, int req, pid_t pid, caddr_t addr, int data)
|
|||
struct proc *t; /* target thread */
|
||||
struct process *tr; /* target process */
|
||||
int error = 0;
|
||||
int s;
|
||||
|
||||
switch (req) {
|
||||
case PT_TRACE_ME:
|
||||
|
|
@ -492,10 +491,10 @@ ptrace_ctrl(struct proc *p, int req, pid_t pid, caddr_t addr, int data)
|
|||
/* Finally, deliver the requested signal (or none). */
|
||||
if (t->p_stat == SSTOP) {
|
||||
tr->ps_xsig = data;
|
||||
SCHED_LOCK(s);
|
||||
SCHED_LOCK();
|
||||
unsleep(t);
|
||||
setrunnable(t);
|
||||
SCHED_UNLOCK(s);
|
||||
SCHED_UNLOCK();
|
||||
} else {
|
||||
if (data != 0)
|
||||
psignal(t, data);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: _lock.h,v 1.4 2019/04/23 13:35:12 visa Exp $ */
|
||||
/* $OpenBSD: _lock.h,v 1.5 2024/06/03 12:46:59 claudio Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1997 Berkeley Software Design, Inc. All rights reserved.
|
||||
|
|
@ -50,7 +50,6 @@
|
|||
|
||||
enum lock_class_index {
|
||||
LO_CLASS_KERNEL_LOCK,
|
||||
LO_CLASS_SCHED_LOCK,
|
||||
LO_CLASS_MUTEX,
|
||||
LO_CLASS_RWLOCK,
|
||||
LO_CLASS_RRWLOCK
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: sched.h,v 1.71 2024/05/29 18:55:45 claudio Exp $ */
|
||||
/* $OpenBSD: sched.h,v 1.72 2024/06/03 12:48:25 claudio Exp $ */
|
||||
/* $NetBSD: sched.h,v 1.2 1999/02/28 18:14:58 ross Exp $ */
|
||||
|
||||
/*-
|
||||
|
|
@ -201,28 +201,12 @@ void remrunqueue(struct proc *);
|
|||
|
||||
extern struct mutex sched_lock;
|
||||
|
||||
#define SCHED_ASSERT_LOCKED() \
|
||||
do { \
|
||||
MUTEX_ASSERT_LOCKED(&sched_lock); \
|
||||
} while (0)
|
||||
#define SCHED_ASSERT_UNLOCKED() \
|
||||
do { \
|
||||
MUTEX_ASSERT_UNLOCKED(&sched_lock); \
|
||||
} while (0)
|
||||
#define SCHED_ASSERT_LOCKED() MUTEX_ASSERT_LOCKED(&sched_lock)
|
||||
#define SCHED_ASSERT_UNLOCKED() MUTEX_ASSERT_UNLOCKED(&sched_lock)
|
||||
|
||||
#define SCHED_LOCK_INIT() mtx_init(&sched_lock, IPL_SCHED)
|
||||
|
||||
#define SCHED_LOCK(s) \
|
||||
do { \
|
||||
(s) = 0; /* XXX cleanup useless argument */ \
|
||||
mtx_enter(&sched_lock); \
|
||||
} while (/* CONSTCOND */ 0)
|
||||
|
||||
#define SCHED_UNLOCK(s) \
|
||||
do { \
|
||||
(void)s; /* XXX cleanup useless argument */ \
|
||||
mtx_leave(&sched_lock); \
|
||||
} while (/* CONSTCOND */ 0)
|
||||
#define SCHED_LOCK() mtx_enter(&sched_lock)
|
||||
#define SCHED_UNLOCK() mtx_leave(&sched_lock)
|
||||
|
||||
#endif /* _KERNEL */
|
||||
#endif /* _SYS_SCHED_H_ */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: syscall_mi.h,v 1.33 2024/04/01 12:00:15 deraadt Exp $ */
|
||||
/* $OpenBSD: syscall_mi.h,v 1.34 2024/06/02 15:31:57 deraadt Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1982, 1986, 1989, 1993
|
||||
|
|
@ -105,9 +105,8 @@ die:
|
|||
ktrpinsyscall(p, error, code, addr);
|
||||
#endif
|
||||
KERNEL_LOCK();
|
||||
/* XXX remove or simplify this log() call after SecBSD 1.5 release */
|
||||
log(LOG_ERR,
|
||||
"%s[%d]: pinsyscalls addr %lx code %ld, pinoff 0x%x "
|
||||
/* XXX remove or simplify this uprintf() call after OpenBSD 7.5 release */
|
||||
uprintf("%s[%d]: pinsyscalls addr %lx code %ld, pinoff 0x%x "
|
||||
"(pin%s %d %lx-%lx %lx) (libcpin%s %d %lx-%lx %lx) error %d\n",
|
||||
p->p_p->ps_comm, p->p_p->ps_pid, addr, code,
|
||||
(pin && code < pin->pn_npins) ? pin->pn_pins[code] : -1,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: uvm_map.c,v 1.328 2024/04/02 08:39:17 deraadt Exp $ */
|
||||
/* $OpenBSD: uvm_map.c,v 1.329 2024/06/02 15:31:57 deraadt Exp $ */
|
||||
/* $NetBSD: uvm_map.c,v 1.86 2000/11/27 08:40:03 chs Exp $ */
|
||||
|
||||
/*
|
||||
|
|
@ -1659,7 +1659,7 @@ uvm_map_inentry(struct proc *p, struct p_inentry *ie, vaddr_t addr,
|
|||
ok = uvm_map_inentry_fix(p, ie, addr, fn, serial);
|
||||
if (!ok) {
|
||||
KERNEL_LOCK();
|
||||
printf(fmt, p->p_p->ps_comm, p->p_p->ps_pid, p->p_tid,
|
||||
uprintf(fmt, p->p_p->ps_comm, p->p_p->ps_pid, p->p_tid,
|
||||
addr, ie->ie_start, ie->ie_end-1);
|
||||
p->p_p->ps_acflag |= AMAP;
|
||||
sv.sival_ptr = (void *)PROC_PC(p);
|
||||
|
|
@ -1685,11 +1685,8 @@ uvm_map_is_stack_remappable(struct vm_map *map, vaddr_t addr, vaddr_t sz,
|
|||
|
||||
vm_map_assert_anylock(map);
|
||||
|
||||
if (!uvm_map_lookup_entry(map, addr, &first)) {
|
||||
printf("map stack 0x%lx-0x%lx of map %p failed: no mapping\n",
|
||||
addr, end, map);
|
||||
if (!uvm_map_lookup_entry(map, addr, &first))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check that the address range exists and is contiguous.
|
||||
|
|
@ -1707,16 +1704,10 @@ uvm_map_is_stack_remappable(struct vm_map *map, vaddr_t addr, vaddr_t sz,
|
|||
}
|
||||
#endif
|
||||
|
||||
if (prev != NULL && prev->end != iter->start) {
|
||||
printf("map stack 0x%lx-0x%lx of map %p failed: "
|
||||
"hole in range\n", addr, end, map);
|
||||
if (prev != NULL && prev->end != iter->start)
|
||||
return FALSE;
|
||||
}
|
||||
if (iter->start == iter->end || UVM_ET_ISHOLE(iter)) {
|
||||
printf("map stack 0x%lx-0x%lx of map %p failed: "
|
||||
"hole in range\n", addr, end, map);
|
||||
if (iter->start == iter->end || UVM_ET_ISHOLE(iter))
|
||||
return FALSE;
|
||||
}
|
||||
if (sigaltstack_check) {
|
||||
if (iter->protection != (PROT_READ | PROT_WRITE))
|
||||
return FALSE;
|
||||
|
|
@ -1740,7 +1731,6 @@ uvm_map_remap_as_stack(struct proc *p, vaddr_t addr, vaddr_t sz)
|
|||
{
|
||||
vm_map_t map = &p->p_vmspace->vm_map;
|
||||
vaddr_t start, end;
|
||||
int error;
|
||||
int flags = UVM_MAPFLAG(PROT_READ | PROT_WRITE,
|
||||
PROT_READ | PROT_WRITE | PROT_EXEC,
|
||||
MAP_INHERIT_COPY, MADV_NORMAL,
|
||||
|
|
@ -1767,11 +1757,7 @@ uvm_map_remap_as_stack(struct proc *p, vaddr_t addr, vaddr_t sz)
|
|||
* placed upon the region, which prevents an attacker from pivoting
|
||||
* into pre-placed MAP_STACK space.
|
||||
*/
|
||||
error = uvm_mapanon(map, &start, end - start, 0, flags);
|
||||
if (error != 0)
|
||||
printf("map stack for pid %d failed\n", p->p_p->ps_pid);
|
||||
|
||||
return error;
|
||||
return uvm_mapanon(map, &start, end - start, 0, flags);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue