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

Tema 15

Proyecto: una shell con pipelines

Vas a integrar lo aprendido sobre tuberías en un intérprete de comandos pequeño: leer una línea, separar sus etapas, crear los canales, ejecutar todos los programas y recoger cada hijo. El proyecto incluye comandos internos, estados de salida, señales y limpieza ante fallos, con pruebas que permiten detectar fugas y bloqueos que no aparecen con una entrada pequeña.

1. Objetivo y alcance del proyecto

El tema 13 conectó dos comandos y el tema 14 estudió el progreso y el cierre de dos flujos. Ahora construiremos una shell que reciba una cantidad variable de etapas, como:

una línea admitida por nuestra shell
seq 1 1000000 | tail -n 3 | wc -l

La shell no implementará seq, tail ni wc. Preparará el entorno de sus procesos para que la salida de una etapa sea la entrada de la siguiente. Los comandos externos se localizarán mediante PATH y se ejecutarán con execvp.

El proyecto consiste en analizar una línea, lanzar todas sus etapas, cerrar las referencias sobrantes y recoger todos los hijos. El contenido del pipeline circula entre los comandos, sin que la shell tenga que copiarlo.

Admitiremos hasta ocho comandos, 32 argumentos por comando incluyendo su nombre y 4096 bytes por línea sin contar el salto final. Esos límites mantienen visibles las estructuras y permiten rechazar entradas excesivas antes de crear procesos.

Esta shell didáctica ejecuta trabajos en primer plano y ofrece cd, status y exit. No implementa el lenguaje completo de Bash, redirecciones a archivos ni control de trabajos. Los ejemplos están escritos para la sintaxis que realmente acepta.

2. Separar las responsabilidades

ComponenteResponsabilidadResultado
Lector.Obtener una línea sin exceder su límite.Texto, fin de entrada o error.
Analizador.Separar argumentos y etapas, validar la sintaxis.Un array de vectores argv.
Despachador.Resolver los comandos internos.Cambio en el padre o ejecución externa.
Lanzador.Crear tuberías e hijos, preparar 0 y 1, ejecutar.Un PID por etapa.
Recolector.Esperar cada PID y traducir sus estados.Estado del pipeline y recursos liberados.

La validación debe terminar antes del primer pipe o fork. Así una línea como seq 1 10 | | wc -l no ejecuta parcialmente el primer comando antes de descubrir el error.

El modo -c ejecutará una sola línea recibida como argumento y devolverá su estado. El modo sin argumentos repetirá el ciclo hasta exit o EOF. Esta separación facilita tanto el uso manual como las pruebas automáticas.

3. Definir la sintaxis admitida

gramática simplificada
línea     := comando ( '|' comando )*
comando   := palabra ( espacio palabra )*

Ejemplos válidos:
pwd
seq 1 20|tail -n 5|wc -l
cd /tmp
status
exit

Los espacios y tabulaciones separan argumentos; el carácter | separa comandos aunque no tenga espacios alrededor. Una línea vacía no ejecuta nada y conserva el estado anterior.

No admitimos comillas, escapes, sustituciones, listas con punto y coma, paréntesis, redirecciones, operadores & ni ejecución en segundo plano. El analizador rechaza esos caracteres en lugar de darles un significado parcial. Los comodines como * y ? se pasan literalmente: no se expanden.

Por tanto, un nombre de archivo con espacios no puede representarse en esta versión. Tampoco puede pasarse un | literal como argumento. Añadir comillas requiere un analizador que conozca el contexto de cada carácter, no simplemente eliminar las comillas después de separar palabras.

4. Representar los comandos y validar la línea

estructura · argumentos terminados en NULL para execvp
struct comando {
    char *argv[MAX_ARGS + 1];
    int argc;
};

/* Para: seq 1 10 | wc -l
   comandos[0].argv = {"seq", "1", "10", NULL}
   comandos[1].argv = {"wc", "-l", NULL}
*/

Los punteros de argv apuntan dentro del búfer de la línea. El analizador reemplaza los separadores por bytes cero y no reserva una copia de cada palabra. Ese búfer debe seguir vivo hasta completar el lanzamiento; no se analiza la siguiente línea mientras se está preparando la actual.

Hay que rechazar comandos vacíos al principio, al final o entre dos barras, el exceso de etapas y el exceso de argumentos. El terminador NULL ocupa una entrada adicional del array, por eso se reserva MAX_ARGS + 1.

La llamada a isspace recibe una conversión a unsigned char. Esto evita pasar un valor negativo inválido cuando char es un tipo con signo y la entrada contiene bytes superiores a 127.

5. N comandos necesitan N − 1 tuberías

Numeraremos las etapas de 0 a N − 1 y los canales de 0 a N − 2. El canal i conecta la salida de la etapa i con la entrada de la etapa i + 1.

Pipeline de tres etapas y dos tuberíasLa etapa cero escribe en la primera tubería. La etapa uno lee de ella y escribe en la segunda. La etapa dos lee de la segunda y conserva la salida heredada. El padre crea y recoge los tres hijos. Etapa 0seqCanal 0W → REtapa 1tailCanal 1W → REtapa 2wcPadre: sin extremos del canal al comenzar las esperas
La etapa intermedia tiene una entrada y una salida conectadas a canales distintos.

Con un comando no hay tuberías. Con ocho habrá siete, es decir, catorce descriptores de canal en el padre antes del lanzamiento. Creamos todos los canales primero: si falla pipe, todavía no existe ningún hijo que cancelar.

Este enfoque facilita revisar el plan de cierres, aunque usa más descriptores simultáneos que una construcción incremental. Una shell con cadenas mucho más largas podría conservar únicamente el lector anterior y el canal siguiente. Las interfaces de creación se describen en pipe(2).

6. Plan de redirecciones y cierres

Etapa iEntrada estándarSalida estándarDespués de dup2
Primera: i = 0.La heredada de la shell.Escritor del canal 0, si hay otra etapa.Cierra todos los descriptores originales de canales.
Intermedia.Lector del canal i − 1.Escritor del canal i.Cierra todos los descriptores originales de canales.
Última: i = N − 1.Lector del canal N − 2, si existe.La heredada de la shell.Cierra todos los descriptores originales de canales.
Padre.Sin modificación.Sin modificación.Cierra todos los extremos antes de esperar.

Un hijo también debe cerrar las tuberías de etapas lejanas. Si la última etapa conserva un escritor de su propia entrada, puede esperar un EOF que su referencia impide. El problema no se limita al padre.

Comprobamos al inicio que 0, 1 y 2 estén abiertos y quitamos su marca FD_CLOEXEC si existiera. Así los canales reciben números mayores que 2 y cerrar sus originales no elimina una redirección estándar. Un programa más general debe tratar también las colisiones con descriptores estándar cerrados.

dup2 reemplaza el destino sin cerrar el origen. La referencia preparada sobre 0 o 1 sigue existiendo después de retirar los números originales; consulta dup(2). No se ejecuta waitpid dentro del bucle de fork: todos los consumidores deben poder existir antes de esperar a sus productores.

7. Comandos que deben ejecutar en el padre

Si cd se ejecutara solo en un hijo, cambiaría el directorio de ese hijo y la shell seguiría en el anterior. Si exit terminara solo un hijo, el bucle del intérprete continuaría. Por eso ambos se resuelven en el proceso de la shell.

Comando internoForma admitidaEfecto
cd.cd ruta.Cambia el directorio de la shell; exige un argumento.
status.status.Imprime el estado anterior y deja como nuevo estado el de su propia impresión.
exit.exit.Termina la shell con el estado anterior.

En esta versión los internos se aceptan únicamente como comando aislado. Una línea como cd /tmp | wc -l se rechaza antes de crear procesos. Esta regla evita mezclar cambios del padre con etapas externas sin haber definido su significado.

No añadimos exit con código ni cd sin argumento para mantener explícito el contrato. Una extensión puede incorporarlos validando sus argumentos antes de ejecutar.

8. Compartir la entrada sin adelantarse al hijo

La shell y la primera etapa heredan el mismo descriptor de entrada. Si el intérprete usara una biblioteca que adelanta varias líneas a un búfer privado, podría retirar bytes que un comando como cat esperaba leer.

Para hacerlo visible y sencillo, el lector del proyecto usa read de un byte y se detiene exactamente en el salto de línea. No es la opción más eficiente, pero evita leer por adelantado contenido de la siguiente etapa. Reintenta EINTR y descarta hasta el fin de línea si se supera el máximo o aparece un byte NUL.

En modo -c, la orden llega por argv y la entrada queda completamente disponible para el primer comando. Por ejemplo, la shell exterior puede proporcionar datos con printf 'hola\n' | ./mini_shell -c 'cat | wc -c'. Las comillas de esta invocación las interpreta Bash, no nuestra mini shell.

Sin -c, un comando que lea stdin puede consumir las líneas restantes del mismo archivo que alimenta al intérprete. Esa es una consecuencia de compartir la entrada. Para probar secuencias de órdenes por un archivo, usa comandos que no lean de ella o elige el modo -c con datos separados.

9. Código completo de la shell

El programa mantiene el estado del último comando. Los errores de sintaxis devuelven 2; los fallos de preparación, 1. Si execvp falla, el hijo termina con 127 para ENOENT y 126 para otras causas. Con éxito, execvp reemplaza al hijo y no retorna; el vector termina en NULL, según exec(3).

mini_shell.c · analizador, internos, pipelines y recolección
#define _POSIX_C_SOURCE 200809L
#include <ctype.h>
#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>

#define MAX_LINEA 4096
#define MAX_COMANDOS 8
#define MAX_ARGS 32

struct comando {
    char *argv[MAX_ARGS + 1];
    int argc;
};

static int analizar(char *linea, struct comando cmds[], int *cantidad)
{
    /* No interpretamos parcialmente una sintaxis que no admitimos. */
    if (strpbrk(linea, "\"'\\;&<>$`()") != NULL) {
        fprintf(stderr, "Sintaxis no admitida en esta version\n");
        return -1;
    }
    memset(cmds, 0, sizeof(struct comando) * MAX_COMANDOS);
    int etapa = 0;
    char *p = linea;
    while (*p != '\0') {
        while (isspace((unsigned char)*p))
            ++p;
        if (*p == '\0')
            break;
        if (*p == '|') {
            if (cmds[etapa].argc == 0 || etapa == MAX_COMANDOS - 1)
                goto invalida;
            ++etapa;
            ++p;
            continue;
        }
        if (cmds[etapa].argc == MAX_ARGS)
            goto invalida;
        cmds[etapa].argv[cmds[etapa].argc++] = p;
        while (*p != '\0' && *p != '|' &&
               !isspace((unsigned char)*p))
            ++p;
        char separador = *p;
        if (separador != '\0')
            *p++ = '\0';
        if (separador == '|') {
            if (etapa == MAX_COMANDOS - 1)
                goto invalida;
            ++etapa;
        }
    }
    if (etapa == 0 && cmds[0].argc == 0) {
        *cantidad = 0;
        return 0;
    }
    if (cmds[etapa].argc == 0)
        goto invalida;
    *cantidad = etapa + 1;
    return 0;
invalida:
    fprintf(stderr, "Pipeline vacio o limite de comandos/argumentos excedido\n");
    return -1;
}

/* 1: linea; 0: EOF; -1: error; -2: linea descartada. */
static int leer_linea(char linea[])
{
    size_t usados = 0;
    int invalida = 0;
    for (;;) {
        unsigned char c;
        ssize_t n = read(STDIN_FILENO, &c, 1);
        if (n == -1) {
            if (errno == EINTR)
                continue;
            return -1;
        }
        if (n == 0 || c == '\n') {
            linea[usados] = '\0';
            if (invalida)
                return -2;
            return n == 0 && usados == 0 ? 0 : 1;
        }
        if (c == '\0' || usados == MAX_LINEA)
            invalida = 1;
        if (!invalida)
            linea[usados++] = (char)c;
    }
}

static int configurar_senales(int hijo)
{
    int senales[] = {SIGINT, SIGQUIT, SIGPIPE, SIGCHLD};
    struct sigaction accion = {0};
    sigset_t permitir;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigemptyset(&permitir) == -1)
        return -1;
    for (size_t i = 0; i < sizeof senales / sizeof senales[0]; ++i) {
        accion.sa_handler = hijo || senales[i] == SIGCHLD ? SIG_DFL : SIG_IGN;
        if (sigaction(senales[i], &accion, NULL) == -1 ||
            sigaddset(&permitir, senales[i]) == -1)
            return -1;
    }
    return sigprocmask(SIG_UNBLOCK, &permitir, NULL);
}

static void cerrar_canales(int canales[][2], int cantidad)
{
    for (int i = 0; i < cantidad; ++i) {
        close(canales[i][0]);
        close(canales[i][1]);
    }
}

static int recoger(pid_t pid, int *estado)
{
    for (;;) {
        if (waitpid(pid, estado, 0) != -1)
            return 0;
        if (errno != EINTR)
            return -1;
    }
}

static int lanzar(struct comando cmds[], int cantidad)
{
    int canales[MAX_COMANDOS - 1][2];
    pid_t pids[MAX_COMANDOS];
    int creados = 0;
    for (int i = 0; i < cantidad - 1; ++i) {
        if (pipe(canales[i]) == -1) {
            perror("pipe");
            cerrar_canales(canales, creados);
            return 1;
        }
        ++creados;
    }
    int hijos = 0;
    for (int i = 0; i < cantidad; ++i) {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            cerrar_canales(canales, creados);
            /* Ninguno fue recogido: sus PID aun no pueden reutilizarse. */
            for (int j = 0; j < hijos; ++j) {
                if (kill(pids[j], SIGKILL) == -1 && errno != ESRCH)
                    perror("kill");
            }
            for (int j = 0; j < hijos; ++j) {
                int estado;
                if (recoger(pids[j], &estado) == -1)
                    perror("waitpid limpieza");
            }
            return 1;
        }
        if (pid == 0) {
            if (configurar_senales(1) == -1) {
                perror("senales del hijo");
                _exit(126);
            }
            if ((i > 0 && dup2(canales[i - 1][0], STDIN_FILENO) == -1) ||
                (i < cantidad - 1 &&
                 dup2(canales[i][1], STDOUT_FILENO) == -1)) {
                perror("dup2");
                _exit(126);
            }
            cerrar_canales(canales, creados);
            execvp(cmds[i].argv[0], cmds[i].argv);
            int causa = errno;
            perror(cmds[i].argv[0]);
            _exit(causa == ENOENT ? 127 : 126);
        }
        pids[hijos++] = pid;
    }
    cerrar_canales(canales, creados);
    int resultado = 0, fallo_espera = 0;
    for (int i = 0; i < hijos; ++i) {
        int estado;
        if (recoger(pids[i], &estado) == -1) {
            perror("waitpid");
            fallo_espera = 1;
            continue; /* Intentar recoger tambien los restantes. */
        }
        if (i == hijos - 1) {
            if (WIFEXITED(estado))
                resultado = WEXITSTATUS(estado);
            else if (WIFSIGNALED(estado))
                resultado = 128 + WTERMSIG(estado);
            else
                resultado = 1;
        }
    }
    return fallo_espera ? 1 : resultado;
}

static int es_interno(const char *nombre)
{
    return strcmp(nombre, "cd") == 0 || strcmp(nombre, "status") == 0 ||
           strcmp(nombre, "exit") == 0;
}

static int ejecutar_linea(char *linea, int anterior, int *salir)
{
    struct comando cmds[MAX_COMANDOS];
    int cantidad;
    if (analizar(linea, cmds, &cantidad) == -1)
        return 2;
    if (cantidad == 0)
        return anterior;
    if (cantidad > 1) {
        for (int i = 0; i < cantidad; ++i) {
            if (es_interno(cmds[i].argv[0])) {
                fprintf(stderr, "Los internos deben ejecutarse sin pipeline\n");
                return 2;
            }
        }
    }
    struct comando *c = &cmds[0];
    if (cantidad == 1 && es_interno(c->argv[0])) {
        if (strcmp(c->argv[0], "cd") == 0) {
            if (c->argc != 2) {
                fprintf(stderr, "Uso: cd ruta\n");
                return 2;
            }
            if (chdir(c->argv[1]) == -1) {
                perror("cd");
                return 1;
            }
            return 0;
        }
        if (c->argc != 1) {
            fprintf(stderr, "status y exit no admiten argumentos\n");
            return 2;
        }
        if (strcmp(c->argv[0], "exit") == 0) {
            *salir = 1;
            return anterior;
        }
        if (printf("%d\n", anterior) < 0 || fflush(stdout) == EOF) {
            perror("status");
            clearerr(stdout);
            return 1;
        }
        return 0;
    }
    return lanzar(cmds, cantidad);
}

int main(int argc, char *argv[])
{
    if (argc != 1 && !(argc == 3 && strcmp(argv[1], "-c") == 0)) {
        fprintf(stderr, "Uso: %s [-c linea]\n", argv[0]);
        return 2;
    }
    for (int fd = 0; fd <= 2; ++fd) {
        int flags = fcntl(fd, F_GETFD);
        if (flags == -1 || fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) == -1) {
            perror("Se requieren 0, 1 y 2 abiertos");
            return 1;
        }
    }
    if (configurar_senales(0) == -1) {
        perror("senales de la shell");
        return 1;
    }
    char linea[MAX_LINEA + 1];
    int salir = 0, estado = 0;
    if (argc == 3) {
        if (strlen(argv[2]) > MAX_LINEA) {
            fprintf(stderr, "Linea demasiado larga\n");
            return 2;
        }
        strcpy(linea, argv[2]);
        return ejecutar_linea(linea, estado, &salir);
    }
    int interactiva = isatty(STDIN_FILENO);
    while (!salir) {
        if (interactiva) {
            fputs("ipc> ", stderr);
            fflush(stderr);
        }
        int r = leer_linea(linea);
        if (r == 0)
            break;
        if (r == -1) {
            perror("leer linea");
            return 1;
        }
        if (r == -2) {
            fprintf(stderr, "Linea excesiva o con byte NUL: descartada\n");
            estado = 2;
            continue;
        }
        estado = ejecutar_linea(linea, estado, &salir);
    }
    return estado;
}

El analizador conserva la clase del separador antes de reemplazarlo por cero. Esto permite reconocer una barra pegada al argumento, como 20|tail. Si la barra aparece después de espacios, la trata la rama inicial del bucle.

La shell vacía la salida de status antes de volver a crear hijos y no conserva líneas leídas por adelantado. Los hijos que fallan usan _exit, por lo que no vacían otra vez búferes heredados del padre.

10. Compilar y recorrer una sesión

Bash · compilar sobre Linux o WSL y entrar al intérprete
$ gcc -std=c17 -Wall -Wextra -Wpedantic mini_shell.c -o mini_shell
$ ./mini_shell
ipc> seq 1 100 | tail -n 5 | wc -l
5
ipc> false
ipc> status
1
ipc> cd /tmp
ipc> pwd
/tmp
ipc> exit

El prompt se escribe por stderr y solo se muestra si stdin es una terminal. Los resultados de los comandos van a stdout. No se imprime automáticamente el estado de cada etapa; status consulta el estado previo.

Bash · una sola orden, entrada separada y estado del proceso
$ ./mini_shell -c 'seq 1 20|tail -n 3|wc -l'
3
$ printf 'hola\n' | ./mini_shell -c 'cat | wc -c'
5
$ ./mini_shell -c 'false'
$ echo $?
1

En estas invocaciones, las comillas exteriores agrupan la línea como un argumento para -c. Una vez dentro de la mini shell, los nombres y opciones se separan por espacios y barras según la gramática del proyecto.

11. Probar datos grandes y errores

Bash · progreso continuo y cierre temprano de lectores
$ ./mini_shell -c 'seq 1 1000000 | cat | wc -l'
1000000
$ ./mini_shell -c 'head -c 1048576 /dev/zero | cat | wc -c'
1048576
$ ./mini_shell -c 'yes | head -n 1 | wc -l'
1
$ echo $?
0

Las dos primeras pruebas transportan más datos de los que pueden quedar pendientes en los canales. La tercera exige que yes pueda detectar la desaparición de su lector; un descriptor lector olvidado puede dejarlo esperando espacio y evitar que la shell termine de recogerlo.

Bash · estados de ejecución y validación antes del lanzamiento
$ ./mini_shell -c 'comando_inexistente_15'
comando_inexistente_15: No such file or directory
$ echo $?
127
$ ./mini_shell -c 'seq 1 5 | | wc -l'
Pipeline vacio o limite de comandos/argumentos excedido
$ echo $?
2
$ ./mini_shell -c 'cd /tmp | wc -l'
Los internos deben ejecutarse sin pipeline

El idioma de los errores del sistema puede variar. Prueba también una barra inicial, una barra final, nueve etapas, 33 argumentos y una línea demasiado larga. Ninguno debe lanzar una parte de un pipeline inválido.

Para comprobar la recuperación del bucle sin interacción, ejecuta desde Bash printf 'false\nstatus\nexit\n' | ./mini_shell. Debe imprimir 1 sin prompts y salir con cero: status tuvo éxito y reemplazó el estado anterior. Con printf 'false\nexit\n' | ./mini_shell, el estado final debe ser 1.

12. Recoger todos los hijos y elegir un estado

El array pids mantiene un PID por posición del pipeline. Después de cerrar todos los canales del padre, la shell espera cada PID, reintenta EINTR y distingue salida normal de terminación por señal mediante las macros de waitpid. El contrato se describe en wait(2).

Esperar por orden de etapas no obliga a que terminen en ese orden. Mientras el padre espera al primero, los demás siguen ejecutándose. Si alguno ya terminó, su estado se conserva hasta recogerlo.

Elegimos como resultado el de la última etapa; si termina por señal, lo traducimos a 128 + señal. Un error de espera provoca un resultado global 1, pero el bucle intenta recoger también los PID restantes.

Así, comando_inexistente_15 | wc -c puede imprimir 0 y devolver cero aunque el primer hijo falle. El último comando recibió EOF y cumplió su tarea. Para ofrecer una opción similar a pipefail, habría que conservar todos los estados y elegir el fallo situado más a la derecha.

Los valores 126 y 127 son convenciones del lanzador. Un programa externo también puede devolverlos por sí mismo; ENOENT puede indicar además un intérprete ausente. Para distinguir de manera inequívoca un fallo de exec se puede añadir un canal de errores cuyo escritor se cierre automáticamente al ejecutar con éxito.

13. Limpiar una creación parcial

Punto del falloQué existeAcción
Análisis.Solo la línea y estructuras locales.Informar error sin ejecutar comandos.
Creación de un canal.Un prefijo de canales; ningún hijo.Cerrar solo los canales creados.
Un fork intermedio.Todos los canales y algunos hijos.Cerrar canales del padre, cancelar esos hijos y recogerlos.
dup2 o preparación del hijo.Un hijo que no pudo preparar su entorno.Diagnóstico por stderr y _exit(126).
execvp.Un hijo que no cargó el comando.Diagnóstico y _exit; el padre recoge toda la cadena.

En un fallo de fork se usa SIGKILL sobre los hijos directos creados para impedir que un comando que ignore SIGTERM deje detenida la limpieza. Se envían todas las cancelaciones antes de empezar a recogerlos. Como ningún hijo fue recogido todavía y SIGCHLD tiene la disposición predeterminada, no se reutilizaron esos PID.

La cancelación no deshace archivos ni otros efectos que los comandos hayan producido. Tampoco alcanza automáticamente a descendientes creados por ellos. Un supervisor completo necesita organizar los procesos como trabajos y decidir cómo cancelar todo el conjunto.

Para probar esta ruta de forma reproducible, puedes crear una variante de prueba que simule EAGAIN en el tercer fork. Debe devolver 1, cerrar los canales y no dejar vivos ni zombis los hijos directos anteriores. Simular el fallo es más controlable que agotar los procesos del equipo.

14. Señales y límites del control de terminal

El padre ignora SIGINT y SIGQUIT para no desaparecer al pulsar Ctrl+C o Ctrl+\. Los hijos restablecen sus acciones predeterminadas y desbloquean esas señales junto con SIGPIPE. El padre usa la disposición predeterminada de SIGCHLD para poder recogerlos. Las disposiciones se administran con sigaction(2).

En una sesión de terminal normal, esta mini shell y sus hijos permanecen en el mismo grupo de primer plano. Ctrl+C llega al grupo: la shell lo ignora y los comandos con comportamiento predeterminado terminan. Al completar las esperas, vuelve a mostrarse el prompt. En el prompt, Ctrl+C no borra la entrada de nuestro lector; no implementamos edición de línea.

No implementamos Ctrl+Z, fg, bg ni trabajos suspendidos. Si se suspenden procesos, la shell no tiene una máquina de estados que los gestione. Una shell completa organiza cada pipeline en un grupo con setpgid, cede la terminal mediante tcsetpgrp y recupera su control al terminar o suspenderse el trabajo. El papel de los grupos se explica en setpgid(2).

La política mostrada supone un programa independiente de un solo hilo y comandos que cooperan con las reglas habituales de la terminal. No añade tiempos límite a programas que nunca terminan ni cancelación de árboles de procesos.

15. Explorar el plan de un pipeline

Elige entre dos y cinco etapas y consulta qué conexiones conservará cada hijo después de sus dup2 y cierres. Activa la fuga para comparar el padre correcto con otro que retiene escritores. El explorador describe referencias finales; no ejecuta los comandos.

Recursos del pipeline3 hijos y 2 tuberías

Entrada de la etapa0 → lector del canal 0

Salida de la etapa1 → escritor del canal 1

Cierres del hijoTodos los originales de los canales

El padre cierra todos los extremos antes de recoger a los tres hijos.

La fuga del padre puede impedir EOF en cualquier canal vacío cuyo consumidor siga leyendo. Aunque el productor correspondiente ya terminó, el núcleo todavía observa un escritor. Una etapa que finalice por otra condición, como head tras suficientes líneas, puede ocultar parte del problema.

16. Diagnóstico y criterios de aceptación

Bash · seguir varios PID y sus descriptores
$ strace -f -o shell15.log ./mini_shell -c 'seq 1 100 | cat | wc -l'
100
$ less shell15.log

Localiza dos canales, tres hijos, los dup2 apropiados, los cierres de todos los originales y tres recolecciones. Los nombres de algunas llamadas pueden variar: pipe puede aparecer como pipe2, fork como clone y waitpid como wait4.

Para inspeccionar fugas durante una ejecución suficientemente larga, consulta /proc/PID/fd en el padre y los hijos. El padre no debe conservar canales mientras espera; cada hijo debe mantener solo sus conexiones estándar a los canales adyacentes.

CriterioEvidencia esperada
Un comando aislado.Un hijo y ninguna tubería.
Pipeline grande.Completa datos mayores que la capacidad de sus canales.
Cierre temprano.yes | head -n 1 | wc -l termina y la shell recoge a todos.
Error sintáctico.No se crea ningún hijo.
Comando inexistente.Diagnóstico separado de stdout y recolección del hijo fallido.
Sesiones repetidas.No crece la cantidad de descriptores del padre ni quedan zombis.
Fallo parcial de fork.Se cancelan y recogen los hijos directos ya creados.
cd.El siguiente pwd observa el directorio cambiado en el padre.

Si la cadena se detiene, relaciona cada PID con una operación pendiente y el descriptor que la sostiene. Comprueba primero los cierres y que no se haya esperado dentro del bucle de lanzamiento. Añadir sleep no resuelve ninguna de esas dependencias.

17. Resumen

18. Preguntas de repaso y ampliaciones

Intenta responder antes de desplegar cada explicación.

1. ¿Cuántas tuberías necesita un pipeline de cinco comandos?

Cuatro: una por cada conexión entre etapas vecinas. Se crean cinco hijos, uno por comando.

2. ¿Por qué se valida toda la línea antes de lanzar?

Para que un error en una etapa posterior no deje comandos anteriores ejecutados parcialmente como consecuencia de una línea inválida.

3. ¿Qué descriptores originales cierra una etapa intermedia?

Todos los extremos de todos los canales, después de preparar sus duplicados sobre 0 y 1. También cierra los que no pertenecen a sus vecinos.

4. ¿Por qué no se espera después de cada fork?

Porque un productor puede llenar el canal antes de que se cree su consumidor. Primero deben lanzarse todas las etapas.

5. ¿Por qué cd debe ejecutarse en el padre?

Porque el directorio de trabajo pertenece al proceso. Cambiarlo en un hijo no modifica el de la shell que ejecutará las siguientes órdenes.

6. ¿Quién interpreta las comillas alrededor del argumento de -c?

La shell exterior, por ejemplo Bash. Nuestra shell recibe la línea agrupada y aplica su propia gramática sencilla, que no admite comillas internas.

7. ¿Qué problema evita el lector de un byte?

Evita adelantar contenido a un búfer privado antes de que un comando hijo tenga la oportunidad de consumir su entrada compartida.

8. ¿Esperar los PID por orden impone el orden de terminación?

No. Los hijos continúan concurrentemente. El orden solo determina cuándo recoge el padre cada estado.

9. ¿Qué devuelve una cadena cuyo primer comando falla y el último termina con cero?

Cero con esta política. El resultado global corresponde a la última etapa; una política de pipefail usaría también los fallos anteriores.

10. ¿Por qué se cancelan todos los hijos antes de recoger el primero en una limpieza?

Para que ninguno quede ejecutándose mientras se espera a otro. Como aún no se recogieron, sus PID siguen asociados a esos hijos.

11. ¿Ignorar SIGINT en el padre hace que sus hijos también la ignoren?

Inicialmente heredan esa disposición, pero el código hijo la restablece antes de exec. Así el comportamiento habitual de los comandos puede responder a Ctrl+C.

12. ¿Por qué no basta esta política para implementar fg y bg?

Porque hace falta representar trabajos, agrupar sus procesos, administrar el dueño de la terminal y recoger estados de suspensión y continuación.

Para practicar y ampliar

  1. Ejecuta pipelines de una, dos, tres y ocho etapas. Anota el número de hijos, canales y descriptores originales.
  2. Prueba barras sin espacios y comandos vacíos. Verifica con strace que una entrada inválida no crea hijos.
  3. Ejecuta una sesión que cambie de directorio, consulte pwd y termine con exit. Comprueba el estado del proceso shell.
  4. Transporta datos binarios y un volumen mayor que la capacidad de las tuberías. Comprueba contenido y terminación.
  5. Simula un fallo del tercer fork en una variante de prueba y verifica la limpieza de los hijos directos.
  6. Añade una opción de pipefail conservando los estados de todas las etapas. Define qué fallo seleccionar si hay varios.
  7. Diseña primero las reglas de comillas simples y dobles antes de modificar el analizador. Incluye palabras vacías y barras literales en tus casos de prueba.
  8. Planifica una redirección de archivo para la primera o última etapa. Decide su precedencia respecto de las conexiones del pipeline.
  9. Compara crear todos los canales al inicio con una construcción incremental. Dibuja qué referencias heredaría cada hijo.
Próximo paso

Con este proyecto termina el bloque de tuberías anónimas. El tema 16 presentará las FIFO: canales con nombre en el sistema de archivos para comunicar programas que no necesitan heredar descriptores de un antecesor común.