La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Systèmes dexploitation Les processus Introduction Concept de processus est le important dans un SE Processus = abstraction dun programme en cours dexécution.

Présentations similaires


Présentation au sujet: "Systèmes dexploitation Les processus Introduction Concept de processus est le important dans un SE Processus = abstraction dun programme en cours dexécution."— Transcription de la présentation:

1

2 Systèmes dexploitation Les processus

3 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

4 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 Un seul compteur ordinal A B C D Multiprogrammation de 4 processus Commutation de processus A B C D 4 compteurs ordinaux Modèle conceptuel de 4 processus séquentiels indépendants Temps processus D C B A Un seul programme actif à un instant donné

5 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

6 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

7 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)

8 Les transitions entre les états Élu PrêtBloqué 4 transitions peuvent avoir lieu entre les états La transition 1 se produit lorsquun processus ne peut plus poursuivre son exécution 1 1. Le processus se bloque en attente de données La transition 2 a lieu lorsque lordonnanceur décide que le processus en cours sest exécuté pendant une durée suffisante ; cette opération est appelée réquisition 2 2. Lordonnanceur choisit un autre processus La transition 3 se produit lorsque tous les processus ont obtenu leur quota de temps et quil faut relancer le premier processus 3. Lordonnanceur choisit le processus initial 3 4 La transition 4 est réalisée si lévènement extérieur attendu par un processus se produit 4. Les données deviennent disponibles 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

9 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 Le nouveau modèle obtenu : 01 n-1n Ordonnanceur (scheduler) … Processus 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

10 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

11 La table des processus Unix Quelques champs typiques de la table des processus Gestion des processusGestion de la mémoireGestion 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

12 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 Une struct user appelée zone u définie dans 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 la TP est interne au noyau : P1 P5 P5 P1 TP noyau les processus

13 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 pid=0) 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 pid=0 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 pid=1 Le processus de pid=1 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)

14 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 …

15 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 : X alloc()

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

17 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

18 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

19 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

20 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

21 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é

22 Les interruptions sous Unix 6 niveaux dinterruptions : Lhorloge est la plus prioritaire dans un système Unix Nature de linterruptionFonction de traitement 0horlogeclockintr 1disquesdiskintr 2consolettyintr 3autres périphériquesdevintr 4appel systèmesottintr 5autre interruptionotherintr

23 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)

24 États dun processus (cas dun système de gestion mémoire par swap ) Listes des états dun processus : 1.:Le processus sexécute en mode utilisateur 2.Le processus sexécute en mode noyau 3.Le processus est prêt 4.Le processus est endormi en mémoire centrale 5.Le processus est prêt en zone swap 6.Le processus est endormi en zone swap 7.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) 8.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 9. 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()

25 Diagramme détat des processus Bloqué en zone swap Prêt en zone swap fork Création Prêt en mémoire Préempté Exécution en mode utilisateur Exécution en mode noyau Zombie Bloqué (endormi) en mémoire Mémoire centrale Swap Examiner et traiter les signaux Examiner les signaux Appel système interruption Gestion interruption exit Retour au mode utilisateur préemption sleep swapin swapout Mémoire insuffisante Mémoire suffisante Ordonnancement du processus wakeup

26 La TP Unix La TP est localisée dans la mémoire du noyau TP = Tableau de struct proc ( ) 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)

27 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, 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 !

28 Les informations temporelles #include 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

29 Changement des répertoires #include 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);

30 Récupération du pid #include 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 pid =0, alors identique à getpgrp )

31 Identification de lutilisateur Luid dun processus est lidentification de lutilisateur exécutant le processus Le système utilise 3 uid : 1.euid : uid effective utilisé pour les tests daccès 2.ruid : uid réelle 3.suid : uid sauvegardée, pour pouvoir revenir en arrière #include #include int setuid(uid_t uid) Fonctionnement : –si euid=0 (root) alors les trois uid sont positionés à la valeur de uid, –sinon si uid=ruid 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)

32 Tailles limites dun processus #include 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

33 Manipulation de la taille du segment de données #include 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

34 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 int nice(int valeur); La commande shell renice permet de changer le « nice » dun processus actif

35 Manipulation de la valeur umask Lappel umask permet de spécifier quels droits doivent être interdits en cas de création de fichiers #include 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 permissions ex : mask = & ~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

36 Lappel système fork Lappel système fork permet la création dun processus clône du processus courant. #include 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; pid=fork(); if (pid>0) {/* processus père */ } else if (pid==0) {/*processus fils*/} else {/* Traitement derreur */}

37 Les appels systèmes exec (1) #include 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

38 Les appels systèmes exec (2) 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 l exec nexiste plus, en cas déchec –1 PrimitivesFormat dargument Passage denvironnement Recherche avec PATH execl execv execle execve execlp execvp Liste Tableau Liste Tableau Liste Tableau Automatique Manuel Automatique Non Oui

39 Lancement dune commande #include 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

40 Terminaison dun processus _exit : primitive de terminaison de processus bas niveau #include 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 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

41 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 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); } $ gcc –o atexit atexit.c $ atexit $ atexit unargument cuicui coucou $ Console shell

42 Attente de la mort dun fils #include #include 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 : –< -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 –> 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 ]

43 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 #include 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


Télécharger ppt "Systèmes dexploitation Les processus Introduction Concept de processus est le important dans un SE Processus = abstraction dun programme en cours dexécution."

Présentations similaires


Annonces Google