Consider a server that monitors 5000 socket file descriptors with signal-driven I/O, all using plain SIGIO:

To take full advantage of signal-driven I/O with fd-specific notification, do two things:

The F_SETSIG fcntl operation tells the kernel which signal to send instead of SIGIO when I/O becomes possible on that specific fd:

/* Specify SIGRTMIN+1 instead of SIGIO for fd */
if (fcntl(fd, F_SETSIG, SIGRTMIN + 1) == -1) {
    perror("fcntl F_SETSIG");
    exit(1);
}

You can read back the currently configured signal with F_GETSIG:

int sig = fcntl(fd, F_GETSIG);
if (sig == -1) {
    perror("fcntl F_GETSIG");
}
printf("Signal for fd: %d (SIGRTMIN = %d)\n", sig, SIGRTMIN);

When you install a handler with SA_SIGINFO, the handler receives a siginfo_t structure as its second argument. For I/O signals, this structure tells you which fd triggered the event and what kind of event it was.

#include <signal.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>

/* Handler that receives full siginfo_t */
static void rtSigioHandler(int sig, siginfo_t *si, void *ucontext)
{
    /*
     * si_fd  — the file descriptor that caused the event
     * si_band — a bitmask of events (like POLLIN, POLLOUT, POLLERR)
     *            uses the same bits as poll()
     */
    printf("Signal %d on fd %d, events: %ld\n",
           sig, si->si_fd, si->si_band);

    if (si->si_band & POLLIN)
        printf("  Data available to read on fd %d\n", si->si_fd);
    if (si->si_band & POLLOUT)
        printf("  Space available to write on fd %d\n", si->si_fd);
    if (si->si_band & POLLERR)
        printf("  Error condition on fd %d\n", si->si_fd);
    if (si->si_band & POLLHUP)
        printf("  Hangup on fd %d\n", si->si_fd);
}

void setup_realtime_sigio(int fd, int rtsig)
{
    struct sigaction sa;

    /* Use SA_SIGINFO to get the extended handler with siginfo_t */
    sa.sa_sigaction = rtSigioHandler;   /* note: sa_sigaction, not sa_handler */
    sa.sa_flags     = SA_RESTART | SA_SIGINFO;
    sigemptyset(&sa.sa_mask);

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

    /* Set owner */
    fcntl(fd, F_SETOWN, getpid());

    /* Specify the realtime signal instead of SIGIO */
    fcntl(fd, F_SETSIG, rtsig);

    /* Enable async + nonblocking */
    int flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_ASYNC | O_NONBLOCK);
}

Signal-driven I/O with realtime signals scales better than select() and poll() for very large numbers of file descriptors.

This example sets up signal-driven I/O on two sockets using different realtime signals so each fd’s events are handled independently.

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <fcntl.h>
#include <poll.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SIG_SOCK1  (SIGRTMIN + 1)
#define SIG_SOCK2  (SIGRTMIN + 2)

static int sock1_fd = -1;
static int sock2_fd = -1;

/* Handler receives which fd triggered and which events are ready */
static void ioReadyHandler(int sig, siginfo_t *si, void *ucontext)
{
    char buf[256];
    ssize_t n;

    printf("[signal %d] fd=%d events=0x%lx\n",
           sig, si->si_fd, (unsigned long)si->si_band);

    if (!(si->si_band & POLLIN))
        return;  /* Only handle readable events in this example */

    n = read(si->si_fd, buf, sizeof(buf) - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("  Read %zd bytes from fd %d: %s\n", n, si->si_fd, buf);
    }
}

static void install_rt_sigio(int fd, int rtsig)
{
    struct sigaction sa;
    int flags;

    /* Install SA_SIGINFO handler */
    memset(&sa, 0, sizeof(sa));
    sa.sa_sigaction = ioReadyHandler;
    sa.sa_flags     = SA_RESTART | SA_SIGINFO;
    sigemptyset(&sa.sa_mask);

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

    /* Set owner to this process */
    if (fcntl(fd, F_SETOWN, getpid()) == -1) {
        perror("F_SETOWN"); exit(1);
    }

    /* Configure the realtime signal for this fd */
    if (fcntl(fd, F_SETSIG, rtsig) == -1) {
        perror("F_SETSIG"); exit(1);
    }

    /* Enable async I/O + nonblocking */
    flags = fcntl(fd, F_GETFL);
    if (fcntl(fd, F_SETFL, flags | O_ASYNC | O_NONBLOCK) == -1) {
        perror("F_SETFL"); exit(1);
    }

    printf("fd %d configured with signal %d (SIGRTMIN+%d)\n",
           fd, rtsig, rtsig - SIGRTMIN);
}

static int make_udp_socket(int port)
{
    int sfd;
    struct sockaddr_in addr;
    const int one = 1;

    sfd = socket(AF_INET, SOCK_DGRAM, 0);
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(port);
    addr.sin_addr.s_addr = INADDR_ANY;
    bind(sfd, (struct sockaddr *)&addr, sizeof(addr));
    return sfd;
}

int main(void)
{
    /* Create two UDP sockets on different ports */
    sock1_fd = make_udp_socket(9001);
    sock2_fd = make_udp_socket(9002);

    /* Install different realtime signals for each fd */
    install_rt_sigio(sock1_fd, SIG_SOCK1);
    install_rt_sigio(sock2_fd, SIG_SOCK2);

    printf("Listening on UDP ports 9001 (signal %d) and 9002 (signal %d)\n",
           SIG_SOCK1, SIG_SOCK2);
    printf("Send: echo 'hello' | nc -u 127.0.0.1 9001\n\n");

    /* Main loop: pause waiting for signals */
    while (1) {
        pause();  /* Wait for any signal */
    }

    return 0;
}

With this setup, data on port 9001 triggers SIG_SOCK1 and data on port 9002 triggers SIG_SOCK2. The handler knows exactly which fd to read from via si->si_fd, with no scanning needed.

The realtime signal queue has a limited capacity (check with ulimit -i or /proc/sys/kernel/rtsig-max on older kernels). When the queue is full, the kernel falls back to sending SIGIO (the standard signal).

/* Fallback SIGIO handler — called when realtime queue overflows */
static void sigioFallbackHandler(int sig)
{
    /*
     * We cannot tell which fd is ready from plain SIGIO.
     * Use poll() or select() to discover which fds have data.
     * Then process them, and the realtime signal queue
     * will drain back to normal on its own.
     */
    printf("SIGIO fallback — realtime queue may have overflowed\n");
    poll_all_fds();   /* your function to poll and process all registered fds */
}

/* Install the fallback alongside your realtime signal handlers */
void install_fallback(void)
{
    struct sigaction sa;
    sa.sa_handler = sigioFallbackHandler;
    sa.sa_flags   = SA_RESTART;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGIO, &sa, NULL);
}