PDF de programación - Lección 7: Creacion de procesos. FORK

fork

LECCIÓN 7: CREACION DE PROCESOS. FORK.



................................................................


1
LECCIÓN 7: CREACION DE PROCESOS. FORK.


....................................................................................

1


7.1 Introducción: procesos, hilos, tareas.


7.2 Llamada al sistema fork
.......................................................................................................

5



7.3 do_fork


..................................................................................................................................

8


13

7.4 Función copy_process


.........................................................................................................



29


7.5 Funciones auxiliares



...........................................................................................................

dup_task_struct()

..................................................................................................................

29



copy_files()

...........................................................................................................................

30



Copy_fs()
33
..............................................................................................................................



35

Copy_sighand()


.....................................................................................................................



Copy_signal()



........................................................................................................................

36

39

Copy_mm()



...........................................................................................................................

40


dup_mm



..............................................................................................................................

41


7.6 BIBLIOGRAFÍA
................................................................................................................



Linux cross reference

....................................................................................

41



fork

7.1 Introducción: procesos, hilos, tareas.

Antes de hablar de la llamada al sistema fork propiamente dicha, conviene
hablar sobre procesos e hilos. Dos conceptos muy parecidos y relacionados,
pero con un conjunto de sutiles diferencias.
Uno de los principales motivos de la existencia de la informática es imitar el
comportamiento de la mente humana. En un comienzo surgieron los
algoritmos, que no son más que una secuencia de pasos para conseguir un
objetivo, a partir de los cuales surgió el pensamiento de “por qué no hacer
varias cosas a la vez” y es precisamente de esta inquietud de donde surgen
los hilos o threads.
Si queremos que nuestro programa empiece a ejecutar varias cosas "a la
vez", tenemos dos opciones. Por una parte podemos crear un nuevo
proceso y por otra, podemos crear un nuevo hilo de ejecución (un thread).
En realidad nuestro ordenador, salvo que tenga varias CPU’s, no ejecutará
varias tareas a la vez esto se refiere a que el sistema operativo, es este
caso Linux, irá ejecutando los threads según la política del mismo, siendo lo
mas usual mediante rodajas de tiempo muy rápidas que dan la sensación
de simultaneidad.

Procesos

Un proceso es un concepto manejado por el sistema operativo que consiste
en el conjunto formado por:

• Las instrucciones de un programa destinadas a ser ejecutadas por el

microprocesador.

• Su estado de ejecución en un momento dado, esto es, los valores de

los registros de la CPU para dicho programa.

• Su memoria de trabajo, es decir, la memoria que ha reservado y sus

contenidos.

• Otra información que permite al sistema operativo su planificación.

En un sistema Linux, que como ya sabemos es multitarea (sistema
operativo multihilo), se pueden estar ejecutando distintas acciones a la par,
y cada acción es un proceso que consta de uno o más hilos, memoria de
trabajo compartida por todos los hilos e información de planificación. Cada
hilo consta de instrucciones y estado de ejecución.
Cuando ejecutamos un comando en el shell, sus instrucciones se copian en
algún sitio de la memoria RAM del sistema para ser ejecutadas. Cuando las

7 - 1

fork

instrucciones ya cumplieron su cometido, el programa es borrado de la
memoria del sistema, dejándola libre para que más programas se puedan
ejecutar a la vez. Por tanto cada uno de estos programas son los procesos.

Los procesos son creados y destruidos por el sistema operativo, pero lo
hace a petición de otros procesos. El mecanismo por el cual un proceso crea
otro proceso se denomina bifurcación (fork). Los nuevos procesos son
independientes y no comparten memoria (es decir, información) con el
proceso que los ha creado.
En definitiva, es posible crear tanto hilos como procesos. La diferencia
estriba en que un proceso solamente puede crear hilos para sí mismo y en
que dichos hilos comparten toda la memoria reservada para el proceso.

Hilos

Los hilos son similares a los procesos ya que ambos representan una
secuencia simple de instrucciones ejecutada en paralelo con otras
secuencias. Los hilos son una forma de dividir un programa en dos o más
tareas que corren simultáneamente, compitiendo, en algunos casos, por la
CPU.

La diferencia más significativa entre los procesos y los hilos, es que los
primeros son típicamente independientes, llevan bastante información de
estados, e interactúan sólo a través de mecanismos de comunicación dados
por el sistema. Por otra parte, los hilos generalmente comparten la
memoria, es decir, acceden a las mismas variables globales o dinámicas,
por lo que no necesitan costosos mecanismos de comunicación para
sincronizarse. Por ejemplo un hilo podría encarguese de la interfaz gráfica
(iconos, botones, ventanas), mientras que otro hace una larga operación
internamente. De esta manera el programa responde más ágilmente a la
interacción con el usuario.

En sistemas operativos que proveen facilidades para los hilos, es más
rápido cambiar de un hilo a otro dentro del mismo proceso, que cambiar de
un proceso a otro.

Es posible que los hilos requieran de operaciones atómicas para impedir
que los datos comunes sean cambiados o leídos mientras estén siendo
modificados. El descuido de esto puede generar estancamiento.

La tabla 1 resume algunas diferencias entre procesos e hilos, y la figura 1
muestra una representación de los conceptos proceso e hilo. Nótese cómo
en la figura 1 se puede apreciar que los procesos son entidades
independientes, mientras que los hilos son entidades relacionadas por la
sección de datos en el interior del proceso que los contiene.

PROCESOS

HILOS

7 - 2

fork

Manejados por el S.O.

Independientes de

otros procesos

Memoria privada, se

necesitan

mecanismos de

comunicación para

compartir
información

Manejados por los

procesos

Relacionados con

otros hilos del mismo

proceso

Memoria compartida
con el resto de hilos

que forman el

proceso

Tabla 1: Procesos e hilos

Figura1: Relación entre procesos e hilos

Creación de procesos: fork y clone

A la hora de crear procesos linux provee de dos funciones para dicho
cometido, la función clone() y la función fork(). Ambas crean un nuevo
proceso a partir del proceso padre pero de una manera distinta.
Cuando utilizamos la llamada al sistema fork, el proceso hijo creado es una
copia exacta del padre (salvo por el PID y la memoria que ocupa). Al
proceso hijo se le facilita una copia de las variables del proceso padre y de
los descriptores de fichero. Es importante destacar que las variables del
proceso hijo son una copia de las del padre (no se refieren físicamente a la
misma variable), por lo que modificar una variable en uno de los procesos
no se refleja en el otro.

La llamada al sistema clone es mucho más genérica y flexible que el fork,
ya que nos permite definir qué van a