Linux System Programming: Creating FIFO in C using “mknod()” system call in Linux
1. FIFO or named pipe exist as a device special file in the file system.
2. FIFO can be used to process of different ancestry.
3. They can share data through a named pipe.
4. The named pipe remains in the file system for later use.
5. An “un-named” pipe will last as long as the process. Named pipe or FIFO will be there till you remove the file.
6. Here two or more files can communicate with each other by reading/writing from this file.
How many ways are there to create a FIFO
There are 2 ways to create FIFO.
1. Creating FIFO directly from the shell.
2. Creating FIFO by using “mknod()” system call.
In this chapter we shall see both ways of creating named FIFO.
1. Creating FIFO directly from the shell.
You can use “mknod()” command on command line to create a named pipe.
When you create a named pipe, it is equivalent to creating an ordinary file. It will exist until you delete it.
Syntax for “mknod”:
mknod named-pipe-identifier p
Here:
“named-pipe-identifier” is the pathname of the named pipe you want to create
To remove a named pipe, use “rm” command.
Full example to create a pipe using command line:
# Named Pipe # # Create named pipe using mknod mknod myPipe p # "cat" command will open "myPipe" to read # "&" is used to run cat process as a background process # here cat command is blocked because myPipe file is not yet opened for writing # It will wait in background cat myPipe & # write message into pipe # as "echo" command opens "myPipe" for writing, once writing is completed, "cat" command that is blocked will display the message echo "This is a message!" > myPipe # Delete pipe. rm myPipe
2. Creating FIFO by using “mknod()” system call.
We will use “mknod()” system call to create FIFO.
int mkfifo(const char *pathname, mode_t mode);
Now we will create 2 programs.
3. we need to use “fp = fopen(file_location, open_mode)” system call to open a physical file.
4. we need to use “fclose(fp)” system call to close a physical file.
1. fifoServer.c
#include #include #include #include #define FIFO_FILE "myFifo" int main(void) < FILE *fp; char readbuf[80]; /* Create the FIFO if it does not exist */ umask(0); mknod(FIFO_FILE, S_IFIFO|0666, 0); while(1) < fp = fopen(FIFO_FILE, "r"); fgets(readbuf, 80, fp); printf("Received string: %s\n", readbuf); fclose(fp); >return(0); > As FIFO is a blocking call, we need to run the server in background till it receives a message from client.
So after you compile it, you will have to run as below:
2. fifoClient.c
#include #include #define FIFO_FILE "myFifo" int main(int argc, char *argv[]) < FILE *fp; if ( argc != 2 ) < printf("USAGE: fifoclient [string]\n"); exit(1); >if((fp = fopen(FIFO_FILE, "w")) == NULL) < perror("fopen"); exit(1); >fputs(argv[1], fp); fclose(fp); return(0); > After compiling it, you need to send the data or buffer wile executing the program.
You need to run as:
./fifoClient “hello world”
Fifo in linux example
С помощью труб могут общаться только родственные друг другу процессы, полученные с помощью 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
Fifo in linux example
NAME
fifo - first-in first-out special file, named pipe
DESCRIPTION
A FIFO special file (a named pipe) is similar to a pipe, except that it is accessed as part of the filesystem. It can be opened by multiple processes for reading or writing. When processes are exchanging data via the FIFO, the kernel passes all data internally without writing it to the filesystem. Thus, the FIFO special file has no contents on the filesystem; the filesystem entry merely serves as a reference point so that processes can access the pipe using a name in the filesystem. The kernel maintains exactly one pipe object for each FIFO special file that is opened by at least one process. The FIFO must be opened on both ends (reading and writing) before data can be passed. Normally, opening the FIFO blocks until the other end is opened also. A process can open a FIFO in nonblocking mode. In this case, opening for read-only will succeed even if no-one has opened on the write side yet, opening for write-only will fail with ENXIO (no such device or address) unless the other end has already been opened. Under Linux, opening a FIFO for read and write will succeed both in blocking and nonblocking mode. POSIX leaves this behavior undefined. This can be used to open a FIFO for writing while there are no readers available. A process that uses both ends of the connection in order to communicate with itself should be very careful to avoid deadlocks.
NOTES
When a process tries to write to a FIFO that is not opened for read on the other side, the process is sent a SIGPIPE signal. FIFO special files can be created by mkfifo(3), and are indicated by ls -l with the file type 'p'.
SEE ALSO
mkfifo(1), open(2), pipe(2), sigaction(2), signal(2), socketpair(2), mkfifo(3), pipe(7)
COLOPHON
© 2019 Canonical Ltd. Ubuntu and Canonical are registered trademarks of Canonical Ltd.
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.