Fifo 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

/*Создаем новый FIFO*/

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*/

&signal_old) 0) /*Родитель читает из FIFO*/

if (( r_fifo=open(«/tmp/fifo0001.1», O_RDONLY))

Next: Блокировка файлов Up: Трубы (pipes) Previous: Функция popen() Contents 2004-06-22

Источник

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

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

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

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

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

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

$ mkfifo a=rw myFIFO

или системного вызова 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-канала:

mknod(«FIFO», S_IFIFO|0666, 0);

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

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

mknod(«FIFO», S_IFIFO|0666, 0);

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

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

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

#define FIFO «FIFO»

/* Буфер для чтения */

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

права доступа 0666 */

mknod(FIFO, S_IFIFO|0666, 0);

fp = fopen(FIFO, «r»);

fgets(buf, 128, fp);

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

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

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

#define FIFO «FIFO»

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

fp = fopen(FIFO, «w»);

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

Получена строка: info

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

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

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

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

Продолжение на ЛитРес

Русские Блоги

linux process communication — известная труба FIFO

введение:Безымянная трубаОсновное ограничение заключается в том, что у него нет имени, а объем общения ограничен процессами, которые связаны кровью. Хорошо известный канал существует в файловой системе как файл FIFO. Таким образом, даже процесс, не связанный с процессом создания FIFO, может обмениваться данными через FIFO, пока он обращается к пути. Эта заметка включает введение в FIFO, примеры кода и реализацию ядра.

1. Введение в FIFO

1.1. «Знаменитый» трубопровод:

FIFO относится к принципу «первым пришел — первым ушел» (first in, first out), FIFO в Unix похож на канал. Это односторонний (полудуплексный поток данных). В отличие от конвейеров, каждый FIFO имеет связанное с ним имя пути, что позволяет несвязанным процессам обращаться к одному и тому же FIFO для связи. FIFO также называется именованным каналом.

1.2. Создать:

FIFO создается функцией mkfifo (), прототип функции:

int mkfifo(const char *pathname, mode_t mode)

const char *pathname：Это общее имя пути unix, это имя FIFO.
** mode: ** параметр режима указывает бит разрешения FIFO, это S_IRUSER (чтение владельца), S_IWUSR (запись владельца), S_IRGRP (чтение члена группы), S_IWGRP (запись члена группы), S_IROTH (чтение другого пользователя), S_IWOTH (написано другими пользователями) — это побитовое ИЛИ, составленное из этих шести констант.

Функция mkfifo неявно указала O_CREAT | O_EXCL, то есть она либо создает новый FIFO, либо возвращает ошибку EEXIST (FIFO с указанным именем уже существует). Если вы не хотите создавать новый FIFO, вызовите open вместо mkfifo. Чтобы открыть существующий FIFO или создать новый FIFO, вы должны сначала вызвать mkfifo, а затем проверить, возвращает ли он ошибку EEXIST. Если возвращается, вызовите вместо этого open.

1.3. Правила открытия FIFO:

1), еслиТекущая открытая операция предназначена для чтенияПри открытии FIFO, если уже естьСоответствующий процесс — записьКогда FIFO открыт, текущая операция открытия будет успешно возвращена; в противном случае она может заблокироваться до тех пор, пока соответствующий процесс не откроет FIFO для записи (текущая операция открытия установила флаг блокировки); или он успешно возвращается (текущая операция открытия не устанавливает флаг блокировки) .
2), еслиТекущая открытая операция предназначена для записиПри открытии FIFO, если уже естьСоответствующий процесс читаетсяКогда FIFO открыт, текущая операция открытия будет успешно завершена; в противном случае он может заблокироваться, пока соответствующий процесс не откроет FIFO для чтения (текущая операция открытия установила флаг блокировки); или он вернет ошибку ENXIO (текущая операция открытия не устанавливает флаг блокировки) ).

Короче говоря, как только установлен флаг блокировки и установлен вызов mkfifo, оба конца конвейера должны быть открыты для чтения и записи.Если какая-либо сторона не открыта, она будет заблокирована при вызове open. Запись в каналы или FIFO всегда добавляет данные в конец, чтение в них всегда возвращает данные с начала и вызывает lseek в каналах или FIFO, чтобы вернуть ошибку ESPIPE.

1.4. Чтение данных в FIFO:

Если процесс блокирует открытие FIFO для чтения данных из FIFO, то операция чтения в процессе называется операцией чтения с установленным флагом блокировки. И есть процесс записи, чтобы открыть FIFO, и в текущем FIFO нет данных,То есть в это время установлены оба конца конвейера, но конец записи еще не записал данные.。

1) Для операции чтения с установленным флагом блокировки она всегда будет заблокирована (то есть блок активен и ожидает данных. Он не потребляет ресурсы ЦП, и этот метод синхронизации процессов очень эффективен для ЦП. )
2). Для операций чтения без установленного флага блокировки возвращается -1, текущее значение errno — EAGAIN, напомните, чтобы повторить попытку позже.

Для операций чтения с установленным флагом блокировки:Есть две причины блокировки：

1) В FIFO есть данные, но эти данные читают другие процессы (для каждого процесса чтения этот знаменитый канал является критическим ресурсом, и все должны быть скромными друг к другу и не могут использоваться вместе).
2) В FIFO нет данных. Причина разблокировки заключается в том, что новые данные записываются в FIFO, и операция чтения не будет заблокирована, потому что количество байтов в FIFO меньше количества байтов, запрошенных для чтения. В это время операция чтения вернет количество данных, которые в настоящее время находятся в FIFO. .

Следует отметить следующее:Считать открытый флаг блокировкиВлияет только на первую операцию чтения этого процессаЕсли в этом процессе есть несколько последовательностей операций чтения, после пробуждения первой операции чтения и завершения операции чтения другие выполняемые операции чтения больше не будут блокироваться, даже если в FIFO нет данных при выполнении операции чтения. Точно так же в это время операция чтения возвращает 0.

1.5. Записать данные в FIFO:

Если процесс блокирует открытие FIFO для записи данных в FIFO, тогда операция записи в процессе называется операцией записи с установленным флагом блокировки. Для операций с установленными флагами блокировки записи:

1), когдаКогда объем записываемых данных не превышает PIPE_BUF，Linux гарантирует атомарность написания. Если свободного буфера конвейера недостаточно для хранения количества байтов, которые должны быть записаны в это время, он переходит в спящий режим, и операция однократной записи начинается, когда буфер может удерживать количество байтов для записи.
2), когда захотитеКогда объем записанных данных больше PIPE_BUF，Linux больше не гарантирует атомарность записи. Как только в буфере FIFO появится свободная область, процесс записи попытается записать данные в канал, и операция записи вернется после записи всех запрошенных данных.

Для операций записи без флага блокировки:

1), при необходимостиКогда объем записываемых данных превышает PIPE_BUF, Linux больше не будет гарантировать атомарность записи.. После заполнения всех свободных буферов FIFO операция записи возвращается.
2)、Когда объем записываемых данных меньше PIPE_BUF, Linux гарантирует атомарность записи.. Если текущий свободный буфер FIFO может вместить количество байтов, запрошенных для записи, он будет успешно возвращен после записи; если текущий свободный буфер FIFO не может вместить количество байтов, запрошенных для записи, будет возвращена ошибка EAGAIN, чтобы напомнить вам о записи позже;

2. Пример кода:

2.1. Связь между несвязанным сервером и клиентом:

Основной процесс:

1). Сервер создает известные каналы FIFO1 и FIFO2 и устанавливает FIFO1 только для чтения, FIFO2 для записи
2). Клиент открывает известные каналы FIFO1 и FIFO2 и устанавливает для FIFO1 только запись и FIFO2 только для чтения.
3), отправка и получение данных
4), внимательно читать и писать, отключать

Программный код на стороне сервера:

Код клиентской программы:

Явление 1: Когда клиент не подключен, сервер находится в состоянии блокировки:

Феномен 2: Когда клиент подключен, состояние выполнения:

3. Реализация в ядре именованных каналов FIFO:

Поскольку конвейер может использоваться только в двух связанных друг с другом процессах, например в родительско-дочернем процессе; если вы хотите использовать каналы для связи между двумя несвязанными процессами, тогда конвейер бесполезен. Как позволить двум несвязанным процессам найти индексный дескриптор с атрибутом pipe? Естественно подумайте об использовании файлов на диске.
Когда два процесса в Linux обращаются к одному и тому же файлу, хотя их соответствующие файлы различаются, все они указывают на один и тот же узел Inode, поэтому канал и файл на диске объединяются для получения имени трубопровод.

Можно видеть, что две функции операций идентичны, что указывает на то, что операции чтения и записи в FIFO также читаются и записываются в буфер канала, поэтому файл, созданный с помощью fifo, позволяет процессу чтения и записи только найти один и тот же индексный дескриптор, а затем использовать один и тот же буфер канала.

Справочные материалы:
1. Сетевое программирование в Unix, том II
2、Linux знаменитый канал FIFO)
3、Поговорим о реализации pipe из кода ядра

Исправления и предложения
Электронная почта: [email protected]

Интеллектуальная рекомендация

Пошаговая загрузка файла Spring MVC-09 (на основе файла загрузки клиента Servlet3.0 + Html5)

пример тестовое задание Исходный код Несмотря на загрузку файлов в Servlet3.0 +, мы можем очень легко программировать на стороне сервера, но пользовательский интерфейс не очень дружелюбен. Одна HTML-ф.

Создайте многоканальное окно в приложениях Win32

Создайте многоканальное окно в приложениях Win32, создайте несколько оконных объектов одного и того же класса Windows, а окна объектов разных классов окон. .

Путь к рефакторингу IOS-APP (3) Введение в модульное тестирование

IOS-APP реконструкция дороги (1) структура сетевых запросов IOS-APP реконструкция дороги (два) Модельный дизайн При рефакторинге нам нужна форма, позволяющая вносить смелые изменения, обеспечивая при .

Tree——No.617 Merge Two Binary Trees

Problem： Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. You need to merge them into a new bin.

Источник

Fifo linux что это