1. Componer programas mediante sus descriptores
En los temas 11 y 12 escribimos y leímos directamente los extremos de una tubería. Ahora reutilizaremos programas existentes. Por ejemplo, printf genera tres líneas y wc cuenta cuántas recibe:
$ printf 'rojo\nverde\nazul\n' | wc -l
3La shell crea el canal y los procesos, conecta sus descriptores y los espera. printf solo escribe en su salida estándar; wc solo lee de su entrada estándar. El núcleo transporta los bytes entre ambos.
Para construir un pipeline se combinan cuatro tareas: pipe crea el canal, fork crea los procesos, dup2 prepara los descriptores y exec carga los comandos. Ninguna de estas operaciones sustituye las otras.
El padre será un supervisor: conservará los PID para recoger a sus hijos, pero no copiará el contenido entre ellos. Esta separación permite que ambos comandos progresen a la vez, sujetos a la contrapresión del canal.
2. Entrada, salida y diagnósticos
Los programas de terminal suelen recibir tres descriptores ya abiertos. Las constantes de unistd.h permiten nombrarlos sin escribir números en cada operación.
| Descriptor | Constante | Uso convencional | En el pipeline |
|---|---|---|---|
| 0 | STDIN_FILENO | Entrada estándar. | El consumidor lo conectará al lector del canal. |
| 1 | STDOUT_FILENO | Salida de resultados. | El productor lo conectará al escritor del canal. |
| 2 | STDERR_FILENO | Diagnósticos. | Ambos hijos lo conservarán para informar errores. |
Estos números no significan necesariamente teclado y pantalla: pueden apuntar a archivos, tuberías u otros recursos. Si ejecutas nuestro supervisor con su salida redirigida a un archivo, el consumidor heredará ese destino.
Redirigir stdout no redirige stderr. Esta diferencia evita que un mensaje como «no se encontró el comando» pase a formar parte de los datos que cuenta wc. Tampoco garantiza un orden visual entre mensajes escritos por procesos distintos.
3. Redirigir con dup2
if (dup2(canal[1], STDOUT_FILENO) == -1) {
perror("dup2 salida");
_exit(126);
}
/* Si son numeros distintos, retirar la referencia original. */
if (canal[1] != STDOUT_FILENO)
close(canal[1]);dup2(origen, destino) hace que destino se refiera al mismo recurso abierto que origen. Si destino estaba abierto, lo reemplaza atómicamente. Retorna destino al tener éxito y −1 al fallar; no mueve los bytes ni elimina origen.
Si origen y destino son iguales y válidos, no cambia nada. Por eso el fragmento evita cerrar después el propio descriptor estándar. Con números distintos, ambos quedan abiertos hasta que se cierre uno.
No simules esta operación con close(1) seguido de dup: otra asignación de descriptor podría ocupar ese número entre ambas llamadas. Consulta las reglas de duplicación en dup(2).
Para simplificar el plan de cierres, los programas completos de este tema comprueban que 0, 1 y 2 estén abiertos antes de crear recursos. Así los archivos y extremos nuevos tendrán números mayores que 2. Es una precondición explícita del laboratorio; un lanzador general también debe resolver las colisiones cuando recibe descriptores estándar cerrados.
4. Reemplazar el programa con exec
char *argumentos[] = {"wc", "-l", NULL};
execvp(argumentos[0], argumentos);
/* Solo se alcanza este punto si execvp fallo. */
int causa = errno;
perror("execvp wc");
_exit(causa == ENOENT ? 127 : 126);exec reemplaza el programa del proceso que lo invoca; su PID sigue siendo el mismo. Si tiene éxito no retorna. execvp recibe un vector de argumentos y busca el comando mediante PATH cuando su nombre no contiene una barra. execv recibe una ruta; execl expresa los argumentos como una lista.
argv[0] contiene por convención el nombre del programa, y el último elemento del vector debe ser NULL. Opciones y valores ocupan entradas separadas. Pasar "wc -l" como nombre intentaría encontrar un ejecutable con ese nombre completo.
execvp no interpreta una línea de shell: "|" y ">" como argumentos no crean conexiones. Su tratamiento especial de ciertos archivos sin formato ejecutable puede recurrir a un intérprete; eso no convierte el vector recibido en una línea de órdenes. Véase exec(3).
El hijo que no logra ejecutar debe informar el fallo y terminar. Usamos _exit para evitar vaciar otra vez los búferes de stdio copiados del padre o ejecutar sus funciones registradas con atexit. Esta terminación sí cierra los descriptores del hijo; está descrita en _exit(2).
5. Experimento: contar líneas de un archivo
Antes de conectar dos comandos, ejecutaremos uno con entrada y salida redirigidas. El hijo abrirá un archivo de entrada, creará el de resultados y ejecutará wc -l. El padre mantendrá sus propios descriptores estándar.
El archivo de salida se abre con O_TRUNC: si existe, su contenido se borra. Utiliza rutas diferentes para entrada y salida y archivos de práctica. El modo 0666 se filtra mediante umask al crear el archivo. Para añadir contenido se estudiaría O_APPEND en lugar de O_TRUNC; las opciones pertenecen a open(2).
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
if (argc != 3) {
fprintf(stderr, "Uso: %s entrada salida\n", argv[0]);
return EXIT_FAILURE;
}
for (int fd = 0; fd <= 2; ++fd) {
if (fcntl(fd, F_GETFD) == -1) {
perror("Se requieren 0, 1 y 2 abiertos");
return EXIT_FAILURE;
}
}
pid_t hijo = fork();
if (hijo == -1) {
perror("fork");
return EXIT_FAILURE;
}
if (hijo == 0) {
int entrada = open(argv[1], O_RDONLY);
if (entrada == -1) {
perror("open entrada");
_exit(126);
}
int salida = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (salida == -1) {
perror("open salida");
close(entrada);
_exit(126);
}
if (dup2(entrada, STDIN_FILENO) == -1 ||
dup2(salida, STDOUT_FILENO) == -1) {
perror("dup2");
_exit(126); /* _exit cierra tambien entrada y salida. */
}
close(entrada);
close(salida);
char *comando[] = {"wc", "-l", NULL};
execvp(comando[0], comando);
int causa = errno;
perror("execvp wc");
_exit(causa == ENOENT ? 127 : 126);
}
int estado;
while (waitpid(hijo, &estado, 0) == -1) {
if (errno == EINTR)
continue;
perror("waitpid");
return EXIT_FAILURE;
}
if (WIFEXITED(estado))
return WEXITSTATUS(estado);
if (WIFSIGNALED(estado)) {
fprintf(stderr, "wc termino por senal %d\n", WTERMSIG(estado));
return 128 + WTERMSIG(estado);
}
return EXIT_FAILURE;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic redirigir_wc.c -o redirigir_wc
$ printf 'uno\ndos\ntres\n' > entrada13.txt
$ ./redirigir_wc entrada13.txt salida13.txt
$ cat salida13.txt
3
$ ./redirigir_wc no-existe13.txt salida13.txt
open entrada: No such file or directory
$ echo $?
126El texto del error depende del idioma del sistema. Si falla la apertura de entrada, no se abre ni trunca la salida. Si falla exec después de abrir la salida, esta ya pudo quedar truncada: preparar una redirección y ejecutar el comando son pasos distintos.
Este primer programa supone el entorno habitual de una shell: SIGCHLD permite recoger al hijo. El siguiente ejemplo deja esa disposición explícita e incorpora la preparación de SIGPIPE para los comandos.
6. Diseñar el pipeline y su plan de cierres
Crearemos una tubería y dos hijos. El izquierdo será el productor y el derecho, el consumidor. El padre no conservará ningún extremo después de crearlos.
| Proceso | Redirección | Cierres antes de exec o waitpid | Referencias finales al canal |
|---|---|---|---|
| Productor. | dup2(canal[1], 1). | Cierra canal[0] y canal[1]. | Solo stdout como escritor. |
| Consumidor. | dup2(canal[0], 0). | Cierra canal[0] y canal[1]. | Solo stdin como lector. |
| Padre. | Ninguna. | Cierra canal[0] y canal[1]. | Ninguna. |
El cierre del número original después de dup2 conserva la referencia estándar. En cambio, dejar un escritor extra en el padre puede impedir EOF. Dejar un lector extra puede impedir que el productor detecte que su consumidor desapareció. Son las condiciones estudiadas en el tema 12.
7. Crear ambos hijos antes de esperar
- Crear el canal. Ningún proceso se ha duplicado todavía.
- Crear el productor. Su rama prepara stdout, cierra sobrantes y ejecuta el primer comando.
- Crear el consumidor. Su rama prepara stdin, cierra sobrantes y ejecuta el segundo comando.
- Cerrar los extremos del padre. El supervisor ya no participa en el flujo.
- Recoger ambos PID. Conservar y comprobar sus estados.
Si el padre espera al productor antes de crear al consumidor, puede formar una dependencia imposible: el productor necesita espacio, el espacio requiere lecturas y el lector todavía no existe. Una prueba pequeña podría terminar porque cabe completa en el canal; una grande dejaría visible el error.
Después de crear ambos hijos y cerrar los extremos del padre, se puede esperar primero a cualquiera de ellos. waitpid suspende al padre, no al otro hijo, que sigue pudiendo consumir. El orden de creación tampoco obliga a que el productor ejecute primero.
8. Proyecto: ejecutar dos comandos conectados
El programa recibe dos vectores separados por un argumento --. Cada comando puede tener opciones. Se exige exactamente un separador y al menos un nombre a cada lado. No implementaremos comillas, expansión de variables ni una shell completa: la shell que invoca el programa ya construye sus argumentos.
Si el segundo fork falla, se cierran los extremos, se cancela el hijo ya creado y se lo recoge. En esta ruta excepcional usamos SIGKILL para que un comando arbitrario no pueda ignorar la cancelación. Esto no revierte los efectos que haya producido antes del fallo.
#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/wait.h>
#include <unistd.h>
static int recoger(pid_t pid, int *estado)
{
for (;;) {
if (waitpid(pid, estado, 0) != -1)
return 0;
if (errno != EINTR)
return -1;
}
}
static void preparar_hijo(void)
{
struct sigaction accion = {0};
accion.sa_handler = SIG_DFL;
sigset_t conjunto;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGPIPE, &accion, NULL) == -1 ||
sigemptyset(&conjunto) == -1 ||
sigaddset(&conjunto, SIGPIPE) == -1 ||
sigprocmask(SIG_UNBLOCK, &conjunto, NULL) == -1) {
perror("preparar SIGPIPE");
_exit(126);
}
}
static void ejecutar(char **comando, int origen, int destino,
const int canal[2])
{
preparar_hijo();
if (dup2(origen, destino) == -1) {
perror("dup2");
_exit(126);
}
/* canal[0] y canal[1] son mayores que 2: no cerramos destino. */
close(canal[0]);
close(canal[1]);
execvp(comando[0], comando);
int causa = errno;
perror(comando[0]);
_exit(causa == ENOENT ? 127 : 126);
}
static int informar(const char *nombre, int estado)
{
if (WIFEXITED(estado)) {
int codigo = WEXITSTATUS(estado);
fprintf(stderr, "%s: salida %d\n", nombre, codigo);
return codigo;
}
if (WIFSIGNALED(estado)) {
int senal = WTERMSIG(estado);
fprintf(stderr, "%s: senal %d\n", nombre, senal);
return 128 + senal;
}
return EXIT_FAILURE;
}
int main(int argc, char *argv[])
{
int separador = -1;
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--") == 0) {
if (separador != -1) {
fprintf(stderr, "Se requiere exactamente un separador --\n");
return 2;
}
separador = i;
}
}
if (separador <= 1 || separador == argc - 1) {
fprintf(stderr, "Uso: %s comando1 [args] -- comando2 [args]\n",
argv[0]);
return 2;
}
argv[separador] = NULL;
char **izquierdo = &argv[1];
char **derecho = &argv[separador + 1];
for (int fd = 0; fd <= 2; ++fd) {
if (fcntl(fd, F_GETFD) == -1) {
perror("Se requieren 0, 1 y 2 abiertos");
return EXIT_FAILURE;
}
}
struct sigaction accion = {0};
accion.sa_handler = SIG_DFL;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGCHLD, &accion, NULL) == -1) {
perror("preparar SIGCHLD");
return EXIT_FAILURE;
}
int canal[2];
if (pipe(canal) == -1) {
perror("pipe");
return EXIT_FAILURE;
}
pid_t productor = fork();
if (productor == -1) {
perror("fork productor");
close(canal[0]);
close(canal[1]);
return EXIT_FAILURE;
}
if (productor == 0)
ejecutar(izquierdo, canal[1], STDOUT_FILENO, canal);
pid_t consumidor = fork();
if (consumidor == -1) {
perror("fork consumidor");
close(canal[0]);
close(canal[1]);
if (kill(productor, SIGKILL) == -1 && errno != ESRCH)
perror("kill productor");
int descartado;
if (recoger(productor, &descartado) == -1)
perror("waitpid productor");
return EXIT_FAILURE;
}
if (consumidor == 0)
ejecutar(derecho, canal[0], STDIN_FILENO, canal);
close(canal[0]);
close(canal[1]);
int estado1, estado2;
int error1 = recoger(productor, &estado1);
if (error1 == -1)
perror("waitpid productor");
int error2 = recoger(consumidor, &estado2);
if (error2 == -1)
perror("waitpid consumidor");
if (error1 == -1 || error2 == -1)
return EXIT_FAILURE;
informar("Productor", estado1);
return informar("Consumidor", estado2);
}Al reemplazar el separador por NULL obtenemos el terminador del primer vector sin copiar cadenas. El segundo vector usa el NULL que ya cierra argv. La función ejecutar retorna solo a través de exec con éxito o de _exit ante un fallo: ninguna rama hija continúa creando más procesos.
La interfaz reserva -- para separar comandos: no permite pasar ese argumento literal a ninguno de ellos. Es un límite deliberado de este ejercicio, que se resolvería con otra interfaz o un analizador en una shell más completa.
9. Pruebas normales, grandes y bajo fallos
Ejecuta las pruebas sobre Linux o WSL, como en el tema 3. Se utilizan comandos habituales del sistema. Los estados se muestran por stderr; el resultado del consumidor sale por stdout. La distribución de espacios de wc y el idioma de los errores pueden variar.
$ gcc -std=c17 -Wall -Wextra -Wpedantic pipeline2.c -o pipeline2
$ ./pipeline2 printf 'rojo\nverde\nazul\n' -- wc -l
3
Productor: salida 0
Consumidor: salida 0
$ ./pipeline2 printf '' -- wc -c
0
Productor: salida 0
Consumidor: salida 0
$ ./pipeline2 seq 1 1000000 -- wc -l
1000000
Productor: salida 0
Consumidor: salida 0La última prueba no requiere que quepa todo el resultado en la tubería. Productor y consumidor intercalan su progreso. El límite de capacidad regula la espera, sin imponer un máximo total de bytes transportados durante la ejecución.
$ ./pipeline2 comando_inexistente_13 -- wc -c
comando_inexistente_13: No such file or directory
0
Productor: salida 127
Consumidor: salida 0
$ echo $?
0
$ ./pipeline2 printf 'hola\n' -- comando_inexistente_13
... diagnóstico del comando derecho y estados de ambos hijos ...
$ echo $?
127Cuando falla el productor, su terminación cierra stdout y wc puede observar EOF sin datos. Cuando falla el consumidor, el productor puede haber completado una escritura pequeña antes del cierre o puede encontrar SIGPIPE; no fijes un único estado para él en esa prueba.
$ ./pipeline2 yes -- head -n 1
y
Productor: senal 13
Consumidor: salida 0
$ echo $?
0
$ ./pipeline2 printf hola --
Uso: ./pipeline2 comando1 [args] -- comando2 [args]
$ echo $?
2El 13 mostrado corresponde a SIGPIPE en Linux. yes produce indefinidamente y head se retira después de una línea; que el productor termine por esa señal es coherente con la tarea. El supervisor restablece SIGPIPE para que esta prueba no dependa de que estuviera ignorada al iniciar el programa.
También puedes guardar solo el resultado con ./pipeline2 seq 1 100 -- wc -l > cuenta13.txt. Los mensajes del supervisor seguirán visibles en stderr. Como prueba adicional de datos binarios, conecta head -c 1048576 /dev/zero con wc -c: debe contar 1048576 bytes, aunque todos valgan cero.
10. Interpretar los estados de terminación
El entero escrito por waitpid no es directamente el código de salida. Primero hay que consultar WIFEXITED o WIFSIGNALED y solo entonces aplicar la macro correspondiente. Reintentar EINTR permite continuar una espera interrumpida. El contrato se describe en wait(2).
| Resultado | Interpretación en este programa |
|---|---|
| Salida 0. | El comando informó éxito según su propio contrato. |
| Salida 126 del lanzador. | Falló la preparación o execvp con una causa distinta de ENOENT. |
| Salida 127 del lanzador. | execvp falló con ENOENT; normalmente el comando no existe. |
| Terminación por señal. | Se informa la señal y se convierte a 128 + señal para el retorno del supervisor. |
| Error propio antes de ejecutar. | El supervisor devuelve 1; los argumentos inválidos devuelven 2. |
Elegimos devolver el resultado del comando derecho, aunque siempre recogemos e informamos los dos. Por eso un fallo del productor puede coexistir con un retorno global cero. Una política similar a pipefail seleccionaría un fallo del pipeline; para dos comandos podrías devolver primero el derecho si falló y, en caso contrario, el izquierdo.
Los códigos 126 y 127 son convenciones de este lanzador, no resultados que exec imponga a todo programa. Un comando también puede salir por sí mismo con esos valores. ENOENT puede deberse además a un intérprete ausente. Para distinguir de forma inequívoca «falló exec» de «el programa terminó con 127» se puede añadir un canal de errores cuyo escritor tenga close-on-exec.
Recoger al productor primero no significa que termine primero. Si el consumidor ya salió, su estado seguirá disponible hasta recogerlo. Un supervisor más general puede usar waitpid(-1, ...) y asociar cada PID a su rol.
11. Herencia, close-on-exec y señales
fork copia las referencias de descriptores al hijo. exec conserva por defecto las que no tienen FD_CLOEXEC. Por eso la conexión preparada sobre 0 o 1 puede seguir funcionando cuando ya está cargado wc o printf. El nuevo programa no conserva las variables locales del lanzador.
En Linux, pipe2 con O_CLOEXEC crea ambos extremos marcados para cerrarse en un exec exitoso. Cuando dup2 copia hacia un número distinto, la nueva referencia queda sin FD_CLOEXEC: puede sobrevivir como stdin o stdout. Si origen y destino coinciden, dup2 no retira una marca que ya existiera; ese caso requiere atención en un lanzador que acepte descriptores estándar cerrados.
close-on-exec reduce fugas hacia programas ejecutados, pero no sustituye el plan de cierres: el padre que está esperando no hace exec, y un hijo también puede fallar antes de ejecutarlo. Este ejemplo usa pipe y cierres explícitos para mostrar la vida de cada referencia. Consulta pipe(2) para pipe2 y sus opciones.
La máscara de señales se conserva al ejecutar otro programa. Las disposiciones de señales ignoradas suelen conservarse, mientras que los manejadores instalados se restablecen. Nuestro hijo restablece y desbloquea SIGPIPE; el padre restablece SIGCHLD para poder recoger los hijos. No se trata de una política completa de señales para una shell interactiva. Los atributos conservados se detallan en execve(2).
12. Búferes de biblioteca y límites del ejemplo
El descriptor pertenece a la interfaz del sistema; FILE y sus búferes pertenecen a la biblioteca de C. Un programa puede usar printf y acumular contenido antes de llamar a write. Al detectar que stdout es una tubería puede cambiar su estrategia de buffering, de modo que una línea no siempre aparece inmediatamente en el consumidor.
Este retraso no demuestra que dup2 haya fallado. El programa productor debe vaciar sus búferes cuando su protocolo lo necesite o proporcionar una opción apropiada. Aumentar la capacidad del canal no vacía un búfer que todavía vive en el proceso.
Los ejemplos son programas independientes de un solo hilo. No conservan impresiones pendientes en el padre antes de fork. En un programa que sí las tenga conviene gestionar esos búferes antes de duplicarse. En un proceso con varios hilos, el recorrido del hijo antes de exec debe restringirse a operaciones async-signal-safe; no copies sin revisar el uso didáctico de perror y execvp de este laboratorio.
El supervisor no añade tiempos límite, grupos de procesos, control de trabajos ni cancelación de descendientes. Un comando que nunca termina hará que siga esperando. La próxima shell del bloque ampliará la composición; aquí el objetivo es dominar una conexión y recoger los dos hijos.
13. Explorar la conexión paso a paso
Avanza por un orden posible de preparación. Activa una fuga antes de empezar y observa qué ocurre al terminar el productor y drenar los datos. El modelo muestra referencias, no ejecuta comandos ni representa el orden real del planificador.
EtapaSin canal
PadreSin extremos
ProductorNo creado
ConsumidorNo creado
Crea el canal para comenzar.
Reinicia y compara los dos recorridos. Si el padre espera al consumidor conservando su escritor, el consumidor no obtiene EOF y no termina: esperar no cierra ese descriptor. Debe retirarse la referencia que sostiene la dependencia.
14. Observar y diagnosticar el pipeline
$ strace -f -o pipeline13.log ./pipeline2 printf 'a\nb\n' -- wc -l
$ less pipeline13.logBusca la creación del canal, la duplicación de procesos, dup2, los close, los execve y las esperas. Según la biblioteca, pipe puede aparecer como pipe2 y fork como clone. La búsqueda mediante PATH puede generar varios intentos de execve. Correlaciona cada línea con su PID y no supongas que los extremos siempre tendrán los números 3 y 4.
Con un comando de duración suficiente, ls -l /proc/PID/fd permite inspeccionar sus referencias. El escritor 1 del productor y el lector 0 del consumidor deben identificar la misma tubería. El padre no debe conservar referencias a ella después de preparar ambos hijos.
| Síntoma | Qué comprobar |
|---|---|
| wc no termina aunque el productor salió. | Un escritor adicional permanece en el padre o en el consumidor. |
| Funciona con poco contenido y se detiene con mucho. | Se esperó al productor antes de crear al lector, o el lector no consume. |
| La salida del productor aparece en la terminal. | Faltó dup2 sobre stdout, falló sin comprobarse o se invirtieron los argumentos. |
| El consumidor informa EBADF. | Se cerró 0 después de redirigirlo o se conectó al extremo incorrecto. |
| El productor no detecta el retiro del consumidor. | Queda una referencia lectora sin usar; revisa también la disposición de SIGPIPE. |
| Aparecen procesos zombis. | No se recogieron ambos hijos, especialmente en rutas de fallo. |
| Se cuentan mensajes de diagnóstico como datos. | Se imprimió el error por stdout o se redirigió stderr al canal. |
| El resultado global es cero aunque falló el izquierdo. | La política elegida devuelve el estado del derecho; consulta ambos estados. |
EOF y SIGPIPE siguen dependiendo de todas las referencias abiertas, incluso las que ningún programa piensa utilizar. Sus condiciones se documentan en pipe(7). Diagnosticar por referencias suele explicar mejor un bloqueo que añadir esperas con sleep.
15. Resumen
- Los comandos pueden cooperar usando sus descriptores estándar sin conocer el canal.
- dup2 conecta un número de descriptor a un recurso ya abierto; no ejecuta programas.
- exec reemplaza el programa del proceso y solo retorna si falla.
- El productor conserva el canal en stdout y el consumidor en stdin; ambos cierran los originales.
- El padre crea los dos hijos, cierra sus extremos y después recoge a ambos.
- stderr permite separar diagnósticos de resultados que circulan por el pipeline.
- El estado global es una política: este ejemplo devuelve el resultado del consumidor.
- Los datos grandes y el cierre temprano del lector revelan errores que una entrada pequeña puede ocultar.
- FD_CLOEXEC y la preparación de señales complementan el plan de herencia y cierres.
16. Preguntas de repaso y práctica
Intenta responder antes de desplegar cada explicación.
1. ¿dup2 crea otra tubería?
No. Añade o reemplaza una referencia hacia un recurso ya abierto. La tubería se creó mediante pipe.
2. ¿Qué se conserva al cerrar canal[1] después de dup2 hacia 1?
La referencia de stdout al escritor, siempre que los números sean distintos. Cerrar la entrada original no elimina el duplicado.
3. ¿Por qué se comprueban 0, 1 y 2 al inicio?
Para que los recursos nuevos tengan números mayores que 2 y los cierres del ejemplo no retiren accidentalmente una redirección estándar.
4. ¿Por qué no se espera al productor antes del segundo fork?
Porque puede llenar el canal y necesitar a un consumidor que todavía no existe. Se crean ambos antes de esperar.
5. ¿Por qué wc podría esperar EOF indefinidamente?
Porque el padre o algún hijo conserva una referencia escritora. El fin del productor principal no basta si esa referencia sigue abierta.
6. ¿exec crea un PID nuevo?
No. Reemplaza el programa en el mismo proceso. fork fue la operación que creó el hijo.
7. ¿Qué significa alcanzar la instrucción posterior a execvp?
Que la ejecución falló. Hay que conservar errno si se necesita, informar el error y terminar la rama hija.
8. ¿Por qué se usa _exit en el hijo que falla?
Para terminar sin vaciar los búferes de stdio heredados ni ejecutar las rutinas atexit del padre. Los descriptores se cierran al terminar.
9. ¿Un retorno global cero demuestra que ambos comandos tuvieron éxito?
No con nuestra política. Se devuelve el estado del consumidor; el productor puede haber fallado. Los dos estados se informan por separado.
10. ¿Por qué yes puede terminar por SIGPIPE frente a head?
Porque head consume lo necesario y cierra su lector. Al no quedar lectores, la siguiente escritura del productor encuentra la condición de SIGPIPE.
11. ¿O_CLOEXEC sustituye los close del padre?
No. Solo actúa cuando ese proceso ejecuta otro programa con éxito. El padre que espera debe cerrar sus referencias explícitamente.
12. ¿Puede pasarse -- como argumento literal a un comando del proyecto?
No con esta interfaz, que reserva ese valor como separador único. Una interfaz más general debe representar por separado ambos vectores o definir otro mecanismo de análisis.
Para practicar
- Ejecuta redirigir_wc con un archivo vacío y otro de tres líneas. Comprueba el contenido de la salida y el estado del supervisor.
- Conecta seq 1 1000000 con wc -l. Explica por qué no es necesario aumentar la capacidad de la tubería.
- Prueba un comando inexistente a cada lado. Registra ambos estados y distingue los resultados que dependen del orden de ejecución.
- Modifica la política de retorno para propagar el fallo del productor cuando el consumidor termine con cero. Conserva la recolección de ambos hijos.
- Prueba datos binarios con head sobre /dev/zero y wc -c. Explica por qué un byte cero no termina el flujo.
- Usa strace -f y anota qué descriptores cierra cada PID antes de exec. Relaciónalos con la tabla del plan de cierres.
- En el explorador, conserva el escritor del padre y explica la dependencia que impide completar la espera del consumidor.
- Diseña sobre papel la redirección adicional del stderr del productor a un archivo, conservando el flujo de resultados hacia el consumidor.
El tema 14 construirá una conversación de petición y respuesta con dos tuberías y analizará los interbloqueos que aparecen si ambos participantes escriben sin permitir que el otro lea.