Three actors are involved: your program, the kernel, and the file descriptor (e.g. stdin, socket).

You must install the SIGIO handler before enabling signal-driven I/O on the file descriptor. Here is why:

Note: On some UNIX systems, the default action for SIGIO is to ignore it (not terminate). But on Linux the default is termination, so always set the handler first.

This example demonstrates signal-driven I/O on standard input (terminal). The main loop does heavy computation, but whenever a key is pressed the SIGIO handler sets a flag. The main loop checks the flag and reads the character. Pressing # exits the program.

The terminal is placed in cbreak mode so each character is available immediately without waiting for Enter to be pressed.

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <errno.h>

/* Global flag set by SIGIO handler */
static volatile sig_atomic_t gotSigio = 0;

/* SIGIO signal handler — just sets a flag, does no real work */
static void sigioHandler(int sig)
{
    gotSigio = 1;
}

int main(void)
{
    struct sigaction sa;
    int flags;
    char ch;
    int done, cnt, j;
    struct termios origTermios;

    /* ---- STEP 1: Install SIGIO handler FIRST ---- */
    sigemptyset(&sa.sa_mask);
    sa.sa_flags   = SA_RESTART;      /* restart syscalls if interrupted */
    sa.sa_handler = sigioHandler;
    if (sigaction(SIGIO, &sa, NULL) == -1) {
        perror("sigaction"); exit(EXIT_FAILURE);
    }

    /* ---- STEP 2: Tell kernel to signal THIS process ---- */
    if (fcntl(STDIN_FILENO, F_SETOWN, getpid()) == -1) {
        perror("fcntl F_SETOWN"); exit(EXIT_FAILURE);
    }

    /* ---- STEP 3: Enable O_ASYNC + O_NONBLOCK on stdin ---- */
    flags = fcntl(STDIN_FILENO, F_GETFL);
    if (flags == -1) { perror("fcntl F_GETFL"); exit(EXIT_FAILURE); }

    if (fcntl(STDIN_FILENO, F_SETFL, flags | O_ASYNC | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL"); exit(EXIT_FAILURE);
    }

    /* ---- STEP 4: Place terminal in cbreak mode ----
       In cbreak mode each key press is delivered immediately.
       origTermios saves the original terminal settings for restore later. */
    /* ttySetCbreak() is a helper from the TLPI library —
       see Chapter 62 for its implementation */
    if (ttySetCbreak(STDIN_FILENO, &origTermios) == -1) {
        perror("ttySetCbreak"); exit(EXIT_FAILURE);
    }

    /* ---- STEP 5: Main loop — does "work" and checks flag ---- */
    for (done = 0, cnt = 0; !done; cnt++) {

        /* Simulate some CPU work */
        for (j = 0; j < 100000000; j++)
            continue;

        /* Check flag set by SIGIO handler */
        if (gotSigio) {
            /*
             * Read ALL available input characters.
             * O_NONBLOCK makes read() return EAGAIN when no more data.
             * We stop when: EAGAIN (no more data), EOF, or '#' seen.
             */
            while (read(STDIN_FILENO, &ch, 1) > 0 && !done) {
                printf("cnt=%d; read '%c'\n", cnt, ch);
                done = (ch == '#');  /* '#' is our exit character */
            }
            gotSigio = 0;  /* reset flag */
        }
    }

    /* ---- STEP 6: Restore original terminal settings ---- */
    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &origTermios) == -1) {
        perror("tcsetattr"); exit(EXIT_FAILURE);
    }

    printf("Exiting after %d loop iterations\n", cnt);
    exit(EXIT_SUCCESS);
}