Linux World
FIFO is a first in first out data structure that which can be used to hold any kind of data. Linux kernel provides useful APIs to make creation and use of FIFO data structure easy.
The first step in creation of FIFO is to define the FIFO required with the type of data it will be holding using
Once the FIFO has been defined we can use a number of functions available to add,remove, check the FIFO. To put data into the FIFO
To take the date out of the FIFO
Just to see the above functions in use we will create a proc entry which will output one data from a FIFO that gets created as soon as the module is inserted into the kernel.
To create a module with 6 char entries
An array of values to be added to the FIFO
To add the entries into the FIFO when the module gets inserted into the kernel, the init function needs to call the kfifo_put function
Once the fifo has been created, we can extract one data at a time using the function kfifo_get . To ensure that only one data is read from the FIFO each time we use the cat command on the proc entry extra checks and flags are needed
The function kfifo_is_empty returns true when the fifo is empty else it returns false.
The full code for creation of the proc entry called «fifo» which will output one data value at a time is:
If the file is saved as proc_read_fifo.c, it can be compiled using
To test the code, once the compile and insert the code
Read the proc entry using the cat command
The output shows that every call to read the entry removes one item from the fifo and when all entries are removed «FIFO empty» message gets printed.
Linux World
In the last post we saw the how to create pipes for communication between processes in linux.
One of the major disadvantage of pipes is that the they can not be accesed using their names by any other process other than child and the parent as they do not get listed in the directory tree.
The work around for this porblem is to create a named pipe which is also called as a FIFO, which stands for First in First out, meaning the data that is written into the pipe first will be read out first always.
The fifos get listed in the directory tree and any process can access it using its name by providing the approproiate path.
fifo are created using the function mkfifo() which takes as arguments
1. The name of the fifo that has to be created
2. The permissions for the file.
Once the file is created, it needs to be opened using the system call open() and the data can be read and written from the file using read() and write system calls.
One of the examples you can think of using a named pipe is communication between a server and a client. If ther are two fifos one of the server and the other of the client, then the client can send request to the server on the server fifo which the server will read and respond back with the reply on the client’s fifo.
Another advantage of a fifo over the pipes is that fifo are birectoinal, that is the same fifo can be read from as well and written into.
Here is an example the demostrates the working of fifos.
First we will create two fifos one called the server and the other called the client.
Save the above program as create_fifo.c and compile is using gcc as follows
If the compilation is successfull, run the program as follows
If there are no errors, then two fifo should have got created in your current working directory. To confirm this run the command the «ls -l» in your current workind directory and you should see some thing like this.
If you notice the first column of the row containing fifo_server and fifo_client, you can see the letter «p» which signifies that it is a pipe.
Now to use these pipes, we will write two program’s one to represent the server and other to represent the client. The server will read from the pipe fifo_server to which the client will send a request. On reciveing the request, the server will send the information to the client on fifo_client.
The above code,server.c, reads the choice from fifo_server to which the client writes and depending on the request,the server responds with the relevant data by writing to fifo_client.
Save the file and server.c and compile it as follows
The above code,client.c, sends a request to the server by writing to the pipe fifo_server, and recieves the reply from the server by reading the pipe fifo_client.
Save the file and server.c and compile it as follows
To see the pipe in operation, open two terminals and go the folder where the pipes have been created.
Note: The server.c and client.c codes assume that the pipes exist in the same directory as the executables of server and client are, if they exist in any other directory you will have to provide the path to the same in the system call open().
The terminal will go into a wait state with the cursor blinking, waiting for request from client.
The client will prompt to make a choice of request to be sent to the server, enter number 1,2 or 3
This number will be sent to the server and the client will go into a wait state, waiting for the server to respond.
After a few seconds you should see the reponse from the server being printed on the client terminal.
Note: wait for 10 seconds for the output to appear as the server has a sleep for 10 seconds, this is required to allow some time for the client to start its read operation on the fifo_client pipe.
for eg if we entered option 2, the response would be
output on client terminal:
Thus we were able to communicate between the two processes using the fifos, even though the pipes were not created by them.
To use the pipes with out writing the server and client code we can use «cat» and «echo» commands.
We should be able to see the «hello world» being printed on the Terminal 1.
Creating fifo in linux
С помощью труб могут общаться только родственные друг другу процессы, полученные с помощью fork (). Именованные каналы FIFO позволяют обмениваться данными с абсолютно «чужим» процессом.
С точки зрения ядра ОС FIFO является одним из вариантов реализации трубы. Системный вызов mkfifo () предоставляет процессу именованную трубу в виде объекта файловой системы. Как и для любого другого объекта, необходимо предоставлять процессам права доступа в FIFO, чтобы определить, кто может писать, и кто может читать данные. Несколько процессов могут записывать или читать FIFO одновременно. Режим работы с FIFO — полудуплексный, т.е. процессы могут общаться в одном из направлений. Типичное применение FIFO — разработка приложений «клиент — сервер».
Синтаксис функции для создания FIFO следующий:
int mkfifo(const char *fifoname, mode_t mode); При возникновении ошибки функция возвращает -1, в противном случае 0. В качестве первого параметра указывается путь, где будет располагаться FIFO. Второй параметр определяет режим работы с FIFO. Пример использования приведен ниже:
int fd_fifo; /*дескриптор FIFO*/
char buffer[]=»Текстовая строка для fifo\n»;
/*Если файл с таким именем существует, удалим его*/
if((mkfifo(«/tmp/fifo0001.1», O_RDWR)) == -1)
fprintf(stderr, «Невозможно создать fifo\n»);
/*Открываем fifo для чтения и записи*/
if((fd_fifo=open(«/tmp/fifo0001.1», O_RDWR)) == — 1)
fprintf(stderr, «Невозможно открыть fifo\n»);
if(read(fd_fifo, &buf, sizeof(buf)) == -1)
fprintf(stderr, «Невозможно прочесть из FIFO\n»);
printf(«Прочитано из FIFO : %s\n»,buf);
Если в системе отсутствует функция mkfifo (), можно воспользоваться общей функцией для создания файла: int mknod(char *pathname, int mode, int dev);
Здесь pathname указывает обычное имя каталога и имя FIFO. Режим обозначается константой S_IFIFO из заголовочного файла . Здесь же определяются права доступа. Параметр dev не нужен. Пример вызова mknod :
if(mknod(«/tmp/fifo0001.1», S_IFIFO | S_IRUSR | S_IWUSR,
Флаг O_NONBLOCK может использоваться только при доступе для чтения. При попытке открыть FIFO с O_NONBLOCK для записи возникает ошибка открытия. Если FIFO закрыть для записи через close или fclose , это значит, что для чтения в FIFO помещается EOF.
Если несколько процессов пишут в один и тот же FIFO, необходимо обратить внимание на то, чтобы сразу не записывалось больше, чем PIPE_BUF байтов. Это необходимо, чтобы данные не смешивались друг с другом. Установить пределы записи можно следующей программой: #include
if((mkfifo(«fifo0001», O_RDWR)) == -1)
fprintf(stderr, «Невозможно создать FIFO\n»);
printf(«Можно записать в FIFO сразу %ld байтов\n»,
printf(«Одновременно можно открыть %ld FIFO \n»,
При попытке записи в FIFO, который не открыт в данный момент для чтения ни одним процессом, генерируется сигнал SIGPIPE .
В следующем примере организуется обработчик сигнала SIGPIPE , создается FIFO, процесс-потомок записывает данные в этот FIFO, а родитель читает их оттуда. Пример иллюстрирует простое приложение типа «клиент — сервер»:
static volatile sig_atomic_t sflag;
static sigset_t signal_new, signal_old, signal_leer;
static void sigfunc(int sig_nr)
fprintf(stderr, «SIGPIPE вызывает завершение
if(signal(SIGPIPE, sigfunc) == SIG_ERR)
fprintf(stderr, «Невозможно получить сигнал
/*Удаляем все сигналы из множества сигналов*/
/*Устанавливаем signal_new и сохраняем его*/
/* теперь маской сигналов будет signal_old*/
int r_fifo, w_fifo; /*дескрипторы FIFO*/
char buffer[]=»Текстовая строка для fifo\n»;
if((mkfifo(«/tmp/fifo0001.1», O_RDWR)) == -1)
fprintf(stderr, «Невозможно создать fifo\n»);
else if(pid > 0) /*Родитель читает из FIFO*/
if (( r_fifo=open(«/tmp/fifo0001.1», O_RDONLY))<0)
else /*Потомок записывает в FIFO*/
write(w_fifo, buffer, strlen(buffer));
Next: Блокировка файлов Up: Трубы (pipes) Previous: Функция popen() Contents 2004-06-22
