EINTR Not Restarting Some Blocking Calls Even With SA_RESTART

Direct Answer

There is no kernel-level global switch to force all blocking system calls to restart after a signal. SA_RESTART is a per-signal flag that only affects a fixed, conservative list of "restartable" syscalls. connect() is deliberately excluded from that list and will return -EINTR even when SA_RESTART is set. getaddrinfo() is a glibc (or libc) library function, not a direct syscall, so SA_RESTART does not automatically govern its internal resolver behavior.

Confirmed Facts vs. Likely Explanation

Confirmed: On Linux, read(), write(), and accept() on sockets, pipes, and terminals are generally restartable under SA_RESTART. connect() on a blocking socket is not restartable; the kernel returns EINTR to userspace regardless of the flag.

Likely: The getaddrinfo() behavior you observe depends on the C library implementation. glibc's resolver may use non-blocking sockets internally and handle EINTR differently across versions, while other libc implementations may surface the error directly. Because it runs in userspace, the kernel cannot enforce a uniform restart policy for it.

Why a Global Restart Mode Does Not Exist

Automatically restarting every interrupted syscall would be unsafe. A signal handler can modify process state, acquire locks, or invalidate assumptions the blocked syscall relied upon. Blindly re-entering the kernel after the handler returns risks deadlocks, double side effects, or corrupted protocol state. The kernel therefore keeps the restartable set small and explicit.

What to Do Instead

1. Verify the restartable list for your system. Consult man 7 signal; the set of calls affected by SA_RESTART is documented there and has been stable across mainstream kernels.
2. Trace the actual behavior. Run the failing program under strace -e trace=connect,read,write,accept -e signal=all to confirm which calls return EINTR when your timer fires.
3. Use explicit EINTR loops for safe calls. For calls that are safe to retry, wrap them:

   ssize_t n;
   do {
       n = read(fd, buf, count);
   } while (n == -1 && errno == EINTR);

   Do not apply this pattern blindly to connect() on a blocking socket; retry semantics are subtle because the connection attempt may already be in progress.
4. Prefer poll/select/epoll for timeouts. Instead of alarm(), put the socket in non-blocking mode, start connect(), and wait for writability with a timeout:

   int flags = fcntl(fd, F_GETFL, 0);
   fcntl(fd, F_SETFL, flags | O_NONBLOCK);
   int r = connect(fd, addr, addrlen);
   if (r < 0 && errno == EINPROGRESS) {
       struct pollfd pfd = { .fd = fd, .events = POLLOUT };
       int pr = poll(&pfd, 1, timeout_ms);
       /* check SO_ERROR and pfd.revents */
   }

   This avoids relying on SA_RESTART entirely and gives you portable timeout control.

If your goal is uniform timeout handling, the supported path is userspace: non-blocking I/O plus poll()/epoll_wait() with explicit timeouts, and EINTR retry loops only where the operation is idempotent.