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

Tema 17

Bloqueo y E/S no bloqueante en FIFO

Abrir una FIFO sin esperar no garantiza que haya un interlocutor, ni que la siguiente operación pueda avanzar. Vas a distinguir ENXIO, EAGAIN, EOF y EPIPE, conservar bytes pendientes y esperar disponibilidad con poll. Después construirás un receptor que mantiene abierto su lector para aceptar nuevos escritores sin confundir un EOF actual con la desaparición definitiva del servicio.

1. Tres preguntas antes de cada operación

En el tema 16 usamos aperturas bloqueantes: el primer participante podía esperar al extremo complementario. Ahora queremos que una llamada retorne cuando no puede avanzar inmediatamente, para que el programa decida qué hacer después.

Separa estas preguntas: ¿pude abrir el extremo?, ¿puedo transferir bytes ahora?, ¿sigue existiendo el interlocutor necesario? Cada una se observa mediante una operación y un resultado diferente.

O_NONBLOCK cambia las reglas de espera; no crea lectores, escritores, espacio ni datos. La aplicación debe conservar su estado y decidir cuándo reintentar, esperar o terminar.

Trabajaremos con una FIFO ya creada y estable dentro de un directorio privado, como en el tema anterior. Las lecturas y escrituras consideradas tienen tamaño positivo; una petición de tamaño cero no sirve para comprobar presencia de datos, EOF o conectividad.

2. Qué cambia al abrir con O_NONBLOCK

AperturaSin extremo complementarioCon extremo complementario disponible
O_RDONLY.Puede esperar un escritor.Puede completar.
O_WRONLY.Puede esperar un lector.Puede completar.
O_RDONLY | O_NONBLOCK.Completa sin exigir un escritor.Completa.
O_WRONLY | O_NONBLOCK.Falla con −1 y ENXIO.Puede completar.

La tabla supone una ruta FIFO válida y permisos suficientes. La apertura también puede fallar por ENOENT, EACCES u otras causas. ENXIO en este contexto significa que no había lector para encontrar al escritor; no es el resultado de un canal lleno.

El lector no bloqueante permite iniciar un servicio antes de que aparezcan clientes. El emisor debe decidir si la ausencia de lectores es un fallo inmediato o una condición transitoria con reintentos limitados. La asimetría de apertura se documenta en fifo(7).

Si open devuelve −1, no existe un descriptor nuevo sobre el que esperar con poll. Para reintentar ENXIO se necesita una política temporal o un mecanismo externo de coordinación.

3. Cambiar el modo con fcntl

fragmento · conservar los flags existentes al activar el modo
int flags = fcntl(fd, F_GETFL);
if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
    perror("fcntl O_NONBLOCK");
    /* Gestionar el fallo. */
}

F_GETFL obtiene flags de estado y F_SETFL permite modificar los que admite la interfaz. No pases únicamente O_NONBLOCK si necesitas conservar los demás. Para retirarlo, usa flags & ~O_NONBLOCK.

Esto no deshace una espera que ya ocurrió: abrir primero con O_WRONLY y activar el flag después no evita que esa apertura se bloquee sin lectores. Cuando la apertura tampoco debe esperar, el flag debe estar en open desde el inicio.

O_NONBLOCK pertenece a la descripción de archivo abierta y se comparte entre referencias duplicadas o heredadas que apuntan a ella. FD_CLOEXEC es otra clase de flag, asociado al descriptor y administrado con F_GETFD/F_SETFD. Las operaciones se resumen en fcntl(2).

4. Lectura: contenido, EAGAIN o EOF

Contenido pendienteEscritores abiertosread bloqueanteread no bloqueante
Sí.Sí o no.Puede devolver bytes.Puede devolver bytes.
No.Sí.Espera contenido o un cambio de estado.−1 con EAGAIN/EWOULDBLOCK.
No.No.0: EOF.0: EOF.

Por eso un lector abierto con O_NONBLOCK puede obtener cero antes de que se conecte el primer escritor. No es EAGAIN: en ese instante no hay productores abiertos ni bytes pendientes.

Cuando el último escritor cierra, los bytes que ya envió se consumen antes de observar EOF. Una lectura puede devolver menos de lo solicitado y seguir siendo correcta. Consulta el contrato de read(2).

En Linux EAGAIN y EWOULDBLOCK tienen el mismo valor, pero el código puede comprobar ambos para expresar la condición de falta temporal de progreso. No reintentes inmediatamente en un bucle ilimitado: espera un evento o aplica una política de reintento.

5. Escritura: espacio, progreso parcial o EPIPE

Una apertura escritora exitosa no reserva la presencia del lector para siempre. Si todos los lectores cierran, una escritura positiva genera SIGPIPE y, cuando esa señal se ignora, puede retornar −1 con EPIPE. Es diferente de ENXIO, que se obtuvo al intentar abrir.

SituaciónResultado relevante con O_NONBLOCKAcción de la aplicación
No quedan lectores.SIGPIPE/EPIPE.Tratar desconexión; esperar espacio no crea un lector.
Petición de hasta PIPE_BUF que no cabe.EAGAIN sin aceptar un prefijo.Conservar la unidad pendiente.
Petición mayor que PIPE_BUF.Puede aceptar solo un prefijo o retornar EAGAIN.Avanzar por los bytes informados y conservar el resto.
Se informa un número positivo.Esos bytes fueron aceptados por el canal.No enviarlos de nuevo.

El programa del proyecto maneja un único escritor y puede fragmentar su contenido libremente. Un protocolo con varios escritores debe respetar además las condiciones de atomicidad estudiadas en el tema 12. El retorno de write sigue siendo la evidencia del progreso, según write(2).

6. Laboratorio: observar los estados sin carreras

Este programa abre y cierra los extremos en un solo proceso para fijar el estado antes de cada operación. No pretende simular dos clientes: elimina la dependencia del planificador para comprobar ENXIO, EOF, EAGAIN, reconexión y EPIPE.

Recibe una FIFO existente, sin otros usuarios durante el experimento. No crea ni elimina la ruta. El directorio privado debe permanecer estable durante la prueba.

estados_fifo.c · operaciones no bloqueantes con referencias controladas
#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 comprobar_lectura(int fd, int eof)
{
    unsigned char byte;
    ssize_t n;
    do {
        n = read(fd, &byte, 1);
    } while (n == -1 && errno == EINTR);
    return eof ? n == 0 :
        (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK));
}

static int intercambiar(int lector, int escritor)
{
    ssize_t n;
    do {
        n = write(escritor, "OK", 2);
    } while (n == -1 && errno == EINTR);
    if (n != 2)
        return 0;
    unsigned char datos[2];
    size_t usados = 0;
    while (usados < sizeof datos) {
        n = read(lector, datos + usados, sizeof datos - usados);
        if (n > 0)
            usados += (size_t)n;
        else if (n == -1 && errno == EINTR)
            continue;
        else
            return 0;
    }
    return memcmp(datos, "OK", 2) == 0;
}

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "Uso: %s ruta_fifo_sin_otros_usuarios\n", argv[0]);
        return EXIT_FAILURE;
    }
    struct stat st;
    if (lstat(argv[1], &st) == -1 || !S_ISFIFO(st.st_mode)) {
        fprintf(stderr, "Se requiere una FIFO existente, sin enlaces\n");
        return EXIT_FAILURE;
    }
    struct sigaction accion = {0};
    accion.sa_handler = SIG_IGN;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGPIPE, &accion, NULL) == -1) {
        perror("sigaction");
        return EXIT_FAILURE;
    }
    int lector = -1, escritor = -1, resultado = EXIT_FAILURE;
    escritor = open(argv[1], O_WRONLY | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC);
    if (escritor != -1 || errno != ENXIO)
        goto limpieza;
    puts("1. Abrir escritor sin lector: ENXIO");
    lector = open(argv[1], O_RDONLY | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC);
    if (lector == -1 || !comprobar_lectura(lector, 1))
        goto limpieza;
    puts("2. Lector sin datos ni escritores: EOF");
    escritor = open(argv[1], O_WRONLY | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC);
    if (escritor == -1 || !comprobar_lectura(lector, 0))
        goto limpieza;
    puts("3. Lector vacio con escritor abierto: EAGAIN");
    if (!intercambiar(lector, escritor))
        goto limpieza;
    puts("4. Contenido recibido: OK");
    close(escritor);
    escritor = -1;
    if (!comprobar_lectura(lector, 1))
        goto limpieza;
    puts("5. Ultimo escritor cerrado y canal drenado: EOF");
    escritor = open(argv[1], O_WRONLY | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC);
    if (escritor == -1 || !intercambiar(lector, escritor))
        goto limpieza;
    puts("6. Nuevo escritor, mismo descriptor lector: OK");
    close(lector);
    lector = -1;
    ssize_t n;
    do {
        n = write(escritor, "X", 1);
    } while (n == -1 && errno == EINTR);
    if (n != -1 || errno != EPIPE)
        goto limpieza;
    puts("7. Escritor abierto sin lectores, SIGPIPE ignorada: EPIPE");
    resultado = EXIT_SUCCESS;
limpieza:
    if (resultado != EXIT_SUCCESS)
        fprintf(stderr, "Estado inesperado: comprueba que no haya otros usuarios\n");
    if (lector != -1)
        close(lector);
    if (escritor != -1)
        close(escritor);
    return resultado;
}
Bash en Linux o WSL · preparar y ejecutar el laboratorio
$ gcc -std=c17 -Wall -Wextra -Wpedantic estados_fifo.c -o estados_fifo
$ directorio=$(mktemp -d "$HOME/fifo17.XXXXXX")
$ canal="$directorio/canal"
$ mkfifo -m 600 "$canal"
$ ./estados_fifo "$canal"
1. Abrir escritor sin lector: ENXIO
2. Lector sin datos ni escritores: EOF
3. Lector vacio con escritor abierto: EAGAIN
4. Contenido recibido: OK
5. Ultimo escritor cerrado y canal drenado: EOF
6. Nuevo escritor, mismo descriptor lector: OK
7. Escritor abierto sin lectores, SIGPIPE ignorada: EPIPE

7. Reconectar escritores sin cerrar el lector

EOF describe el estado actual del flujo. En una FIFO, un proceso futuro puede volver a abrir el extremo escritor mientras el lector conserva su descriptor. Ese lector puede recibir nuevos bytes después de haber observado cero.

La aplicación debe elegir una política. Un programa de transferencia de una sola sesión puede terminar al primer EOF, como en el tema 16. Un servicio persistente puede mantener su lector y esperar actividad posterior. Ninguna política se deduce únicamente del nombre de la FIFO.

Un lector persistente y dos escritores sucesivosEl lector conserva su descriptor. Un primer escritor envía y cierra, el lector observa EOF y un escritor posterior vuelve a abrir y enviar sobre la misma FIFO. Lector persistenteConserva su fdMisma FIFOSin recrear la rutaEscritor AEnvía y cierraEscritor B posteriorAbre y vuelve a enviar
El EOF intermedio no obliga a cerrar el lector ni a eliminar el nombre.

Si el lector termina, un escritor no bloqueante posterior encuentra ENXIO. Si el lector cierra y reabre, aparece un intervalo sin lectores. Mantener el descriptor evita ese intervalo, pero obliga a controlar el comportamiento del bucle durante la ausencia de escritores.

No retires ni recrees la ruta como parte automática de cada reconexión. Los descriptores antiguos seguirían apuntando al objeto anterior y podrían separarse de los procesos que abren la nueva entrada.

8. Esperar disponibilidad y tratar POLLHUP

poll permite esperar que un descriptor pueda progresar sin consultar continuamente. El lector suele solicitar POLLIN y el escritor, POLLOUT. El resultado es una indicación para intentar E/S, no una reserva de bytes o de espacio.

EventoLectura prácticaPrecaución
POLLIN.Hay una condición de lectura que atender.Consume y conserva el resultado real de read.
POLLOUT.Puede haber posibilidad de escribir.No garantiza completar un bloque arbitrario.
POLLHUP.Existe una condición de cierre del otro extremo.Puede coexistir con bytes pendientes.
POLLERR.Existe una condición de error.En un escritor de tubería puede indicar ausencia de lectores.
POLLNVAL.El descriptor no es válido.Es un error del manejo de recursos.

En Linux, un lector de FIFO que ya observó una conexión y su cierre puede recibir POLLHUP repetidamente mientras no haya escritor. Volver a llamar a poll inmediatamente puede retornar otra vez sin dormir. Además, no debes exigir POLLHUP para detectar el EOF inicial anterior al primer escritor: read puede devolver cero aunque esa notificación aún no se presente.

El receptor del proyecto intenta read primero. Si recibe cero, aplica una pausa acotada antes de volver a observar el canal. Si recibe EAGAIN, espera con poll. Así trata tanto el inicio sin escritor como el cierre posterior sin girar sobre un aviso persistente. Los eventos están descritos en poll(2).

9. Definir reintentos, memoria y cancelación

El proyecto adopta estas decisiones antes de escribir el bucle:

Los cinco segundos no son un plazo total de toda la transferencia: cada espera por falta de espacio tiene su propio límite. Un servicio que necesite una fecha límite global debe medir tiempo monotónico y recalcular lo que queda.

Las pausas son una decisión de reintento cuando falta el interlocutor, no una forma de ordenar procesos con precisión. El programa no supone que un cliente aparecerá tras cierto número de milisegundos.

10. Proyecto: emisor no bloqueante y receptor persistente

El programa utiliza una FIFO existente y estable en un directorio privado. El modo escuchar copia el canal hacia stdout hasta recibir una señal de parada; el modo enviar copia stdin y termina. Ambos ignoran SIGPIPE para gestionar los errores de escritura.

O_NONBLOCK se aplica al descriptor de la FIFO. Stdin y stdout mantienen su modo original y pueden esperar; este ejemplo no es un bucle de eventos que multiplexe también esos otros recursos. Los diagnósticos van a stderr y no se mezclan con el contenido.

fifo_nb.c · reintentos acotados, poll y lectura persistente
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

static volatile sig_atomic_t detener = 0;

static void solicitar_parada(int senal)
{
    detener = senal;
}

static int pausa(void)
{
    struct timespec resto = {0, 250000000L};
    while (!detener) {
        if (nanosleep(&resto, &resto) == 0)
            return 0;
        if (errno != EINTR)
            return -1;
    }
    errno = EINTR;
    return -1;
}

static int abrir(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 = open(ruta, modo | O_NONBLOCK | O_NOFOLLOW | O_CLOEXEC);
    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;
}

static int esperar(int fd, short evento, int milisegundos)
{
    struct pollfd p = {.fd = fd, .events = evento};
    while (!detener) {
        int r = poll(&p, 1, milisegundos);
        if (r == -1 && errno == EINTR)
            continue;
        if (r <= 0)
            return r;
        if (p.revents & POLLNVAL) {
            errno = EBADF;
            return -1;
        }
        if (evento == POLLOUT && (p.revents & (POLLERR | POLLHUP))) {
            errno = EPIPE;
            return -1;
        }
        return 1; /* El llamador vuelve a intentar su operacion. */
    }
    errno = EINTR;
    return -1;
}

static int escribir(int fd, const unsigned char *datos, size_t cantidad,
                    int no_bloqueante)
{
    size_t enviados = 0;
    while (enviados < cantidad && !detener) {
        ssize_t n = write(fd, datos + enviados, cantidad - enviados);
        if (n > 0) {
            enviados += (size_t)n;
            continue;
        }
        if (n == -1 && errno == EINTR)
            continue;
        if (n == -1 && no_bloqueante &&
            (errno == EAGAIN || errno == EWOULDBLOCK)) {
            int r = esperar(fd, POLLOUT, 5000);
            if (r == 1)
                continue;
            if (r == 0)
                errno = ETIMEDOUT;
            return -1;
        }
        if (n == 0)
            errno = EIO;
        return -1;
    }
    if (detener) {
        errno = EINTR;
        return -1;
    }
    return 0;
}

static int enviar(int fd)
{
    unsigned char bloque[16384];
    while (!detener) {
        ssize_t n = read(STDIN_FILENO, bloque, sizeof bloque);
        if (n > 0) {
            if (escribir(fd, bloque, (size_t)n, 1) == -1)
                return -1;
        } else if (n == 0)
            return 0;
        else if (errno != EINTR)
            return -1;
    }
    errno = EINTR;
    return -1;
}

static int escuchar(int fd)
{
    unsigned char bloque[16384];
    int eof_anunciado = 0;
    while (!detener) {
        ssize_t n = read(fd, bloque, sizeof bloque);
        if (n > 0) {
            eof_anunciado = 0;
            if (escribir(STDOUT_FILENO, bloque, (size_t)n, 0) == -1)
                return -1;
        } else if (n == 0) {
            if (!eof_anunciado)
                fprintf(stderr, "EOF actual: conservo el lector para futuros escritores\n");
            eof_anunciado = 1;
            if (pausa() == -1)
                return -1;
        } else if (errno == EINTR) {
            continue;
        } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
            eof_anunciado = 0;
            if (esperar(fd, POLLIN, 500) == -1)
                return -1;
        } else {
            return -1;
        }
    }
    errno = EINTR;
    return -1;
}

int main(int argc, char *argv[])
{
    if (argc != 3 || (strcmp(argv[1], "enviar") != 0 &&
                      strcmp(argv[1], "escuchar") != 0)) {
        fprintf(stderr, "Uso: %s enviar|escuchar ruta_fifo\n", argv[0]);
        return 1;
    }
    for (int fd = 0; fd <= 2; ++fd) {
        if (fcntl(fd, F_GETFD) == -1) {
            perror("Se requieren 0, 1 y 2 abiertos");
            return 1;
        }
    }
    struct sigaction accion = {0};
    accion.sa_handler = solicitar_parada;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1) {
        perror("preparar parada");
        return 1;
    }
    accion.sa_handler = SIG_IGN;
    if (sigaction(SIGPIPE, &accion, NULL) == -1) {
        perror("preparar SIGPIPE");
        return 1;
    }
    int emisor = strcmp(argv[1], "enviar") == 0;
    int fd = -1;
    for (int intento = 0; intento < (emisor ? 20 : 1) && !detener; ++intento) {
        fd = abrir(argv[2], emisor ? O_WRONLY : O_RDONLY);
        if (fd != -1)
            break;
        if (!emisor || errno != ENXIO || intento == 19)
            break;
        if (intento == 0)
            fprintf(stderr, "ENXIO: aun no hay lector; reintentos limitados\n");
        if (pausa() == -1)
            break;
    }
    if (fd == -1) {
        if (!detener)
            perror("abrir FIFO");
        return detener ? 128 + (int)detener : 1;
    }
    fprintf(stderr, "%s: descriptor FIFO no bloqueante abierto\n",
            emisor ? "Emisor" : "Receptor");
    int r = emisor ? enviar(fd) : escuchar(fd);
    int resultado = 0;
    if (r == -1 && !detener) {
        perror(emisor ? "enviar" : "escuchar");
        resultado = 1;
    }
    if (close(fd) == -1) {
        perror("close FIFO");
        resultado = 1;
    }
    return detener ? 128 + (int)detener : resultado;
}

El manejador solo guarda la señal en un sig_atomic_t. El cierre y los diagnósticos se realizan en el flujo normal. Las pausas y poll vuelven al bucle al ser interrumpidos, y la solicitud de parada evita reintentar indefinidamente.

La comprobación lstat/open/fstat detecta varios usos incorrectos de la ruta, pero sigue siendo una secuencia de operaciones. El programa supone un directorio privado y una entrada que no se reemplaza durante el uso. No crea la FIFO, no cambia sus permisos ni la elimina.

La copia a stdout está pensada para un destino bloqueante habitual. Si el programa se integra en un sistema donde stdin o stdout ya son no bloqueantes, esos descriptores también necesitan su propia gestión de disponibilidad y de datos pendientes.

11. Probar ausencia, reconexión y contrapresión

Bash · compilar y probar la ausencia de lectores
$ gcc -std=c17 -Wall -Wextra -Wpedantic fifo_nb.c -o fifo_nb
$ printf 'sin receptor\n' | ./fifo_nb enviar "$canal"
ENXIO: aun no hay lector; reintentos limitados
... tras agotar los intentos ...
abrir FIFO: No such device or address
$ echo $?
1

El texto del sistema depende del idioma. No inicia una espera de escritura, porque todavía no consiguió abrir un descriptor. Si aparece un receptor durante los reintentos, puede completar la apertura y enviar.

Bash · dos emisores sucesivos con el mismo receptor
$ ./fifo_nb escuchar "$canal" > recibido17.bin &
$ receptor=$!
$ printf 'primero\n' | ./fifo_nb enviar "$canal"
$ printf 'segundo\n' | ./fifo_nb enviar "$canal"
$ cat recibido17.bin
primero
segundo

Antes de consultar el archivo, espera a que el receptor haya tenido oportunidad de copiarlo: la salida del emisor confirma aceptación en el canal, no recepción final en stdout. Puedes consultar el archivo nuevamente hasta observar ambas líneas. Si quieres observar el EOF intermedio, inicia el segundo emisor después del diagnóstico de EOF del receptor; si se solapan, ese estado puede no observarse.

Bash · datos binarios grandes y parada del receptor
$ head -c 1048576 /dev/urandom > origen17.bin
$ ./fifo_nb enviar "$canal" < origen17.bin
... el receptor añade los bytes a recibido17.bin ...
$ kill -TERM "$receptor"
$ wait "$receptor"
$ echo $?
143

Para verificar el binario con cmp, usa una sesión de receptor nueva con un archivo de salida vacío y espera a que su tamaño alcance el de origen antes de detenerlo. Una señal de parada puede abandonar bytes todavía pendientes: no es un mensaje de confirmación del protocolo.

Para provocar contrapresión, usa un lector de prueba que abra la FIFO y retrase el consumo de una entrada mayor que la capacidad. El emisor debe conservar el sufijo pendiente y continuar cuando haya espacio, o terminar con ETIMEDOUT si una espera vence. Si el lector cierra, el resultado esperado es un fallo de conexión como EPIPE, no un reenvío automático del bloque completo.

Al terminar y cerrar todos los participantes, retira únicamente los objetos propios del laboratorio con rm -- "$canal" y rmdir -- "$directorio".

12. EOF no es un límite fiable entre clientes

El lector observa el estado agregado de los escritores, no la identidad de cada cliente. Si un emisor abre antes de que el anterior cierre, nunca desaparece el conjunto de escritores. Incluso sin solapamiento, un escritor nuevo puede llegar antes de la siguiente lectura del receptor.

Por tanto, no cuentes clientes por el número de EOF observados. Tampoco interpretes cada read positivo como una solicitud completa. La aplicación necesita delimitadores, longitudes o registros acotados que definan sus unidades.

Reconectar un emisor después de un fallo tiene otra dificultad: un prefijo pudo haberse aceptado antes de desconectarse. Reenviar toda la solicitud puede duplicar datos; enviar solo el sufijo a un nuevo servicio puede producir una solicitud incompleta. La recuperación requiere identificadores, confirmaciones o una política explícita de descarte.

Mantener un escritor auxiliar abierto puede impedir EOF, pero cambia el significado de la ausencia de clientes. No debe añadirse como arreglo automático. El proyecto del tema 18 definirá su protocolo y la responsabilidad sobre cada canal.

13. Evaluar aperturas y operaciones

Selecciona un estado y compara los resultados. El modelo separa una nueva apertura del uso de un descriptor que ya existe. Para escribir supone SIGPIPE ignorada. La capacidad de ocho unidades y el límite atómico de cuatro son valores didácticos.

Nueva apertura lectoraCompleta sin exigir escritor

Nueva apertura escritoraPuede completar

read en un lector existente0: EOF actual

write en un escritor existenteNo hay descriptor escritor válido

Un lector abierto sin escritores ni contenido puede observar EOF y conservar su descriptor.

Prueba primero un lector sin escritores y luego activa el escritor: una lectura vacía cambia de EOF a EAGAIN. Después deja un escritor sin lectores: una nueva apertura escritora falla con ENXIO, mientras el uso del escritor ya abierto encuentra EPIPE.

14. Diagnosticar esperas y consumo de CPU

Bash · observar operaciones y política de espera
$ strace -tt -o fifo17.log ./fifo_nb escuchar "$canal"
... envía contenido desde otra terminal y termina con Ctrl+C ...
$ less fifo17.log

Con el canal vacío y sin escritores deben verse lecturas que devuelven cero separadas por pausas. Con un escritor conectado pero inactivo pueden verse EAGAIN y esperas poll. Al cerrar el escritor, puede aparecer POLLHUP y luego EOF. Los nombres de las llamadas de pausa pueden variar según la biblioteca.

SíntomaQué comprobar
open devuelve ENXIO.Es una apertura escritora no bloqueante sin lector; no hay descriptor nuevo que vigilar.
read devuelve cero al arrancar.Puede no haber escritor todavía; define si el servicio debe persistir.
read devuelve EAGAIN.El canal está vacío pero quedan escritores; espera disponibilidad.
La CPU sube después de desconectarse un emisor.Un bucle reintenta read sobre EOF o poll sobre POLLHUP persistente.
Se pierden bytes al tratar POLLHUP.Se cerró sin consumir el contenido pendiente.
Hay bytes repetidos.Se reenvió un prefijo ya aceptado tras una escritura parcial.
El emisor espera aunque se activó O_NONBLOCK después.La espera puede haber ocurrido antes, dentro de open bloqueante.
Nunca aparece EOF.Alguna referencia escritora sigue abierta, quizá un escritor auxiliar o un O_RDWR.
No coinciden EOF y cantidad de clientes.EOF refleja escritores agregados y puede no observarse entre conexiones.

O_NONBLOCK no elimina la contrapresión ni la necesidad de un protocolo. Las condiciones de capacidad, atomicidad y pérdida del interlocutor se mantienen, como describe pipe(7).

15. Resumen

16. Preguntas de repaso y práctica

Responde antes de abrir cada explicación.

1. ¿Qué diferencia hay entre ENXIO y EPIPE?

ENXIO aparece al abrir un escritor no bloqueante sin lector. EPIPE corresponde a una escritura sobre un descriptor existente cuando no quedan lectores, con SIGPIPE gestionada apropiadamente.

2. ¿Un lector no bloqueante siempre devuelve EAGAIN si está vacío?

No. Si no quedan escritores, devuelve cero. EAGAIN indica vacío con escritores todavía abiertos.

3. ¿EOF obliga a cerrar el lector de una FIFO?

No. El programa puede conservarlo si su política admite escritores futuros sobre la misma FIFO.

4. ¿Activar el flag con fcntl evita la espera de una apertura anterior?

No. Para evitar la espera de open debe pasarse O_NONBLOCK en esa misma llamada.

5. ¿Por qué se usa F_GETFL antes de F_SETFL?

Para conservar los flags de estado existentes al añadir o retirar O_NONBLOCK.

6. ¿POLLHUP significa que no queda contenido?

No. Puede haber bytes pendientes y deben consumirse antes de reconocer el fin actual del flujo.

7. ¿Por qué poll puede provocar un bucle que consume CPU?

Si la condición de cierre persiste, puede retornar inmediatamente en cada llamada. El programa necesita cambiar su política de espera o el recurso observado.

8. ¿Por qué no se reenvía todo el bloque tras una escritura parcial?

Porque el prefijo informado como aceptado ya está en el flujo y se duplicaría. Se conserva el desplazamiento y se continúa desde el sufijo.

9. ¿Los cinco segundos del proyecto limitan toda la transferencia?

No. Son un límite por espera de espacio. Un plazo global exige medir el tiempo total con un reloj monotónico.

10. ¿Un escritor auxiliar abierto facilita detectar que no hay clientes?

No. Mantiene la condición de escritor presente y evita EOF. Puede ser una política deliberada, pero cambia el significado de la observación.

11. ¿Un EOF corresponde siempre al cierre de un único cliente?

No. El estado depende de todos los escritores y el lector puede no observar el intervalo entre clientes sucesivos.

12. ¿Cerrar y recrear la ruta reconecta automáticamente a todos?

No. Los descriptores existentes siguen apuntando al objeto anterior y los nuevos abren la FIFO recreada.

Para practicar

  1. Ejecuta estados_fifo y relaciona cada salida con las referencias abiertas en ese instante.
  2. Inicia el emisor sin receptor y mide el intervalo de reintentos. Comprueba que termina si no aparece un lector.
  3. Inicia el receptor durante los reintentos del emisor y verifica que puede completarse la apertura.
  4. Envía dos contenidos con el mismo receptor persistente. Repite con escritores solapados y explica por qué no hay un EOF por cliente.
  5. Usa un lector lento para provocar EAGAIN en un envío grande. Comprueba con cmp que no se duplican ni pierden bytes.
  6. Deja abierto un lector que no consume y verifica el vencimiento de la espera del emisor.
  7. Retira el lector durante un envío y distingue EPIPE de un agotamiento de espacio.
  8. Diseña un registro con longitud o delimitador para distinguir peticiones sin depender de EOF.
  9. Propón un plazo total de transferencia usando CLOCK_MONOTONIC y explica cuándo se recalcula el tiempo restante.
Próximo paso

El tema 18 integrará las FIFO en un servicio local: peticiones acotadas, un canal de respuesta por cliente, control de errores y limpieza de rutas.