Процессы в Linux изолированы друг от друга адресными пространствами, и ядро отсекает прямой доступ к чужой памяти ещё на уровне таблиц страниц. Когда двум программам всё же нужен обмен, в дело вступают механизмы IPC. Каналы, очереди сообщений, разделяемая память и семафоры решают одну задачу по-разному, различаясь интерфейсом, лимитами ядра и ценой одного обмена. Решение, принятое без понимания внутреннего устройства, потом оборачивается переделками и загадочными блокировками под нагрузкой. Ниже разбираются основные интерфейсы на уровне системных вызовов, показывается, где читать и как менять лимиты ядра, и формулируются правила выбора механизма под конкретный сервис.

Каналы и именованные FIFO для передачи потоков байтов

Канал, создаваемый системным вызовом pipe(), это пара файловых дескрипторов: один предназначен только для чтения, второй только для записи. Байты проходят через кольцевой буфер в памяти ядра, поэтому поток получается непрерывным, без границ между отдельными записями. Видеть канал могут лишь процесс-создатель и его потомки после fork(), что превращает pipe() в типовой способ связать родителя с детьми, ровно так работают конвейеры оболочки вида grep | sort | uniq.

#include <unistd.h>

int fd[2];
if (pipe(fd) == -1) {
    perror("pipe");
    return 1;
}
pid_t pid = fork();
if (pid == 0) {
    close(fd[1]);               /* the child reads */
    char buf[64];
    ssize_t n = read(fd[0], buf, sizeof(buf) - 1);
    if (n > 0) {
        buf[n] = '\0';
    }
} else {
    close(fd[0]);               /* the parent writes */
    write(fd[1], "ping\n", 5);
}

Вызов pipe2(), добавленный в ядре 2.6.27, принимает флаги и открывает оба дескриптора сразу с O_CLOEXEC или O_NONBLOCK. В многопоточном процессе это закрывает окно гонки между pipe() и последующим fcntl(), через которое дескриптор успевает утечь в параллельную нить перед exec().

Ёмкость канала по умолчанию равна 64 КиБ, то есть шестнадцати страницам памяти. Запись блокируется, пока буфер полон, чтение, пока он пуст. Текущий размер возвращает fcntl() с командой F_GETPIPE_SZ, а команда F_SETPIPE_SZ меняет его в пределах потолка из файла /proc/sys/fs/pipe-max-size. Атомарность гарантируется только для порций не длиннее PIPE_BUF, то есть 4096 байт: более крупные записи от нескольких процессов способны перемешаться в буфере, и протокол поверх канала обязан это учитывать.

Закрывший свой конец записи процесс приносит читателю признак конца файла, а попытка писать в канал без читателей завершается сигналом SIGPIPE, который по умолчанию убивает процесс, поэтому в серверном коде его обычно игнорируют и разбирают ошибку EPIPE вручную.

Когда родства между процессами нет, выручает именованный канал, создаваемый mkfifo():

mkfifo /tmp/events
wc -l < /tmp/events

FIFO выглядит в дереве каталогов специальным файлом и открывается обычным open(), поэтому связывает совершенно незнакомые процессы: один пишет, другой читает. Открытие на чтение или на запись блокируется до появления пары с противоположной стороны, и эта блокировка сама по себе служит точкой синхронизации запуска.

Очереди сообщений System V и их POSIX аналог

Очереди сообщений хранят в ядре дискретные записи, а не сплошной поток байтов: каждая запись несёт числовой тип и полезную нагрузку. Семейство System V опирается на четыре вызова: msgget() создаёт или находит очередь по ключу, msgsnd() ставит сообщение в конец, msgrcv() извлекает его, причём выборочно по типу, msgctl() управляет очередью вплоть до удаления.

Ключ обычно вычисляет ftok() из пути к существующему файлу и номера проекта: независимые процессы получают одинаковый ключ и находят один и тот же объект.

struct msgbuf {
    long mtype;
    char mtext[256];
};

key_t key = ftok("/var/run/app", 42);
int qid = msgget(key, IPC_CREAT | 0660);
struct msgbuf m = { .mtype = 1 };
strcpy(m.mtext, "task");
msgsnd(qid, &m, strlen(m.mtext) + 1, 0);

Поле mtype даёт главную гибкость: получатель указывает в msgrcv() желаемый тип и забирает записи выборочно. На одной очереди так строят несколько логических каналов или модель приоритетов, когда диспетчер пишет задачи с типом 1 для быстрых обработчиков и с типом 2 для медленных. По умолчанию вызовы блокируются, флаг IPC_NOWAIT переводит их в неблокирующий режим, а MSG_NOERROR разрешает молча обрезать сообщение, не влезающее в буфер получателя.

Лимиты интерфейса лежат в /proc/sys/kernel: msgmax ограничивает размер одного сообщения, msgmnb задаёт суммарный объём одной очереди, msgmni определяет число очередей в системе. Значения по умолчанию скромные, порядка 8 КиБ на сообщение и 16 КиБ на очередь, поэтому переполненная очередь просто блокирует отправителя. В нагруженных сервисах лимиты поднимают через sysctl либо уходят на POSIX-вариант.

POSIX-очереди создаются вызовом mq_open() с именем вроде "/events", поддерживают приоритеты прямо в аргументах mq_send() и mq_receive() и умеют асинхронно уведомлять через mq_notify() о появлении сообщения, сигналом или в отдельной нити.

mqd_t mq = mq_open("/events", O_CREAT | O_RDONLY, 0600, NULL);
struct mq_attr attr;
mq_getattr(mq, &attr);
char buf[attr.mq_msgsize];
unsigned prio;
ssize_t n = mq_receive(mq, buf, attr.mq_msgsize, &prio);

Лимиты лежат в /proc/sys/fs/mqueue: msg_max ограничивает число сообщений в очереди, msgsize_max размер одного сообщения, queues_max число очередей. Компилировать такой код нужно с -lrt, а сами очереди видны файлами в каталоге /dev/mqueue. POSIX-интерфейс моложе и аккуратнее, однако System V до сих пор встречается в унаследованном коде, поэтому администратору приходится знать оба.

Разделяемая память и экономия на копировании данных

Разделяемая память остаётся самым быстрым механизмом обмена: одни и те же страницы физической памяти отображаются в адресные пространства сразу нескольких процессов, и ядро в самом обмене не участвует вовсе. Нет копирования, нет переключений контекста на каждую порцию, нет системных вызовов на чтение и запись, процесс работает с общими страницами так же быстро, как с собственными. Обратная сторона симметрична: синхронизацию доступа процессам приходится устраивать самим, и без семафоров или атомарных операций сегмент превращается в источник гонок.

Классический интерфейс System V начинается с shmget(), создающей сегмент по ключу и флагам. shmat() подключает сегмент к адресному пространству и возвращает указатель, shmdt() отсоединяет, а shmctl() с командой IPC_RMID помечает сегмент к удалению. Реально ядро уничтожит его лишь после отсоединения последнего пользователя, поэтому сегмент переживает смерть создавшего процесса: это удобно при перезапуске служб и коварно при отладке, когда осиротевшие сегменты копятся и съедают лимит shmall.

int shmid = shmget(key, 4096, IPC_CREAT | 0660);
void *addr = shmat(shmid, NULL, 0);
/* the segment is readable and writable here */
shmdt(addr);
shmctl(shmid, IPC_RMID, NULL);

Флаг SHM_RDONLY в shmat() подключает сегмент только на чтение и помогает выстроить модель с одним писателем и многими читателями.

POSIX-вариант ближе к обычной работе с файлами: shm_open() возвращает дескриптор, ftruncate() задаёт размер, mmap() отображает память, shm_unlink() удаляет объект. Объекты живут в tmpfs и видны файлами в каталоге /dev/shm, компилировать нужно с -lrt.

int fd = shm_open("/cache", O_CREAT | O_RDWR, 0600);
ftruncate(fd, 1024 * 1024);
void *p = mmap(NULL, 1024 * 1024, PROT_READ | PROT_WRITE,
               MAP_SHARED, fd, 0);

Для родственных процессов хватает mmap() с флагами MAP_SHARED и MAP_ANONYMOUS, без ключей и идентификаторов вовсе. Современная альтернатива, вызов memfd_create() из ядра 3.17, создаёт анонимный файл в памяти, дескриптор которого передают другому процессу через доменный сокет и отображают там через mmap(): так поступают графические композиторы и гипервизоры, передающие буферы кадров.

Семафоры System V и POSIX для координации доступа

Общая память без синхронизации это гонка на запись: два процесса увеличивают один счётчик, и половина обновлений теряется. Семафоры System V создаются вызовом semget() и работают наборами: один идентификатор держит сразу несколько счётчиков, пронумерованных с нуля. Атомарные операции выполняет semop(), принимающий массив структур sembuf с номером семафора, изменением и флагами.

struct sembuf op = { .sem_num = 0, .sem_op = -1, .sem_flg = SEM_UNDO };
semop(semid, &op, 1);       /* down: 1 -> 0 */
op.sem_op = 1;
semop(semid, &op, 1);       /* up: 0 -> 1 */

Отрицательное значение sem_op вычитает и блокирует процесс, пока счётчик не станет достаточным, положительное добавляет и будит ожидающих, нулевое ждёт обнуления. Флаг SEM_UNDO привязывает изменения к процессу и откатывает их при аварийном завершении, спасая остальных от вечного ожидания. Начальное значение задаёт semctl() с командой SETVAL, той же командой IPC_RMID набор удаляют.

POSIX-семафоры заметно проще: sem_open() для именованных, sem_init() для безымянных, которые размещают прямо в разделяемой памяти рядом с защищаемыми переменными. Пара sem_wait() и sem_post() закрывает критическую секцию, и связка безымянного семафора с общим сегментом mmap() закрывает большинство задач координации внутри одной машины. Когда синхронизация сводится к счётчикам и флагам, легче берут атомарные операции из заголовка stdatomic.h, хотя барьеры памяти там приходится понимать самостоятельно.

Лимиты ядра и настройка через файловую систему proc

У каждого семейства интерфейсов свои системные ограничения, и почти все они читаются прямо из /proc/sys/kernel: msgmax, msgmnb и msgmni для очередей System V, shmmax, shmall и shmmni для разделяемой памяти, параметр sem из четырёх чисел для семафоров. POSIX-очереди настраиваются отдельным деревом /proc/sys/fs/mqueue, а предельная ёмкость каналов лежит в /proc/sys/fs/pipe-max-size.

cat /proc/sys/kernel/shmmax
sysctl -w kernel.msgmnb=262144
sysctl -a | grep -E 'msg|mqueue|shm'

Разовые изменения вносит sysctl -w, постоянные значения добавляют в файл /etc/sysctl.d/*.conf, и они переживают перезагрузку. Значения по умолчанию рассчитаны скорее на настольную машину, и серверу с десятками очередей либо крупными сегментами их приходится поднимать: иначе отправитель упирается в потолок и выглядит зависшим без явных ошибок в журнале.

SysV-объекты живут в отдельном пространстве имён, поэтому в контейнерах лимиты изолируются вместе с ними: оркестраторы и менеджеры контейнеров нередко режут значения по умолчанию. Диагностировать упор в потолок помогает просмотр текущих ограничений внутри самого контейнера, а не только на хосте, иначе поиск причины уводит не туда.

Наблюдение за объектами IPC инструментами ipcs и ipcrm

Утилита ipcs перечисляет все созданные в системе объекты: флаг -q показывает очереди сообщений, -m сегменты разделяемой памяти, -s наборы семафоров, а -l выводит системные лимиты. Вывод содержит ключи, идентификаторы, владельцев, права и объёмы, флаг -p добавляет идентификаторы процессов, создавших объект и выполнивших последнюю операцию, что быстро указывает виновника.

ipcs -m
ipcs -q -i 32768
ipcrm -m 65536
ls /dev/shm

Команда ipcrm удаляет объект по идентификатору или по ключу, и в скриптах очистки это стандартный способ прибрать за упавшими процессами. Те же сведения в машиночитаемом виде лежат в псевдофайлах /proc/sysvipc/msg, shm и sem, что удобно для парсинга без запуска внешних утилит. При трассировке выручает strace с фильтром -e trace=%ipc: он показывает каждый msgget, shmget и semop вместе с аргументами и кодами возврата.

Выбор механизма обмена под конкретную задачу сервиса

Практика сводит выбор к нескольким правилам:

  1. для непрерывного потока байтов без границ между записями подходят каналы и FIFO;
  2. для дискретных сообщений с типами, приоритетами и несколькими независимыми получателями подходят очереди сообщений;
  3. для максимальной пропускной способности и минимальных задержек подходит разделяемая память вместе с семафорами;
  4. для обмена между машинами, передачи дескрипторов и делегирования прав подходят доменные и сетевые сокеты.

Каналы при каждом обмене копируют содержимое дважды, из памяти отправителя в ядро и из ядра к получателю, и платят переключением контекста на каждый системный вызов. Очереди сообщений копируют каждую порцию по одному разу, но хранят её в ядре и расходуют память на очередь целиком. Разделяемая память снимает копирование вовсе, оставляя только синхронизацию, и потому уверенно выигрывает тесты пропускной способности на больших объёмах. Проигрывает она в другом: ошибка синхронизации здесь разрушает общие структуры вместо того, чтобы просто заблокировать процесс, а протокол поверх общего сегмента приходится описывать самостоятельно.

Разумная стратегия начинается с каналов и очередей как самых простых интерфейсов и переходит к разделяемой памяти тогда, когда профилирование действительно показывает упор в пересылку. Сэкономленные на копировании миллисекунды редко оправдывают отладку гонок, зато там, где счёт идёт на микросекунды, альтернативы общей памяти попросту нет.