Image de processus superposée

Supposons que nous exécutons un programme et que nous souhaitons exécuter un autre programme à partir du programme actuel. Est-ce possible? Pourquoi pas, si nous implémentons le concept de superposition de l'image de processus. C'est bien, mais qu'en est-il du programme en cours d'exécution, peut-il aussi être exécuté. Comment est-ce possible, puisque nous avons superposé le programme actuel avec le nouveau programme. Que faire, si je veux exécuter les deux programmes sans perdre le programme en cours d'exécution, est-ce possible? Oui c'est possible.

Créez un processus enfant, de sorte que nous ayons un processus parent et un processus enfant nouvellement créé. Nous exécutons déjà le programme actuel dans le processus parent, alors exécutez le processus nouvellement créé dans l'enfant. De cette façon, nous pouvons exécuter un autre programme à partir du programme actuel. Non seulement un seul programme, mais nous pouvons exécuter n'importe quel nombre de programmes à partir du programme actuel en créant autant de processus enfants.

Prenons comme exemple le programme suivant.

/ * Nom du fichier: helloworld.c * /

#include<stdio.h>

void main() {
   printf("Hello World\n");
   return;
}

/ * Nom du fichier: execl_test.c * /

#include<stdio.h>
#include<unistd.h>

void main() {
   execl("./helloworld", "./helloworld", (char *)0);
   printf("This wouldn't print\n");
   return;
}

Le programme ci-dessus superposerait l'image de processus de execl_test avec helloworld. C'est la raison pour laquelle le code image de process de execl_test (printf ()) n'est pas exécuté.

Étapes de compilation et d'exécution

Hello World

Maintenant, nous allons exécuter les deux programmes suivants à partir d'un seul programme, c'est-à-dire execl_run_two_prgms.c.

Programme Hello World (helloworld.c)
Programme en boucle While pour imprimer de 1 à 10 (while_loop.c)

/ * Nom du fichier: while_loop.c * /

/* Prints numbers from 1 to 10 using while loop */
#include<stdio.h>

void main() {
   int value = 1;
   while (value <= 10) {
      printf("%d\t", value);
      value++;
   }
   printf("\n");
   return;
}

Voici le programme pour exécuter deux programmes (un programme de l'enfant et un autre programme du parent).

/ * Nom de fichier: execl_run_two_prgms.c * /

#include<stdio.h>
#include<unistd.h>

void main() {
   int pid;
   pid = fork();
   
   /* Child process */
   if (pid == 0) {
      printf("Child process: Running Hello World Program\n");
      execl("./helloworld", "./helloworld", (char *)0);
      printf("This wouldn't print\n");
   } else { /* Parent process */
      sleep(3);
      printf("Parent process: Running While loop Program\n");
      execl("./while_loop", "./while_loop", (char *)0);
      printf("Won't reach here\n");
   }
   return;
}

Note - Placez un appel sleep () pour vous assurer que les processus enfant et parent s'exécutent séquentiellement (ne chevauchez pas le résultat).

Étapes de compilation et d'exécution

Child process: Running Hello World Program
This wouldn't print
Parent process: Running While loop Program
Won't reach here

Maintenant, nous exécuterions deux programmes à partir d'un seul programme, c'est-à-dire execl_run_two_prgms.c, même programme que ci-dessus mais avec des arguments de ligne de commande. Ainsi, nous exécutons deux programmes à savoir, helloworld.c dans le processus enfant et le programme while_loop.c dans le processus parent. C'est comme suit -

Programme Hello World (helloworld.c)
Programme en boucle While pour imprimer de 1 à num_times_str selon les arguments de la ligne de commande (while_loop.c)

Ce programme effectue globalement les actions suivantes -

Crée un processus enfant
Le processus enfant exécute le programme helloworld.c
Le processus parent exécute le programme while_loop.c en passant la valeur de l'argument de ligne de commande comme argument au programme. Si les arguments de la ligne de commande ne sont pas transmis, la valeur par défaut est 10. Sinon, elle prend la valeur d'argument donnée. La valeur de l'argument doit être numérique; le code ne validerait pas s'il était donné en alphabets.

/ * Nom de fichier: execl_run_two_prgms.c * /

#include<stdio.h>
#include<string.h>
#include<unistd.h>

void main(int argc, char *argv[0]) {
   int pid;
   int err;
   int num_times;
   char num_times_str[5];
   
   /* In no command line arguments are passed, then loop maximum count taken as 10 */
   if (argc == 1) {
      printf("Taken loop maximum as 10\n");
      num_times = 10;
      sprintf(num_times_str, "%d", num_times);
   } else {
      strcpy(num_times_str, argv[1]);
      printf("num_times_str is %s\n", num_times_str);
      pid = fork();
   }
   
   /* Child process */
   if (pid == 0) {
      printf("Child process: Running Hello World Program\n");
      err = execl("./helloworld", "./helloworld", (char *)0);
      printf("Error %d\n", err);
      perror("Execl error: ");
      printf("This wouldn't print\n");
   } else { /* Parent process */
      sleep(3);
      printf("Parent process: Running While loop Program\n");
      execl("./while_loop", "./while_loop", (char *)num_times_str, (char *)0);
      printf("Won't reach here\n");
   }
   return;
}

Voici le programme helloworld.c appelé depuis le processus fils du programme, execl_run_two_prgms.c.

/ * Nom du fichier: helloworld.c * /

#include<stdio.h>

void main() {
   printf("Hello World\n");
   return;
}

Voici le programme while_loop.c appelé depuis le processus parent du programme, execl_run_two_prgms.c. L'argument de ce programme est passé depuis le programme qui l'exécute, c'est-à-dire execl_run_two_prgms.c.

/ * Nom de fichier: while_loop.c * /

#include<stdio.h>

void main(int argc, char *argv[]) {
   int start_value = 1;
   int end_value;
   if (argc == 1)
   end_value = 10;
   else
   end_value = atoi(argv[1]);
   printf("Argv[1] is %s\n", argv[1]);
   while (start_value <= end_value) {
      printf("%d\t", start_value);
      start_value++;
   }
   printf("\n");
   return;
}

Étapes de compilation et d'exécution

Taken loop maximum as 10
num_times_str is 10
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 10
1 2 3 4 5 6 7 8 9 10
Taken loop maximum as 15
num_times_str is 15
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Voyons maintenant les fonctions de la bibliothèque liées aux images superposées.

#include<unistd.h>

int execl(const char *path, const char *arg, ...);

Cette fonction superposerait l'image de processus en cours d'exécution avec le nouveau processus comme mentionné dans les arguments, le chemin et l'argument. Si un argument doit être transmis à une nouvelle image de processus, il sera envoyé via des arguments «arg» et le dernier argument doit être NULL.

Cette fonction renverrait une valeur uniquement en cas d'erreur. Le processus de superposition des appels liés à l'image est comme mentionné ci-dessous -

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

Ces appels concerneraient le passage des arguments de ligne de commande (argv []), des variables d'environnement (envp []) et d'autres paramètres.