Llamadas al sistema

Sistema de bifurcación llamada Linux

Sistema de bifurcación llamada Linux

Llamada al sistema de horquilla

La llamada al sistema de la bifurcación se utiliza para crear nuevos procesos. El proceso recién creado es el proceso hijo. El proceso que llama a fork y crea un nuevo proceso es el proceso padre. Los procesos hijo y padre se ejecutan al mismo tiempo.

Pero los procesos hijo y padre residen en diferentes espacios de memoria. Estos espacios de memoria tienen el mismo contenido y cualquier operación realizada por un proceso no afectará al otro proceso.

Cuando se crea el proceso hijo; ahora ambos procesos tendrán el mismo contador de programa (PC), por lo que ambos procesos apuntarán a la misma instrucción siguiente. Los archivos abiertos por el proceso padre serán los mismos para el proceso hijo.

El proceso hijo es exactamente el mismo que el padre, pero hay una diferencia en los ID de los procesos:

  1. El ID de proceso del proceso hijo es un ID de proceso único que es diferente de los ID de todos los demás procesos existentes.
  2. La identificación del proceso de los padres será la misma que la identificación del proceso del padre del niño.

Propiedades del proceso hijo

Las siguientes son algunas de las propiedades que tiene un proceso hijo:

  1. Los contadores de CPU y la utilización de recursos se inicializan para restablecerse a cero.
  2. Cuando se termina el proceso principal, los procesos secundarios no reciben ninguna señal porque el atributo PR_SET_PDEATHSIG en prctl () se restablece.
  3. El hilo usado para llamar a fork () crea el proceso hijo. Entonces, la dirección del proceso secundario será la misma que la del padre.
  4. El descriptor de archivo del proceso padre es heredado por el proceso hijo. Por ejemplo, el desplazamiento del archivo o el estado de las banderas y los atributos de E / S se compartirán entre los descriptores de archivo de los procesos padre e hijo. Por lo tanto, el descriptor de archivo de la clase principal se referirá al mismo descriptor de archivo de la clase secundaria.
  5. Los descriptores de cola de mensajes abiertos del proceso padre son heredados por el proceso hijo. Por ejemplo, si un descriptor de archivo contiene un mensaje en el proceso padre, el mismo mensaje estará presente en el descriptor de archivo correspondiente del proceso hijo. Entonces podemos decir que los valores de las banderas de estos descriptores de archivo son los mismos.
  6. De manera similar, los procesos secundarios heredarán los flujos de directorio abiertos.
  7. El valor de holgura del temporizador predeterminado de la clase secundaria es el mismo que el valor de holgura del temporizador actual de la clase principal.

Propiedades que no hereda el proceso hijo

Las siguientes son algunas de las propiedades que no hereda un proceso hijo:

  1. Bloqueos de memoria
  2. La señal pendiente de una clase secundaria está vacía.
  3. Procesar bloqueos de registros asociados (fcntl ())
  4. Operaciones de E / S asíncronas y contenido de E / S.
  5. Notificaciones de cambio de directorio.
  6. Los temporizadores como alarm (), setitimer () no son heredados por la clase secundaria.

tenedor () en C

No hay argumentos en fork () y el tipo de retorno de fork () es entero. Debe incluir los siguientes archivos de encabezado cuando se usa fork ():

#incluir
#incluir
#incluir

Al trabajar con tenedor (), se puede utilizar para el tipo pid_t para procesos ID como pid_t se define en .

El archivo de encabezado es donde se define fork (), por lo que debe incluirlo en su programa para usar fork ().

El tipo de retorno se define en y la llamada fork () se define en . Por lo tanto, debe incluir ambos en su programa para usar la llamada al sistema fork ().

Sintaxis de fork ()

La sintaxis de la llamada al sistema fork () en Linux, Ubuntu es la siguiente:

pid_t fork (vacío);

En la sintaxis, el tipo de retorno es pid_t. Cuando el proceso hijo se crea con éxito, el PID del proceso hijo se devuelve en el proceso padre y 0 se devolverá al proceso hijo en sí.

Si hay algún error, se devuelve -1 al proceso padre y no se crea el proceso hijo.

No se pasan argumentos a fork (). 

Ejemplo 1: llamar a fork ()

Considere el siguiente ejemplo en el que hemos utilizado la llamada al sistema fork () para crear un nuevo proceso hijo:

CÓDIGO:

#incluir
#incluir
#incluir
int main ()

tenedor();
printf ("Usando la llamada al sistema fork () \ n");
return 0;

PRODUCCIÓN:

Usando la llamada al sistema fork ()
Usando la llamada al sistema fork ()

En este programa, hemos usado fork (), esto creará un nuevo proceso hijo. Cuando se crea el proceso hijo, tanto el proceso padre como el proceso hijo apuntarán a la siguiente instrucción (el mismo contador de programa). De esta forma las instrucciones restantes o sentencias C se ejecutarán el número total de tiempos de proceso, es decir 2norte veces, donde n es el número de llamadas al sistema fork ().

Entonces, cuando la llamada fork () se usa una vez como arriba (21 = 2) tendremos nuestra salida 2 veces.

Aquí, cuando se usa la llamada al sistema fork (), la estructura interna se verá así:

Considere el siguiente caso en el que el fork () se usa 4 veces:

CÓDIGO:

#incluir
#incluir
#incluir
int main ()

tenedor();
tenedor();
tenedor();
tenedor();
printf ("Usando la llamada al sistema fork ()");
return 0;

Producción:

Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando fork () llamada al sistema Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () Usando la llamada al sistema fork () 

Ahora el número total de procesos creados son 24 = 16 y tenemos nuestra declaración de impresión ejecutada 16 veces.

Ejemplo 2: probar si fork () fue exitoso

En el siguiente ejemplo, hemos utilizado la construcción de toma de decisiones para probar el valor (int) devuelto por fork (). Y se muestran los mensajes correspondientes:

CÓDIGO:

#incluir
#incluir
#incluir
int main ()

pid_t p;
p = tenedor ();
si (p == - 1)

printf ("Hay un error al llamar a fork ()");

si (p == 0)

printf ("Estamos en el proceso hijo");

demás

printf ("Estamos en el proceso padre");

return 0;

PRODUCCIÓN:

Estamos en proceso de padres
Estamos en el proceso del niño

En el ejemplo anterior, hemos utilizado el tipo pid_t que almacenará el valor de retorno de fork (). fork () se llama en línea:

p = tenedor ();

Entonces, el valor entero devuelto por fork () se almacena en py luego se compara p para verificar si nuestra llamada a fork () fue exitosa.

Cuando se usa la llamada fork () y el hijo se crea correctamente, la identificación del proceso hijo se devolverá al proceso padre y 0 se devolverá al proceso hijo.La identificación del proceso secundario en el proceso principal no será la misma que la identificación del proceso secundario en el proceso secundario. En el proceso hijo, el ID del proceso hijo será 0.

Con este tutorial, puede ver cómo comenzar con la llamada al sistema fork en linux.

Puertos de código abierto de motores de juegos comerciales
Las recreaciones gratuitas, de código abierto y de motores de juegos multiplataforma se pueden usar para jugar títulos de juegos antiguos y también al...
Los mejores juegos de línea de comandos para Linux
La línea de comandos no es solo su mayor aliado cuando usa Linux, también puede ser la fuente de entretenimiento porque puede usarla para jugar muchos...
Las mejores aplicaciones de mapeo de gamepad para Linux
Si te gusta jugar juegos en Linux con un gamepad en lugar de un sistema de entrada de teclado y mouse típico, hay algunas aplicaciones útiles para ti....