HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-future/test-fiber.c
Git blob: 2760b919a0045d1c65e5731116683fc70deb11d2
Lines 1001–1172 of 1,172
/* The waiter blocked SIGUSR1 before await'ing us; the per-thread mask should still
* have it blocked here. */
ASSERT_OK_ZERO(-pthread_sigmask(SIG_SETMASK, NULL, ¤t));
ASSERT_TRUE(sigismember(¤t, SIGUSR1));
ASSERT_OK(sigemptyset(&set));
ASSERT_OK(sigaddset(&set, SIGUSR1));
ASSERT_OK_ZERO(-pthread_sigmask(SIG_UNBLOCK, &set, NULL));
return 0;
}
static int sigmask_waiter_fiber(void *userdata) {
sd_future *peer = ASSERT_PTR(userdata);
sigset_t set, current;
ASSERT_OK(sigemptyset(&set));
ASSERT_OK(sigaddset(&set, SIGUSR1));
ASSERT_OK_ZERO(-pthread_sigmask(SIG_BLOCK, &set, NULL));
ASSERT_OK_ZERO(-pthread_sigmask(SIG_SETMASK, NULL, ¤t));
ASSERT_TRUE(sigismember(¤t, SIGUSR1));
int r = sd_fiber_await(peer);
if (r < 0)
return r;
/* The peer unblocked SIGUSR1 while we were suspended. The change is per-thread, so
* we must observe it here. */
ASSERT_OK_ZERO(-pthread_sigmask(SIG_SETMASK, NULL, ¤t));
ASSERT_FALSE(sigismember(¤t, SIGUSR1));
return 0;
}
TEST(fiber_signal_mask_is_per_thread) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_event_set_exit_on_idle(e, true));
sigset_t saved;
ASSERT_OK_ZERO(-pthread_sigmask(SIG_SETMASK, NULL, &saved));
_cleanup_(sd_future_unrefp) sd_future *waiter = NULL, *peer = NULL;
ASSERT_OK(sd_fiber_new(e, "sigmask-peer", sigmask_peer_fiber, NULL, NULL, &peer));
ASSERT_OK(sd_future_set_priority(peer, 1));
ASSERT_OK(sd_fiber_new(e, "sigmask-waiter", sigmask_waiter_fiber, peer, NULL, &waiter));
ASSERT_OK(sd_future_set_priority(waiter, 0));
ASSERT_OK(sd_event_loop(e));
ASSERT_OK(sd_future_result(waiter));
ASSERT_OK(sd_future_result(peer));
ASSERT_OK_ZERO(-pthread_sigmask(SIG_SETMASK, &saved, NULL));
}
/* Test: log context is per-fiber. fiber_run() swaps the thread-local log context (and prefix) with
* a per-fiber stash on entry and exit, so fields pushed by one fiber must not leak into another
* fiber that runs while the first is suspended, and must be restored when the first resumes. */
static int log_context_peer_fiber(void *userdata) {
size_t *peer_observed = ASSERT_PTR(userdata);
/* The waiter pushed a field before await'ing us. If log context were shared across fibers,
* we would observe it here. Record what we see and let the caller verify. */
*peer_observed = log_context_num_fields();
return 0;
}
static int log_context_waiter_fiber(void *userdata) {
sd_future *peer = ASSERT_PTR(userdata);
size_t before_push = log_context_num_fields();
LOG_CONTEXT_PUSH("WAITER=here");
size_t after_push = log_context_num_fields();
if (after_push != before_push + 1)
return -EBADF;
int r = sd_fiber_await(peer);
if (r < 0)
return r;
/* Our pushed field must be visible again after the peer ran and resumed us. */
if (log_context_num_fields() != after_push)
return -EBADF;
return 0;
}
TEST(fiber_log_context_per_fiber) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_event_set_exit_on_idle(e, true));
size_t baseline = log_context_num_fields();
size_t peer_observed = 0;
_cleanup_(sd_future_unrefp) sd_future *waiter = NULL, *peer = NULL;
ASSERT_OK(sd_fiber_new(e, "log-peer", log_context_peer_fiber, &peer_observed, NULL, &peer));
ASSERT_OK(sd_future_set_priority(peer, 1));
ASSERT_OK(sd_fiber_new(e, "log-waiter", log_context_waiter_fiber, peer, NULL, &waiter));
ASSERT_OK(sd_future_set_priority(waiter, 0));
ASSERT_OK(sd_event_loop(e));
ASSERT_OK(sd_future_result(waiter));
ASSERT_OK(sd_future_result(peer));
/* Inside the peer, only the peer's own FIBER= field (pushed by fiber_run) should have been
* active — the waiter's WAITER= push must have been swapped out. */
ASSERT_EQ(peer_observed, baseline + 1);
/* The thread-local log context should be exactly as it was before the test ran. */
ASSERT_EQ(log_context_num_fields(), baseline);
}
static int stack_overflow_fiber(void *userdata) {
volatile char anchor;
size_t pagesz = page_size();
/* Walk one page at a time away from the fiber's current SP toward the guard page,
* writing one byte per page until the kernel raises a fatal signal. On downward
* stacks we walk to lower addresses (guard at the base); on upward stacks like
* hppa we walk to higher addresses (guard at the top of the mapping). The 64 MiB
* ceiling is purely a safety net so the test fails loudly instead of looping if
* the guard isn't there. */
for (size_t i = 1; i < (64U * U64_MB) / pagesz; i++) {
uintptr_t off = i * pagesz;
volatile char *p = (volatile char *) (STACK_GROWS_UP
? (uintptr_t) &anchor + off
: (uintptr_t) &anchor - off);
*p = 0;
}
return 0;
}
TEST(fiber_stack_guard) {
#if HAS_FEATURE_ADDRESS_SANITIZER
(void) log_tests_skipped("ASan intercepts deliberate stack OOB writes");
return;
#endif
#if HAVE_VALGRIND_VALGRIND_H
if (RUNNING_ON_VALGRIND) {
(void) log_tests_skipped("Valgrind intercepts deliberate stack OOB writes");
return;
}
#endif
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
int r = pidref_safe_fork("(stack-overflow)", FORK_RESET_SIGNALS|FORK_LOG, &pidref);
ASSERT_OK(r);
if (r == 0) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_event_set_exit_on_idle(e, true));
_cleanup_(sd_future_unrefp) sd_future *f = NULL;
ASSERT_OK(sd_fiber_new(e, "overflow", stack_overflow_fiber, NULL, NULL, &f));
(void) sd_event_loop(e);
_exit(EXIT_SUCCESS); /* unreachable if the guard fires */
}
siginfo_t si;
ASSERT_OK(pidref_wait_for_terminate(&pidref, &si));
ASSERT_TRUE(IN_SET(si.si_code, CLD_KILLED, CLD_DUMPED));
ASSERT_TRUE(IN_SET(si.si_status, SIGSEGV, SIGBUS));
}
DEFINE_TEST_MAIN(LOG_DEBUG);