Implement Pipes from Scratch: Circular Buffer with Blocking Read/Write

Topic Overview

Circular Buffer IPC

Pipes connect a writer fd to a reader fd through a kernel buffer implemented as a ring. Writes block when full; reads block when empty. Shell pipelines are just pipe pairs between processes.

Ring Buffer Invariants

Track:

• head/tail indices modulo capacity
• count of bytes present
• reader/writer wait queues

For example, capacity 4096 with 5000 byte write blocks after 4096 bytes until reader consumes data.

cCopy
Loading…

Why This Matters in Production

This circular buffer with blocking read/write is a near-exact model of the real Linux kernel pipe implementation in fs/pipe.c, which is exactly what makes cat file | grep pattern work without either program blocking forever. Getting the close-both-ends discipline wrong here reproduces a real, common bug: forgetting to close the unused pipe end in a forked child means the reader never sees EOF and hangs indefinitely, a classic shell-implementation gotcha.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will implement blocking read/write on a userspace ring buffer with mutex/cond or your mini-kernel pipe. This exercise requires demonstrating producer-consumer throughput without busy waiting.

Your Task

A pipe is a circular buffer between a writer and a reader, plus rules for what happens when one side closes. Build one that holds 8 integers.

• Reads take from head and writes store at tail, and both advance with (pos + 1) % 8, so the buffer wraps around.
• A write checks, in order:
  1. the write end is closed: EBADF;
  2. the read end is closed: EPIPE, because nobody can ever read it; a real process also gets SIGPIPE;
  3. the buffer is full: it would block;
  4. otherwise it stores the value.
• A read checks, in order:
  1. the read end is closed: EBADF;
  2. data is buffered: return the oldest value. Data written before the write end closed is still delivered;
  3. the write end is closed: EOF, because no more data can arrive;
  4. otherwise it would block.

Input

Commands until the end of input:

• write V
• read
• close_write
• close_read
• state

Output

First === Pipe Buffer cap=8 ===. Then one line per command: