test: strengthen tests for sigTest
This commit is contained in:
dualfroz committed
1 parent
978d2ad905
commit
febf5254a4
1 file changed
+155
+155
@@ -626,3 +626,158 @@ KTEST(sigConsumePendingDefersSameSignalRaisedAgainWhileItsOwnHandlerIsActive)
|
||||
KT_TRUE(t, threadDiscard(id));
|
||||
}
|
||||
|
||||
/* sigFlagNoDefer's whole point: registered for a signal, that signal's own
|
||||
bit is no longer added to sigBlocked when its handler starts, so raising
|
||||
the SAME signum again while that handler is still active genuinely
|
||||
nests a second instance of it -- the direct opposite outcome of the
|
||||
test just above, same signum, only the flag differs. */
|
||||
KTEST(sigConsumePendingNoDeferFlagLetsSameSignalNestIntoItsOwnActiveHandler)
|
||||
{
|
||||
uint32 id = threadCreate("sigNoDeferOnTarget", noopThreadEntry);
|
||||
KT_NE(t, id, threadInvalidId);
|
||||
Thread* thread = threadAt(id);
|
||||
Registers regs = makeUserRegs();
|
||||
int signum = -1;
|
||||
|
||||
uint64 handlerAddr = 0x40009000ull;
|
||||
sigSetHandler(thread, sigUsr1, handlerAddr, 0, sigFlagNoDefer);
|
||||
sigRaise(id, sigUsr1);
|
||||
|
||||
KT_EQ(t, sigConsumePending(thread, ®s, &signum), sigOutcomeHandler);
|
||||
KT_EQ(t, signum, sigUsr1);
|
||||
/* The one thing sigFlagNoDefer actually changes: sigUsr1's own bit is
|
||||
NOT in sigBlocked, unlike the default case above. */
|
||||
KT_FALSE(t, thread->sigBlocked & (1ull << sigUsr1));
|
||||
KT_EQU(t, thread->sigHandlerDepth, 1u);
|
||||
|
||||
Registers midHandler = regs;
|
||||
sigRaise(id, sigUsr1);
|
||||
int nestedSignum = -1;
|
||||
KT_EQ(t, sigConsumePending(thread, ®s, &nestedSignum), sigOutcomeHandler);
|
||||
KT_EQ(t, nestedSignum, sigUsr1);
|
||||
KT_EQU(t, regs.rip, sigTrampolineVirtualAddr);
|
||||
KT_EQU(t, regs.rax, handlerAddr);
|
||||
KT_EQU(t, thread->sigHandlerDepth, 2u);
|
||||
/* Still no self-block even at the nested depth -- a third raise would
|
||||
nest again the same way, bounded only by sigMaxNestDepth, never by
|
||||
sigUsr1 blocking itself. */
|
||||
KT_FALSE(t, thread->sigBlocked & (1ull << sigUsr1));
|
||||
KT_EQ(t, memcmp(&thread->sigSavedRegs[1], &midHandler, sizeof(midHandler)), 0);
|
||||
|
||||
/* Unwinding pops the nested instance first, resuming the outer one
|
||||
exactly where the re-raise interrupted it -- LIFO, same as any other
|
||||
nested delivery. */
|
||||
KT_TRUE(t, sigOnSigReturn(thread, ®s));
|
||||
KT_EQ(t, memcmp(®s, &midHandler, sizeof(midHandler)), 0);
|
||||
KT_EQU(t, thread->sigHandlerDepth, 1u);
|
||||
|
||||
KT_TRUE(t, sigOnSigReturn(thread, ®s));
|
||||
KT_EQU(t, thread->sigHandlerDepth, 0u);
|
||||
|
||||
KT_TRUE(t, threadDiscard(id));
|
||||
}
|
||||
|
||||
KTEST(sigConsumePendingCustomHandlerRewritesTrapframeAndPushesContext)
|
||||
{
|
||||
uint32 id = threadCreate("sigConsumeHandler", noopThreadEntry);
|
||||
KT_NE(t, id, threadInvalidId);
|
||||
Thread* thread = threadAt(id);
|
||||
Registers regs = makeUserRegs();
|
||||
Registers before = regs;
|
||||
int signum = -1;
|
||||
|
||||
uint64 handlerAddr = 0x40009000ull;
|
||||
sigSetHandler(thread, sigUsr1, handlerAddr, 0, 0);
|
||||
sigProcMask(thread, sigMaskBlock, (1ull << sigUsr2));
|
||||
uint64 blockedBefore = thread->sigBlocked;
|
||||
sigRaise(id, sigUsr1);
|
||||
|
||||
KT_EQ(t, sigConsumePending(thread, ®s, &signum), sigOutcomeHandler);
|
||||
KT_EQ(t, signum, sigUsr1);
|
||||
|
||||
/* Trapframe rewritten to enter the trampoline: rip is the shared
|
||||
trampoline entry, rax is the handler address its `call *%rax`
|
||||
invokes, rdi is the signal number (the handler's sole argument). */
|
||||
KT_EQU(t, regs.rip, sigTrampolineVirtualAddr);
|
||||
KT_EQU(t, regs.rax, handlerAddr);
|
||||
KT_EQU(t, regs.rdi, (uint64)sigUsr1);
|
||||
/* Untouched: the trampoline runs on the interrupted thread's own
|
||||
existing stack, no separate signal stack. */
|
||||
KT_EQU(t, regs.rsp, before.rsp);
|
||||
|
||||
/* sigUsr1's own sa_mask is empty (0 above), so the ONLY new bit added
|
||||
to sigBlocked is sigUsr1 itself (self-blocked, like real Unix) --
|
||||
whatever was already blocked (sigUsr2, from sigProcMask) survives
|
||||
untouched, a union not a replacement. */
|
||||
KT_EQU(t, thread->sigHandlerDepth, 1u);
|
||||
KT_EQU(t, thread->sigBlocked, blockedBefore | (1ull << sigUsr1));
|
||||
KT_EQU(t, thread->sigSavedBlocked[0], blockedBefore);
|
||||
|
||||
/* The ENTIRE pre-signal trapframe must be recoverable later -- not
|
||||
just the fields this test happens to check above. */
|
||||
KT_EQ(t, memcmp(&thread->sigSavedRegs[0], &before, sizeof(before)), 0);
|
||||
|
||||
/* An ALREADY-blocked signal (sigUsr2, blocked since before sigUsr1 was
|
||||
even raised) stays deferred while a handler is active, exactly like
|
||||
it would with no handler running at all -- the depth stack does not
|
||||
change what sigBlocked itself gates. */
|
||||
sigRaise(id, sigUsr2);
|
||||
int blockedSignum = -1;
|
||||
KT_EQ(t, sigConsumePending(thread, ®s, &blockedSignum), sigOutcomeNone);
|
||||
KT_EQ(t, blockedSignum, -1);
|
||||
KT_TRUE(t, thread->sigPending & (1ull << sigUsr2));
|
||||
|
||||
/* A signal NOT covered by sigUsr1's mask nor its own self-block --
|
||||
sigHup -- genuinely interrupts the active handler with a NESTED one
|
||||
of its own: this is the behavior a single "one handler at a time"
|
||||
bool (this code used to have) could never produce, since it gated
|
||||
delivery before sigBlocked was even consulted. */
|
||||
Registers midUsr1Handler = regs;
|
||||
uint64 handlerAddrHup = 0x4000B000ull;
|
||||
sigSetHandler(thread, sigHup, handlerAddrHup, 0, 0);
|
||||
sigRaise(id, sigHup);
|
||||
int nestedSignum = -1;
|
||||
KT_EQ(t, sigConsumePending(thread, ®s, &nestedSignum), sigOutcomeHandler);
|
||||
KT_EQ(t, nestedSignum, sigHup);
|
||||
KT_EQU(t, regs.rip, sigTrampolineVirtualAddr);
|
||||
KT_EQU(t, regs.rax, handlerAddrHup);
|
||||
KT_EQU(t, regs.rdi, (uint64)sigHup);
|
||||
KT_EQU(t, thread->sigHandlerDepth, 2u);
|
||||
/* sigHup's own handler has no mask either, so its blocked set is
|
||||
whatever sigUsr1's handler already made it, plus sigHup's own bit. */
|
||||
KT_EQU(t, thread->sigBlocked,
|
||||
blockedBefore | (1ull << sigUsr1) | (1ull << sigHup));
|
||||
/* What got pushed for THIS (nested) frame is exactly the trapframe
|
||||
sigUsr1's handler was actually running with the instant sigHup
|
||||
preempted it -- not the original pre-sigUsr1 `before` snapshot. */
|
||||
KT_EQ(t, memcmp(&thread->sigSavedRegs[1], &midUsr1Handler,
|
||||
sizeof(midUsr1Handler)), 0);
|
||||
KT_EQU(t, thread->sigSavedBlocked[1], blockedBefore | (1ull << sigUsr1));
|
||||
|
||||
/* Unwinding: first sigOnSigReturn resumes sigUsr1's still-active
|
||||
handler exactly where sigHup interrupted it, not the original
|
||||
program -- LIFO, like a real call stack of signal frames. */
|
||||
KT_TRUE(t, sigOnSigReturn(thread, ®s));
|
||||
KT_EQ(t, memcmp(®s, &midUsr1Handler, sizeof(midUsr1Handler)), 0);
|
||||
KT_EQU(t, thread->sigHandlerDepth, 1u);
|
||||
KT_EQU(t, thread->sigBlocked, blockedBefore | (1ull << sigUsr1));
|
||||
|
||||
/* Second sigOnSigReturn finally resumes the ORIGINAL interrupted
|
||||
program, restoring the exact pre-sigUsr1 trapframe and blocked
|
||||
mask. */
|
||||
KT_TRUE(t, sigOnSigReturn(thread, ®s));
|
||||
KT_EQ(t, memcmp(®s, &before, sizeof(before)), 0);
|
||||
KT_EQU(t, thread->sigHandlerDepth, 0u);
|
||||
KT_EQU(t, thread->sigBlocked, blockedBefore);
|
||||
|
||||
KT_TRUE(t, threadDiscard(id));
|
||||
}
|
||||
|
||||
KTEST(sigConsumePendingRefusesNewHandlerAtMaxNestDepth)
|
||||
{
|
||||
uint32 id = threadCreate("sigNestDepthLimit", noopThreadEntry);
|
||||
KT_NE(t, id, threadInvalidId);
|
||||
Thread* thread = threadAt(id);
|
||||
Registers regs = makeUserRegs();
|
||||
int signum = -1;
|
||||
|
||||
Reference in new issue
Block a user