pipe

PIPE(7)                  Руководство программиста Linux                  PIPE(7)



ИМЯ
       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, ёмкость канала была равна размеру системной
       страницы (4096 байт на i386). Начиная с Linux 2.6.11, ёмкость канала
       равна 65536 байтам. Начиная с Linux 2.6.35, ёмкость канала по умолчанию
       равна 65536 байтам, но это значение можно определить и изменить с помощью
       вызова fcntl(2) с операциями F_GETPIPE_SZ и F_SETPIPE_SZ. Подробности
       смотрите в fcntl(2).

       Следующая операция ioctl(2), которая может быть применена к файловому
       дескриптору, указывающему на любой конец канала, помещает количество
       непрочитанных байт канала в буфер int, задаваемый последним аргументом
       вызова:

           ioctl(fd, FIONREAD, &nbytes);

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

   PIPE_BUF
       В POSIX.1 указано, что операция write(2) для записи меньше чем PIPE_BUF
       байт должна быть атомарна: выходные данные записываются в канал как
       непрерывная последовательность. Запись более PIPE_BUF байт может быть не
       атомарна: ядро может чередовать данные с данными, записываемыми другими
       процессами. В POSIX.1 требуется, чтобы значение PIPE_BUF было не менее
       512 байт (в Linux, PIPE_BUF равно 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 требуются только однонаправленные каналы. Переносимые
       приложения не должны зависеть от семантики двунаправленных каналов.

СМОТРИТЕ ТАКЖЕ
       mkfifo(1), dup(2), fcntl(2), open(2), pipe(2), poll(2), select(2),
       socketpair(2), splice(2), stat(2), mkfifo(3), epoll(7), fifo(7)



Linux                              2016-03-15                            PIPE(7)