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:
- Contenido pendiente. Los bytes escritos que todavía no se consumieron.
- Referencias lectoras y escritoras. Los descriptores abiertos que mantienen esos extremos, en cualquier proceso.
- Modo de E/S. Si la operación puede esperar o debe retornar cuando no puede progresar.
- Tamaño solicitado. Especialmente su relación con PIPE_BUF para escribir.
- Disposición de SIGPIPE. Qué hace el proceso al escribir cuando no quedan lectores.
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 bloqueante | Lector no bloqueante |
|---|---|---|---|
| Sí | Sí o no. | Puede recibir bytes. | Puede recibir bytes. |
| No | Sí. | Espera datos o un cambio relevante. | Retorna −1 con EAGAIN. |
| No | No. | 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.
#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;
}$ 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: EOFEl 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.
#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;
}$ 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 normalmenteEl 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.
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ño | Modo bloqueante | Modo no bloqueante |
|---|---|---|
| n ≤ PIPE_BUF | La 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_BUF | No 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.
#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;
}$ 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: EOFLos 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.
- Lectura de un canal vacío. Necesita datos o el cierre de todos los escritores.
- Escritura que no cabe. Necesita que un lector consuma, además de conservar al menos un lector.
- waitpid antes de drenar una salida. Puede esperar a un hijo que está esperando espacio para terminar de escribir.
- Canal de respuesta. Con dos tuberías, ambos procesos pueden llenar su salida si nadie avanza leyendo.
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íntoma | Pregunta 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? |
$ strace -f -o sigpipe.log ./probar_sigpipe predeterminada
$ strace -o capacidad.log ./medir_tuberia
$ less sigpipe.logEn 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
- EOF requiere canal vacío y ausencia de escritores; vacío con escritores es otra condición.
- Una referencia duplicada o heredada puede prolongar el extremo aunque no se use.
- Cerrar el último escritor no elimina los bytes ya pendientes.
- Escribir sin lectores genera SIGPIPE; la política de la señal determina si se puede gestionar EPIPE normalmente.
- La capacidad es almacenamiento pendiente y puede producir contrapresión.
- PIPE_BUF es un límite de atomicidad de escritura, distinto de la capacidad total.
- Las escrituras pequeñas no bloqueantes no aceptan un prefijo cuando no pueden completarse.
- Las escrituras grandes pueden requerir progreso parcial o espera y no garantizan atomicidad.
- La atomicidad no crea mensajes para el lector ni corrige una dependencia circular.
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
- Ejecuta eof_referencias y localiza el escritor original y la copia. Explica en qué momento desaparece la última referencia.
- En una copia del primer laboratorio, conserva una segunda duplicación y ciérrala después. Predice por qué no aparecerá EOF hasta retirarla.
- 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.
- Ejecuta medir_tuberia y registra capacidad, PIPE_BUF y bytes recuperados. No uses el resultado como una constante para otro equipo.
- 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.
- Diseña un registro que quepa en PIPE_BUF y un lector capaz de reconstruirlo aunque llegue dividido. Incluye límites y validación.
- En el evaluador, deja dos bytes utilizables y solicita cuatro. Compara modo bloqueante y no bloqueante. Después solicita seis y explica qué cambia.
- 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.
Con las condiciones del canal claras, el tema 13 conectará comandos mediante dup2 y exec para construir una tubería de dos programas.