Skip to content

Fix GH-25541: Signal on a thread that never ran PHP crashes or kills the process - #25580

Open
phcorp wants to merge 2 commits into
php:PHP-8.4from
phcorp:fix-gh25541-minimal
Open

phcorp wants to merge 2 commits into
php:PHP-8.4from
phcorp:fix-gh25541-minimal

Conversation

@phcorp

@phcorp phcorp commented Nov 19, 2026 •

Copy link
Copy Markdown

Under ZTS, the kernel may deliver a process signal to any thread that does not block it, including threads that never ran PHP and have no TSRM storage. Examples are the Go runtime threads in FrankenPHP, or any thread an embedding application creates. When that happens:

  • with --disable-zend-signals, pcntl_signal_handler() reads PCNTL_G() through a NULL TSRM pointer and crashes;
  • with zend signals (the default), zend_signal_handler_defer() falls back to the original disposition, so SIG_DFL kills the process even though the script registered a pcntl handler.

Reproducer (ZTS, with the new zend_test hook): pcntl_signal(SIGUSR1, fn() => print "ok\n"); zend_test_raise_on_foreign_thread(SIGUSR1); pcntl_signal_dispatch();. On a stock 8.4 build, the process dies from SIGUSR1, or crashes with --disable-zend-signals.

Fix: on a thread without TSRM, for a signal that at least one PHP thread still handles (neither SIG_DFL nor SIG_IGN) and the embedder does not, the handler adds the signal to the mask saved in its ucontext (so the thread blocks it after sigreturn) and sends it to the process again with kill(getpid(), signo). The kernel then delivers it to a thread that does not block it, and foreign threads stop taking it after the first time, so it ends up on a PHP thread. A thread unblocks re-routed signals when it starts a request, which covers threads created by a masked thread. Faults and abort() keep their default action on the thread they hit; signals with no PHP handler, or handled by the embedder, keep the original disposition, as before. A per-signal count of PHP threads with a handler follows zend_sigaction(), request start and thread exit, so a handler set back to SIG_DFL stops the re-routing. There's no new thread and no lock. Re-routing is enabled on Linux, macOS and FreeBSD, where I measured it (glibc and musl, arm64 and amd64; macOS arm64; FreeBSD 15.1 arm64).

Not covered:

  • It changes the signal mask of threads the embedder owns, for signals PHP handles. At request start, PHP threads unblock re-routed signals, as zend_sigaction() already does for the signals it registers.
  • siginfo of the delivered signal names this process as the sender.
  • The PHP thread that receives the signal is not necessarily the one that registered the handler (ZTS: pcntl signal handled by one PHP thread ends the process or is lost when delivered elsewhere #25549).
  • On macOS, a signal re-sent while every thread blocks it is attached to the main thread, so if the main thread doesn't run PHP it is lost. Linux and FreeBSD keep it pending process-wide. Also on macOS, SIGSEGV and SIGBUS sent with kill() carry a fault code, so they are treated as faults.

GH-25548 (the execution timer) is a separate PR on top of this one.

Questions for reviewers:

  1. Is changing a foreign thread's mask acceptable for embedders, or should it be opt-in?
  2. This adds three ZEND_API functions on 8.4 so pcntl can use them without zend signals. Is that OK on a stable branch, or should pcntl keep its own copy?

Merge-up notes (first commit checked locally on 8.5, 8.6 and master, with and without zend signals; the second commit checked on master only, on macOS):

  • PHP-8.6 and master: drop the # ifdef HAVE_STRUCT_SIGINFO_T / # endif around the re-route in pcntl_signal_handler(), since ext/pcntl simplification. #13975 removed that macro. Otherwise it still compiles, but signals are dropped with --disable-zend-signals, which no CI job builds.
  • master: in Zend/zend_signal.c, zend_atomic_bool/zend_atomic_int become atomic_bool/atomic_int, zend_atomic_*_load_ex()/_store_ex() become atomic_load()/atomic_store(), and zend_atomic_int_compare_exchange_ex() becomes atomic_compare_exchange_strong(); zend_signal_startup() passes zend_signal_globals_dtor to ts_allocate_tls_id().

…ls the process

Under ZTS, a process signal can be delivered to a thread that has no TSRM
storage, e.g. a Go runtime thread in FrankenPHP or any thread an embedder
creates. pcntl_signal_handler() then read PCNTL_G() through a NULL pointer
(--disable-zend-signals), and zend_signal_handler_defer() fell back to the
original disposition, so SIG_DFL killed the process although the script
registered a handler.

On such a thread, for a signal PHP handles, add the signal to the mask saved
in the interrupted context and send it to the process again. The kernel
delivers it to a thread that does not block it, which converges on a PHP
thread. Threads unblock re-routed signals when they start a request. Faults
and abort() keep their default action on the thread they hit. Re-routing is
enabled on Linux, macOS and FreeBSD, where it was verified.
@devnexen

Copy link
Copy Markdown
Member

I do not feel particularly confident overall, can this test be tried ?

--TEST--
GH-25541 (Signal whose handler was removed keeps its default action on a thread that never ran PHP)
--EXTENSIONS--
pcntl
posix
zend_test
--SKIPIF--
<?php
if (!function_exists('zend_test_start_foreign_thread')) die('skip ZTS only');
?>
--FILE--
<?php
$pid = pcntl_fork();
if ($pid === 0) {
    pcntl_signal(SIGUSR1, function () {});
    pcntl_signal(SIGUSR1, SIG_DFL);
    zend_test_start_foreign_thread();

    /* The PHP thread blocks the signal, so the kernel picks the other thread. */
    pcntl_sigprocmask(SIG_BLOCK, [SIGUSR1]);
    posix_kill(posix_getpid(), SIGUSR1);
    usleep(500000);
    echo "child survived", PHP_EOL;
    exit(0);
}

pcntl_waitpid($pid, $status);
var_dump(pcntl_wifsignaled($status));
var_dump(pcntl_wifsignaled($status) && pcntl_wtermsig($status) === SIGUSR1);
?>
--EXPECT--
bool(true)
bool(true)

A signal whose handler was set back to SIG_DFL kept being sent on from a
thread that never ran PHP. If every PHP thread blocked it, the signal
stayed pending instead of taking its default action.

Count the PHP threads whose handler is neither SIG_DFL nor SIG_IGN, and
only re-route while that count is positive. The count follows every
write to a thread's handlers and drops when a thread's storage is freed.

zend_test_start_foreign_thread() starts a thread that never runs PHP and
stays alive, so a test can block the signal on the PHP thread only.
@phcorp

phcorp commented Nov 19, 2026

Copy link
Copy Markdown
Author

Thanks, your doubt was justified: the test found a real regression. I ran it three times per build, on stock 8.4 and on this branch, with and without zend signals:

  • Linux (glibc and musl) and FreeBSD: stock 8.4 passes. This branch failed with zend signals ("child survived"). The flag that enables re-routing was set when a handler was registered and never cleared, so the other thread kept sending SIGUSR1 on, and with the PHP thread blocking it, nothing took it.
  • macOS: it fails on stock 8.4 too, because sigprocmask() there blocks the signal in every thread, the foreign one included. So it skips on macOS.

Fixed in 9e158b5. The flag is now a count of PHP threads whose handler is neither SIG_DFL nor SIG_IGN. zend_sigaction() updates it, as do request start and the freeing of a thread's storage. Re-routing only happens while the count is positive.

I added your test unchanged except for the macOS skip, with zend_test_start_foreign_thread() in zend_test. I also added gh25541_blocked.phpt for the opposite case: the handler is still set and the PHP thread blocks the signal, and the handler must run once it unblocks it. On stock 8.4 that one kills the process (SIGUSR1), or crashes with --disable-zend-signals.

With the fix, the five gh25541 tests pass 5/5 on glibc, musl and FreeBSD in both modes, and ext/pcntl, ext/posix, ext/zend_test and Zend/tests show no new failures.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants