Retry EINTR on poll/select so profiling signals don't break native blocking calls (#1060)

[emeryberger]

Fixes #1060.

Problem

Profiling with Scalene breaks SQL Server connections made via pyodbc / ODBC
Driver 18 on Linux (reported on Azure Batch): connect() fails with WSAEINTR
(0x2714 / 10004) / SQLSTATE 08S01. The same code works without Scalene,
and works under Scalene on Windows.

Root cause

Scalene profiles wall-clock time by default (use_virtual_time=False), so it
arms ITIMER_REAL and delivers SIGALRM periodically — including while the
process is blocked inside a native syscall. Scalene already installs its handlers
with SA_RESTART (siginterrupt(s, False)), which auto-resumes restartable
syscalls. But per signal(7), poll(2)/select(2)/ppoll(2)/pselect(2)/
epoll_wait(2) are never restarted regardless of SA_RESTART — they always
fail with EINTR when a handler runs.

CPython retries its own I/O on EINTR (PEP 475), but native libraries that don't
break. The ODBC Driver 18 TCP provider does a non-blocking connect() followed
by poll()/select() with a login timeout; a SIGALRM landing on that wait
surfaces as WSAEINTR and a failed connection. It's Linux-only because Windows
samples via threads, not signals — and a slower (containerized / cross-network)
connection widens the window, matching the report.

No signal-handler flag can fix this: poll/select simply aren't restartable.
The interrupted wait has to be retried.

Fix

libscalene is already LD_PRELOADed whenever memory profiling is enabled (the
default), so it interposes the non-restartable wait calls and retries them on
EINTR, recomputing the remaining timeout so deadlines are preserved.

Only Scalene-induced EINTR is absorbed, so SIGINT/Ctrl-C and other signals
still propagate. Scalene's CPU sampler re-arms its one-shot interval timer from
inside the signal handler on every tick (ScaleneSignalManager.restart_timer →
setitimer), and libscalene already interposes setitimer — so the interposer
just bumps a generation counter there. The retry loop continues only when that
counter advanced across the interrupted call. No signal handler is touched,
so Scalene's signal machinery (including the --stacks native unwinder) is left
completely intact.

Opt out with SCALENE_DISABLE_EINTR_RETRY=1 (pure pass-through).

Files

• src/include/eintr_retry.hpp — interposer logic. Linux uses
  dlsym(RTLD_NEXT); macOS calls the libc symbol directly (as Heap-Layers'
  memcpy wrapper does), because __interpose only redirects other images and
  dlsym(RTLD_NEXT) would otherwise return our own shim and recurse.
• src/source/libscalene.cpp — exported interpose entry points + MAC_INTERPOSE.
• tests/test_eintr_retry.py — POSIX regression test (builds a tiny interposer
  from the real header; verifies poll/select survive the timer while SIGINT
  still interrupts) plus a Windows test that profiles a blocking TCP round-trip
  under scalene run and asserts it completes cleanly.
• .github/workflows/tests.yml — adds a scoped run-tests-windows job that
  builds Scalene and runs the test on windows-latest (Python 3.11 + 3.13).

Testing

Verified with a rebuilt libscalene:

• Baseline (no interposer) reproduces the bug — poll dies with EINTR in ~6 ms.
• With the interposer, poll/select run their full timeout despite the timer;
  SIGINT still interrupts; SCALENE_DISABLE_EINTR_RETRY=1 restores pass-through.
• scalene run (default + memory), --stacks, and --stacks --profile-interval
  all run clean (the earlier handler-wrapping approach crashed here; the
  setitimer-based design does not). Measured no profiling overhead vs master
  (2.5 s memory-profiling run, identical to baseline).

CI: smoketests pass on all platforms incl. Windows; run-tests passes on
Linux + macOS (the regression test runs and passes there); the new
run-tests-windows jobs pass.

🤖 Generated with Claude Code