Syst

1
Systèmes dexploitation

• Les processus

2
Introduction

• Concept de processus est le ? important dans un
  SE
• Processus abstraction dun programme en cours
  dexécution
• Tous les ordinateurs modernes peuvent exécuter
  plusieurs tâches à la fois (ex programme en
  cours de calcul affichage sur un terminal
  impression)
• MAIS le processeur, à un instant donné, nexécute
  réellement quun seul programme
• Dans un système multiprogrammé, le processeur
  passe dun programme à un autre en exécutant
  chaque programme pendant quelques dizaines de
  millisecondes ? impression de parallélisme
• Ce parallélisme est qualifié de
  pseudo-parallélisme
• Attention ne pas confondre avec le parallélisme
  qui seffectue au niveau matériel
  (nécessite plusieurs processeurs)
• Le contrôle de plusieurs activités en
  pseudo-parallélisme est une tâche difficile qui a
  fait lobjet de nombreuses améliorations pour
  obtenir le modèle actuel

3
Le modèle des processus (1)

• Un processus est un programme qui sexécute et
  qui possède son compteur ordinal, ses registres
  et ses variables
• Conceptuellement, chaque processus a son propre
  processeur virtuel
• En réalité, le processeur commute entre plusieurs
  processus
• Cette commutation rapide est appelée
  multiprogrammation

4
Le modèle des processus (2)

• Comme le processeur commute entre les processus,
  la vitesse dexécution dun processus ne sera pas
  uniforme et variera vraissemblablement si les
  mêmes processus sont exécutés à nouveau
• Attention Ne pas confondre programme et
  processus (ex confection dun gâteau
  et piqûre dabeille)
• Lidée clé est quun processus est une activité
  dun certain type qui possède un programme, des
  données, en entrée et en sortie, ainsi quun état
  courant
• Un seul processeur peut être partagé entre
  plusieurs processus en se servant dun algorithme
  dordonnancement qui détermine quand il faut
  suspendre un processus pour en servir un autre

5
Hiérarchie entre les processus

• Les SE qui font appel au concept de processus
  doivent permettre de créer et détruire
  dynamiquement les processus
• 2 exemples Unix et MS-DOS
• Unix
• Les processus sont créés par lappel système fork
• Le fork crée une copie conforme du processus
  appelant
• À la suite du fork, le processus père continue à
  sexécuter en  parallèle  avec son fils
• Le processus père peut créer dautres fils et ces
  processus fils peuvent eux-mêmes avoir des fils ?
  Arborescence de processus ? hiérarchie
• MS-DOS
• Un appel système pour charger un fichier binaire
  en mémoire et lexécuter en tant que processus
  fils
• Contrairement à Unix, MS-DOS suspend le père
  jusquà ce que le fils ai terminé son exécution ?
  pas de pseudo-parallélisme

6
Les différents états dun processus

• Les processus, bien quétant des entités
  indépendantes doivent parfois interagir avec
  dautres processus (ex cat fic1 fic2 grep
  mot)
• Lordre et la vitesse dexécution des processus
  peut amener un des processus à se bloquer (ex
  le grep est prêt à sexécuter mais ne peut le
  faire faute de données)
• Un processus se bloque lorsquil ne peut pas,
  pour une raison logique, poursuivre son exécution
  (ex attente de données)
• Un processus élu peut être arrêté et mis en
  situation dattente (on dit quil est prêt), même
  sil peut poursuivre son exécution (ex le SE
  décide dallouer le processeur à un autre
  processus)
• Ces 2 situations sont totalement différentes
• Dans le premier cas, la suspension est inhérente
  au problème
• Dans le second cas, il sagit dune
  caractéristique technique du système

• 1. Élu (en cours dexécution)
• 3 états possibles 2. Prêt (suspendu pour
  permettre lexécution dun autre processus)
• 3. Bloqué (attendant un événement extérieur
  pour pouvoir continuer)

7
Les transitions entre les états

• Les transitions 2 et 3 sont provoqués par
  lordonnanceur de processus (module du SE)

• Le rôle de lordonnanceur est très important
  il choisit le processus à exécuter ainsi que
  le moment où il faut le lancer il constitue le
  niveau le plus bas du SE

• Il existe ? stratégies dordonnancement, qui
  seront étudiées dans la suite du cours

8
Le modèle des processus (suite)

• Le modèle des processus permet de mieux
  comprendre ce qui se passe à lintérieur du SE
• Une partie des processus exécutent les programmes
  des utilisateurs
• Les autres processus font partie du système et
  gèrent les tâchent telles que les requêtes au
  gestionnaire de fichiers ou les opérations sur
  disques

• Lordonnanceur constitue le niveau le bas du SE

• Il est surmonté dune multitude de processus

• La gestion des interruptions, la suspension et
  la relance des processus sont déportées dans
  lordonnanceur

• Le reste du SE est structuré sous forme de
  processus

9
La réalisation des processus

• Pour mettre en œuvre pratiquement le modèle de
  processus, le SE a une table (tableau de
  structures) la table des processus (TP) dont
  chaque entrée correspond à un processus
  particulier
• Chaque entrée comporte des informations sur
• létat du processus
• son compteur ordinal
• son pointeur de pile
• son allocation mémoire
• létat des fichiers ouverts
• et tout ce qui doit être sauvé lorsquun
  processus passe de létat élu à létat prêt
• Le contenu de la table des processus varie dun
  système à un autre
• En général, les informations concernent la
• La gestion du processus
• La gestion mémoire
• La gestion des fichiers

10
La table des processus Unix
Quelques champs typiques de la table des processus Quelques champs typiques de la table des processus Quelques champs typiques de la table des processus
Gestion des processus Gestion de la mémoire Gestion des fichiers
Registres, compteur ordinal Mot détat du programme Pointeur de pile État du processus Date de lancement du processus Temps CPU utilisé Temps CPU des fils Date de la prochaine alarme Pointeurs sur files de message Bits des signaux en attente Identificateur de processus (pid) Divers indicateurs Pointeur sur le segment de code Pointeur sur segment de données Pointeur sur segment BSS Statut de fin dexécution Statut de signal Identificateur de processus (pid) Processus père Groupe du processus uid réel, uid effectif gid réel, gid effectif Table de bits des signaux Divers indicateurs Masque UMASK Répertoire racine Répertoire de travail Descripteurs de fichiers uid effectif gid effectif Paramètres des appels systèmes Divers indicateurs
11
Les processus Unix

• Un processus Unix se décompose en
• Un espace dadressage (visible par
  lutilisateur/le programmeur)
• Le bloc de contrôle du processus (BCP) lui-même
  décomposé en
• Une entrée dans la TP du noyau struct proc
  définie dans ltsys/proc.hgt
• Une struct user appelée zone u définie dans
  ltsys/user.hgt
• Les processus Unix apportent
• La multiplicité dexécution (plusieurs processus
  peuvent être lexécution dun même prog.)
• La protection des exécutions (un processus ne
  peut exécuter que ses instructions propres et ce
  de façon séquentielle)
• Les processus Unix communiquent entre eux et avec
  le reste du monde grâce aux appels systèmes

12
Création dun processus Unix

• Cette création est réalisée par lappel système
• int fork(void)
• Chaque processus est identifié par un numéro
  unique, son PID
• Tous les processus (sauf le processus de pid0)
  sont créés par un appel à fork
• Le processus qui appelle le fork est appelé
  processus père
• Le nouveau processus est appelé processus fils
• Tout processus a 1 seul père mais peut avoir 0 ou
  plusieurs fils
• Le processus de pid0 est créé  manuellement 
  au démarrage de la machine
• ce processus joue un rôle spécial pour le
  système (swappeur,gestionnaire de pages)
• pour le bon fonctionnement des prog. utilisant
  fork, ce processus reste toujours utilisé
• ce procéssus crée grâce à un appel fork, le
  processus init de pid1
• Le processus de pid1 est lancêtre de tous les
  autres processus (le processus 0 ne réalisant
  plus de fork)
• il a notamment pour rôle de recueillir tous les
  processus orphelins de père (ceci afin de
  collecter les informations à la mort de chaque
  processus)

13
Format dun fichier exécutable

• Les compilateurs permettent de créer des fichiers
  exécutables
• Ces fichiers ont un format particulier qui permet
  au noyau de les transformer en processus
• Une en-tête qui décrit lensemble du fichier, ses
  attributs et sa carte des sections
• Une section TEXT qui contient le code (en langage
  machine)
• Une section DATA codée en langage machine qui
  comporte 2 parties
• Une partie pour les données initialisées
• Une autre pour les données non initialisées (BSS)
• Éventuellement dautres sections
• Table des symboles pour le débuggeur
• Images
• Icones
• Tables des chaînes

14
Chargement/changement dun exécutable

• Lappel système execve change lexécutable du
  processus courant en chargeant un nouvel
  exécutable
• Pour chaque section, de lexécutable une région
  mémoire est alloué soit au moins
• les régions code et données initialisées
• mais aussi les régions des piles et du tas
• La pile est une pile de structures qui sont
  empilées et dépilées lors de lappel ou le retour
  de fonction
• le pointeur de pile, un des registres de lUC
  donne la profondeur courante de la pile
• le code du programme gère les extensions de pile,
  cest le noyau qui alloue lespace nécessaire à
  ces extensions
• un processus Unix pouvant sexécuter dans 2 modes
  (noyau, utilisateur), une pile privée sera
  utilisée dans chaque mode
• Le tas est une zone où est réalisée lallocation
  dynamique avec les fonctions Xalloc()

15
Structure interne des processus
Adresse haute 0xFFFFFFFF
argc, argv, envp argc, argv, envp argc, argv, envp
Tas
? ? ? ? ? ?
Pile
Données non initialisées (BSS) Données non initialisées (BSS) Données non initialisées (BSS)
Données initialisées Données initialisées Données initialisées
Texte Texte Texte
initialisé par exec
lu par exec
Adresse basse 0
16
zone u et table des processus

• Tous les processus sont associés à une entrée
  dans la TP qui interne au noyau
• De , le noyau alloue pour chaque processus une
  structure appelée zone u qui contient les données
  privées du processus (uniquement manipulable par
  le noyau)
• La TP, permet daccéder à la table des régions
  par processus (TRP)
• Ce double niveau dindirection permet le partage
  des régions
• Dans une organisation en mémoire virtuelle, la
  TRP est matérialisée logiquement dans la table
  des pages
• Les structures de régions dans TRP contiennent
  des infos sur le type, les droits daccès et la
  localisation (adresses en mémoire ou adresses sur
  disque) de la région
• Seule la zone u du processus courant est
  manipulable par le noyau, les autres sont
  inaccessibles
• Ladresse de la zone u est placée dans le mot
  détat du processus

17
Le contexte dun processus

• Le contexte dun processus est lensemble des
  données qui permettent de reprendre lexécution
  dun processus qui a été interrompu
• Il est constitué de
• son état
• son mot détat, en particulier
• la valeur des registres actifs
• le compteur ordinal
• les valeurs des variables globales statiques ou
  dynamiques
• son entrée dans la TP
• sa zone u
• les piles utilisateurs et systèmes
• les zones de code et de données
• Le noyau et ses variables ne font partie du
  contexte daucun processus !
• Lexécution dun processus se fait dans son
  contexte
• Quand il y a changement de processus courant, il
  y a réalisation dune commutation de mot détat
  et dun changement de contexte

18
Contexte dunité centrale

• Fonctions de très bas niveau, fondamentales pour
  pouvoir programmer un SE
• Pour être exécuté et donner naissance à un
  processus, un programme et ses données doivent
  être chargées en mémoire centrale de lUC
• LUC comprend des circuits logiques qui
  effectuent les instructions mais aussi des
  mémoires appelés registres
• Laccumulateur (reçoit le résultat dune
  instruction)
• Le registre dinstruction (contient linstruction
  en cours)
• Le compteur ordinal (adresse de linstruction en
  mémoire)
• Le registre dadresse
• Les registres de données (utilisées pour
  lire/écrire une donnée à une adresse spécifiée)
• Les registres détat du processeur (actif, mode
  (user/sys), vecteur dinterruptions, )
• Les registres détat du processus (droits,
  adresses, priorités, )
• Ces registres forment le contexte dunité
  centrale dun processus

19
Commutation de mot détat

• Pour pouvoir exécuter un nouveau processus, il
  faut sauvegarder le contexte dunité centrale du
  processus courant (mot détat), puis charger le
  nouveau mot détat
• Cette opération est appelée commutation de mot
  détat
• Cette commutation doit se faire de manière non
  interruptible !
• Cette  super-instruction  utilise 2 adresses
• ladresse de sauvegarde du mot détat
• ladresse de lecteur du nouveau mot détat
• Le compteur ordinal faisant partie du mot détat,
  ce changement provoque lexécution dans le
  nouveau processus
• Les fonctions setjmp/longjmp permettent de
  sauvegarder et de réinitialiser le contexte
  dunité central du processus courant, en
  particulier le pointeur de pile

20
Les interruptions

• Une interruption est une commutation de mot
  détat provoquée par un signal produit par le
  matériel
• Ce signal est la conséquence dun évènement
  extérieur ou intérieur, il modifie létat dun
  indicateur qui est régulièrement testé par lUC
• Une fois le signal détecté, on utilise le vecteur
  dinterruptions pour identifier la cause et
  réaliser la tâche demandée
• 3 grands types dinterruptions
• Externes (indépendantes du processus) pannes,
  interventions de lutilisateur
• Déroutements erreur interne du processeur
  (débordement, div/0, ) ?sauvegarde sur disque
  de limage mémoire core dumped
• Appels systèmes accès disque, demande dE/S,
• Il existe plusieurs niveaux dinterruptions, ce
  qui permet au système de sélectionner
  linterruption à traiter en priorité

21
Les interruptions sous Unix

• 6 niveaux dinterruptions
• Lhorloge est la plus prioritaire dans un système
  Unix

Nature de linterruption Fonction de traitement
0 horloge clockintr
1 disques diskintr
2 console ttyintr
3 autres périphériques devintr
4 appel système sottintr
5 autre interruption otherintr
22
La cascade dinterruptions !

• Si durant le traitement dune interruption, une
  autre interruption se produit et que ceci se
  répète durant le traitement de la nouvelle
  interruption le système ne fait plus progresser
  le processus en cours, ni les interruptions !
• Nécessité de pouvoir retarder ou annuler une
  interruption ? 2 mécanismes le masquage et
  le désarmement dun niveau dinterruption
• Masquer ignorer temporairement un niveau
  dinterruption
• Désarmer rendre le positionnement de
  linterruption caduque (impossible pour les
  déroutements)

23
États dun processus (cas dun système de
gestion mémoire par swap)

• Listes des états dun processus
• Le processus sexécute en mode utilisateur
• Le processus sexécute en mode noyau
• Le processus est prêt
• Le processus est endormi en mémoire centrale
• Le processus est prêt en zone swap
• Le processus est endormi en zone swap
• Le processus passe du mode noyau au mode
  utilisateur mais est préempté (bien que le
  processus soit prêt, il est retiré du traitement
  pour les autres processus progressent)
• Naissance dun processus, ce processus nest pas
  encore prêt, il nest pas encore endormi, cest
  létat initial de tous processus sauf le swappeur
  
• Zombie le processus vient de réaliser un exit,
  il apparaît uniquement dans la TP où il est
  conservé le temps que son père récupère le code
  de retour et dautres informations de gestion (ex
  tps dexécution)
• Létat  zombie  est létat final des processus,
  il reste dans cet état jusquà ce que le père
  lise leur valeur de retour (status) à laide
  lappel système wait()

24
Diagramme détat des processus
25
La TP Unix

• La TP est localisée dans la mémoire du noyau
• TP Tableau de struct proc (ltsys/proc.hgt)
• Cette structure contient les informations qui
  doivent toujours être accessibles par le noyau
• État (cf diagramme)
• Adresse de la zone u
• Adresses taille et localisation en mémoire
• pid et ppid valeurs initialisées en état 8
• uid
• Événement descripteur de lévénement attendu
  lorsque le processus est endormi (bloqué)
• Priorités utilisés par lordonnanceur
• Vecteurs dinterruptions du processus ensemble
  des signaux reçus mais non traités
• Divers compteurs (ex tps CPU pour faire payer
  le temps de calcul), alarme
• Ces informations peuvent être obtenues à partir
  de la commande shell ps ou par consultation du
  pseudo système de fichiers /proc (et pour
  certaines dentre elles, par différents appels
  systèmes)

26
La zone u

• La zone u est utilisée lorsque un processus
  sexécute (mode noyau ou utilisateur)
• Une unique zone u est accessible à la fois
  celle du processus en cours dexécution (états 1
  et 2)
• La zone u est de type struct user définie dans
  ltsys/user.hgt, elle contient
• Pointeur sur la structure de processus de la TP
• uid réel et effectif détermine les privilèges
  donnés au processus
• Compteurs de temps (user et system)
• Terminal terminal de contrôle du processus
  (sil existe)
• Erreur dernière erreur rencontrée pendant un
  appel système
• Retour valeur de retour du dernier appel
  système
• E/S structures associées au E/S
• Répertoires courant et racine (cf. chroot())
• Table des descripteurs
• Limites (cf. ulimit en Bourne Shell et limit en
  csh)
• umask masque de création de fichiers
• Ces informations ne sont accessibles que par une
  réponse du processus lui-même et donc par
  lutilisation dappels systèmes !

27
Les informations temporelles

• include ltsys/time.hgt
• clock_t times (struct tms buffer)
• times remplit la structure pointée par buffer
  avec des informations sur le temps machine
  utilisé en état 1 et 2
• Struct tms
• clock_t tms_utime / user time /
• clock_t tms_stime / system time /
• clock_t tms_cutime / user time, children /
• clock_t tms_csutime / system time, children
  /
• Contient des temps indiqués en microsecondes, la
  précision dépend de lordinateur

28
Changement des répertoires

• include ltunistd.hgt
• int chroot(const char path)
• Permet de définir un nouveau point de départ pour
  les références absolues (commençant par /).
• La référence .. de ce répertoire racine étant
  associée à lui-même, il nest donc pas possible
  de sortir du sous-arbre défini par chroot
• Les appels suivants permettent de changer le
  répertoire de travail du processus
• int chdir(const char path)
• int fchdir(int fd)

29
Récupération du pid

• include ltunistd.hgt
• pid_t getpid(void)
• pid_t getppid(void)
• pid_t getpgrp(void)
• pid_t getpgrp2(pid_t pid)
• Lappel à getpid retourne le pid du processus
  courant
• getppid, le pid du processus père
• getpgrp, le pid du groupe du processus courant
• getpgrp2, le pid du groupe du processus pid (si
  pid0, alors identique à getpgrp)

30
Identification de lutilisateur

• Luid dun processus est lidentification de
  lutilisateur exécutant le processus
• Le système utilise 3 uid
• euid uid effective utilisé pour les tests
  daccès
• ruid uid réelle
• suid uid sauvegardée, pour pouvoir revenir en
  arrière
• include ltsys/types.hgtinclude ltunistd.hgtint
  setuid(uid_t uid)
• Fonctionnement
• si euid0 (root) alors les trois uid sont
  positionés à la valeur de uid,
• sinon si uidruid ou suid alors euid prend la
  valeur uid (ruid et suid ne changent pas),
• sinon RIEN ! (pas de changements)
• La commande setreuid permet de changer le ruid,
  elle est utilisée pendant le login, seul le super
  utilisateur peut lexécuter avec succès
• Pour les goupes int setgid(gid_t gid)

31
Tailles limites dun processus

• include ltunistd.hgt
• long ulimit(int cmd, )
• La commande cmd est
• UL_GETFIZE retourne la taille maximum des
  fichiers en blocs
• UL_SETFSIZE positionne cette valeur avec le
  deuxième argument
• UL_GETMAXBRK valeur maximale pour lappel
  dallocation dynamique de mémoire brk.
• Ces valeurs sont héritées du processus père
• Remarque cet appel système nest pas implémenté
  dans les noyaux 2.0 des systèmes Linux

32
Manipulation de la taille du segment de données

• include ltunistd.hgt
• int brk(void endds)
• void sbrk(ptrdiff_t incr)
• brk positionne la fin du segment de données à
  ladresse spécifiée
• endds doit être supérieur à la fin du segment de
  texte et 16ko avant la fin de la pile
• sbrk incrémente lespace de données du programme
  de incr octets
• sbrk nest pas un appel système, juste une
  fonction de la bibliothèque C
• Remarques
• brk et sbrk ne sont pas définis dans le C
  standard et sont volontairement exclus des
  standards POSIX
• Il ne faut pas les utiliser conjointement aux
  fonctions dallocation standard malloc, calloc,
  realloc, free

33
Manipulation de la valeur de nice

• La valeur de nice dun processus indique la
  priorité du processus pour lordonnancement
• Plus la valeur est petite, plus le processus est
  prioritaire
• La valeur de de nice est comprise entre 0 et 39
• Seul le super utilisateur peut spécifier une
  valeur de nice négative
• include ltunistd.hgt
• int nice(int valeur)
• La commande shell renice permet de changer le
   nice  dun processus actif

34
Manipulation de la valeur umask

• Lappel umask permet de spécifier quels droits
  doivent être interdits en cas de création de
  fichiers
• include ltunistd.hgt
• int umask(int mask)
• umask fixe le masque de création de fichiers à la
  valeur mask 0777
• Les bits contenus dans le masque sont éliminés de
  la valeur 0666 pour créer les nouvelles
  permissionsex mask0022 ? 0666 0022 0644
  rw-r--r--
• Cet appel système néchoue jamais et la valeur
  précédente du masque est renvoyée
• La commande umask existe également en shell

35
Lappel système fork

• Lappel système fork permet la création dun
  processus clône du processus courant.
• include ltunistd.hgt
• pid_t fork(void)
• DEUX valeurs de retour en cas de succès !
• Dans le processus père, la valeur de retour est
  égale au pid du fils
• Dans le processus fils, la valeur de retour est
  égale à zéro
• Si échec (seul le processus père existe), la
  valeur de retour est égale à 1
• Les pid et ppid sont les seules informations
  différentes entre les deux processus
• Les deux processus poursuivent leur exécution à
  linstruction qui suit le fork
• Utilisation courante

pid_t pid pidfork() if (pidgt0) / processus
père / else if (pid0) /processus
fils/ else / Traitement derreur /
36
Les appels systèmes exec (1)

• include ltunistd.hgt
• int execl(char path,char arg0,char arg1, ,
  NULL)
• int execv(char path,char arg)
• int execle(char path,char arg0,, NULL, char
  envp)
• int execve(char path,char arg,char envp)
• int execlp(char file,char arg0,char arg1, ,
  NULL)
• int execvp(char file,char arg)
• Toutes ces fonctions sont  identiques  et
  diffèrent simplement par le mode de passage des
  paramètres
• Les différents noms des fonctions exec sont
  mnémoniques
• l liste darguments
• v arguments sous forme de vecteur
• p recherche du fichier avec la variable
  denvironnement PATH
• e transmission dun environnement en dernier
  paramètre, en remplacement de lenvironnement
  courant

37
Les appels systèmes exec (2)
Primitives Format dargument Passage denvironnement Recherche avec PATH
execl execv execle execve execlp execvp Liste Tableau Liste Tableau Liste Tableau Automatique Automatique Manuel Manuel Automatique Automatique Non Non Non Non Oui Oui

• La famille des fonctions exec remplace limage
  mémoire du processus en cours par un nouveau
  processus.
• Informations conservées par le processus pid,
  ppid, pgid, ruid, suid, euid, nice, groupe
  daccès, répertoires courant et racine, terminal
  de contrôle, utilisation et limites des
  ressources, umask, masques des signaux, signaux
  en attente, table des descripteurs de fichiers,
  verrous, session
• Valeur de retour en cas de succès AUCUNE le
  code ayant fait lexec nexiste plus, en cas
  déchec 1

38
Lancement dune commande

• include ltstdlib.hgt
• int system(const char commande)
• Crée un nouveau processus  /bin/sh  qui exécute
  la commande (/bin/sh c commande)
• Le processus appelant cette fonction reste bloqué
  jusquà la fin de lexécution du processus
• Ce mécanisme est très coûteux et nest pas un
  appel système
• La valeur de retour est 127 si lappel système
  execve pour /bin/sh échoue, -1 si une autre
  erreur, ou le code de retour de la commande sinon

39
Terminaison dun processus

• _exit primitive de terminaison de processus bas
  niveau
• include ltunistd.hgt void _exit(int valeur)
• elle ferme les descripteurs ouverts par open,
  opendir ou hérités du processus père
• la valeur est fournie au processus père qui la
  récupère après lappel système wait
• cette valeur est le code de retour de processus
  en shell
• cette primitive est automatiquement appelée à la
  fin de la fonction main (sauf en cas dappels
  récursifs de main)
• Exit fonction de terminaison de processus de
  stdlib
• include ltstdlib.hgt void exit(int valeur)
• elle lance les fonctions définies par atexit
• ferme lensemble des descripteurs ouverts grâce à
  la bibliothèque standard (fopen)
• détruit les fichiers fabriqués par la primitive
  tmpfile
• appelle _exit avec valeur

40
La primitive atexit

• Cette primitive (non système) permet de spécifier
  des fonctions à appeler en fin dexécution, elles
  sont lancées par exit dans lordre inverse de
  leur positionnement par atexit
• include ltstdlib.hgt
• void atexit(void (fonction) (void))
• Exemple
• void bob(void)printf(coucou\n)
• void bib(void)printf(cuicui )
• main(int argc)
• atexit(bob)atexit(bib)
• if (argc 1) exit(0)
• else _exit(O)

41
Attente de la mort dun fils

• include ltsys/types.hgt include ltsys/wait.hgt
• pid_t wait (int status)
• pid_t waitpid(pid_t pid, int status, int
  options)
• La fonction wait suspend lexécution du processus
  courant jusquà ce quun fils se termine (ou
  jusquà réception dun signal)
• Si un processus fils est déjà mort (il est
  zombie) la fonction revient immédiatement
• Toutes les ressources utilisées par le fils sont
  libérées
• La fonction waitpid suspend lexécution du
  processus courant jusquà ce que le processus
  fils de numéro pid se termine (ou jusquà
  réception dun signal)
• La valeur de pid peut être
• lt -1 attente la fin de nimporte quel processus
  fils appartenant au groupe dID pid
• -1 attendre nimporte quel fils (identique au
  wait)
• 0 attendre la fin de nimporte quel processus
  fils du même groupe appelant
• gt 0 attendre la fin du processus de numéro pid
• ? ? options, la plus utile WNOHANG qui permet
  de ne pas bloquer si aucun fils nest mort
• Si status ? NULL, les informations sur la
  terminaison du fils y sont stockées
• WIFEXITED(status) est non nul si le fils sest
  terminé normalement
• WEXITSTATUS(status) donne le code retour du
  fils tel quil la mentionné lors de lappel
  _exit(retour)valide uniquement si
  WIFEXITED(status)?0

42
Gestion des erreurs

• Dès lors que lon effectue des appels systèmes,
  il est important de contrôler TOUTES les valeurs
  de retour
• Nous sommes aidés dans cette tâche par la
  bibliothèque C lterrno.hgt
• include lterrno.hgt
• perror(const char s)
• La fonction perror affiche un message sur la
  sortie standard des erreurs, décrivant la
  dernière erreur rencontrée durant un appel
  système
• La chaîne s est imprimée en premier suivie dun
  et du message derreur approprié
• Le numéro de lerreur est obtenu à partir de la
  variable externe errno qui contient le code
  derreur lorsquun problème survient, mais qui
  nest PAS effacé lorsquun appel réussi