1. De notificar un evento a transportar datos
El bloque anterior estudió señales: avisos de control, cambios de estado y pequeños valores asociados. Ahora queremos conectar programas que producen y consumen contenido: texto, registros, bloques de un archivo o datos binarios.
Una tubería anónima ofrece un canal de bytes administrado por el núcleo. Un proceso escribe por un extremo y otro lee por el otro. El canal conserva temporalmente los bytes pendientes y proporciona reglas de espera cuando productor y consumidor no avanzan a la misma velocidad.
Ya viste tuberías en ejemplos introductorios y al capturar la salida de un comando. Este bloque las desarrolla como herramienta: primero su creación y uso directo, después EOF, SIGPIPE y capacidad, y finalmente la composición de comandos y las conversaciones con dos canales.
Una tubería anónima es un flujo unidireccional de bytes accesible mediante descriptores. Crear el canal no crea procesos, no comparte variables y no define por sí solo el formato de los datos.
2. Crear el canal con pipe
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
/* No usar los extremos como si la creacion hubiera tenido exito. */
}Si tiene éxito, pipe devuelve cero y escribe dos descriptores en el arreglo: canal[0] es el extremo de lectura y canal[1] el de escritura. El arreglo no contiene el mensaje ni el espacio donde el núcleo lo almacena.
Los índices 0 y 1 del arreglo no deben confundirse con los números de descriptor. En una terminal donde 0, 1 y 2 estén ocupados y no haya otras aperturas, podrías obtener 3 y 4, pero esos números no son una promesa. Usa los valores devueltos.
La forma habitual de preparar un intercambio con un hijo es crear el canal antes de fork. Por ahora la llamada solo afecta a los recursos del proceso actual. La interfaz, sus resultados y los flags de pipe2 se documentan en pipe(2).
En el programa del tema 8 usamos pipe2 para solicitar flags al crear. Aquí empezamos con pipe para concentrarnos en el modelo básico; el canal creado por esta llamada se utiliza inicialmente en modo bloqueante y sus descriptores no quedan marcados automáticamente como close-on-exec.
3. Dos extremos y una dirección
El padre puede producir y el hijo consumir, o al revés. Lo que determina la dirección es qué extremo conserva cada participante. No se convierte en un canal de respuesta porque ambos procesos tengan un descriptor.
Leer del extremo escritor o escribir en el lector no es el uso de una tubería POSIX unidireccional. Tampoco permite lseek para retroceder y volver a leer: los bytes consumidos salen del flujo. Si necesitas una conversación en ambas direcciones, prepara dos canales o elige otro mecanismo.
Que sea anónima significa que no se publica con una ruta para abrirla después como una FIFO. Los participantes necesitan obtener referencias a sus extremos, normalmente por herencia y, en diseños más avanzados, por transferencia de descriptores.
4. Un flujo de bytes, no una cadena
La tubería no sabe de líneas, terminadores nulos ni estructuras C. Si envías A, un byte cero y B, los tres forman parte del contenido. read devuelve una cantidad, no añade un terminador nulo para printf con %s.
De la misma forma, dos llamadas a write no crean dos mensajes recuperables como tales. El lector puede obtener un fragmento de un envío o combinar bytes de varios, según su tamaño de lectura y los datos disponibles.
Para enviar una cadena de texto debes acordar si viaja su terminador, su longitud, un salto de línea o algún otro formato. Para transmitir datos binarios conviene usar cantidades explícitas. La creación del canal y la delimitación del protocolo son decisiones separadas.
5. Experimento: A, cero y B
El primer laboratorio usa ambos extremos en el mismo proceso para observar los bytes sin introducir aún la planificación entre procesos. Envía solo tres bytes, cierra el escritor y consume el flujo. Esta secuencia pequeña no es un patrón general para enviar archivos completos antes de empezar a leer.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
static int escribir_todo(int fd, const unsigned char *datos, size_t total)
{
size_t usados = 0;
while (usados < total) {
ssize_t n = write(fd, datos + usados, total - usados);
if (n > 0) {
usados += (size_t)n;
} else if (n == -1 && errno == EINTR) {
continue;
} else {
if (n == 0)
errno = EIO;
return -1;
}
}
return 0;
}
int main(void)
{
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
return EXIT_FAILURE;
}
printf("Lector: %d; escritor: %d\n", canal[0], canal[1]);
const unsigned char datos[] = {'A', 0, 'B'};
if (escribir_todo(canal[1], datos, sizeof datos) == -1) {
perror("write");
close(canal[0]);
close(canal[1]);
return EXIT_FAILURE;
}
close(canal[1]);
unsigned char buffer[2];
size_t total = 0;
int resultado = EXIT_SUCCESS;
for (;;) {
ssize_t n = read(canal[0], buffer, sizeof buffer);
if (n > 0) {
printf("Lectura de %zd %s:", n, n == 1 ? "byte" : "bytes");
for (ssize_t i = 0; i < n; i++)
printf(" %02X", (unsigned int)buffer[i]);
putchar('\n');
total += (size_t)n;
} else if (n == 0) {
printf("EOF; total recibido: %zu bytes\n", total);
break;
} else if (errno != EINTR) {
perror("read");
resultado = EXIT_FAILURE;
break;
}
}
close(canal[0]);
return resultado;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic explorar_pipe.c -o explorar_pipe
$ ./explorar_pipe
Lector: 3; escritor: 4
Lectura de 2 bytes: 41 00
Lectura de 1 byte: 42
EOF; total recibido: 3 bytes41, 00 y 42 representan los tres bytes en hexadecimal en este entorno. El cero no hizo terminar el flujo: viajó como contenido. El fin se reconoció cuando no quedaron bytes ni escritores abiertos. Los números de descriptor y la partición de las lecturas deben tratarse como resultados observados, no como constantes del programa.
6. Compartir el canal mediante fork
Si creas la tubería antes de fork, el hijo hereda entradas de descriptor que se refieren al mismo canal del núcleo. El arreglo canal se copia como parte de la memoria, pero sus enteros siguen identificando referencias a los extremos compartidos.
No se copian dos colas independientes con los mismos datos. Si el padre escribe en su escritor, el hijo puede leer desde su lector. Si, en cambio, cada rama llama a pipe después de fork, cada una crea un canal diferente y no se conectan por tener los mismos números.
Al principio quedan dos referencias lectoras y dos escritoras, una de cada tipo en cada proceso. Para un intercambio simple debes decidir cuáles sobran. La herencia de los descriptores se documenta en fork(2).
7. Escribir un plan de cierres
En el proyecto el padre enviará datos y el hijo los transformará. El plan se puede escribir antes del código:
| Participante | Conserva | Cierra |
|---|---|---|
| Padre productor | canal[1] mientras envía. | canal[0] al comenzar; canal[1] al terminar el envío. |
| Hijo consumidor | canal[0] mientras recibe. | canal[1] al comenzar; canal[0] al finalizar. |
Esos cierres no son solo una optimización. Si el hijo conserva un escritor abierto, puede consumir todos los bytes y quedarse esperando más en su propio lector, aunque el padre ya haya cerrado. Si el padre espera entonces que el hijo termine, ninguno avanzará.
El cierre del último escritor permite reconocer EOF después de consumir lo pendiente. El detalle de esa condición, la pérdida de lectores y la capacidad se estudia en el tema 12; aquí ya utilizaremos el cierre correcto como parte del protocolo.
8. Proyecto: transformar la entrada en otro proceso
El padre leerá de la entrada estándar o de un archivo indicado como argumento. Enviará esos bytes por la tubería y el hijo convertirá únicamente las letras ASCII a–z a A–Z, escribiendo el resultado por su salida estándar. Los demás bytes, incluido cero, se conservarán.
Guarda el programa como transformar_pipe.c. Usa búferes de distinto tamaño en cada proceso para que el protocolo no dependa de una lectura por escritura. El padre espera al hijo solo después de cerrar su escritor.
El programa ignora SIGPIPE de forma explícita para gestionar un EPIPE mediante el retorno de write si desaparece el consumidor. También prepara SIGCHLD con su disposición predeterminada para poder recoger al hijo sin depender de una configuración ignorada heredada. Son decisiones de este programa completo, no cambios que una biblioteca deba hacer sin coordinarse.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
static int escribir_todo(int fd, const unsigned char *datos, size_t total)
{
size_t usados = 0;
while (usados < total) {
ssize_t n = write(fd, datos + usados, total - usados);
if (n > 0) {
usados += (size_t)n;
} else if (n == -1 && errno == EINTR) {
continue;
} else {
if (n == 0)
errno = EIO;
return -1;
}
}
return 0;
}
static void consumir(int lector)
{
unsigned char buffer[1024];
for (;;) {
ssize_t n = read(lector, buffer, sizeof buffer);
if (n > 0) {
for (ssize_t i = 0; i < n; i++) {
if (buffer[i] >= 'a' && buffer[i] <= 'z')
buffer[i] = (unsigned char)(buffer[i] - 'a' + 'A');
}
if (escribir_todo(STDOUT_FILENO, buffer, (size_t)n) == -1) {
perror("write de la salida del hijo");
close(lector);
_exit(EXIT_FAILURE);
}
} else if (n == 0) {
close(lector);
_exit(EXIT_SUCCESS);
} else if (errno != EINTR) {
perror("read de la tuberia");
close(lector);
_exit(EXIT_FAILURE);
}
}
}
int main(int argc, char *argv[])
{
if (argc > 2) {
fprintf(stderr, "Uso: %s [archivo]\n", argv[0]);
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;
}
accion.sa_handler = SIG_DFL;
if (sigaction(SIGCHLD, &accion, NULL) == -1) {
perror("preparar SIGCHLD");
return EXIT_FAILURE;
}
int entrada = STDIN_FILENO;
if (argc == 2) {
entrada = open(argv[1], O_RDONLY);
if (entrada == -1) {
perror("open de la entrada");
return EXIT_FAILURE;
}
}
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
if (entrada != STDIN_FILENO)
close(entrada);
return EXIT_FAILURE;
}
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
close(canal[0]);
close(canal[1]);
if (entrada != STDIN_FILENO)
close(entrada);
return EXIT_FAILURE;
}
if (hijo == 0) {
close(canal[1]);
close(entrada); /* El hijo solo consume desde el canal. */
consumir(canal[0]);
}
close(canal[0]);
unsigned char buffer[4096];
int correcto = 1;
for (;;) {
ssize_t n = read(entrada, buffer, sizeof buffer);
if (n > 0) {
if (escribir_todo(canal[1], buffer, (size_t)n) == -1) {
perror("write de la tuberia");
correcto = 0;
break;
}
} else if (n == 0) {
break;
} else if (errno != EINTR) {
perror("read de la entrada");
correcto = 0;
break;
}
}
if (close(canal[1]) == -1) {
perror("close del escritor");
correcto = 0;
}
if (entrada != STDIN_FILENO && close(entrada) == -1) {
perror("close de la entrada");
correcto = 0;
}
int estado;
while (waitpid(hijo, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
if (WIFEXITED(estado)) {
int codigo = WEXITSTATUS(estado);
fprintf(stderr, "Hijo: salida %d\n", codigo);
if (codigo != 0)
correcto = 0;
} else if (WIFSIGNALED(estado)) {
fprintf(stderr, "Hijo terminado por senal %d\n", WTERMSIG(estado));
correcto = 0;
} else {
correcto = 0;
}
return correcto ? EXIT_SUCCESS : EXIT_FAILURE;
}El hijo termina con _exit, porque ya envió su salida usando write y no necesita vaciar un búfer de stdout heredado. El padre no imprime datos del protocolo en su salida estándar; el informe de terminación va a stderr.
Ejecuta el ejemplo desde un entorno normal con los descriptores estándar abiertos. No es una conversión general de Unicode: trabaja sobre los bytes de las letras ASCII. Una letra acentuada en UTF-8 conserva sus bytes, no se convierte aquí a su mayúscula lingüística.
9. Probar texto, entrada vacía y datos grandes
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 transformar_pipe.c -o transformar_pipe
$ printf 'hola\nPipe 123\n' | ./transformar_pipe
HOLA
PIPE 123
Hijo: salida 0
$ printf 'otro ejemplo\n' > entrada.txt
$ ./transformar_pipe entrada.txt > salida.txt
$ cat salida.txt
OTRO EJEMPLOEl orden visible del informe de stderr puede variar respecto del texto. Al redirigir stdout, el archivo salida.txt contiene solo el flujo transformado, no el informe del padre.
$ printf '' | ./transformar_pipe > vacia.bin
$ wc -c < vacia.bin
0
$ printf 'a\000b\n' | ./transformar_pipe | od -An -tx1
41 00 42 0aEl cero vuelve a viajar como contenido y el hijo convierte a y b. El tratamiento no usa strlen para calcular lo recibido y no añade bytes que no estuvieran presentes.
$ dd if=/dev/zero of=bloques.bin bs=1024 count=256
$ ./transformar_pipe bloques.bin > bloques_salida.bin
$ cmp bloques.bin bloques_salida.bincmp no muestra diferencias y termina con cero si los archivos coinciden. Como el archivo contiene ceros, la transformación los conserva. El intercambio no reserva memoria para todo el archivo ni presupone una capacidad concreta del canal: productor y consumidor avanzan a través de sus bucles.
En un pipeline, el estado final que muestra la shell puede corresponder al último comando y no al transformador. Para diagnosticar su estado de forma aislada, utiliza la variante con archivo de entrada y redirección de salida y consulta $? inmediatamente después.
10. Interpretar cada lectura
read intenta entregar hasta el tamaño solicitado. Un retorno positivo significa que esos bytes son válidos, aunque sean menos de los pedidos. No exige que el emisor haya llenado tu búfer y no conserva los límites de sus llamadas a write.
| Situación del lector | Resultado que importa | Qué hace el programa |
|---|---|---|
| Hay bytes disponibles. | Una cantidad positiva. | Procesa exactamente esa cantidad. |
| No hay bytes, pero queda un escritor. | Una lectura bloqueante puede esperar. | El otro proceso debe poder producir o cerrar. |
| No hay bytes ni escritores. | 0 para una petición de lectura de tamaño positivo. | Finaliza la recepción de este flujo. |
| Una señal interrumpe sin entregar bytes. | −1 con EINTR, cuando la interfaz retorna así. | Reintenta en este protocolo. |
| Otro error. | −1 y errno. | Informa y abandona el recorrido correspondiente. |
El tamaño del búfer determina cuántos bytes puedes recibir como máximo en una llamada, no el tamaño de un mensaje del emisor. Tampoco un read de tamaño cero sirve para comprobar EOF. Los resultados están documentados en read(2).
El proyecto transforma fragmentos de forma independiente porque cada byte ASCII puede decidirse por sí solo. Un protocolo con longitudes, registros o caracteres multibyte podría necesitar conservar un fragmento entre lecturas. Esa estructura no la proporciona automáticamente la tubería.
11. Progreso de escritura y capacidad
write devuelve cuántos bytes aceptó. La función escribir_todo conserva un offset y continúa desde el primer byte pendiente, reintentando EINTR cuando corresponde. No vuelve al inicio de un bloque que ya se aceptó parcialmente.
El canal tiene capacidad finita. Si el productor avanza más rápido, una escritura bloqueante puede esperar hasta que el consumidor libere espacio. Eso permite acoplar ritmos, pero exige que el consumidor pueda ejecutarse: no debes esperar que termine antes de empezar a drenar una salida grande.
En el primer experimento se escribían solo tres bytes antes de leer. Si hicieras lo mismo con un archivo arbitrariamente grande en un único proceso, podrías llenar el canal y quedar esperando a un lector que todavía no ejecutaste. El proyecto evita esa dependencia usando dos procesos que pueden avanzar concurrentemente.
El resultado de escritura no confirma que el hijo procesó el contenido ni que su salida se guardó de forma durable. El padre recoge además la terminación, pero ese estado tampoco sustituye un contrato de persistencia. Los retornos parciales y errores se detallan en write(2).
La capacidad y el límite de atomicidad PIPE_BUF son conceptos diferentes. No los utilizamos como una constante del protocolo. El tema 12 profundizará en esa distinción y en lo que ocurre al desaparecer lectores o escritores.
12. Errores y vida útil del canal
Una tubería no necesita un nombre que retirar con unlink, pero sí referencias que cerrar. El objeto del núcleo puede seguir existiendo mientras conserve referencias relevantes en los procesos. No hay que buscar un archivo temporal que represente el contenido del canal.
| Punto de fallo | Recursos que ya existen | Respuesta del proyecto |
|---|---|---|
| Apertura de entrada | Solo la configuración inicial del programa. | Informa y termina sin crear un hijo. |
| pipe | La entrada, si fue abierta por esta instancia. | Cierra esa entrada propia y termina. |
| fork | Los dos extremos y la entrada. | Cierra las referencias preparadas; no espera un hijo inexistente. |
| Lectura o envío del padre | Un hijo y un flujo que puede estar incompleto. | Marca el fallo, cierra el escritor y recoge al hijo. |
| Transformación o salida del hijo | El lector y una posible salida parcial. | Informa, cierra y termina con fallo. |
Si falla una lectura de la entrada después de enviar varios bloques, el hijo puede haber emitido un prefijo válido. El proyecto no es una transacción que deshaga salida ya escrita. El padre debe informar un resultado global fallido aunque el hijo haya recibido EOF y terminado con cero.
Los errores de creación pueden estar relacionados con límites de descriptores o recursos del sistema. Antes de aumentar límites, comprueba si tu aplicación deja canales abiertos en cada solicitud. El tema 5 ofrece el método general de clasificación y conservación de errores.
waitpid recoge al hijo; cerrar el canal no cumple esa responsabilidad por sí solo. Y recoger al hijo no corrige una referencia escritora que quedó abierta en otro proceso. Cada operación resuelve una parte de la vida útil. El contrato de espera está en waitpid(2).
Estos ejemplos son de un hilo y usan canales bloqueantes. Si añades hilos, otros recolectores, modo no bloqueante o cancelación, tendrás que revisar la propiedad de los descriptores y cómo conservas el progreso pendiente.
13. Observar la tubería en Linux
strace permite ver la creación del canal y las operaciones de ambos procesos. Usa -f para seguir al hijo y un archivo de entrada si quieres mantener la prueba fácil de reproducir:
$ strace -f -o tuberia.log ./transformar_pipe entrada.txt > salida.txt
$ less tuberia.logPuedes encontrar pipe o pipe2, clone o una variante de creación del hijo, los cierres, las lecturas y escrituras y la espera. Que la biblioteca implemente pipe mediante otra llamada del núcleo no cambia los dos extremos que recibe tu código.
En una traza de texto verás a veces bytes escapados y operaciones que retornan antes de completar el tamaño solicitado. Observa la cantidad devuelta, no solo el texto que representa la herramienta. Para correlacionar el flujo, identifica proceso, descriptor y cierre.
También puedes consultar /proc/PID/fd mientras un proceso siga vivo. Una forma sencilla de mantenerlo esperando es ejecutar ./transformar_pipe sin archivo desde una terminal y todavía no introducir texto: el padre espera su entrada y el hijo espera datos del canal.
$ ps -eo pid,ppid,stat,args
$ ls -l /proc/PID/fdSustituye PID por el padre o el hijo de tu prueba. Los enlaces pueden mostrar pipe:[identificador]; los extremos del mismo canal pueden compartir ese identificador. Si estás dentro de un pipeline, puede haber otras tuberías de la shell: no identifiques tu canal solo porque aparezca la palabra pipe.
Termina la entrada del padre desde su terminal cuando quieras completar la práctica. La visibilidad de /proc depende de permisos y del entorno, y el proceso puede terminar antes de la consulta. La interfaz y el comportamiento general de las tuberías se describen en pipe(7).
14. Construir el intercambio paso a paso
Selecciona la dirección, crea el canal, haz fork y cierra los extremos sobrantes. Solo después se habilitan el envío y la lectura. Los descriptores 3 y 4 son una elección del modelo, suponiendo que los estándar estaban abiertos.
| Proceso | fd 3 | fd 4 |
|---|---|---|
| Padre | — | — |
| Hijo | No existe | No existe |
Bytes pendientesVacío
Bytes recibidosNinguno
Referencias escritoras0
Última lecturaSin lecturas
Crear pipe prepara recursos en el padre; todavía no crea un hijo.
Prueba leer antes de enviar; envía ABC dos veces y consume de dos en dos; cierra el escritor cuando todavía queden datos y sigue leyendo. El consumidor no depende del número de llamadas del productor y todavía puede consumir bytes después del cierre.
El modelo representa una lectura bloqueante mediante un aviso, no dejando la página suspendida. Para reintentar debes pulsar otra vez. Elige hasta dos bytes disponibles para mostrar la fragmentación, pero no promete esa misma partición en una ejecución real.
No simula capacidad, señales ni terminación de procesos. «Cerrar escritor» cierra una referencia; no significa ejecutar exit ni recoger al hijo. El tema siguiente permitirá analizar con más detalle los estados de EOF y la pérdida de lectores.
15. Resumen
- pipe crea un canal y devuelve dos descriptores; no crea procesos.
- canal[0] es el lector y canal[1] el escritor; sus números reales no están fijados.
- El flujo transporta bytes, incluidos ceros, y no conserva fronteras de write.
- Crear antes de fork permite heredar referencias al mismo canal.
- El padre no tiene que ser siempre el productor: la dirección depende de los extremos conservados.
- Cerrar referencias sobrantes forma parte del protocolo de finalización.
- read y write requieren bucles que respeten los bytes realmente transferidos.
- Productor y consumidor deben poder avanzar sin esperar una terminación que dependa del canal.
- Cerrar el canal y recoger al hijo son responsabilidades diferentes.
16. Preguntas de repaso y práctica
Responde antes de abrir la explicación.
1. ¿Qué contiene el arreglo pasado a pipe?
Dos números de descriptor que referencian los extremos. No contiene el mensaje ni el búfer de datos administrado por el núcleo.
2. ¿canal[0] tiene que valer cero?
No. Cero es el índice del elemento lector en el arreglo. El número de descriptor devuelto depende de las aperturas actuales del proceso.
3. ¿Por qué el byte cero no termina la lectura del primer experimento?
Porque es contenido del flujo. La tubería no aplica la convención de terminación de cadenas C. El programa usa la cantidad retornada por read.
4. ¿Dos write obligan a realizar dos read?
No. El receptor puede leer fragmentos o combinar bytes. El protocolo debe delimitar sus unidades si las necesita.
5. ¿Por qué crear la tubería antes de fork?
Para que ambos procesos obtengan referencias a los mismos extremos. Dos llamadas separadas en las ramas crearían canales independientes.
6. ¿El padre debe leer y el hijo escribir?
No. Puede elegirse cualquiera de las dos direcciones. Lo importante es conservar el escritor en el productor y el lector en el consumidor.
7. ¿Qué ocurre si el hijo consumidor conserva un escritor?
Después de consumir los bytes puede seguir esperando, porque su propia referencia impide que desaparezcan todos los escritores y se observe EOF.
8. ¿Cerrar el escritor descarta los datos pendientes?
No. El lector puede consumirlos y después detectar el fin del flujo si no queda otra referencia escritora.
9. ¿Por qué no escribir un archivo arbitrario completo antes de empezar a leer en el mismo proceso?
Porque el canal tiene capacidad finita y write puede esperar espacio. Si ese mismo flujo todavía no ejecutó al lector, puede detenerse sin posibilidad de progreso.
10. ¿Por qué el transformador usa unsigned char?
Para tratar el contenido como bytes y hacer explícita la transformación limitada a ASCII, conservando los demás valores en lugar de interpretarlos como una cadena.
11. ¿Qué indica que el hijo termine con cero?
Que completó su recorrido previsto. El padre todavía debe comprobar sus propios errores de entrada y envío, y el resultado no implica persistencia durable.
12. ¿Hace falta borrar una ruta al cerrar una tubería anónima?
No tiene una ruta pública creada para abrirla después. Hay que cerrar las referencias y recoger los procesos correspondientes; una FIFO con nombre tiene otra gestión.
Para practicar
- Cambia el búfer de explorar_pipe a un byte y después a ocho. Comprueba que el total sigue siendo tres y que el cero continúa formando parte del contenido.
- Añade otro byte al arreglo del primer laboratorio y explica por qué sizeof datos incluye ese nuevo contenido.
- Ejecuta transformar_pipe con texto, entrada vacía y un archivo binario. Compara el tamaño de entrada y salida y recuerda qué bytes deben cambiar.
- Reduce el búfer del hijo a siete bytes y el del padre a trece. Comprueba que el resultado no depende de alinear sus bloques.
- Entrega al proyecto un archivo inexistente y después una entrada cuya lectura falle en tu entorno. Distingue errores anteriores y posteriores a crear el hijo.
- En una copia del proyecto, omite el cierre del escritor en el hijo y ejecuta la prueba pequeña con timeout 3s. Explica la espera final y restaura el cierre.
- En el simulador, invierte la dirección del flujo. Dibuja qué referencias conserva cada proceso después del plan de cierres.
- Localiza en una traza la creación del canal, la del hijo, los cierres y la espera. Identifica cuál de los procesos produce cada bloque de salida.