When Is a Pending Signal Delivered?

Order of Delivery When Multiple Signals Are Pending

If several signals are unblocked at the same time (e.g. you call sigprocmask(SIG_SETMASK, ...) to unblock all of them), the Linux kernel delivers them in ascending signal number order. So SIGINT (2) is delivered before SIGQUIT (3).

Nested Signal Handlers

When multiple signals are pending and one handler is already executing, the kernel can interrupt the running handler to invoke a second one. This creates a nested call stack.

/* signal_order_demo.c - Observe order of pending signal delivery */
#define _GNU_SOURCE
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>

void handler(int sig) {
    /* async-signal-safe write() instead of printf() */
    char buf[64];
    int len = snprintf(buf, sizeof(buf), "Handler: signal %d (%s)\n",
                       sig, strsignal(sig));
    write(STDOUT_FILENO, buf, len);
}

int main(void) {
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    /* Install handlers for several signals */
    for (int s = SIGHUP; s <= SIGTERM; s++) {
        if (s != SIGKILL && s != SIGSTOP)
            sigaction(s, &sa, NULL);
    }

    /* Block ALL signals */
    sigset_t all, prev;
    sigfillset(&all);
    sigprocmask(SIG_SETMASK, &all, &prev);

    printf("PID=%d: All signals blocked. Send multiple signals now:\n",
           getpid());
    printf("Example: kill -2 %d; kill -3 %d; kill -1 %d\n",
           getpid(), getpid(), getpid());

    sleep(5);  /* Allow time to send signals from another terminal */

    printf("Unblocking all signals — watch delivery order:\n");
    sigprocmask(SIG_SETMASK, &prev, NULL);  /* unblock all at once */

    sleep(1);
    printf("Done.\n");
    return 0;
}

## Terminal 1:
$ ./signal_order_demo
PID=9999: All signals blocked. Send multiple signals now:

## Terminal 2 (while program sleeps):
$ kill -3 9999   # SIGQUIT
$ kill -2 9999   # SIGINT
$ kill -1 9999   # SIGHUP

## Back in Terminal 1 after 5 seconds:
Unblocking all signals — watch delivery order:
Handler: signal 1 (Hangup)      <-- SIGHUP delivered first (lowest number)
Handler: signal 2 (Interrupt)
Handler: signal 3 (Quit)        <-- SIGQUIT last (highest number of the three)
Done.

The Problem: Unreliable Signal Semantics

Early UNIX (System V heritage) signal() had two serious bugs:

/* signal_unreliable_demo.c - Show the "reset on entry" problem */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int count = 0;

void handler(int sig) {
    count++;
    printf("Handler invoked (count=%d)\n", count);

    /* With unreliable semantics, disposition is now SIG_DFL.
       There is a small window here where another SIGINT would
       terminate the process.
       A "reliable" handler must re-arm itself: */
    signal(SIGINT, handler);  /* Re-arm (still has a race window) */
}

int main(void) {
    signal(SIGINT, handler);
    printf("PID=%d. Keep pressing Ctrl+C quickly.\n", getpid());
    while (count < 5)
        pause();
    printf("Got 5 SIGINTs, exiting.\n");
    return 0;
}

The Fix: Always Use sigaction()

sigaction() gives you full control over signal semantics through flags. It is the correct, portable, POSIX-standard way to install signal handlers.

/* signal_impl.c - Implement signal() correctly using sigaction() */
#include <signal.h>
#include <errno.h>

typedef void (*sighandler_t)(int);

/* This is how glibc implements signal() internally */
sighandler_t my_signal(int sig, sighandler_t handler) {
    struct sigaction newDisp, prevDisp;

    newDisp.sa_handler = handler;
    sigemptyset(&newDisp.sa_mask);

    /* SA_RESTART: automatically restart interrupted system calls
       This is the "modern reliable" behavior.
       For OLD/unreliable behavior, you would use:
       SA_RESETHAND | SA_NODEFER  (resets handler + allows recursive) */
    newDisp.sa_flags = SA_RESTART;

    if (sigaction(sig, &newDisp, &prevDisp) == -1)
        return SIG_ERR;

    return prevDisp.sa_handler;
}

/* sigaction_correct.c - The RIGHT way to install a signal handler */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

volatile sig_atomic_t got_signal = 0;

void handler(int sig) {
    /* sa_mask in sigaction ensures SIGINT is blocked DURING this handler.
       No recursive invocation. No disposition reset.
       This is reliable, POSIX-correct behavior. */
    got_signal = 1;
    write(STDOUT_FILENO, "Signal caught\n", 14);
}

int main(void) {
    struct sigaction sa;
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, SIGINT);   /* block SIGINT during handler */
    sa.sa_flags = SA_RESTART;          /* restart interrupted syscalls */

    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    printf("Waiting for Ctrl+C (PID=%d)\n", getpid());
    while (!got_signal)
        pause();

    printf("Exiting cleanly after signal\n");
    return 0;
}