Appel système Linux Exec

L'appel système EXEC est utilisé pour exécuter un fichier qui réside dans un processus actif. Lorsque Exec est appelé le fichier exécutable précédent est remplacé et que le fichier est exécuté.

Plus précisément, nous pouvons dire que l'utilisation de l'appel du système Exec remplacera l'ancien fichier ou le programme du processus par un nouveau fichier ou un nouveau programme. L'ensemble du contenu du processus est remplacé par un nouveau programme.

Le segment de données utilisateur qui exécute l'appel système EXEC () est remplacé par le fichier de données dont le nom est fourni dans l'argument lors de l'appel exec ().

Le nouveau programme est chargé dans le même espace de processus. Le processus actuel est simplement transformé en un nouveau processus et donc le processus de processus n'est pas modifié, c'est parce que nous ne créons pas un nouveau processus que nous remplaçons simplement un processus par un autre processus dans EXEC.

Si le processus en cours d'exécution contient plus d'un thread, tous les threads seront terminés et la nouvelle image de processus sera chargée puis exécutée. Il n'y a pas de fonctions de destructeur qui terminent les threads du processus actuel.

Le PID du processus n'est pas modifié mais les données, le code, la pile, le tas, etc. du processus sont modifiés et sont remplacés par ceux du processus nouvellement chargé. Le nouveau processus est exécuté à partir du point d'entrée.

EXEC System Call est une collection de fonctions et dans C Langage de programmation C, les noms standard de ces fonctions sont les suivants:

1. execl
2. execle
3. execlp
4. execv
5. exécution
6. execvp

Il convient de noter ici que ces fonctions ont la même base exécutif suivi d'une ou plusieurs lettres. Ceux-ci sont expliqués ci-dessous:

E: Il s'agit d'un tableau de pointeurs qui pointe vers des variables d'environnement et qui est transmis explicitement au processus nouvellement chargé.

L: l est pour les arguments de ligne de commande transmis une liste à la fonction

P: P est la variable d'environnement de chemin qui aide à trouver le fichier passé comme un argument à charger dans le processus.

V: V est pour les arguments de la ligne de commande. Ceux-ci sont passés comme un tableau de pointeurs vers la fonction.

Pourquoi l'exec est utilisé?

Exec est utilisé lorsque l'utilisateur souhaite lancer un nouveau fichier ou un nouveau programme dans le même processus.

Fonctionnement intérieur de l'exec

Considérez les points suivants pour comprendre le fonctionnement de l'exec:

1. L'image de processus actuelle est écrasée avec une nouvelle image de processus.
2. Nouvelle image de processus est celle que vous avez passé comme argument exécutif
3. Le processus en cours d'exécution est terminé
4. Une nouvelle image de processus a le même ID de processus, le même environnement et le même descripteur de fichiers (car le processus n'est pas remplacé l'image de processus est remplacée)
5. La statistique du CPU et la mémoire virtuelle sont affectées. La cartographie de mémoire virtuelle de l'image de processus actuelle est remplacée par la mémoire virtuelle de la nouvelle image de processus.

Syntaxes des fonctions de la famille Exec:

Voici les syntaxes de chaque fonction d'EXEC:

int execl (const char * path, const char * arg,…)
int execlp (fichier const char *, const char * arg,…)
int execle (const char * path, const char * arg,…, char * const envp [])
int execv (const char * path, const char * argv [])
int execvp (fichier const char *, const char * argv [])
int execvpe (fichier const char *, const char * argv [], char * const envp [])

Description:

Le type de retour de ces fonctions est int. Lorsque l'image de processus est remplacée avec succès, rien n'est renvoyé à la fonction d'appel parce que le processus qui l'appelle ne s'exécute plus. Mais s'il y a une erreur -1 sera retourné. Si une erreur se produit errer est réglé.

Dans la syntaxe:

1. chemin est utilisé pour spécifier le nom de chemin complet du fichier qui doit être exécuté.

2. arg L'argument est-il passé. C'est en fait le nom du fichier qui sera exécuté dans le processus. La plupart du temps, la valeur de l'ARG et du PATH est le même.

3. const char * arg Dans Functions EXECL (), EXECLP () et execle () est considéré comme Arg0, Arg1, Arg2,…, Argn. Il s'agit essentiellement d'une liste de pointeurs vers des cordes terminées nuls. Ici, le premier argument indique le nom de fichier qui sera exécuté comme décrit au point 2.

4. envp est un tableau qui contient des pointeurs qui pointent vers les variables environnementales.

5. déposer est utilisé pour spécifier le nom du chemin qui identifiera le chemin du nouveau fichier d'image de processus.

6. Les fonctions d'appel exec qui se terminent avec e sont utilisés pour modifier l'environnement pour la nouvelle image de processus. Ces fonctions passent la liste des paramètres d'environnement en utilisant l'argument envp. Cet argument est un tableau de caractères qui pointe vers la chaîne terminée nul et définit la variable d'environnement.

Pour utiliser les fonctions de la famille Exec, vous devez inclure le fichier d'en-tête suivant dans votre programme C:

#inclure

Exemple 1: Utilisation du programme Système Exec dans C Programme

Considérez l'exemple suivant dans lequel nous avons utilisé l'appel du système EXEC dans la programmation C dans Linux, Ubuntu: nous avons deux fichiers C ici exemple.C et bonjour.C:

exemple.c

CODE:

#inclure
#inclure
#inclure
int main (int argc, char * argv [])

printf ("pid d'exemple.c =% d \ n ", getPid ());
char * args [] = "Bonjour", "C", "Programmation", null;
execv ("./ bonjour ", args);
printf ("Retour à l'exemple.C ");
retour 0;

Bonjour.c

CODE:

#inclure
#inclure
#inclure
int main (int argc, char * argv [])

printf ("Nous sommes en bond.c \ n ");
printf ("pid de bonjour.c =% d \ n ", getPid ());
retour 0;

SORTIR:

Pid d'exemple.c = 4733
Nous sommes en bond.c
Pid de bonjour.c = 4733

Dans l'exemple ci-dessus, nous avons un exemple.C fichier C et bonjour.c fichier. Dans l'exemple .C Fichier C Tout d'abord, nous avons imprimé l'ID du processus actuel (exemple de fichier.C est en cours d'exécution en cours). Ensuite, dans la ligne suivante, nous avons créé un tableau de pointeurs de personnages. Le dernier élément de ce tableau devrait être nul comme point de terminaison.

Ensuite, nous avons utilisé la fonction execv () qui prend le nom de fichier et le tableau de pointeur de caractère comme argument. Il convient de noter ici que nous avons utilisé ./ avec le nom du fichier, il spécifie le chemin du fichier. Comme le fichier est dans le dossier où l'exemple.C réside donc il n'est pas nécessaire de spécifier le chemin complet.

Lorsque la fonction EXECV () est appelée, notre image de processus sera remplacée maintenant l'exemple de fichier.C n'est pas dans le processus mais le fichier bonjour.C est dans le processus. On peut voir que l'ID de processus est le même si bonjour.C est l'image de processus ou l'exemple.C est l'image de processus car le processus est le même et l'image de processus est uniquement remplacée.

Ensuite, nous avons une autre chose à noter ici qui est l'instruction printf () après que Execv () ne soit pas exécuté. En effet. Le contrôle ne revient qu'à la fonction d'appel lors du remplacement de l'image du processus. (La valeur de retour est -1 dans ce cas).

Différence entre les appels système Fork () et Exec ():

L'appel système Fork () est utilisé pour créer une copie exacte d'un processus en cours et la copie créée est le processus enfant et le processus en cours est le processus parent. Tandis que l'appel système exécutif est utilisé pour remplacer une image de processus par une nouvelle image de processus. Il n'y a donc aucun concept de processus parent et enfant dans l'appel du système exec ().

Dans le système Fork () appelez les processus parent et enfants sont exécutés en même temps. Mais dans EXEC () Call System, si le remplacement de l'image de processus est réussi, le contrôle ne revient pas à l'endroit où la fonction Exec a été appelée plutôt qu'elle exécutera le nouveau processus. Le contrôle ne sera transféré que s'il y a une erreur.

Exemple 2: combinaison des appels système fork () et exec ()

Considérez l'exemple suivant dans lequel nous avons utilisé les appels système Fork () et Exec () dans le même programme:

exemple.c

CODE:

#inclure
#inclure
#inclure
int main (int argc, char * argv [])

printf ("pid d'exemple.c =% d \ n ", getPid ());
pid_t p;
p = fork ();
if (p == - 1)

printf ("Il y a une erreur en appelant Fork ()");

if (p == 0)

printf ("Nous sommes dans le processus enfant \ n");
printf ("appeler bonjour.C de l'enfant Process \ n ");
char * args [] = "Bonjour", "C", "Programmation", null;
execv ("./ bonjour ", args);

autre

printf ("Nous sommes dans le processus parent");

retour 0;

Bonjour.C:

CODE:

#inclure
#inclure
#inclure
int main (int argc, char * argv [])

printf ("Nous sommes en bond.c \ n ");
printf ("pid de bonjour.c =% d \ n ", getPid ());
retour 0;

SORTIR:

Pid d'exemple.c = 4790
Nous sommes dans le processus parent
Nous sommes en procédure enfant
Appeler Hello.C du processus enfant
Nous sommes en bond.c
Pid de bonjour.C = 4791

Dans cet exemple, nous avons utilisé l'appel système Fork (). Lorsque le processus de l'enfant est créé, 0 sera affecté à P, puis nous passerons au processus de l'enfant. Maintenant, le bloc des instructions avec if (p == 0) sera exécuté. Un message s'affiche et nous avons utilisé l'appel système execv () et l'image actuelle du processus enfant qui est un exemple.C sera remplacé par Hello.c. Avant que les processus EXECV () appellent l'enfant et les parents.

On peut voir que le pid d'exemple.C et bonjour.C est différent maintenant. C'est parce que l'exemple.C est l'image du processus parent et bonjour.C est l'image du processus d'enfant.