The key insight is: select() can only watch file descriptors, not signals. The self-pipe trick converts a signal event into an I/O event by routing it through a pipe. Now select() can watch for it!

This is a common interview topic. Both ends must be O_NONBLOCK for different reasons:

Signal handlers have strict restrictions. You cannot call most standard library functions inside a signal handler because they may not be async-signal-safe — they might use global state, locks, or buffers that could be in an inconsistent state when the signal interrupted the main program.

For example: printf() uses internal locks and buffers — NOT safe in a signal handler. malloc() uses heap locks — NOT safe. But write() is a raw system call with no internal buffering or locks — it IS async-signal-safe and is explicitly listed in the POSIX table of safe functions.

Important: The signal handler must also save and restore errno before and after the write() call. This is because write() can change errno, and if the signal arrived while the main program was in the middle of a system call that was setting errno, the main program’s errno would be corrupted.

This is a subtle but important detail. Any system call inside a signal handler can change the global errno. If the signal interrupted the main program while it was in the middle of checking errno, the value would be overwritten. The fix is simple — save and restore errno.

static void
handler(int sig)
{
    int savedErrno;   /* Save errno before doing anything */

    savedErrno = errno;

    /* This write() might change errno to EAGAIN if pipe is full */
    if (write(pfd[1], "x", 1) == -1 && errno != EAGAIN)
        /* Real error — but we can't easily handle it here */
        _exit(EXIT_FAILURE);   /* Use _exit(), not exit() — _exit is signal-safe */

    errno = savedErrno;   /* Restore errno so main program is not affected */
}

This is a complete, compilable example demonstrating the self-pipe trick. It monitors stdin for input and catches SIGINT (Ctrl+C), handling both through a single select() call.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>

/* Global pipe file descriptors — used by both handler and main */
static int pfd[2];

/* -------------------------------------------------------
 * Signal handler — only writes ONE byte to the pipe.
 * This is the entire self-pipe trick on the signal side.
 * ------------------------------------------------------- */
static void
handler(int sig)
{
    int savedErrno;

    savedErrno = errno;   /* Save errno — write() may change it */

    /* write() is async-signal-safe — safe to call here.
     * If pipe is full (EAGAIN), ignore — earlier write already notified. */
    if (write(pfd[1], "x", 1) == -1 && errno != EAGAIN) {
        /* Unrecoverable error — use _exit (not exit) */
        _exit(EXIT_FAILURE);
    }

    errno = savedErrno;   /* Restore errno */
}

/* Helper: make a file descriptor non-blocking */
static void
make_nonblocking(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        perror("fcntl F_GETFL");
        exit(EXIT_FAILURE);
    }

    flags |= O_NONBLOCK;

    if (fcntl(fd, F_SETFL, flags) == -1) {
        perror("fcntl F_SETFL");
        exit(EXIT_FAILURE);
    }
}

int main(void)
{
    fd_set readfds;
    struct sigaction sa;
    struct timeval timeout;
    int ready, nfds;
    char ch;

    /* ---- Step 1: Create the pipe ---- */
    if (pipe(pfd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    /* Make BOTH ends non-blocking */
    make_nonblocking(pfd[0]);   /* read end — so drain loop can detect empty */
    make_nonblocking(pfd[1]);   /* write end — so handler never blocks */

    /* ---- Step 2: Set up the fd_set ---- */
    FD_ZERO(&readfds);
    FD_SET(STDIN_FILENO, &readfds);  /* Watch stdin */
    FD_SET(pfd[0], &readfds);        /* Watch pipe read end */

    /* nfds must be highest fd + 1 */
    nfds = pfd[0] + 1;   /* Assuming pfd[0] > STDIN_FILENO */
    if (STDIN_FILENO + 1 > nfds)
        nfds = STDIN_FILENO + 1;

    /* ---- Step 3: Install signal handler for SIGINT ---- */
    sa.sa_handler = handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;   /* Restart system calls interrupted by signal */

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

    printf("Waiting for stdin input or SIGINT (Ctrl+C)...\n");
    printf("PID = %d\n", (int)getpid());

    /* ---- Step 4: select() in a loop — restart on EINTR ---- */
    for (;;) {
        /* IMPORTANT: Must reset fd_set on each iteration!
         * select() modifies the sets to show which fds are ready. */
        FD_ZERO(&readfds);
        FD_SET(STDIN_FILENO, &readfds);
        FD_SET(pfd[0], &readfds);

        /* Timeout: wait up to 30 seconds */
        timeout.tv_sec  = 30;
        timeout.tv_usec = 0;

        ready = select(nfds, &readfds, NULL, NULL, &timeout);

        if (ready == -1) {
            if (errno == EINTR) {
                /* Signal interrupted select() — restart the loop.
                 * The handler already wrote to the pipe, so on the
                 * next iteration select() will return immediately with pfd[0] set. */
                printf("[select() was interrupted by a signal — restarting]\n");
                continue;
            }
            perror("select");
            exit(EXIT_FAILURE);
        }

        if (ready == 0) {
            printf("Timeout — nothing happened for 30 seconds.\n");
            break;
        }

        /* ---- Step 5: Check if signal arrived via pipe ---- */
        if (FD_ISSET(pfd[0], &readfds)) {
            printf("A signal was caught via self-pipe!\n");

            /* ---- Step 6: Drain ALL bytes from pipe ---- */
            /* Loop until read() returns EAGAIN (pipe empty) */
            int signal_count = 0;
            for (;;) {
                if (read(pfd[0], &ch, 1) == -1) {
                    if (errno == EAGAIN)
                        break;   /* Pipe is empty — done draining */
                    perror("read");
                    exit(EXIT_FAILURE);
                }
                signal_count++;
            }

            printf("Number of signals delivered: %d\n", signal_count);
            printf("Taking action in response to signal...\n");

            /* In a real program, take appropriate action here.
             * For SIGINT, we could initiate a graceful shutdown. */
            printf("Received SIGINT — initiating graceful shutdown.\n");
            break;
        }

        /* Check if stdin has data */
        if (FD_ISSET(STDIN_FILENO, &readfds)) {
            char buf[256];
            ssize_t n = read(STDIN_FILENO, buf, sizeof(buf) - 1);
            if (n > 0) {
                buf[n] = '\0';
                printf("Read from stdin: %s", buf);
            } else if (n == 0) {
                printf("stdin closed (EOF)\n");
                break;
            }
        }
    }

    /* Clean up */
    close(pfd[0]);
    close(pfd[1]);

    printf("Program exiting.\n");
    return 0;
}

gcc -Wall -o self_pipe self_pipe.c
./self_pipe
# Type something and press Enter — stdin input detected
# Press Ctrl+C — signal caught via self-pipe

The self-pipe trick is not limited to select(). The same technique works equally well with poll() and epoll_wait(). The signal handler and pipe setup are identical — only the I/O monitoring call changes.

#include <poll.h>

/* Setup: same pipe creation + handler as before */

struct pollfd fds[2];
fds[0].fd     = STDIN_FILENO;
fds[0].events = POLLIN;

fds[1].fd     = pfd[0];   /* Pipe read end */
fds[1].events = POLLIN;

int ready = poll(fds, 2, 30000);   /* 30 second timeout in ms */

if (ready > 0) {
    if (fds[1].revents & POLLIN) {
        /* Signal arrived via pipe — drain it */
        char ch;
        while (read(pfd[0], &ch, 1) == 1)
            ;   /* Drain all bytes */
        handle_signal();
    }
    if (fds[0].revents & POLLIN) {
        /* stdin has data */
    }
}

#include <sys/epoll.h>

/* Setup: same pipe creation + handler as before */

int epfd = epoll_create1(0);

struct epoll_event ev;

/* Add stdin */
ev.events  = EPOLLIN;
ev.data.fd = STDIN_FILENO;
epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev);

/* Add pipe read end */
ev.events  = EPOLLIN;
ev.data.fd = pfd[0];
epoll_ctl(epfd, EPOLL_CTL_ADD, pfd[0], &ev);

struct epoll_event events[10];
int ready = epoll_wait(epfd, events, 10, 30000);   /* 30s timeout */

for (int i = 0; i < ready; i++) {
    if (events[i].data.fd == pfd[0]) {
        /* Signal via pipe */
        char ch;
        while (read(pfd[0], &ch, 1) == 1)
            ;   /* Drain */
        handle_signal();
    }
    if (events[i].data.fd == STDIN_FILENO) {
        /* stdin ready */
    }
}