-
Notifications
You must be signed in to change notification settings - Fork 16
/
program_execution.txt
193 lines (177 loc) · 11.6 KB
/
program_execution.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
PROGRAM_EXECUTION
ENVIRONMENT VARIABLES #Préférer les fonctions suivantes à la manipulation du
==> #troisième argument de main(), char **arge.
#Les environment variables sont enregistrées sous la
#forme "VAR=VAL". Nous appelerons VAR la CLEF, et VAL
#la CLEF_VAL.
#Voici :
HEADER ==> #<unistd.h>
environ #STR_ARR contenant les environment variables courantes.
#N'a pas besoin que main soit invoqué avec char **arge
HEADER ==> #<stdlib.h>
getenv(STR) # Voir C89.
HEADER ==> #<stdlib.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
setenv(STR1, STR2, #Fait que la CLEF_VAL STR2 est affectée à la CLEF STR1.
INT_VAL) #Si STR1 existe déjà dans l'environment courant et
#qu'INT_VAL == 0, rien n'est effectué (ce n'est pas une
#erreur pour autant). STR2 peut être une null string.
----| Renvoie 0 si succès, != 0 si erreur
unsetenv(STR1) #Equivaut à setenv(STR1, "", 1)
HEADER ==> #<stdlib.h>
MACROS A DEFINIR ==> #_SVID_SOURCE
putenv(STR) #STR est sous la forme "VAR=VAL". La CLEF_VAL VAL est
#affectée à la CLEF VAR, qu'elle existe déjà ou non. STR
#n'est pas copié mais utilisé tel quel par l'environment
#Ainsi, STR ne doit pas être local et, s'il est
#dynamiquement alloué, lorsqu'il sera freed, il sera
#peut-être enlevé de l'environment.
#Si STR ne contient pas d'=, il est interprété comme
#"STR="""
----| Renvoie 0 si succès, != 0 si erreur. Préférer setenv()
clearenv(void) #Vide l'environment courant. environ devient donc NULL.
----| Renvoie 0 si succès, != 0 si erreur
HEADER ==> #<sys/types.h>
pid_t #Type enregistrant un PID ou PPID (souvent INT)
getpid(void) ----# Renvoie le PID du process courant sous forme de pid_t
getppid(void) ----# Renvoie le PID du process parent sous forme de pid_t
A COMPLETER ==>
FORK VS EXEC ==> #Voici la liste des attributs hérités ou non du process
#parent après un fork() ou exec*() :
#
# exec*() fork()
#
# PID et PPID == nouveaux
# session et process group == ?
# RUID et GID == ?
# umask == ?
# signal mask == ==
# signal en cours == annulés
# signal handlers (ceux étant sur SIG_IGN
# uniquement) == ==
# autres signal handlers != ==
# exit handlers pas hérités ?
# timers (dont alarm) en cours ==(?) pas hérités
# temps écoulé et ressources utilisées depuis début du
#process == remis à 0
# répertoire courant et répertoire root (attention à
#pas bloquer le pwd) == ?
# file descriptor, sauf si FD_CLOEXEC flag. Streams
#ferment, mais leur fd est encore disponible (le
#récupérer, et faire un fdopen() ensuite) == copi
#es des fd (donc share slt le file position, mais les
#flags peuvent être manipulés à part), streams restent
#ouverts
# file et memory locks pas hérités pas hérités
# sémaphores ajustement ? pas hérités
# termination signal SIGCHLD SIGCHLD
# tous pthreads objects (dont mutex) ? hérités
# mmap pas hérités ?
# unamed et named sémaphores pas hérités ?
# Locales setlocale(LC_ALL, "C") est éxécuté au
#début ?
#
#Le reste est hérité
HEADER ==> #<unistd.h>
fork(void) #Crée un process enfant identique à celui courant.
#L'image du process est copié à partir de celui courant,
#les deux reprennent en même temps à partir de
#l'invocation de fork().
----| Renvoie 0 s'il s'agit du retour de fork() dans le
| process parent, et renvoie le PID du process forké
| s'il s'agit de ce dernier, sous forme de pid_t.
| Renvoie -1 si erreur. Permet de différencier ensuite
| l'action du process forké et du process parent.
| Une technique courante est le fork-and-die : un daemon
| lance un ou plusieurs processes via fork(), puis
| s'arrête.
execve(STR, STR_ARR1, #Exécute le fichier dont le chemin est STR, avec les
STR_ARR2) #arguments STR_ARR1, et les environment variables
#STR_ARR2.
#Le premier STR de STR_ARR1 doit être le même exécutable
#que STR (il s'agit de $0)
#Le dernier STR des arrays STR_ARR1 et STR_ARR2 doit
#être un NULL
#STR_ARR2 peut être environ.
#STR_ARR2 est une array de strings sous la forme
#"VAR=VAL"
#L'exécutable STR devient la nouvelle image du process
#courant, il le remplace. Le process d'origine ne
#reprend donc pas après l'exécution de STR, il s'agit
#d'un réel remplacement.
----| Ne retourne rien si succès, car le process courant est
| discarded. Si erreur, retourne -1
execv(STR, STR_ARR1) #Equivaut à execve(STR, STR_ARR1, environ)
execvp(STR, STR_ARR1) #Comme execv(), mais STR prend en compte PATH s'il
#s'agit d'un chemin relatif
execle(STR, STR..., #Comme execve(), mais n'utilise pas un STR_ARR, mais une
STR_ARR2) #ellipse STR...
execl(STR, STR...) #Même chose, mais pour execv()
execlp(STR, STR...) #Même chose, mais pour execvp()
HEADER ==> #<sys/wait.h>
PROCESSUS ZOMBIES ==> #Un processus zombie est un processus s'étant achevé,
#mais dont certaines valeurs de retour restent en
#mémoire, le temps que son parent fasse un waitpid().
#Si SIGCHLD est automatiquement ignoré (SIG_IGN), alors
#un processus ne devient jamais zombie (ce n'est pas
#l'action par défaut, il faut faire par exemple un
#signal(SIGCHLD, SIG_IGN))
#Un process zombie dont le parent meurt est hérité par
#init(), qui fait un wait() immédiatement pour le
#supprimer.
W* FLAGS ==> #Flags utilisés par waitpid() comme option. Les voici :
WNOHANG #N'effectue que 1), et pas 2)
WUNTRACED #Recherche non seulement le fait qu'un process enfant
#soit achevé/zombie OU qu'il soit stoppé.
WCONTINUED #Recherche non seulement le fait qu'un process enfant
#soit achevé/zombie OU qu'il ait été stoppé puis
#continué.
W* MACROS ==> #Macros utilisées avec l'INT_VAL renvoyé comme STATUS
#par waitpid(), pour informer sur ce STATUS. Indique
#pour le processus enfant :
WIFEXITED(INT_VAL) #Renvoie != 0 s'il s'est achevé normalement, avec
#return ou exit(), ou 0 sinon
WEXITSTATUS(INT_VAL) #Renvoie l'exit code. Ne doit être employé que si
#WIFEXITED renvoie != 0
WIFSIGNALED(INT_VAL) #Renvoie != 0 s'il s'est achevé à cause d'un signal, ou
#0 sinon.
WTERMSIG(INT_VAL) #Renvoie le numéro du signal ayant achevé le process. A
#n'utiliser que si WIFSIGNALED renvoie != 0
WCOREDUMP(INT_VAL) #Renvoie != 0 s'il y a eu un core dump lors de la
#clôture. A n'utiliser que si WIFSIGNALED renvoie != 0
WIFSTOPPED(INT_VAL) #Renvoie != 0 s'il a été stoppé. Ne marche que si
#waitpid() a utilisé le flag WUNTRACED
WSTOPSIG(INT_VAL) #Renvoie le numéro du signal l'ayant stoppé. A
#n'utiliser que si WIFSTOPPED renvoie != 0
WIFCONTINUED(INT_VAL) #Renvoie != 0 s'il a subi un SIGCONT après avoir été
#stoppé. Ne marche que si waitpid() a utilisé le flag
#WCONTINUED.
WAIT_ANY #Macro utilisée par waitpid() (-1)
WAIT_MYGRP #Même chose (0)
waitpid(PID_T_VAL, # 1) S'il y a des processus enfants zombies dont le PID,
INT1_ADR, INT2_VAL) # matche PID_T_VAL, choisit l'un de ces processus,
# qui cesse alors d'être zombie
# 2) Sinon, attends que le processus enfant dont le PID
# est PID_T_VAL s'achève.
#PID_T_VAL signifie s'il est :
# - > 0 : process enfant ayant le PID PID_T_VAL
# - WAIT_MYGRP : process enfant dont le PGID == PGID
# courant
# - WAIT_ANY : tout process enfant
# - < -1 : process enfant dont le PGID == abs(PIDT_VAL)
#Si INT1_ADR n'est pas NULL, un STATUS représentant
#le processus s'étant achevé est affecté à INT1_VAR.
#INT2_VAL est une suite de W* flags or'd qui activent
#des options. 0 si aucune option.
#waitpid() est donc à la recherche d'un process enfant
#achevé, mais en fonction des flags INT2_VAL peut
#aussi recherché un process enfant stoppé ou continué.
----| Si succès, renvoie le PID du process enfant choisi.
| Si le flag WNOHANG a été précisé, et que des process
| matchant PID_T_VAL existent mais n'étaient pas
| zombies, renvoie 0
| Si échec (pas de processus enfant), ou erreur, renvoie
| -1.
wait(INT1_ADR) #Equivaut à waitpid(-1, INT1_ADR, 0)