← Comunicación entre ProcesosBloque 4 · Tuberías con nombre: FIFO · Tema 16 de 52

Tema 16

Crear y abrir una FIFO con mkfifo

Una tubería con nombre permite que dos programas encuentren un canal mediante una ruta, sin heredar sus extremos de un padre común. Vas a crear ese punto de encuentro, controlar sus permisos y abrirlo desde procesos independientes. También distinguirás la vida del nombre en el sistema de archivos de la vida del flujo que transporta los datos.

1. Un punto de encuentro para procesos independientes

En el bloque anterior creamos canales con pipe y repartimos sus descriptores mediante fork. Ese mecanismo funciona cuando los procesos pueden heredar referencias de un antecesor que preparó la conexión.

Ahora imagina un receptor iniciado en una terminal y un emisor ejecutado después desde otra. Queremos que ambos encuentren el mismo canal usando un nombre acordado. Una FIFO, también llamada tubería con nombre, proporciona ese punto de encuentro.

Una FIFO es un archivo especial que permite abrir una tubería mediante una ruta. Su nombre pertenece al sistema de archivos; los bytes intercambiados se mantienen en el canal del núcleo y no se guardan como contenido de un archivo regular.

Los procesos necesitan ver la misma FIFO y tener permisos para abrirla. No basta con escribir rutas de igual texto si cada proceso ve un sistema de archivos distinto, como puede ocurrir con contenedores o espacios de nombres separados.

El nombre no identifica automáticamente a un interlocutor concreto. Cualquier proceso con acceso apropiado podría abrirlo. En este tema trabajaremos con un emisor y un receptor bajo el mismo usuario.

2. Tubería anónima, FIFO y archivo regular

PropiedadTubería anónimaFIFOArchivo regular
Creación habitual.pipe devuelve dos descriptores.mkfifo crea una entrada; open obtiene descriptores.open puede crear y abrir contenido persistente.
Cómo se encuentra.Por referencias heredadas o transmitidas.Por una ruta y sus permisos.Por una ruta y sus permisos.
Contenido.Flujo temporal de bytes.Flujo temporal de bytes.Datos almacenados en el archivo.
Acceso aleatorio.No.No; lseek no permite retroceder en el flujo.Habitualmente sí.
Encuentro de lector y escritor.Los extremos existen al crear el canal.La apertura bloqueante puede esperar al extremo complementario.Abrirlo no exige otro proceso conectado.
Qué queda al cerrar todo.El canal deja de estar referenciado.El nombre puede seguir existiendo, sin conservar los bytes del intercambio.El contenido puede seguir disponible.

La semejanza con un archivo regular termina en la interfaz de ruta y descriptores. Una FIFO no sirve como registro durable ni como buzón que acumule datos indefinidamente cuando no hay receptor.

3. Crear el nombre con mkfifo

interfaz POSIX · declarada en sys/stat.h
int mkfifo(const char *ruta, mode_t modo);

if (mkfifo(ruta, 0600) == -1) {
    perror("mkfifo");
    /* No suponer que se creo una FIFO nueva. */
}

mkfifo devuelve cero al crear la entrada y −1 al fallar, dejando la causa en errno. No retorna un descriptor, no crea procesos y no espera a que aparezca un lector. Para usar el canal se necesita un open posterior.

El modo especifica permisos, no el tipo de archivo: la propia operación crea una FIFO. Los números de permisos se escriben con cero inicial en C porque son valores octales. La interfaz y sus errores están documentados en mkfifo(3).

Error habitualQué revisar
EEXIST.Ya hay una entrada con ese nombre; podría ser otro tipo de archivo.
ENOENT.Falta algún directorio de la ruta.
EACCES.Faltan permisos para recorrer la ruta o crear una entrada en el directorio.
ENOTDIR.Un componente que debía ser directorio no lo es.
EROFS.El sistema de archivos está montado como solo lectura.

La orden de terminal mkfifo ruta permite crear el mismo tipo de objeto sin escribir C. Usaremos tanto la orden como la función para relacionar el estado del sistema con las llamadas del programa.

4. Permisos, umask y directorio contenedor

Los permisos de lectura permiten abrir el extremo lector; los de escritura, el escritor. El bit de ejecución de la FIFO no la convierte en un programa. En los directorios de la ruta, el permiso de búsqueda permite alcanzar la entrada.

En el caso habitual sin una ACL predeterminada en el directorio, los permisos iniciales resultan de modo & ~umask. Por ejemplo, solicitar 0660 con umask 0027 produce 0640. Las ACL predeterminadas pueden modificar esta regla de creación, como explica umask(2).

Bash · observar los permisos en un directorio de práctica
$ (umask 027; mkfifo permisos16.fifo)
$ ls -l permisos16.fifo
prw-r----- ... permisos16.fifo

La orden mkfifo sin -m solicita normalmente 0666, que con esa máscara también produce 0640. El subshell entre paréntesis limita el cambio de umask a ese ejemplo. Comprueba el resultado real con ls o stat.

El laboratorio principal solicitará 0600 y usará un directorio privado creado con mktemp -d. El emisor y el receptor deben ejecutarse bajo el mismo usuario; una máscara más restrictiva aún puede retirar permisos solicitados.

El directorio importa tanto como la FIFO: quien puede modificar sus entradas puede retirar o reemplazar el nombre. No soluciones un error de acceso concediendo permisos universales sin definir primero qué procesos deben participar.

5. Decidir qué hacer si la ruta ya existe

Ignorar cualquier EEXIST es un error: la ruta podría señalar a un archivo regular, un directorio o un enlace simbólico. Abrir después un supuesto canal podría terminar leyendo o escribiendo un recurso distinto.

fragmento · inspeccionar la entrada sin seguir un enlace simbólico
struct stat estado;
if (lstat(ruta, &estado) == -1) {
    perror("lstat");
} else if (!S_ISFIFO(estado.st_mode)) {
    fprintf(stderr, "La entrada no es una FIFO\n");
}

lstat describe la entrada final sin seguirla si es un enlace; fstat describe el recurso que ya se abrió. Sus diferencias se documentan en stat(2).

El creador de este tema rechazará toda ruta existente. El programa de transferencia exigirá una FIFO previamente creada y verificará su tipo antes y después de abrirla. No borrará una entrada ajena para resolver el conflicto.

Comprobar con lstat y abrir después son dos operaciones: otra parte podría cambiar la ruta entre ambas. El programa añade O_NOFOLLOW y compara dispositivo e inode tras abrir, pero eso no vuelve atómica toda la secuencia ni evita cualquier espera sobre un objeto reemplazado. Su entorno de uso es un directorio privado que no modifican otros participantes durante la apertura.

6. Abrir los extremos y esperar al interlocutor

fragmentos · apertura bloqueante en procesos distintos
/* Receptor */
int entrada = open(ruta, O_RDONLY);

/* Emisor */
int salida = open(ruta, O_WRONLY);

Al abrir para lectura sin escritor disponible, open puede esperar a un escritor. Al abrir para escritura sin lector disponible, espera a un lector. El primer programa puede estar detenido dentro de open, sin haber llegado todavía a read o write. El encuentro no depende de cuál terminal se inició primero.

Cuando ambos extremos se encuentran, cada proceso obtiene su descriptor y puede comenzar la transferencia. La devolución de open no confirma que el otro vaya a seguir conectado ni que haya recibido datos. Las reglas de apertura se describen en fifo(7).

El emisor abre con O_WRONLY, sin O_CREAT ni O_TRUNC. La FIFO ya debe existir; no queremos crear accidentalmente un archivo regular si falta. O_CLOEXEC evita heredar el descriptor si más adelante el programa ejecuta otro binario. Las opciones pertenecen a open(2).

No se utiliza O_RDWR para evitar la espera. Linux permite abrir así una FIFO, pero POSIX no define ese comportamiento; además, el propio proceso sostendría ambos extremos y alteraría la detección de EOF o de ausencia de lectores. El tema 17 estudiará O_NONBLOCK y sus resultados específicos.

7. Laboratorio: preparar una FIFO privada

Este primer programa solo crea el nombre. No lo abre ni lo elimina al terminar, porque los otros programas necesitan encontrarlo después. Rechaza una ruta existente y deja que el propietario del laboratorio decida cuándo retirarla.

crear_fifo.c · crear no significa conectar
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "Uso: %s ruta_fifo\n", argv[0]);
        return EXIT_FAILURE;
    }
    if (mkfifo(argv[1], 0600) == -1) {
        perror("mkfifo");
        return EXIT_FAILURE;
    }
    printf("FIFO creada: %s\n", argv[1]);
    return EXIT_SUCCESS;
}
Bash en Linux o WSL · preparar y registrar la ruta absoluta
$ gcc -std=c17 -Wall -Wextra -Wpedantic crear_fifo.c -o crear_fifo
$ directorio=$(mktemp -d "$HOME/fifo16.XXXXXX")
$ canal="$directorio/canal"
$ ./crear_fifo "$canal"
FIFO creada: /home/usuario/fifo16.ABC123/canal
$ ls -l "$canal"
prw------- ... /home/usuario/fifo16.ABC123/canal
$ printf '%s\n' "$canal"
/home/usuario/fifo16.ABC123/canal

La ruta mostrada es ilustrativa: conserva la que imprimió tu equipo. La letra inicial p de ls identifica el tipo FIFO. Una salida de tamaño cero no significa que un emisor no pueda tener bytes pendientes; el tamaño del archivo especial no mide la ocupación del canal.

Usa el sistema de archivos Linux de WSL, como tu directorio personal. Un sistema de archivos montado desde Windows puede no ofrecer las mismas operaciones para archivos especiales.

8. Programa: enviar y recibir desde procesos separados

El siguiente programa tiene dos modos. enviar copia stdin hacia la FIFO; recibir copia la FIFO hacia stdout. Cada invocación es un proceso independiente: no contiene fork ni comparte variables con la otra.

Se transportan bytes sin suponer cadenas ni líneas. El bucle conserva el progreso de escrituras parciales y reintenta EINTR. SIGPIPE se ignora para tratar la desaparición del lector como EPIPE y poder cerrar el descriptor.

fifo_transferir.c · un ejecutable, dos roles independientes
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

static int escribir_todo(int fd, const unsigned char *datos, size_t cantidad)
{
    size_t enviados = 0;
    while (enviados < cantidad) {
        ssize_t n = write(fd, datos + enviados, cantidad - enviados);
        if (n > 0)
            enviados += (size_t)n;
        else if (n == -1 && errno == EINTR)
            continue;
        else {
            if (n == 0)
                errno = EIO;
            return -1;
        }
    }
    return 0;
}

static int copiar(int origen, int destino)
{
    unsigned char bloque[4096];
    for (;;) {
        ssize_t n = read(origen, bloque, sizeof bloque);
        if (n > 0) {
            if (escribir_todo(destino, bloque, (size_t)n) == -1)
                return -1;
        } else if (n == 0)
            return 0;
        else if (errno != EINTR)
            return -1;
    }
}

static int abrir_fifo(const char *ruta, int modo)
{
    struct stat antes, despues;
    if (lstat(ruta, &antes) == -1)
        return -1;
    if (!S_ISFIFO(antes.st_mode)) {
        errno = EINVAL;
        return -1;
    }
    int fd;
    do {
        fd = open(ruta, modo | O_NOFOLLOW | O_CLOEXEC);
    } while (fd == -1 && errno == EINTR);
    if (fd == -1)
        return -1;
    int causa = 0;
    if (fstat(fd, &despues) == -1)
        causa = errno;
    else if (!S_ISFIFO(despues.st_mode) || antes.st_dev != despues.st_dev ||
             antes.st_ino != despues.st_ino)
        causa = EINVAL;
    if (causa != 0) {
        close(fd);
        errno = causa;
        return -1;
    }
    return fd;
}

int main(int argc, char *argv[])
{
    if (argc != 3 || (strcmp(argv[1], "enviar") != 0 &&
                      strcmp(argv[1], "recibir") != 0)) {
        fprintf(stderr, "Uso: %s enviar|recibir ruta_fifo\n", argv[0]);
        return EXIT_FAILURE;
    }
    for (int fd = 0; fd <= 2; ++fd) {
        if (fcntl(fd, F_GETFD) == -1) {
            perror("Se requieren 0, 1 y 2 abiertos");
            return EXIT_FAILURE;
        }
    }
    struct sigaction accion = {0};
    accion.sa_handler = SIG_IGN;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGPIPE, &accion, NULL) == -1) {
        perror("preparar SIGPIPE");
        return EXIT_FAILURE;
    }
    int enviar = strcmp(argv[1], "enviar") == 0;
    fprintf(stderr, "%s: abriendo FIFO; puede esperar al otro extremo\n",
            enviar ? "Emisor" : "Receptor");
    int fd = abrir_fifo(argv[2], enviar ? O_WRONLY : O_RDONLY);
    if (fd == -1) {
        perror("abrir FIFO (ruta existente y tipo FIFO requeridos)");
        return EXIT_FAILURE;
    }
    fprintf(stderr, "%s: FIFO abierta\n", enviar ? "Emisor" : "Receptor");
    int resultado = EXIT_SUCCESS;
    if (copiar(enviar ? STDIN_FILENO : fd,
               enviar ? fd : STDOUT_FILENO) == -1) {
        perror("copiar");
        resultado = EXIT_FAILURE;
    }
    if (close(fd) == -1) {
        perror("close FIFO");
        resultado = EXIT_FAILURE;
    }
    return resultado;
}

El mensaje «abriendo FIFO» aparece antes de open; «FIFO abierta» confirma que esa llamada terminó. Ambos van a stderr. El receptor devuelve solo el contenido por stdout, lo que permite redirigirlo a un archivo para verificarlo.

La validación del descriptor no cambia los permisos ni crea el nombre. Si falla el acceso, se informa el error y termina. El modo de uso supone que la FIFO permanece estable en el directorio privado durante el encuentro.

9. Ejecutar el intercambio en dos terminales

Compila fifo_transferir y usa la ruta real creada en el paso anterior. Ambos terminales deben ejecutar el binario desde su directorio o mediante una ruta absoluta.

Bash · compilar una vez
$ gcc -std=c17 -Wall -Wextra -Wpedantic fifo_transferir.c -o fifo_transferir
terminal A · receptor, conservando la variable canal del laboratorio
$ ./fifo_transferir recibir "$canal"
Receptor: abriendo FIFO; puede esperar al otro extremo
... espera al emisor ...
terminal B · sustituir la ruta de ejemplo por la ruta real de A
$ canal='/home/usuario/fifo16.ABC123/canal'
$ printf 'hola desde otro proceso\n' | ./fifo_transferir enviar "$canal"
Emisor: abriendo FIFO; puede esperar al otro extremo
Emisor: FIFO abierta

En A aparecerá «Receptor: FIFO abierta», seguido del texto recibido. Cuando printf termina, el emisor obtiene EOF de su stdin, cierra su escritor y sale. El receptor consume lo pendiente y obtiene EOF del canal, por lo que también termina.

Repite invirtiendo el orden: inicia primero B y luego A. El emisor puede esperar dentro de open; todavía no ha empezado a copiar desde stdin. Ninguno necesita conocer el PID del otro.

También puedes usar herramientas de terminal sobre la misma FIFO: cat "$canal" en A y printf 'prueba\n' > "$canal" en B. En el segundo caso, la shell realiza la apertura para la redirección antes de ejecutar printf.

10. Probar bytes cero, entrada vacía y datos grandes

Las siguientes pruebas arrancan el receptor en segundo plano desde Bash para facilitar la repetición. Ejecuta cada emisor antes de esperar al receptor: si haces wait demasiado pronto, este podría seguir esperando su apertura complementaria.

Bash · preservar un byte cero dentro del flujo
$ ./fifo_transferir recibir "$canal" > recibido16.bin &
$ receptor=$!
$ printf 'A\000B\n' | ./fifo_transferir enviar "$canal"
$ wait "$receptor"
$ od -An -t x1 recibido16.bin
 41 00 42 0a
Bash · abrir y cerrar un escritor sin enviar contenido
$ ./fifo_transferir recibir "$canal" > vacio16.bin &
$ receptor=$!
$ ./fifo_transferir enviar "$canal" < /dev/null
$ wait "$receptor"
$ wc -c < vacio16.bin
0

La apertura se encuentra con la del receptor aunque no haya contenido. Después, el cierre del único escritor permite EOF. No es lo mismo que no iniciar nunca el emisor: en ese caso el receptor bloqueante puede seguir detenido en open.

Bash · superar la capacidad del canal y comparar todos los bytes
$ head -c 1048576 /dev/urandom > origen16.bin
$ ./fifo_transferir recibir "$canal" > destino16.bin &
$ receptor=$!
$ ./fifo_transferir enviar "$canal" < origen16.bin
$ wait "$receptor"
$ cmp origen16.bin destino16.bin
$ echo $?
0

Los mensajes de apertura siguen visibles por stderr y no contaminan los archivos. No se exige que el MiB completo quepa en la FIFO: el lector libera espacio mientras el emisor avanza.

Prueba además una ruta inexistente y un archivo regular en lugar del canal. El programa debe rechazar ambos sin crear la ruta ausente ni modificar el archivo regular. Volver a ejecutar crear_fifo sobre la FIFO existente debe informar EEXIST y conservarla.

11. Flujo compartido y límites de mensaje

Una FIFO sigue siendo un flujo de bytes: no conserva fronteras de mensajes para read. Una lectura puede devolver parte de una escritura o agrupar contenido de varias. El orden FIFO no equivale a «una llamada, un mensaje».

Si hay varios lectores sobre el mismo canal, compiten por el contenido; no recibe cada uno una copia. Si hay varios escritores, sus bytes alimentan el mismo flujo. Para difundir mensajes o distinguir clientes se necesita diseñar un protocolo distinto.

La garantía de PIPE_BUF evita que escrituras suficientemente pequeñas se entremezclen con otras, bajo las condiciones estudiadas en el tema 12. No permite asumir que una cabecera y un cuerpo enviados en llamadas separadas forman una unidad atómica.

El programa de transferencia usa un solo escritor y un solo lector. Su bucle escribir_todo conserva progreso, pero no sirve por sí solo como protocolo de registros para varios productores. En el tema 18 se diseñarán peticiones acotadas y canales de respuesta por cliente.

12. close, unlink y vida del canal

Operación o situaciónQué cambiaQué no debes suponer
mkfifo.Crea una entrada del sistema de archivos.No devuelve extremos abiertos.
open.Obtiene un descriptor y puede esperar el encuentro.No crea por sí solo el nombre en nuestro programa.
close.Libera una referencia del proceso.No elimina el nombre de la FIFO.
unlink.Retira un nombre de la entrada.No cierra los descriptores que ya estaban abiertos.
Todos los extremos cerrados.Termina la vida del flujo abierto sin conservar su contenido para una sesión posterior.La entrada puede seguir existiendo y abrirse de nuevo.

Si retiras el nombre mientras emisor y receptor ya están conectados, pueden continuar por sus descriptores abiertos. Un proceso nuevo no podrá encontrar esa entrada por la ruta retirada. La relación entre nombres y referencias se describe en unlink(2).

Si se vuelve a crear una FIFO bajo la misma ruta antes de cerrar los descriptores antiguos, será un objeto distinto. Los procesos viejos pueden seguir conectados al canal anterior y los nuevos abrir el recién creado. Una cadena de texto igual no garantiza que todos estén usando la misma generación del canal.

Por eso el propietario del laboratorio retira el nombre después de que ambos programas hayan terminado. Los programas de transferencia no ejecutan unlink: cada invocación desconoce si alguien más todavía necesita abrirlo.

Bash · limpieza al finalizar todos los intercambios del laboratorio
$ rm -- "$canal"
$ rmdir -- "$directorio"

Ejecuta estos pasos en la terminal que conserva directorio y canal del laboratorio. rmdir exige que el directorio esté vacío. Si los programas terminaron por una señal antes de la limpieza, la FIFO puede quedar presente: no hay eliminación automática por salir de un proceso.

13. Explorar creación, apertura y EOF

Elige qué extremo intenta abrir primero. Avanza por una sesión con un emisor y un receptor. Después del encuentro puedes retirar el nombre para comprobar que eso no equivale a cerrar sus descriptores. El modelo no representa reconexiones, que se estudiarán en el tema 17.

Nombre en el directorioTodavía no existe

ReceptorSin descriptor

EmisorSin descriptor

Bytes pendientes0

Crea la FIFO para comenzar.

Compara «el escritor cerró, pero quedan datos» con «no quedan datos ni escritores». El receptor primero consume lo pendiente y solo después observa EOF. Si el nombre permanece al terminar, eso no significa que los bytes sigan guardados.

14. Diagnosticar rutas, permisos y esperas

Bash · inspeccionar y seguir una apertura bloqueante
$ stat "$canal"
$ strace -o receptor16.log ./fifo_transferir recibir "$canal"
... inicia el emisor desde otra terminal para completar el encuentro ...
$ less receptor16.log

Busca la inspección de tipo, la apertura, read y close. Según la biblioteca, open puede aparecer como openat, lstat como newfstatat y mkfifo como mknodat. No confundas una llamada de apertura todavía pendiente con una lectura que ya está esperando datos.

SíntomaQué comprobar
El receptor muestra solo «abriendo FIFO».Falta un escritor que abra el mismo objeto; puede estar esperando en open.
El emisor no llega a «FIFO abierta».No hay apertura lectora complementaria sobre esa FIFO.
mkfifo informa EEXIST.Inspecciona la entrada; no la borres suponiendo que es un residuo propio.
open informa EACCES.Permisos del canal, búsqueda en directorios y usuario efectivo de cada proceso.
Un programa informa ENOENT.Ruta absoluta, variable canal, directorios existentes y posibles unlink.
Se rechaza la ruta con EINVAL.Tipo no FIFO o recurso distinto al inspeccionado antes de open.
El receptor no termina después del emisor.Puede quedar otra referencia escritora abierta en algún proceso.
write informa EPIPE.Desaparecieron todos los lectores; el programa ignora SIGPIPE para tratar el fallo.
La ruta existe, pero los procesos no se encuentran.Podrían ver objetos distintos por recreación del nombre o por sistemas de archivos diferentes.

Si el canal está abierto, la semántica de lectura y escritura coincide en lo esencial con la de las tuberías anónimas: capacidad finita, contrapresión, EOF y pérdida del lector. Las condiciones del flujo se documentan en pipe(7).

15. Resumen

16. Preguntas de repaso y práctica

Responde antes de desplegar las explicaciones.

1. ¿mkfifo devuelve un descriptor?

No. Retorna cero o −1 y crea una entrada en el sistema de archivos. Para obtener un descriptor se llama a open.

2. ¿Por qué dos procesos independientes pueden usar la misma FIFO?

Porque la abren por una ruta que identifica el mismo objeto visible para ambos y cuyos permisos permiten el acceso. No necesitan heredar los extremos del canal.

3. ¿La FIFO guarda los bytes como un archivo regular?

No. Los datos circulan por el canal del núcleo; la entrada del directorio proporciona un nombre y no almacenamiento durable del contenido.

4. ¿EEXIST permite continuar sin más?

No. La entrada existente puede tener otro tipo o pertenecer a otro uso. El creador del laboratorio la rechaza y no la reemplaza.

5. ¿Qué ocurre si el lector bloqueante se inicia primero?

Puede esperar dentro de open hasta que aparezca un escritor complementario. Todavía no está necesariamente ejecutando read.

6. ¿Por qué el emisor no utiliza O_CREAT?

Porque la FIFO debe haber sido creada previamente. Si faltara y se usara O_CREAT, se podría crear un archivo regular en lugar del canal esperado.

7. ¿Qué permisos deja 0660 con umask 0027 en el caso habitual sin ACL predeterminada?

0640: la máscara retira la escritura del grupo y los permisos de otros. La fórmula es modo & ~umask.

8. ¿Un byte cero termina la recepción?

No. Es contenido y se cuenta en el retorno positivo de read. EOF es el retorno cero de una lectura de tamaño positivo bajo las condiciones del flujo.

9. ¿Dos lectores reciben una copia del mismo contenido?

No. Consumen del flujo compartido. Una FIFO no implementa difusión a cada lector.

10. ¿unlink interrumpe un intercambio ya conectado?

No por sí solo. Retira el nombre, pero las referencias abiertas pueden continuar utilizando el objeto anterior.

11. ¿Recrear el mismo nombre reconecta a los procesos antiguos?

No. Los descriptores antiguos siguen asociados a su objeto; la nueva entrada identifica otra FIFO.

12. ¿Por qué los programas no eliminan el canal automáticamente?

Porque cada transferencia desconoce si otro proceso todavía necesita abrirlo. El propietario del laboratorio realiza la retirada al finalizar el uso.

Para practicar

  1. Crea la FIFO en un directorio privado y observa su tipo y permisos con ls y stat. Distingue nombre, inode y descriptor.
  2. Ejecuta el intercambio comenzando por el lector y luego por el escritor. Identifica en qué open espera el primero.
  3. Transfiere un byte cero, una entrada vacía y un archivo binario grande. Verifica todo el contenido con cmp.
  4. Prueba crear dos veces la misma ruta y verifica que el objeto original se conserva.
  5. Pasa un archivo regular y un enlace simbólico al programa de transferencia. Comprueba que los rechaza sin modificar su contenido.
  6. Compara los permisos creados bajo dos máscaras en un directorio sin ACL predeterminada. Restaura el entorno usando subshells.
  7. Usa strace para distinguir una apertura pendiente de una lectura pendiente. Inicia el interlocutor desde otra terminal.
  8. Dibuja qué ocurre al retirar el nombre durante una conexión y recrearlo antes de cerrar los extremos antiguos.
Próximo paso

El tema 17 estudiará el bloqueo y la E/S no bloqueante en FIFO: O_NONBLOCK, ENXIO, EAGAIN, EOF y la reconexión de lectores y escritores.