What is a Named Pipe (FIFO)?
Learn what a named pipe (FIFO) is, how it lets unrelated processes rendezvous, with a C example and OS interview questions answered.
Expected Interview Answer
A named pipe, or FIFO, is a special filesystem entry that behaves like an anonymous pipe but has a persistent path name, allowing entirely unrelated processes to open it independently and communicate without sharing a common parent.
A FIFO is created with mkfifo(), which registers a special file in the filesystem’s namespace; the file itself stores no data, it is merely a name the kernel uses to rendezvous two independent processes at its in-memory buffer. Any process that knows the path can open() it for reading or writing, unlike an anonymous pipe whose descriptors must be inherited through fork(). The kernel still enforces first-in-first-out ordering and the same blocking flow control as an anonymous pipe: opening a FIFO for reading blocks until a writer also opens it, and vice versa, which is a common source of confusion for beginners expecting non-blocking behavior. Because it is unidirectional per FIFO, bidirectional communication typically requires two FIFOs, one for each direction.
- Enables IPC between processes with no common ancestor
- Reuses the same FIFO ordering and blocking semantics as anonymous pipes
- Named in the filesystem, so it can be referenced by path from any program
- Simple mechanism for producer-consumer style communication across programs
AI Mentor Explanation
A named pipe is like a designated drop-off spot on the boundary rope, marked with a signpost, where any fielder from either team who knows the spot’s name can deliver or collect a ball — unlike a private relay line, no shared captain is required. The first ball dropped is the first one picked up, and a fielder arriving to collect waits there until someone actually drops one off, matching the blocking rendezvous of a FIFO. Two such spots would be needed if balls must travel both into and out of the field from that point.
Step-by-Step Explanation
Step 1
Create the FIFO
A process calls mkfifo("/tmp/myfifo", mode), which creates a named special file in the filesystem.
Step 2
Independent processes open by path
Any process, unrelated to the others, opens the same path for reading or writing.
Step 3
Blocking rendezvous
An open for read blocks until some process opens for write, and vice versa, synchronizing the pair.
Step 4
Stream and close
Data streams through the kernel buffer with FIFO ordering; closing the write end signals end-of-file to the reader.
What Interviewer Expects
- Clear distinction from anonymous pipes: named in the filesystem, usable by unrelated processes
- Understanding of the blocking open() rendezvous semantics
- Knowledge that a FIFO stores no data on disk, only rendezvous the buffer
- Awareness that two FIFOs are needed for bidirectional communication
Common Mistakes
- Assuming a FIFO persists written data like a regular file
- Not realizing open() blocks until a matching reader or writer appears
- Thinking one FIFO can handle two-way traffic
- Confusing FIFO ordering guarantees with message boundaries (FIFOs are a byte stream)
Best Answer (HR Friendly)
“A named pipe, or FIFO, is like a regular pipe but given an actual name on the filesystem, so any two programs that know that name can connect to it, even if one did not start the other. It behaves the same way underneath — one-way, first-in-first-out, with the kernel pausing either side automatically — but the name is what lets unrelated programs find each other.”
Code Example
/* create once, e.g. in a setup step */
mkfifo("/tmp/myfifo", 0666);
/* writer.c */
int wfd = open("/tmp/myfifo", O_WRONLY); /* blocks until a reader opens it */
write(wfd, "hello via fifo", 15);
close(wfd);
/* reader.c (separate, unrelated process) */
int rfd = open("/tmp/myfifo", O_RDONLY); /* blocks until a writer opens it */
char buf[32];
int n = read(rfd, buf, sizeof(buf));
buf[n] = '\0';
printf("reader got: %s\n", buf);
close(rfd);Follow-up Questions
- Why does opening a FIFO for reading block until a writer opens it?
- How would you build bidirectional communication using FIFOs?
- What happens to a FIFO's contents if no process has it open?
- How does a FIFO differ from a Unix domain socket for local IPC?
MCQ Practice
1. What is the key advantage of a named pipe over an anonymous pipe?
A FIFO has a name in the filesystem namespace, so any process that knows the path can open it, unlike anonymous pipes which require inherited descriptors.
2. What happens when a process calls open() on a FIFO for reading and no writer has opened it yet?
FIFO opens rendezvous: a read-open blocks until a matching write-open occurs, and vice versa.
3. Does a FIFO file store its transmitted data persistently on disk?
The FIFO special file is just a name; actual data flows through kernel memory exactly like an anonymous pipe.
Flash Cards
What is a named pipe (FIFO)? — A pipe with a persistent filesystem path, letting unrelated processes rendezvous and communicate.
How is a FIFO created? — With mkfifo(path, mode), which creates a special file entry in the filesystem.
What happens on open() for read with no writer yet? — The call blocks until a process opens the same FIFO for writing.
How many FIFOs for two-way communication? — Two — one FIFO per direction, since each FIFO is unidirectional.