In signal-driven I/O, you tell the kernel: “Watch this file descriptor for me. When it becomes ready, send me a signal.” Your process then goes off and does other work freely. When the kernel sends the signal, your signal handler runs and you perform the I/O.

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

/*
 * Signal handler: called when stdin has data ready.
 * Keep signal handlers short and async-signal-safe.
 * Write a byte to a pipe or set a flag for the main loop.
 */
static volatile sig_atomic_t io_ready = 0;

static void sigio_handler(int sig) {
    /*
     * Do not call printf() or read() directly here in production!
     * Only async-signal-safe functions are allowed in signal handlers.
     * Set a flag and let the main loop do the actual I/O.
     */
    io_ready = 1;
}

int main() {
    struct sigaction sa;
    int flags;
    char buf[256];
    ssize_t n;

    /* Step 1: Install handler for SIGIO */
    sa.sa_handler = sigio_handler;
    sa.sa_flags   = SA_RESTART;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGIO, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }

    /* Step 2: Set this process as the owner (receiver) of SIGIO for stdin */
    if (fcntl(STDIN_FILENO, F_SETOWN, getpid()) == -1) {
        perror("fcntl F_SETOWN");
        exit(EXIT_FAILURE);
    }

    /* Step 4: Enable O_ASYNC on stdin */
    flags = fcntl(STDIN_FILENO, F_GETFL);
    if (fcntl(STDIN_FILENO, F_SETFL, flags | O_ASYNC) == -1) {
        perror("fcntl F_SETFL O_ASYNC");
        exit(EXIT_FAILURE);
    }

    printf("Signal-driven I/O enabled on stdin. Type something!\n");
    printf("Main loop doing other work...\n");

    /* Main loop: do other work, check io_ready flag */
    for (int i = 0; i < 20; i++) {
        if (io_ready) {
            io_ready = 0;
            /* Now safe to read since kernel told us data is ready */
            n = read(STDIN_FILENO, buf, sizeof(buf) - 1);
            if (n > 0) {
                buf[n] = '\0';
                printf("Got from stdin: '%s'\n", buf);
                break;
            }
        }
        printf("Working... iteration %d\n", i + 1);
        sleep(1);
    }

    return 0;
}
    

epoll (event poll) is a Linux-specific API introduced in kernel 2.6. It is the backbone of every major high-performance Linux server: Nginx, Node.js, Redis, and many more all use epoll internally.

The key insight of epoll is: instead of passing your FD list on every call (like select/poll do), you register FDs with a kernel-side data structure once. The kernel then tracks events internally. When you call epoll_wait(), the kernel gives you only the FDs that are actually ready — no scanning through inactive ones.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>

#define MAX_EVENTS 10

/*
 * epoll example: monitor stdin and a pipe simultaneously.
 * Shows the typical epoll usage pattern used in real servers.
 */
int main() {
    int epfd;
    int pipefd[2];
    char buf[256];
    ssize_t n;
    int ret;
    struct epoll_event ev, events[MAX_EVENTS];

    /* Create a pipe and pre-fill it with data */
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    write(pipefd[1], "hello from pipe", 15);

    /* Step 1: Create epoll instance */
    epfd = epoll_create1(0);
    if (epfd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    /* Step 2a: Register stdin with epoll */
    ev.events  = EPOLLIN;          /* Watch for data to read */
    ev.data.fd = STDIN_FILENO;     /* Store fd in data so we know which FD later */
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1) {
        perror("epoll_ctl add stdin");
        exit(EXIT_FAILURE);
    }

    /* Step 2b: Register pipe read end with epoll */
    ev.events  = EPOLLIN;
    ev.data.fd = pipefd[0];
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, pipefd[0], &ev) == -1) {
        perror("epoll_ctl add pipe");
        exit(EXIT_FAILURE);
    }

    printf("epoll watching stdin and pipe. Type something or wait...\n");

    /* Step 3: Event loop */
    while (1) {
        /*
         * epoll_wait: sleep until at least one FD is ready.
         * events[] will only contain the READY FDs.
         * Timeout 5000ms = 5 seconds.
         */
        ret = epoll_wait(epfd, events, MAX_EVENTS, 5000);

        if (ret == -1) {
            perror("epoll_wait");
            break;
        }
        if (ret == 0) {
            printf("Timeout: no events in 5 seconds\n");
            break;
        }

        /*
         * Loop over ONLY the ready FDs (ret of them).
         * Not over all registered FDs. This is what makes epoll fast!
         */
        for (int i = 0; i < ret; i++) {

            if (events[i].data.fd == STDIN_FILENO) {
                n = read(STDIN_FILENO, buf, sizeof(buf) - 1);
                if (n > 0) {
                    buf[n] = '\0';
                    printf("stdin: '%s'\n", buf);
                } else if (n == 0) {
                    printf("stdin: EOF\n");
                    /* Remove from epoll when done */
                    epoll_ctl(epfd, EPOLL_CTL_DEL, STDIN_FILENO, NULL);
                }
            }

            else if (events[i].data.fd == pipefd[0]) {
                n = read(pipefd[0], buf, sizeof(buf) - 1);
                if (n > 0) {
                    buf[n] = '\0';
                    printf("pipe: '%s'\n", buf);
                    /* Remove pipe from epoll after reading */
                    epoll_ctl(epfd, EPOLL_CTL_DEL, pipefd[0], NULL);
                    goto done;
                }
            }

            /* Handle error or hangup */
            if (events[i].events & (EPOLLERR | EPOLLHUP)) {
                printf("Error or hangup on fd %d\n", events[i].data.fd);
                epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                close(events[i].data.fd);
            }
        }
    }

done:
    close(epfd);
    close(pipefd[0]);
    close(pipefd[1]);
    return 0;
}
    

Compile: gcc -o epoll_demo epoll_demo.c && ./epoll_demo

epoll supports two notification modes. This is one of its most important features and also a common interview topic.

/* Level-triggered (default) - no extra flag needed */
ev.events = EPOLLIN;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

/* Edge-triggered - add EPOLLET flag */
ev.events = EPOLLIN | EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

/*
 * In edge-triggered mode: when you get an EPOLLIN event,
 * you MUST read until EAGAIN, otherwise you will miss data:
 */
if (events[i].events & EPOLLIN) {
    while (1) {
        n = read(fd, buf, sizeof(buf));
        if (n == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                break;  /* All data consumed. Stop looping. */
            perror("read");
            break;
        }
        if (n == 0) {
            printf("Connection closed\n");
            break;
        }
        /* process buf[0..n-1] */
        process_data(buf, n);
    }
}