Page MenuHomeFreeBSD
Differential D12773 Diff 67994 head/sys/kern/subr_trap.c

Changeset View

Standalone View

View Options

head/sys/kern/subr_trap.c

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines#ifdef DIAGNOSTIC
* racy and cannot be performed reliably. * racy and cannot be performed reliably.
* If current process is vfork child, indicated by P_PPWAIT, then * If current process is vfork child, indicated by P_PPWAIT, then
* issignal() ignores stops, so we block the check to avoid * issignal() ignores stops, so we block the check to avoid
* classifying pending signals. * classifying pending signals.
*/ */
if (p->p_numthreads == 1) { if (p->p_numthreads == 1) {
PROC_LOCK(p); PROC_LOCK(p);
thread_lock(td); thread_lock(td);
if ((p->p_flag & P_PPWAIT) == 0) { if ((p->p_flag & P_PPWAIT) == 0 &&
KASSERT(!SIGPENDING(td) || (td->td_flags & (td->td_pflags & TDP_SIGFASTBLOCK) == 0) {
(TDF_NEEDSIGCHK | TDF_ASTPENDING)) == if (SIGPENDING(td) && (td->td_flags &
(TDF_NEEDSIGCHK | TDF_ASTPENDING), (TDF_NEEDSIGCHK | TDF_ASTPENDING)) !=
("failed to set signal flags for ast p %p " (TDF_NEEDSIGCHK | TDF_ASTPENDING)) {
"td %p fl %x", p, td, td->td_flags)); thread_unlock(td);
panic(
"failed to set signal flags for ast p %p td %p fl %x",
p, td, td->td_flags);
} }
}
thread_unlock(td); thread_unlock(td);
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
#endif #endif
#ifdef KTRACE #ifdef KTRACE
KTRUSERRET(td); KTRUSERRET(td);
#endif #endif
td_softdep_cleanup(td); td_softdep_cleanup(td);
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
* This is relatively easy. * This is relatively easy.
* This function will return with preemption disabled. * This function will return with preemption disabled.
*/ */
void void
ast(struct trapframe *framep) ast(struct trapframe *framep)
{ {
struct thread *td; struct thread *td;
struct proc *p; struct proc *p;
int flags; uint32_t oldval;
int sig; int flags, sig, res;
td = curthread; td = curthread;
p = td->td_proc; p = td->td_proc;
CTR3(KTR_SYSC, "ast: thread %p (pid %d, %s)", td, p->p_pid, CTR3(KTR_SYSC, "ast: thread %p (pid %d, %s)", td, p->p_pid,
p->p_comm); p->p_comm);
KASSERT(TRAPF_USERMODE(framep), ("ast in kernel mode")); KASSERT(TRAPF_USERMODE(framep), ("ast in kernel mode"));
WITNESS_WARN(WARN_PANIC, NULL, "Returning to user mode"); WITNESS_WARN(WARN_PANIC, NULL, "Returning to user mode");
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (p->p_numthreads == 1 && (flags & TDF_NEEDSIGCHK) == 0) {
thread_lock(td); thread_lock(td);
/* /*
* Note that TDF_NEEDSIGCHK should be re-read from * Note that TDF_NEEDSIGCHK should be re-read from
* td_flags, since signal might have been delivered * td_flags, since signal might have been delivered
* after we cleared td_flags above. This is one of * after we cleared td_flags above. This is one of
* the reason for looping check for AST condition. * the reason for looping check for AST condition.
* See comment in userret() about P_PPWAIT. * See comment in userret() about P_PPWAIT.
*/ */
if ((p->p_flag & P_PPWAIT) == 0) { if ((p->p_flag & P_PPWAIT) == 0 &&
KASSERT(!SIGPENDING(td) || (td->td_flags & (td->td_pflags & TDP_SIGFASTBLOCK) == 0) {
(TDF_NEEDSIGCHK | TDF_ASTPENDING)) == if (SIGPENDING(td) && (td->td_flags &
(TDF_NEEDSIGCHK | TDF_ASTPENDING), (TDF_NEEDSIGCHK | TDF_ASTPENDING)) !=
("failed2 to set signal flags for ast p %p td %p " (TDF_NEEDSIGCHK | TDF_ASTPENDING)) {
"fl %x %x", p, td, flags, td->td_flags)); thread_unlock(td); /* fix dumps */
panic(
"failed2 to set signal flags for ast p %p td %p fl %x %x",
p, td, flags, td->td_flags);
} }
}
thread_unlock(td); thread_unlock(td);
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
#endif #endif
/* /*
* Check for signals. Unlocked reads of p_pendingcnt or * Check for signals. Unlocked reads of p_pendingcnt or
* p_siglist might cause process-directed signal to be handled * p_siglist might cause process-directed signal to be handled
* later. * later.
*/ */
if (flags & TDF_NEEDSIGCHK || p->p_pendingcnt > 0 || if (flags & TDF_NEEDSIGCHK || p->p_pendingcnt > 0 ||
!SIGISEMPTY(p->p_siglist)) { !SIGISEMPTY(p->p_siglist)) {
fetch_sigfastblock(td);
PROC_LOCK(p); PROC_LOCK(p);
mtx_lock(&p->p_sigacts->ps_mtx); mtx_lock(&p->p_sigacts->ps_mtx);
if ((td->td_pflags & TDP_SIGFASTBLOCK) != 0 &&
td->td_sigblock_val != 0) {
reschedule_signals(p, fastblock_mask,
SIGPROCMASK_PS_LOCKED | SIGPROCMASK_FASTBLK);
} else {
while ((sig = cursig(td)) != 0) { while ((sig = cursig(td)) != 0) {
KASSERT(sig >= 0, ("sig %d", sig)); KASSERT(sig >= 0, ("sig %d", sig));
postsig(sig); postsig(sig);
} }
}
mtx_unlock(&p->p_sigacts->ps_mtx); mtx_unlock(&p->p_sigacts->ps_mtx);
PROC_UNLOCK(p); PROC_UNLOCK(p);
} }
/*
* Handle deferred update of the fast sigblock value, after
* the postsig() loop was performed.
*/
if (td->td_pflags & TDP_SIGFASTPENDING) {
td->td_pflags &= ~TDP_SIGFASTPENDING;
res = fueword32(td->td_sigblock_ptr, &oldval);
if (res == -1) {
fetch_sigfastblock_failed(td, false);
} else {
for (;;) {
oldval |= SIGFASTBLOCK_PEND;
res = casueword32(td->td_sigblock_ptr, oldval,
&oldval, oldval | SIGFASTBLOCK_PEND);
if (res == -1) {
fetch_sigfastblock_failed(td, true);
break;
}
if (res == 0) {
td->td_sigblock_val = oldval &
~SIGFASTBLOCK_FLAGS;
break;
}
MPASS(res == 1);
res = thread_check_susp(td, false);
if (res != 0)
break;
}
}
}
/* /*
* We need to check to see if we have to exit or wait due to a * We need to check to see if we have to exit or wait due to a
* single threading requirement or some other STOP condition. * single threading requirement or some other STOP condition.
*/ */
if (flags & TDF_NEEDSUSPCHK) { if (flags & TDF_NEEDSUSPCHK) {
PROC_LOCK(p); PROC_LOCK(p);
thread_suspend_check(0); thread_suspend_check(0);
PROC_UNLOCK(p); PROC_UNLOCK(p);
Show All 21 Lines