Linux I/O Models Interview Preparation Guide

In a blocking I/O model, the calling process or thread is suspended by the kernel until the requested I/O operation (such as reading from a socket) completes fully, releasing the CPU core entirely. In a non-blocking I/O model (configured via O_NONBLOCK), system calls that cannot be satisfied immediately return an error code (-1 with EAGAIN or EWOULDBLOCK) rather than suspending the thread. This forces the application to either poll repeatedly or integrate with an event notification facility like epoll, preventing threads from stalling on idle connections.

Traditional select() and poll() primitives operate with O(N) time complexity because the application must pass the entire file descriptor set to the kernel on every call, and the kernel linearly scans all descriptors to check readiness. In contrast, epoll maintains an in-kernel red-black tree of registered descriptors and a separate ready list populated directly by device driver interrupt handlers. When calling epoll_wait(), the kernel returns only the subset of descriptors that are actively ready, achieving O(1) time complexity regardless of the total number of monitored connections.

Level-Triggered mode (the default) notifies the application repeatedly as long as a file descriptor remains in a ready state, making it simpler and safer to program but introducing minor performance overhead. Edge-Triggered mode notifies the application only when the readiness state changes (e.g., when new data arrives), offering maximum performance and reduced wakeups. However, ET mode requires the application to drain all available data completely until receiving EAGAIN; failing to do so results in permanently missed events and application hangs.

Traditional I/O models require applications to execute explicit system calls (such as read() or write()) for every single operation, triggering costly user-to-kernel context switches. io_uring bypasses this overhead by establishing shared memory submission (SQ) and completion (CQ) ring buffers mapped directly between user space and kernel space. Applications enqueue I/O submission entries (SQEs) directly into the ring and reap completion events asynchronously without issuing traditional system calls, enabling true zero-copy processing and hardware-speed throughput.

EINTR (Interrupted System Call) occurs when an active blocking system call is interrupted by the delivery of an operating system signal before any I/O data could be processed. Rather than failing permanently, the kernel interrupts the system call and returns -1 with errno set to EINTR to allow the signal handler to execute. Robust production applications must wrap blocking system calls in retry loops that check for EINTR and automatically reissue the call to ensure uninterrupted execution.

The thundering herd problem occurs when multiple worker threads sleep on the same epoll instance and awaken simultaneously when a single connection event arrives, causing massive context-switching overhead and CPU contention where only one thread successfully accepts the connection. This is mitigated in modern Linux kernels by utilizing the EPOLLEXCLUSIVE flag during epoll_ctl registration, which ensures the kernel awakens only one eligible worker thread per event, or by employing decoupled multi-reactor architectures with SO_REUSEPORT.

The sk_buff (socket buffer) is the core data structure used by the Linux kernel to manage network packets traversing protocol layers from network interface cards to user-space applications. It holds raw packet payloads alongside protocol header metadata, managing memory allocation and pointer adjustments efficiently across OSI layers. Socket buffers queue incoming TCP segments in kernel space until the user application issues a read system call to copy the data into user space.

The splice() system call moves data between two file descriptors—such as a network socket and a disk file—without copying the data into user-space application memory. It achieves this by creating an in-kernel pipe buffer that points directly to kernel memory pages, allowing data to flow entirely within kernel space via DMA and pointer manipulation. This eliminates redundant memory copies and CPU cache pollution, significantly accelerating high-throughput file transfer services.

An asynchronous event loop relies on non-blocking operations to manage thousands of concurrent connections within a single thread. If a developer invokes a synchronous blocking database driver inside an event handler, that single thread suspends entirely while waiting for database responses, freezing the entire event loop. Consequently, all other concurrent connections starve, leading to cascading timeouts, connection pool exhaustion, and severe application unresponsiveness.

Every open network socket, file, pipe, and directory in Linux is represented by an integer file descriptor stored in a process-specific table. By default, Linux distributions enforce conservative per-process limits (typically 1024). High-concurrency servers handling tens of thousands of persistent client connections will exhaust this limit rapidly, causing incoming connection attempts to fail with EMFILE (Too many open files) errors. Administrators must explicitly raise system-wide and service-level descriptor limits using limits.conf and systemd configuration directives.

Direct I/O bypasses the operating system page cache entirely, transferring data directly between storage devices and application buffers. Database engines implement their own specialized buffer pools and transaction logging mechanisms; relying on the Linux page cache would introduce double-buffering overhead, redundant memory copies, and unpredictable dirty page writeback flushing schedules that conflict with strict ACID durability guarantees.

SO_REUSEPORT is a socket option that allows multiple worker processes or threads to bind to the exact same IP address and port combination. When enabled, the Linux kernel hashes incoming connection requests and distributes them evenly across all listening sockets at the kernel layer. This eliminates the traditional bottleneck of a single listener thread accepting connections and allows multi-core servers to scale connection acceptance cleanly across independent thread reactors.