Using FIFOs in Linux
I ran into an interesting "feature" when using two FIFO's in Linux for bi-directional communication between two processes. Basically, I kept encountering a deadlock no matter what I did, and I couldn't figure out why.
Here's the scenario: You have two separate processes (not necessarily parent/child) and two separate FIFO's. Although a FIFO can be used for bi-directional communication, each one will be set up to be uni-directional: Process #1 will write to FIFO #1 and read from FIFO #2, while Process #2 will write to FIFO #2 and read from FIFO #1. Doing things this way allows Process #1 to pass data to Process #2 via FIFO #1, and Process #2 can pass a result back to Process #1 via FIFO #2. This provides an easy way to keep both processes synchronized, because each process will block when reading the FIFO streams.
Each process blocks when opening both FIFOs as well (during initialization, for example) until both a read and a writer are present (which is normal). Once they are opened, Process #1 writes some data (a number, for example) to FIFO #1. Process #2 should receive the data and return a value via FIFO #2. However, no matter what I tried, the data never reached Process #2, and both processes were in deadlock. But if only a single FIFO was used (where data was passed from Process #1 to Process #2 only), everything worked fine!
If you're now asking, "Just what the hell is a FIFO?", then stop reading here. If you want to know what the problem was and the solution, keep reading.
This silly problem stumped me for some hours. The internets didn't offer much help - apparently other people don't have this type of problem.
Here is the first example using a single FIFO that actually works.
-
// Server, single FIFO
-
int main(char argc, char **argv)
-
{
-
FILE * fifo = fopen("/tmp/cvalidout", "w");
-
int s = 123;
-
fwrite( (void*)&s, sizeof(s), 1, fifo);
-
fclose(fifo);
-
}
-
// Client, single FIFO
-
int main(char argc, char **argv)
-
{
-
FILE * fifo = fopen("/tmp/cvalidout", "r");
-
int s;
-
fread( (void*)&s, sizeof(s), 1, fifo);
-
fclose(fifo);
-
}
The above two examples work fine. However using two FIFOs for bi-directional communication (as in the examples below) does NOT work. Why?
-
// Server, two FIFOs
-
int main(char argc, char **argv)
-
{
-
FILE * fifoin = fopen("/tmp/cvalidin", "r");
-
FILE * fifoout = fopen("/tmp/cvalidout", "w");
-
int s = 123;
-
fwrite( (void*)&s, sizeof(s), 1, fifoout);
-
fread( (void*)&s, sizeof(s), 1, fifoin);
-
fclose(fifoin);
-
fclose(fifoout);
-
}
-
// Client, two FIFOs
-
int main(char argc, char **argv)
-
{
-
FILE * fifoout = fopen("/tmp/cvalidin", "w");
-
FILE * fifoin = fopen("/tmp/cvalidout", "r");
-
int s;
-
fread( (void*)&s, sizeof(s), 1, fifoin);
-
s = 456;
-
fwrite( (void*)&s, sizeof(s), 1, fifoout);
-
fclose(fifoin);
-
fclose(fifoout);
-
}
The solution is this:
I was using fread() and fwrite() calls in these examples. The fwrite() call uses some kind of buffering. So after every fwrite() call, you need to use the fflush() call so that the written data is actually committed. That's all! To make the server/client programs work, insert a fflush() after the fwrite() calls.
The reason that the first sample program I wrote works is because the server program writes the value to the pipe (which does not block) and then promptly ends. When the process ends, the buffer is flushed automatically - which is what I didn't realize, and which is why I took so long to figure out what the hell was going on. Geez.
Anyway, I hope someone else that runs into this same sillyness can find this post and save themselves a little bit of time!