feat: add sigResetState and sigDefaultIsIgnore
This commit is contained in:
dualfroz committed
1 parent
c885f33d76
commit
26476fc78b
1 file changed
+156
+156
@@ -0,0 +1,156 @@
|
||||
#include "signal.h"
|
||||
#include "string.h"
|
||||
#include "pmm.h"
|
||||
#include "paging.h"
|
||||
|
||||
/* Machine code for the shared trampoline page, sigTrampoline.S -- position
|
||||
independent by construction (no absolute address references at all), so
|
||||
copying its bytes anywhere and mapping them there is enough. */
|
||||
extern char sigTrampolineStart[];
|
||||
extern char sigTrampolineEnd[];
|
||||
|
||||
/* Physical frame addresses backing sigInfoVirtualAddr's page(s), filled in
|
||||
by sigInstallInfoPage -- kept as separate frames (not assumed physically
|
||||
contiguous, unlike their virtual mapping, which IS contiguous by
|
||||
construction: pmmAlloc gives no contiguity guarantee across calls, so
|
||||
sigConsumePending must look up the right frame for a given slot rather
|
||||
than pointer-arithmetic across a single base). Physical frames below the
|
||||
1 GiB boot-time identity map (see sigTrampolineVirtualAddr's own comment)
|
||||
are directly dereferenceable through their own physical value from
|
||||
kernel code, exactly like sigInstallTrampoline's memcpy into `frame`
|
||||
above already relies on. */
|
||||
static uint64 sigInfoFrames[sigInfoMaxPages];
|
||||
static uint32 sigInfoPageCount = 0;
|
||||
|
||||
/* How many SigInfo structs fit in one frameSize page -- shared by
|
||||
sigInstallInfoPage's sizing loop and sigConsumePending's slot lookup, so
|
||||
the two can never disagree about the layout. */
|
||||
#define sigInfoSlotsPerPage (frameSize / sizeof(SigInfo))
|
||||
|
||||
void sigResetState(Thread* thread)
|
||||
{
|
||||
thread->sigPending = 0;
|
||||
thread->sigBlocked = 0;
|
||||
thread->sigHandlerDepth = 0;
|
||||
thread->sigInRetryableSyscall = false;
|
||||
memset(thread->sigHandlers, 0, sizeof(thread->sigHandlers));
|
||||
memset(thread->sigHandlerMasks, 0, sizeof(thread->sigHandlerMasks));
|
||||
memset(thread->sigHandlerFlags, 0, sizeof(thread->sigHandlerFlags));
|
||||
memset(thread->sigPendingInfo, 0, sizeof(thread->sigPendingInfo));
|
||||
memset(thread->sigSavedBlocked, 0, sizeof(thread->sigSavedBlocked));
|
||||
memset(thread->sigSavedRegs, 0, sizeof(thread->sigSavedRegs));
|
||||
}
|
||||
|
||||
/* Real-world default disposition for signals this kernel actually defines
|
||||
that is Ignore rather than Terminate -- SIGCHLD (no handler installed:
|
||||
nothing happens) and SIGCONT (its actual resume effect already happened
|
||||
unconditionally in sigRaise -- see file comment -- so "no handler" here
|
||||
just means no handler runs, not that nothing happened at all). SIGSTOP
|
||||
never reaches this function to begin with (sigRaise bypasses the whole
|
||||
scan for it, like sigKill), so it is deliberately absent from this list,
|
||||
the same way sigKill already was. SIGTSTP is NOT here -- its default is
|
||||
Stop, not Ignore, see sigDefaultIsStop below. Every other defined signal
|
||||
defaults to Terminate. */
|
||||
static bool sigDefaultIsIgnore(int signum)
|
||||
{
|
||||
switch (signum) {
|
||||
case sigChld:
|
||||
case sigCont:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/* Real-world default disposition that is Stop rather than Terminate:
|
||||
SIGTSTP only. Unlike SIGSTOP (see file comment / sigRaise), SIGTSTP is
|
||||
fully catchable/blockable/ignorable -- this default only applies when it
|
||||
is neither, exactly like sigDefaultIsIgnore's entries. */
|
||||
static bool sigDefaultIsStop(int signum)
|
||||
{
|
||||
return signum == sigTstp;
|
||||
}
|
||||
|
||||
/* Whether `signum` would genuinely be delivered (a real handler OR a
|
||||
default disposition of Terminate/Stop -- anything sigConsumePending
|
||||
itself would act on, not silently dismiss) if `thread` returned to ring 3
|
||||
right now. Deliberately mirrors sigConsumePending's own
|
||||
blocked/ignored-dismissal logic for exactly one signal number rather than
|
||||
sharing code with it -- sigConsumePending also mutates sigPending/
|
||||
sigHandlerDepth/the trapframe as it scans, none of which this pure
|
||||
predicate may do, since it runs from sigRaise against a target that is
|
||||
not currently resuming at all. Used solely to decide whether a Sleeping/
|
||||
Blocked target needs early-waking (threadWakeForSignal, sched.c) for this
|
||||
signal -- if this ever drifted out of sync with sigConsumePending's own
|
||||
logic, the failure mode is always benign either way: "wakes for a signal
|
||||
that turns out not to be delivered" is a harmless spurious wake (the
|
||||
target's own retry-syscall loop just re-blocks, exactly like a real
|
||||
spurious wakeup), and "does not wake for one that would have delivered"
|
||||
just falls back to today's behavior of waiting for a natural wake. */
|
||||
static bool sigWouldDeliver(const Thread* thread, int signum)
|
||||
{
|
||||
uint64 bit = 1ull << (uint32)signum;
|
||||
if (thread->sigBlocked & bit)
|
||||
return false;
|
||||
|
||||
uint64 handler = thread->sigHandlers[signum];
|
||||
if (handler == sigHandlerIgnore ||
|
||||
(handler == sigHandlerDefault && sigDefaultIsIgnore(signum)))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool sigRaiseInfo(uint32 targetId, int signum, int siCode, int siPid, int siStatus)
|
||||
{
|
||||
if (signum <= 0 || signum >= sigMaxSignals)
|
||||
return false;
|
||||
|
||||
/* SIGKILL never touches sigPending/sigBlocked at all -- it is
|
||||
delegated straight to the pre-existing unconditional termination
|
||||
path, exactly like real kill(pid, SIGKILL) bypassing every handler/
|
||||
mask a target could have installed. threadKill does its own id
|
||||
validation (range, state), so none is duplicated here. Neither it
|
||||
nor SIGSTOP just below ever reaches a sigHandlers[] entry that could
|
||||
even be sigFlagSigInfo, so the caller-supplied SigInfo fields are
|
||||
simply never used on either of these two paths. */
|
||||
if (signum == sigKill)
|
||||
return threadKill(targetId);
|
||||
|
||||
/* SIGSTOP: uncatchable, unblockable, unignorable, exactly like SIGKILL
|
||||
above -- bypasses sigPending/sigHandlers/sigBlocked entirely and acts
|
||||
on ThreadState directly. threadStop does its own id validation. */
|
||||
if (signum == sigStop)
|
||||
return threadStop(targetId);
|
||||
|
||||
if (targetId == 0 || targetId >= threadCapacity())
|
||||
return false;
|
||||
|
||||
Thread* target = threadAt(targetId);
|
||||
if (target->state == threadDead || target->state == threadUnused)
|
||||
return false;
|
||||
|
||||
/* SIGCONT's resume is likewise not something a mask or a missing
|
||||
handler can defer -- called unconditionally before the generic
|
||||
pending-bit path below, so a Stopped target is moved back to
|
||||
threadRunnable regardless of whether it also has a handler
|
||||
installed. Its return value is intentionally ignored: "target
|
||||
was not actually Stopped" is a harmless no-op at the process-state
|
||||
level (real SIGCONT to a running process), not a reason to skip
|
||||
delivering the signal itself for any installed handler. */
|
||||
if (signum == sigCont)
|
||||
threadContinue(targetId);
|
||||
|
||||
target->sigPending |= (1ull << (uint32)signum);
|
||||
|
||||
/* Attached regardless of whether signum's handler actually has
|
||||
sigFlagSigInfo set (sigConsumePending is what decides whether this
|
||||
ever gets read at all) -- cheap (4 ints), and simpler than threading
|
||||
the handler's own flags in here just to skip it, matching how
|
||||
sigHandlerMasks/sigHandlerFlags are likewise set unconditionally by
|
||||
sigSetHandler and only ever consulted conditionally. */
|
||||
target->sigPendingInfo[signum].siSignum = signum;
|
||||
target->sigPendingInfo[signum].siCode = siCode;
|
||||
target->sigPendingInfo[signum].siPid = siPid;
|
||||
target->sigPendingInfo[signum].siStatus = siStatus;
|
||||
|
||||
Reference in new issue
Block a user