What is fifo in linux

26.3. Каналы типа FIFO

Канал FIFO — это канал, основанный на принципе очереди: «первым вошел, первым вышел». От обычного канала канал FIFO отличается следующим:

? Канал FIFO сохраняется в файловой системе в виде файла, поэтому каналы FIFO называются именованными.

? С именованным каналом, как с обычным файлом, могут работать все процессы, а не только предок и потомки.

? В отличие от полудуплексного канала, находящегося в ядре, канал FIFO находится в файловой системе и остается там даже после завершения обмена данными. Для следующего использования канала его не нужно заново создавать.

Создать именованный канал можно с помощью командного интерпретатора:

или системного вызова mknod():

int mknod(char *pathname, mode_t mode, dev_t dev);

Функция mknod() используется не только для создания каналов FIFO. Она может создать любой i-узел (inode) файловой системы: файл, устройство, канал FIFO. Функция возвращает 0, если создание узла прошло успешно, или -1, если произошла ошибка. Проанализировать ошибку можно с помощью переменной errno, которая равна:

? EFAULT, ENOTDIR, ENOENT — неправильно задан путь;

? EACCESS — у вас недостаточно прав;

? ENAMETOOLONG — слишком длинный путь.

Пример создания FIFO-канала:

В текущем каталоге будет создан канал FIFO с правами доступа 0666.

Указывая права доступа создаваемого файла, помните, что они находятся под влиянием umask. Поэтому, если вы хотите установить истинное значение прав доступа, используйте системный вызов umask(0), чтобы временно отключить влияние umask:

Рассмотрим программу, создающую FIFO-канал и ожидающую данных по этому каналу. Программа после создания канала будет ожидать данных по этому каналу и не завершится до тех пор, пока вы не «убьете» процесс.

Листинг 26.3. Процесс-читатель

/* Наш канал называется FIFO, он будет создан в текущем

/* Создаем канал, если он еще не создан,

printf(«Получена строка: %s «, buf);

Теперь рассмотрим процесс-писатель, который будет записывать данные в FIFO-канал. Этот процесс не завершится до тех пор, пока процесс-читатель не прочитает их:

Листинг 26.4. Процесс-писатель writefifo.c

void main(int argc, char *argv[])

Запустите процесс-читатель, затем перейдите на другую консоль и запустите «писателя» с аргументом — строкой «info». На первой консоли вы увидите сообщение:

При использовании каналов FIFO нужно учитывать механизм их блокирования. Если процесс открыл канал для записи, то он блокируется до тех пор, пока другой процесс не откроет его для чтения. Аналогично, если какой-то процесс откроет FIFO-канал для чтения, он будет блокирован, пока другой процесс не запишет в канал данные. Если блокировка процесса нежелательна, можно использовать опцию O_NONBLOCK.

Ясное дело, что тогда нужно немного модифицировать исходный код: вызовы fclose(), fputs(), fgets() использовать уже нельзя, вместо них нужно использовать соответствующие вызовы close(), write(), read().

И последнее, что нужно помнить при программировании FIFO-каналов: идеология FIFO-каналов предполагает наличие «читателей» и «писателей». Если «писатель» пишет в канал, у которого нет «читателя», из ядра будет послан сигнал SIGPIPE.

Данный текст является ознакомительным фрагментом.

Читайте также

9.3. Базовое межпроцессное взаимодействие: каналы и очереди FIFO

9.3. Базовое межпроцессное взаимодействие: каналы и очереди FIFO Межпроцессное взаимодействие (Interprocess communication — IPC) соответствует своему названию: это способ взаимодействия для двух отдельных процессов. Самым старым способом IPC на системах Unix является канал (pipe):

9.4.3.4. Неблокирующий ввод/вывод для каналов и FIFO

9.4.3.4. Неблокирующий ввод/вывод для каналов и FIFO Ранее для описания способа работы каналов мы использовали сравнение с двумя людьми, моющими и вытирающими тарелки с использованием сушилки; когда сушилка заполняется, останавливается моющий, а когда она пустеет,

FIFO

FIFO Название каналов FIFO происходит от выражения First In First Out (первый вошел — первый вышел). FIFO очень похожи на каналы, поскольку являются однонаправленным средством передачи данных, причем чтение данных происходит в порядке их записи. Однако в отличие от программных

5.12 КАНАЛЫ

5.12 КАНАЛЫ Каналы позволяют передавать данные между процессами в порядке поступления («первым пришел — первым вышел»), а также синхронизировать выполнение процессов. Их использование дает процессам возможность взаимодействовать между собой, пусть даже не известно,

Каналы FXO и FXS

Каналы FXO и FXS Каналы FXO и FXS отличаются друг от друга лишь тем, что один из них обеспечивает тональный сигнал готовности линии. FXO-порт не генерирует тонального сигнала, он его принимает. Самый простой пример — тональный сигнал, поставляемый телефонной компанией. FXS- порт

4.6. Именованные каналы (FIFO)

4.6. Именованные каналы (FIFO) Программные каналы не имеют имен, и их главным недостатком является невозможность передачи информации между неродственными процессами. Два неродственных процесса не могут создать канал для связи между собой (если не передавать

Атомарность записи в FIFO

Атомарность записи в FIFO Наша простейшая пара клиент-сервер позволяет наглядно показать важность наличия свойства атомарности записи в пpoгрaммныe каналы и FIFO. Предположим, что два клиента посылают серверу запрос приблизительно в один и тот же момент. Первый клиент

FIFO и NFS

FIFO и NFS Каналы FIFO представляют собой вид IPC, который может использоваться только в пределах одного узла. Хотя FIFO и обладают именами в файловой системе, они могут применяться только в локальных файловых системах, но не в присоединенных сетевых (NFS).solaris % mkfifo

4.11. Ограничения программных каналов и FIFO

4.11. Ограничения программных каналов и FIFO На программные каналы и каналы FIFO системой накладываются всего два ограничения:? OPEN_MAX — максимальное количество дескрипторов, которые могут быть одновременно открыты некоторым процессом (Posix устанавливает для этой величины

10.14. Реализация с использованием FIFO

10.14. Реализация с использованием FIFO Займемся реализацией именованных семафоров Posix с помощью каналов FIFO. Именованный семафор реализуется как канал FIFO с конкретным именем. Неотрицательное количество байтов в канале соответствует текущему значению семафора. Функция sem_post

Отличия процедур типа Function от процедур типа Sub

Отличия процедур типа Function от процедур типа Sub Между процедурами типа Function и типа Sub есть одно существенное отличие: в процедуре типа Function обязательно где-то должен присутствовать по крайней мере один оператор, задающий значение этой функции. При этом используется имя

5.4. Каналы

5.4. Каналы Канал — это коммуникационное устройство, допускающее однонаправленное взаимодействие. Данные, записываемые на «входном» конце канала, читаются на «выходном» его конце. Каналы являются последовательными устройствами: данные всегда читаются в том порядке, в

5.4.5. Каналы FIFO

5.4.5. Каналы FIFO Файл FIFO (First-In, First-Out — первым пришел, первым обслужен) — это канал, у которого есть имя в файловой системе. Любой процесс может открыть и закрыть такой файл. Процессы, находящиеся на противоположных концах канала, не обязаны быть связанными друг с другом.

Источник

What is 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

Источник

What is fifo in linux

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.

Источник