What happens when a producer ignores SIGPIPE while using head/tail for pagination?

The Interaction Between SIGPIPE and Pipe Buffers

When a producer writes to a pipe consumed by a utility like head or tail, the consumer exits immediately after reaching its requested line limit. This closes the read end of the pipe. Under default Linux behavior, the next write attempt by the producer triggers a SIGPIPE signal, which terminates the producer process unless it is explicitly ignored or handled.

If the producer ignores SIGPIPE, the kernel does not terminate the process. Instead, the write() system call returns -1 and sets errno to EPIPE. If the producer ignores both the signal and the return value, it will continue to execute as if the data were being delivered, leading to silent data loss.

Blocking and Buffer Relief

The point at which a producer is "relieved" from blocking depends on the state of the kernel pipe buffer (typically 64 KiB by default). There are two distinct scenarios:

• Buffer Not Full: The producer writes data that fits in the buffer. head reads the required lines and exits. The producer's next write immediately returns EPIPE.
• Buffer Full: The producer writes faster than head can process. The producer blocks on the write() call once the buffer is full. It is only relieved when head reads enough data to satisfy its line limit and exits, closing the pipe and triggering the EPIPE error.

The latency between the producer's attempt to write and the eventual EPIPE is determined by the pipe buffer size (configurable via /proc/sys/fs/pipe-max-size). A larger buffer allows the producer to "over-write" more data before blocking, potentially increasing the gap between the consumer's exit and the producer's awareness of the closed pipe.

Locale and Line Counting

Setting LC_ALL=C does not eliminate variability in line-counting for multibyte streams in this context. Both head and tail identify lines by scanning for the newline character (\n). Because the newline character is consistent across UTF-8 and ASCII, the line-counting logic remains the same regardless of the locale.

Verification Steps

To verify this behavior on a Linux system, you can use strace to monitor the system calls of a producer that ignores SIGPIPE:

# Example: Producer ignoring SIGPIPE piped to head
# The producer must be coded to ignore SIGPIPE (e.g., signal(SIGPIPE, SIG_IGN))
strace -e write ./my_producer | head -n 5

In the strace output, you will observe write(...) = -1 EPIPE (Broken pipe) occurring immediately after head terminates.