One of the fundamental features that makes Linux and other Unices useful is the “pipe”. Pipes allow separate processes to communicate without having been designed explicitly to work together. This allows tools quite narrow in their function to be combined in complex ways.
A simple example of using a pipe is the command:
ls | grep x
When bash examines the command line, it finds the vertical bar character
| that separates the two commands. Bash and other shells run both commands, connecting the output of the first to the input of the second. The
ls program produces a list of files in the current directory, while the
grep program reads the output of
ls and prints only those lines containing the letter
x.
The above, familiar to most Unix users, is an example of an “unnamed pipe”. The pipe exists only inside the kernel and cannot be accessed by processes that created it, in this case, the bash shell. For those who don't already know, a parent process is the first process started by a program that in turn creates separate child processes that execute the program.
The other sort of pipe is a “named” pipe, which is sometimes called a FIFO. FIFO stands for “First In, First Out” and refers to the property that the order of bytes going in is the same coming out. The “name” of a named pipe is actually a file name within the file system. Pipes are shown by
ls as any other file with a couple of differences:
% ls -l fifo1
prw-r--r-- 1 andy users 0 Jan 22 23:11 fifo1|
The
p in the leftmost column indicates that fifo1 is a pipe. The rest of the permission bits control who can read or write to the pipe just like a regular file. On systems with a modern
ls, the
| character at the end of the file name is another clue, and on Linux systems with the color option enabled,
fifo| is printed in red by default.
On older Linux systems, named pipes are created by the
mknod program, usually located in the /etc directory. On more modern systems,
mkfifo is a standard utility. The
mkfifo program takes one or more file names as arguments for this task and creates pipes with those names. For example, to create a named pipe with the name
pipe1 give the command:
mkfifo pipe
The simplest way to show how named pipes work is with an example. Suppose we've created
pipe as shown above. In one virtual console1, type:
ls -l > pipe1
and in another type:
cat < pipe
Voila! The output of the command run on the first console shows up on the second console. Note that the order in which you run the commands doesn't matter.
If you haven't used virtual consoles before, see the article “Keyboards, Consoles and VT Cruising” by John M. Fisk in the November 1996
Linux Journal.
If you watch closely, you'll notice that the first command you run appears to hang. This happens because the other end of the pipe is not yet connected, and so the kernel suspends the first process until the second process opens the pipe. In Unix jargon, the process is said to be “blocked”, since it is waiting for something to happen.
One very useful application of named pipes is to allow totally unrelated programs to communicate with each other. For example, a program that services requests of some sort (print files, access a database) could open the pipe for reading. Then, another process could make a request by opening the pipe and writing a command. That is, the “server” can perform a task on behalf of the “client”. Blocking can also happen if the client isn't writing, or the server isn't reading.
Create two named pipes, pipe1 and pipe2. Run the commands:
echo -n x | cat - pipe1 > pipe2 &
cat <pipe2 > pipe1
On screen, it will not appear that anything is happening, but if you run
top (a command similar to
ps for showing process status), you'll see that both
cat programs are running like crazy copying the letter
x back and forth in an endless loop.
After you press ctrl-C to get out of the loop, you may receive the message “
broken pipe”. This error occurs when a process writing to a pipe when the process reading the pipe closes its end. Since the reader is gone, the data has no place to go. Normally, the writer will finish writing its data and close the pipe. At this point, the reader sees the
EOF (end of file) and executes the request.
Whether or not the “broken pipe” message is issued depends on events at the exact instant the ctrl-C is pressed. If the second
cat has just read the
x, pressing ctrl-C stops the second
cat,
pipe1 is closed and the first
cat stops quietly, i.e., without a message. On the other hand, if the second
cat is waiting for the first to write the
x, ctrl-C causes
pipe2 to close before the first
cat can write to it, and the error message is issued. This sort of random behavior is known as a “race condition”.
