FIFOs
Uma FIFO (first in, first out, ou “primeiro a entrar, primeiro a sair”) também é chamada de named pipe (pipe nomeado). Um pipe anônimo costuma ser suficiente para a comunicação entre processos relacionados, como pai e filho. Quando programas independentes precisam se comunicar, podemos usar uma FIFO, que possui um nome no sistema de arquivos:
Qualquer processo que tenha permissão pode abrir /tmp/my_fifo para leitura ou escrita.
A FIFO não é um arquivo comum. Ela aparece no sistema de arquivos, mas não armazena os dados de forma persistente. Exemplo:
A saída do comando acima será semelhante a prw-rw-r-- 1 lcsgborges lcsgborges 0 Jun 28 13:34 canal. O p no início indica que esse arquivo especial é um pipe. A FIFO funciona como um ponto de encontro: os dados passam por ela, mas não ficam armazenados nela.
Para fazer um teste rápido, execute em um terminal:
O cat fica bloqueado enquanto espera que outro processo escreva. Em outro terminal, execute:
Isso já é IPC (interprocess communication, ou comunicação entre processos): dois processos independentes se comunicaram por meio da FIFO.
Diferença entre pipe e FIFO
Pipe
- É criado com
pipe(). - Não tem nome no sistema de arquivos.
- Normalmente é usado entre processos relacionados, como pai e filho.
- Deixa de existir quando todos os descritores associados a ele são fechados.
FIFO
- É criada com o comando
mkfifoou com a função Cmkfifo(). - Tem nome no sistema de arquivos.
- Pode ser aberta por processos independentes.
- Sua entrada no sistema de arquivos continua existindo até ser removida com
rmouunlink().
Depois que a FIFO é aberta, sua utilização é semelhante à de um pipe anônimo: usamos read(), write() e close().
Criando uma FIFO pelo terminal
mkfifo /tmp/minha_fifo
# Verifica se a FIFO foi criada.
ls -l /tmp/minha_fifo
# Remove a FIFO.
rm /tmp/minha_fifo
Criando uma FIFO em C
A função POSIX usada para criar uma FIFO é mkfifo(). Exemplo:
Aqui vale um detalhe importante sobre a base de um literal numérico em C:
| Prefixo | Base | Valor equivalente a 0666 |
|---|---|---|
| nenhum | decimal | 438 |
0 |
octal | 0666 |
0x ou 0X |
hexadecimal | 0x1B6 |
0b ou 0B (C23 ou extensão GNU) |
binário | 0b110110110 |
Quando passamos 0666, usamos um valor octal para solicitar permissão de leitura e escrita para o proprietário, o grupo e os demais usuários (rw-rw-rw-). A umask do processo pode remover algumas dessas permissões. Por exemplo, com umask 0002, o modo efetivo será 0664 (rw-rw-r--).
Exemplo completo:
#include <stdio.h>
#include <sys/stat.h>
int main(void) {
if (mkfifo("canal", 0666) == -1) {
perror("mkfifo");
return 1;
}
printf("FIFO criada: canal.\n");
return 0;
}
Programa leitor
O programa leitor.c cria a FIFO, caso ela ainda não exista, e lê os dados recebidos:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
int main(void) {
const char *fifo_path = "canal";
if (mkfifo(fifo_path, 0666) == -1 && errno != EEXIST) {
perror("mkfifo");
return 1;
}
printf("Leitor: aguardando escritor...\n");
fflush(stdout);
int fd = open(fifo_path, O_RDONLY);
if (fd == -1) {
perror("open");
return 1;
}
printf("Leitor: escritor conectado.\n");
fflush(stdout);
char buffer[128];
ssize_t n;
while ((n = read(fd, buffer, sizeof(buffer))) > 0) {
size_t total = 0;
while (total < (size_t)n) {
ssize_t written = write(
STDOUT_FILENO,
buffer + total,
(size_t)n - total
);
if (written == -1) {
perror("write");
close(fd);
return 1;
}
total += (size_t)written;
}
}
if (n == -1) {
perror("read");
close(fd);
return 1;
} else {
printf("\nLeitor: escritor fechou a FIFO.\n");
}
close(fd);
return 0;
}
Programa escritor
O programa escritor.c também tenta criar a FIFO. Assim, qualquer um dos dois programas pode ser iniciado primeiro:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <errno.h>
int main(void) {
const char *fifo_path = "canal";
if (mkfifo(fifo_path, 0666) == -1 && errno != EEXIST) {
perror("mkfifo");
return 1;
}
printf("Escritor: aguardando leitor...\n");
fflush(stdout);
int fd = open(fifo_path, O_WRONLY);
if (fd == -1) {
perror("open");
return 1;
}
printf("Escritor: leitor conectado.\n");
const char *msg = "Mensagem enviada pela FIFO.\n";
if (write(fd, msg, strlen(msg)) == -1) {
perror("write");
close(fd);
return 1;
}
close(fd);
return 0;
}
Os exemplos tratam EEXIST como indicação de que a FIFO já foi criada. Em código de produção, devemos verificar com lstat() e S_ISFIFO() se o caminho existente realmente representa uma FIFO antes de abri-lo, principalmente em diretórios compartilhados como /tmp.
Comportamento de bloqueio
Por padrão, abrir uma FIFO somente para leitura com open("canal", O_RDONLY) bloqueia a execução até que um escritor a abra. Da mesma forma, open("canal", O_WRONLY) bloqueia a execução até que um leitor abra a FIFO. Com a opção O_NONBLOCK, a abertura para leitura retorna imediatamente, mesmo sem escritores, enquanto a abertura para escrita falha com ENXIO quando não há leitores.
Exemplo real: servidor de comandos por FIFO
// servidor_fifo.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
#include <errno.h>
int main(void) {
const char *fifo_path = "/tmp/app_comandos";
if (mkfifo(fifo_path, 0666) == -1 && errno != EEXIST) {
perror("mkfifo");
return 1;
}
printf("Servidor iniciado. FIFO: %s.\n", fifo_path);
printf("Envie comandos com: echo status > %s\n", fifo_path);
while (1) {
FILE *fifo = fopen(fifo_path, "r");
if (fifo == NULL) {
perror("fopen");
return 1;
}
char buffer[128];
while (fgets(buffer, sizeof(buffer), fifo) != NULL) {
buffer[strcspn(buffer, "\n")] = '\0';
if (strcmp(buffer, "status") == 0) {
printf("STATUS: servidor rodando.\n");
} else if (strcmp(buffer, "reload") == 0) {
printf("RELOAD: recarregando configuração.\n");
} else if (strcmp(buffer, "stop") == 0) {
printf("STOP: encerrando servidor.\n");
fclose(fifo);
unlink(fifo_path);
return 0;
} else {
printf("Comando desconhecido: %s.\n", buffer);
}
}
fclose(fifo);
}
}
Uma FIFO normalmente é usada como um canal unidirecional. Para uma comunicação bidirecional, podemos usar duas FIFOs, uma para cada direção, ou um soquete de domínio Unix (Unix domain socket).
Quando usar FIFO
Use uma FIFO quando:
- Os processos estão na mesma máquina.
- A comunicação é simples.
- Os processos não são pai e filho.
- A comunicação consiste basicamente em texto ou em um fluxo simples de bytes.
- Queremos testar IPC facilmente pelo terminal.
Bons exemplos de uso:
- Um canal local de comandos.
- Um script que envia comandos a um serviço simples.
- Um pipeline manual entre processos independentes.
- A transmissão de logs ou eventos simples.
- Um protótipo de IPC.
Não use uma FIFO quando:
- A aplicação exige comunicação bidirecional complexa.
- É necessária uma autenticação forte.
- É necessário coordenar vários clientes.
- A comunicação precisa ocorrer pela rede.
- A aplicação exige mensagens estruturadas com respostas.
Em resumo, uma FIFO é útil quando processos independentes precisam trocar dados simples na mesma máquina usando um canal identificado por um nome conhecido no sistema de arquivos.