Sous-routine exec, execl, execle, execlp, execv, execve, execvp, exect ou fexecve

Objectif

Exécute un fichier.

Bibliothèque

Bibliothèque C standard (libc.a)

Syntaxe

#include <unistd.h>

extern 
char **environ;

int execl (
 Path, 
 Argument0 [, Argument1, ...], 0)
const char *Path, *Argument0, *Argument
1, ...;

int execle (
 Path, 
 Argument0 [, Argument1, ...], 0,
        
 EnvironmentPointer)
const 
char *Path, *Argument0, *Argum
ent
1, ...;
char *const EnvironmentPointer[ ];

int execlp (
 File, 
 Argument0 [, Argument1
, ...], 0)
const char *File, *Argument0, *Argument
1, ...;

int execv (
 Path, 
 ArgumentV)
const char *Path;
char *const ArgumentV[ ];

int execve (
 Path, 
 ArgumentV,
        
 EnvironmentPointer)
const char *Path;
char 
*const ArgumentV[ ], *EnvironmentPointer
[ ];

int execvp (
 File, 
 ArgumentV)
const char *File;
char *const ArgumentV[ ];

int exect (
 Path,
 ArgumentV,
 EnvironmentPointer)
char *Path, *ArgumentV, *EnvironmentPointer [ ];

int fexecve (FileDescriptor, ArgumentV, EnvironmentPointer)
int FileDescriptor;
char *const ArgumentV[ ], *EnvironmentPointer[ ];

Descriptif

Sous toutes ses formes, le sous-programme Exec exécute un nouveau programme dans le processus appelant. Le sous-programme Exec ne crée pas de processus, mais superpose le programme en cours à un nouveau, appelé Image de nouveau processus. Le nouveau fichier image de processus peut être l'un des trois types de fichier suivants:

• Fichier binaire exécutable au format de fichier XCOFF.
• Fichier de texte exécutable contenant une procédure de shell (seules les sous-routines Execlp et Execvp permettent ce type de fichier image de nouveau processus).
• Fichier qui nomme un fichier binaire exécutable ou une procédure de shell à exécuter.

La sous-routine Fexecve est équivalente à la sous-routine Execve , sauf que le sous-programme fexecve prend le descripteur de fichier d'un fichier ouvert à exécuter en tant que premier paramètre, au lieu d'un nom de chemin. Toutefois, les points suivants s'appliquent:

L'image de nouveau processus hérite des attributs suivants de l'image du processus appelant: l'appartenance à la session, les ID de groupe supplémentaires, le masque de signal de processus et les signaux en attente.

Le dernier des types mentionnés est reconnu par un en-tête avec la syntaxe suivante:

#! Path [String]

Le #! Est le fichier Nombre magique, qui identifie le type de fichier. Le nom de chemin du fichier à exécuter est indiqué par le paramètre Chemin . Le paramètre Chaîne est une chaîne de caractères facultative qui ne contient ni tabulation ni espace. Si elle est spécifiée, cette chaîne est transmise au nouveau processus en tant qu'argument devant le nom du nouveau fichier image de processus. L'en-tête doit être arrêté avec un caractère de nouvelle ligne. Lorsqu'il est appelé, le nouveau processus transmet le paramètre Path en tant qu' argumentV[0]. Si un paramètre de type chaîne est spécifié dans le nouveau fichier d'image de processus, le sous-programme exec attribue à ArgumentV[0] les valeurs des paramètres Chaîne et Chemin concaténées ensemble. Les autres arguments transmis sont identiques à ceux transmis à la sous-routine Exec .

La sous-routine Exec tente d'annuler l'encours de Demandes d'E-S asynchrones par ce processus. Si les demandes d'E-S asynchrones ne peuvent pas être annulées, l'application est bloquée jusqu'à ce que les demandes soient terminées.

La sous-routine Exec est similaire à la sous-routine Charge , sauf que le sous-programme Exec n'a pas de paramètre de chemin de bibliothèque explicite. A la place, la sous-routine exec utilise la variable d'environnement LIBPATH ou LD_LIBRARY_PATH . La variable LIBPATH , lorsqu'elle est définie, est utilisée en faveur de LD_LIBRARY_PATH; sinon, LD_LIBRARY_PATH est utilisé. Ces variables de chemin de bibliothèque sont ignorées lorsque le programme exécuté par le sous-programme Exec a plus de privilèges que le programme appelant (par exemple, un programme Suid ).

La sous-routine Exect est incluse pour la compatibilité avec les anciens programmes qui sont tracés à l'aide de la commande Ptrace . Le programme en cours d'exécution est forcé en mode à une étape matérielle.

Paramètres

Lorsqu'un programme C est exécuté, il reçoit les paramètres suivants:

main (ArgumentCount, ArgumentV, EnvironmentPointer)
int ArgumentCount;
char *ArgumentV[ ], *EnvironmentPointer[ 
];

Dans cet exemple, le paramètre ArgumentCount est le nombre d'arguments et le paramètre ArgumentV est un tableau de pointeurs de caractères vers les arguments eux-mêmes. Par convention, la valeur du paramètre ArgumentCount est au moins égale à 1, et le paramètre ArgumentV[0] pointe vers une chaîne de caractères contenant le nom du fichier image du nouveau processus.

La routine Principal d'un programme de langage C commence automatiquement par une routine de démarrage d'exécution. Cette routine définit la variable globale environ de sorte qu'elle pointe vers le tableau d'environnement transmis au programme dans EnvironmentPointer. Vous pouvez accéder à cette variable globale en incluant la déclaration suivante dans votre programme:

extern char **environ;

Les sous-programmes Execl, Execv, Execlpet Execvp utilisent la variable globale Environ pour transmettre l'environnement de processus appelant au nouveau processus.

Les descripteurs de fichier ouverts dans le processus d'appel restent ouverts, à l'exception de ceux dont l'indicateur Fermeture-sur-exec est défini. Pour les descripteurs de fichier qui restent ouverts, le pointeur de fichier est inchangé. (Pour plus d'informations sur le contrôle des fichiers, voir le fichier fcntl.h .)

Les descripteurs d'état de conversion et les descripteurs de catalogue de messages de la nouvelle image de processus ne sont pas définis. Pour le nouveau processus, un équivalent du sous-programme Setlocale , spécifiant la valeur LC_ALL pour sa catégorie et la valeur "C" pour son environnement local, est exécuté au démarrage.

Si le nouveau programme requiert des bibliothèques partagées, la sous-routine Exec trouve, ouvre et charge chacun d'entre eux dans l'espace adresse de nouveau processus. Les nombres référencés pour les bibliothèques partagées en cours d'utilisation par l'émetteur de Exec sont décrémentés. Les bibliothèques partagées sont recherchées dans les répertoires répertoriés dans la variable d'environnement LIBPATH . Si l'un de ces fichiers est distant, les données sont copiées dans la mémoire virtuelle locale.

Les sous-programmes Exec réinitialisé tous les signaux capturés à l'action par défaut. Les signaux qui entraînent l'action par défaut continuent de le faire après les sous-routines Exec . Les signaux ignorés restent ignorés, le masque de signal reste le même et l'état de la pile de signaux est réinitialisé. (Pour plus d'informations sur les signaux, voir la sous-routine Sigaction .)

Si le bit de mode SetUserID du fichier image du nouveau processus est activé, le sous-programme exec définit l'ID utilisateur effectif du nouveau processus à l'ID propriétaire du fichier image du nouveau processus. De même, si le bit de mode SetGroupID du fichier image du nouveau processus est activé, l'ID de groupe effectif du nouveau processus correspond à l'ID de groupe du fichier image du nouveau processus. L'ID utilisateur réel et l'ID de groupe réel du nouveau processus restent les mêmes que ceux du processus appelant. (Pour plus d'informations sur les modes SetID , voir la sous-routine chmod .)

A la fin de l'opération Exec , l'ID utilisateur sauvegardé et l'ID groupe sauvegardé du processus sont toujours définis sur l'ID utilisateur effectif et l'ID groupe effectif, respectivement, du processus.

Lorsqu'un ou les deux bits de mode d'ID ensemble sont définis et que le fichier à exécuter est un fichier distant, l'utilisateur de fichier et les ID de groupe passent par la traduction sortante sur le serveur. Elles sont ensuite transmises au poste client où elles sont traduites en fonction de la table de conversion entrante. Ces ID traduits deviennent les ID utilisateur et groupe du nouveau processus.

Le profilage est désactivé pour le nouveau processus.

Le nouveau processus hérite des attributs suivants du processus appelant:

• Valeur de Nice (voir la sous-routine Prior_getpriorité , la sous-routine Priorité de consigne , la sous-routine Gentile )
• ID de processus
• ID du processus parent
• ID groupe de processus
• Valeurs Semadj (voir la sous-routine Semelle )
• ID groupe tty (voir la sous-routine Sortie, Sortieou _exit , sous-routine Sigaction )
• Indicateur Trace (voir la requête 0 du sous-programme Ptrace )
• Temps restant jusqu'à un signal d'alarme (voir la sous-routine incinterval , la sous-routine setitimer et la sous-routine alarm )
• Répertoire de travail
• Répertoire racine
• Masque de création de mode fichier (voir la sous-routine Umask )
• Limite de taille de fichier (voir la sous-routine Ulimit )
• Limites de ressources (voir la sous-routine Getrlimit , la sous-routine Setrlimit et la sous-routine Vlimit )
• tms_utime,tms_stime,tms_cutimeettms_ctimeZones de la structure Tms (voir la sous-routine Heures )
• ID d'utilisateur de connexion

Une fois l'opération terminée, la marque de sous-programmes Exec pour la mise à jourst_atimeDu fichier.

Exemples

1. Pour exécuter une commande et lui transmettre un paramètre, entrez:

   execlp("ls", "ls", "-al", 0);

   Le sous-programme Execlp recherche chacun des répertoires répertoriés dans la variable d'environnement CHEMIN pour la commande Ls , puis il superpose l'image de processus en cours à l'aide de cette commande. Le sous-programme Execlp n'est pas renvoyé, sauf si la commande Ls ne peut pas être exécutée.
   Remarque: Cet exemple n'exécute pas le processeur de commandes de shell, de sorte que les opérations interprétées par l'interpréteur de commandes, telles que l'utilisation de caractères génériques dans les noms de fichier, ne sont pas valides.
2. Pour exécuter l'interpréteur de commandes pour interpréter une commande, entrez:

   execl("/usr/bin/sh", "sh", "-c", "ls -l *.c", 
   0);

   Cette commande exécute la commande Sh avec l'indicateur -c , ce qui indique que le paramètre suivant est la commande à interpréter. Cet exemple utilise la sous-routine execl à la place de la sous-routine execlp car le nom de chemin complet /usr/bin/sh est spécifié, ce qui rend la recherche de chemin inutile.

   L'exécution d'une commande shell dans un processus enfant est généralement plus utile que la simple utilisation de la sous-routine Exec , comme illustré dans cet exemple. La méthode la plus simple consiste à utiliser le sous-programme Système .

3. Voici un exemple de fichier de nouveau processus qui nomme un programme à exécuter:

   #! /usr/bin/awk -f
   { for (i = NF; i > 0; --i) print $i }

   Si ce fichier est nomméreverse, entrez la commande suivante sur la ligne de commande:

   reverse chapter1 chapter2

   Cette commande exécute la commande suivante:

   /usr/bin/awk -f reverse chapter1 chapter2

   Remarque: Les sous-routines Exec utilisent uniquement la première ligne du nouveau fichier image de processus et ignorent le reste. De plus, la commande Awk interprète le texte qui suit un signe # (dièse) comme commentaire.

Valeurs renvoyées

Une fois l'opération terminée, les sous-programmes Exec ne sont pas renvoyé car l'image du processus appelant est surposée par l'image du nouveau processus. Si les sous-programmes exec retournent au processus appelant, la valeur -1 est renvoyée et la variable globale errno est définie pour identifier l'erreur.

Codes d'erreur

Si la sous-routine Exec échoue, elle renvoie un ou plusieurs des codes d'erreur suivants:

Si la sous-routine Exec échoue en raison d'une condition nécessitant une résolution de nom de chemin, elle renvoie un ou plusieurs des codes d'erreur suivants:

En outre, certaines erreurs peuvent se produire lors de l'utilisation du nouveau fichier de processus une fois que l'ancienne image de processus a été remplacée. Ces erreurs incluent des problèmes lors de la configuration des nouveaux registres de données et de pile, des problèmes de mappage d'une bibliothèque partagée ou des problèmes de lecture du nouveau fichier de processus. Etant donné que le retour au processus d'appel n'est pas possible, le système envoie le signal SIGKILL au processus lorsque l'une de ces erreurs se produit.

Si une erreur s'est produite lors du mappage d'une bibliothèque partagée, un message d'erreur décrivant la cause de l'erreur est écrit en erreur standard avant que le signal SIGKILL ne soit envoyé au processus. Si une bibliothèque partagée ne peut pas être mappée, la sous-routine renvoie l'un des codes d'erreur suivants:

Si la sous-routine Fexecve échoue, elle peut également renvoyer l'un des codes d'erreur suivants:

Si NFS est installé sur le système, la sous-routine exec peut également échouer si les conditions suivantes sont remplies: