HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-future/test-fiber.c

40,692 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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, &current));
        ASSERT_TRUE(sigismember(&current, 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, &current));
        ASSERT_TRUE(sigismember(&current, 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, &current));
        ASSERT_FALSE(sigismember(&current, 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);