5 · Interludio: la API de procesos de Unix
Apuntes propios sobre el capítulo 5 de OSTEP (Interlude: Process API). Fuente: https://ostep.org
5.1 El trío: fork(), exec(), wait()
Unix separa “crear un proceso” y “ejecutar un programa” en dos llamadas distintas. Esta decisión, rara a primera vista, es la que da su potencia al modelo.
fork()
fork() crea un clon casi exacto del proceso llamante. Rarezas importantes:
- Retorna dos veces: en el padre devuelve el PID del hijo; en el hijo devuelve 0. Ambos continúan desde el mismo punto del código, y se distinguen mirando ese valor.
- El hijo recibe copias del espacio de direcciones, registros y descriptores (copias lógicas: hoy se implementan con copy-on-write, ver ampliación).
- La salida de padre e hijo es no determinista: el scheduler decide quién corre primero — primer contacto del libro con el no determinismo que explota en la parte de concurrencia.
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(void) {
pid_t pid = fork();
if (pid < 0) { // error
perror("fork"); return 1;
} else if (pid == 0) { // hijo
printf("hijo: pid %d\n", getpid());
} else { // padre
wait(NULL); // espera al hijo
printf("padre: mi hijo era %d\n", pid);
}
}
wait() / waitpid()
El padre se bloquea hasta que un hijo termine, y recoge su código de salida. Además de sincronizar (hace determinista el orden de los printf de arriba), libera al zombi: hasta que alguien hace wait, el SO retiene la entrada del hijo terminado para poder entregar su estado.
exec()
exec() (familia: execl, execvp, …) reemplaza el programa del proceso actual por otro: carga el nuevo ejecutable sobre el mismo proceso, reinicializa heap y pila, y salta a su main. No crea proceso nuevo y no retorna si tiene éxito — el programa que llamó ya no existe en ese proceso.
5.2 Por qué separar fork y exec: el shell
La ventana entre fork() y exec() permite al hijo alterar su propio entorno antes de convertirse en el nuevo programa, sin tocar al padre. Es exactamente lo que hace un shell con cada comando:
- Lees
wc archivo.txt > salida.txty el shell hacefork(). - El hijo, antes de exec: cierra stdout y abre
salida.txt(que reutiliza el descriptor 1) → la redirección queda montada. - El hijo hace
exec("wc", ...): wc escribe en “stdout” sin saber que es un fichero. - El padre hace
wait()y muestra el prompt de nuevo.
Las pipes (ls | wc -l) son la misma jugada con pipe(): un buffer en el kernel con un extremo de escritura y otro de lectura; el shell conecta el stdout del primer hijo al extremo de escritura y el stdin del segundo al de lectura. Programas que no saben nada uno de otro quedan compuestos — la filosofía Unix hecha syscall.
// esqueleto de un shell mínimo
while (1) {
leer_linea(cmd);
if (fork() == 0) { // hijo
preparar_redirecciones();
execvp(cmd->argv[0], cmd->argv);
perror("exec"); _exit(127); // solo se llega aquí si exec falla
}
waitpid(-1, &status, 0); // padre
}
5.3 Control de procesos y señales
kill()envía señales: SIGTERM (terminar, educado), SIGKILL (matar, inapelable), SIGINT (Ctrl-C), SIGTSTP (Ctrl-Z: parar; se reanuda confg/bg), SIGSEGV…- Un proceso puede instalar manejadores con
signal()/sigaction()para reaccionar (salvo a SIGKILL y SIGSTOP, incapturables). - Solo puedes señalar procesos de tu mismo usuario (UID): la noción de usuario delimita el control.
5.4 Herramientas
ps (procesos), top/htop (en vivo), kill/killall, pstree (árbol padre-hijo), nice/renice (prioridad).
Ampliación (no está en OSTEP)
- fork() hoy es COW: no se copia la memoria, solo las tablas de páginas, con todo marcado de solo lectura; la copia ocurre página a página al escribir (cap. 21 y
../virtualizacion.md§3.3). Por esofork()de un proceso de gigas cuesta microsegundos. - posix_spawn() y vfork(): para el caso común fork+exec inmediato existen atajos; y hay una crítica académica seria a fork como API: Baumann et al., A fork() in the road (HotOS 2019) — argumenta que fork es un fósil hostil a la memoria masiva, los hilos y la seguridad. Contrapunto moderno al entusiasmo del capítulo.
- Señales en tiempo real (SIGRTMIN..SIGRTMAX) se encolan (las normales se fusionan). Y
signalfd/pidfdson la interfaz moderna de Linux para gestionarlas sin las trampas clásicas de los handlers. - El PID 1 (init/systemd) adopta a los huérfanos y les hace wait — por eso los zombis no se acumulan indefinidamente si el padre muere.
Referencias
- OSTEP cap. 5.
- Stevens & Rago, Advanced Programming in the UNIX Environment (APUE) — la referencia exhaustiva de esta API.
- Baumann et al., A fork() in the road, HotOS 2019.
man 2 fork,man 2 execve,man 2 wait,man 7 signal.