Both system calls use different conventions for indicating readiness:

Inside the Linux kernel, select() and poll() both use the same internal poll routines. select() converts the kernel’s poll bitmask to its r/w/x format using these internal macros:

/* Internal kernel macros that map poll bits to select() results */
#define POLLIN_SET   (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP | POLLERR)
                     /* → marks fd as readable in select() */

#define POLLOUT_SET  (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
                     /* → marks fd as writable in select() */

#define POLLEX_SET   (POLLPRI)
                     /* → marks fd as exceptional in select() */

Notice: POLLERR appears in both POLLIN_SET and POLLOUT_SET. This means if there is an error on an fd, select() marks it as both readable AND writable. This is why your code must call read() or write() after select() to find out what actually happened.

File descriptors that refer to regular files (files on disk) are always considered ready by both select() and poll(). This is true for both reading and writing.

Why always ready?

• A read() on a regular file will always return immediately — with data, end-of-file, or an error. It never blocks waiting for data to “arrive”.
• A write() to a regular file will always transfer data or fail immediately with an error. It never waits.

Practical implication: Using select() or poll() to watch regular files is mostly pointless — they are always ready. These tools are really designed for sockets, pipes, and terminals where blocking is a real concern.

/* Example: regular files are ALWAYS ready */
#include <stdio.h>
#include <fcntl.h>
#include <poll.h>

int main(void)
{
    struct pollfd pfd;
    int fd = open("/etc/hostname", O_RDONLY);
    if (fd == -1) { perror("open"); return 1; }

    pfd.fd     = fd;
    pfd.events = POLLIN;

    int ret = poll(&pfd, 1, 0);  /* non-blocking poll */
    printf("poll returned: %d\n", ret);
    printf("revents: POLLIN=%s\n",
           (pfd.revents & POLLIN) ? "yes" : "no");
    /* Output: always shows POLLIN=yes for regular files */

    close(fd);
    return 0;
}

Terminals (like your keyboard/screen connection) and pseudoterminals (used by SSH, xterm, tmux, etc.) have more interesting readiness behavior because data arrival depends on user input or a remote host.

/* Watching stdin (terminal) for input */
#include <stdio.h>
#include <poll.h>
#include <unistd.h>

int main(void)
{
    struct pollfd pfd;
    pfd.fd     = STDIN_FILENO;  /* fd 0 = terminal input */
    pfd.events = POLLIN;

    printf("Waiting 5 seconds for you to type something...\n");
    int ret = poll(&pfd, 1, 5000);  /* 5 second timeout */

    if (ret == 0) {
        printf("Timeout: no input in 5 seconds\n");
    } else if (ret > 0) {
        if (pfd.revents & POLLIN) {
            char buf[256];
            int n = read(STDIN_FILENO, buf, sizeof(buf) - 1);
            buf[n] = '\0';
            printf("You typed: %s", buf);
        }
        if (pfd.revents & POLLHUP) {
            printf("Terminal closed!\n");
        }
    } else {
        perror("poll");
    }
    return 0;
}

Pipes are the classic use case for poll(). The readiness of a pipe’s read-end depends on two things: whether there is data in the pipe, and whether the write-end is still open.

/* Demonstrating pipe read-end readiness */
#include <stdio.h>
#include <unistd.h>
#include <poll.h>

void check_pipe_readiness(int read_fd, const char *label)
{
    struct pollfd pfd = { .fd = read_fd, .events = POLLIN };
    int ret = poll(&pfd, 1, 0);  /* non-blocking check */

    printf("\n[%s]\n", label);
    printf("  poll() returned: %d\n", ret);
    printf("  POLLIN  = %s\n", (pfd.revents & POLLIN)  ? "YES" : "no");
    printf("  POLLHUP = %s\n", (pfd.revents & POLLHUP) ? "YES" : "no");
}

int main(void)
{
    int pfd[2];
    if (pipe(pfd) == -1) { perror("pipe"); return 1; }

    /* State 1: No data, write-end open → should NOT be ready */
    check_pipe_readiness(pfd[0], "No data, write-end open");

    /* State 2: Data available, write-end open → POLLIN */
    write(pfd[1], "hello", 5);
    check_pipe_readiness(pfd[0], "Data available, write-end open");

    /* State 3: Data available, write-end closed → POLLIN | POLLHUP */
    close(pfd[1]);
    check_pipe_readiness(pfd[0], "Data available, write-end closed");

    /* Read the data */
    char buf[10];
    read(pfd[0], buf, 5);

    /* State 4: No data, write-end closed → POLLHUP (EOF) */
    check_pipe_readiness(pfd[0], "No data, write-end closed (EOF)");

    close(pfd[0]);
    return 0;
}

The write-end readiness of a pipe depends on two things: whether there is enough space in the pipe buffer, and whether the read-end is still open.

What is PIPE_BUF? Linux uses PIPE_BUF (4096 bytes by default) as the threshold for atomic writes. poll() considers a pipe writable only when there is at least PIPE_BUF bytes of free space. This guarantees that a write of up to PIPE_BUF bytes will not block.

/* Check what PIPE_BUF is on your system */
#include <stdio.h>
#include <limits.h>
#include <unistd.h>

int main(void)
{
    printf("PIPE_BUF = %d bytes\n", PIPE_BUF);
    /* On Linux: typically 4096 bytes */

    /* Actual pipe capacity is larger (65536 bytes since Linux 2.6.11) */
    /* but poll() uses PIPE_BUF as the "safe atomic write" threshold */

    long pipe_cap = fpathconf(1, _PC_PIPE_BUF);
    printf("_PC_PIPE_BUF = %ld\n", pipe_cap);
    return 0;
}

Sockets have the richest and most important set of readiness conditions because they cover both TCP stream and UDP datagram sockets, listening sockets, and various shutdown scenarios.

POLLRDHUP (Linux-specific, available since kernel 2.6.17) deserves special attention:

• It is set when the remote peer has shut down the writing half of the connection — i.e., the remote called shutdown(fd, SHUT_WR) or closed the socket entirely.
• Without POLLRDHUP, you would have to notice that POLLIN is set, then call read(), and check if it returns 0 (which means EOF / remote shutdown).
• With POLLRDHUP, you can detect the remote shutdown directly in your revents check, writing simpler code.

/* Socket poll() example: TCP server detecting client disconnect */
#include <stdio.h>
#include <poll.h>
#include <unistd.h>
#include <sys/socket.h>

void handle_client(int client_fd)
{
    struct pollfd pfd;
    pfd.fd     = client_fd;
    pfd.events = POLLIN | POLLRDHUP;  /* watch for data AND remote close */

    while (1) {
        int ret = poll(&pfd, 1, -1);
        if (ret == -1) { perror("poll"); break; }

        /* Check for remote shutdown first */
        if (pfd.revents & POLLRDHUP) {
            printf("Remote peer shut down writing half\n");
            break;
        }

        /* Check for data to read */
        if (pfd.revents & POLLIN) {
            char buf[1024];
            int n = read(client_fd, buf, sizeof(buf));
            if (n == 0) {
                printf("EOF: client disconnected\n");
                break;
            } else if (n > 0) {
                printf("Received %d bytes\n", n);
                /* process data here */
            } else {
                perror("read");
                break;
            }
        }

        /* Check for error */
        if (pfd.revents & POLLERR) {
            printf("Error on socket\n");
            break;
        }

        /* Check for hangup */
        if (pfd.revents & POLLHUP) {
            printf("Hangup on socket\n");
            break;
        }
    }

    close(client_fd);
}

There are two ways to detect that a remote peer has stopped sending data:

if (pfd.revents & POLLIN) {
    int n = read(fd, buf, sz);
    if (n == 0) {
        /* EOF: remote closed */
    }
}
/* Need extra read() call
   just to detect shutdown */

if (pfd.revents & POLLRDHUP) {
    /* remote shutdown detected
       directly in revents —
       no extra read() needed */
}
/* Simpler, especially useful
   with edge-triggered epoll */

POLLRDHUP is especially valuable when using the edge-triggered mode of epoll (another I/O model covered in Section 63.4), where getting events right without extra system calls matters a lot for performance.