161 lines
5.1 KiB
Markdown
161 lines
5.1 KiB
Markdown
# Cours 3
|
||
La création de processus via la commande ```fork``` est intéressante mais son utilisation
|
||
est limitée. Le système fourni un compagnon à ```fork``` l'appel système ```exec```. Son rôle est
|
||
de permettre à un processus de _changer son code_ (recouvrir). On parle souvent des appels ```fork/exec```.
|
||
|
||
## La famille ```exec```
|
||
Il existe six primitives de préfixe commun ```exec``` qui se différencient :
|
||
|
||
- par la manière dont les arguments récupérés via l’argument ```argv``` sont transmis.
|
||
|
||
- soit directement sous forme d’un tableau ou vecteur (d’où le ```v```) contenant
|
||
les différents paramètres. Il s’agit des primitives ```execv```, ```execvp``` et ```execve``` qui ont un nombre fixe de paramètres ;
|
||
|
||
- soit sous forme d’une liste (d’où le ```l```) ```arg0, arg1, ..., argn, NULL``` dans
|
||
les primitives ```execl```, ```execlp``` et ```execle``` qui ont ainsi un nombre variable de paramètres ;
|
||
- par la manière dont le fichier à charger est recherché dans le système de fichiers :
|
||
- avec ```execlp``` et ```execvp``` le fichier est recherché dans les répertoires spécifiés via la variable ```PATH``` de l’environnement (et dans l’ordre d’apparition) ;
|
||
- avec les autres primitives, le fichier, s’il n’est pas désigné par une référence absolue, n’est recherché que relativement au répertoire de travail du processus appelant ;
|
||
- par l’environnement conservé par le processus au cours du recouvrement :
|
||
- avec les primitives ```execve``` et ```execle``` un nouvel environnement transmis en
|
||
paramètre se substitue à l’ancien ;
|
||
- avec les autres primitives, l’environnement reste inchangé.
|
||
|
||
Le code de retour peut-être $-1$ en cas d'erreur.
|
||
|
||
### Description
|
||
|
||
```c
|
||
int execl (const char *reference, const char *arg0, ..., NULL);
|
||
```
|
||
|
||
Le fichier de ```reference``` absolue ou relative (au répertoire de travail du processus) donnée est chargé et la fonction ```main``` correspondante est appelée avec les paramètres de la liste constituée par les autres paramètres. Le paramètre ```arg0``` est récupéré dans la fonction ```main``` dans ```argv[0]```.
|
||
|
||
#### Par exemple
|
||
|
||
```c
|
||
execl("/bin/ls", "ls", "-l", "/", NULL)
|
||
```
|
||
correspond à ```ls -l /```.
|
||
|
||
|
||
```c
|
||
int execlp (const char *reference, const char *arg0, ..., NULL);
|
||
```
|
||
|
||
se comporte comme la précédente sauf que si la ```reference``` est relative la recherche de la référence se fait dans les répertoires spécifiés dans la variable ```PATH``` de votre environnement.
|
||
|
||
```c
|
||
int execle (const char *reference, const char *arg0, ..., NULL, const char **arge);
|
||
```
|
||
|
||
même comportement que ```execl``` mais le dernier paramètre pointe sur un environnement à substituer à l'ancien. Un environnement est constitué d'un ensemble de pointeurs sur des chaines de la forme *nom=valeur* (la fin de la liste est marquée par le pointeur ```NULL```).
|
||
|
||
#### Exemple
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
|
||
extern char **environ;
|
||
|
||
int main(int argc, char *argv[]) {
|
||
int ind;
|
||
char **ptr;
|
||
|
||
for (ind = 0; ind < argc; ind++) printf("%s\n", argv[ind]);
|
||
|
||
ptr = environ;
|
||
|
||
while (*ptr != NULL) printf("%s\n", *ptr++);
|
||
|
||
return EXIT_SUCCESS;
|
||
}
|
||
```
|
||
|
||
Dont voici une exécution :
|
||
|
||
```sh
|
||
bash-4.4$ ./recouvrante a s d f fg g=8
|
||
./recouvrante
|
||
a
|
||
s
|
||
d
|
||
f
|
||
fg
|
||
g=8
|
||
CONDA_SHLVL=1
|
||
CONDA_EXE=/anaconda3/bin/conda
|
||
LANG=fr_FR.UTF-8
|
||
XPC_FLAGS=0x0
|
||
DISPLAY=/private/tmp/com.apple.launchd.3687PRnHur/org.macosforge.xquartz:0
|
||
TERM_SESSION_ID=03974C81-0A61-46AD-80DE-7F8E93D00974
|
||
CONDA_PREFIX=/anaconda3
|
||
SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.VXQ8jzyBiw/Listeners
|
||
USER=pvalarcher
|
||
PWD=/Users/pvalarcher/git/ASR31/notes_de_cours/Cours3
|
||
HOME=/Users/pvalarcher
|
||
CONDA_PYTHON_EXE=/anaconda3/bin/python
|
||
TERM_PROGRAM=Apple_Terminal
|
||
TERM_PROGRAM_VERSION=421.2
|
||
Apple_PubSub_Socket_Render=/private/tmp/com.apple.launchd.MVmgyBLeD8/Render
|
||
TMPDIR=/var/folders/fz/3908mpd559x0cywbp_kvkhx00000gn/T/
|
||
CONDA_PROMPT_MODIFIER=
|
||
XPC_SERVICE_NAME=0
|
||
TERM=xterm-256color
|
||
SHELL=/bin/bash
|
||
SECURITYSESSIONID=186aa
|
||
SHLVL=2
|
||
LOGNAME=pvalarcher
|
||
PATH=/anaconda3/bin:/Library/Frameworks/Python.framework/Versions/3.7/bin:/Users/pvalarcher/anaconda/bin:/opt/local/bin:/opt/local/sbin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/TeX/texbin:/opt/X11/bin
|
||
CONDA_DEFAULT_ENV=base
|
||
_=./recouvrante
|
||
OLDPWD=/Users/pvalarcher/git/ASR31/notes_de_cours
|
||
bash-4.4$
|
||
```
|
||
|
||
|
||
```c
|
||
int execv(const char *reference, const char *argv[]);
|
||
```
|
||
|
||
charge ```reference``` et appelle ```main``` avec les paramètres ```argc``` et ```argv```.
|
||
|
||
|
||
#### Exemple
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
#include <unistd.h>
|
||
#define NMAX 5
|
||
main() {
|
||
char *argv[NMAX]; /* NMAX > 3 */
|
||
|
||
argv[0] = "ls"; argv[1] = "-l"; argv[2]="/"; argv[3]=NULL;
|
||
|
||
execv("/bin/ls", argv);
|
||
perror("execv");
|
||
}
|
||
```
|
||
|
||
|
||
#### Exercice
|
||
Montrer que ```argc``` contient bien la bonne valeur.
|
||
|
||
|
||
|
||
```c
|
||
int execvp(const char *reference, const char *argv[]);
|
||
```
|
||
comme ```execv``` mais avec recherche dans le cas ou ```reference``` est relative dans ```PATH```.
|
||
|
||
```c
|
||
int execvp(const char *reference, const char *argv[], const char **arge);
|
||
```
|
||
|
||
comme ```execv``` mais avec installation d'un nouvel environnement.
|
||
|
||
On peut modifier des attributs du processus après recouvrement.
|
||
|
||
|