← Comunicación entre ProcesosBloque 3 · Tuberías anónimas y shells · Tema 12 de 52

Tema 12

EOF, SIGPIPE y capacidad de una tubería

Un canal vacío puede significar espera o fin del flujo. Una escritura puede esperar espacio o descubrir que ya no existe ningún lector. Y una capacidad grande no hace atómico cualquier registro. Vas a separar estas situaciones mediante experimentos con referencias duplicadas, SIGPIPE y saturación, y a distinguir la capacidad del límite PIPE_BUF.

1. Las variables que determinan el resultado

En el tema 11 creamos un canal, transmitimos bytes y cerramos los extremos sobrantes. Ahora interesa explicar por qué ese plan funciona y qué pasa cuando se altera. No basta con saber que un proceso terminó o que una lectura no encontró bytes.

Para razonar sobre una tubería, separa al menos estas propiedades:

Los ejemplos utilizan peticiones de lectura y escritura de tamaño positivo. Una operación de tamaño cero no sirve para deducir las mismas condiciones. Tampoco observamos aquí escrituras que ya estuvieran parcialmente en curso durante un cambio de estado: la interfaz puede informar un progreso que debes conservar.

2. EOF no significa solamente canal vacío

Una lectura de tamaño positivo devuelve cero cuando no quedan bytes pendientes y no queda ningún escritor abierto. Si el canal está vacío pero existe un escritor, la condición es otra: aún podrían llegar datos.

Bytes pendientes¿Quedan escritores?Lector bloqueanteLector no bloqueante
SíSí o no.Puede recibir bytes.Puede recibir bytes.
NoSí.Espera datos o un cambio relevante.Retorna −1 con EAGAIN.
NoNo.Retorna 0: EOF.Retorna 0: EOF.

Cerrar el último escritor no descarta lo ya enviado. El lector puede consumir ese contenido antes de obtener cero. Tampoco se transmite un byte especial de EOF: el cero es un resultado de read, distinto de un byte de valor cero dentro del contenido.

El modo no bloqueante no convierte EOF en EAGAIN. Distingue la ausencia temporal de datos de un flujo que ya no tiene productores posibles mediante sus referencias. El contrato de lectura está en read(2).

3. Referencias heredadas y duplicadas

La condición no se expresa como «el productor principal terminó», sino como «no queda un escritor abierto». fork puede dejar referencias en hijos; dup o dup2 pueden añadir otras dentro del mismo proceso. Una referencia heredada durante exec también puede prolongar la vida del extremo.

Si el padre conserva un escritor que nunca usa, el núcleo no puede saber que no piensa utilizarlo. Si el hijo consumidor conserva su copia del escritor, puede bloquear su propia detección de EOF. Es un problema de referencias, no de cuánto texto se haya imprimido.

close libera la entrada del proceso que lo ejecuta. No elimina automáticamente otras entradas que referencian el extremo. Su vida útil y la reutilización de números de descriptor se describen en close(2).

El siguiente experimento usa dup para mostrar esa condición en un solo proceso. El lector será no bloqueante para observar el resultado sin dejar el laboratorio detenido.

4. Experimento: un escritor que todavía existe

Se escribe OK, se cierra el escritor original y se consumen los datos. Una referencia duplicada sigue abierta, así que la siguiente lectura da EAGAIN. Solo después de cerrar esa referencia se observa EOF.

eof_referencias.c · el número de productores no es el número de referencias
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static ssize_t leer(int fd, char *buffer, size_t cantidad)
{
    ssize_t n;
    do {
        n = read(fd, buffer, cantidad);
    } while (n == -1 && errno == EINTR);
    return n;
}

int main(void)
{
    int canal[2];
    if (pipe(canal) == -1) {
        perror("pipe");
        return EXIT_FAILURE;
    }
    int copia = dup(canal[1]);
    int resultado = EXIT_FAILURE;
    if (copia == -1) {
        perror("dup");
        goto limpieza;
    }
    int flags = fcntl(canal[0], F_GETFL);
    if (flags == -1 || fcntl(canal[0], F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl");
        goto limpieza;
    }
    ssize_t enviados;
    do {
        enviados = write(canal[1], "OK", 2);
    } while (enviados == -1 && errno == EINTR);
    if (enviados != 2) {
        fprintf(stderr, "No se completo el envio pequeno de prueba\n");
        goto limpieza;
    }
    close(canal[1]);
    canal[1] = -1;
    char buffer[8];
    size_t total = 0;
    for (;;) {
        ssize_t n = leer(canal[0], buffer, sizeof buffer);
        if (n > 0) {
            printf("Contenido: %.*s\n", (int)n, buffer);
            total += (size_t)n;
        } else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
            break;
        } else {
            fprintf(stderr, "Resultado inesperado antes de cerrar la copia\n");
            goto limpieza;
        }
    }
    if (total != 2)
        goto limpieza;
    puts("Vacio con escritor duplicado: EAGAIN, no EOF");
    close(copia);
    copia = -1;
    if (leer(canal[0], buffer, sizeof buffer) != 0) {
        fprintf(stderr, "No se observo EOF\n");
        goto limpieza;
    }
    puts("Vacio sin escritores: EOF");
    resultado = EXIT_SUCCESS;

limpieza:
    if (copia != -1)
        close(copia);
    if (canal[1] != -1)
        close(canal[1]);
    close(canal[0]);
    return resultado;
}
Bash · comprobar los dos estados del canal vacío
$ gcc -std=c17 -Wall -Wextra -Wpedantic eof_referencias.c -o eof_referencias
$ ./eof_referencias
Contenido: OK
Vacio con escritor duplicado: EAGAIN, no EOF
Vacio sin escritores: EOF

El mismo principio explica una fuga en un pipeline: no importa que la referencia adicional no haya enviado nunca un byte. Mientras permanezca abierta, puede impedir la condición de fin.

5. Qué sucede al desaparecer los lectores

La condición simétrica para escribir es que no quede ninguna referencia lectora. Al iniciar una escritura de tamaño positivo en ese estado se genera SIGPIPE. Con su acción predeterminada, el proceso termina; si la señal se ignora, write puede devolver −1 con EPIPE para que el programa gestione el fallo.

No confundas «lector lento» con «ningún lector». El primero puede provocar contrapresión y espera por espacio. El segundo indica que los datos no tienen destinatario en ese canal. Aumentar la capacidad no crea un lector.

Instalar un manejador o bloquear SIGPIPE implica otras decisiones; el siguiente laboratorio compara solo la disposición predeterminada y la ignorada, y la deja explícitamente sin bloquear. La relación entre extremos, EOF y SIGPIPE se documenta en pipe(7).

6. Experimento: SIGPIPE frente a EPIPE

El programa cierra el único lector antes de crear un hijo escritor. Así no depende de dormir para esperar a que otro proceso cierre. El padre observa si el hijo termina por SIGPIPE o si trata EPIPE y sale normalmente.

probar_sigpipe.c · el observador distingue señal de terminación normal
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    if (argc != 2 || (strcmp(argv[1], "predeterminada") != 0 &&
        strcmp(argv[1], "ignorar") != 0)) {
        fprintf(stderr, "Uso: %s predeterminada|ignorar\n", argv[0]);
        return EXIT_FAILURE;
    }
    int ignorar = strcmp(argv[1], "ignorar") == 0;
    struct sigaction accion = {0};
    accion.sa_handler = ignorar ? SIG_IGN : SIG_DFL;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGPIPE, &accion, NULL) == -1) {
        perror("preparar SIGPIPE");
        return EXIT_FAILURE;
    }
    accion.sa_handler = SIG_DFL;
    if (sigaction(SIGCHLD, &accion, NULL) == -1) {
        perror("preparar SIGCHLD");
        return EXIT_FAILURE;
    }
    sigset_t permitir;
    if (sigemptyset(&permitir) == -1 ||
        sigaddset(&permitir, SIGPIPE) == -1 ||
        sigprocmask(SIG_UNBLOCK, &permitir, NULL) == -1) {
        perror("desbloquear SIGPIPE");
        return EXIT_FAILURE;
    }
    int canal[2];
    if (pipe(canal) == -1) {
        perror("pipe");
        return EXIT_FAILURE;
    }
    close(canal[0]); /* Desde este punto no hay lectores. */
    pid_t hijo = fork();
    if (hijo == -1) {
        perror("fork");
        close(canal[1]);
        return EXIT_FAILURE;
    }
    if (hijo == 0) {
        ssize_t n;
        do {
            n = write(canal[1], "X", 1);
        } while (n == -1 && errno == EINTR);
        int causa = errno;
        close(canal[1]);
        if (ignorar && n == -1 && causa == EPIPE) {
            dprintf(STDERR_FILENO, "Hijo: write retorno EPIPE\n");
            _exit(EXIT_SUCCESS);
        }
        _exit(2); /* No es el recorrido esperado de la prueba. */
    }
    close(canal[1]);
    int estado;
    while (waitpid(hijo, &estado, 0) == -1) {
        if (errno == EINTR)
            continue;
        perror("waitpid");
        return EXIT_FAILURE;
    }
    if (!ignorar && WIFSIGNALED(estado) && WTERMSIG(estado) == SIGPIPE) {
        puts("Padre: hijo terminado por SIGPIPE");
        return EXIT_SUCCESS;
    }
    if (ignorar && WIFEXITED(estado) && WEXITSTATUS(estado) == EXIT_SUCCESS) {
        puts("Padre: hijo gestiono EPIPE y termino normalmente");
        return EXIT_SUCCESS;
    }
    fprintf(stderr, "Estado del hijo diferente del esperado\n");
    return EXIT_FAILURE;
}
Bash · comparar las dos políticas
$ gcc -std=c17 -Wall -Wextra -Wpedantic probar_sigpipe.c -o probar_sigpipe
$ ./probar_sigpipe predeterminada
Padre: hijo terminado por SIGPIPE
$ ./probar_sigpipe ignorar
Hijo: write retorno EPIPE
Padre: hijo gestiono EPIPE y termino normalmente

El padre termina con cero en ambos casos si observó el resultado esperado. En el primer modo, el hijo no llegó a gestionar un retorno normal de write. En el segundo pudo reconocer el error porque SIGPIPE estaba ignorada. El mensaje del hijo va a stderr y el del padre a stdout.

Es una política de este laboratorio, no una orden de ignorar SIGPIPE en toda aplicación. En una biblioteca o proceso con varios componentes, cambiar una disposición afecta al conjunto del proceso y debe coordinarse.

7. Capacidad y contrapresión

La capacidad es cuánto contenido puede mantener el canal pendiente de lectura. Cuando los productores intentan avanzar más rápido que los consumidores, aparece contrapresión: con E/S bloqueante pueden esperar espacio; con E/S no bloqueante deben gestionar la falta temporal de progreso.

Una capacidad mayor puede absorber una ráfaga, pero no corrige una diferencia permanente de ritmos. Si el productor genera más bytes por segundo de los que el consumidor procesa, el canal acabará saturándose o el programa tendrá que aplicar otra política.

En Linux puedes consultar la capacidad nominal con fcntl y F_GETPIPE_SZ. Puede variar por configuración, límites y consumo de recursos del usuario. No fijes 65536 ni otra cifra observada como parte del protocolo. F_SETPIPE_SZ permite solicitar cambios dentro de sus reglas, pero no lo necesitamos para el experimento.

La organización interna por páginas y el tamaño de las escrituras pueden afectar cuánto espacio es utilizable en un momento concreto. Capacidad nominal menos bytes pendientes no siempre equivale al tamaño de cualquier escritura que pueda aceptarse inmediatamente. Estas particularidades se documentan en F_GETPIPE_SZ y F_SETPIPE_SZ.

8. Qué garantiza PIPE_BUF

PIPE_BUF es un límite relacionado con la atomicidad de escrituras. Si una escritura a una tubería solicita como máximo ese límite, la garantía evita que sus bytes se entremezclen con los de otras escrituras al canal, bajo las condiciones de la interfaz.

No significa que el canal solo pueda almacenar esa cantidad ni que el lector reciba el bloque en un único read. Tampoco significa que un registro grande se vuelva atómico porque la aplicación lo envuelva en una función llamada escribir_todo.

Atomicidad frente a fronteras de lecturaDos escrituras pequeñas contienen AAA y BBB. El flujo puede conservar AAA seguido de BBB, mientras una lectura de cuatro bytes devuelve AAAB y otra devuelve BB. write: AAAwrite: BBBFlujo posibleAAABBBread: AAABread: BB
Los escritores no se entremezclaron, pero las lecturas no conservaron sus fronteras.

En el esquema, también podría aparecer BBBAAA según el orden de los escritores. La garantía no asigna un turno fijo entre ellos. Para obtener registros debes acordar longitudes o delimitadores y reconstruirlos en el receptor.

Puedes consultar el límite asociado al descriptor con fpathconf y _PC_PIPE_BUF. El programa siguiente lo mostrará junto a la capacidad para que no se confundan.

9. Escrituras bloqueantes y no bloqueantes

La tabla supone que existe al menos un lector, que el descriptor escritor es válido y que la petición tiene n bytes positivos. Las interrupciones y otros fallos deben tratarse además mediante el retorno real.

TamañoModo bloqueanteModo no bloqueante
n ≤ PIPE_BUFLa escritura puede esperar espacio para completar la unidad sin entremezclarla.Si puede aceptar la unidad, la escribe completa; si no, EAGAIN sin aceptar un prefijo.
n > PIPE_BUFNo garantiza atomicidad frente a otros escritores. Puede necesitar esperar mientras avanza; sin interrupciones o errores completa la petición.Sin espacio puede retornar EAGAIN. Si progresa, puede aceptar solo una parte y no garantiza que no se entremezcle.

Para una escritura no bloqueante grande, nunca avances el offset por lo pedido si el resultado fue menor: avánzalo por lo aceptado. Para una unidad pequeña rechazada con EAGAIN, conserva la unidad completa pendiente y espera disponibilidad según tu protocolo.

Esta distinción no elimina todos los límites de la aplicación: registros demasiado grandes, varios productores y reintentos pueden necesitar una estrategia adicional de serialización. El comportamiento del flujo y PIPE_BUF se describen en pipe(7) y los retornos de escritura en write(2).

10. Medir y saturar una tubería en Linux

El tercer laboratorio crea una tubería no bloqueante, consulta capacidad y PIPE_BUF, y escribe hasta EAGAIN sin que otro proceso lea. Después drena todo el contenido hasta volver a EAGAIN, verifica que puede transmitir un byte nuevo y finalmente cierra el escritor para obtener EOF.

Los bloques de llenado son como máximo PIPE_BUF. Si una escritura pequeña no cabe, el programa no la divide para fingir que se aceptó; acumula solo lo que write devuelve. La cifra observada se informa sin convertirla en una constante para otras tuberías.

medir_tuberia.c · capacidad, saturación, espacio recuperado y EOF
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(void)
{
    int canal[2];
    if (pipe2(canal, O_NONBLOCK | O_CLOEXEC) == -1) {
        perror("pipe2");
        return EXIT_FAILURE;
    }
    int resultado = EXIT_FAILURE;
    int capacidad = fcntl(canal[1], F_GETPIPE_SZ);
    if (capacidad == -1) {
        perror("F_GETPIPE_SZ");
        goto limpieza;
    }
    errno = 0;
    long atomico = fpathconf(canal[1], _PC_PIPE_BUF);
    if (atomico <= 0) {
        if (errno != 0)
            perror("fpathconf");
        else
            fprintf(stderr, "No se obtuvo un PIPE_BUF positivo\n");
        goto limpieza;
    }
    printf("Capacidad consultada: %d bytes\n", capacidad);
    printf("PIPE_BUF consultado: %ld bytes\n", atomico);
    unsigned char bloque[4096];
    memset(bloque, 'x', sizeof bloque);
    size_t pedido = sizeof bloque;
    if ((unsigned long)atomico < (unsigned long)pedido)
        pedido = (size_t)atomico;
    size_t enviados = 0;
    for (;;) {
        ssize_t n = write(canal[1], bloque, pedido);
        if (n > 0) {
            enviados += (size_t)n;
        } else if (n == -1 && errno == EINTR) {
            continue;
        } else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
            break;
        } else {
            if (n == 0)
                errno = EIO;
            perror("write de llenado");
            goto limpieza;
        }
    }
    printf("Bytes aceptados antes de EAGAIN: %zu\n", enviados);
    size_t recibidos = 0;
    for (;;) {
        ssize_t n = read(canal[0], bloque, sizeof bloque);
        if (n > 0) {
            recibidos += (size_t)n;
        } else if (n == -1 && errno == EINTR) {
            continue;
        } else if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
            break;
        } else {
            fprintf(stderr, "Lectura inesperada durante el drenaje\n");
            goto limpieza;
        }
    }
    printf("Bytes recuperados: %zu\n", recibidos);
    if (recibidos != enviados) {
        fprintf(stderr, "El total no coincide\n");
        goto limpieza;
    }
    puts("Vacio con escritor abierto: EAGAIN");
    ssize_t n;
    do {
        n = write(canal[1], "Z", 1);
    } while (n == -1 && errno == EINTR);
    if (n != 1) {
        fprintf(stderr, "No se pudo escribir tras vaciar\n");
        goto limpieza;
    }
    do {
        n = read(canal[0], bloque, 1);
    } while (n == -1 && errno == EINTR);
    if (n != 1 || bloque[0] != 'Z') {
        fprintf(stderr, "No se recupero el byte nuevo\n");
        goto limpieza;
    }
    puts("Tras vaciar, escritura y lectura vuelven a progresar");
    close(canal[1]);
    canal[1] = -1;
    do {
        n = read(canal[0], bloque, 1);
    } while (n == -1 && errno == EINTR);
    if (n != 0) {
        fprintf(stderr, "No se observo EOF al cerrar el escritor\n");
        goto limpieza;
    }
    puts("Vacio sin escritores: EOF");
    resultado = EXIT_SUCCESS;

limpieza:
    if (canal[1] != -1)
        close(canal[1]);
    close(canal[0]);
    return resultado;
}
Bash · una ejecución en Linux; los tamaños pueden variar
$ gcc -std=c17 -Wall -Wextra -Wpedantic medir_tuberia.c -o medir_tuberia
$ ./medir_tuberia
Capacidad consultada: 65536 bytes
PIPE_BUF consultado: 4096 bytes
Bytes aceptados antes de EAGAIN: 65536
Bytes recuperados: 65536
Vacio con escritor abierto: EAGAIN
Tras vaciar, escritura y lectura vuelven a progresar
Vacio sin escritores: EOF

Los números dependen del entorno. En esta secuencia de una tubería nueva y un productor, puedes observar que se acepta la capacidad nominal completa; el programa no exige esa igualdad como regla universal. Sí comprueba que recupera todos los bytes aceptados.

O_NONBLOCK permite observar la saturación sin bloquear este único proceso. Si retiraras ese flag del escritor y mantuvieras el mismo orden «llenar primero, leer después», podría detenerse en write antes de llegar al drenaje. No es un fallo de pipe: es una dependencia incorrecta del programa.

11. Atomicidad no es enmarcado de mensajes

Supón varios productores que envían registros por una tubería común. Mantener un registro dentro de PIPE_BUF y enviarlo en una llamada puede evitar que otro escritor inserte bytes en su interior. El receptor todavía necesita saber dónde termina cada registro.

Un formato por líneas sirve si los datos no incluyen saltos de línea o se escapan. Un formato con longitud necesita validar esa longitud, guardar fragmentos y limitar el tamaño. Un tamaño fijo simplifica la reconstrucción, pero no admite por sí solo datos de cualquier longitud.

Si divides un registro en dos llamadas pequeñas, otro escritor puede intervenir entre ellas. Las dos llamadas siguen siendo unidades distintas aunque cada una esté bajo PIPE_BUF. Y varios lectores no obtienen automáticamente «un registro para cada uno»: compiten por bytes del flujo.

Para datos grandes puede ser más sencillo dedicar un canal por productor, serializar el acceso o utilizar un transporte de mensajes. La elección depende de la semántica y de cómo gestiones la contrapresión, no solo de una medida de velocidad.

12. Evitar interbloqueos y fugas

Antes de ejecutar, enumera quién puede mantener cada referencia. Después pregunta qué evento espera cada operación bloqueante y quién tiene que producirlo.

En cada rama posterior a fork cierra de inmediato lo que no pertenece a su rol. Si ejecutarás otro programa, define qué referencias deben sobrevivir a exec y cuáles deben llevar close-on-exec. dup2 puede preparar la salida estándar, pero no elimina por sí solo todos los números originales.

Un tiempo límite permite diagnosticar o abandonar una prueba, pero no corrige el protocolo. Un canal más grande puede retrasar un interbloqueo y ocultarlo con entradas pequeñas. La solución es permitir el progreso correcto y gestionar las referencias.

Si esperas eventos con poll, un aviso de cierre puede coexistir con datos pendientes. No cierres el lector sin consumir lo que el protocolo necesita solo porque apareció POLLHUP. Las banderas de disponibilidad y cierre se explican en poll(2).

13. Evaluar lecturas y escrituras

El evaluador usa capacidad 8 y límite atómico 4, números pequeños exclusivamente didácticos. Supone espacio utilizable sin modelar páginas internas. Configura referencias, contenido, petición y modo para comparar las operaciones; no ejecuta llamadas reales ni modifica el estado al evaluar.

Modelo: capacidad C = 8; límite atómico L = 4

LecturaEsperaría datos

EscrituraPuede completar 3 sin entremezclar

Espacio del modelo8 bytes utilizables

Relación con el límitePetición pequeña: n ≤ L

Una lectura puede esperar al mismo tiempo que una escritura pequeña puede progresar: son operaciones y condiciones diferentes.

Prueba vacío con uno y con cero escritores; después coloca bytes pendientes sin escritores. Para escribir, conserva al menos una referencia escritora y retira los lectores. Compara la disposición de SIGPIPE y, por último, cambia entre una petición pequeña y una grande cuando queda poco espacio.

Las referencias incluyen la necesaria para efectuar la operación. Si no existe ningún lector, el evaluador no finge que se puede llamar válidamente a read; si se intentara usar un descriptor ya cerrado, sería un problema como EBADF. Análogamente, sin escritor válido no hay una escritura que pueda producir SIGPIPE.

Para una petición grande no bloqueante con espacio, el resultado real puede ser parcial y debe comprobarse; el modelo muestra un rango, no una promesa exacta. Para una petición grande bloqueante no inventa un retorno corto solo por encontrar poco espacio: puede avanzar y seguir esperando hasta completar o ser interrumpida.

14. Diagnosticar cierres y saturación

SíntomaPregunta que conviene responder
read espera después de consumir todo.¿Qué proceso o descriptor duplicado conserva un escritor?
write espera y el consumidor no avanza.¿El lector puede ejecutarse o está esperando al escritor?
El programa termina cuando otro cierra la entrada.¿SIGPIPE mantiene su acción predeterminada?
write retorna EAGAIN con una unidad pequeña.¿Cabe completa o hay que esperar espacio sin aceptar un prefijo?
Los registros aparecen fragmentados al leer.¿Se confundió atomicidad de escritura con fronteras de lectura?
Una capacidad mayor solo retrasa el bloqueo.¿Hay una diferencia permanente de ritmos o una dependencia circular?
Bash · observar el cierre y la señal
$ strace -f -o sigpipe.log ./probar_sigpipe predeterminada
$ strace -o capacidad.log ./medir_tuberia
$ less sigpipe.log

En la primera traza busca el cierre del lector antes de crear al hijo, su escritura, SIGPIPE y la recolección del padre. En la segunda, distingue EAGAIN de llenado, EAGAIN de lectura vacía y la lectura de cero después del cierre.

Para un proceso vivo, /proc/PID/fd ayuda a localizar referencias; usa -f en strace si necesitas seguir hijos. No deduzcas la propiedad de un extremo solo del número: el mismo número en procesos diferentes puede apuntar a otra cosa.

Una traza puede alterar el orden temporal, pero las condiciones de EOF y de ausencia de lectores no deberían depender de una velocidad particular. Prepara pruebas por estados o con coordinación, como los laboratorios, antes de recurrir a sleeps para intentar reproducir un fallo.

15. Resumen

16. Preguntas de repaso y práctica

Responde antes de abrir cada explicación.

1. ¿Por qué vacío no implica EOF?

Porque un escritor abierto todavía puede enviar datos. En ese estado una lectura bloqueante espera y una no bloqueante puede informar EAGAIN.

2. ¿El cero del retorno de read es un byte que envió el productor?

No. Es el resultado que indica fin de entrada para una petición positiva en estas condiciones. Un byte cero es contenido y se cuenta dentro de un retorno positivo.

3. ¿Cerrar el escritor original basta si existe un dup?

No. La copia mantiene una referencia escritora. Deben desaparecer todas las referencias relevantes antes de que un lector vacío observe EOF.

4. ¿Qué diferencia hay entre lector lento y ningún lector?

El lector lento puede producir falta de espacio y espera. La ausencia de lectores hace que una escritura positiva encuentre la condición de SIGPIPE/EPIPE.

5. ¿Por qué el observador de SIGPIPE termina con cero en ambos modos?

Porque el padre comprueba el resultado esperado del laboratorio: señal en el hijo o tratamiento de EPIPE. El estado del observador es distinto del del hijo.

6. ¿Aumentar la capacidad convierte en atómico un registro grande?

No. La capacidad y PIPE_BUF expresan propiedades distintas. El tamaño del registro sigue estando sujeto a la garantía de atomicidad correspondiente.

7. ¿Un write atómico implica un read completo del mismo tamaño?

No. La garantía evita entremezclar los bytes de otras escrituras dentro de esa unidad; no conserva una frontera para cada lectura.

8. ¿Qué pasa con una escritura pequeña no bloqueante que no cabe?

Retorna EAGAIN sin aceptar un prefijo de la unidad. Debe conservarse pendiente y esperarse disponibilidad según el protocolo.

9. ¿Por qué el medidor utiliza O_NONBLOCK?

Para poder observar la saturación sin quedarse esperando espacio en el único proceso que todavía no empezó a leer.

10. ¿Capacidad menos contenido garantiza cualquier escritura inmediata?

No de forma general en Linux: la organización interna y los tamaños pueden afectar el espacio utilizable. El resultado de cada operación sigue siendo la evidencia necesaria.

11. ¿Qué puede significar POLLHUP junto con datos?

Que existe un evento de cierre pero todavía hay contenido por consumir. No debe descartarse automáticamente el flujo pendiente.

12. ¿Por qué un búfer mayor puede ocultar un interbloqueo?

Porque permite avanzar más antes de encontrar la dependencia circular. No cambia quién tiene que leer o terminar para que el otro proceso progrese.

Para practicar

  1. Ejecuta eof_referencias y localiza el escritor original y la copia. Explica en qué momento desaparece la última referencia.
  2. En una copia del primer laboratorio, conserva una segunda duplicación y ciérrala después. Predice por qué no aparecerá EOF hasta retirarla.
  3. Ejecuta los dos modos de probar_sigpipe y consulta el estado del padre. Distingue el retorno de la prueba del cambio de estado del hijo.
  4. Ejecuta medir_tuberia y registra capacidad, PIPE_BUF y bytes recuperados. No uses el resultado como una constante para otro equipo.
  5. Reduce el tamaño del bloque de llenado del medidor a un valor pequeño y compara el resultado. Explica por qué no debes convertir una observación sobre espacio interno en una garantía universal.
  6. Diseña un registro que quepa en PIPE_BUF y un lector capaz de reconstruirlo aunque llegue dividido. Incluye límites y validación.
  7. En el evaluador, deja dos bytes utilizables y solicita cuatro. Compara modo bloqueante y no bloqueante. Después solicita seis y explica qué cambia.
  8. Dibuja una tubería compartida entre padre y dos hijos. Indica qué escritor olvidado impediría EOF y qué referencias lectoras evitarían la condición de EPIPE.
Próximo paso

Con las condiciones del canal claras, el tema 13 conectará comandos mediante dup2 y exec para construir una tubería de dos programas.