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:
- Identidad. Un PID permite identificar al proceso dentro de su entorno; el PPID identifica a su padre.
- Espacio de direcciones. Contiene el código, la pila, el heap y las regiones mapeadas que ve ese proceso.
- Tabla de descriptores. Relaciona números enteros con archivos, extremos de canal y otros recursos abiertos.
- Estado de ejecución y terminación. El proceso puede estar ejecutando, esperando o haber terminado mientras conserva información pendiente de recoger.
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:
| Resultado | Quién lo recibe | Qué significa |
|---|---|---|
| −1 | El proceso que intentó crear al hijo. | La creación falló; no existe un hijo nuevo al que esperar. |
| 0 | El hijo. | Está en la rama del proceso recién creado. |
| Un PID positivo | El padre. | Identifica al hijo creado. |
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:
- Entrada de descriptor. Pertenece a la tabla del proceso y contiene propiedades como FD_CLOEXEC.
- 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.
- Archivo subyacente. El objeto al que se accede, que también puede tener otras aperturas independientes.
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.
| Elemento | Después de fork | Consecuencia práctica |
|---|---|---|
| Variable ordinaria | Contenido inicial equivalente y cambios privados. | No sirve por sí sola para comunicar un resultado. |
| Tabla de descriptores | El hijo tiene sus propias entradas. | close modifica la tabla del proceso que lo llama. |
| Apertura referenciada | Puede 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_NONBLOCK | Pertenecen a la apertura compartida. | Cambiarlos puede afectar a otros descriptores de esa apertura. |
| Flag FD_CLOEXEC | La 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 stdio | Su 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.
#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;
}$ 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: 6El 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).
| Variante | Argumentos | Búsqueda del ejecutable |
|---|---|---|
| execl | Lista de argumentos terminada por un puntero nulo. | Usa la ruta indicada. |
| execv | Vector argv terminado por un puntero nulo. | Usa la ruta indicada. |
| execvp | Vector argv terminado por un puntero nulo. | Busca en PATH si el nombre no contiene una barra. |
| execve | Vectores 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.
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.
| Proceso | Conserva para el intercambio | Cierra |
|---|---|---|
| Padre | El lector de la tubería. | Su escritor heredado. |
| Hijo antes de exec | El escritor, a través del descriptor 1. | El lector y el escritor original si era otro número. |
| Comando ejecutado | La 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).
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.
#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;
}$ 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 $?
1Los 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.
$ ./capturar_comando printf '%s\n' 'hola mundo' > salida.txt
$ cat salida.txt
hola mundoLas 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:
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
| Descriptor | Padre | Hijo / comando |
|---|---|---|
| 0 | Entrada estándar | — |
| 1 | Salida estándar | — |
| 2 | Error 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:
$ strace -f -o captura.log ./capturar_comando printf 'hola\n'
$ less captura.logBusca 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:
$ ./capturar_comando sleep 20
... mientras espera, en otra terminal ...
$ ps -eo pid,ppid,stat,args
$ ls -l /proc/PID/fdEl 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
- Crear la tubería en cada rama después de fork. Cada llamada crea un canal distinto. Prepara el que quieres heredar antes de crear al hijo.
- Tratar un descriptor como una variable compartida. El entero es local; lo compartido puede ser la apertura a la que se refiere.
- Cerrar el descriptor 1 después de dup2 sin comprobar los números. Si el escritor original ya era 1, podrías cerrar la conexión que querías conservar.
- Conservar extremos sobrantes. Una sola referencia olvidada puede impedir EOF o mantener recursos abiertos durante otro programa.
- Seguir ejecutando cuando exec falla. El hijo podría entrar en lógica que no le corresponde. Informa del fallo y termina su rama.
- Esperar antes de consumir una salida grande. Puedes introducir un interbloqueo por capacidad finita.
- Consultar WEXITSTATUS sin WIFEXITED. Una terminación por señal no es una salida normal con ese código.
- Suponer que close-on-exec también actúa en fork. La referencia sigue existiendo en el hijo hasta el reemplazo exitoso o un cierre explícito.
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
- fork crea un hijo; exec cambia el programa del proceso existente.
- Las variables ordinarias se independizan, pero los descriptores heredados pueden referirse a los mismos objetos del núcleo.
- Dos descriptores de la misma apertura comparten el desplazamiento del archivo regular y sus flags de estado.
- dup2 permite preparar entrada o salida estándar antes de ejecutar un comando.
- close libera una referencia de la tabla del proceso que lo llama; no cierra por sí solo todas las demás.
- EOF de una tubería requiere agotar los bytes y cerrar todos los escritores.
- waitpid recoge al hijo y entrega un estado que se interpreta mediante las macros correspondientes.
- FD_CLOEXEC controla qué referencias sobreviven a exec, sin sustituir los cierres necesarios después de fork.
- Los búferes de stdio son memoria de usuario y necesitan una consideración distinta de los descriptores.
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
- 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.
- 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.
- 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.
- 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.
- Ejecuta
./capturar_comando seq 1 100000 > numeros.txty comprueba que se capturaron todas las líneas. Explica por qué el padre debe leer antes de esperar. - 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.
- 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.
- Busca en una traza el mismo PID antes y después de execve. Relaciónalo con la diferencia entre proceso y programa.