← Comunicación entre ProcesosBloque 1 · Fundamentos y entorno de trabajo · Tema 4 de 52

Tema 4

Procesos, descriptores y herencia

Dos procesos pueden tener variables independientes y, al mismo tiempo, conservar referencias al mismo archivo o canal. Esa combinación permite a una shell crear un hijo, conectar su salida a una tubería y ejecutar otro programa sin perder la conexión. En este tema seguirás esas referencias, comprobarás un desplazamiento de archivo compartido y construirás un capturador de comandos con fork, execvp, dup2 y waitpid.

1. El modelo de proceso que necesitamos

Un programa es el código y los datos que puedes guardar en un ejecutable. Un proceso es una instancia en ejecución, con identidad, memoria, recursos y estado administrados por el sistema operativo. Puedes iniciar el mismo programa varias veces y obtener procesos distintos.

Para construir comunicación entre procesos nos interesan especialmente cuatro partes:

En el tema 1 comprobaste que modificar una variable ordinaria en el hijo no cambiaba la del padre. Eso no implica que todos sus recursos sean independientes: la memoria y los descriptores siguen reglas distintas. Comprender esa diferencia explica cómo se conserva una conexión al iniciar otro programa.

Los ejemplos de esta lección son programas de un solo hilo ejecutados en Linux. Si fork se utiliza desde un proceso con varios hilos, el hijo tiene restricciones adicionales hasta exec: no es correcto trasladar sin revisión cualquier función de biblioteca a ese intervalo.

2. fork: dos ejecuciones desde una llamada

Si tiene éxito, fork() crea un hijo y ambos procesos continúan desde el retorno de esa llamada. La diferencia está en el valor que recibe cada uno:

ResultadoQuién lo recibeQué significa
−1El proceso que intentó crear al hijo.La creación falló; no existe un hijo nuevo al que esperar.
0El hijo.Está en la rama del proceso recién creado.
Un PID positivoEl padre.Identifica al hijo creado.
esquema · comprobar el resultado antes de usarlo
pid_t hijo = fork();
if (hijo == -1) {
    /* Error: informar y liberar los recursos preparados. */
} else if (hijo == 0) {
    /* Trabajo del hijo o preparacion seguida de exec. */
} else {
    /* Trabajo del padre; hijo contiene el PID que debe recoger. */
}

No hay una garantía general de que el padre avance antes que el hijo, ni de que el orden de los mensajes impresos sea siempre igual. Si un paso requiere que otro haya terminado, establece esa relación con una espera o un protocolo, no con la velocidad observada ni con un sleep elegido a ojo.

Los contenidos iniciales de las variables ordinarias coinciden, pero sus cambios posteriores son privados. Las regiones creadas para compartir memoria son una excepción deliberada a ese comportamiento. El tratamiento de memoria y descriptores heredados se describe en fork(2).

3. Descriptor, apertura y objeto

Un descriptor es un número no negativo que sirve de índice en la tabla de un proceso. No es el archivo en sí ni una dirección de memoria. El número 4 puede referirse a objetos distintos en dos procesos que lo obtuvieron de forma independiente.

Para un archivo regular conviene distinguir tres niveles:

  1. Entrada de descriptor. Pertenece a la tabla del proceso y contiene propiedades como FD_CLOEXEC.
  2. Descripción de archivo abierto. Representa una apertura en el núcleo y mantiene, entre otras cosas, el desplazamiento y flags de estado de archivo.
  3. Archivo subyacente. El objeto al que se accede, que también puede tener otras aperturas independientes.
Dos descriptores y una misma aperturaEl descriptor cuatro del padre y el descriptor cuatro del hijo apuntan a la misma descripción de archivo abierto, cuyo desplazamiento es compartido. Esa apertura referencia el archivo datos.txt. Padrefd 4Hijofd 4Una aperturaoffset compartidoflags de estadoArchivodatos.txt
Los números pertenecen a cada proceso; la apertura del núcleo puede ser la misma.

Dos llamadas independientes a open sobre la misma ruta suelen crear dos descripciones de apertura distintas: cada una tiene su desplazamiento. En cambio, un descriptor heredado por fork o duplicado mediante dup se refiere a la misma apertura que su original. Las distinciones y los flags se documentan en open(2).

Los números convencionales son 0 para entrada estándar, 1 para salida estándar y 2 para error estándar. En C puedes usar STDIN_FILENO, STDOUT_FILENO y STDERR_FILENO. Una terminal suele empezar conectada ahí, pero una redirección puede hacer que apunten a un archivo o una tubería.

4. Qué heredan padre e hijo

Después de fork, el hijo obtiene entradas de descriptor que se refieren a las mismas aperturas que las del padre. Las tablas son distintas: cerrar una entrada en el hijo no elimina automáticamente la entrada del padre. Algunas propiedades de los objetos referenciados sí se comparten.

ElementoDespués de forkConsecuencia práctica
Variable ordinariaContenido inicial equivalente y cambios privados.No sirve por sí sola para comunicar un resultado.
Tabla de descriptoresEl hijo tiene sus propias entradas.close modifica la tabla del proceso que lo llama.
Apertura referenciadaPuede ser la misma en ambos procesos.Un read o lseek sobre un archivo regular puede cambiar el offset que verá el otro.
Flags de estado, como O_NONBLOCKPertenecen a la apertura compartida.Cambiarlos puede afectar a otros descriptores de esa apertura.
Flag FD_CLOEXECLa entrada se copia con su valor, pero sigue siendo una propiedad por descriptor.Cambiarlo en una tabla no marca automáticamente todas las demás entradas.
Búfer de un FILE de stdioSu contenido en memoria se duplica con el proceso.Un texto pendiente puede terminar enviándose dos veces.

En una tubería no hay desplazamiento de archivo que puedas reposicionar con lseek. Lo compartido es la referencia a sus extremos y al canal: por eso un escritor olvidado en un hijo puede impedir que otro proceso detecte EOF.

5. Experimento: un desplazamiento compartido

Crea un archivo de seis bytes y ábrelo una sola vez antes de fork. El hijo leerá tres bytes y terminará; el padre lo recogerá y después leerá otros tres. Esa espera elimina la carrera por el orden de lectura y permite observar el desplazamiento compartido.

offset_heredado.c · una apertura usada por dos procesos
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

static int mostrar_tres(int fd, const char *nombre)
{
    char datos[3];
    size_t usados = 0;
    while (usados < sizeof datos) {
        ssize_t n = read(fd, datos + usados, sizeof datos - usados);
        if (n == -1) {
            if (errno == EINTR)
                continue;
            perror("read");
            return -1;
        }
        if (n == 0) {
            fprintf(stderr, "Faltan bytes: usa un archivo de al menos seis bytes\n");
            return -1;
        }
        usados += (size_t)n;
    }
    if (dprintf(STDOUT_FILENO, "%s: %.*s\n", nombre, (int)usados, datos) < 0) {
        perror("dprintf");
        return -1;
    }
    return 0;
}

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "Uso: %s archivo\n", argv[0]);
        return EXIT_FAILURE;
    }
    int fd = open(argv[1], O_RDONLY);
    if (fd == -1) {
        perror("open");
        return EXIT_FAILURE;
    }
    pid_t hijo = fork();
    if (hijo == -1) {
        perror("fork");
        close(fd);
        return EXIT_FAILURE;
    }
    if (hijo == 0) {
        int resultado = mostrar_tres(fd, "Hijo");
        close(fd);
        _exit(resultado == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
    }

    int estado;
    while (waitpid(hijo, &estado, 0) == -1) {
        if (errno == EINTR)
            continue;
        perror("waitpid");
        close(fd);
        return EXIT_FAILURE;
    }
    if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) {
        close(fd);
        return EXIT_FAILURE;
    }
    if (mostrar_tres(fd, "Padre") == -1) {
        close(fd);
        return EXIT_FAILURE;
    }
    off_t posicion = lseek(fd, 0, SEEK_CUR);
    if (posicion == (off_t)-1) {
        perror("lseek");
        close(fd);
        return EXIT_FAILURE;
    }
    close(fd);
    printf("Offset final: %lld\n", (long long)posicion);
    return EXIT_SUCCESS;
}
Bash · preparar el archivo y ejecutar
$ printf 'ABCDEF' > datos.txt
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 offset_heredado.c -o offset_heredado
$ ./offset_heredado datos.txt
Hijo: ABC
Padre: DEF
Offset final: 6

El padre no vuelve a leer ABC porque ambos descriptores remiten a la misma apertura. Cerrar el descriptor del hijo no reinicia el desplazamiento ni cierra el del padre. Si el padre hiciera otra llamada a open después de esperar, esa nueva apertura empezaría normalmente en cero.

El ejemplo usa read y dprintf para evitar mezclar lecturas con el búfer de un FILE. Si reemplazaras read por fread, la lectura anticipada de stdio añadiría otra capa al experimento. El archivo de prueba debe contener texto sencillo: el formato utilizado para mostrar los tres bytes no es un visor binario general.

6. exec reemplaza el programa

La familia exec carga otro programa en el proceso que la llama. No crea un hijo adicional: reemplaza la imagen del proceso existente y conserva su PID. Por eso una shell suele combinar dos operaciones: fork crea el proceso y exec hace que ese hijo ejecute el comando elegido.

Si exec tiene éxito, no vuelve al código siguiente. Si retorna, falló: debes informar y terminar la rama del hijo, en lugar de continuar accidentalmente por la lógica del padre. La semántica del reemplazo se describe en execve(2).

VarianteArgumentosBúsqueda del ejecutable
execlLista de argumentos terminada por un puntero nulo.Usa la ruta indicada.
execvVector argv terminado por un puntero nulo.Usa la ruta indicada.
execvpVector argv terminado por un puntero nulo.Busca en PATH si el nombre no contiene una barra.
execveVectores de argumentos y entorno explícitos.Usa la ruta indicada.

El nuevo programa recibe su argv y su entorno según la variante. Las variables ordinarias y el heap anteriores no continúan como memoria de la aplicación reemplazada. Los descriptores abiertos, en cambio, se conservan salvo que tengan configurado el cierre al ejecutar.

Pasar un vector de argumentos no equivale a pedir que una shell interprete texto. Con execvp, un argumento que contiene | no crea una tubería por sí solo, ni > redirige la salida. Es el programa que prepara al hijo quien debe construir esas conexiones.

7. Redirigir con dup2

dup2(origen, destino) hace que la entrada destino se refiera a la misma apertura que origen. Si destino estaba abierto y es diferente de origen, lo cierra como parte de la operación de sustitución. El descriptor origen sigue abierto.

esquema · conectar un escritor a la salida estándar
if (dup2(escritor, STDOUT_FILENO) == -1) {
    /* Informar y terminar esta rama. */
}
if (escritor != STDOUT_FILENO)
    close(escritor);

Después de esa redirección, un programa que escribe en el descriptor 1 enviará bytes al canal, aunque no sepa que el canal existe. Cerrar el número original no rompe la salida estándar: queda la referencia del descriptor 1.

No lo reemplaces por close(1); dup(escritor);. Entre ambas operaciones podría ocuparse el número liberado y dup elegiría otro. dup2 realiza la sustitución del destino como una operación indivisible frente a esa carrera. Si origen y destino ya son iguales, dup2 valida el descriptor y no hace una nueva duplicación. Los casos y flags se describen en dup(2).

La duplicación comparte el objeto y sus flags de estado, pero no convierte todas las propiedades de descriptor en compartidas. En particular, cuando origen y destino son distintos, el nuevo descriptor de dup2 queda sin FD_CLOEXEC. Esa propiedad es útil para una salida estándar que debe sobrevivir a exec.

8. close y el fin de una tubería

Crear una tubería antes de fork deja, inicialmente, un lector y un escritor en cada proceso. Si solo el hijo produce y el padre consume, el hijo debe cerrar el lector y el padre debe cerrar el escritor. Después de dup2, el hijo también puede cerrar el número original que ya no necesita.

ProcesoConserva para el intercambioCierra
PadreEl lector de la tubería.Su escritor heredado.
Hijo antes de execEl escritor, a través del descriptor 1.El lector y el escritor original si era otro número.
Comando ejecutadoLa salida estándar preparada.Al terminar libera sus descriptores abiertos.

El lector obtiene EOF cuando consume los datos pendientes y no queda ningún escritor abierto. No basta con que termine «el productor esperado»: si otra referencia al escritor sigue abierta, el canal todavía puede recibir datos. Esa referencia puede estar en el propio padre, otro hijo o un programa al que se filtró durante exec.

Cerrar una referencia tampoco elimina los bytes ya escritos: el receptor puede seguir consumiéndolos. Y cerrar todos los lectores cambia lo que le ocurre al escritor, que puede recibir SIGPIPE o el error correspondiente según la disposición de la señal.

9. Recoger y comprobar al hijo

waitpid(hijo, &estado, 0) espera al hijo indicado. Si retorna su PID, el valor de estado permite distinguir terminación normal de terminación por señal. Si retorna −1, hay que interpretar el error; un EINTR se puede reintentar en los ejemplos de esta lección.

No compares directamente el entero estado con el código de salida esperado. Usa WIFEXITED antes de consultar WEXITSTATUS; usa WIFSIGNALED antes de WTERMSIG. El formato del estado también puede representar otros cambios cuando se solicitan opciones adicionales.

Un hijo terminado puede dejar temporalmente una entrada zombi: ya no ejecuta código, pero conserva información para que su padre la recoja. Cerrar su canal no sustituye esa espera. La relación entre terminación, estado y recolección se documenta en waitpid(2).

Esperar después de drenar la salida

Si el hijo puede producir más de lo que cabe en la tubería, el padre debe consumir mientras el hijo trabaja. Esperar su terminación antes de leer puede hacer que el hijo espere espacio y el padre espere al hijo. En el experimento del archivo regular no existía esa dependencia de un canal lleno.

10. Proyecto: capturar la salida de un comando

El siguiente programa prepara una tubería, crea un hijo, redirige su salida estándar y ejecuta el comando recibido en argv. El padre consume los bytes y los reenvía a su propia salida estándar. El error estándar del comando sigue en el descriptor 2: no se mezcla con la captura.

Guarda el código como capturar_comando.c. Ejecútalo desde una terminal normal, con los descriptores estándar abiertos. El programa comprueba los resultados importantes del intercambio, maneja escrituras parciales y recoge al hijo tras cerrar la lectura.

capturar_comando.c · fork, dup2, execvp, read y waitpid
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

static int escribir_todo(int fd, const char *datos, size_t cantidad)
{
    size_t usados = 0;
    while (usados < cantidad) {
        ssize_t n = write(fd, datos + usados, cantidad - usados);
        if (n == -1) {
            if (errno == EINTR)
                continue;
            return -1;
        }
        if (n == 0) {
            errno = EIO;
            return -1;
        }
        usados += (size_t)n;
    }
    return 0;
}

int main(int argc, char *argv[])
{
    if (argc < 2) {
        fprintf(stderr, "Uso: %s comando [argumentos...]\n", argv[0]);
        return EXIT_FAILURE;
    }
    int canal[2];
    if (pipe(canal) == -1) {
        perror("pipe");
        return EXIT_FAILURE;
    }
    pid_t hijo = fork();
    if (hijo == -1) {
        perror("fork");
        close(canal[0]);
        close(canal[1]);
        return EXIT_FAILURE;
    }
    if (hijo == 0) {
        close(canal[0]);
        if (canal[1] != STDOUT_FILENO) {
            int resultado;
            do {
                resultado = dup2(canal[1], STDOUT_FILENO);
            } while (resultado == -1 && errno == EINTR);
            if (resultado == -1) {
                perror("dup2");
                _exit(126);
            }
            close(canal[1]);
        }
        execvp(argv[1], &argv[1]);
        int error_exec = errno; /* Solo se llega aqui si execvp fallo. */
        perror(argv[1]);
        _exit(error_exec == ENOENT ? 127 : 126);
    }

    close(canal[1]);
    char buffer[4096];
    int correcto = 1;
    for (;;) {
        ssize_t n = read(canal[0], buffer, sizeof buffer);
        if (n > 0) {
            if (escribir_todo(STDOUT_FILENO, buffer, (size_t)n) == -1) {
                perror("write a stdout");
                correcto = 0;
                break;
            }
        } else if (n == 0) {
            break;
        } else if (errno != EINTR) {
            perror("read");
            correcto = 0;
            break;
        }
    }
    close(canal[0]);

    int estado;
    while (waitpid(hijo, &estado, 0) == -1) {
        if (errno == EINTR)
            continue;
        perror("waitpid");
        return EXIT_FAILURE;
    }
    if (!correcto)
        return EXIT_FAILURE;
    if (WIFEXITED(estado)) {
        int codigo = WEXITSTATUS(estado);
        fprintf(stderr, "Hijo %ld: salida %d\n", (long)hijo, codigo);
        return codigo;
    }
    if (WIFSIGNALED(estado)) {
        int senal = WTERMSIG(estado);
        fprintf(stderr, "Hijo %ld: terminado por senal %d\n", (long)hijo, senal);
        return 128 + senal; /* Convencion del lanzador, no valor de waitpid. */
    }
    return EXIT_FAILURE;
}
Bash · capturar un comando y comprobar su estado
$ gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 capturar_comando.c -o capturar_comando
$ ./capturar_comando printf 'uno\ndos\n'
uno
dos
Hijo 4200: salida 0
$ ./capturar_comando false
Hijo 4201: salida 1
$ echo $?
1

Los PID son ilustrativos. El informe del padre va a stderr: si rediriges la salida a un archivo, ese informe no forma parte del contenido capturado. La shell que inicia el lanzador encuentra su ejecutable; después execvp busca el comando indicado, como printf o false.

Prueba también un nombre inexistente. El hijo informa del error y termina con 127, según la convención elegida aquí; otros fallos de exec se traducen a 126. Un comando que se ejecutó correctamente también podría elegir esos códigos, así que este esquema no prueba por sí solo la causa exacta. Un canal de errores dedicado permitiría distinguir el fallo de arranque del estado del programa.

Bash · redirección del lanzador y prueba de argumentos
$ ./capturar_comando printf '%s\n' 'hola mundo' > salida.txt
$ cat salida.txt
hola mundo

Las comillas las interpreta la shell antes de iniciar el lanzador y conservan hola mundo como un argumento. El lanzador pasa el vector al comando sin construir una cadena para otra shell. Si quieres ejecutar una shell, tendrías que indicarla explícitamente, por ejemplo sh con su opción -c, y entonces aceptar sus reglas de interpretación.

El programa es un ejemplo de captura de stdout, no una shell completa: no administra trabajos, entrada del comando, límites de tiempo ni captura separada de stderr. Tampoco establece una política propia de SIGPIPE si desaparece su salida. Esas decisiones se añadirían según el contrato del servicio.

11. Controlar la herencia en exec

Conservar descriptores a través de exec permite redirigir un comando, pero también puede filtrar recursos que el nuevo programa no necesita. Un archivo de configuración, un extremo de tubería o una conexión de administración no debería heredarse por accidente.

El flag FD_CLOEXEC significa «cerrar este descriptor si exec tiene éxito». No lo cierra al hacer fork y no lo cierra si el reemplazo falla. Para aperturas nuevas se puede solicitar mediante O_CLOEXEC; sobre un descriptor existente se consulta y actualiza con fcntl:

fragmento · marcar un descriptor existente, con fcntl.h incluido
int flags = fcntl(fd, F_GETFD);
if (flags == -1) {
    /* Tratar el error. */
} else if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
    /* Tratar el error. */
}

En programas con hilos, abrir y marcar después crea un intervalo en el que otro hilo podría lanzar un hijo y ejecutar un programa. Por eso conviene solicitar el flag al crear el recurso cuando la interfaz lo permite. En Linux existe, por ejemplo, pipe2 con O_CLOEXEC; se estudiará junto con las tuberías.

El capturador cierra sus extremos sobrantes explícitamente. Si lo ampliaras para crear todos los descriptores con close-on-exec, tendrías que verificar que el descriptor final 1 sobreviva. dup2 con números distintos crea la referencia sin ese flag; si el escritor ya fuera el descriptor 1, ese caso especial exigiría revisar el flag en vez de asumir una duplicación.

12. Seguir los descriptores paso a paso

El modelo siguiente muestra una ejecución posible del capturador. Suponemos que 0, 1 y 2 estaban abiertos y que pipe devuelve 3 y 4. «Lectura» y «escritura» representan referencias a los extremos del mismo canal; no son copias independientes de sus datos.

Paso 0 de 9 · antes de crear la tubería

DescriptorPadreHijo / comando
0Entrada estándar—
1Salida estándar—
2Error estándar—
3——
4——

Referencias escritoras0

Bytes pendientes0

Situación del hijoTodavía no existe

Lectura del padreTodavía no comienza

El padre tiene sus descriptores estándar; aún no existe ningún canal.

Recorre primero la secuencia normal. Observa que dup2 cambia a qué apunta el descriptor 1 del hijo y que exec conserva esa conexión. La terminación del comando cierra su escritor, pero los bytes siguen disponibles para el padre. waitpid aparece después del consumo.

Después activa el error y avanza. El hijo termina, se consumen los bytes y aun así no aparece EOF: el padre mantiene un escritor abierto. El modelo se detiene en esa espera. Cambiar la opción reinicia el recorrido para comparar las dos situaciones.

Es una representación didáctica de referencias y orden, no una ejecución de C dentro del navegador. Otros órdenes de planificación son posibles. La memoria, la capacidad del canal y las señales no se simulan aquí.

13. Observar la ejecución en Linux

Con las herramientas preparadas en el tema 3 puedes comprobar cómo se implementa la secuencia. Registra la ejecución del capturador siguiendo al hijo:

Bash · observar el comando y sus descriptores
$ strace -f -o captura.log ./capturar_comando printf 'hola\n'
$ less captura.log

Busca la creación del canal, la del hijo, dup2, los cierres, execve, las lecturas y la espera. fork puede aparecer como clone o clone3; execvp puede realizar varios intentos de execve durante la búsqueda en PATH. El nombre de una función de biblioteca no tiene por qué coincidir con la llamada del núcleo que verás.

En un proceso vivo, Linux permite inspeccionar los enlaces de /proc/PID/fd. Sustituye PID por el número del proceso que quieras observar mientras todavía exista. Para facilitar la observación puedes lanzar un comando que tarde:

dos terminales · observar procesos que siguen vivos
$ ./capturar_comando sleep 20
... mientras espera, en otra terminal ...
$ ps -eo pid,ppid,stat,args
$ ls -l /proc/PID/fd

El padre debería conservar el lector y el comando tendrá su salida estándar apuntando al canal. El formato de los enlaces puede incluir un identificador de tubería. La inspección requiere permisos y puede fallar si el proceso termina antes de consultarlo; no confundas esa carrera de observación con un error del programa.

Si rediriges tanto stdout como stderr del capturador al mismo destino, el orden visible entre mensajes puede diferir del de una terminal con salidas separadas. Para analizar el transporte, identifica qué proceso escribe, por qué descriptor y en qué momento.

14. Errores de diseño frecuentes

El caso de los búferes de stdio

Un printf puede dejar texto pendiente en memoria. Si haces fork antes de vaciarlo, ambos procesos reciben una copia de ese búfer. Si después ambos llaman a exit, los dos podrían escribirlo. Un salto de línea no garantiza el vaciado cuando stdout está redirigido a un archivo.

Cuando corresponda, vacía los flujos antes de fork y comprueba el resultado. En la rama que prepara exec usa _exit si el reemplazo falla: no ejecuta el vaciado de stdio ni las funciones registradas con atexit del programa anterior. Por esa misma razón, un mensaje del hijo dejado solo en un búfer de stdout podría perderse al usar _exit.

Estos ejemplos no intentan resolver toda cancelación ni toda recuperación. El tema siguiente profundiza en errores, bloqueos y vida útil; aquí el objetivo es que cada referencia tenga un dueño y cada cierre un motivo.

15. Resumen

16. Preguntas de repaso y práctica

Responde antes de desplegar la explicación.

1. ¿Por qué fork y exec no son la misma operación?

fork crea otro proceso que continúa la ejecución. exec reemplaza el programa del proceso que lo llama; conserva su identidad de proceso y no retorna si tiene éxito.

2. ¿El número 4 siempre identifica el mismo archivo?

No. Es un índice dentro de la tabla de cada proceso. Solo una relación concreta, como una herencia o duplicación, permite afirmar que dos entradas remiten a la misma apertura.

3. ¿Por qué el padre lee DEF en el primer experimento?

Porque el hijo avanzó tres bytes en la apertura compartida. El padre espera su terminación y lee desde el desplazamiento que quedó, no desde una apertura nueva.

4. ¿Cerrar el descriptor del hijo cierra el del padre?

No. Cada proceso tiene su entrada. El objeto del núcleo puede seguir referenciado por el padre y por otros descriptores.

5. ¿Qué hace dup2 con el descriptor origen?

Lo mantiene abierto y hace que destino se refiera a la misma apertura. Por eso normalmente se cierra el número original después, si es distinto del destino y ya no se necesita.

6. ¿Qué pasa si execvp retorna?

El reemplazo falló. La rama del hijo debe tratar el error y terminar o ejecutar una alternativa explícita; no debe continuar como si el nuevo programa se hubiera iniciado.

7. ¿Por qué el capturador recibe datos de un programa que no conoce la tubería?

Porque antes de exec el hijo conectó el descriptor 1 al escritor mediante dup2. El programa nuevo utiliza su salida estándar habitual y esa referencia sobrevive.

8. ¿Que el comando termine garantiza EOF?

No. También deben haberse cerrado las otras referencias escritoras, incluido cualquier escritor olvidado por el padre u otro proceso.

9. ¿Qué guarda un proceso zombi?

Información de terminación pendiente de recoger. Ya no está ejecutando el programa, pero el padre debe recoger su estado según el diseño de supervisión.

10. ¿FD_CLOEXEC evita que el hijo reciba el descriptor con fork?

No. El hijo lo hereda con el flag; se cerrará si tiene lugar un exec exitoso o si se cierra explícitamente.

11. ¿Una cadena con | pasada como argumento a execvp crea un pipeline?

No. execvp recibe un vector de argumentos y busca el ejecutable. La interpretación de operadores pertenece a una shell si se ejecuta explícitamente o al lanzador que construya esas conexiones.

12. ¿Por qué un printf anterior a fork podría aparecer dos veces?

Porque su contenido pendiente puede copiarse con la memoria del proceso. Si ambas copias se vacían posteriormente, ambas escriben el texto. Vaciar antes de fork y distinguir exit de _exit evita suposiciones incorrectas.

Para practicar

  1. Ejecuta offset_heredado con ABCDEF. Añade una nueva apertura en el padre después de esperar y comprueba desde dónde empieza a leer esa nueva referencia.
  2. Usa un archivo de dos bytes para comprobar el fallo controlado del primer ejemplo. Verifica que el padre no da por correcto un resultado incompleto.
  3. Captura printf con varios argumentos, un comando que termine con estado cero y otro que termine con estado distinto de cero. Consulta el estado del lanzador inmediatamente después.
  4. Prueba un nombre de comando inexistente y un archivo regular sin permiso de ejecución. Explica los mensajes y los códigos elegidos por el ejemplo.
  5. Ejecuta ./capturar_comando seq 1 100000 > numeros.txt y comprueba que se capturaron todas las líneas. Explica por qué el padre debe leer antes de esperar.
  6. Omite temporalmente el cierre del escritor en el padre y ejecuta la prueba pequeña con timeout 3s. Observa que puede mostrar el contenido y luego quedarse esperando. Restaura el cierre.
  7. Dibuja los descriptores que debería conservar cada proceso si también quisieras enviar entrada al comando. Identifica los cierres y el riesgo de llenar dos canales.
  8. Busca en una traza el mismo PID antes y después de execve. Relaciónalo con la diferencia entre proceso y programa.