1. ¿Qué es un Proceso? ======================

En el ámbito de los sistemas operativos, un proceso se define como una instancia de un programa en ejecución. Para comprenderlo mejor, recordemos la arquitectura de Von Neumann: los datos de entrada/salida y las instrucciones de un programa residen en la memoria principal. Cuando la CPU comienza a ejecutar estas instrucciones almacenadas en la memoria, el programa pasa de ser un simple archivo en disco a una entidad activa: un proceso.

De manera sencilla, un programa que ha sido cargado en la memoria RAM y está en estado de ejecución se considera un proceso. Es común y esperado que un sistema operativo moderno pueda gestionar múltiples procesos simultáneamente. Por ejemplo, podemos escuchar música y navegar por internet al mismo tiempo, lo que demuestra la ejecución concurrente de varios procesos.

2. Gestión de Procesos ======================

Una vez que entendemos la naturaleza de un proceso, el siguiente paso es comprender cómo el sistema operativo los gestiona eficientemente dentro de la memoria.

2.1. El Mecanismo de Gestión

El objetivo principal es supervisar y controlar las múltiples instancias de programas en ejecución. Necesitamos la capacidad de inspeccionar el estado de cada proceso y, si es necesario, modificar ciertos aspectos de su comportamiento o asignación de recursos.

Sin embargo, el código y los datos de un programa por sí solos no son suficientes para esta tarea. Consideremos un programa simple como hello.c. Si múltiples usuarios lo ejecutan, ¿cómo distingue el sistema entre las diferentes instancias? ¿Cómo rastrea la ubicación de cada una en la memoria?

Para resolver esto, el sistema operativo asocia a cada programa en ejecución una serie de atributos adicionales que facilitan su administración. Estos atributos incluyen, pero no se limitan a:

• Un identificador único para el proceso (PID).
• El estado actual del proceso (ejecutándose, esperando, detenido, etc.).
• Prioridad de ejecución.
• Punteros a la región de memoria donde reside el código y los datos del proceso.
• Información sobre los recursos que está utilizando (archivos abiertos, dispositivos).

Así, un proceso no es meramente el código y los datos de un programa cargado en memoria, sino también toda esta información administrativa adicional.

El principio fundamental de la gestión en sistemas operativos es la filosofía de "describir y luego organizar":

• Descripción: Primero se definen las propiedades y características que el sistema necesita para gestionar una entidad. Para un proceso, estas propiedades se agrupan en una estructura de datos.
• Organización: Una vez descritas las entidades, se eligen estructuras de datos adecuadas (como listas, árboles, etc.) para almacenar y relacionar estas descripciones, permitiendo operaciones eficientes como búsqueda, inserción o eliminación.

Dado que el kernel de Linux (y muchos otros sistemas operativos) está escrito en C, estas "descripciones" se implementan como estructuras (struct). Por lo tanto, cada proceso puede verse como una instancia de una estructura de datos que encapsula sus atributos de gestión.

Es crucial entender que la información de gestión (los atributos) está separada del código y los datos del programa en sí, aunque vinculada a ellos.

2.2. Bloque de Control de Proceso (PCB)

El conjunto de atributos que describen y permiten la gestión de un proceso se conoce como Bloque de Control de Proceso (PCB). Cada proceso en el sistema tiene su propio PCB, que es una estructura de datos que contiene toda la información necesaria para que el sistema operativo lo administre.

Entre los campos típicos de un PCB se encuentran:

• Identificador de Proceso (PID) y de Proceso Padre (PPID).
• Estado del proceso (nuevo, listo, ejecutando, esperando, terminado).
• Registros de la CPU (contador de programa, registros generales).
• Información de planificación de la CPU (prioridad, punteros).
• Información de gestión de memoria (tablas de páginas, límites de memoria).
• Información contable (tiempo de CPU utilizado, límites de recursos).
• Información de E/S (archivos abiertos, dispositivos asignados).

Por lo tanto, "gestionar procesos" es, en esencia, "gestionar sus PCBs". Los PCBs suelen organizarse en listas enlazadas u otras estructuras de datos dentro del kernel, permitiendo al sistema operativo realizar operaciones como la creación, destrucción, suspensión y reanudación de procesos.

2.2.1. task_struct en Linux

En el kernel de Linux, la implementación específica del PCB es la estructura task_struct. Es una de las estructuras de datos más importantes en el kernel, ya que encapsula toda la información de un proceso.

La creación de un nuevo proceso en Linux implica la instanciación y inicialización de una nueva task_struct.

2.2.2. Organización de task_struct

El kernel de Linux organiza las diferentes estructuras task_struct en una lista doblemente enlazada, lo que facilita la iteración a través de todos los procesos activos y la realización de operaciones de planificación y gestión. Además, estas listas pueden estar integradas en estructuras más complejas, como árboles o colas de prioridad, para gestionar diferentes estados o grupos de procesos.

3. Visualización de Procesos ============================

Para ver los procesos que están activos en nuestro sistema, podemos utilizar varias herramientas. Aquí exploraremos dos métodos comunes en entornos Linux.

3.1. Comando ps

El comando ps (process status) es fundamental para obtener una instantánea de los procesos en ejecución. La combinación de opciones ajx proporciona una salida detallada en un formato de estilo BSD, incluyendo información sobre el ID de usuario, PID, PPID, etc.

ps ajx

Este comando mostrará una tabla con muchos procesos. Notará columnas como PID (Process ID) y PPID (Parent Process ID), que son los identificadores únicos de cada proceso y de su proceso padre, respectivamente. La operación de ps en sí implica recorrer las estructuras de datos del kernel (los PCBs) para recopilar esta información.

Para buscar un proceso específico, se puede combinar ps con grep:

ps ajx | grep mi_aplicacion

Si busca mi_aplicacion, verá que grep mi_aplicacion también aparece como un proceso. Esto es porque el comando grep, al ejecutarse, se convierte en un proceso por sí mismo.

3.2. Explorando el sistema de archivos /proc

Linux ofrece una interfaz fascinante para inspeccionar los procesos en tiempo real a través del sistema de archivos virtual /proc. Dentro de este directorio, el kernel crea una carpeta con nombre numérico para cada proceso en ejecución, utilizando su PID como nombre.

ls /proc

Al ejecutar este comando, verá una lista de directorios numéricos. Cada uno corresponde a un proceso activo. Cuando un proceso finaliza, su directorio correspondiente en /proc se elimina automáticamente. Estos directorios contienen archivos que exponen los atributos internos del PCB de cada proceso.

Para ver los atributos de un proceso específico, podemos listar el contenido de su directorio:

ls -l /proc/<PID_del_proceso>

Dentro de estos directorios, encontrará enlaces simbólicos y archivos informativos. Uno de los más relevantes es cwd (current working directory), que es un enlace simbólico al directorio de trabajo actual del proceso. Este es el directorio desde el cual el proceso se lanzó o su directorio de trabajo modificado. Este concepto explica por qué muchos comandos de archivo operan implícitamente en la "ubicación actual" sin necesidad de especificar rutas absolutas, ya que el proceso tiene un registro de su propio directorio de trabajo.

4. Procesos Padre e Hijo ========================

4.1. Concepto de Procesos Padre e Hijo

Cada proceso tiene un PID (Process ID), un número único que lo identifica en el sistema. Además, la mayoría de los procesos (excepto el proceso 'init', que es el padre de todos) tienen un PPID (Parent Process ID), que identifica al proceso que lo creó.

Podemos obtener los PIDs de un proceso en ejecución programáticamente en C:

#include <stdio.h>
#include <unistd.h> // Para getpid() y getppid()
#include <sys/types.h> // Para pid_t

int main() {
    pid_t mi_pid = getpid();    // Obtiene el PID del proceso actual
    pid_t mi_ppid = getppid();  // Obtiene el PID del proceso padre

    printf("Mi PID: %d\n", (int)mi_pid);
    printf("PID de mi padre: %d\n", (int)mi_ppid);

    return 0;
}

Al compilar y ejecutar este código, verá los PIDs de su proceso y su proceso padre. Si lo ejecuta múltiples veces, notará que el PID de su proceso cambiará, pero el PPID de su proceso (que es el PID del shell bash, por ejemplo) probablemente permanecerá constante (a menos que cierre la terminal).

Para verificar el padre, podemos usar ps:

ps -axj | head -n 1 && ps -axj | grep <PID_del_padre>

El resultado mostrará que el proceso padre es, muy a menudo, bash (el intérprete de comandos). Esto se debe a que cuando ejecutas un comando en la terminal, bash crea un nuevo proceso (un hijo) para ejecutar ese comando.

4.2. Creación de Procesos Hijos con fork()

La llamada al sistema fork() es la forma primordial en que un proceso crea un duplicado de sí mismo, dando origen a un proceso hijo. A diferencia de ejecutar un programa externo (como ./mi_programa), fork() crea un nuevo proceso que inicialmente es una copia exacta del proceso padre.

4.2.1. Uso de fork()

Consideremos el siguiente ejemplo:

#include <stdio.h>
#include <unistd.h> // Para fork(), getpid(), getppid()
#include <sys/types.h> // Para pid_t

int main() {
    printf("--- Antes de fork()... Mi PID: %d ---\n", (int)getpid());

    pid_t id_proceso = fork(); // Llamada a fork

    if (id_proceso == -1) {
        perror("Error al crear el proceso hijo");
        return 1;
    } else if (id_proceso == 0) {
        // Este bloque se ejecuta en el proceso hijo
        printf("Soy el PROCESO HIJO. Mi PID: %d, Mi PPID: %d. Valor de id_proceso: %d\n",
               (int)getpid(), (int)getppid(), (int)id_proceso);
    } else {
        // Este bloque se ejecuta en el proceso padre
        printf("Soy el PROCESO PADRE. Mi PID: %d, Mi PPID: %d, Hijo PID: %d. Valor de id_proceso: %d\n",
               (int)getpid(), (int)getppid(), (int)id_proceso, (int)id_proceso);
    }

    printf("--- Esta línea la ejecutan AMBOS procesos. Mi PID: %d ---\n", (int)getpid());

    return 0;
}

Al ejecutar este código, notará que algunos mensajes se imprimen dos veces. Esto se debe a que, después de la llamada a fork(), tanto el proceso padre como el hijo continúan ejecutando el código a partir del punto de la llamada a fork().

La función fork() tiene un comportamiento de retorno peculiar:

• En el proceso padre, fork() devuelve el PID del nuevo proceso hijo.
• En el proceso hijo, fork() devuelve 0.
• Si ocurre un error, fork() devuelve -1 en el proceso padre y no se crea un hijo.

4.2.2. Análisis de fork(): Tres Preguntas Clave

i. ¿Por qué el hijo recibe 0 y el padre el PID del hijo?

La razón principal es la diferenciación. Después de fork(), el padre y el hijo ejecutan el mismo código. Para que puedan realizar tareas distintas, necesitan una manera de saber quién es quién. Devolver 0 al hijo es una forma sencilla de identificarlo, ya que 0 nunca es un PID válido para un proceso (los PIDs son números positivos). El padre necesita el PID del hijo para poder gestionarlo (por ejemplo, esperar su finalización o enviarle señales).

ii. ¿Cómo es que fork() devuelve dos veces?

La clave está en que la duplicación del proceso ocurre antes de que fork() devuelva un valor. Cuando fork() es invocado, el kernel realiza una serie de pasos:

1. Crea una nueva task_struct para el proceso hijo.
2. Copia ciertos recursos del padre al hijo (como la tabla de descriptores de archivos).
3. Duplica el espacio de direcciones virtuales del padre (inicialmente de forma virtual).
4. Asigna un nuevo PID al hijo.

En este punto, ya existen dos procesos distintos, padre e hijo, que comparten la misma imagen de memoria lógica y el mismo contador de programa (es decir, la misma posición de ejecución). Por lo tanto, cuando la ejecución llega a la instrucción return dentro de la función fork() (que es parte del código del kernel), tanto el padre como el hijo "retornan" de la función, pero con valores diferentes según su rol.

iii. ¿Cómo puede una variable tener valores diferentes? (El concepto de "Copia en Escritura")

Después de fork(), el padre y el hijo son procesos independientes, aunque inicialmente son casi idénticos. Cada proceso necesita su propio espacio de datos para garantizar su independencia. Si modificaran las mismas variables, podrían interferir entre sí.

Originalmente, la implementación más sencilla sería copiar todo el espacio de memoria de datos del padre al hijo. Sin embargo, esto puede ser ineficiente si el proceso padre tiene una gran cantidad de datos y el hijo solo necesita modificar una pequeña parte o ninguna. Para optimizar esto y reducir el consumo de memoria, Linux utiliza una técnica llamada "Copia en Escritura" (Copy-on-Write, COW).

Con COW, después de fork(), tanto el padre como el hijo comparten las mismas páginas de memoria física para sus datos. Estas páginas se marcan como "solo lectura". Si cualquiera de los procesos (padre o hijo) intenta escribir en una de estas páginas compartidas, el sistema operativo intercepta la operación, crea una copia privada de esa página de memoria para el proceso que intenta escribir, y luego permite que la escritura ocurra en la nueva página privada. Las demás páginas que no se modifican siguen siendo compartidas, ahorrando memoria.

Este mecanismo explica por qué, en el ejemplo de fork(), la variable id_proceso toma diferentes valores en el padre y en el hijo. Aunque ambos tienen una variable llamada id_proceso, en el momento en que se les asigna su valor de retorno específico de fork(), si esa asignación implica una "escritura" en la memoria, el mecanismo COW garantiza que cada uno tenga su propia copia modificada de esa variable.