ИМЯ

pipe - обзор каналов и FIFO

ОПИСАНИЕ

Каналы и FIFO (также называемые именованными каналами) предоставляют
двунаправленный канал обмена между процессами. У канала имеется конец для чтения
(read end) и конец для записи (write end). Данные, записанные в конец для записи,
можно прочитать из конца для чтения.

Канал создаётся с помощью вызова pipe(2), который образует новый канал и
возвращает два файловых дескриптора, один указывает на конец для чтения, а другой
на конец для записи. Каналы можно использовать для создания канала обмена между
процессами; пример смотрите в pipe(2).

У FIFO (сокращение от First In First Out, первым вошёл, первым вышел) имеется имя
в файловой системе (создаётся с помощью mkfifo(3)), и такой канал открывается с
помощью open(2). Любой процесс может открыть FIFO, если это ему разрешено правами
на файл. Конец для чтения открывается при указании флага O_RDONLY; конец для
записи открывается при указании флага O_WRONLY. Подробней смотрите fifo(7).
Замечание: хотя у FIFO есть путь в файловой системе, при вводе-выводе из FIFO не
используются операции с нижележащим устройством (если оно есть).

Ввод-вывод из каналов и FIFO
Каналы и FIFO отличаются только способом создания и открытия. После выполнения
этих задач, ввод-вывод из каналов и FIFO имеет одинаковую семантику.

Если процесс пытается выполнить чтение из пустого канала, то read(2) заблокирует
выполнение в ожидании данных. Если процесс пытается выполнить запись в заполненный
канал (смотрите далее), то write(2) заблокирует выполнение до тех пор, пока из
канала не будут прочитаны данные, чтобы можно было записать ожидающие. Возможен
неблокируемый ввод-вывод с помощью вызова fcntl(2) с операцией F_SETFL, включающей
флаг O_NONBLOCK в состоянии открытого файла.

Канал обмена, предоставляемый каналом, является потоком байт: какие-либо границы
сообщений отсутствуют.

Если все файловые дескрипторы, указывающие на конец канала для записи, были
закрыты, то попытка выполнить read(2) из канала возвратит конец файла (read(2)
вернёт 0). Если все файловые дескрипторы, указывающие на конец канала для чтения,
были закрыты, то write(2) завершится сигналом SIGPIPE, который будет послан
вызывающему процессу. Если вызывающий процесс игнорирует этот сигнал, то write(2)
завершится ошибкой EPIPE. Приложение, использующее pipe(2) и fork(2), должно
использовать правильные вызовы close(2) для закрытия ненужных копий файловых
дескрипторов; это обеспечит появления конца файла и доставку SIGPIPE/EPIPE в
подходящий момент.

Для канала невозможно вызвать lseek(2).

Ёмкость канала
Канал имеет ограниченную ёмкость. Если канал переполнен, то write(2) заблокируется
или завершится с ошибкой, в зависимости от наличия флага O_NONBLOCK (смотрите
далее). В различных реализациях разные ограничения на ёмкость канала. Приложения
не должны полагаться на определённую величину: их нужно разрабатывать так, чтобы
читающий процесс перерабатывал данные как только они появляются, чтобы пишущий
процесс не блокировался.

В Linux до версии 2.6.11, ёмкость канала была равна размеру системной страницы

ioctl(fd, FIONREAD, &nbytes);

Операция FIONREAD отсутствует в стандартах, но имеется во многих реализациях.

Файлы в /proc
В Linux управление количеством памяти каналов осуществляется через следующие
файлы:

/proc/sys/fs/pipe-max-pages (только в Linux 2.6.34)
Верхнее ограничение (в страницах) ёмкости, которое непривилегированный
пользователь (без мандата CAP_SYS_RESOURCE) может задать для канала.

Значение по умолчанию этого ограничения равно 16 кратному размеру ёмкости
канала по умолчанию (смотрите выше); нижнее ограничение равно 2м страницам.

Данный интерфейс удалён в Linux 2.6.35; его заменяет
/proc/sys/fs/pipe-max-size.

/proc/sys/fs/pipe-max-size (начиная с Linux 2.6.35)
Максимальный размер (в байтах) отдельных каналов, который может быть
установлен пользователем без мандата CAP_SYS_RESOURCE. Значение,
записываемое в этот файл, может округлиться в большую сторону, отражая
реальное значение, принятое для удобства реализации. Чтобы определить
увеличенное значение, прочитайте содержимое этого файла после записи
значения.

Значение по умолчанию равно 1048576 (1 МиБ). Минимальное значение равно
размеру системной страницы. При попытке задать меньшее значение вызов
write(2) завершится ошибкой EINVAL.

Начиная с Linux 4.9 значение в данном файле также служит верхним пределом
ёмкости по умолчанию для новых каналов или открываемых FIFO.

/proc/sys/fs/pipe-user-pages-hard (начиная с Linux 4.5)
Жёсткое ограничение на общий размер (в страницах) всех каналов создаваемых
или изменяемых одним непривилегированным пользователем (т. е., без мандата
CAP_SYS_RESOURCE или CAP_SYS_ADMIN). Пока общее количество страниц,
выделенных под буферы каналов для этого пользователя, равно этому
ограничению, попытки создать новые каналы будут отклоняться, также как и
попытки увеличить ёмкость канала.

Если значение этого ограничения равно нулю (по умолчанию), то жёсткое
ограничение не применяется.

/proc/sys/fs/pipe-user-pages-soft (начиная с Linux 4.5)
Мягкое ограничение на общий размер (в страницах) всех каналов создаваемых
или изменяемых одним непривилегированным пользователем (т. е., без мандата
CAP_SYS_RESOURCE или CAP_SYS_ADMIN). Пока общее количество страниц,
выделенных под буферы каналов для этого пользователя, равно этому
ограничению, отдельные каналы, создаваемые пользователем, будут ограничены
одной страницей, а попытки увеличить ёмкость канала будут отклоняться.

Если значение этого ограничения равно нулю, то мягкое ограничение не
применяется. По умолчанию значение в этом файле равно 16384, что позволяет
создать до 1024 каналов с ёмкостью по умолчанию.

4096 байт). Точная семантика зависит от вида блокированности файлового дескриптора
(O_NONBLOCK), есть ли несколько писателей в канала и от n, количества записываемых
байт:

O_NONBLOCK сброшен, n <= PIPE_BUF
Все n байт записываются атомарно; write(2) может заблокироваться, если нет
места для немедленной записи n байт

O_NONBLOCK установлен, n <= PIPE_BUF
Если есть место для записи n байт в канал, то write(2) немедленно
завершается без ошибки, записывая все n байт; в противном случае write(2)
завершается с ошибкой, а errno присваивается значение EAGAIN.

O_NONBLOCK сброшен, n > PIPE_BUF
Запись не атомарна: данные, переданные во write(2), могут чередоваться с
write(2) из других процессов; write(2) блокируется до тех пор, пока не
будут записаны n байт.

O_NONBLOCK установлен, n > PIPE_BUF
Если канала переполнен, то write(2) завершается с ошибкой, а errno
присваивается значение EAGAIN. В противном случае, может быть записано от
1 до n байт (т. е., может произойти «частичная запись»; вызывающий должен
проверить возвращаемое значение write(2), чтобы узнать сколько байт
действительно записано), и эти байты могут чередоваться с данными,
записанными другими процессами.

Флаги состояния открытого файла
К каналу и FIFO из флагов состояния открытого файла применимы только O_NONBLOCK и
O_ASYNC.

Установка флага O_ASYNC для чтения от конца канала проводит к генерации сигнала
(по умолчанию SIGIO) при появлении новых данных в канале. Получатель сигнала
должен быть указан с помощью команды F_SETOWN вызовом fcntl(2). В Linux O_ASYNC
поддерживается для каналов и FIFO только начиная с ядра версии 2.6.

Замечания о переносимости
В некоторых системах (но не в Linux), каналы являются двунаправленными: данные
можно передавать в обоих направлениях между концами канала. Согласно POSIX.1
требуются только однонаправленные каналы. Переносимые приложения не должны
зависеть от семантики двунаправленных каналов.

ДЕФЕКТЫ
До Linux 4.9 имелись дефекты, влияющие на обработку ограничений
pipe-user-pages-soft и pipe-user-pages-hard при операции fcntl(2) F_SETPIPE_SZ по
изменению ёмкости канала:

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

Начиная с Linux 4.9 при проверке ограничения добавляется память, требуемая
под ёмкость нового канала.

(2) Проверки ограничения выполнялись даже, когда ёмкость нового канала была
меньше чем ёмкость существующего канала. Это могло привести к проблемам, если

(а) Выполнялась проверка не превышает ли пользователь ограничение.
(б) Выделялся буфер под новый канал.
(в) Учитывалось новое выделение в ограничениях.

Это приводило к появлению состязательности. Несколько процессов могли пройти
пункт (а) одновременно и затем выделить буферы канала, которое учитывалось
только в шаге (в), что приводило к превышению пользовательского ограничения
размера выделения буферов под канал.

Начиная с Linux 4.9, шаг учёта выполняется до выделения и операция
завершается с ошибкой, если бы было превышение ограничения.

До Linux 4.9, дефекты подобные (1) и (3), также могли происходить, когда ядро
выделяет память под буферы нового канала; то есть, когда вызывается pipe(2) и
когда открывается ранее не открытый FIFO.

СМОТРИТЕ ТАКЖЕ

mkfifo(1), dup(2), fcntl(2), open(2), pipe(2), poll(2), select(2), socketpair(2),
splice(2), stat(2), tee(2), vmsplice(2), mkfifo(3), epoll(7), fifo(7)