Cours Système Linux

Cours Syst`me e
D.Revuz 17 fvrier 2005 e
ii
Table des mati`res e

1 Introduction 1.1 Unix . . . . . . . . . . . . . . . . . . . . . . . 1.1.1 Pourquoi unix ? . . . . . . . . . . . . 1.1.2 le succ`s dUnix et de linux . . . . . . e 1.1.3 Des points forts . . . . . . . . . . . . 1.1.4 Des points faibles . . . . . . . . . . . . 1.2 Structure gnrale des syst`mes dexploitation e e e 1.2.1 Les couches fonctionnelles . . . . . . . 1.2.2 Larchitecture du syst`me . . . . . . . e 1.2.3 Larchitecture du noyau . . . . . . . . 1.3 historique . . . . . . . . . . . . . . . . . . . . 2 Syst`me de Gestion de Fichiers e 2.1 Le concept de chier . . . . . . . . . . . 2.2 Fichiers ordinaires / Fichiers spciaux. e 2.3 Organisation utilisateur des Disques . . 2.4 Les inodes . . . . . . . . . . . . . . . . . 2.5 Organisation des disques System V . . . 2.6 Adressage des blocs dans les inodes . . . 2.7 Allocation des inodes dun disque . . . . 2.8 Allocation des blocs-disque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 1 1 1 2 2 3 3 5 5 7 7 8 8 9 10 11 11 11 17 17 17 17 18 18 23 23 24 24 25 25 26 26 26 26 27 27 27
3 Le Buer Cache 3.1 Introduction au buer cache . . . . . . . . . . . . . 3.1.1 Avantages et dsavantages du buer cache . e 3.2 Le buer cache, structures de donnes. . . . . . . . e 3.2.1 La liste doublement cha ee des blocs libres n 3.3 Lalgorithme de la primitive getblk . . . . . . . .
4 La biblioth`que standard e 4.1 Les descripteurs de chiers. . . . . . . . . . . . . . . . . . . . . . . 4.1.1 Ouverture dun chier . . . . . . . . . . . . . . . . . . . . . 4.1.2 Redirection dun descripteur : freopen . . . . . . . . . . . 4.1.3 Cration de chiers temporaires . . . . . . . . . . . . . . . . e 4.1.4 Ecriture non formate . . . . . . . . . . . . . . . . . . . . . e 4.1.5 Acc`s squentiel . . . . . . . . . . . . . . . . . . . . . . . . e e 4.1.6 Manipulation du pointeur de chier . . . . . . . . . . . . . 4.1.7 Un exemple dacc`s direct sur un chier dentiers. . . . . . e 4.1.8 Les autres fonctions de dplacement du pointeur de chier. e 4.2 Les tampons de chiers de stdlib. . . . . . . . . . . . . . . . . . . . 4.2.1 Les modes de buerisation par dfaut. . . . . . . . . . . . . e 4.2.2 Manipulation des tampons de la biblioth`que standard. . . e iii
iv 4.3 4.4 4.5 4.6 4.7 Manipulation des liens dun chier . . Lancement dune commande shell . . . Terminaison dun processus . . . . . . Gestion des erreurs . . . . . . . . . . . Cration et destruction de rpertoires e e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
` TABLE DES MATIERES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 29 30 31 31 33 33 35 36 36 36 37 37 38 38 41 41 41 42 42 43 43 45 45 46 47 47 47 48 49 49 50 50 50 51 51 51 52 52 52 52 53 53 55 55 56 56 57 57 57 58
5 Appels syst`me du Syst`me de Gestion de Fichier e e 5.1 open . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.1 Droulement interne dun appel de open . . . e 5.2 creat . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 read . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4 write . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5 lseek . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6 dup et dup2 . . . . . . . . . . . . . . . . . . . . . . . 5.7 close . . . . . . . . . . . . . . . . . . . . . . . . . . 5.8 fcntl . . . . . . . . . . . . . . . . . . . . . . . . . .
6 Les processus 6.1 Introduction aux processus . . . . . . . . . . . . . . . . . . 6.1.1 Cration dun processus - fork() . . . . . . . . . . e 6.2 Format dun chier excutable . . . . . . . . . . . . . . . . e 6.3 Chargement/changement dun excutable . . . . . . . . . . e 6.4 zone u et table des processus . . . . . . . . . . . . . . . . . 6.5 fork et exec (revisits) . . . . . . . . . . . . . . . . . . . . e 6.6 Le contexte dun processus . . . . . . . . . . . . . . . . . . 6.7 Commutation de mot dtat et interruptions. . . . . . . . . e 6.8 Les interruptions . . . . . . . . . . . . . . . . . . . . . . . . 6.9 Le probl`me des cascades dinterruptions . . . . . . . . . . . e 6.9.1 Etats et transitions dun processus . . . . . . . . . . 6.9.2 Listes des tats dun processus . . . . . . . . . . . . e 6.10 Lecture du diagramme dtat. . . . . . . . . . . . . . . . . . e 6.11 Un exemple dexcution . . . . . . . . . . . . . . . . . . . . e 6.12 La table des processus . . . . . . . . . . . . . . . . . . . . . 6.13 La zone u . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.14 Acc`s aux structures proc et user du processus courant . . e 6.14.1 Les informations temporelles. . . . . . . . . . . . . . 6.14.2 Changement du rpertoire racine pour un processus. e 6.14.3 Rcupration du PID dun processus . . . . . . . . . e e 6.14.4 Positionement de leuid, ruid et suid . . . . . . . . . 6.15 Tailles limites dun processus . . . . . . . . . . . . . . . . . 6.15.1 Manipulation de la taille dun processus. . . . . . . . 6.15.2 Manipulation de la valeur nice . . . . . . . . . . . . 6.15.3 Manipulation de la valeur umask . . . . . . . . . . . 6.16 Lappel syst`me fork . . . . . . . . . . . . . . . . . . . . . e 6.17 Lappel syst`me exec . . . . . . . . . . . . . . . . . . . . . e 7 Lordonnancement des processus 7.1 Le partage de lunit centrale . . . e 7.1.1 Famine . . . . . . . . . . . 7.1.2 Stratgie globale . . . . . . e 7.1.3 Crit`res de performance . . e 7.2 Ordonnancement sans premption. e 7.3 Les algorithmes premptifs . . . . e 7.3.1 Round Robin (tourniquet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
` TABLE DES MATIERES 7.3.2 Les algorithmes ` queues multiples a Multi-level-feedback round robin Queues . 7.4.1 Les niveaux de priorit . . . . . . . e 7.4.2 Evolution de la priorit . . . . . . e 7.4.3 Les classes de priorit . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
v 58 58 58 59 60 61 61 61 63 63 63 63 63 65 65 65 66 66 66 66 66 67 68 68 68 69 69 71 71 72 72 73 75 75 75 76 76 76 77 77 78 78 80 81 83 83 83 85 86 86 86
7.4
8 La mmoire e 8.0.4 les mmoires . . . . . . . . . . . . . . . . . . . . . . . . . e 8.0.5 La mmoire centrale . . . . . . . . . . . . . . . . . . . . . e 8.1 Allocation contigu . . . . . . . . . . . . . . . . . . . . . . . . . . e 8.1.1 Pas de gestion de la mmoire . . . . . . . . . . . . . . . . e 8.1.2 Le moniteur rsidant . . . . . . . . . . . . . . . . . . . . . e 8.1.3 Le registre barri`re . . . . . . . . . . . . . . . . . . . . . . e 8.1.4 Le registre base . . . . . . . . . . . . . . . . . . . . . . . . 8.1.5 Le swap . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.6 Le cot du swap . . . . . . . . . . . . . . . . . . . . . . . u 8.1.7 Utilisation de la taille des processus . . . . . . . . . . . . 8.1.8 Swap et excutions concurrentes . . . . . . . . . . . . . . e 8.1.9 Contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.10 Deux solutions existent . . . . . . . . . . . . . . . . . . . 8.1.11 Les probl`mes de protection . . . . . . . . . . . . . . . . . e 8.1.12 Les registres doubles . . . . . . . . . . . . . . . . . . . . . 8.2 Ordonnancement en mmoire des processus . . . . . . . . . . . . e 8.3 Allocation non-contigu . . . . . . . . . . . . . . . . . . . . . . . e 8.3.1 Les pages et la pagination . . . . . . . . . . . . . . . . . . 8.3.2 Ordonnancement des processus dans une mmoire pagine e e 8.3.3 Comment protger la mmoire pagine . . . . . . . . . . . e e e 8.3.4 La mmoire segmente . . . . . . . . . . . . . . . . . . . . e e 9 La mmoire virtuelle e 9.0.5 Les overlays . . . . . . . . . . . . . . . . . . . . . . . . 9.0.6 Le chargement dynamique . . . . . . . . . . . . . . . . 9.1 Demand Paging . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.1 Ecacit . . . . . . . . . . . . . . . . . . . . . . . . . e 9.2 Les algorithmes de remplacement de page . . . . . . . . . . . 9.2.1 Le remplacement optimal . . . . . . . . . . . . . . . . 9.2.2 Le remplacement peps (FIFO) . . . . . . . . . . . . . 9.2.3 Moins rcemment utilise LRU. . . . . . . . . . . . . . e e 9.2.4 Lalgorithme de la deuxi`me chance . . . . . . . . . . e 9.2.5 Plus frquemment utilis MFU . . . . . . . . . . . . . e e 9.2.6 Le bit de salet (Dirty Bit) . . . . . . . . . . . . . . . e 9.3 Allocation de pages aux processus . . . . . . . . . . . . . . . 9.4 Lappel fork et la mmoire virtuelle . . . . . . . . . . . . . . . e 9.5 Projection de chiers en mmoire . . . . . . . . . . . . . . . . e 9.6 Les conseils et politiques de chargement des zones mmappes e 9.7 Chargement dynamique . . . . . . . . . . . . . . . . . . . . . 10 Tubes et Tubes Nomms e 10.1 Les tubes ordinaires (pipe) . 10.2 Cration de tubes ordinaires e 10.3 Lecture dans un tube . . . . 10.4 Ecriture dans un tube . . . 10.5 Interblocage avec des tubes 10.6 Les tubes nomms . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . .
vi
` TABLE DES MATIERES 10.6.1 Ouverture et synchronisation des ouvertures de tubes nomms . . . . . . . e 10.6.2 Suppression dun tube nomm . . . . . . . . . . . . . . . . . . . . . . . . . e 10.6.3 les appels popen et pclose . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 87 87 89 89 89 90 91 91 91 93 94 95 95 96 96 97 97
11 Les signaux 11.0.4 Provenance des signaux . . . . . . . . 11.0.5 Gestion interne des signaux . . . . . . 11.0.6 Lenvoi de signaux : la primitive kill . 11.1 La gestion simplie avec la fonction signal e 11.1.1 Un exemple . . . . . . . . . . . . . . . 11.2 Probl`mes de la gestion de signaux ATT . . . e 11.2.1 Le signal SIGCHLD . . . . . . . . . . 11.3 Manipulation de la pile dexcution . . . . . . e 11.4 Quelques exemples dutilisation . . . . . . . . 11.4.1 Lappel pause . . . . . . . . . . . . . . 11.5 La norme POSIX . . . . . . . . . . . . . . . . 11.5.1 Le blocage des signaux . . . . . . . . . 11.5.2 sigaction . . . . . . . . . . . . . . . . . 11.5.3 Lattente dun signal . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . .
12 Les verrous de chiers 12.1 Caractristiques dun verrou . . . . . . . . . . . e 12.2 Le mode opratoire des verrous . . . . . . . . . e 12.3 Manipulation des verrous . . . . . . . . . . . . 12.4 Utilisation de fcntl pour manipuler les verrous
99 . 99 . 99 . 100 . 101 . . . . . . . . . . . . . . . . . . . . . . . 103 103 103 104 105 105 105 105 107 107 108 109 109 110 110 110 110 112 115 115 116 119 119 119 119 119
13 Algorithmes Distribus & Interblocages e 13.1 exemples . . . . . . . . . . . . . . . . . . . . . . . . 13.1.1 Les mfaits des acc`s concurrents . . . . . . e e 13.1.2 Exclusion mutuelle . . . . . . . . . . . . . . 13.2 Mode dutilisation des ressources par un processus. 13.3 Dnition de linterblocage (deadlock) . . . . . . . e 13.4 Quatre conditions ncessaires ` linterblocage. . . . e a 13.5 Les graphes dallocation de ressources . . . . . . .
14 Scurit et S ret de fonctionnement e e u e 14.1 Protection des syst`mes dexploitation . . . . . . . . . . . . . . . . . . e 14.2 Gnralits sur le contrle dacc`s . . . . . . . . . . . . . . . . . . . . . e e e o e 14.2.1 Domaines de protection et matrices dacc`s . . . . . . . . . . . e 14.2.2 Domaines de protection restreints . . . . . . . . . . . . . . . . . 14.2.3 Avantages des domaines de protections restreints . . . . . . . . 14.3 Le cheval de Troie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4 Le connement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5 les mcanismes de contrle . . . . . . . . . . . . . . . . . . . . . . . . . e o 14.5.1 Application des capacits au domaines de protection restreints e 14.6 Les ACL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6.1 Appels systemes setacl et getacl . . . . . . . . . . . . . . . . 14.6.2 Autres pistes sur la scurit . . . . . . . . . . . . . . . . . . . . e e 15 Multiplexer des entres-sorties e 15.1 Gerer plusieurs cannaux dentre sortie . . . e 15.1.1 Solution avec le mode non bloquant 15.1.2 Utiliser les mcanismes asynchrones e 15.2 Les outils de slection . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
` TABLE DES MATIERES 15.2.1 La primitive select . 15.2.2 La primitive poll . . 15.2.3 Le priphrique poll . e e 15.2.4 Les extensions de read 15.3 une solution multi-activits . e . . . . . . . . . . . . . . . . . . et write . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
vii 119 121 122 123 123 125 125 125 127 127 127 128 128 128 129 129 129 130 130 132 132 133 134 134 134 134
16 Les threads POSIX 16.0.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.0.2 fork et exec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.0.3 clone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.0.4 Les noms de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.0.5 les noms de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.0.6 Attributs dune activit . . . . . . . . . . . . . . . . . . . . . . . . . . . e 16.0.7 Cration et terminaison des activits . . . . . . . . . . . . . . . . . . . . e e 16.1 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1 Le mod`le fork/join (Paterson) . . . . . . . . . . . . . . . . . . . . . . . e 16.1.2 Le probl`me de lexclusion mutuelle sur les variables gres par le noyau e ee 16.1.3 Les smaphores dexclusion mutuelle . . . . . . . . . . . . . . . . . . . . e 16.1.4 Utilisation des smaphores . . . . . . . . . . . . . . . . . . . . . . . . . . e 16.1.5 Les conditions (v`nements) . . . . . . . . . . . . . . . . . . . . . . . . . e e 16.2 Ordonnancement des activits . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 16.2.1 Lordonnancement POSIX des activits . . . . . . . . . . . . . . . . . . e 16.3 Les variables spciques ` une thread . . . . . . . . . . . . . . . . . . . . . . . e a 16.3.1 Principe gnral des donnes spciques, POSIX . . . . . . . . . . . . . e e e e 16.3.2 Cration de cls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e e 16.3.3 Lecture/criture dune variable spcique . . . . . . . . . . . . . . . . . e e 16.4 Les fonctions standardes utilisant des zones statiques . . . . . . . . . . . . . . .
17 Clustering 135 17.1 Le clustering sous linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 18 Bibliographie 137 18.1 Webographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
viii
` TABLE DES MATIERES
Cours de conception de syst`mes et dutilisation dUNIX e Ce poly est ` lusage des tudiants de la li`re Informatique et Rseaux de lcole dingnieurs a e e e e e Ingnieurs 2000 UMLV et de la trois`me anne de lience dinformatique de Marne la Valle comme e e e e ` support du cours SYSTEMES dEXPLOITATION. Cette version du , apporte de nombreuse corrections de typo et autre, je remercie David Lecorfec pour sa lecture attentive, et les remarques sur le fond seront prises en compte dans la prochaine version. Ce poly a une version HTML disponible sur le Web a ladresse suivante : http://www-igm.univ-mlv.fr/~dr/NCS/ Ce document a de nombreux dfauts en particulier son manque dhomognit, et une absence e e e e dexplications dans certaines parties (explication donnes en gnral oralement en cours). e e e Au menu lessentiel dUNIX : SGF, processus, signaux, mmoire, mmoire virtuelle, manipulae e tion des terminaux, tubes, IPC. Quelques dtours : micro-noyaux, scurit. Un chapitre important e e e mais un peut court : les probl`mes de programmation distribu et des interblocages (amliorations e e e en cours n 2004). Prrequis : pour la partie conceptuelle des notions de programmation et dalgorithmique sont e ncessaire pour proter pleinement du cours, pour la partie technique une comptance raisonable e e en C est ncessaire, en particulier les notions de pointeurs dallocation dynamique doivent tre maie e trises, les 4 mthodes dallocation principale du C doivent tre maitrises ! (text,static,auto,heap). e e e e Evolutions futures : dr@univ-mlv.fr (jattend vos remarques), uniformisation de la prsentation, e nettoyage des points obscurs, corrections orthographiques, complement sur fcntl, ioctl, plus dexemples, des sujets de projets , des sujets dexamen.
Chapitre 1
Introduction
Ceci est un polycopi de cours de licence informatique sur les syst`mes dexploitations en e e gnral et plus spcialement sur la famille Unix. e e e Ce poly est le support utilis pour les licences et pour les Apprentis ingnieurs de la li`re Infore e e matique et Rseau. e
1.1
1.1.1
Unix
Pourquoi unix ?
Pourquoi ce choix dunix comme sujet dtude pour le cours ? e LE PRIX la disponibilit des sources e Lintlligence des solutions mise en oeuvre e de grande ressource bibliographique il faut mieux apprendre les conceptes fondamentaux dans un syst`me simple et ouvert puis e passer a des syst`mes propritaires et ferms que linverse. e e e parceque je ne vais pas changer mon cours tout de suite
1.1.2
le succ`s dUnix et de linux e
Le succ`s dUNIX sans doute parce que : e Ecrit dans un langage de haut niveau : C (C++, Objective C) ; une interface simple et puissante : les shells, qui fournissent des services de haut niveau ; Des primitives puissantes qui permettent de simplier lcriture des programmes ; e Un syst`me de chier hirarchique qui permet une maintenance simple et une implmentation e e e ecace ; Un format gnrique pour les chiers, le ot doctets qui simplie lcriture des programmes ; e e e Il fournit une interface simple aux priphriques ; e e Il est multi-utilisateurs et multi-tches ; a Il cache compl`tement larchitecture de la machine ` lutilisateur. e a
1.1.3
Des points forts
Syst`me n dans le monde de la recherche e e intgration de concepts avancs e e Diusion ouverte acc`s aux sources e 1
CHAPITRE 1. INTRODUCTION Langage (de haut niveau ) compilation spare, conditionnelle, paramtrage, prcompilation e e e e Enrichissement constant Ouverture (paramtrabilit du poste de travail) e e Souplesse des entres/sorties e uniformit e Facilits de communication inter-syst`mes e e Communauts dutilisateurs (/etc/groups) e Langages de commandes (exibles et puissants) Aspect multi-utilisateurs connections de tout type de terminal, biblioth`ques, etc e Paralllisme e multi-tches : scheduling par tche a a communication entre tches a multiprocesseurs Interface syst`me/applications e appels syst`me, biblioth`que e e le syst`me de gestion de chiers e hirarchie e Interfaces graphiques normes : X11. e Profusion dinterfaces graphiques sous linux Gnome et KDE en particulier
1.1.4
Des points faibles
Fragilit du S.G.F. e pertes de chiers possible en cas de crash rgl avec les SGF journaliss e e e Gestion et rattrapage des interruptions inadapt au temps rel e e Des volutions avec RLlinux et OS9. e Mcanisme de cration de processus lourd e e de nombreuses amliorations en particulier les threads. e Une dition de liens statique e Amlioration avec les librairies partages. e e des Modules noyau chargeables/dchargeables dynamiquement e Rattrapage derreur du compilateur C standard peu ais ! e Ces bugs sont corriges e Cot en ressources u reste globalement ecasse Gestion
1.2
Structure gnrale des syst`mes dexploitation e e e
Un syst`me dexploitation est un programme qui sert dinterface entre un utilisateur et un ordie nateur.
Un syst`me dexploitation est un ensemble de procdures manuelles et automatiques qui permet e e
` 1.2. STRUCTURE GENERALE DES SYSTEMES DEXPLOITATION ` un groupe dutilisateurs de partager ecacement un ordinateur. Brinch Hansen. a
Il est plus facile de dnir un syst`me dexploitation par ce quil fait que par ce quil est. J.L. e e Peterson.
Un syst`me dexploitation est un ensemble de procdures cohrentes qui a pour but de grer la e e e e pnurie de ressources. J-l. Stehl P. Hochard. e e
Quelques syst`mes : e le batch Le traitement par lot (disparus). interactifs Pour les utilisateurs (ce cher UNIX). temps rels Pour manipuler des situations physiques par des priphriques (OS9 un petit fr`re e e e e fut dUNIX). Lide est de grer le temps vrai.En particulier de grer des v`nement e e e e e e alatoires qui neccessite lexcution dune action en proirit absolue. e e e distribus UNIX ?, les micros noyaux ? lavenir ? e moniteurs transactionnels Ce sont des applications qui manipulent des objets ` tches mula a tiples comme les comptes dans une banque, des rservations, etc. Lide est de dcomposer e e e lactivit en actions, chacune indpendantes des autres,pour ce faire elle sont crites pour e e e avoir un comportement dit atomique ainsi il ny a pas de programme mais des v`nement e e et des actions associes. Il ny pas dans de changement de context pour traiter une action, e cest le syst`me adapt pour trait de gros volumes de petites oprations. e e e e SE orients objets Micro Noyaux. e
1.2.1
Les couches fonctionnelles
Couches fonctionnelles : Programmes utilisateurs Programmes dapplication diteurs/tableurs/BD/CAO e Programmes syst`me assembleurs/compilateurs/diteurs de liens/chargeurs e e syst`me dexploitation e langage machine microprogramme machines physiques
1.2.2
Larchitecture du syst`me e
Larchitecture globale dUNIX est une architecture par couches (coquilles) successsives comme le montre la gure 1.2. Les utilisateurs ordinaire communiquent avec la couche la plus volue celle e e des applications (en gnrale aujourdhui associ avec une interface graphique). Le programmeur e e e lui va en fonction de ses besoins utiliser des couches de plus en plus profondes, plus prcises mais e plus diciles a utiliser. Chaque couche est construite pour pouvoir tre utilise sans connaitre les couches infrieures (ni e e e leur fonctionnement, ni leur interface). Cette hirarchie dencapsulation permet dcrire des applications plus portables. En eet si elles e e sont crites dans les couches hautes, le travaille de portage est fait par le portage des couches e infrieures. Pour des applications o` le temps de calcul prime devant la portabilit, les couches e u e basses seront utilises. e
CHAPITRE 1. INTRODUCTION
Utilisateurs user 1 user 2 user 3 user N
compilateur
editeur
jeux
Base de ...
Applications Systme dexploitation
Matriel
Fig. 1.1 Vue gnrale du syst`me e e e
utilisateur utilisateur
SHELL make ls awk Hardware cc Kernel vi Applications
utilisateur
Fig. 1.2 Point de vue utilisateur
1.3. HISTORIQUE
Applications/utilisateurs bibliotheques

Niveau Utilisateur Niveau Noyau Interface appels - systeme Sous-Systeme de Gestion de fichiers Sous-Systeme Gestion des processus communication interprocessus "scheduler" gestion memoire caractere | bloc Controleurs
cache
Niveau Noyau Niveau Materiel Materiel
Fig. 1.3 Architecture du noyau
1.2.3
Larchitecture du noyau
Lautre approche architecturale est larchitecture interne du Noyau (kernel). Cest une architecture logicielle elle permet aux dveloppeur de structurer le travail de dveloppement. Le but ici est e e de simplier la comprhension et la fabrication du syst`me. Nous cherchons donc ici ` dcomposer e e a e le noyau en parties disjointes (qui sont concevables et programmables de faons disjointes). La c Figure 1.3 donne une ide de ce que peut tre larchitecture interne dun noyau UNIX. Noter bien e e la position extrieure des biblioth`ques . e e
1.3
historique
Il existe un site tr`s agrable sur lhistoire des ordinateurs : e e http://www.computerhistory.org/ .
Controle Materiel
CHAPITRE 1. INTRODUCTION
Chapitre 2
Syst`me de Gestion de Fichiers e

Le syst`me de gestion de chiers est un outil de manipulation des chiers et de la structure e darborescence des chiers sur disque et a aussi le rle sous UNIX de conserver toutes les informao tions dont la prennit est importante pour le syst`me (et pour les utilisateurs biensur). Ainsi tous e e e les objets importants du syst`me sont rfrencs dans le syst`me de chiers (mmoire, terminaux, e ee e e e priphriques varis, etc). e e e Le syst`me de gestion de chier permet une manipulation simple des chiers et g`re de faon e e c transparente les dirents probl`mes dacc`s aux supports de masse : e e e partage : utilisation dun mme chier/disque par plusieurs utilisateurs e ecacit : utilisation de cache, uniformisation des acc`s e e droits : protection des lments important du syst`me et protection interutilisateurs ee e alignement : transtypage entre la mmoire et les supports magntiques e e
2.1
Le concept de chier
Lunit logique de base de linterface du Syst`me de Gestion de Fichiers : le fichier. e e Un chier Unix est une suite nie de bytes (octets) Matrialise par des blocs e e disques, et une inode qui contient les proprits du chier (mais pas son nom). e e Le contenu est enti`rement dni par le crateur, la gestion de lallocation des ressources ncessaires e e e e est a la seule responsabilit du syst`me. e e Sur Unix les chiers ne sont pas typs du point de vue utilisateur, le concept de chier permet e de proposer un type gnrique (polymorphe) aux programmeurs le syst`me grant la multiplicit e e e e e des formats eectifs (direnttes marques et conceptions de disques dur par exemple). e Linode dnit le chier, soit principalement les informations : e la localisation sur disque, le propritaire et le groupe propritaire, e e les droits dacc`s des dirents utilisateurs, e e la taille, la date de cration. e On trouvera sur dautre syst`mes dautres structures dinformation pour dcrire les chiers, par e e exemple NT utilise des objets les records. Un nom est li ` un chier (une rfrence indique un chier) mais un chier nest pas li ` e a ee e a une rfrence, un chier peut exister sans avoir de nom dans larborescence. ee 7
` CHAPITRE 2. SYSTEME DE GESTION DE FICHIERS
2.2
Fichiers ordinaires / Fichiers spciaux. e
Le syst`me est un utilisateur du syst`me de gestion de chier et en temps que crateur il dnit e e e e quelques contenus structurs ces chiers auront de ce fait des acc`s r`glements. e e e e Pour le syst`me les chiers sont donc organiss en deux grandes familles : e e les chiers standards que sont par exemple les chiers texte, les excutables, etc. Cest-`-dire e a tout ce qui est manipul et structur par les utilisateurs. e e Les chiers spciaux priphriques, mmoire, et autre chiers physiques ou logique. Ces e e e e chiers ont une structure interne dnie (par les dveloppeurs du syst`me) qui doit tre rese e e e pect cest pourquoi leur manipulation nest possible que par par lintermdiaire du syst`me e e e (encore un bon exemple dencapsulation). Les catalogues sont des chiers spciaux, il faut pour les manipuler physiquement faire appel e au syst`me ce qui en prot`ge la structure1 . e e Les chiers physiques dans le rpertoire /dev (dev comme devices dispositifs matriels, les priphriques e e e e et quelques dispositifs logiques ) Character devices (priphriques ou la communication ce fait octets par octets) e e les terminaux (claviers, crans) e les imprimantes la mmoire e etc Block devices (priphriques ou la communication ce fait par groupe doctet appels blocs) e e e les disques les bandes magntiques e etc Les chiers ` usages logiques et non physiques a liens symboliques pseudo-terminaux sockets tubes nomms e Ce dernier type de chiers spciaux est utilis pour servir dinterface entre disques, entre e e machines et simuler : des terminaux, des lignes de communication, etc. Cette distinction entre chier ordinaire et spciaux et tout simplement le fait que le syst`me est e e un utilisateur comme les autres des chiers. Pour certains chier le syst`me utilise une structure e interne spciale (dou le nom) qui ne doit pas tre modier sous peine de comportement indni. e e e Pour se protger le syst`me ne permet pas lacc`s direct aux informations cest lui qui fait toutes e e e les entres sortie sur les chiers spciaux de faon a en assurer lintgrit. Ceci est indpendant e e c e e e du syst`me de droits dacc`s, la structure du code du noyau ne permet pas dautres acc`s que les e e e acc`s spciaux 2 . e e
2.3
Organisation utilisateur des Disques
Comment permettre aux utilisateurs didentier les donnes sur les supports de masse ? e Le syst`me le plus rpendu aujourdhui est un syst`me arborescent avec des chiers utiliss comme e e e e
1 les rpertoires sont rest accessible longtemps en lecture comme des chiers ordinaires mais lacc`s en e e e criture tait contraint, pour assurer la structure arborescente acyclique. Aujourdhui tout les acc`s au rpertoires e e e e ont contraint et on a un ensemble dappels syst`me spciques pour raliser des entrs sortie dans les repere e e e toires. opendir(3), closedir(3), dirfd(3), readdir(3), rewinddir(3), scandir(3),seekdir(3), telldir(3) approche qui permet dtre eectivement plus indpendant sur la structure interne des rpertoires, avec des syst`me e e e e plus ecaces que les listes utilises dans les premi`re implmentations. Voire Reiser fs par exemple. e e e 2 Pour plsu dinformation sur le sujet aller voire dans les sources les structures de sgf et dinode TODO : nom de chiers concerns . e
2.4. LES INODES
Fig. 2.1 larborescence MULTICS noeud de larbre qui permette de lister les chiers et les sous arbres quil contienti, dautres organisations plates existe ou lon organise les chiers en utilisans des types et des extentions de nom de chier pour organiser. Les arborescences de chiers et de catalogues, organises comme un graphe acyclique 3 , appae raissent avec le projet MULTICS. Cette organisation logique du disque a les avantages suivants : Une racine, un acc`s absolu ais (` la dirence de certains syst`me qui ont de nome e a e e breuses racines). Une structure dynamique. Une grande puissance dexpression. Un graphe acyclique. Lorganisation est arborescente avec quelques connections supplmentaires (liens multiples sur un e mme chier) qui en font un graphe. Mais ce graphe doit rester acyclique, pour les raisons suie vantes : Lensemble des algorithmes simples utilisables sur des graphe acycliques comme le parcours, la vrication des chiers libres, etc. deviennent beaucoup plus diciles ` crire pour des graphes e ae admettant des cycles. Des algorithmes de ramasse-miettes doivent tre utiliss pour savoir si certains objets sont e e utiliss on non et pour rcuperer les inodes ou blocs perdus apr`s un crash. e e e Tous les algorithmes de dtection dans un graphe quelconque ont une complexit beaucoup e e plus grande que ceux qui peuvent proter de lacyclicit du graphe. e Sous Unix nous sommes assurs que le graphe est acyclique car il est interdit davoir plusieurs e rfrences pour un mme catalogue (sauf la rfrence spciale .. ). ee e ee e Sous UNIX cest un graphe acyclique !
2.4
Les inodes
Linode est le passage oblig de tous les changes entre le syst`me de chier et la mmoire. e e e e Linode est la structure qui contient toutes les informations sur un chier donn ` lexception de ea
3 Ce
nest pas un arbre car un chier peut avoir plusieurs rfrences ee
10
sa rfrence dans larborescence (son nom), larborescence ntant quun outil de rfrencement ee e ee des chiers. Les informations stockes dans une inode disque sont : e utilisateur propritaire e groupe propritaire e type de chier - chiers ordinaires d rpertoire (dyrectory) e b mode bloc c mode caract`re e l lien symbolique p pour une fo (named pipe) s pour une socket droits dacc`s (ugo*rwx) e date de dernier acc`s e date de derni`re modication e date de derni`re modication de linode e taille du chier adresses des blocs-disque contenant le chier. Dans une inode en mmoire (chier en cours dutilisation par un processus) on trouve dautres e informations supplmentaires : e le statut de linode { locked, waiting P inode ` crire, ae chier ` crire, ae le chier est un point de montage } Et deux valeurs qui permettent de localiser linode sur un des disques logiques : Numro du disque logique e Numro de linode dans le disque e cette information est inutile sur le disque (on a une bijection entre la position de linode sur disque et le numro dinode). e On trouve aussi dautres types dinformations comme lacc`s ` la table des verrous ou bien des e a informations sur les disques ` distance dans les points de montage. a
2.5
Organisation des disques System V
Lorganisation disque dcrite sur la gure 2.2 est la plus simple que lon peut trouver de nos e jours sous UNIX, il en existe dautres o` lon peut en particulier placer un mme disque logique u e sur plusieurs disques physiques (dangereux), certaines o` les blocs sont fragmentables, etc. u Boot bloc utilis au chargement du syst`me. e e Super Bloc il contient toutes les informations gnrales sur le disque logique. e e Inode list Table des inodes. blocs les blocs de donnes chains ` la cration du disque (mkfs). e e a e Les blocs de donnes ne sont pas fragmentables sous Syst`me V. e e
2.6. ADRESSAGE DES BLOCS DANS LES INODES

Structure du systme de fichier sur un disque logique Boot Bloc Super Bloc Inode liste Blocs de donnes
11
Plusieurs disques logiques sur un disque physique
Super Bloc
Inode liste
Disque logique 1 Disque logique 2 Disque logique 3
Boot Bloc
Boot Bloc (vide)
Blocs de donnes
Fig. 2.2 Organisation des blocs et des inodes (SYS V)
2.6
Adressage des blocs dans les inodes
Le syst`me dadressage des blocs dans les inodes (syst`me V) consiste en 13 adresses de blocs. e e Les dix premi`res adresses sont des adresses qui pointent directement sur les blocs de donnes du e e chier. Les autres sont des adresses indirectes vers des blocs de donnes contenant des adresses. e La gure 2.3 nous montre les trois niveaux dindirection. Lintrt de cette reprsentation est ee e dconomiser sur la taille des inodes tout en permettant un acc`s rapide au petits chiers (la mae e jorit des chiers sont petits). Mais en laissant la possibilit de crer de tr`s gros chiers : e e e e 10 + 256 + (256 256) + (256 256 256) blocs disques.
2.7
Allocation des inodes dun disque
Lallocation des inodes est ralise en recherchant dans la zone des inodes du disque une inode e e libre. Pour acclrer cette recherche : un tampon dinodes libres est gr dans le SuperBloc, de ee ee plus lindice de la premi`re inode libre est gard en rfrence dans le SuperBloc an de redmarrer e e ee e la recherche qu` partir de la premi`re inode rellement libre. a e e Mais ce syst`me a une faille quil faut prvoir dans lcriture dans lalgorithme ialloc dallocation e e e dinode, cette faille est dcrite dans la Figure 2.10 e
2.8
Allocation des blocs-disque
Lalgorithme utilis pour grer lallocation des inodes sappuie sur le fait que lon peut tester si e e une inode est libre ou non en regardant son contenu. Ceci nest plus vrai pour les blocs. La solution est de cha ner les blocs. Ce cha nage est ralis par blocs dadresses pour acclrer les acc`s et e e ee e proter au maximum du buer cache. Il existe donc un bloc dadresses dans le super bloc qui sert de zone de travail pour lallocateur de blocs. Lutilisation de ce bloc et le mcanisme dallocation e sont dcrits dans les Figures 2.11 ` 2.16 e a
12
Blocs de donnes sur le disque
Inode direct 0 direct 1 direct 2 direct 3 direct 4 direct 5 direct 6 direct 7 direct 8 direct 9 indirect double triple
Fig. 2.3 Adressage direct et indirect des inode UNIX
Liste des inodes du Super Bloc inodes libres 18 83 19 48 20 Curseur vide
Fig. 2.4 Inodes libres dans le SuperBloc.
Liste des inodes du Super Bloc inodes libres 18 83 19 Curseur 20 vide
Fig. 2.5 Allocation dune inode.
2.8. ALLOCATION DES BLOCS-DISQUE
13
Liste des inodes du Super Bloc 473 0 Curseur (numro d'inode de rfrence) vide
Liste des inodes du Super Bloc 539 0 inodes libres 479 477 475
Fig. 2.6 Si le SuperBloc est vide.
Liste des inodes du Super Bloc 539 0 Curseur inodes libres 479 477 475
Fig. 2.7 Libration dune inode avec le SuperBloc plein. e
Fig. 2.8 Le numro dinode infrieur au numro de rfrence. e e e ee
Fig. 2.9 Le numro dinode suprieur au numro de rfrence. e e e ee
14
Processus A allocation de l'inode I en sommeil pendant la lecture de l'inode (a)
Processus B
Processus C
allocation avec super bloc vide (b) l'inode I (libre) est remise dans le super bloc (c) Travail sur l'Inode I en mmoire allocation d'une inode (d) allocation (d) de l'inode I Mais l'inode I n'est pas libre !! allocation (e) d'une autre l'inode
temps (a) (b) (c) (d) (e) temps

Fig. 2.10 Faille de lalgorithme dallocation.
JIK JI L
2.8. ALLOCATION DES BLOCS-DISQUE
15
Super Bloc Liste 109 106 103 100 Bloc 109 211 208 205 202 199 112 95
Bloc 211 311 308 305 302 301 214
etc
Fig. 2.11 Liste chaine de blocs. e
Super Bloc Liste 109 vide
211 208 205 202 199

Fig. 2.12 Etat initial du SuperBloc.
112
Super Bloc Liste 109 978
211 208 205 202 199

Fig. 2.13 Libration du bloc 978. e
112
Super Bloc Liste 109 Bloc 109 211 208 205 202 199
Fig. 2.14 Allocation du bloc 978.
112
16
Super Bloc Liste 211 208 205 202 199 112
Bloc 211 311 308 305 302 301

Fig. 2.15 Allocation du bloc 109.
214
Super Bloc Liste 612 Bloc 612 211 208 205 202 199
Fig. 2.16 Libration du bloc 612. e
112
Chapitre 3
Le Buer Cache
3.1 Introduction au buer cache
Le buer cache est un ensemble de structures de donnes et dalgorithmes qui permettent de e minimiser le nombre des acc`s disque. e Ce qui est tr`s important car les disques sont tr`s lents relativement au CPU et un noyau qui e e se chargerait de toutes les entres/sorties serait dune grande lenteur et lunit de traitement ne e e serait eectivement utilise qu` un faible pourcentage (voir Historique). e a Deux ides pour rduire le nombre des acc`s disques : e e e 1. bueriser les direntes commandes dcriture et de lecture de faon ` faire un acc`s disque e e c a e uniquement pour une quantit de donnes de taille raisonnable (un bloc disque). e e 2. Eviter des critures inutiles quand les donnes peuvent encore tre changes (criture dires). e e e e e ee
3.1.1
Avantages et dsavantages du buer cache e
Un acc`s uniforme au disque. Le noyau na pas ` conna e a tre la raison de lentre-sortie. Il e copie les donnes depuis et vers des tampons (que ce soient des donnes, des inodes ou le e e superbloc). Ce mcanisme est modulaire et sint`gre facilement ` lensemble du syst`me quil e e a e rend plus facile ` crire. ae Rend lutilisation des entres-sorties plus simple pour lutilisateur qui na pas ` se soucier e a des probl`mes dalignement, il rend les programmes portables sur dautres UNIX 1 . e Il rduit le trac disque et de ce fait augmente la capacit du syst`me. Attention : le nombre e e e de tampons ne doit pas trop rduire la mmoire centrale utilisable. e e Limplmentation du buer cache prot`ge contre certaines critures concurrentes e e e Lcriture dire pose un probl`me dans le cas dun crash du syst`me. En eet si votre e ee e e machine sarrte (coupure de courant) et que un (ou plusieurs) blocs sont marqus ` crire e e ae ils nont donc pas ts sauvegards physiquement. Lintgrit des donnes nest donc pas ee e e e e assure en cas de crash. e Le buer cache ncessite que lon eectue une recopie (interne ` la mmoire, de la zone utilie a e sateur au cache ou inversement) pour toute entre-sortie. Dans le cas de transferts nombreux e ceci ralentit les entres-sorties . e
3.2
Le buer cache, structures de donnes. e
Le statut dun bloc cache est une combinaison des tats suivants : e verrouill lacc`s est reserv ` un processus. e e ea
1 Les
probl`mes dalignement existent toujours quand on transf`re des donnes, cf. protocoles XDR,RPC e e e
17
18
Entte de Bloc # de disque # de bloc statut
CHAPITRE 3. LE BUFFER CACHE
Prcdent sur hash queue Prcdent sur liste des libres
Suivant sur hash queue Suivant sur liste des libres
Fig. 3.1 Structure des enttes de Bloc du Buer Cache e

Liste des blocs libres
tte de liste
b1
b2
bn
allocation du tampon 1 : le moins rcemment utilis
tte de liste
b2
bn
Fig. 3.2 La liste des tampons libres. valide (les donnes contenues dans le bloc sont valides). e ` crire les donnes du bloc doivent tre crites sur disque avant de rallouer le bloc ( cest ae e e e e de lcriture retarde). e e actif le noyau est en train dcrire/lire le bloc sur le disque. e attendu un processus attend la libration du bloc. e
3.2.1
La liste doublement cha ee des blocs libres n
Les tampons libres appartiennent simultanment ` deux listes doublement cha ees : la liste e a n des blocs libres et la hash-liste correspondant au dernier bloc ayant t contenu dans ce tampon. ee Linsertion dans la liste des tampons libres se fait en n de liste, la suppression (allocation du tampon ` un bloc donn) se fait en dbut de liste, ainsi le tampon allou est le plus vieux a e e e tampon libr2 . Ceci permet une rponse immdiate si le bloc correspondant est rutilis avant ee e e e e que le tampon ne soit allou ` un autre bloc. ea
3.3
Lalgorithme de la primitive getblk
Algorithme getblk (allocation dun tampon) entree : # disque logique , # de block sortie : un tampon verrouille utilisable pour manipuler bloc { while (tampon non trouve)
2 ordre
fo : rst in rst out
3.3. LALGORITHME DE LA PRIMITIVE GETBLK
19
bloc# 0 mod 4 bloc# 1 mod 4 bloc# 2 mod 4 bloc# 3 mod 4 liste libres
28 17 98 3
4 5 50 35
64 97 10 99
Fig. 3.3 Etat du buer cache avant les scnarios 1, 2 et 3. e { if (tampon dans sa hash liste) { if (tampon actif ) { [5] sleep attente de la liberation du tampon continuer } [1] verrouiller le tampon retirer le tampon de la liste des tampons libres retourner le tampon } else /* nest pas dans la hash liste */ { if (aucun tampon libre ) { [4] sleep attente de la liberation dun tampon continuer } retirer le tampon de la liste libre [3] if (le tampon est a ecrire) { lancer la sauvegarde sur disque continuer } [2] retirer le buffer de son ancienne liste de hashage, le placer sur la nouvelle retourner le tampon } } }
20
28 17 98 3
4 5 50 35
64 97 10 99
Fig. 3.4 Scnario 1- Demande dun tampon pour le bloc-disque 4. e
28 17 98
4 5 50 35
64 97 10 99 41
Fig. 3.5 Scnario 2- Demande dun tampon pour le bloc-disque 41. e
28 17 98 3
writing
4 5
writing
64 97 10 99 18
50 35
Fig. 3.6 Scnario 3- Demande pour le bloc 18 (3 & 5 marqus ` crire). e e ae
3.3. LALGORITHME DE LA PRIMITIVE GETBLK
21
28 17 98 3
4 5 50 35
64 97 10 99
Fig. 3.7 Scnario 4- Plus de blocs libres. e
28 17 98 3
4 5 50 35
64 97 10 99
Fig. 3.8 Scnario 5- Demande pour le bloc 17 qui est dj` utilis. e ea e
22
Chapitre 4
La biblioth`que standard e
4.1 Les descripteurs de chiers.
Le chier dinclusion <stdio.h> contient la dnition du type FILE. Ce type est une structure e contenant les informations ncessaires au syst`me pour la manipulation dun chier ouvert. Le e e contenu exact de cette structure peut varier dun syst`me ` lautre (UNIX, VMS, autre). e a Toutes les fonctions dE/S utilisent en premier argument un pointeur sur une telle structure : FILE *. Le rle de cet argument est dindiquer le ux sur lequel on doit eectuer lopration o e dcriture ou de lecture. e Pour pouvoir utiliser une fonction dentre-sortie il faut donc avoir une valeur pour ce premier e argument, cest le rle de la fonction fopen de nous fournir ce pointeur en ouvrant le chier. o Les deux fonctions printf et scanf sont des synonymes de fprintf(stdout, format, ...) et fscanf(stdin, format, ...) o` stdout et stdin sont des expressions de type FILE * dnies sous forme de macro-dnitions u e e dans le chier <stdio.h> . Avec POSIX ce sont eectivement des fonctions. Sur les syst`me de la famille UNIX les chiers ouverts par un processus le restent dans ses ls. e Par exemple le shell a en gnral trois ux standards : e e stdin le terminal ouvert en lecture. stdout le terminal ouvert en criture. e stderr le terminal ouvert en criture, et en mode non bueris. e e ainsi si lexcution dun programme C est ralise ` partir du shell le programme C a dj` ces e e e a ea trois descripteurs de chiers utilisables. Cest pourquoi il est en gnral possible dutiliser printf e e et scanf sans ouvrir pralablement de chiers. Mais si lentre standard nest pas ouverte, scanf e e choue : e #include <stdio.h> main() { int i; if (scanf("%d", &i) == EOF) { printf("l\entree standard est fermee\n"); } else { printf("l\entree standard est ouverte\n"); 23
24 } }
` CHAPITRE 4. LA BIBLIOTHEQUE STANDARD
Compil,(a.out), cela donne les deux sorties suivantes : e $ a.out lentree standard est ouverte $ a.out <&- # fermeture de lentree standard en ksh lentree standard est fermee De mme printf choue si la sortie standard est ferme. e e e
4.1.1
Ouverture dun chier
La fonction de la biblioth`que standard fopen permet douvrir un chier ou de le crer. e e #include <stdio.h> FILE *fopen(const char *filename, const char *type); lename est une rfrence absolue ou relative du chier ` ouvrir ; si le chier nexiste pas alors ee a il est cr si et seulement si lutilisateur du processus a lautorisation dcrire dans le rpertoire. ee e e type est une des cha nes suivantes : r ouverture en lecture au dbut du chier e w ouverture en criture au dbut du chier avec crasement du chier si il existe (le chier est e e e vid de son contenu ` louverture). e a a ouverture en criture ` la n du chier (mode append). e a r+,w+,a+ ouverture en lecture criture respectivement au dbut du chier, au dbut e e e du chier avec crasement, ` la n du chier. e a FILE *f; ... if ((f = fopen("toto", "r")) == NULL) { fprintf(stderr, "impossible douvrir toto\n"); exit(1); } ... La fonction retourne un pointeur sur un descripteur du chier ouvert ou NULL en cas dchec, e (acc`s interdit, cration impossible, etc). e e
4.1.2
Redirection dun descripteur : freopen
Permet dassocier un descripteur dj` utilis ` une autre ouverture de chier. Ceci permet de ea ea raliser facilement les redirections du shell. e FILE *freopen(const char *ref, const char *mode, FILE *f) Par exemple les redirections de la ligne shell : com <ref1 >>ref2 peuvent tre ralises avec e e e
4.1. LES DESCRIPTEURS DE FICHIERS. if (!freopen("ref1", "r", stdin) || !freopen("ref2", "a", stdout)) { fprintf(stderr, "erreur sur une redirection\n"); exit(1); } execl("./com", "com", NULL);
25
4.1.3
Cration de chiers temporaires e
La fonction #include <stdio.h> FILE *tmpfile(void); cre et ouvre en criture un nouveau chier temporaire, qui sera dtruit (un unlink est ralis e e e e e immdiatement) ` la n de lexcution du processus, attention le descripteur est la aussi hrit e a e e e par les ls, et il faut en grer le partage. Cette fonction utilise la fonction e int mkstemp(char *patron); Les 6 dernier caract`re du chemin patron doivent tre XXXXXX il seront remplac par une e e e chaine rendant le nom unique, ce chemin sera utilis pour ouvrir un chier temporaire avec loption e cration et echec sur cration avec les droit 0600 ce qui permet dviter des troux de scurit. La e e e e e fonction retourne le descripteur. Attention mkstemp nassure pas que le chier sera dtruit apr`s e e utilisation comme cetait le cas avec tmpfile , par contre il devient tr`s dicile de raliser une e e attaque sur les chiers temporaire crer par mkstemp. e
4.1.4
Ecriture non formate e
Les deux fonctions suivantes permettent dcrire et de lire des zones mmoire, le contenu de e e la mmoire est directement crit sur disque sans transformation, et rciproquement le contenu du e e e disque est plac tel quel en mmoire. Lintrt de ces fonctions est dobtenir des entres sorties e e ee e plus rapides et des sauvegardes disque plus compactes mais malheureusement illisibles (binaire). Dautre part les fonction de lecture et decriture sont exactement symtrique ce qui nest pas le e cas de scanf et printf #include <stdio.h> int fwrite(void *add, size_t ta, size_t nbobjets, FILE *f); Ecrit nbobjets de taille ta qui se trouvent ` ladresse add dans le chier de descripteur f. a #include <stdio.h> int fread(void *add, size_t ta, size_t nbobjets, FILE *f); Lit nbobjets de taille ta dans le chier de descripteur f et les place ` partir de ladresse add a en mmoire. e Attention : La fonction fread retourne 0 si lon essaye de lire au del` du chier. Pour crire a e une boucle de lecture propre on utilise la fonction feof(FILE *) : int n[2]; while (fread(n, sizeof(int), 2, f), !feof(f)) printf("%d %d \n", n[0], n[1]);
26
4.1.5
Acc`s squentiel e e
On distingue deux techniques dacc`s aux supports magntiques : e e Lacc`s squentiel qui consiste ` traiter les informations dans lordre o` elle apparaissent sur e e a u le support (bandes). Le lecteur physique avance avec la lecture, et se positionne sur le dbut e de lenregistrement suivant. Lacc`s direct qui consiste ` se placer directement sur linformation sans parcourir celles e a qui la prc`dent (disques). Le lecteur physique reste sur le mme enregistrement apr`s une e e e e lecture. En langage C lacc`s est squentiel mais il est possible de dplacer le pointeur de chier cest ` e e e a dire slectionner lindice du prochain octet ` lire ou crire. e a e Comme nous venons de le voir dans les modes douverture, le pointeur de chier peut tre e initialement plac en dbut ou n de chier. e e Les quatre fonctions dentre-sortie (fgetc, fputc, fscanf, fprintf) travaillent squentiele e lement ` partir de cette origine xe par fopen, et modiable par fseek. a e
4.1.6
Manipulation du pointeur de chier
Le pointeur de chier est un entier long qui indique ` partir de quel octet du chier la prochaine a fonction dentre-sortie doit seectuer. e En dbut de chier cet entier est nul. e #include <stdio.h> int fseek(FILE *f, long pos, int direction); f le descripteur du chier dans lequel ont dplace le pointeur. e direction est une des trois constantes enti`res suivantes : e SEEK SET positionnement sur loctet pos du chier SEEK CUR positionnement sur le pos-i`me octet apr`s la position courante du pointeur de e e chier. (quivalent ` SEEK SET courant+pos). e a SEEK END positionnement sur le pos-i`me octet apr`s la n du chier. e e Remarquer que pos est un entier sign : il est possible se placer sur le 4i`me octet avant la n e e du chier : fseek(f, -4L, SEEK_END);
4.1.7
Un exemple dacc`s direct sur un chier dentiers. e
La fonction suivante lit le n-i`me entier dun chier dentiers pralablement crit grce ` e e e a a fwrite : int lirenieme(int n, FILE *f) { int buf; fseek(f, sizeof(int)*(n-1), SEEK_SET); fread(&buf, sizeof(int), 1, f); return buf; \istd{fseek}\istd{fread}
4.1.8
Les autres fonctions de dplacement du pointeur de chier. e
La fonction ftell long int ftell(FILE *);
4.2. LES TAMPONS DE FICHIERS DE STDLIB. retourne la position courante du pointeur. La fonction rewind void rewind(FILE *f); quivalent ` : (void) fseek (f, 0L, 0) e a
27
4.2
Les tampons de chiers de stdlib.
La biblioth`que standard utilise des tampons pour minimiser le nombre dappels syst`me. Il est e e possible de tester lecacit de cette buerisation en comparant la vitesse de recopie dun mme e e chier avec un tampon de taille 1 octet et un tampon adapt ` la machine, la dirence devient ea e vite tr`s importante. Une faon simple de le percevoir est dcrire un programme com qui ralise e c e e des critures sur la sortie standard ligne par ligne, de regarder sa vitesse puis de comparer avec la e commande suivantes :com | cat la biblioth`que standard utilisant des buer dirents dans les e e deux cas une dirence de vitese dexcution est perceptible (sur une machine lente la dirence e e e de vitesse est vidente, mais elle existe aussi sur une rapide. . .). e
4.2.1
Les modes de buerisation par dfaut. e
Le mode de buerisation des chiers ouverts par la biblioth`que standard dpend du type de e e priphrique. e e Si le chier est un terminal la buerisation est faite ligne ` ligne. a En criture le tampon est vid ` chaque criture dun \n , ou quand il est plein e e a e (premi`re des deux occurences). e En lecture le tampon est rempli apr`s chaque validation (RC), si lon tape trop de e caract`res le terminal proteste (beep) le buer clavier tant plein. e e Si le chier est sur un disque magntique e En criture le tampon est vid avant de dborder. e e e En lecture le tampon est rempli quand il est vide. Le shell de login change le mode de buerisation de stderr qui est un chier terminal ` non a bueris. e Nous avons donc ` notre disposition trois modes de buerisation standards : a Non bueris (sortie erreur standard), e Bueris par ligne (lecture/criture sur terminal), e e Bueris par blocs (taille des tampons du buer cache). e Un exemple de rouverture de la sortie standard, avec perte du mode de buerisation : e #include <stdio.h> main() { freopen("/dev/tty", "w", stderr); fprintf(stderr, "texte non termine par un newline "); sleep(12); exit(0); /* realise fclose(stderr) qui realise fflush(stderr) */ } Il faut attendre 12 secondes lachage.
4.2.2
Manipulation des tampons de la biblioth`que standard. e
Un tampon allou automatiquement (malloc) est associ ` chaque ouverture de chier par e e a fopen au moment de la premi`re entre-sortie sur le chier. e e
28
La manipulation des tampons de la biblioth`que standard comporte deux aspects : e 1. Manipulation de la buerisation de faon ponctuelle (vidange). c 2. Positionnement du mode de buerisation. Manipulations ponctuelles La fonction suivante permet de vider le tampon associ au FILE * f : e #include <stdio.h> fflush(FILE *f); En criture force la copie du tampon associ ` la structure f dans le tampon syst`me (ne garantit e ea e pas lcriture en cas dinterruption du syst`me !). e e En lecture dtruit le contenu du tampon, si lon est en mode ligne uniquement jusquau premier e caract`re \n. e La fonction fclose() ralise un ush() avant de fermer le chier. e La fonction exit() appel fclose() sur tous les chiers ouvert par fopen (freopen,tmple,. . .) avant de terminer le processus.
Manipulations du mode de buerisation et de la taille du tampon. La primitive int setvbuf(FILE *f, char *adresse, int mode, size_t taille); permet un changement du mode de buerisation du chier f avec un tampon de taille taille fourni par lutilisateur ` ladresse adresse si elle est non nulle, avec le mode dni par les macroa e dnitions suivantes (<stdio.h>) : e _IOFBF _IONBF _IOMYBUF _IOLBF bufferise Non bufferise Mon buffer bufferise par ligne (ex: les terminaux)
Attention : Il ne faut pas appeler cette fonction apr`s lallocation automatique ralise par la e e e biblioth`que standard apr`s le premier appel ` une fonction dentre-sortie sur le chier. e e a e Il est fortement conseill que la zone mmoire pointe par adresse soit au moins dune taille gale e e e e ` taille. a Seul un passage au mode bueris en ligne ou non bueris peut tre ralis apr`s lallocation e e e e e e automatique du tampon, au risque de perdre ce tampon (absence d appel de free). Ce qui permet par exemple de changer le mode de buerisation de la sortie standard apr`s un fork. Attention e ce peut tre dangereux, pour le contenu courant du tampon comme le montre lexemple suivant. e Avant cette fonction de norme POSIX on utilisait trois fonctions : void setbuf(FILE *f, char *buf); void setbuffer(FILE *f,char *adresse,size_t t); void setlignebuf(FILE *f);
4.3. MANIPULATION DES LIENS DUN FICHIER #include <stdio.h> main() { printf("BonJour "); switch(fork()) { case -1 : exit(1); case 0 : printf("je suis le fils"); /* version 1 sans la ligne suivante version 2 avec setbuffer(stdout, NULL, 0); sleep(1); printf("Encore le fils"); break; default : printf("je suis le pere"); sleep(2); } printf("\n"); } version 1 fork_stdlib BonJour je suis le fils Encore le fils BonJour je suis le pere version 2 Encore le fils BonJour je suis le pere
29
*/
4.3
Manipulation des liens dun chier
Changer le nom dun chier : int rename(const char *de,const char *vers); permet de renommer un chier (ou un rpertoire). Il faut que les deux rfrences soient de e ee mme type (chier ou rpertoire) dans le mme syst`me de chiers. e e e e Rappel : ceci na deet que sur larborescence de chiers. Dtruire une rfrence : e ee int remove(const char *filename); Dtruit le lien donn en argument, le syst`me rcup`re linode et les blocs associs au chier e e e e e e si ctait le dernier lien. e
4.4
Lancement dune commande shell
#include <stdlib.h> int system(const char *chaine_de_commande); Cre un processus /bin/posix/sh qui excute la commande ; il y a attente de la n du shell, e e (la commande peut elle tre lance en mode dtach ce qui fait que le shell retourne immdiatement e e e e e
30
sans faire un wait). Ce mcanisme est tr`s coteux. Attention la commande system bloque les e e u signaux SIGINT et SIGQUIT, il faut analyser la valeur de retour de system de la mme faons e c que celle de wait. Il est conseill de bloquer ces deux signaux avant lappel de system . e
4.5
exit
Terminaison dun processus

La primitive de terminaison de processus de bas niveau : #include <stdlib.h> void _exit(int valeur);
La primitive exit est la fonction de terminaison bas niveau elle ferme les descripteurs ouverts par open, opendir ou hrits du processus p`re. e e e la valeur est fournie au processus p`re qui la rcup`re par lappel syst`me wait. Cette valeur e e e e est le code de retour de processus en shell. Cette primitive est automatiquement appele ` la n de la fonction main (sauf en cas dappels e a rcursifs de main). e exit La fonction de terminaison de processus de stdlib :
#include <stdlib.h> void exit(int valeur); la fonction exit : lance les fonctions dnies par atexit. e ferme lensemble des descripteurs ouverts grce ` la biblioth`que standard (fopen). a a e dtruit les chiers fabriqus par la primitive tmple e e appelle exit avec valeur. atexit La primitive atexit permet de spcier des fonctions ` appeler en n dexcution, elle e a e sont lances par exit dans lordre inverse de leur positionnement par atexit. e #include <stdlib.h> int 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(0); } $ make atexit cc atexit.c -o atexit $ atexit $ atexit unargument cuicui coucou $
4.6. GESTION DES ERREURS
31
4.6
Gestion des erreurs
Les fonctions de la biblioth`que standard positionnent deux indicateurs derreur, la fonction e suivante les repositionne : void clearerr(FILE *); La fonction int feof(FILE *) est vraie si la n de chier est atteinte sur ce canal, int ferror(FILE *) est vraie si une erreur a eu lieu pendant la derni`re tentative de lecture ou e dcriture sur ce canal. e Une description en langue naturelle de la derni`re erreur peut tre obtenue grace ` e e a void perror(const char *message); lachage se fait sur la sortie erreur standard (stderr).
4.7
Cration et destruction de rpertoires e e
Cration dun rpertoire vide (mme syntaxe que creat) : e e e #include <unistd.h> int mkdir(char *ref, mode_t Destruction : int rmdir(char *ref); avec les mmes restrictions que pour les shells sur le contenu du rpertoire (impossible de e e dtruire un rpertoire non vide). e e mode);
32
Chapitre 5
Appels syst`me du Syst`me de e e Gestion de Fichier

Les appels syst`me dentres-sorties ou entres-sorties de bas niveau sont rudimentaires mais e e e polymorphes, en eet cest eux qui permettent dcrire des programmes indpendamment des supe e ports physiques sur lesquels se font les entres/sorties et de pouvoir facilement changer les supports e physiques associs a une entre-sortie. e e Les appels syst`me du syst`me de gestion de chier sont : e e open/creat ouverture/cration dun chier e read/write lecture/ecriture sur un chier ouvert lseek dplacement du pointeur de chier e dup,dup2 copie douverture de chier close fermeture dun chier mount chargement dun disque mknode cration dun inode de chier spcial e e pipe cration dun tube e fcntl manipulation des caractristiques des ouvertures de chiers e Les appels syst`me sont raliss par le noyau et retournent -1 en cas derreur. e e e
5.1
open
#include <fcntl.h> int open(char *ref, int mode, int perm); Ouverture du chier de rfrence (absolue ou relative ` .) ref. ee a Le mode douverture est une conjonction des masques suivants : O_RDONLY O_WRONLY O_RDWR O_NDELAY O_APPEND O_CREAT O_TRUNC O_EXCL /* /* /* /* /* /* /* /* open for reading */ open for writing */ open for read & write */ non-blocking open */ append on each write */ open with file create */ open with truncation */ error on create if file exists*/ 33
34
Dans le noyau Sur Disque la table des inodes en mmoire inodes

Buffer cache
Dans chaque processus table des descripteurs 0 1 2
` ` CHAPITRE 5. APPELS SYSTEME DU SYSTEME DE GESTION DE FICHIER
Fig. 5.1 Tables du syst`me de chiers. e
donnes
la table systme des fichiers ouverts
5.1. OPEN
35
Dans le processus descripteurs 0 1 2 Dans le processus descripteurs 0 1 2 fd
Dans le noyau inodes en mmoire
1 rd 1 wr Dans le noyau 1 wr 1 rw 1 rd 1 wr 1 wr
vers le buffer cache et le disque inodes en mmoire 1 3
vers le buffer cache et le disque
fd=open("toto",O_RDWR |O_CREAT,0666);
Fig. 5.2 Avant louverture, descripteurs standard ouverts, puis apr`s louverture de toto. e Le param`tre permission na de sens qu` la cration du chier, il permet de positionner les e a e valeurs du champ mode de linode. Les droits eectivement positionns dpendent de la valeur e e de umask, grace ` la formule droits = perm & ~ umask. La valeur par dfaut de umask est 066 a e (valeur octale). La valeur de retour de open est le numro dans la table de descripteurs du processus qui a t e ee utilis par open. Ce numro est appel descripteur de louverture. Ce descripteur est utilis dans e e e e les autres appels syst`me pour spcier louverture de chier sur laquelle on veut travailler1 , et -1 e e en cas dchec de louverture. e
5.1.1
Droulement interne dun appel de open e
1. Le syst`me dtermine linode du chier rfrence (namei). e e ee 2. Soit linode est dans la table des inodes en mmoire. e Soit il alloue une entre et recopie linode du disque (iget). e 3. Le syst`me vrie les droits dacc`s dans le mode demand. e e e e 4. Il alloue une entre dans la table des chiers ouverts du syst`me, et positionne le curseur de e e lecture criture dans le chier (oset = 0, sauf dans le cas du mode O APPEND oset=taille e du chier). 5. Le syst`me alloue une place dans la table des descripteurs iob du chier. e 6. Il renvoie au processus le numro de descripteur, cest ` dire le numro de lentre quil vient e a e e dallouer dans le tableau iob. Si lopration a chou dans une des tapes le syst`me renvoie -1. e e e e e
1 Un
mme chier peut tre ouvert plusieurs fois. e e
36
5.2
creat
Cration dun chier et ouverture en criture. e e int creat(char *reference, int permissions); 1. Le syst`me dtermine linode du catalogue o` lon demande la cration du chier. e e u e (a) Si il existe dj` une inode pour le chier ea Le noyau lit linode en question (allocation dans la table des inodes en mmoire), e vrie que cest un chier ordinaire autoris en criture par le propritaire eectif du e e e e processus, sinon chec. e Le syst`me lib`re les blocs de donnes et rduit la taille du chier ` zro, il ne modie e e e e a e pas les droits quavait le chier antrieurement. e (b) Si nexistait pas dinode pour le chier Le syst`me teste les droits en criture sur le catalogue e e Il alloue une nouvelle inode (ialloc) Il alloue une nouvelle entre dans la table des inodes en mmoire. e e Mme suite que pour open. e
5.3
read
int nbcharlus = read(int d, char *tampon, int nbalire) descripteur entre de la table des descripteurs correspondante au chier dans lequel doit tre e e eectue la lecture (fourni par open). e nbalire nombre de caract`res ` lire dans le chier. e a tampon un tableau de caract`res allou par lutilisateur. Les caract`res lus sont placs dans ce e e e e tampon. nbcharlus nombre de caract`res eectivement lus, ou -1 en cas dchec de lappel syst`me, (droits, e e e ...), la n de chier est atteinte quand le nombre de caract`res lus est infrieur au nombre e e de caract`res demands. e e Droulement : e 1. Vrication du descripteur acc`s aux tables syst`me. e e e 2. Droits (mode adquat) e 3. Grce ` linode le syst`me obtient les adresses du (des) bloc(s) contenant les donnes ` lire. a a e e a Le syst`me eectue la lecture de ces blocs. e 4. Le syst`me recopie les donnes du buer cache vers le tampon de lutilisateur. e e 5. Le curseur dans le chier est remit ` jour dans lentre de la table des chiers ouverts. a e 6. Le syst`me renvoie le nombre de caract`res eectivement lus. e e
5.4
write
int nbcecrits = write(int desc, char *tampon, int nbaecrire); Mme droulement que read mais avec une allocation ventuelle de bloc-disque dans le cas e e e dun ajout au-del` de la n du chier. a Dans le cas o` lappel concerne un priphrique en mode caract`re : le syst`me active la fonction u e e e e write (rciproquement read pour une lecture) du priphrique qui utilise directement ladresse e e e du tampon utilisateur.
5.5. LSEEK
37
Remarquons ici encore le polymorphisme de ces deux appels syst`me qui permet de lire et dcrire e e sur une grande varit de priphriques en utilisant une seule syntaxe. Le code C utilisant lapee e e pel syst`me marchera donc indiremment sur tous les types de priphriques qui sont dnis e e e e e dans le syst`me de chier. Par exemple, il existe deux priphriques logiques qui sont /dev/null e e e et /dev/zro (que lon ne trouve pas sur toutes les machines). Le premier est toujours vide en e lecture et les critures nont aucun eet (il est donc possible de dverser nimporte quoi sur ce e e priphrique). Le deuxi`me fournit en lecture une innit de zro et naccepte pas lcriture. e e e e e e
5.5
lseek
#include <fcntl.h> off_t lseek(int d, off_t offset, int direction) lseek permet de dplacer le curseur de chier dans la table des chiers ouverts du syst`me. e e oset un dplacement en octets. e d le descripteur. direction une des trois macros L SET, L INCR, L XTND. L SET la nouvelle position est oset sauf si oset est suprieur ` la taille du chier, auquel cas e a la position est gale ` la taille du chier. Si loset est ngatif, alors la position est zro. e a e e L INCR la position courante est incrmente de oset place (mme contrainte sur la position e e e maximum et la position minimum). L XTND Dplacement par rapport ` la n du chier, cette option permet daugmenter la taille e a du chier (ne pas crer de chiers virtuellement gros avec ce mcanisme, ils posent des e e probl`mes de sauvegarde). e La valeur de retour de lseek est la nouvelle position du curseur dans le chier ou -1 si lappel a chou. e e
5.6
dup et dup2
Les appels dup et dup2 permettent de dupliquer des entres de la table des descripteurs du e processus. int descripteur2 = dup(int descripteur1);
1. vrication que descripteur est le numro dune entre non nulle. e e e 2. recopie dans la premi`re entre libre du tableau des descripteurs lentre correspondant ` e e e a descripteur1. 3. le compteur de descripteurs de lentre associe ` descripteur1 dans la table des ouvertures e e a de chiers est incrment. e e 4. renvoi de lindice dans la table des descripteurs de lentre nouvellement alloue. e e Redirection temporaire de la sortie standard dans un chier : tempout = open("sortie_temporaire",1); oldout = dup(1); close(1); newout = dup(tempout); /* renvoie 1 */ write(1,"xxxx",4); /* ecriture dans le fichier temporaire */
38
close(tempout); close(1); newout = dup(oldout); close(oldout); Il est aussi possible de choisir le descripteur cible avec int ok = dup2(int source, int destination); Recopie du descripteur source dans lentre destination de la table des descripteurs. Si e destination dsigne le descripteur dun chier ouvert, celui-ci est pralablement ferm avant e e e duplication. Si destination nest pas un numro de descripteur valide, il y a une erreur, retour e -1.
5.7
close
Fermeture dun chier. int ok = close(descripteur); 1. si descripteur nest pas un descripteur valide retour -1 2. lentre dindice descripteur de la table est libre. e ee 3. Le compteur de lentre de la table des chiers ouvert associ ` descripteur est dcrment. e ea e e e Si il passe ` Zro alors a e 4. lentre de la table des chiers ouverts est libre et le compteur des ouvertures de linode e ee en mmoire est dcrment. e e e e Si il passe ` Zro alors a e 5. lentre dans la table des inodes en mmoire est libre. e e ee Si de plus le compteur de liens de linode est ` 0 alors a 6. le chier est libr : rcupration de linode et des blocs. ee e e Dans le cas dune ouverture en criture : le dernier bloc du buer cache dans lequel on a crit e e est marqu a crire. e e
5.8
fcntl
Lappel syst`me fnctl permet de manipuler les ouverture de chier apr`s louverture, bien e e sur il nest pas possible de changer le mode douverture (lecture/criture/lecture-criture) apr`s e e e louverture. #include <sys/types.h> #include <unistd.h> #include <fcntl.h> int fcntl(int desc, int commande); int fcntl(int desc, int commande, long arg); int fcntl(int desc, int commande, struct flock *verrou); Lappel syst`me fnctl permet de positionner des verrous de chier voire le chapitre 12. Lappel e syst`me fnctl permet la manipulation de certains des drapeaux douverture : e O APPEND
5.8. FCNTL
dup2(fd,1); descripteurs 0 1 2 fd 2 rw 1 rd 1 2
39
1 wr close(fd); 0 1 2 1 rw 1 rd 1 2
1 wr
Fig. 5.3 Redirection de la sortie standard sur toto. O NONBLOCK O ASYNC O DIRECT Lappel syst`me fnctl permet gerer les signaux associs aux entre asyncrones. e e e
40
Chapitre 6
Les processus
6.1 Introduction aux processus
Un processus est un ensemble doctets (en langage machine) en cours dexcution, en dautres e termes, cest lexcution dun programme. e Un processus UNIX se dcompose en : e 1. un espace dadressage (visible par lutilisateur/programmeur) 2. Le bloc de contrle du processus (BCP) lui-mme dcompos en : o e e e une entre dans la table des processus du noyau struct proc e dnie dans <sys/proc.h>. e une structure struct user appele zone u dnie dans <sys/user.h> e e Les processus sous Unix apportent : La multiplicit des excutions e e Plusieurs processus peuvent tre lexcution dun mme programme. e e e La protection des excutions e Un processus ne peut excuter que ses instructions propres et ce de faon squentielle ; il ne e c e peut pas excuter des instructions appartenant ` un autre processus. e a Les processus sous UNIX communiquent entre eux et avec le reste du monde grce aux a appels syst`me. e
6.1.1
Cration dun processus - fork() e
Sous UNIX la cration de processus est ralise par lappel syst`me : e e e e
P1
P5
le noyau
table des processus
P1
les processus
P5
Fig. 6.1 La table des processus est interne au noyau. 41
42 int fork(void);
CHAPITRE 6. LES PROCESSUS
Tous les processus sauf le processus didentication 0, sont crs par un appel ` fork. ee a Le processus qui appelle le fork est appel processus p`re. e e Le nouveau processus est appel processus ls. e Tout processus a un seul processus p`re. e Tout processus peut avoir zro ou plusieurs processus ls. e Chaque processus est identi par un numro unique, son PID. e e Le processus de PID=0 est cr manuellement au dmarrage de la machine, ce processus ee e a toujours un rle spcial1 pour le syst`me, de plus pour le bon fonctionement des programmes o e e utilisant fork() il faut que le PID zro reste toujours utilis. Le processus zro cre, grce ` un e e e e a a appel de fork, le processus init de PID=1. Le processus de PID=1 de nom init est lanctre de tous les autres processus (le processus 0 e ne ralisant plus de fork()), cest lui qui accueille tous les processus orphelins de p`re (ceci a n e e de collecter les information ` la mort de chaque processus). a
6.2
Format dun chier excutable e
Les compilateurs nous permettent de crer des chiers excutables. Ces chiers ont le format e e suivant qui permet au noyau de les transformer en processus : Une en-tte qui dcrit lensemble du chier, ses attributs et sa carte des sections. e e La taille ` allouer pour les variables non initialises. a e Une section TEXT qui contient le code (en langage machine) Une section donnes (DATA) code en langage machine qui contient les donnes initialises. e e e e Eventuellement dautres sections : Table des symboles pour le dbugeur, Images, ICONS, e Table des cha nes, etc. Pour plus dinformations se reporter au manuel a.out.h sur la machine.
6.3
Chargement/changement dun excutable e
Lappel syst`me execve change lexcutable du processus courant en chargeant un nouvel e e excutable. Les rgions associe au processus sont pralablement libres : e e e e ee int execve(/* plusieurs formats */); Pour chaque section de lexcutable une rgion en mmoire est alloue. e e e e Soit au moins les rgions : e le code les donnes initialises e e Mais aussi les rgions : e des piles du tas La rgion de la pile : e Cest une pile de structures de pile qui sont empiles et dpiles lors de lappel ou le retour de e e e fonction. Le pointeur de pile, un des registres de lunit centrale, indique la profondeur courante e de la pile.
1 swappeur,gestionnaire
de pages
6.4. ZONE U ET TABLE DES PROCESSUS

Adresse Haute = 0xFFFFFFFF argc,argv,env Tas
43
Pile Donnes non-initialises Donnes initialise Texte Adresse Basse =0
} initialise zro par exec lu par exec
Fig. 6.2 La structure interne des processus.
Le code du programme g`re les extensions de pile (appel ou retour de fonction), cest le noyau qui e alloue lespace ncessaire ` ces extensions. Sur certains syst`mes on trouve une fonction alloca() e a e qui permet de faire des demandes de mmoire sur la pile. e Un processus UNIX pouvant sexcuter en deux modes (noyau, utilisateur), une pile prive sera e e utilise dans chaque mode. e La pile noyau sera vide quand le processus est en mode utilisateur. Le tas est une zone o` est ralise lallocation dynamique avec les fonctions Xalloc(). u e e
6.4
zone u et table des processus
Tous les processus sont associs ` une entre dans la table des processus qui est interne au e a e noyau. De plus, le noyau alloue pour chaque processus une structure appele zone u , qui contient e des donnes prives du processus, uniquement manipulables par le noyau. e e La table des processus nous permet daccder ` la table des rgions par processus qui permet daccder ` la table des e a e e a rgions. Ce double niveau dindirection permet de faire partager des rgions. e e Dans lorganisation avec une mmoire virtuelle, la table des rgions est matrialise logiquement e e e e dans la table de pages. Les structures de rgions de la table des rgions contiennent des informations sur le type, les e e droits dacc`s et la localisation (adresses en mmoire ou adresses sur disque) de la rgion. e e e Seule la zone u du processus courant est manipulable par le noyau, les autres sont inaccessibles. Ladresse de la zone u est place dans le mot dtat du processus. e e
6.5
fork et exec (revisits) e
Quand un processus ralise un fork, le contenu de lentre de la table des rgions est dupliqu, e e e e chaque rgion est ensuite, en fonction de son type, partage ou copie. e e e Quand un processus ralise un exec, il y a libration des rgions et rallocation de nouvelles e e e e rgions en fonction des valeurs dnies dans le nouvel excutable. e e e
44
zone u
Table des rgions par processus
Table des rgions
Table des processus
Mmoire Centrale
Fig. 6.3 Table des rgions, table des rgions par processus e e
zone u zone u
Table des rgions partage copie
copie Table des processus
fork()
pre = fils = Mmoire Centrale
Fig. 6.4 Changement de rgions au cours dun fork. e
zone u
Table des rgions
ancienne entre
Table des processus
exec()
Mmoire Centrale
Fig. 6.5 Changement de rgions au cours dun exec. e
6.6. LE CONTEXTE DUN PROCESSUS
45
6.6
Le contexte dun processus
Le contexte dun processus est lensemble des donnes qui permettent de reprendre lexcution e e dun processus qui a t interrompu. ee Le contexte dun processus est lensemble de 1. son tat e 2. son mot dtat : en particulier e La valeur des registres actifs Le compteur ordinal 3. les valeurs des variables globales statiques ou dynamiques 4. son entre dans la table des processus e 5. sa zone u 6. Les piles user et system 7. les zones de code et de donnes. e Le noyau et ses variables ne font partie du contexte daucun processus ! Lexcution dun processus se fait dans son contexte. e Quand il y a changement de processus courant, il y a ralisation dune commutation de mot e dtat et dun changement de contexte. Le noyau sexcute alors dans le nouveau contexte. e e
6.7
Commutation de mot dtat et interruptions. e
Ces fonctions de tr`s bas niveau sont fondamentales pour pouvoir programmer un syst`me e e dexploitation. Pour tre excut et donner naissance ` un processus, un programme et ses donnes doivent e e e a e tre chargs en mmoire centrale. Les instructions du programme sont transfres une ` une de la e e e ee a mmoire centrale sur lunit centrale o` elles sont excutes. e e u e e Lunit centrale : e Elle comprend des circuits logiques et arithmtiques qui eectuent les instructions mais aussi des e mmoires appeles registres. e e Certains de ces registres sont spcialiss directement par les constructeurs de lunit centrale, e e e dautres le sont par le programmeur du noyau. Quelques registres spcialiss : e e Laccumulateur qui reoit le rsultat dune instruction ; sur les machines ` registres multiples, c e a le jeu dinstructions permet souvent dutiliser nimporte lequel des registres comme accumulateur. le registre dinstruction (qui contient linstruction en cours) le compteur ordinal (adresse de linstruction en mmoire) Ce compteur change au cours de e la ralisation dune instruction pour pointer sur la prochaine instruction ` excuter, la mae a e jorit des instructions ne font quincrmenter ce compteur, les instructions de branchement e e ralisent des oprations plus complexes sur ce compteur : aectation, incrmentation ou e e e dcrmentation plus importantes. e e le registre dadresse les registres de donnes qui sont utiliss pour lire ou crire une donne ` une adresse spcie e e e e a e e en mmoire. e les registres dtat du processeur : (actif, mode (user/system), retenue, vecteur dinterruptions, e etc) les registres dtat du processus droits, adresses, priorits, etc e e Ces registres forment le contexte dunit centrale dun processus. A tout moment, un procese sus est caractris par ces deux contextes : le contexte dunit centrale qui est compos des mmes e e e e e donnes pour tous les processus et le contexte qui dpend du code du programme excut. Pour e e e e
46
Nature de linterruption 0 1 2 3 4 5 horloge disques console autres peripheriques appel system autre interruption

fonction de traitement clockintr diskintr ttyintr devintr sottintr otherintr
Fig. 6.6 Sous UNIX, on trouvera en gnral 6 niveaux dinterruption e e
pouvoir excuter un nouveau processus, il faut pouvoir sauvegarder le contexte dunit centrale e e du processus courant (mot dtat), puis charger le nouveau mot dtat du processus ` excuter. e e a e Cette opration dlicate ralise de faon matrielle est appele commutation de mot dtat. e e e e c e e e Elle doit se faire de faon non interruptible ! Cette Super instruction utilise 2 adresses qui sont c respectivement : ladresse de sauvegarde du mot dtat e ladresse de lecture du nouveau mot dtat e Le compteur ordinal faisant partie du mot dtat, ce changement provoque lexcution dans le e e nouveau processus. Cest le nouveau processus qui devra raliser la sauvegarde du contexte global. En gnral cest e e e le noyau qui ralise cette sauvegarde, le noyau nayant pas un contexte du mme type. e e Le processus interrompu pourra ainsi reprendre exactement o` il avait abandonn. u e Les fonctions setjmp/longjmp permettent de sauvegarder et de rinitialiser le contexte dunit e e central du processus courant, en particulier le pointeur de pile.
6.8
Les interruptions
Une interruption est une commutation de mot dtat provoque par un signal produit par le e e matriel. e Ce signal tant la consquence dun vnement extrieur ou intrieur, il modie ltat dun indie e e e e e e cateur qui est rguli`rement test par lunit centrale. e e e e Une fois que le signal est dtect, il faut dterminer la cause de linterruption. Pour cela on utilise e e e un indicateur, pour les direntes causes, On parle alors du vecteur dinterruptions. e Trois grands types dinterruptions : externes (indpendantes du processus) interventions de loprateur, pannes,etc e e droutements erreur interne du processeur, dbordement, division par zro, page fault etc e e e (causes qui entraine la ralisation dune sauvegarde sur disque de limage mmoire core e e dumped en gnral) e e appels syst`mes demande dentre-sortie par exemple. e e Suivant les machines et les syst`mes un nombre variable de niveaux dinterruption est utilis. e e Ces direntes interruptions ne ralisent pas ncessairement un changement de contexte come e e plet du processus courant. Il est possible que plusieurs niveaux dinterruption soient positionns quand le syst`me les e e consulte. Cest le niveau des direntes interruptions qui va permettre au syst`me de slectionner e e e linterruption ` traiter en priorit. a e Lhorloge est linterruption la plus prioritaire sur un syst`me Unix. e
` 6.9. LE PROBLEME DES CASCADES DINTERRUPTIONS

Systme traitement dinterruption Sauvegarde du contexte du Processus 1 traitement Chargement du contexte du processus 2 Processus 1 interruption Processus 2
47
Acquittement
Commutations dtat
Fig. 6.7 Le traitement dune interruption.
6.9
Le probl`me des cascades dinterruptions e
Si pendant le traitement dune interruption, une autre interruption se produit, et que ceci se rp`te pendant le traitement de la nouvelle interruption, le syst`me ne fait plus progresser les e e e processus ni les interruptions en cours de traitement ... Il est donc ncessaire de pouvoir retarder ou annuler la prise en compte dun ou plusieurs e signaux dinterruptions. Cest le rle des deux mcanismes de masquage et de dsarmement o e e dun niveau dinterruption. Masquer, cest ignorer temporairement un niveau dinterruption. Si ce masquage est fait dans le mot dtat dun traitement dinterruption, ` la nouvelle commue a tation dtat, le masquage dispara ; les interruptions peuvent de nouveau tre prises en compte. e t e Dsarmer, cest rendre le positionnement de linterruption caduque. (Il est clair que ceci ne peut e sappliquer aux droutements). e
6.9.1
Etats et transitions dun processus
Nous nous plaons dans le cas dun syst`me qui utilise un mcanisme de swap pour grer la c e e e mmoire ; nous tudierons ensuite le cas des syst`mes de gestion pagine de la mmoire (les couples e e e e e dtats 3,5 et 4,6 y sont fusionns). e e
6.9.2
Listes des tats dun processus e
1. le processus sexcute en mode utilisateur e 2. le processus sexcute en mode noyau e 3. le processus ne sexcute pas mais est ligible (prt ` sexcuter) e e e a e 4. le processus est endormi en mmoire centrale e 5. le processus est prt mais le swappeur doit le transfrer en mmoire centrale pour le rendre e e e ligible. (ce mode est dirent dans un syst`me ` pagination). e e e a 6. le processus est endormi en zone de swap (sur disque par exemple). 7. le processus passe du mode noyau au mode utilisateur mais est prempt2 et a eectu un e e e changement de contexte pour lire un autre processus. e 8. naissance dun processus, ce processus nest pas encore prt et nest pas endormi, cest ltat e e initial de tous processus sauf le swappeur.
2 Bien que le processus soit prt, il est retir de lunit de traitement pour que les autres processus puissent e e e avancer.
48
Excution en mode utilisateur Appel system interruption Excution en mode noyau gestion interruption exit zombie 9 sleep ordonancement du processus Examiner les signaux 3 wakeup Endormi en mmoire 4 swapout
centrale swap

Examiner et traiter les signaux
Retour au mode utilisateur premption
Prempt
Prt et en mmoire mmoire suffisante
swapout swapin
Cration fork 8 mmoire insuffisante
Endormi 6 en zone de swap
wakeup 5
Prt en zone de swap
Fig. 6.8 Diagramme dtat des processus e 9. zombie le processus vient de raliser un exit, il appara uniquement dans la table des e t processus o` il est conserv le temps pour son processus p`re de rcup`rer le code de retour u e e e e et dautres informations de gestion (cot de lexcution sous forme de temps, et dutilisation u e des ressources ). Ltat zombie est ltat nal des processus, les processus restent dans cet tat jusqu` ce que leur e e e a p`re lise leur valeur de retour (exit status). e
6.10
Lecture du diagramme dtat. e
Le diagramme des transitions dtat permet de dcrire lensemble des tats possibles dun e e e processus. Il est clair que tout processus ne passera pas ncessairement par tous ces dirents e e tats. e La naissance dun processus a lieu dans ltat 8 apr`s lappel syst`me fork excut par un e e e e e autre processus. Il devient au bout dun certain temps prt ` sexcuter. Il passe alors dans e a e ltat excut en mode noyau o` il termine sa partie de lappel syst`me fork. Puis le processus e e e u e termine lappel syst`me et passe dans ltat excut en mode utilisateur. Pass une certaine e e e e e priode de temps (variable dun syst`me ` lautre), lhorloge peut interrompre le processeur. Le e e a processus rentre alors en mode noyau, linterruption est alors ralise avec le processus en mode e e noyau. Au retour de linterruption, le processus peut tre prempt (tant rest tout son quantum de e e e e e temps sur le cpu), cest ` dire, il reste prt ` sexcuter mais un autre processus est lu. Cet tat a e a e e e 7 est logiquement quivalent ` ltat 3, mais il existe pour matrialiser le fait quun processus ne e a e e peut tre prempt quau moment o` il retourne du mode noyau au mode utilisateur. Quand un e e e u processus prempt est rlu, il retourne directement en mode utilisateur. e e ee Un appel syst`me ne peut tre prempt. On peut dtecter en pratique cette r`gle, en eet e e e e e e
6.11. UN EXEMPLE DEXECUTION
49
on constate un ralentissement du dbit de la machine pendant la ralisation dun core de grande e e taille. Quand un processus excute un appel syst`me, il passe du mode utilisateur au mode syst`me. e e e Supposons que lappel syst`me ralise une entre-sortie sur le disque et que le processus doive e e e attendre la n de lentre-sortie. Le processus est mis en sommeil (sleep) et passe dans ltat e e endormi en mmoire. Quand lentre-sortie se termine, une interruption a lieu, le traitement de e e linterruption consistant ` faire passer le processus dans le mode prt ` sexcuter (en mmoire). a e a e e
6.11
Un exemple dexcution e
Plaons-nous dans la situation suivante : lensemble de la mmoire est occup par des processus, c e e mais, le processus le plus prioritaire est un processus dans ltat 5, soit : prt ` sexcuter en e e a e zone de swap. Pour pouvoir excuter ce processus, il faut le placer dans ltat 3, soit : prt ` e e e a sexcuter en mmoire. Pour cela le syst`me doit librer de la mmoire (faire de la place), en e e e e e faisant passer des processus des tats 3 ou 4 en zone de swap (swapout) donc les faire passer dans e les tats 5 et 6. e Cest au swappeur de raliser les deux oprations : e e Slectionner une victime (le processus le plus appropri), pour un transfert hors mmoire e e e centrale (swapout). raliser ce transfert. e une fois quune place susante est libre, le processus qui a provoqu le swapout est charg ee e e en mmoire (swapin). e Le processus a un contrle sur un nombre rduit de transitions : il peut faire un appel syst`me, o e e raliser un exit, raliser un sleep, les autres transitions lui sont dictes par les circonstances. e e e Lappel ` exit() fait passer dans ltat zombie, il est possible de passer ` ltat zombie sans a e a e que le processus ait explicitement appel exit() (` la rception de certains signaux par exemple). e a e Toutes les autres transitions dtat sont slectionnes et ralises par le noyau selon des r`gles bien e e e e e e prcises. Une de ces r`gles est par exemple quun processus en mode noyau ne peut tre prempt3 . e e e e e Certaines de ces r`gles sont dnies par lalgorithme dordonnancement utilis. e e e
6.12
La table des processus
La table des processus est dans la mmoire du noyau. Cest un tableau de structure proc e (<sys/proc.h>). Cette structure contient les informations qui doivent toujours tre accessibles e par le noyau. tat se reporter au diagramme, ce champ permet au noyau de prendre des dcisions sur les e e changements dtat ` eectuer sur le processus. e a adresse de la zone u adresses taille et localisation en mmoire (centrale, secondaire). Ces informations permettent de e transfrer un processus en ou hors mmoire centrale. e e UID propritaire du processus, permet de savoir si le processus est autoris ` envoyer des signaux e ea et ` qui il peut les envoyer. a PID,PPID lidenticateur du processus et de son p`re. Ces deux valeurs sont initialises dans e e ltat 8, cration pendant lappel syst`me fork. e e e v`nement un descripteur de lv`nement attendu quand le processus est dans un mode endormi. e e e e Priorits Plusieurs param`tres sont utiliss par lordonnanceur pour slectionner llu parmi les e e e e e processus prts. e vecteur dinterruption du processus ensemble des signaux reus par le processus mais pas c encore traits. e
3 Exercice
: Donner un exemple.
50
divers des compteurs utiliss pour la comptabilit (pour faire payer le temps CPU utilis) et e e e que lon peut manipuler par la commande alarm, des donnes utilises par limplmentation e e e eective du syst`me, etc. e
6.13
La zone u
La zone u de type struct user dnie dans <sys/user.h> est la zone utilise quand un proe e cessus sexcute que ce soit en mode noyau ou mode utilisateur. Une unique zone u est accessible e a ` la fois : celle de lunique processus en cours dexcution (dans un des tats 1 ou 2). e e Contenu de la zone u : pointeur sur la structure de processus de la table des processus. uid rel et eectif de lutilisateur qui dtermine les divers privil`ges donns au processus, tels e e e e que les droits dacc`s ` un chier, les changements de priorit, etc. e a e Compteurs des temps (users et system) consomms par le processus e Masque de signaux Sur syst`me V sous BSD dans la structure proc e Terminal terminal de contrle du processus si celui-ci existe. o erreur stockage de la derni`re erreur rencontre pendant un appel syst`me. e e e retour stockage de valeur de retour du dernier appel syst`me. e E/S les structures associes aux entres-sorties, les param`tres utiliss par la biblioth`que stane e e e e dard, adresses des buers, tailles et adresses de zones ` copier, etc. a . et / le rpertoire courant et la racine courante (c.f. chroot()) e la table des descripteurs position variable dun implmentation ` lautre. e a
1 limites de la taille des chiers de la mmoire utilisable etc 4 (c.f. ulimit en Bourne shell et limit e en Csh ).
umask masque de cration de chiers. e
6.14
Acc`s aux structures proc et user du processus courant e
Les informations de la table des processus peuvent tre lues grce ` la commande shell ps. Ou e a a par des appels syst`me. Par contre, les informations contenues dans la zone u ne sont accessibles e que par une rponse du processus lui-mme (en progammation objet, on dit que ce sont des vae e riables dinstances prives), do` les appels syst`me suivants : e u e times, chroot, chdir, fchdir, getuid, getgid, ..., setuid, ..., ulimit, nice, brk, sbrk. Qui permettent de lire ou de changer le contenu des deux structures.
6.14.1
Les informations temporelles.
#include <sys/times.h> clock_t times(struct tms *buffer); times remplit la structure pointe par buffer avec des informations sur le temps machine utie lis dans les tat 1 et 2. e e La structure? : struct tms { clock_t clock_t
tms_utime; tms_stime;
/* user time */ /* system time */
` 6.14. ACCES AUX STRUCTURES PROC ET USER DU PROCESSUS COURANT clock_t clock_t }; tms_cutime; tms_cstime; /* user time, children */ /* system time, children */
51
contient des temps indiqus en microsecondes 10-6 secondes, la prcision de lhorloge est par e e defaut sur les HP9000 700/800 de 10 microsecondes.
6.14.2
Changement du rpertoire racine pour un processus. e
#include <unistd.h> int chroot(const char *path); permet de dnir un nouveau point de dpart pour les rfrences absolues (commenant par e e ee c /). La rfrence .. de ce rpertoire racine est associe ` lui-mme, il nest donc pas possible de ee e e a e sortir du sous-arbre dni par chroot. Cet appel est utilis pour rsh et ftp, et les comptes pour e e invits. e Les appels suivants permettent de changer le rpertoire de travail de rfrence . et donc e ee linterprtation des rfrences relatives : e ee int chdir(char *ref); int fchdir(int descripteur);
6.14.3
Rcupration du PID dun processus e e
#include <unistd.h> pid_t getpid(void); pid_t getpgrp(void); pid_t getppid(void); pid_t getpgrp2(pid_t pid); Lappel getpid() retourne le PID du processus courant, getppid le PID du processus p`re, e getpgrp le PID du groupe du processus courant, getpgrp2 le PID du groupe du processus pid (si pid=0 alors quivalent ` getpgrp). e a
6.14.4
Positionement de leuid, ruid et suid
Luid dun processus est lidentication de lutilisateur excutant le processus. Le syst`me e e utilise trois uid qui sont : euid uid eective utilis pour les tests dacc`s. e e ruid uid relle, uid ` qui est factur le temps de calcul. e a e suid uid sauvegarde, pour pouvoir revenir en arri`re apr`s un setuid. e e e #include <unistd.h> int setuid(uid_t uid); int setgid(gid_t gid); Fonctionnement : si euid == 0 (euid de root) les trois uid sont positionns ` la valeur de uid e a sinon si uid est gal ` ruid ou suid alors euid devient uid. ruid et suid ne changent pas. sinon rien ! e a pas de changements. Syntaxe identique pour setgid et gid. La commande setreuid() permet de changer le propitaire rel du processus, elle est utilis e e e pendant le login, seul le super utilisateur peut lexcuter avec succ`s. e e
52
6.15
Tailles limites dun processus
#include <ulimit.h> long ulimit(int cmd,...); La commande cmd est UL GETFSIZE retourne le taille maximum des chiers en blocs. UL SETFSIZE positionne cette valeur avec le deuxi`me argument. e UL GETMAXBRK valeur maximale pour lappel dallocation dynamique de mmoire : brk. e Ces valeurs sont hrites du processus p`re. e e e La valeur FSIZE (taille maximum des chiers sur disques en blocs) peut tre change en ksh e e avec ulimit [n].
6.15.1
Manipulation de la taille dun processus.
#include <unistd.h> int brk(const void *endds); void *sbrk(int incr); Les deux appels permettent de changer la taille du processus. Ladresse manipule par les deux e appels est la premi`re adresse qui est en dehors du processus. Ainsi on ralise des augmentations e e de la taille du processus avec des appels ` sbrk et on utilise les adresses retournes par sbrk pour a e les appels ` brk pour rduire la taille du processus. On utilisera de prfrence pour les appels a e ee ` sbrk des valeurs de incr qui sont des multiples de la taille de page. Le syst`me ralisant des a e e dplacement du point de rupture par nombre entier de pages (ce qui est logique dans un syst`me de e e mmoire pagin). A ne pas utiliser en conjonction avec les fonctions dallocation standard malloc, e e calloc, realloc, free.
6.15.2
Manipulation de la valeur nice
Permet de changer la valeur de nice utilise par le processus. Si lon a des droits privilgis la e e e valeur peut tre ngative. La valeur de nice est toujours comprise entre -20 et +20 sous linux. Seul e e le super utilisateur pouvant utiliser une valeur ngative. e #include <unistd.h> int nice(int valeur); La commande shell renice priorite -p pid -g pgrp -u user permet de changer le nice dun processus actif.
6.15.3
Manipulation de la valeur umask
Lappel umask permet de spcier quels droits doivent tre interdits en cas de cration de e e e chier. cf. 5.1 #include <sys/stat.h> mode_t umask(mode_t mask); la valeur retourne est lancienne valeur. e
` 6.16. LAPPEL SYSTEME FORK
53
6.16
pid_t
Lappel syst`me fork e

fork(void);
lappel syst`me fork permet le cration dun processus clne du processus courrant. e e o
DEUX valeurs de retour en cas de succ`s : e Dans le processus p`re valeur de retour = le PID du ls, e Dans le processus ls valeur de retour = zro. e Sinon Dans le processus p`re valeur de retour = -1. e Les PID et PPID sont les seules informations direntes entre les deux processus. e
6.17
Lappel syst`me exec e
#include <unistd.h> extern char **environ; int execl( const char *path, const char *arg0, ...,NULL); int execv(const char *path, char * const argv[]); int execle( const char *path, const char *arg0, ...,NULL,
char * const envp[]);
int execve(const char *file, char * const argv[], char * const envp[]); int execlp( const char *file,const char *arg0, ... , NULL ); int execvp(const char *file, char * const argv[]); Informations conserves par le processus : PID PPID PGID ruid suid (pour leuid cf le e setuidbit de chmod ), nice, groupe dacc`s, catalogue courant, catalogue /, terminal de e contrle, utilisation et limites des ressources (temps machine, mmoire, etc), umask, masques o e des signaux, signaux en attente, table des descripteurs de chiers, verrous, session. Quand le processus excute dans le nouvel excutable la fonction : e e main(int argc, char **argv,char **envp) argv et env sont ceux qui ont t utiliss dans lappel de execve. ee e Les dirents noms des fonction exec sont des mnmoniques : e e l liste darguments v arguments sont forme dun vecteur. p recherche du chier avec la variable denvironnement PATH. e transmission dun environnement en dernier param`tre, en remplacement de lenvironnement e courant.
54
Chapitre 7
Lordonnancement des processus

La slection dans le temps des processus pouvant acc`der ` une ressource est un probl`me dit e e a e dordonnancement. Nous prsentons ici : e le cas gnral e e les besoins et les probl`mes e et nous dcrirons des solutions que lon trouve sous UNIX pour dirents probl`mes dordonnane e e cement. Les algorithmes dordonnancement ralisent la slection parmi les processus actifs de celui e e qui va obtenir lutilisation dune ressource, que ce soit lunit centrale, ou bien un priphrique e e e dentre-sortie. e Pour lunit centrale notre but est de maximiser dbit et taux utile de lunit centrale : e e e le dbit est le nombre moyen de processus excuts en un temps donn. e e e e le taux utile est la proportion de temps rellement utilise pour excuter des processus utilisae e e teurs. Un exemple : Soient 2 processus A et B de mme comportement 30 priodes de deux seconde : e e 1 seconde dactivit e 1 seconde dinactivit e AIAIAIAIAIAIAIAIAIAIAIAIAIAIAIAIAIAIAI Si lon excute les deux processus conscutivement on obtient un dbit de 1 processus par e e e minute, et un taux utile de 50%. Si lon entrelace les priodes actives et inactives des deux processus e on obtient un dbit de 2 processus par minute et un taux dutilisation de 100%. e Pour une autre ressource dautres crit`res seront utiliss. e e
7.1
Le partage de lunit centrale e
Ce partage doit tre fait non seulement entre les processus utilisateurs mais aussi entre les e direntes tches du syst`me, scheduler, entres-sorties, gestion des interruptions, etc. e a e e Nous demandons de plus ` lalgorithme dordonnancement de nous assurer lexclusion mua tuelle et labsence de famine, qui sont les points-clefs de la plupart des probl`mes dordonnane cement. Linvention dun algorithme dordonnancement se base en gnrale sur des remarques e e statistique sur le comportement des processus : Le couple UC/ES (cpu/io), les processus ont tendance ` basculer constamment entre des a phases dentres-sorties et des phases de calcul sur lunit centrale. e e Les processus consommant de longues priodes dU.C. sont proportionnellement rares. e 55
56
CHAPITRE 7. LORDONNANCEMENT DES PROCESSUS
200
150
100
50
0 1 4 8 12 16 20 24
Fig. 7.1 Histogramme de rpartition de la dure de la priode dutilisation de lunit centrale e e e e

A long terme A court terme
ligibles pour lU.C.
U.C.
E/S
Files (FIFO) des priphriques dentres/sorties
Fig. 7.2 Stratgie globale dordonnancement. e
7.1.1
Famine
Notre premi`re tche est daecter une ressource (lUC par exemple) ` un unique processus ` e a a a la fois (exclusion mutuelle) et sassurer de labsence de famine. famine : un processus peut se voir refuser lacc`s ` une ressource pendant un temps indtermin, e a e e il est dit alors que le processus est en famine. Un syst`me qui ne cre pas de cas de famine : fournira toujours la ressource demande par un e e e processus, au bout dun temps ni. Si on prend le cas des priphriques (tels que les disques) lordonnancement peut se faire de e e faon simple avec par exemple une le dattente (FIFO). c Pour lunit centrale on va devoir utiliser des structures de donnes plus complexes car nous e e allons avoir besoin de grer des priorits. Cest par exemple, autoriser lexistence de processus qui e e vitent la le dattente. La structure de donnes utilise peut parfaitement tre une le, une liste, e e e e un arbre ou un tas, ceci en fonction de llment-clef de notre algorithme de slection (ge, priorit ee e a e simple, priorit ` plusieurs niveaux, etc). ea Cette structure de donnes doit nous permettre daccder ` tous les processus prts (ligibles). e e a e e
7.1.2
Stratgie globale e
On peut reprsenter lordonnancement global avec le schma 7.2 e e Les ordonnancements ` court terme doivent tre tr`s rapides, en eet le processus lu ne va a e e e utiliser lunit centrale que pendant un tr`s court laps de temps ( 10 milli-secondes par exemple). e e
7.2. ORDONNANCEMENT SANS PREEMPTION.
57
Si on utilise trop de temps (1 milli-seconde) pour slectionner cet lu, le taux utile dcro tr`s e e e t e rapidement (ici on perd 9% du temps dunit centrale). e Par contre lordonnancement ` long terme peut tre plus long car il a lieu moins souvent (toutes a e les secondes par exemple). La conception de lordonnanceur ` long terme est faite dans loptique a dobtenir un ordonnanceur ` court terme rapide. a
7.1.3
Crit`res de performance e
Les crit`res de performance des algorithmes dordonnancement e Taux dutilisation de lunit centrale e Dbit e Temps rel dexcution e e Temps dattente Temps de rponse e Ces cinq crit`res sont plus ou moins mutuellement exclusifs. e Les comparaisons des dirents algorithmes se fait donc sur une slection de ces crit`res. e e e
7.2
Ordonnancement sans premption. e
FCFS : First Come First served Facile ` crire et ` comprendre, peu ecace ... ae a SJF : Shortest Job First le plus petit en premier. Optimal pour le temps dattente moyen ... A priorit : e Lutilisateur donne des priorits aux dirents processus et ils sont activs en fonction de e e e cette priorit. e probl`me famine possible des processus peu prioritaires e Solution faire augmenter la priorit avec le temps dattente : e plus un processus attend, plus sa priorit augmente ainsi au bout dun certain temps le e processus devient ncessairement le plus prioritaire. e re-probl`me si le processus en question (le tr`s vieux tr`s gros) est excut alors que de e e e e e nombreux utilisateurs sont en mode interactif chute catastrophique du temps de rponse et e du dbit e solution premption. e La premption est la possibilit qua le syst`me de reprendre une ressource ` un processus sans e e e a que celui-ci ait libr cette ressource. ee Ceci est impossible sur bon nombre de ressources. Lesquelles ?
7.3
Les algorithmes premptifs e
FCFS ne peut tre premptif ... e e SJF peut tre premptif : si un processus plus court que le processus actif arrive dans la queue, e e le processus actif est prempt. e e Dans des syst`mes interactifs en temps partag un des crit`res est le temps de rponse, cest ` e e e e a dire que chaque utilisateur dispose de lunit centrale rguli`rement. Heureusement, les processus e e e interactifs utilisent lUC pendant de tr`s courts intervalles ` chaque fois. e a
58
7.3.1
Round Robin (tourniquet)
Cet algorithme est spcialement adapt aux syst`mes en temps partag. e e e e On dnit un quantum de temps (time quantum) dutilisation de lunit centrale. e e La le dattente des processus ligibles est vue comme une queue circulaire (fo circulaire). e Tout nouveau processus est plac ` la n de la liste. ea De deux choses lune, soit le processus actif rend lUnit Centrale avant la n de sa tranche de e temps (pour cause dentre/sortie) soit il est prempt, et dans les deux cas plac en n de liste. e e e e Un processus obtiendra le processeur au bout de (n -1)*q secondes au plus (n nombre de processus et q longueur du quantum de temps), la famine est donc assurment vite. e e e Remarquons que si le quantum de temps est trop grand, round-robin devient quivalent ` FCFS. e a De lautre cot si le quantum de temps est tr`s court, nous avons thoriquement un processeur n e e e fois moins rapide pour chaque processus (n nombre de processus). Malheureusement si le quantum de temps est court, le nombre de changements de contexte ds u ` la premption grandit, do` une diminution du taux utile, do` un processeur virtuel tr`s lent. a e u u e Une r`gle empirique est dutiliser un quantum de temps tel que 80 pourcent des processus e interrompent naturellement leur utilisation de lunit centrale avant lexpiration du quantum de e temps.
7.3.2
Les algorithmes ` queues multiples a
Nous supposons que nous avons un moyen de direncier facilement les processus en plusieurs e classes de priorit direntes (cest le cas sous UNIX o` nous allons direncier les tches syst`me, e e u e a e comme le swappeur, des autres tches). a Pour slectionner un processus, le scheduler parcourt successivement les queues dans lordre e dcroissant des priorits. e e Un exemple de queues organises en fonction du contenu des processus : e les processus syst`mes e les processus interactifs les processus dition e les processus gros calcul les processus des tudiants e pour quun processus tudiant soit excut il faut que toutes les autres les dattente soient vides ... e e e Une autre possibilit est de partager les quantums de temps sur les direntes queues. e e Il est aussi possible de raliser dirents algorithmes de scheduling sur les direntes queues : e e e Round Robin sur les processus interactifs FCFS sur les gros calculs en tche de fond. a
7.4
Multi-level-feedback round robin Queues
Le syst`me dordonnancement des processus sous UNIX (BSD 4.3 et system V4) utilise plue sieurs les dattente qui vont matrialiser des niveaux de priorit dirents et ` lintrieur de ces e e e a e dirents niveaux de priorit, un syst`me de tourniquet. e e e
7.4.1
Les niveaux de priorit e
Le scheduler parcourt les listes une par une de haut en bas jusqu` trouver une liste contenant a un processus ligible. Ainsi tant quil y a des processus de catgorie suprieure ` excuter les autres e e e a e processus sont en attente de lunit centrale. e
7.4. MULTI-LEVEL-FEEDBACK ROUND ROBIN QUEUES
59
Interne au Noyau
non interruptibles
swapper Disk I/O Buffer Inode tty input tty output enfants
interruptibles
priorit limite
Attentes de :
niveau 0 niveau 1
Utilisateurs
niveau N
Fig. 7.3 Les queues multiples en tourniquet Dans les listes internes au noyau, de simples les dattente sont utilises avec la possibilit de e e doubler les processus endormis de la mme liste (en eet seul le processus rveill par la n de son e e e entre/sortie est ligible). e e Pour les processus utilisateurs, la mme r`gle est utilise mais avec premption et la r`gle du e e e e e tourniquet. Cest ` dire, on calcul une priorit de base qui est utilise pour placer le processus dans la a e e bonne le dattente. Un processus qui utilise lunit centrale voit augmenter sa priorit. e e Un processus qui lib`re lunit centrale pour demander une entre/sortie ne voit pas sa priorit e e e e changer. Un processus qui utilise tout sont quantum de temps est prempt et plac dans une nouvelle le e e e dattente. Attention : plus la priorit est grande moins le processus est prioritaire. e
7.4.2
Evolution de la priorit e
Regardons la priorit et lvolution de la priorit dun processus utilisateur au cours du temps. e e e Les fonctions suivantes sont utilises dans une implmentation BSD. e e Pour calculer la priorit dun processus utilisateur, le scheduler utilise lquation suivante qui e e est calcule tous les 4 clicks horloge (valeur pratique empirique) : e P usrpri = PUSER + P cpu + 2 P nice 4
cette valeur est tronque ` lintervalle PUSER..127. En fonction de cette valeur le processus e a est plac dans une des listes correspondant ` son niveau courant de priorit. e a e Ceci nous donne une priorit qui diminue linairement en fonction de lutilisation de lunit e e e centrale (il advient donc un moment o` le processus devient le processus le plus prioritaire !). u P nice est une valeur spcie par le programmeur grce ` lappel syst`me nice. Elle varie entre e e a a e -20 et +20 et seul le super utilisateur peut spcier une valeur ngative. e e P cpu donne une estimation du temps pass par un processus sur lunit centrale. A chaque click e e e e e dhorloge, la variable p cpu du processus actif est incrmente. Ce qui permet de matrialiser la
60
consommation dunit central du processus. Pour que cette valeur ne devienne pas trop pnalisante e e sur le long terme (comme pour un shell) elle est attnue toute les secondes grce ` la formule e e a a suivante : P cpu = 2 load P cpu + P nice 2 load + 1
la valeur de load (la charge) est calcule sur une moyenne du nombre de processus actifs e pendant une minute. Pour ne pas utiliser trop de ressources, les processus qui sont en sommeil (sleep) voient leur P cpu recalcul uniquement ` la n de leur priode de sommeil grce ` la formule : e a e a a P cpu = 2 load 2 load + 1
sleep time
P cpu
la variable sleep time tant initialise ` zro puis incrmente une fois par seconde. e e a e e e
7.4.3
Les classes de priorit e
La priorit des processus en mode syst`me dpend de laction ` raliser. e e e a e PSWAP 0 priorit en cours de swap e PINOD 10 priorit en attendant une lecture dinformation sur le syst`me de chiers e e PRIBIO 20 priorit en attente dune lecture/criture sur disque e e PZERO 25 priorit limite e PWAIT 30 priorit dattente de base e PLOCK 35 priorit dattente sur un verrou e PSLEP 40 priorit dattente dun v`nement e e e PUSER 50 priorit de base pour les processus en mode utilisateur e Le choix de lordre de ces priorits est tr`s important, en eet un mauvais choix peut entra e e ner une diminution importante des performances du syst`me. e Il vaut mieux que les processus en attente dun disque soient plus prioritaires que les processus en attente dun buer, car les premiers risquent fort de librer un buer apr`s leur acc`s disque e e e (de plus il est possible que ce soit exactement le buer attendu par le deuxi`me processus). Si la e priorit tait inverse, il deviendrait possible davoir un interblocage ou une attente tr`s longue si ee e le syst`me est bloqu par ailleurs. e e De la mme faons, le swappeur doit tre le plus prioritaire et non interruptible Si un e c e processus est plus prioritaire que le swappeur et quil doit tre swapp en mmoire ... e e e En Demand-Paging le swappeur est aussi le processus qui ralise les chargements de page, ce e processus doit tre le plus prioritaire. e
Chapitre 8
La mmoire e
8.0.4 les mmoires e
La mmoire dun ordinateur se dcompose en plusieurs lments, dont le prix et le temps e e ee dacc`s sont tr`s variables, cf gure 8.1. Nous dvelopperons dans ce chapitre et le suivant les e e e questions et solutions relatives ` la mmoire centrale. a e Limportance de la gestion de la mmoire centrale vient de son cot et du cot relatif des e u u autres formes de stockage, la gure 8.2 donne une ide des caractristiques relatives des dirents e e e types de stockage.
8.0.5
La mmoire centrale e
La mmoire est un tableau ` une dimension de mots machines (ou doctets), chacun ayant une e a adresse propre. Les changes avec lextrieur se font en gnral par des lectures ou des critures ` e e e e e a des adresses spciques. e Le syst`me Unix est multi-tche,ceci pour maximiser lutilisation du cpu. Cette technique e a pose comme condition obligatoire que la mmoire centrale soit utilise et/ou partage entre les e e e direntes tches. e a Les solutions de gestion de la mmoire sont tr`s dpendantes du matriel et ont mis longtemps e e e e ` voluer vers les solutions actuelles. Nous allons voir plusieurs approches qui peuvent servir dans ae des situations particuli`res . e La mmoire est le point central dans un syst`me dexploitation, cest ` travers elle que lunit e e a e centrale communique avec lextrieur. e
Registres Mmoire cache Mmoire centrale Disques
Mmoire volatile
Cot par bit croissant vitesse daccs croissant capacit de stockage dcroissante
Mmoire permanente
Bandes magntiques
Fig. 8.1 Hirarchie de mmoires e e 61
62
CHAPITRE 8. LA MEMOIRE
CARACTERISTIQUES DES TYPES DE MEMOIRES
TYPE DE MEMOIRE CACHE
TAILLE (Octets) 103-104
TEMPS DACCES (secondes) 10-8
COUT RELATIF PAR BIT 10
MEMOIRE CENTRALE
106-107
10-7
DISQUE
108-109
10-3-10-2
10-2-10-3
BANDE
108-109
10-102
10-4
Fig. 8.2 Caractristiques relatives des mmoires. e e
64Kilos octets utilisateurs
FFFF
Fig. 8.3 Une mmoire de 64 Kilo Octets. e
8.1. ALLOCATION CONTIGUE

0 Registre Barrire le noyau (moniteur)
63
un programme utilisateur
FFFF
Fig. 8.4 Protection du moniteur par un registre barri`re. e
8.1
8.1.1
Allocation contigu e
Pas de gestion de la mmoire e
Pas de gestion de la mmoire ! Cette mthode, qui a lavantage de la simplicit et de la rapidit, e e e e permet toute libert quand ` lutilisation de la mmoire. En eet, toute adresse est accessible, et e a e peut tre utilise pour nimporte quelle tche. Le dsavantage : aucune fonctionnalit, tout doit e e a e e tre reprogramm, typiquement il ny pas de syst`me dexploitation ! e e e
8.1.2
Le moniteur rsidant e
On cherche ` protger le noyau des interfrences possibles de la part des utilisateurs. Pour cela, a e e toute adresse dinstruction ou de donne manipule par un programme utilisateur est compare ` e e e a un registre barri`re (fence register). e Tant que ladresse est suprieure ` la barri`re, ladresse est lgale, sinon ladresse est une e a e e rfrence illgale au moniteur et une interruption est mise (invalid adress). ee e e Cette mthode demande que pour tout acc`s ` la mmoire une vrication de la validit de e e a e e e ladresse soit ralise. Ceci ralentit toute excution dun acc`s mmoire. (Paterson donne comme e e e e e exemple de ralentissement des temps de 980 nanosecondes sans vrication et 995 nanosecondes e avec vrication). Globalement ce temps supplmentaire peut tre oubli. e e e e
8.1.3
Le registre barri`re e
Limplmentation dun tel mcanisme doit tre ralise de faon matrielle. e e e e e c e La valeur du registre barri`re est parfois ralise de faon xe sur une machine, ce qui pose des e e e c probl`mes d`s que lon veut changer le noyau et/ou protger plus de mmoire (voir DOS). e e e e
8.1.4
Le registre base
Le mcanisme suivant est une notion plus utile et plus ergonomique pour dcrire la zone e e dadressage dun programme, et utile pour rsoudre le probl`me de dplacement des programmes e e e en mmoire (relocation). e En eet, du fait que lon utilise un registre barri`re, les adresses utilisables de la mmoire ne e e commencent plus ` 0000, alors que lutilisateur veut continuer ` utiliser des adresses logiques qui a a commencent ` 0000. a
64
Registre Barrire
unit centrale
A < Barrire oui Intruption
non
mmoire
Fig. 8.5 Implmentation du registre Barri`re. e e
Registre Base 1400
unit centrale
+ 0346 1746
mmoire
Fig. 8.6 Implmentation du registre de Base. e
0 le noyau (moniteur)
Registre Barrire
un programme utilisateur
FFFF
Fig. 8.7 Positionnement dun processus par un registre de Base.
8.1. ALLOCATION CONTIGUE

Moniteur
Barrire
65
1 swap out Zone utilisateur
P1
P2 2 swap in
Fig. 8.8 Un syst`me de swap utilisant uniquement un registre barri`re. e e Pour continuer ` fournir cette possibilit le registre barri`re est transform en registre de base a e e e (relocation) . A chaque utilisation dune adresse logique du programme, on ajoute ` cette adresse a la valeur du registre de base pour trouver ladresse physique. Lutilisateur ne conna plus les t adresses physiques. Il travaille uniquement avec des adresses logiques (xdb). Le moniteur a videmment une valeur nulle pour son registre de base et donc peut adresser e toute la mmoire. Le changement de la valeur du registre de base se fait de faon protge en e c e e mode moniteur. Ces deux syst`mes de protection de la mmoire sont clairement mono-processus. Seul le moe e niteur peut tre protg par ces mcanismes, il nest pas possible de protger les processus entre e e e e e eux.
8.1.5
Le swap
Il est possible avec les registres barri`re ou les registres de base dcrire des syst`mes temps e e e partag, en utilisant le mcanisme de swap (change). e e e Swapper, cest changer le contenu de la mmoire centrale avec le contenu dune mmoire e e e secondaire. Par extension swapper devient laction de dplacer une zone mmoire de la mmoire e e e vers le support de swap (en gnral un disque) ou rciproquement du priphrique de swap vers e e e e e la mmoire. e Le syst`me va raliser cet change ` chaque changement de contexte. Les syst`mes de swap e e e a e utilisent une mmoire secondaire qui est en gnral un disque mais on peut utiliser dautre supports e e e secondaires plus lents ou plus rapides comme des bandes ou mmoires secondaires (non accessibles e par lunit de traitement). e
8.1.6
Le co t du swap u
Sur un tel syst`me, le temps de commutation de tches est tr`s important. Il est donc ncessaire e a e e que chaque processus reste possesseur de lunit de traitement un temps susamment long pour e que le ralentissement d au swap ne soit pas trop sensible. Que ce passe-t-il sinon ? Le syst`me u e utilise la majeure partie de ses ressources ` dplacer des processus en et hors mmoire centrale. a e e Lunit de traitement nest plus utilise au maximum ... e e
8.1.7
Utilisation de la taille des processus
Pour amliorer les mcanismes de swap, on remarque que le temps de swap est proportionnel ` e e a la taille des donnes ` dplacer. Pour amliorer les performances, il faut donc introduire la notion e a e e
66
Bas Haut
unit centrale
A < Bas oui Interruption
non
A > Haut oui Interruption
non
mmoire
Fig. 8.9 Double registre barri`re. e de taille eective dun processus, ce qui permet damliorer le dbit mais cela impose que toutes e e les augmentations ou rductions de taille dun processus utilisateur soient ralise par un appel e e e syst`me (sbrk) an que le noyau connaisse ` tout moment la taille relle de chaque processus. e a e
8.1.8
Swap et excutions concurrentes e
Une autre approche tr`s ecace est de raliser le swap pendant lexcution dun autre processus. e e e Mais avec le syst`me de registres de relocation cest dangereux. En eet nous ne pouvons pas e assurer quun processus utilisateur donn ne va pas crire dans les adresses rserves ` un autre e e e e a processus.
8.1.9
Contraintes
Le swap introduit dautres contraintes : un processus doit tre en prempt actif pour tre e e e e swapp, cest ` dire ntre en attente daucune entre-sortie. En eet, si P1 demande une E/S et e a e e pendant cette demande il y a change de P1 et P2, alors la lecture demande par P1 a lieu dans e e les donnes de P2. e
8.1.10
Deux solutions existent
Soit ne jamais swapper de processus en attente dentres-sorties. Soit raliser toutes les entrese e e sorties dans des buers internes au noyau (solution UNIX), ce qui a pour cot une recopie mmoire u e a e ` mmoire supplmentaire par E/S. Les transferts entre le noyau et le processus ayant lieu unie quement quand le processus est en mmoire. e
8.1.11
Les probl`mes de protection e
Nous venons dapercevoir des probl`mes de protection entre un processus et le noyau. Si lon e autorise plusieurs processus ` rsider en mmoire en mme temps, il nous faut un mcanisme de a e e e e protection inter-processus. Deux mthodes sont couramment utilises : les extensions du registre barri`re et du registre de e e e base (relocation).
8.1.12
Les registres doubles
Deux registres Barri`re Bas et Haut e Si Adresse < Bas lever une exception erreur dadresse Si Adresse >= Haut lever une exception erreur dadresse Sinon adresse correcte. Deux registres de relocation Base et Limit, on travaille avec des adresses logiques Limit donne la valeur maximale dune adresse logique et Base donne la position en mmoire de ladresse logique e
8.2. ORDONNANCEMENT EN MEMOIRE DES PROCESSUS

limite Base
67
unit centrale
A > limite oui Interruption
non
mmoire
Fig. 8.10 Base et Limite.

0 300k 500k 600k Moniteur p1 p2 0 300k 500k 600k 800k 1000k 1200k 1500k 1900k 2100k Initial p4 1900k 2100k Dplacement : 600k 2100k Dplacement : 400k 2100k p3 p3 1200k Moniteur p1 p2 p3 p4 1000k 1200k 1500k p4 0 300k 500k 600k Moniteur p1 p2 p4 p3 0 300k 500k 600k Moniteur p1 p2
Dplacement : 200k
Fig. 8.11 Une situation dordonnancement de processus en mmoire. e zro. e Si Adresse >= Limit lever une exception erreur dadresse sinon utiliser ladresse physique Adresse+Base.
8.2
Ordonnancement en mmoire des processus e
Les choix de limplmentation des mcanismes dadressage inuence normment lordonnane e e e cement des processus. Nous travaillons dans le cas dun syst`me de traitement par lots cest ` dire en temps partag e a e mais les processus restent en mmoire tout le temps de leur excution. Sil ny a plus de place le e e processus est mis en attente (i.e. non charg en mmoire). e e Nous devons rsoudre le probl`me suivant : il nous faut un algorithme pour choisir dynamie e quement, parmi les blocs libres de la mmoire centrale, celui qui va recevoir le nouveau processus e (algorithme dallocation de mmoire ` un processus). On reconna en gnral trois mthodes : e a t e e e First-t Le premier bloc susamment grand pour contenir notre processus est choisi. Best-t Le plus petit bloc susamment grand pour contenir notre processus est choisi. Worst-t Le bloc qui nous laisse le plus grand morceau de mmoire libre est choisi (le plus grand e bloc). De nombreuse expriences pratiques et des simulations ont montr que le meilleur est rst-t e e puis best-t et que ces deux algorithmes sont beaucoup plus ecaces que worst-t. Compactage On cherche ` amliorer ces mcanismes en dfragmentant la mmoire cest ` dire en dplaant les a e e e e a e c processus en mmoire de faon ` rendre contigus les zones de mmoire libre de faon ` pouvoir e c a e e c a les utiliser.
68
0
Moniteur
0
Moniteur
40k
P5
40k
P5
90k 100k
P4
90k
P4
160k 170k 200k

P3 P3
190k Zone contigu de 66k 256k
230k 256k
Fig. 8.12 Compactage

0
Moniteur
0
Moniteur
0
Moniteur
0
Moniteur
0
Moniteur
40k
P1
40k
P1
40k
P1
40k
40k
P5
100k
P2
100k
100k
P4
100k
P4
90k 100k
P4
170k 200k
P3
170k 200k
P3 P3
170k 200k
P3
200k
P3
200k 230k 256k
230k 256k
230k 256k
230k
230k 256k
256k
Fig. 8.13 Plusieurs dplacements possibles. e
8.3
8.3.1
Allocation non-contigu e
Les pages et la pagination
Pour acclrer ces mcanismes dallocation, la notion de page a t introduite. ee e ee On va dcouper la mmoire et les processus en pages. Grce ` ce syst`me, il ne sera plus e e a a e ncessaire de placer les processus dans une zone contige de la mmoire. Il devient possible dallouer e u e de la mmoire ` un processus sans avoir ` raliser de compactage ! e a a e Ce principe des page ncessite de nouvelles possibilits matrielles. Toute adresse est maintee e e nant considre comme un couple ee (Numro de page, Position dans la page) e A : adresse logique, P : taille de page Numro de page = A div P e Position = A modulo P
8.3.2
Ordonnancement des processus dans une mmoire pagine e e
Le choix de lorganisation mmoire a une inuence prpondrante sur lordonnancement des e e e processus, qui devient beaucoup plus indpendant de la mmoire quand celle-ci est pagine. e e e Le dsavantage de la mthode de gestion de mmoire par un mcanisme de page est le phnom`ne e e e e e e de fragmentation interne. On alloue une page enti`re alors que le processus ne lutilise quen e partie. Mais la taille des mmoires et des processus deviennent tels par rapport aux tailles de page e que cette perte devient minime.
8.3. ALLOCATION NON-CONTIGUE

Adresse logique unit centrale p d Adresse physique d mmoire
69
p f
Table des pages
Fig. 8.14 Calcul dune adresse avec la table des pages
page 0 page 1 page 2 page 3 mmoire logique
0 1 2 3
1 4 3 7
Table des pages
0 1 page 0 2 3 page 2 4 page 1 5 6 7 page 3 mmoire physique
Fig. 8.15 La mmoire logique et la Table des pages. e Un avantage des pages est une plus grande simplicit du partage de la mmoire entre dirents e e e processus. En particulier quand plusieurs processus partagent le mme code. La page qui contient e du code utilis par les processus sera partageable et protge en criture. e e e e Sous Unix le compilateur produit automatiquement des programmes dont la partie code est partageable.
8.3.3
Comment protger la mmoire pagine e e e
Les protections dacc`s sont faites au niveau de la table des pages. e On a une table des pages globale. Cest donc le syst`me qui alloue les pages ` un processus, e a qui par construction (du syst`me de pagination) ne peut pas crire en dehors de ses propres pages. e e De plus, dans la table des pages dun processus, des drapeaux indiquent le type de page (droits dacc`s en lecture/criture/excution). e e e
8.3.4
La mmoire segmente e e
Nous venons de voir que les adresses logiques utilises par le programmeur sont direntes des e e adresses physiques. La mmoire segmente est une organisation de la mmoire qui respecte le comportement usuel e e e des programmeurs, qui gnralement voient la mmoire comme un ensemble de tableaux distincts e e e contenant des informations de types dirents. Un segment pour chaque type : donnes, code, table e e des symboles, librairies etc. Ces direntes zones ayant des tailles varies, et parfois variables au e e cours du temps (le tas par exemple).
70
Table des segments Adresse logique unit centrale p d
b b
Adresse physique d mmoire
d<l non
oui
interruption erreur dadresse
Fig. 8.16 Mmoire segmente e e La mmoire segmente non pagine pose des probl`mes de compactage (dfragmentation). La e e e e e stratgie idale est : la mmoire en segments pagins. e e e e
Chapitre 9
La mmoire virtuelle e
Les mthodes de gestion mmoire que nous venons de voir ont toutes un dfaut majeur qui est e e e de garder lensemble du processus en mmoire, ce qui donne : e un cot en swap important u Impossibilit de crer de tr`s gros processus. e e e Les mthodes de mmoire virtuelle permettent dexcuter un programme qui ne tient pas enti`rement e e e e en mmoire centrale ! e Nous avons commenc par prsenter des algorithmes de gestion de la mmoire qui utilisent le e e e concept de base suivant : lensemble de lespace logique adressable dun processus doit tre en mmoire pour pouvoir excuter e e e le processus. Cette restriction semble ` la fois raisonnable et ncessaire, mais aussi tr`s dommageable car a e e cela limite la taille des processus ` la taille de la mmoire physique. a e Or si lon regarde des programmes tr`s standards, on voit que : e il y des portions de code qui g`rent des cas tr`s inhabituels qui ont lieu tr`s rarement (si ils e e e ont lieu) les tableaux, les listes et autres tables sont en gnral initialiss ` des tailles beaucoup plus e e e a grandes que ce qui est rellement utile e Certaines options dapplication sont tr`s rarement utilises e e Mme dans le cas o` le programme en entier doit rsider en mmoire, tout nest peut-tre pas e u e e e absolument ncessaire en mme temps. e e Avec la mmoire virtuelle, la mmoire logique devient beaucoup plus grande que la mmoire e e e physique. De nombreux avantages : Comme les utilisateurs consomment individuellement moins de mmoire, plus dutilisateurs peuvent e travailler en mme temps. Avec laugmentation de lutilisation du CPU et de dbit que cela ime e plique (mais pas daugmentation de la vitesse). Moins dentres-sorties sont eectues pour lexcution dun processus, ce qui fait que le proe e e cessus sexcute (temps rel) plus rapidement. e e
9.0.5
Les overlays
Une des premi`res versions dexcutables partiellement en mmoire est celle des overlay qui e e e est lide de charger successivement des portions disjointes et direntes de code en mmoire, e e e excutes lune apr`s lautre. e e e Les direntes passes dun compilateur sont souvent ralises en utilisant un overlay (prprocesseurs, e e e e pass1, pass2, pour les compilateurs C). 71
72
CHAPITRE 9. LA MEMOIRE VIRTUELLE
Les overlay ncessitent quelques adaptations de lditeur de liens et des mcanismes de relocae e e tion.
9.0.6
Le chargement dynamique
Un autre syst`me couramment utilis dans les logiciels du march des micros est le chargement e e e dynamique. Avec le chargement dynamique, une fonction nest charge en mmoire quau moment e e de son appel. Le chargement dynamique demande que toutes les fonctions soient repositionnables en mmoire de faon indpendante. e c e A chaque appel de fonction on regarde si la fonction est en mmoire sinon un diteur de liens e e dynamique est appel pour la charger. e Dans les deux cas (overlay et chargement dynamique), le syst`me joue un rle tr`s restreint, il e o e sut en eet davoir un bon syst`me de gestion de chiers. e Malheureusement, le travail que doit raliser le programmeur pour choisir les overlays et/ou e installer un mcanisme de chargement dynamique ecace est non trivial et requiert que le proe grammeur ait une parfaite connaissance du programme. Ceci nous am`ne aux techniques automatiques. e
9.1
Demand Paging
La mthode de Demand Paging est la plus rpandue des implmentations de mmoire vire e e e tuelle, elle demande de nombreuse capacits matrielles. e e Nous partons dun syst`me de swap o` la mmoire est dcoupe en pages. Comme pour le e u e e e swap, quand un programme doit tre excut nous le chargeons en mmoire (swap in) mais au lieu e e e e de faire un swap complet, on utilise un swappeur paresseux (lazy swapper). Un swappeur paresseux charge une page uniquement si elle est ncessaire. e Que ce passe-t-il quand le programme essaie daccder ` une page qui est hors mmoire ? e a e le matriel va traduire ladresse logique en une adresse physique grce ` la table des pages. e a a tant que les pages demandes sont en mmoire, le programme tourne normalement, sinon si e e la page est contenue dans lespace des adresses logiques mais nest pas charge, il y a une e page fault. En gnral, une erreur dadresse est de ` une tentative dacc`s ` une adresse extrieure e e u a e a e (invalide). Dans ce cas, le programme doit tre interrompu, cest le comportement normal dun e syst`me de swap. e Mais il est possible avec un swappeur paresseux que la page existe mais ne soit pas en mmoire e centrale, do` les tapes suivantes dans ce cas : u e On peut faire dmarrer un processus sans aucune page en mmoire. La premi`re Page Fault e e e aurait lieu ` la lecture de la premi`re instruction (linstruction ntant pas en mmoire). a e e e Il faut raliser une forme spciale de sauvegarde de contexte, il faut garder une image de ltat e e e du processus qui vient deectuer une Page Fault mais de plus il faudra redmarrer (rexcuter) e e e linstruction qui a plac le processus dans cet tat, en eet il est possible que linstruction ne se e e soit pas termin par manque de donnes. e e Le syst`me dexploitation a ici un rle important, cest lui qui va raliser le chargement de la e o e page manquante puis relancer le processus et linstruction. Les circuits ncessaires ` la mthode de Demande Paging sont les mmes que ceux que lon e a e e utilise pour un syst`me de swap pagin, cest-`-dire une mmoire secondaire et un gestionnaire de e e a e pages (table des pages). Par contre, la partie logicielle est beaucoup plus importante. Enn il faut que les instructions soient interruptibles, ce qui nest pas toujours le cas sur tous les processeurs et ce qui est fondamental, comme nous allons le voir sur des exemples : add A,B in C
9.1. DEMAND PAGING

3 la page existe en zone de swap
73
noyau 1 rfrence load M 6 relancer linstruction table des pages disque de swap 4 swap in de la page fautive ... 2 interruption
5 mise jours de la table des page du P. mmoire
Fig. 9.1 Etapes de la gestion dune erreur de page 1. chercher et dcoder linstruction add e 2. charger le contenu de ladresse A 3. charger le contenu de ladresse B 4. sommer et sauvegarder dans C Si lerreur de page a lieu dans le 4i`me acc`s ` la mmoire (C), il faudra de nouveau recommencer e e a e les 3 acc`s mmoire de linstruction, cest-`-dire lire linstruction, etc. e e a Un autre type de probl`me vient dinstructions comme la suivante que lon trouve sur PDP-11 e : MOV (R2)++,(R3) cette instruction dplace lobjet point par le registre R2 dans ladresse point par R3, R2 est e e e incrment apr`s le transfert et R3 avant. e e e Que se passe-t-il si lon a une erreur de page en cherchant ` accder ` la page point par R3 ? a e a e
9.1.1
Ecacit e
Ecacit des performances de Demand Paging : e Soit ma = 500 nanosecondes, le temps moyen dacc`s a une mmoire. e e le temps eectif dacc`s avec le Demand Paging est e temps eectif = (1-p)*ma + p * temps de gestion de lerreur de page o` p est la probabilit doccurrence dune erreur de page (page fault). u e Une erreur de page ncessite de raliser les oprations suivantes e e e 1. lever une interruption pour le syst`me e 2. sauvegarder le contexte du processus 3. dterminer que linterruption est une erreur de page e 4. vrier que la page en question est une page lgale de lespace logique, dterminer o` se e e e u trouve la page dans la mmoire secondaire. e 5. excuter une lecture de la page sur une page mmoire libre (librer ventuellement une page e e e e cf. algorithme de remplacement de page) attendre que le priphrique soit libre e e
74 temps de latence du priphrique e e commencer le transfert
6. allouer pendant ce temps-l` le cpu ` un autre utilisateur a a 7. interruption du priphrique e e 8. sauvegarde du contexte du processus courant 9. dterminer que linterruption tait la bonne interruption (venant du priphrique) e e e e 10. mise ` jour de la table des pages et dautres pages pour indiquer que la page demande est a e en mmoire maintenant. e 11. attendre que le processus soit slectionn de nouveau pour utiliser lunit centrale (cpu) e e e 12. charger le contexte du processus ! Toutes ces instructions ne sont pas toujours ralises (on peut en particulier supposer que e e lon ne peut pas prempter lunit centrale, mais alors quelle perte de temps pour lensemble du e e syst`me). e Dans tous les cas, nous devons au moins raliser les 3 actions suivantes : e grer linterruption e swapper la page demande e relancer le processus Ce qui cote le plus cher est la recherche de la page sur le disque et son transfert en mmoire, ce u e qui prend de lordre de 1 ` 10 millisecondes. a Ce qui nous donne en prenant une vitesse dacc`s mmoire de 1 microseconde et un temps de e e gestion de page de 5 millisecondes un temps eectif = (1 p) + p 5000 microsecondes Une erreur de page toutes les mille pages nous donne un temps eectif onze fois plus long que lacc`s standard. e Il faut rduire ` moins dune erreur de page tout les 100000 acc`s pour obtenir une dgradation e a e e infrieure ` 10 e a On comprend bien que les choix ` faire sur des pages quil faut placer en mmoire sont donc a e tr`s importants. e Ces choix deviennent encore plus importants quand lon a de nombreux utilisateurs et quil y a sur-allocation de la mmoire, excution concurrente de 6 processus de la taille suprieure ou gale e e e e a ` la mmoire physique ! e Si lon suppose de plus que nos 6 programmes utilisent dans une petite squence dinstructions e toutes les pages de leur mmoire logique, nous nous trouvons alors dans une situation de pnurie e e de pages libres. Le syst`me dexploitation peut avoir recoure ` plusieurs solution dans ce cas-l` e a a 1. tuer le processus fautif ... 2. utiliser un algorithme de remplacement de page Cet algorithme de remplacement est introduit dans notre squence de gestion derreur de page e l` o` lon sattribuait une page libre de la mmoire centrale. a u e Maintenant il nous faut slectionner une victime, cest-`-dire, une des pages occupes de la e a e mmoire centrale qui sera swappe sur disque et remplace par la page demande. e e e e
9.2. LES ALGORITHMES DE REMPLACEMENT DE PAGE
75
Remarquons que dans ce cas-l` notre temps de transfert est doubl, comme il faut ` la fois lire a e a une page et sauvegarder une page sur disque (le temps de transfert disque est ce qui est le plus coteux dans la gestion dune erreur de page). u Il est possible de raliser des syst`mes de demand segments, mais le lecteur avis remarquera e e e rapidement les probl`mes poss par la taille variable des segments. e e
9.2
Les algorithmes de remplacement de page
Un algorithme de remplacement de page doit minimiser le nombre de Page Faults. On recherche lalgorithme qui rduit au mieux la probabilit doccurrence dune erreur de page. e e Un algorithme est valu en prenant une cha de numros de page et en comptant le nombre de e e ne e fautes de page qui ont lieu au cours de cette suite dacc`s, et cela en fonction du nombre de pages e de mmoire centrale dont il dispose. e Pour illustrer les algorithmes de remplacement, nous utiliserons la suite de pages suivante : 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 et 3 pages en mmoire centrale. e
9.2.1
Le remplacement optimal
Utiliser comme victime la page qui ne sera pas utilise pendant le plus longtemps. e Soit pour notre suite : 7xx 70x 701 201 - 203 - 243 - -203 - - 201 - - - 701 - soit seulement 9 fautes de page. Mais cet algorithme nest valable que dans un cas o` lon conna ` lavance les besoins, ce u t a qui nest gnralement pas le cas. e e
9.2.2
Le remplacement peps (FIFO)
Lalgorithme le plus simple est Premier Entr Premier Sorti (First-In-First-Out ). e Quand une victime doit tre slectionne cest la page la plus ancienne qui est slectionne. e e e e e Soit pour la liste 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 et trois page de mmoire centrale : e 7XX/70X/701/201-201/231/230/430/420/423/ 023-023-023/013/012-012-012/712/702/701 soit Quinze Page Faults. Ce mcanisme rapide et simple ` programmer nest malheureusement pas tr`s ecace. Il existe e a e des suites de pages pour lesquelles cet algorithme fait plus de page faults avec quatre pages mmoire e quavec trois ! (par exemple : 1,2,3,4,1,2,5,1,2,3,4,5).
76
9.2.3
Moins rcemment utilise LRU. e e
LRU (Least Recently Used page). Nous utilisons ici le vieillissement dune page et non plus lordre de cration de la page. On fait e le pari que les pages qui ont t rcemment utilises le seront dans un proche avenir, alors que les ee e e pages qui nont pas t utilises depuis longtemps ne sont plus utiles. ee e Soit pour notre suite : 7xx 70x 701 201 - 203 - 403 402 432 032 - - 132 - 102 - 107 soit Douze Page Faults. Lalgorithme LRU est un bon algorithme mais il pose de nombreux probl`mes dimplmentation e e et peut demander de substantiels outils matriels. e Des solutions logicielles : Des compteurs ` chaque entre de la table des pages, on ajoute un compteur de temps qui est a e mis ` jour ` chaque acc`s ` la page. Il faut rechercher sur lensemble de la table la victime. a a e a De plus, ces temps doivent tre mis ` jour quand on change de table de page (celle dun e a autre processus ...). On ne peut utiliser le temps rel ... e Une pile ` chaque fois que lon acc`de ` une page, la page est place en sommet de pile. Le dessus a e a e est toujours la page la plus rcemment utilise et le fond de la pile la moins rcemment e e e utilise. e Des masques On utilise un octet associ ` chaque page. Le syst`me positionne ` 1 le bit de e a e a poids fort ` chaque acc`s ` la page. Toutes les N millisecondes (click dhorloge, cf clock, N a e a = 100 sur llmore) le syst`me fait un dcalage ` droite de loctet associ ` chaque page. On e e a ea obtient ainsi un historique de lutilisation de la page. Loctet ` 00000000 indique que la page a na pas t utilise depuis 8 cycles, 11111111 indique que la page a t utilise pendant les ee e ee e 8 cycles. La page de masque 11000100 ` t utilise plus rcemment que 01110111. Si lon aee e e interpr`te ces octets comme des entiers non-signs, cest la page ayant le plus petit octet e e qui a t utilise le moins rcemment (lunicit des numros ntant pas assure, la slection ee e e e e e e e entre numros identiques se fait avec lordre FIFO). e
9.2.4
Lalgorithme de la deuxi`me chance e
Un bit associ ` chaque page est positionn ` 1 ` chaque fois quune page est utilise par un ea ea a e processus. Avant de retirer une page de la mmoire, on va essayer de lui donner une deuxi`me e e chance. On utilise un algorithme FIFO plus la deuxi`me chance : e Si le bit dutilisation est ` 0, la page est swappe hors mmoire (elle na pas t utilise depuis la a e e ee e derni`re demande de page). e Si le bit est ` 1, il est positionn a zro et lon cherche une autre victime. Ainsi cette page ne a e e sera swappe hors mmoire que si toutes les autres pages ont t utilises, et utilisent aussi leur e e ee e deuxi`me chance. e On peut voir ceci comme une queue circulaire, o` lon avance sur les pages qui ont le bit ` 1 u a (en le positionnant ` zro) jusqu` ce que lon trouve une page avec le bit dutilisation ` zro. a e a a e
9.2.5
Plus frquemment utilis MFU e e
Plus frquemment Utilise : e e Comme son nom lindique, cest la frquence dutilisation qui joue au lieu de lanciennet, mais e e cest le mme mcanisme que LRU. Ces deux algorithmes de LRU et MFU sont rarement utiliss e e e car trop gourmands en temps de calcul et diciles ` implmenter, mais ils sont assez ecaces. a e
9.3. ALLOCATION DE PAGES AUX PROCESSUS
77
9.2.6
Le bit de salet (Dirty Bit) e
Remarquons que si il existe une copie identique sur disque (zone de swap) dune page de mmoire, il nest pas ncessaire dans le cas dun swapout de sauvegarder la page sur disque, il e e sut de la librer. e Le bit de salet permet dindiquer quune page est (ou nest plus) conforme ` la page en zone de e a swap. Ce bit de propret est utilis dans les autres algorithmes, on choisit entre deux victimes possibles e e la plus propre, cest-`-dire celle qui ne ncessite pas de swapout. a e
9.3
Allocation de pages aux processus
Comment rpartir les pages sur les dirents processus et le syst`me ? e e e remplacement local le processus se voit aect un certain nombre de pages quil va utiliser de e faon autonome, son temps dexcution ne dpend que de son propre comportement. c e e remplacement global le comportement dallocation de pages aux processus dpend de la charge e du syst`me et du comportement des dirents processus. e e Le remplacement local demande que lon ralise un partage entre les dirents processus. e e Le partage quitable : m pages de mmoire physique, n processus, m/n pages par processus e e ! On retrouve ici un probl`me proche de la fragmentation interne, un grand nombre de pages est e donn ` un processus qui en utilise eectivement peu. ea On fait un peu mieux en utilisant : S = si o` si est le nombre de pages de la mmoire u e logique du Processus i. Chaque processus se voit attribu (si /S)m pages. On amliore en faisant e e varier ce rapport en fonction de la priorit de chaque processus. e
Probl`mes dcroulement Si le nombre de pages alloues ` un processus non-prioritaire tombe e e e a en dessous de son minimum vital, ce processus est constamment en erreur de page : il passe tout son temps ` raliser des demandes de pages. Ce processus doit tre alors ject enti`rement en a e e e e e zone de swap et reviendra plus prioritaire quand il y aura de la place. Un exemple de bonne et mauvaise utilisation des pages (rappel les compilateurs c allouent les tableaux sur des plages dadresse croissante contiges int m[A][B] est un tableau de A tableaux u de B entiers) : /* bonne initialisation */ int m[2048][2048]; main() {int i,j; for(i=0;i<2048;i++) for(j=0;j<2048;j++) m[i][j] = 1; } ce processus acc`de a une nouvelle page toute les 2048 aectation. e /* mauvaise initialisation */ int m[2048][2048]; main() {int i,j; for(i=0;i<2048;i++) for(j=0;j<2048;j++) m[j][i] = 1; }
78
ce processus acc`de a une nouvelle page toute les aectations ! e Attention : En fortran lallocation des tableaux se fait dans lautre sens par colones . . . Si la mmoire est libre et assez grande, les deux processus sont grossi`rement aussi rapides, e e par contre si on lance dix exemplaires du premier, le temps dattente est juste multipli par 10. e Pour le deuxi`me, le temps dattente est au moins multipli par 100 (je nai pas attendu la n de e e lexcution). e
9.4
Lappel fork et la mmoire virtuelle e
Nous avons vu que la primitive fork() ralise une copie de limage mmoire du processus p`re e e e pour crer le processus ls. Cette copie nest pas intgrale car les deux processus peuvent partager e e des pages marques en lecture seule, en particulier le segment du code est partag par les deux e e processus (rentrance standard des processus unix). e Mais avec le syst`me de demand-paging, on peut introduire une nouvelle notion qui est la e copie sur criture (copy on write). On ajoute ` la structure de page de la table des pages des e a indicateurs de copie sur criture. Lide est de raliser la copie de la page uniquement dans le e e e cas o` lun des processus qui peuvent y acc`der ralise une criture. Dans ce cas-l`, la page est u e e e a recopie avant lcriture et le processus crivain poss`de alors sa propre page. e e e e Lintrt de ce mcanisme est surtout visible dans le cas tr`s frquent o` le fork est immdiatement ee e e e u e suivi par un exec. En eet, ce dernier va raliser une libration de toutes les pages, il est donc e e inutile de les recopier juste avant cette libration. e Le syst`me BSD a introduit la premi`re version de cette ide en partant de lappel syst`me e e e e vfork() qui lui permet le partage totale de toutes les pages entre le processus p`re et le processus e ls sans aucune copie. Lintrt est de pouvoir raliser rapidement un execve sans avoir ` recopier ee e a lespace dadressage du processus p`re. e
9.5
Projection de chiers en mmoire e
La fonction mmap permet la projection de chiers en mmoire. Le segment du chier indiqu e e est plac en mmoire ` partir de ladresse indique. Le segment de chier peut ainsi tre parcouru e e a e e par des acc`s par adresse sans utiliser de commande de lecture ou dcriture. e e #include <sys/mman.h> #include <sys/types.h> void *mmap(void int int *adr, int len, prot, int options, desc, int offset);
int munmap(void *adr, int len); Ladresse adr indique o` doit tre plac le chier, cette adresse doit tre une adresse de dbut u e e e e de page (un multiple de sysconf( SC PAGE SIZE)), si le param`tre est NULL alors le syst`me e e slectionne ladresse de placement qui est retourne par la fonction. Lintervalle de position e e [offset, offset+len] du chier desc est plac en mmoire. e e prot indique les protections dacc`s sous HP-UX les protections suivantes sont disponible : e
9.5. PROJECTION DE FICHIERS EN MEMOIRE --r-r-x rw rwx PROT_NONE PROT_READ PROT_READ|PROT_EXECUTE PROT_READ|PROT_WRITE PROT_READ|PROT_WRITE|PROT_EXECUTE
79
options indique si lon veut que les critures ralises dans les pages contenant la projece e e tion soient partages (MAP SHARED), ou au contraire quune copie sur criture soit ralise e e e e (MAP PRIVATE). La fonction munmap permet de librer la zone mmoire dadresse adr et de longueur len. e e Pour une autre forme de mmoire partage, voir le chapitre sur les IPC (sur le web). e e Un exemple dutilisation de mmap pour copier un chier : #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/mman.h> #include <fcntl.h> int main(int argc,char *argv[]) { int fdin,fdout ; struct stat statbuf ; char *src,*dst ; if (argc != 3) { fprintf(stderr,"usage : %s source destination ",argv[0]) ; exit(-1) ; } if ((fdin = open(argv[1], O RDONLY)) < 0) { fprintf(stderr,"impossible d\ouvrir : %s en lecture ",argv[1]) ; exit(-2) ; } if ((fdout = open(argv[2], O RDWR|O CREAT|O TRUNC,0666)) < 0) { fprintf(stderr,"impossible d\ouvrir : %s en ecriture ",argv[2]) ; exit(-3) ; } if (fstat(fdin,&statbuf) < 0 ) { fprintf(stderr,"impossible de faire stat sur %s ",argv[1]) ; exit(-4) ; } if (lseek(fdout, statbuf.st size -1 , SEEK SET) == -1 ) { fprintf(stderr,"impossible de lseek %s ",argv[2]) ; exit(-5) ; } if (write(fdout,"",1) != 1) { fprintf(stderr,"impossible d\ecrire sur %s ",argv[2]) ; exit(-6) ; }
80
CHAPITRE 9. LA MEMOIRE VIRTUELLE if ((src = mmap (0,statbuf.st size, PROT READ, MAP FILE | MAP SHARED, fdin,0)) == (caddr t) -1 ) { fprintf(stderr,"impossible de mapper %s ",argv[1]) ; exit(-7) ; } if ((dst = mmap (0,statbuf.st size, PROT READ | PROT WRITE, MAP FILE | MAP SHARED, fdout,0)) == (caddr t) -1 ) { fprintf(stderr,"impossible de mapper %s ",argv[2]) ; exit(-8) ; } memcpy(dst,src,statbuf.st size) ; /* copie */ exit(0) ;
Attention, quand vous utilisez mmap cest de la mmoire, mais cest a vous de grer lallignement. e e Exemple : char *p = map(...); int *q = p+1; // warning *q = 1 ; // probl`me dallignement e
9.6
Les conseils et politiques de chargement des zones mmappes e
Une foit que lon dcider de faire des projection en mmoire avec mmap il peut tre oportin de e e e faire appel ` la fonction madvise qui permet de donner un conseil au syst`me en le prvenant par a e e avance de la faon dont vous aller utiliser le segement de mmoire. En particulier allez vous lire c e le chier sequentiellement ou de faon allatoire. Avez vous encore besoin du chier apr`s lecture c e e etc. Biensur la fonction madvise ne se limite pas aux pages mapps mais cest sur celle ci quil est e le plus facile de prendre des dcisions, les autres pages tant grer dans la pile le tas et le code e e e zone plus dlicates et moins bien cartographies en gnrale (sic). e e e e #include <sys/mman.h> int madvise(void *start, size_t length, int advice); La valeur du conseil advice : MADV NORMAL Comportement par dfaut. e MADV RANDOM prevoit des acces aux pages dans un ordre aleatoire. MADV SEQUENTIAL prevoit des acces aux pages dans un ordre sequentiel. MADV WILLNEED prevoit un acces dans un futur proche. MADV DONTNEED Ne prevoit pas dacces dans un futur proche. Biensur si cest une mmap vous pouvez aussi utiliser la commande munmap. Biensur ce ne sont que des conseils le syst`me les utilisera si il en a la possibilit, soit parce quil e e y a du temps idle (sans activit) soit parce quil protera des lectures groupes sur disque en e e ralisant des lectures en avance cas squentiel. Il peut aussi proter de lindication DONTNEED e e pour prendre des dcissions dans le code de remplacement de page. e
9.7. CHARGEMENT DYNAMIQUE
81
9.7
Chargement dynamique
Indpendement de lexistance de la mmoire virtuel il est possible de grer ` la main le code e e e a accessible en utilisant le chargement direct (non automatique) de librairies. Pour construire une librairie de chier lib.c : #include <stdio.h> /* fonction optionelle qui permet dinitialiser la libraire */ void _init() { fprintf(stderr," intialisation \n"); } /* fonction optionelle qui est appelle avant le dchargement */ e e void _fini() { fprintf(stderr," dchargement excution de _fini \n"); e e } /* des fonctions spcifiques a votre libraire */ e int doit(int u) { fprintf(stderr," doit to u= %d " , u ); return u*u; } Compilation de la libraire, loption nostartle pour que le compilateur ne construise pas dexcutable. e gcc -shared -nostartfiles -o ./malib lib.c Le chier main qui va charger la libraire puis appeler une fonction de cette libraire. #include <stdio.h> #include <dlfcn.h> int main(int argc, char **argv) { void *handle; int (*doit)(int); char *error; handle = dlopen ("./malib", RTLD_LAZY); if (!handle) { fputs (dlerror(), stderr); exit(1); } doit = dlsym(handle, "doit"); if ((error = dlerror()) != NULL) { fprintf (stderr, "%s\n", error); exit(1); } printf ("%d\n", (*doit)(23)); handle = dlopen ("./malib", RTLD_LAZY); // nouveau rfrencement avce le m^me handle e e e dlclose(handle); // dcrementation du conteur de rfrence e e e
82
fprintf(stderr," avant le deuxieme dlclose \n"); dlclose(handle); }
Chapitre 10
Tubes et Tubes Nomms e

Les tubes sont un mcanisme de communication qui permet de raliser des communications e e entre processus sous forme dun ot continu doctets. Les tubes sont un des lments de lagrment ee e dutilisation dUNIX. Cest ce mcanisme qui permet lapproche ltre de la conception sous UNIX. e Mcanisme de communication li au syst`me de gestion de chier, les tubes nomms ou non e e e e sont des paires dentres de la table des chiers ouverts, associes ` une inode en mmoire gre e e a e ee par un driver spcique. Une entre est utilise par les processus qui crivent dans le tube, une e e e e entre pour les lecteurs du tube. e Lopration de lecture y est destructive ! e Lordre des caract`res en entre est conserv en sortie (premier entr premier e e e e sorti). Un tube a une capacit nie : en gnral le nombre dadresses directes des inodes e e e du SGF (ce qui peut varier de 5 ` 80 Ko). a
10.1
Les tubes ordinaires (pipe)
Un tube est matrialis par deux entres de la table des ouvertures de chiers, une de ces e e e entres est ouverte en criture (lentre du tube), lautre en lecture (la sortie du tube). Ces deux e e e entres de la table des chiers ouverts nous donnent le nombre de descripteurs qui pointent sur e elles. Ces valeurs peuvent tre traduites comme : e nombre de lecteurs = nombre de descripteurs associs ` lentre ouverte en lecture.On ne peut e a e pas crire dans un tube sans lecteur. e nombre dcrivains = nombre de descripteurs associs ` lentre ouverte en criture. La nullit e e a e e e de ce nombre dnit le comportement de la primitive read lorsque le tube est vide. e
10.2
Cration de tubes ordinaires e
Un processus ne peut utiliser que les tubes quil a crs lui-mme par la primitive pipe ou quil ee e a hrits de son p`re grce ` lhritage des descripteurs ` travers fork et exec. e e e a a e a #include <unistd.h> int pipe(int p[2]); On ne peut pas manipuler les descripteurs de tubes avec les fonctions et primitives : lseek, ioctl, tcsetattr et tcgetattr, comme il ny a pas de priphrique associ au tube (tout est e e e 83
84
processus A
pipe(p)
CHAPITRE 10. TUBES ET TUBES NOMMES
Dans le noyau inodes en mmoire
descripteurs
p[0] 2 0 1 rd p[1] 1 wr
Fig. 10.1 Ouverture dun tube

processus A
fork()
ouvertures de fichiers
inodes 2 0
p[0] 2 rd p[1] processus B fils de A p[0] p[1] 2 wr
Fig. 10.2 Hritage dun tube e fait en mmoire). e Hritage dun tube dans la gure 10.2 : le processus B hrite des descripteurs ouverts par son e e p`re A et donc, ici, du tube. e Dans la Figure 10.3, les descripteurs associs aux tubes sont placs comme descripteurs 0 et e e 1 des processus A et B, cest ` dire la sortie de A et lentre de B. Les autres descripteurs sont a e ferms pour assurer lunicit du nombre de lecteurs et dcrivains dans le tube. e e e
10.3. LECTURE DANS UN TUBE
85
processus A
dup2(1,p[1]) 1 close (p[0]) close (p[1])
ouvertures
1 rd processus B fils de A
dup2(0,p[0]) close (p[0]) close (p[1])
1 wr
Fig. 10.3 Redirection de la sortie standard de A dans le tube et de lentre standard de B dans e le tube, et fermeture des descripteurs inutiles
10.3
Lecture dans un tube
On utilise lappel syst`me read. e int nb_lu; nb_lu = read(p[0], buffer, TAILLE_READ); Remarquer que la lecture se fait dans le descripteur p[0]. Comportement de lappel : Si le tube nest pas vide et contient taille caract`res : e lecture de nb lu = min(taille, TAILLE READ) caract`res. e Si le tube est vide Si le nombre dcrivains est nul e alors cest la n de chier et nb lu est nul. Si le nombre dcrivains est non nul e Si lecture bloquante alors sommeil Si lecture non bloquante alors en fonction de lindicateur O NONBLOCK nb lu= -1 et errno=EAGAIN. O NDELAY nb lu = 0.
86
10.4
Ecriture dans un tube
nb_ecrit = write(p[1], buf, n); Lcriture est atomique si le nombre de caract`res ` crire est infrieur ` PIPE BUF, la taille e e ae e a du tube sur le syst`me. (cf <limits.h>). e Si le nombre de lecteurs est nul envoi du signal SIGPIPE ` lcrivain. a e Sinon Si lcriture est bloquante, il ny a retour que quand e les n caract`res ont t crits dans le tube. e eee Si criture non bloquante e Si n > PIPE BUF, retour avec un nombre infrieur ` n e a ventuellement -1 ! e Si n PIPE BUF et si n emplacements libres, criture nb ecrit = n e sinon retour -1 ou 0. Comment rendre un read ou write non bloquant ? en utilisant fctnl sur le descripteur du tube. F SETFL xe de nouveaux attributs pour le descripteur de chier fd. Les nouveaux attributs sont e e contenus dans arg. Seuls O APPEND, O NONBLOCK et O ASYNC peuvent tre modis ainsi, les autres attributs ne sont pas aects. e
10.5
Interblocage avec des tubes
Un mme processus a deux acc`s ` un tube, un acc`s en lecture, un acc`s en criture et essaie e e a e e e de lire sur le tube vide en mode bloquant le processus est bloqu indniment dans la primitive e e read. Avec deux processus : deux tubes entre les deux processus, tous les deux bloqus en lecture ou tous les deux bloqus en e e criture, tous les deux en attente dune action de lautre processus. e
10.6
Les tubes nomms e
Les tube nomms sont des tubes (pipe) qui existent dans le syst`me de chiers, et donc peuvent e e tre ouverts grce ` une rfrence. e a a ee Il faut pralablement crer le tube nomm dans le syst`me de chiers, grce ` la primitive mknod e e e e a a (mkfifo), avant de pouvoir louvrir avec la primitive open. int mknod(reference, mode | S_IFIFO,0); mode est construit comme le param`tre de mode de la fonction open. e En POSIX, un appel simpli : e #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *ref, mode_t mode); On peut crer des FIFOs ` partir du shell grce ` e a a a mkfifo [-p] [-m mode] ref ... Louverture dun tube nomm se fait exclusivement soit en mode O RDONLY soit en mode e O WRONLY, ainsi le nombre de lecteur et dcrivain peut tre comptabilis. e e e
10.6. LES TUBES NOMMES
87
10.6.1
Ouverture et synchronisation des ouvertures de tubes nomms e
Il y a automatiquement synchronisation des processus qui ouvrent en mode bloquant un tube nomm. e Lopration douverture sur un tube nomm est bloquante en lecture. e e Le processus attend quun autre processus ouvre la fo en criture. e Louverture en criture est aussi bloquante, avec attente quun autre processus ouvre la fo en e lecture. Louverture bloquante se termine de faons synchrone pour les deux processus. c Ainsi un unique processus ne peut ouvrire ` la fois en lecture et criture un tube nomm. a e e En mode non bloquant (O NONBLOCK, O NDELAY), seule louverture en lecture russit e dans tous les cas. Louverture en criture en mode non bloquant dun tube nomm ne fonctionne e e que si un autre processus a dj` ouvert en mode non bloquant le tube en lecture, ou bien quil ea est bloqu dans lappel dune ouverture en lecture en mode bloquant. Ceci pour viter que le e e processus qui vient douvrir le tube nomm, ncrive dans le tube avant quil ny ait de lecteur e e (quun processus ait ouvert le tube en lecture) et ce qui engendrerait un signal SIGPIPE (tube dtruit), ce qui nest pas vrai car le tube na pas encore t utilis. e ee e
10.6.2
Suppression dun tube nomm e
Lutilisation de rm ou unlink ne fait que dtruire la rfrence, le tube nest rellement dtruit e ee e e que lorsque son compteur de liens internes et externes est nul. Une fois que tous les liens par rfrence sont dtruits, le tube nomm devient un tube ordinaire. ee e e
10.6.3
les appels popen et pclose
Une interface plus facile pour lancer un coprocessus est propos avec les primitives popen et e pclose.
88
Chapitre 11
Les signaux
Les signaux sont un mcanisme asynchrone de communication inter-processus. e Intuitivement, il sont comparables ` des sonneries, les dierentes sonneries indiquant des v`nements a e e dirents. Les signaux sont envoys ` un ou plusieurs processus. Ce signal est en gnral associ e e a e e e ` un v`nement. a e e Peu portables entre BSD et ATT, ils deviennent plus commodes ` utiliser et portables avec a la norme POSIX qui utilise la notion utile de vecteur de signaux et qui fournit un mcanisme de e masquage automatique pendant les procdures de traitement (comme BSD). e Un signal est envoy ` un processus en utilisant lappel syst`me : ea e kill(int pid, int signal); signal est un numro compris entre 1 et NSIG (dni dans <signal.h>) et pid le numro du e e e processus. Le processus vis reoit le signal sous forme dun drapeau positionn dans son bloc de contrle. e c e o Le processus est interrompu et ralise ventuellement un traitement de ce signal. e e On peut considrer les signaux comme des interruptions logicielles, ils interrompent le ot nore mal dun processus mais ne sont pas traits de faon synchrone comme les interruptions matrielles. e c e
11.0.4
Provenance des signaux
Certains signaux peuvent tre lancs ` partir dun terminal grce aux caract`res spciaux e e a a e e comme intr, quit dont la frappe est transforme en lenvoi des signaux SIGINT et SIGQUIT. e Dautres sont ds ` des causes internes au processus, par exemple : SIGSEGV qui est envoy en cas u a e derreur dadressage, SIGFPE division par zro (Floating Point Exception). e Enn certains sont ds ` des v`nements comme la dconnection de la ligne (le terminal) u a e e e utilis : si le processus leader dun groupe de processus est dconnect, il envoie ` lensemble des e e e a processus de son groupe le signal SIGHUP (Hangup = raccrocher).
11.0.5
Gestion interne des signaux
Cest dans le bloc de contrle (BCP) de chaque processus que lon trouve la table de gestion o des signaux (attention, sous System V < V.4, la table de gestion des processus est dans la zone u, cest ` dire dans lespace-mmoire du processus). a e Cette table contient, pour chaque signal dni sur la machine, une structure sigvec suivante : e { bit pendant; 89
90 void (*traitement)(int); }
CHAPITRE 11. LES SIGNAUX
En BSD et POSIX, on a un champ supplmentaire : bit masque ; e Le drapeau pendant indique que le processus a reu un signal, mais na pas encore eu loccasion c de prendre en compte ce signal. Remarque : comme pendant est un unique bit, si un processus reoit plusieurs fois le mme c e signal avant de le prendre en compte, alors il ny a pas mmorisation des rceptions successives, e e un seul traitement sera donc ralis. e e Comme nous lavons vu dans le graphe dtat des processus, la prise en compte des signaux e se fait au passage de ltat actif noyau ` ltat actif utilisateur. Pourquoi la prise en compte de e a e signaux se fait-elle uniquement ` ce moment l` ? a a Parce que Une sauvegarde de la pile utilisateur et du contexte a t eectue quand le processus est pass en ee e e mode noyau. Il nest pas ncessaire de faire un nouveau changement de contexte. Il est facile pour e traiter le signal de raliser immdiatement une nouvelle augmentation de pile pour le traitement e e du signal, de plus la pile noyau est vide (remarque : en POSIX, il devient possible de crer une e pile spciale pour les fonctions de traitement de signaux). e Lappel ` la fonction de traitement est ralis de faon ` ce quau retour de la fonction, le a e e c a processus continue son excution normalement en poursuivant ce qui tait en cours de ralisation e e e avant la rception du signal. Si lon veut que le processus se poursuive dans un autre contexte (de e pile), il doit grer lui-mme la restauration de ce contexte. e e La primitive longjmp peut permettre de raliser des changements de contexte interne au proe cessus, grce ` un dsempilement brutal. a a e Pendant ce changement dtat, la table de gestion des signaux du processus est teste pour la e e prsence dun signal reu mais non trait (cest un simple vecteur de bit pour le bit pendant, et e c e donc testable en une seule instruction, ceci doit tre fait rapidement comme le test de rception e e dun signal est souvent ralis). e e Si un signal a t reu ( et quil nest pas masqu), alors la fonction de traitement associe est ee c e e ralise. Le masquage permet au processus de temporiser la mise en euvre du traitement. e e
11.0.6
Lenvoi de signaux : la primitive kill
kill(int pid, int sig) Il y a NSIG signaux sur une machine, dclars dans le chier /usr/include/signal.h. e e La valeur de pid indique le PID du processus auquel le signal est envoy. e 0 Tous les processus du groupe du processus ralisant lappel kill e 1 En syst`me V.4 tous les processus du syst`me sauf 0 et 1 e e pid positif le processus du pid indiqu e pid ngatif tous les processus du groupe | pid | e le param`tre sig est interprt comme un signal si sig [0-NSIG], ou comme une demande e ee dinformation si sig = 0 (suis-je autoris ` envoyer un signal ` ce(s) processus ?). Comme un e a a param`tre erron sinon. e e La fonction raise(int signal) est un raccourci pour kill(getpid(), signal), le processus senvoie ` lui-mme un signal. a e Remarquez que lon peut rcrire kill(0, signal) par kill(-getpid(), signal). Rappel : ee les PID sont toujours positifs.
11.1. LA GESTION SIMPLIFIEE AVEC LA FONCTION SIGNAL
91
11.1
La gestion simplie avec la fonction signal e
ZZZ : cette section est historique, utiliser la norme POSIX dcrite plus loin. e ancien C : (*signal(sig, func))() int sig; int (*func)(); ANSI C : void (*signal(int sig, void (*action)(int)))(int);
La fonction signal permet de spcier ou de conna e tre le comportement du processus ` la a rception dun signal donn, il faut donner en param`tre ` la fonction le numro du signal sig e e e a e que lon veut dtourner et la fonction de traitement action ` raliser ` la rception du signal. e a e a e Trois possibilits pour ce param`tre action e e SIG DFL Comportement par dfaut, plusieurs possibilits e e exit Le processus se termine (avec si possible la ralisation dun core) e ignore Le processus ignore le signal pause Suspension du processus continue Reprise du processus si il tait suspendu. e e SIG IGN le signal est ignor. Remarque : les signaux SIGKILL, SIGSTOP ne peuvent pas tre ignors. e e HANDLER Une fonction de votre cru.
11.1.1
Un exemple
Exemple pour rendre un programme insensible ` la frappe du caract`re de contrle intr sur le a e o terminal de contrle du processus. o void got_the_blody_signal(int n) { signal(SIGINT, got_the_blody_signal); printf(" gotcha!! your (%d) signal is useless \n"); } main() { signal(SIGINT, got_the_blody_signal); printf(" kill me now !! \n"); for(;;); } une version plus lgante et plus able : ee signal(SIGINT, SIG_IGN);
11.2
Probl`mes de la gestion de signaux ATT e
Les phnom`nes suivants sont dcrits comme des probl`mes mais la norme POSIX permet den e e e e conserver certains, mais fournit aussi les moyens de les viter. e 1. un signal est repositionn ` sa valeur par dfaut au dbut de son traitement (handler). ea e e #include <signal.h> traitement() { printf("PID %d en a capture un \n", getpid());
92 -> }
CHAPITRE 11. LES SIGNAUX reception du deuxieme signal, realisation dun exit signal(SIGINT, traitement);
main() { int ppid; signal(SIGINT,traitement); if (fork()==0) {/* attendre que pere ait realise son nice() */ sleep(5); ppid = getppid(); /* numero de pere */ for(;;) if (kill(ppid,SIGINT) == -1) exit(); } /* pere ralenti pour un conflit plus sur */ nice(10); for(;;) pause(); <- reception du premier signal /* pause cest mieux quune attente active */ } Si lon cherche ` corriger ce dfaut, on repositionne la fonction traitement au dbut du a e e traitement du signal. Ceci risque de nous placer dans une situation de dpassement de pile : e en eet, dans le programme prcdent, nous pouvons imaginer que le p`re peut recevoir e e e un nombre de signaux arbitrairement grand pendant le traitement dun seul signal, do` u une explosion assure de la pile (il sut en eet que chaque empilement de la fonction e traitement soit interrompu par un signal) traitement(){ signal(SIGINT,traitement); -> signal SIGINT printf("PID %d en a capture un \n",getpid()); } On peut aussi ignorer les signaux pendant leur traitement, mais cela peut crer des pertes e de rception. e Enn, la solution BSD/POSIX o` lon peut bloquer et dbloquer la rception de signaux ` u e e a laide du vecteur de masquage (sans pour autant nous assurer de la rception de tous les e signaux ! !). De plus, en POSIX, le traitement dun signal comporte une clause de blocage automatique. On indique quels signaux doivent tre bloqus pendant le traitement du signal, e e grce ` un vecteur de masquage dans la structure sigaction. a a Ceci est le comportement naturel de gestion des interruptions matrielles : on bloque les e interruptions de priorit infrieure pendant le traitement dun interruption. e e 2. Seconde anomalie des signaux sous System V < V4 : certains appels syst`mes peuvent tre e e interrompus et dans ce cas la valeur de retour de lappel syst`me est -1 (chec). Il faudrait, e e pour raliser correctement le mod`le dune interruption logicielle, relancer lappel syst`me en e e e n de traitement du signal. (Sous BSD ou POSIX, il est possible de choisir le comportement en cas dinterruption dun appel syst`me grce ` la fonction siginterrupt, c-a-d relancer e a a ou non lappel syst`me, un appel ` read, par exemple, peut facilement tre interrompu si il e a e ncessite un acc`s disque). e e 3. Troisi`me anomalie des signaux sous ATT : si un signal est ignor par un processus endormi, e e celui-ci sera rveill par le syst`me uniquement pour apprendre quil ignore le signal et doit e e e donc tre endormi de nouveau. Cette perte de temps est de au fait que le vecteur des e u signaux est dans la zone u et non pas dans le bloc de contrle du processus. o
` 11.2. PROBLEMES DE LA GESTION DE SIGNAUX ATT
93
11.2.1
Le signal SIGCHLD
Le signal SIGCHLD (anciennement SIGCLD) est un signal utilis pour rveiller un processus e e dont un des ls vient de mourir. Cest pourquoi il est trait diremment des autres signaux. La e e raction ` la rception dun signal SIGCHLD est de repositionner le bit pendant ` zro, et dignoe a e a e rer le signal, mais le processus a quand mme t rveill pour cela. Leet dun signal SIGCHLD e ee e e est donc uniquement de rveiller un processus endormi en priorit interruptible. e e Si le processus capture les signaux SIGCHLD, il invoque alors la procdure de traitement e dnie par lutilisateur comme il le fait pour les autres signaux, ceci en plus du traitement par e dfaut. e Le traitement normal est li ` la primitive wait qui permet de rcuprer la valeur de retour ea e e (exit status) dun processus ls. En eet, la primitive wait est bloquante et cest la rception du e signal qui va rveiller le processus, et permettre la n de lexcution de la primitive wait. e e Un des probl`mes de la gestion de signaux System V est le fait que le signal SIGCHLD est e reu (raised) au moment de la pose dune fonction de traitement. c Ces proprits du signal SIGCHLD peuvent induire un bon nombre derreurs. ee Par exemple, dans le programme suivant nous positionnons une fonction de traitement dans laquelle nous repositionnons la fonction de traitement. Comme sous System V, le comportement par dfaut est repositionn pendant le traitement dun signal. Or le signal est lev ` la pose de la e e ea fonction de traitement, do` une explosion de la pile. u #include <stdio.h> #include <unistd.h> /* ancienne norme */ #include <signal.h> void hand(int sig) { signal(sig, hand); printf("message qui nest pas affiche\n"); } main() { if (fork()) { exit(0); /* creation dun zombi */ } signal(SIGCHLD, hand); printf("ce printf nest pas execute\n"); } Sur les HP, un message derreur vous informe que la pile est pleine : stack growth failure. Deuxi`me exemple : e #include <signal.h> #include <sys/wait.h> int pid, status; void hand(int sig) { printf(" Entree dans le handler \n"); system("ps -l"); /* affichage avec etat zombi du fils */ if ((pid = wait(&status)) == -1) /* suppression du fils zombi */ { perror("wait handler "); return ;
94 } printf(" wait handler return; }
pid: %d
status %d \n", pid, status);
main() { signal(SIGCHLD,hand); /* installation du handler */ if (fork() == 0) { /* dans le fils */ sleep(5); exit(2); } /* dans le pere */ if ((pid = wait(&status)) == -1) /* attente de terminaison du fils */ { perror("wait main "); return ; } printf(" wait main pid: %d status %d \n", pid, status); } rsultat : e Entree dans le handler F S UID PID PPID C PRI NI ADDR 1 S 121 6792 6667 0 158 20 81ac180 1 S 121 6667 6666 0 168 20 81ac700 1 Z 121 6793 6792 0 178 20 81bda80 1 S 121 6794 6792 0 158 20 81ac140 1 R 121 6795 6794 4 179 20 81bd000 wait handler pid: 6793 status 512 wait main: Interrupted system call SZ WCHAN TTY TIME COMD 6 49f5fc ttys1 0:00 sigchld 128 7ffe6000 ttys1 0:00 tcsh 0 ttys1 0:00 sigchld 78 4a4774 ttys1 0:00 sh 43 ttys1 0:00 ps (2 * 256)
A la mort du ls, Le p`re reoit le signal SIGCHLD (alors quil tait dans le wait du main), e c e puis le handler est execut, et ps ache bien le ls zombi. Ensuite cest le wait du handler qui e prend en compte la terminaison du ls. Au retour du handler, lappel a wait du main retourne -1, puisquil avait t interrompu par SIGCHLD. ee
11.3
Manipulation de la pile dexcution e
La primitive #include <setjmp.h> int sigsetjmp(sigjmp_buf env, int indicateur); sauvegarde un environnement dexcution, cest ` dire un tat de la pile, et si indicateur est e a e non nul, sauvegarde le masque de signaux courant. La valeur de retour de cette fonction est zro e quand on fait une sauvegarde, et sinon dpend du param`tre valeur de la fonction siglongjmp. e e int siglongjmp(sigjmp_buf env, int valeur); La primitive siglongjmp permet de reprendre lexcution ` lendroit sauvegard par sigsetjmp e a e dans la variable env. Deux remarques : env doit avoir t initialis par sigsetjmp, les valeurs de pile places auee e e dessus de lenvironnement repris sont perdues. Lenvironnement de pile doit encore exister dans la pile au moment de lappel, sinon le rsultat est indtermin. e e e
11.4. QUELQUES EXEMPLES DUTILISATION
95
11.4
Quelques exemples dutilisation
/*un exemple de signaux BSD */ #include <stdio.h> #include <signal.h> void gots1(int n) { raise(SIGUSR2); printf("got void gots2(int n) { printf("got s2(%d) ", n); } main() { int mask ; struct sigvec s1,s2; s1.sv_handler = gots1; s1.sv_mask = sigmask(SIGUSR1); sigvec(SIGUSR1, &s1, NULL); s2.sv_handler = gots2; s2.sv_mask = sigmask(SIGUSR2); sigvec(SIGUSR2, &s2, NULL); printf(" sans masquage de SIGUSR2: ") raise(SIGUSR1); printf(" \n avec masquage de SIGUSR2: " ); s1.sv_mask = sigmask(SIGUSR2); sigvec(SIGUSR1, &s1, NULL); raise(SIGUSR1); } Nous donne les achages suivant : sans masquage de SIGUSR2: got avec masquage de SIGUSR2: got s2(31) got s1(30) got s1(30) s2(31)
s1(%d) ", n); }
Sous BSD, pas de fonction de manipulation propre des groupes de signaux (on regroupe les signaux par des conjonctions de masques). Le probl`me de linterruption des appels syst`me par les signaux est corrig par la fonction : e e e int siginterrupt(int sig, int flag); le drapeau flag prend comme valeur 0 ou 1, ce qui signie que les appels syst`mes interrompus e par un signal seront : soit relancs avec les mmes param`tres. e e e soit retourneront la valeur -1, et dans ce cas la valeur de errno est positionne ` EINTR. e a Certaines fonctions comme readdir utilisent des variables statiques, ces fonctions sont dites non rentrantes. Il faut viter dappeler ce type de fonctions dans un handler de signal, dans le cas e e o` lon fait dj` appel ` la fonction dans le reste du processus. De la mme faon la variable errno u ea a e c est unique. Si celle-ci est positionne dans le main mais quun signal arrive avant son utilisation, e une primitive appele dans le handler peut en changer la valeur ! (ce probl`me de rentrance sera e e e vu plus en dtail avec les processus multi-activits). e e
11.4.1
Lappel pause
Fonction de mise en attente de rception dun signal : e
96 pause(void);
cette primitive est le standard UNIX dattente de la rception dun signal quelconque, BSD e propose la primitive suivante : sigpause(int sigmask) qui permet lattente dun groupe spcique de signaux, attention les signaux du masque sont e dbloqus (c.f. sigprocmask). e e
11.5
La norme POSIX
La norme POSIX ne dnit pas le comportement dinterruption des appels syst`mes, il faut le e e spcier dans la structure de traitement du signal. e
Les ensembles de signaux La norme POSIX introduit les ensembles de signaux : ces ensembles de signaux permettent de dpasser la contrainte classique qui veut que le nombre e de signaux soit infrieur ou gal au nombre de bits des entiers de la machine. Dautre part, des e e fonctions de manipulation de ces ensembles sont fournies et permettent de dnir simplement des e masques. Ces ensembles de signaux sont du type sigset t et sont manipulables grce aux fonctions a suivantes : int int int int sigemptyset(sigset_t *ens) sigfillset(sigset_t *ens) sigaddset(sigset_t *ens, int sig) sigdelset(sigset_t *ens, int sig) /* raz */ /* ens = { 1,2,...,NSIG} */ /* ens = ens + {sig} */ /* ens = ens - {sig } */
Ces fonctions retournent -1 en cas dchec et 0 sinon. e int sigismember(sigset_t *ens, int sig); /* sig appartient ` ens ?*/ a
retourne vrai si le signal appartient ` lensemble. a
11.5.1
Le blocage des signaux
La fonction suivante permet de manipuler le masque de signaux du processus : #include <signal.h> int sigprocmask(int op, const sigset_t Lopration op : e SIG SETMASK aectation du nouveau masque, recupration de la valeur de lancien masque. e SIG BLOCK union des deux ensembles nouv et anc SIG UNBLOCK soustraction anc - nouv On peut savoir si un signal est pendant et donc bloqu grce ` la fonction : e a a int sigpending(sigset_t *ens); retourne -1 en cas dchec et 0 sinon et lensemble des signaux pendants est stock ` ladresse e ea ens. *nouv, sigset_t *anc);
11.5. LA NORME POSIX
97
11.5.2
sigaction
La structure sigaction dcrit le comportement utilis pour le traitement dun signal : e e struct sigaction { void (*sa_handler) (); sigset_t sa_mask; int sa_flags;} sa handler fonction de traitement (ou SIG DFL et SIG IGN) sa mask ensemble de signaux supplmentaires ` bloquer pendant le traitement e a sa ags direntes options e SA NOCLDSTOP le signal SIGCHLD nest pas envoy ` un processus lorsque lun ea de ses ls est stopp. e SA RESETHAND simulation de lancienne mthode de gestion des signaux, pas de e blocage du signal pendant le handler et repositionnement du handler par dfaut e au lancement du handler. SA RESTART les appels syst`me interrompus par un signal capt sont relancs au e e e lieu de renvoyer -1. Cet indicateur joue le rle de lappel siginterrupt(sig,0) o des versions BSD. SA NOCLDWAIT si le signal est SIGCHLD, ses ls qui se terminent ne deviennent pas zombis. Cet indicateur correspond au comportement des processus pour SIG IGN dans les versions ATT. Le positionnement du comportement de reception dun signal se fait par la primitive sigaction. Linstallation dune fonction de traitement du signal SIGCHLD peut avoir pour eet denvoyer un signal au processus, ceci dans le cas o` le processus a des ls zombis, cest toujours le probl`me u e li ` ce signal qui na pas le mme comportement que les autres signaux. ea e Un handler positionn par sigaction reste jusqu` ce quun autre handler soit positionn, ` la e a e a dirence des versions ATT o` le handler par dfaut est repositionn automatiquement au dbut e u e e e du traitement du signal. #include <signal.h> int sigaction(int sig, const struct sigaction *paction, struct sigaction *paction_precedente); Cette fonction ralise soit une demande dinformation. Si le pointeur paction est null, on obe tient la structure sigaction courante. Sinon cest une demande de modication du comportement.
11.5.3
Lattente dun signal
En plus de lappel pause, on trouve sous POSIX lappel int sigsuspend(const sigset t *ens) ; qui permet de raliser de faons atomique les actions suivantes : e c linstallation du masque de blocage dni par ens (qui sera repositionn ` sa valeur dorigine) e ea ` la n de lappel, a mise en attente de la rception dun signal non bloqu. e e
98
Chapitre 12
Les verrous de chiers

Mcanismes de contrle dacc`s concurrents ` un chier, les verrous sont dune grande utilit e o e a e dans les applications de gestion et dans llaboration de bases de donnes partages. e e e Les verrous sont rattachs aux inuds. Ainsi toutes les ouvertures dun mme chier, et ` fortiori e e a tous les descripteurs sur ces ouvertures, voient le verrou. La protection ralise par le verrou a donc lieu sur le chier physique. e e Un verrou est la proprit dun seul processus, et seul le processus propritaire du verrou peut le e e e modier ou lenlever, attention le verrou ne prot`ge pas contre les acc`s du processus propritaire e e e (attention ` une situation multi-thread). a
12.1
Caractristiques dun verrou e
Les verrous sont dnis par deux caractristiques : e e La porte : Ensemble des positions du chier auxquelles le verrou sapplique. Cet ensemble e est un intervalle, soit une portion du chier [position1, position2] soit jusqu` la n du chier a [position1, fin de fichier[ dans ce dernier cas si le chier augmente, le verrou prot`ge les nouvelles positions. e Le type : qui dcrit les possibilits de cohabitation des dirents verrous. e e e F RDLCK partag, plusieurs verrous de ce type peuvent avoir des portes non disjointes, par e e exemple les verrous [80, 150] et [100, 123] F WRLCK exclusif, pas de cohabitation possible avec un autre verrou quelque soit son type.
12.2
Le mode opratoire des verrous e
Le mode opratoire joue sur le comportement des primitives read et write. Les verrous dun e chier sont soit consultatifs, soit impratifs (NON-POSIX) 1 . e Dans le premier mode advisory (consultatif), la prsence dun verrou nest teste qu` la pose e e a dun verrou, la pose sera refuse sil existe un verrou de porte non disjointe et que lun des deux e e verrous est exclusif.
1 En eet le mode impratif nest pas POSIX, et donc par dfaut nest pas mise en oeuvre sur les disque sous e e linux.
99
100
CHAPITRE 12. LES VERROUS DE FICHIERS
Dans le second mode mandatory, la prsence de verrous est teste pour la pose mais aussi pour e e les appels syst`mes read et write. e Dans le mode consultatif, les verrous nont deet que sur les processus jouant eectivement le jeu, cest-`-dire, posant des verrous sur les zones du chiers sur lesquels ils veulent raliser une a e lecture (verrou partag) ou une criture (verrou exclusif). e e Dans le mode impratif, les verrous ont un impact sur les lectures/critures de tous les procese e sus : sur les verrous de type partag (F RDLCK), toute tentative dcriture (appel syst`me write) e e e par un autre processus est bloque ; e sur les verrous de type exclusif (F WRLCK), toute tentative de lecture ou dcriture (read e et write) par un autre processus est bloque. e Pour rendre lutilisation imprative il faut sous linux monter le disque avec loption -o mand. e Puis il faut utiliser la commande chmod pour positionner le SETGID bit, soit chmod g+s chier en shell soit la mme chose en C : si lon a le descripteur d dune ouverture sur le chier e #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> ... struct stat buf fstat(d, &buf); fchmod(d,buf.st_mode |
S_ISGID);
mme chose avec stat et chmod si lon la rfrence du chier. e ee
12.3
Manipulation des verrous

{ l_type; l_whence; l_start; l_len; l_pid;
La structure de verrou flock : struct flock short short off_t off_t pid_t }; /* /* /* /* /* F_RDLCK, F_WRLCK,F_UNLCK */ SEEK_SET,SEEK_CUR,SEEK_END */ position relative a l_whence */ longueur de lintervalle */ PID du processus propritaire */ e
le champ l type F RDLCK verrou partag e F WRLCK verrou exclusif F UNLCK dverrouillage e Les manipulations de verrous se font avec la primitive fcntl, cest-`-dire par le biais dun a descripteur. Pour poser un verrou partag, ce descripteur doit pointer sur une ouverture en lecture. e De mme, il faut un descripteur sur une ouverture en criture pour un verrou de type exclusif e e . Pour dcrire la porte du verrou que lon veut poser, on utilise la mme syntaxe que pour la e e e primitive lseek, le dbut de lintervalle est whence+l start : e l whence = SEEK SET whence = 0 l whence = SEEK CUR whence = oset courrant l whence = SEEK END whence = taille du chier.
12.4. UTILISATION DE FCNTL POUR MANIPULER LES VERROUS
101
La longueur du verrou est dnie par le champ l len. Si cette valeur est nulle, le verrou va e jusqu` la n du chier (mme si le processus change cette n). Remarque : il est possible de poser a e un verrou dont la porte est suprieure ` la taille du chier. e e a Le champ l pid contient le pid du processus propritaire du verrou, ce champ est rempli par e fcntl dans le cas dun appel consultatif (F GETLK).
12.4
Utilisation de fcntl pour manipuler les verrous

#include <sys/types.h> #include <unistd.h> #include <fcntl.h> int fcntl(int desc, int commande, struct flock *verrou);
fcntl retourne 0 en cas de succ`s, ou -1 en cas dechec. e Trois commandes possibles : F SETLK pose non bloquante si il existe un verrou incompatible, errno a pour valeur EAGAIN si lon na pas les droits dacc`s sur le chier pour le type de verrou demand, alors e e errno a pour valeur EACCES ; si la pose du verrou cre une situation dinterblocage, alors errno a pour valeur EDEADLK. e F SETLKW pose bloquante (Wait) succ`s immdiat si il ny a pas de verrou incompatible, ou succ`s une fois les verrous e e e incompatibles levs. e si lappel est interrompu, errno a pour valeur EINTR si une situation dinterblocage est dtecte, alors errno a pour valeur EDEADLK. e e F GETLK Test dexistence dun verrou incompatible avec le verrou pass en param`tre (retour e e -1 sur des param`tres incorrects) e si il existe un tel verrou incompatible, alors la structure ock passe en param`tre est e e e remplie avec les valeurs de ce verrou incompatible. Le champ l pid indique alors lidentit du processus propritaire de ce verrou incompatible. e sinon, la structure ock reste inchange except le champ type qui contient F UNLCK. e e Attention, apr`s un test dexistence qui nous informe de labsence de verrou incompatible, nous e ne sommes pas assur quau prochain appel la pose de ce verrou soit possible, en eet un autre e processus a peut-tre pos un verrou incompatible entre-temps (cf. interblocages chapitre 13). e e
102
CHAPITRE 12. LES VERROUS DE FICHIERS
Chapitre 13
Algorithmes Distribus & e Interblocages

Ce chapitre introduit les probl`mes lis ` la gestion de processus concurrents. Le probl`me e e a e ` resoudre est le partage de ressources entre dirents processus asynchrones. Les I.P.C. et les a e verrous sont deux types doutils permettant le partage asynchrone de ressources entre processus.
13.1
13.1.1
exemples
Les mfaits des acc`s concurrents e e
Lexemple le plus simple est une variable enti`re partage par deux processus ou threads, ou e e bien manipul par une fonction asyncrone comme un handler de signal. Supposont que lon dnise e e deux fonctions de manipulation de la variable : int getValue(); void setValue(int ); Pour incrmenter la variable, il sut dexcuter setValue(getValue()+1) ; mais dcomposont e e e en int tmp=getValue() ; setValue(tmp+1) ; ce qui ne change pas grand chose tmp tant sime plement alloue sur la pile dans le premier cas. Regardont lxecution suivant du code par deux e e thread : int tmp1=getValue(); | int tmp2= getValue(); setValue(tmp1+1); | setValue(tmp2+1); Que cest il pass ? e la variable na t incrmente quune fois ! ee e e Le cas dun signal le code c de prog #include <stdio.h> #include <signal.h> int nbi; // nbre dincrementation acc`s atomique e int partage; // nbr dincrmentation acc`s non atomique e e int getValue() { return partage; } 103
104
CHAPITRE 13. ALGORITHMES DISTRIBUES & INTERBLOCAGES
void setValue(int x) { partage = x; } void handler(int s) { int tmp=getValue(); setValue(tmp+1); nbi++; }
int main(int c, char *argv[]) { struct sigaction sig; long diff = 0; sig.sa_handler= handler; sig.sa_flags = 0; sigaction(SIGUSR1, &sig, NULL); fprintf(stderr,"sigusr1= %d\n",SIGUSR1); fprintf(stderr,"%d %d\n", nbi,partage); for(;;) { int tmp=getValue(); setValue(tmp+1); nbi++; if ((partage != nbi) && (diff!= nbi-partage)) { diff = nbi-partage; fprintf(stderr,"%d\n", nbi-partage); } } }
13.1.2
Exclusion mutuelle
Probl`me : il y a une rivi`re que lon peut traverser par un gu fait de pierre alignes, o` e e e e u il nest pas possible de se croiser, et il nest pas possible de faire demi-tour. Comment doit-t-on organiser le passage ? Solutions : 1. regarder avant de traverser 2. si deux personnes arrivent en mme temps sur chaque rive, e si elles avancent en mme temps interblocage e si elles attendent en mme temps interblocage e 3. Un rem`de : un ct prioritaire famine. En eet si le cot OUEST est prioritaire et quun e oe e ot continu de personnes arrive de ce ct, les personnes ` lEST sont bloques indniment. oe a e e 4. Une solution : alterner les priorits. e Pour des ressources syst`me comme les chiers, le partage nest pas gr par le SGF. Il faut e ee donc un mcanisme de partage : les verrous, qui permettent un partage dynamique et partiel (pore tions de chiers). Pour un partage entre utilisateurs, on utilise plutt des outils comme SCCS, RCS. o
13.2. MODE DUTILISATION DES RESSOURCES PAR UN PROCESSUS.
105
13.2
Mode dutilisation des ressources par un processus.
Formalisons les oprations ralisables sur une ressource. e e requte : demande bloquante de ressources e utilisation : lecture/criture sur la zone verrouille e e libration : verrou L-type e
13.3
Dnition de linterblocage (deadlock) e
Un ensemble de processus est en interblocage si et seulement si tout processus de lensemble est en attente dun v`nement qui ne peut tre ralis que par un autre processus de lensemble. e e e e e Exemple : Le processus A poss`de un verrou de porte [0,400] sur un chier f, et demande un verrou e e de porte [800,1000] sur ce mme chier, alors quun processus B poss`de un verrou de porte e e e e [600,900] sur le chier f et demande un verrou de porte [0,33] sur f. Les deux processus sont en e interblocage. Dans le cas de la pose de verrous sous UNIX, il y a dtection de cet interblocage et e la commande fcntl choue. e
13.4
Quatre conditions ncessaires ` linterblocage. e a
Les conditions suivantes sont ncessaires pour avoir une possibilit dinterblocage. e e Exclusion mutuelle les ressources ne sont pas partageables, un seul processus ` la fois peut a utiliser la ressource. Possession & attente il doit exister un processus qui utilise une ressource et qui est en attente sur une requte. e Sans premption les ressources ne sont pas premptibles cest-`-dire que les librations sont e e a e faites volontairement par les processus. On ne peut pas forcer un processus ` rendre une a ressource. (Contre exemple : le CPU sous Unix est premptible) e Attente circulaire il doit exister un ensemble de processus Pi tel que Pi attend une ressource possde par Pi+1 . e e Les quatre conditions sont ncessaires pour quune situation dinterblocage ait lieu. e Exercice : montrer que pour les verrous, les quatre conditions tiennent. Exercice : montrer que si lune des condition nest pas vrie alors il ne peut y avoir dinterblocage. e e
13.5
Les graphes dallocation de ressources
Les graphes dallocation de ressources permettent de dcrire simplement les probl`mes dintere e blocage. G = (N,T) N = P U R P : ensemble des processus R : ensemble des ressources T est inclus dans RXP U PXR Soit le couple (x,y) appartenant ` T, a si (x,y) appartient ` RXP, cela signie que la ressource x est utilise par le processus y. a e si (x,y) appartient ` PXR, cela signie que le processus x demande la ressource y. a
106
CHAPITRE 13. ALGORITHMES DISTRIBUES & INTERBLOCAGES
Chapitre 14
Scurit et S ret de e e u e fonctionnement

Comme pour une habitation il faut que votre syst`me ore deux chose importante, dune part e que la vie dans lhabitation soit sur, pas de risque pour les utilisateurs ni pour les lments matriel. ee e Feux , indondation, enfermement, tremblement de terre etc. Cest la suret de fonctionnement. e Dautre par lhabitation est protge ainsi que ses habitants contre des attaques plus ou moins e e malveillantes. La porte du jardin est ferme pour viter que des animaux dtriore le jardin. Lhae e ee bitation est munie de systme de vrouillage pour se proteger contre un cambriollage. Cest la e e scurit. e e La sret de fonctionnement est un lment statgique qui doit tre grer par la direction u e ee e e e informatique en fonction de contraintes oprationnelles. La scurit est le probl`me de tout le e e e e monde. Pour que la scurit fonctionne, il faut que toutes les personnes ayant un acc`s ` une e e e a ressource soient conscient du degr de scurit associ ` la ressource. La stratgie de scurit doit e e e ea e e e bien sur tre dnie par la direction informatique mais cest un travail collectif (installation dune e e srure na pas deet si tout le monde laisse la porte ouverte). e
14.1
Protection des syst`mes dexploitation e
Scuriser un syst`me, cest protger ce syst`me contre un fonctionnement imprvu ou dfectueux. e e e e e e Il peut sagir : derreurs de programmation (dun utilisateur, ou du syst`me lui-mme) qui se propagent au e e syst`me (du fait de contrles insusants ou mal eectus). e o e dun mauvais fonctionnement du matriel. e enn, dun oprateur, concepteur ou ralisateur malveillant ou peu scrupuleux (quand il e e sagit dinformations nanci`res !). e Le recensement des oprations frauduleuses aux Etats-Unis au cours dune anne a donn 339 cas e e e de fraude, pour un cot dun milliard de francs. u La protection des sites a galement un cot tr`s important (temps et complexit), do` des e u e e u syst`mes de protection qui rsultaient dun compromis cot/ecacit. e e u e Le cot en ressources de la protection tant rest stationnaire, les syst`mes et les machines u e e e actuelles plus rapides ont rendu ce cot moins prohibitif. u Lide dun syst`me de protection est de traiter les dirents types de probl`mes de mani`re e e e e e gnrale et unitaire. e e
107
108
CHAPITRE 14. SECURITE ET SURETE DE FONCTIONNEMENT
Fig. 14.1 Un compromis entre le cout dune attaque et celui de la scurit e e Implants seuls, les dispositifs de protection cotent cher. e u Heureusement, si ces dispositifs permettent daugmenter les performances du logiciel, dans des domaines comme celui de la abilit ou de la rsistance aux erreurs, leur cot relatif diminue. Si, e e u de plus, ces dispositifs permettent une gestion des ressources partages plus facile et plus sre, ils e u peuvent devenir comptitifs dun point de vue commercial. e Il est dicile de dnir prcisment ce que lon entend par protection dun syst`me dexploitae e e e tion (et dinformation en gnral), tant les facteurs qui peuvent inuer sur cette notion (humains, e e sociaux, conomiques), sont nombreux. On peut dire cependant que la protection se rapporte ` e a tout ce par quoi linformation peut tre modie, divulgue ou dtruite. Dans certains cas, la e e e e gestion du trac arien par exemple, elle peut tre la garantie des performances du syst`me. La e e e condentialit denregistrements nanciers, mdicaux ou personnels rel`ve aussi de la protection, e e e comme le fait quun processus utilisateur ne puisse tre excut en mode syst`me. La protection e e e e exige enn la correction des processus syst`me. e prennit du syst`me e e e condentialit des donnes (syst`me, utilisateur, etc.) e e e correction du syst`me e A loppos, nous ne parlerons pas de : e protection physique de lordinateur (feu, vol, coupures, etc.) malveillance ou incomptence de loprateur (il est ventuellement possible de limiter soie e e gneusement les privil`ges du super-utilisateur an de prserver le syst`me). e e e Le degr de protection du syst`me dpend de deux facteurs : e e e le degr de protection des informations quil manipule e le degr de conance en ses logiciels, en particulier le syst`me dexploitation. e e Un logiciel est able quand il satisfait correctement ses spcications et quand, de plus, il est cae pable de rsister ` un environnement imprvu (donnes errones, pannes, etc.), soit en corrigeant e a e e e lanomalie, soit en la signalant, mais en vitant que les erreurs ne se propagent et ne contaminent e le syst`me tout entier. e La protection, lintgrit et lauthenticit des donnes qui transitent dans un syst`me dinformae e e e e tion sont ralises par les syst`mes cryptographiques (ATHENA et Kerberos au MIT). e e e Le connement des erreurs est obtenu en contrlant les acc`s aux entits du syst`me dexploitao e e e tion, par les domaines de protection.
14.2
Gnralits sur le contrle dacc`s e e e o e
Contrle tr`s prcis de lutilisation des ressources par les processus. o e e
` 14.2. GENERALITES SUR LE CONTROLE DACCES
109
Objets Sujets
Processus Processus 1 2 Lire Ecrire Lire Ecrire Executer
Fig. 14.2 Matrice dacc`s e Deux niveaux : un niveau logique (soft), celui du mod`le de protection, ensemble de r`gles qui dnissent e e e quels acc`s (aux ressources) sont autoriss et quels acc`s sont interdits. Ces r`gles sont e e e e dnies soit ` la conception du syst`me, soit par les utilisateurs. e a e un niveau matriel qui permet dappliquer le mod`le rellement. Cest le rle des mcanismes e e e o e de protection. Le premier doit tre dynamique. Par contre, le deuxi`me doit tre stable pour faciliter limplmentation, e e e e le contrle et la abillisation. o Les deux doivent de surcro tre indpendants du mod`le pour orir un vaste ensemble de r`gles t e e e e possibles. Un exemple de protection simple est celui des rpertoires sous unix, pour viter quils soit corome e pus (ou que larborescence soit corompue), il sont identis comme des chiers spciaux et il nest e e possible dy acc`der que par le truchement dappels syst`mes spciques. Biensur il est toujours e e e possible de les manipuler si lon peut acc`der en mode raw au disque dur mais cette option est e rserve au super utilisateur. e e
Fichier 1 Lire
Segment 1 Executer
Segment 2 Lire Ecrire
Processus 2
Editeur Entrer
Entrer
Processus
Entrer Entrer
14.2.1
Domaines de protection et matrices dacc`s e
On formalise le syst`me comme un ensemble dentits actives, les sujets, un ensemble dentits e e e accessibles, les objets. Le mod`le de protection dnit quels sujets ont acc`s ` quels objets et e e e a comment (modalits dacc`s). e e On parle alors de droit dacc`s, dnis par le couple (objet, modalits) e e e Exemple : (chier, lire) Le mod`le doit xer ` tout instant les droits dacc`s dont dispose chaque processus. Cet ene a e semble de droits est le domaine de protection du processus. Voire un exemple de matrice dacc`s e dans la gure 14.2
14.2.2
Domaines de protection restreints
Il est souhaitable que la matrice dacc`s puisse voluer dynamiquement. En eet, un mme e e e processus peut avoir, au cours de son existence, des besoins variables an que chaque module
110
qui compose un processus ne mette pas en danger des ressources non utilises. Par exemple : un e module de lecture de donnes, un module de calcul, un module dimpression. On va donc excuter e e chaque module dans un domaine de protection le plus rduit possible. e Cest le principe du moindre privil`ge : un programme ne peut endommager un objet auquel e il na pas acc`s ! e Pour mettre en place ces domaines dynamiques, une possibilit est de changer les droits dacc`s e e du processus au cours de son excution. Une autre possibilit est dajouter aux objets le type e e domaine et de contrler les acc`s ` la matrice. Ldition de cases de la matrice devient une o e a e opration protge. e e e
14.2.3
Avantages des domaines de protections restreints
Avantages de cette souplesse : le maillon faible : un syst`me rigide laisse souvent des poternes (portes drobes) pour e e e pouvoir implmenter certaines oprations ; e e si les mesures de protection sont trop pesantes, lexprience prouve que lon cre souvent des e e moyens exceptionnels pour les contourner ; il est intressant de faire varier les contrles suivant les utilisateurs ; e o on peut raliser des acc`s ` la carte sur certains objets ; e e a enn, certains probl`mes de protection ncessitent des mesures souples, ce sont : le cheval e e de Troie et le connement.
14.3
Le cheval de Troie
Un utilisateur fait souvent appel ` un certain nombre de programmes quil na pas crit luia e mme (heureusement), un diteur par exemple. Ce programme peut tre un cheval de Troie : il va e e e proter des droits donns par lutilisateur pour consulter, copier, modier ou altrer des donnes e e e auxquelles il nest pas cens accder. e e
14.4
Le connement
Le probl`me ici est tout simplement le fait que le programme ne manipule pas de donnes de e e lutilisateur mais simplement enregistre ses param`tres dappels (les utilisateurs ` qui vous envoyez e a du courrier par exemple). Le probl`me du connement est donc de vous protger contre ce type e e dextraction dinformations (ce qui peut par exemple tre utilis en bourse pour connaitre votre e e comportement dachat).
14.5
les mcanismes de contrle e o
Acc`s hirarchiques e e UNIX (4)/ MULTICS (8) / VMS Listes dacc`s e UNIX/MULTICS Capacits e Les capacits sont des triplets (utilisateur, droits, pointeur). La manipulation des capae cits est ralise de faon protge. Le pointeur nest pas directement utilisable par lutilisateur e e e c e e de la capacit. La capacit donne le droit dacc`s ` certains utilisateurs dune certaine ressource. e e e a Pour quun autre utilisateur puisse utiliser votre ressource, vous devez lui donner une capacit. e Changer de protection revient ` changer de C-liste. a La notion de domaine se matrialise par une simple indirection sur une autre C-liste. e Comme les capacits donnent un acc`s sans contrle aux objets, la protection des capacits e e o e doit tre absolue. Elle est donc ralise de faon matrielle. e e e c e
Objets
Fichier 1 Lire Domaine Domaine 2 Lire Ecrire Lire Ecrire Executer Processus i Entrer 1 Executer Lire Ecrire Entrer Segment 1 Segment 2 Processus 2 Editeur Domaine Domaine 1 2 Entrer Entrer
14.5. LES MECANISMES DE CONTROLE
Sujets
Entrer
Fig. 14.3 Matrice dacc`s e
Nom Modalitees dacces Pointeur

Domaine 3 Entrer Entrer Domaine i
Fig. 14.4 Une capacit e
Objet
111
112
Nom Editeur Proc Fic1 Fic2
Modalitees dacces Pointeur Executer Lire,Executer Lire
Code Editeur
Code Procedure Fichier
Lire,Ecrire Fichier
Fig. 14.5 Une liste de capacits e
14.5.1
Application des capacits au domaines de protection restreints e
Les C-listes sont des objets dun type nayant quun droit dentre, la C-liste contenant le droit e rel. e Cette technique sur les C-listes permet dimplanter facilement le principe de moindre privil`ge. e Les mcanismes dacc`s mmoire modernes permettent aisment de raliser les capacits. e e e e e e Un probl`me important est la rvocation e e En eet, une fois que vous avez donn une capacit, lacc`s est dnitivement donn. Pour e e e e e rgler ce probl`me, on ne fournira pas la capacit dacc`s ` un objet mais ` un domaine, et on e e e e a a dtruira ce domaine si lon veut de nouveau interdire lacc`s ` lobjet. On cre deux capacits en e e a e e chaine et lon dtruit celle que lon poss`de quand ont veut retirer lacc`s. e e e
14.5. LES MECANISMES DE CONTROLE
113
Proc
Entrer Objet
C-liste1
Entrer . . .
Liste des Capacites de la Procedure appelante
Liste des Capacites de la Procedure appelee
Fig. 14.6 Changement du domaine de protection
O Lire,Ecrire
Objet O Objet
O Lire,revoquer
Copie
O Copies O
Lire
O O Lire,Ecrire
Lire
Lire
Fig. 14.7 Transmission dune capacit e
114
O Lire,Ecrire
Objet O Objet
O Lire,revoquer
Copie
O Copies O
Lire
Lire Revocation
Lire
Fig. 14.8 Rvocation dune capacit e e
14.6. LES ACL
115
14.6
Les ACL
Les ACL (access control lists) sont une extension des modes de protection standard dUNIX. Les ACL sont des droits que lon dnit en plus des 9 bits de protection classiques, ils permettent e en particulier dautoriser lacc`s ou de le refuser, ` un utilisateur donn, ou ` un groupe donn. e a e a e Deux commandes permettent de manipuler les ACL, ce sont chacl et lsacl. La syntaxe de la commande shell chacl : chacl (dr.staff,r-x)(zipstein.%,r-x)(%.licence,---) proj qui donne sur le chier proj les droits de lecture et dcriture ` lutilisateur dr du groupe e a staff et ` lutilisateur zipstein quelque soit son groupe et qui refuse cet acc`s aux utilisateurs a e du groupe licence. chacl (binome.%,rwx)(%.@,--x)(%.%,---) catalogue projet qui donne le droit dacc`s total ` lutilisateur binome (quelque soit son groupe), permet le e a parcours du rpertoire aux membres du groupe propritaire et refuse lacc`s ` tous les autres utie e e a lisateurs. Deux symboles spciaux : e % pour nimporte qui (utilisateur ou groupe) @ pour le propritaire ou le groupe propritaire e e On retrouve aussi les autres syntaxes de chmod par exemple : chacl %.%=r fichier ou chacl @.%=5 fichier Attention les acl sont dtruits par la commande chmod et la commande chacl ne permet pas e de positioner les autres bits dnis dans linode ; seuls les 9 bits de protections sont positionnables e par chacl. Pour positionner les droits standard et des acl, il faut donc raliser en succession un chmod e puis un chacl. On utilisera : chacl (prof.%,rwx) catalogue projet pour les projets de C ou de syst`me. e La commande lsacl [fichiers] permet de conna les acl associs aux chiers, remarquer tre e qu` linverse de /bin/ls cette commande na pas de param`tres par dfaut. a e e
14.6.1
Appels systemes setacl et getacl
On trouvera deux appels syst`mes correspondant : e #include <sys/acl.h> int setacl( const char *path, size t nentries, const struct acl entry *acl ); int fsetacl( int fildes, size t nentries, const struct acl entry *acl
116 );
Un bon exercice : rcrire lsacl de faon quil fonctionne dune mani`re similaire ` /bin/ls. e c e a Utilisation de la commande script pour montrer le comportement des acl. Script started on Fri May 5 10:33:20 1995 $ lsacl * (dr.%,rw-)(%.staff,---)(%.%,---) fich (dr.%,rw-)(%.staff,---)(%.%,---) file (dr.%,rwx)(%.staff,---)(%.%,---) projet $ chacl (prof.%,rwx) fich $ lsacl * (prof.%,rwx)(dr.%,rw-)(%.staff,---)(%.%,---) fich (dr.%,rw-)(%.staff,---)(%.%,---) file (dr.%,rwx)(%.staff,---)(%.%,---) projet $ chacl (%.staff,rx) fich $ lsacl * (prof.%,rwx)(dr.%,rw-)(%.staff,r-x)(%.%,---) fich (dr.%,rw-)(%.staff,---)(%.%,---) file (dr.%,rwx)(%.staff,---)(%.%,---) projet $ chacl (illouz.staff= fich $ lsacl fich (illouz.staff,---)(prof.%,rwx)(dr.%,rw-)(%.staff,r-x)(%.%,---) fich $ chacl (prof.%,rx) . .. $ su prof Password: $ cat fich $ touch fich $ chacl (dr.staff,x) fich chacl: file "fich": Not owner (errno = 1) $ lsacl * (illouz.staff,---)(prof.%,rwx)(dr.%,rw-)(%.staff,r-x)(%.%,---) fich (dr.%,rw-)(%.staff,---)(%.%,---) file (dr.%,rwx)(%.staff,---)(%.%,---) projet $ exit # du su $ exit # du script script done on Fri May 5 10:37:18 1995
14.6.2

Autres pistes sur la scurit e e
crack et autres logiciels dattaque de mots de passe root-x et autres Pots de Miel virus et logiciels antivirus (sous linux ? ? ? ?) Gestion des mots de passe Honey Pot Haute disponibilit e Redondance RAID (cf chapitre) Distribution de disques SAN Clusters keep alive Sauvegardes et syst`mes de sauvegarde e
14.6. LES ACL Les attaques par dni de services e
117
118
Chapitre 15
Multiplexer des entres-sorties e

15.1 Gerer plusieurs cannaux dentre sortie e
Dans ce chapitre, nous voulons prsenter le probl`me des attentes actives sur plusieurs dese e cripteurs. Lexemple le plus frquent est celui dun serveur web, le serveur doit grer simultanment un e e e tr`s grand nombre de ux dentre et de ux de sortie et de ux de contrle (les information de e e o contrle des sockets). o
15.1.1
Solution avec le mode non bloquant
Il est possible dutiliser des entre-sorties non bloquantes mais cest loing dtre la solution e e optimal car notre processus vas raliser de nombreux appels syst`me inutile dautant plus si dans e e le cas dun serveur avec des comportements de clients tr`s allatoires. Le cot en ressources de e e u cette attente active est extrmement cher, et doit tre vit dans le cas dune machine en temps e e e e partag. e
15.1.2
Utiliser les mcanismes asynchrones e
On peut utiliser des entres-sorties asynchrones et demander au noyau de nous prvenir par un e e signal qui informe de larrive de donnes sur un descripteur. Ce signal est SIGIO, mais ce nest e e valable que sur les descripteurs qui sont des priphriques. De plus ce mcanisme ne dsigne pas e e e e le descripteur sur lequel sest faite larrive de caract`res, do` de nouvelles pertes de temps des e e u u aux appels raliss inutilement en mode non bloquant. e e
15.2
Les outils de slection e
La solution la plus ecase vient de syst`mes de slection qui prend un param`tre un ensemble e e e de descripteurs, et qui permet tester si lun de ses descripteurs est pr`s ` satisfaire un appel syst`me e a e read ou write. Cet appel est bloquant jusqu` larrive de caract`res sur un des descripteurs de a e e lensemble. Ainsi il ny pas de consomation de ressource processus inutile, le travail est fait ` un a niveau plus bas (dans le noyau) de faon plus conomique en ressources. c e
15.2.1
La primitive select
La premi`re implmentation dun outil de selection sous Unix est lappel syst`me select, male e e heureusement sa syntaxe est devenu inadapt pour cituations ou le nombre de descipteur utilis e e par le programme est tr`s grand ce qui peut arriver facilement avec un serveur de chier. Nous e fournissont ` la primitive select : a 119
120
CHAPITRE 15. MULTIPLEXER DES ENTREES-SORTIES
Les descripteurs que nous voulons scruter. (lindice du plus grand descripteur qui nous intresse dans la table des descripteurs du processus) e Les conditions de rveil sur chaque descripteur (en attente de lecture, criture, v`nement ?) e e e e Combien de temps nous voulons attendre. La fonction retourne pour chaque descripteur sil est prt en lecture, criture, ou si lv`nement e e e e a eu lieu, et aussi le nombre de descripteur prts. Cette information nous permet ensuite dappeler e read ou write sur le(s) bon(s) descripteur(s). #include #include #include <sys/types.h> <sys/time.h> <unistd.h>
int select(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *exceptfds struct timeval *delai); Retourne le nombre de descripteurs prts, 0 en cas dexpiration du dlai. e e Paramtrage du dlai : e e struct timeval { long tv_sec; long tv_usec; }; delai == NULL Bloquant, attente innie delai->tv sec == 0 && delai->tv usec == 0 Non bloquant, retour immdiat. e delai->tv sec > 0 && delai->tv usec >0 Semi bloquant, attente jusqu` ce quun descripa teur soit prt ou que le dlai en secondes plus microsecondes soit coul. e e e e Les trois pointeurs (readfds, writefds, et exceptfds) sur des ensembles de descripteurs sont utiliss pour indiquer en entre les situations qui nous intressent. Cest ` priori (cela peut varier e e e a avec limplmentation) des tableaux de bits avec un bit pour chaque descripteur du tableau de e descripteurs du processus. Lentier maxfd est la position du dernier bit signicatif de ce tableau de bits. Les seules faons de manipuler ces ensembles de descripteurs sont : c Allocation :fd\_set *fd=(fd\_set*)malloc(sizeof(fd\_set)); Cration e Aectation Utilisation dune des quatre macros suivantes : FD ZERO(fd set fdset) RAZ de lensemble. FD SET(int fd, fd set *fdset) Positionne le bit fd a 1. FD CLR(int fd, fd set *fdset) Positionne le bit fd ` 0 a FD ISSET(int fd, fd set *fdset) vrai si le bit fd est ` 1 dans lensemble. a Un descripteur est considr comme prt en lecture si un appel read dessus ne sera pas bloee e quant. De mme, un descripteur est considr comme prt en criture si un appel write ne sera pas e ee e e bloquant. Les exceptions / v`nements sont dnis pour les lignes de communication qui acceptent e e e les messages hors bande comme les sockets en mode datagramme.
15.2. LES OUTILS DE SELECTION
121
15.2.2
La primitive poll
La primitive poll fournit un service proche de select avec une autre forme dinterface. Cette interface est adapte quand le nombre de descripteurs ouvert par le processsus est tr`s grand mais e e que lon ne sintr`sse qua un petit nombre de ceux-ci. ee #include <stropts.h> #include <poll.h> int poll(struct pollfd fdarray[], unsigned long nfds, int timeout ); struct pollfd int short short }; { fd; events; revents;
Ici on spcie la liste de descripteurs (dans un tableau) et ce que lon veut g`ter sur chacun e e deux. La valeur de retour est -1 en cas derreur, 0 si le temps dattente timeout est coul, ou un e e entier positif indiquant le nombre de descripteurs pour lesquels la valeur du champ revents a t ee modie. e Les v`nements sont ici : e e Pour les v`nements de events : e e POLLIN Donnes non prioritaire peuvent tre lues. e e POLLPRI Donnes prioritaire peuvent tre lues. e e POLLOUT Donnes non prioritaire peuvent tre crites, les messages de haute priorit peuvent e e e e toujours tres crits. e e Pour les revents (valeurs de retour de la primitive poll) : POLLIN,POLLPRI les donnes sont l`. e a POLLOUT lcriture est possible e POLLERR Une erreur a eu lieu. POLLHUP La ligne a t coupe. ee e POLLNVAL Descripteur invalide. Le mode de blocage de la primitive poll dpend du param`tre timeout e e timeout == INFTIM Bloquant, INFTIM est dni dans stropts.h. e timeout == 0 Non bloquant. timeout > 0 Semi bloquant, attente de timeout micro secondes.
Un Exemple Attente de donnes sur ifd1 et ifd2, de place pour crire sur ofd, avec un e e dlai maximum de 10 seconds : e #include <poll.h> struct pollfd fds[3] ; int ifd1, ifd2, ofd, count ;
fds[0].fd = ifd1 ; fds[0].events = POLLIN ; fds[1].fd = ifd2 ; fds[1].events = POLLIN ; fds[2].fd = ofd ;
122
fds[2].events = POLLOUT ; count = poll(fds, 3, 10000) ; if (count == -1) { perror("poll failed") ; exit(1) ; } if (count==0) printf("Rien \n") ; if (fds[0].revents & POLLIN) printf("Donnes a lire sur ifd%d\n", fds[0].fd) ; e if (fds[1].revents & POLLIN) printf("Donnes a lire sur ifd%d\n", fds[1].fd) ; e if (fds[2].revents & POLLOUT) printf("De la place sur fd%d\n", fds[2].fd) ;
15.2.3
Le priphrique poll e e
Dans le cas de serveur travaillant avec un tr`s grand nombre de descripteurs (plueirus dizaine e de milliers de descripteurs) les deux syntaxes poll et select sont incaces. Soit dans le cas e deselect car le nombre de descripteurs scruts par le noyau est tr`s grand alors quun tr`s faible e e e par dentre eux sont inutilis. Soit dans le cas de poll car il faut manipuler avant chaque appel e un tr`s grand tableau et que le syst`me doit relire ce tableau a chaque appel. e e Pour rsoudre ce probl`me une nouvelle interface a t mise au point /dev/poll. Cette interface e e ee permet de crer un priphrique poll dans lequel il sut dcrire pour ajouter un descripteur a e e e e la liste des descipteurs que le noyau doit scruter. Et il sut dcrire de nouveau pour retirer un e descripteur. Epoll est un patch du noyau !1 1. Il faut verier la prsence depoll sur votre syst`me, ouvrer le priphrique /dev/epoll en e e e e mode O RDWR, sinon retour a select et poll kdpfd = open("/dev/epoll",O_RDWR); 3. Allouer un segment de mmoire partag avec char *map = (char *)mmap(NULL, EP MAP SIZE(maxfds, e e PROT READ | PROT WRITE, MAP PRIVATE, epoll fd, 0)) 4. Maintenant vous pouvez ajouter des descipteurs struct pollfd pfd; pfd.fd = fd; pfd.events = POLLIN | POLLOUT | POLLERR | POLLHUP; pfd.revents = 0; if (write(kdpfd, &pfd, sizeof(pfd)) != sizeof(pfd)) { /* gestion derreur */ } 5. Rcupere les venements e e struct pollfd *pfds; struct evpoll evp; for (;;) { evp.ep_timeout = STD_SCHED_TIMEOUT; evp.ep_resoff = 0; nfds = ioctl(kdpfd, EP_POLL, &evp);
1 Il
2. Dniser le nombre maximal maxfd de descipteurs scrutables #include <linux/eventpoll.h> \ldots ioctl(epol e
existe deux version une version /Dev/poll et une version /dev/epoll qui faut utiliser car plus ecasse.
15.3. UNE SOLUTION MULTI-ACTIVITES pfds = (struct pollfd *) (map + evp.ep_resoff); for (ii = 0; ii < nfds; ii++, pfds++) { traitmement(pfds[ii].fd, pfds[ii].revents); } } 6. Retirer des descripteurs pfd.fd = fd; pfd.events = POLLREMOVE; pfd.revents = 0; if (write(kdpfd, &pfd, sizeof(pfd)) != sizeof(pfd)) { /* gestion derreur */ }
123
Le petit dtail technique gnial de cette interface est le fait que pendant que vous rcupere des e e e venements le syst`me continu a travailler pour vous dans le segment de mmoire fournis par mmap e e e ce qui fait que votre programme sexcute en parall`le de la rcupration dinformation sur les e e e e priphriques et que lappel ioctl est ainsi tr`s rapide. e e e
15.2.4
Les extensions de read et write
Une extension readv, writev de read et write permet en un seul appel syst`me de raliser e e lcriture de plusieurs zones mmoire non contigus, ce qui permet dacclerer certaines entrese e e e e sorties structures. Mais aussi de mieux organiser les appels syst`me dans notre cas. e e #include <sys/types.h> #include <sys/uio.h> ssize_t readv(int fd, const struct iovec iov[], int iovl); ssize_t writev(int fd, const struct iovec iov[], int iovl); struct iovec { void *iov_base ; int iov_len; };
15.3
une solution multi-activits e
Lutilisation de plusieurs activits (threads, voir chapitre 16) permet de raliser plusieurs appels e e de read en simultan, le premier read qui se dbloque entraine lexcution de lactivit le ralisant, e e e e e ainsi le cot dattente sur les descripteurs est minimal le syst`me signalant imdiatement ` la thread u e e a lvenement. Le seul probl`me est davoir a grer cette multiplicit dactivits, ce qui est dans le e e e e e cas dun simple echange bidirectionel est raisonable il sut de deux activits indpendantes. e e Pour un serveur de chier cette solutions multi-activit peut ne pas supporter la mont en e e charge le nombre de threads tant limit plus rapidement que celui des descripteurs (a ma connaise e sance ont peut crer au plus 10000 threads sous linux et xp) e Pour une situation plus complexe comme un serveur de partage de donnes, des mcanismes e e dexclusion mutuelle entre activits devront tre mis en oeuvre, ce qui peut compliquer inutilement e e le probl`me. La solution avec un seul processus grant rapidement des requtes multiples sur e e e plusieurs ux tant plus simple a raliser. e e
124
Chapitre 16
Les threads POSIX

La programmation par thread (actvit) est naturelle pour grer des phnom`nes asyncrones. e e e e Les entres utilisateur dans les interfaces graphiques (souris, clavier) sont plus facile a grer si lon e e peut sparer lactivit principale du logiciel de la gestion des commandes utilisateur. Les entres e e e sorties multiples voir le chapitre 15 correspondant, sont gres plus simplement en utilisant des ee threads. Les actvitis sont une nouvelle faon de voire les processus dans un syst`me. Lide est de e c e e sparer en deux le concept de processus. La premi`re partie est lenvironement dexcution, on y e e e retrouve une tr`s grande partie des lments constitutifs dun processus en particulier les infore ee mations sur le propritaire, la position dans larborescence le masque de cration de chier etc. e e La deuxi`me partie est lactivit, cest la partie dynamique, elle contient une pile, un context e e processeurs (pointeur dinstruction etc), et des donnes dordonancement. e Lide de ce dcoupage est de pouvoir associer plusieurs activit au mme environement e e e e dexcution. Pour CHORUS lensemble des ressources dun environnement dexcution est appel e e e des acteurs, MACH parle de tches et AMOEBA de process. Mais tous dsigne lunit dexcution a e e e par le terme de thread of control. Organisation en mmoire pour un processus UNIX avec plusieurs threads : voir gure 16.1. e On peut grace au thread grer plusieurs phnom`nes asyncrone dans le mme contexte, cest e e e e ` dire, un espace dadressage commun, ce qui est plus confortable que de la mmoire partage et a e e moins couteux en ressource que plusieurs processus avec un segment de mmoire partag. e e Un processus correspond ` une instance dun programme en cours dxcution. Un thread a e e correspond ` lactivit dun processeur dans le cadre dun processus. Un thread ne peut pas a e exister sans processus (la tche englobante), mais il peut y a voir plusieurs thread par processus, a dans le cas de linux il ne peut y a voir de tche sans au moins une activit. a e
16.0.1
Description
Un processus est compos des parties suivantes : du code, des donnes, une pile, des descripteurs e e de chiers, des tables de signaux. Du point de vue du noyau, transfrer lexcution ` un autre e e a processus revient ` rediriger les bons pointeurs et recharger les registres du processeur de la pile. a Les divers threads dun mme processus peuvent partager certaines parties : le code, les donnes, e e les descripteurs de chiers, les tables de signaux. En fait, ils ont au minimum leur propre pile, et partagent le reste.
16.0.2
fork et exec
Apr`s un fork, le ls ne contient quune seule activit (celle qui a excut le fork). Attene e e e tion aux variables dexclusion mutuelle (qui font partie de lespace dadressage partag) qui sont e 125
126
CHAPITRE 16. LES THREADS POSIX
Donnes de la Tache rpertoire de travail umask Descripteurs Accs aux tables de pages * programme * donnes globales * pile globale Propritaires Scheduling Donnes de Registres laThread 1 Pile noyau Scheduling Donnes de Registres laThread 2 Pile noyau Scheduling Donnes de Registres laThread 3 Pile noyau
Fig. 16.1 Organisation mmoire, partage des fonctions entre le processus et les activits e e
127 conserves apr`s le fork() et dont le contenu ne varie pas. Ainsi si une activit a pris le smaphore e e e e avant le fork(), si lactivit principale cherche ` prendre ce smaphore apr`s le fork() elle sera e a e e indniment bloque. e e Apr`s un exec, le processus ne contient plus que la thread qui a excut lune des six commandes e e e exec. Pas de probl`me avec les smaphores comme lespace dadressage a chang. e e e
16.0.3
clone
Sous linux (et rarement sous les syst`mes Unix) il existe un appel syst`me un peut spcial. Cet e e e appel syst`me ralise un ddoublement du processus comme fork dou son nom de clone. Cet e e e appel syst`me permet de prciser exactement ce que lon entend partager entre le processus p`re e e e et le processus ls. Elments partageables : e ppid Cration dun fr`re au lieux dun ls. e e FS Partage de la structure dinformation lie au syst`me de chier (., /, umask), e e FILES Partage de la table des descripteurs, SIGHAND Partage de la table des gestionnaires de Signaux, mais pas des masques de signaux, PTRACE Partage du crochet (hook) de debug voire lappel ptrace. VFORK Partage du processeur ! le processus p`re est bloqu tantque le ls na pas excut soit e e e e exit soit execve, cest ` dire quil sest dtach de tout les lment partageable du processus a e e ee p`re (sauf les FILEs), e VM Partage de la mmoire virtuelle, en particulier les allocations et dsallocations par mmap et e e munmap sont visibles par les deux proccessus. pid Les deux processus ont le mme numro. e e THREAD Partage du groupe de thread, les deux processus sont ou ne sont pas dans le mme e groupe de threads.
16.0.4
Les noms de fonctions
pthread[_objet]_operation[_np] o` u objet dsigne si il est prsent le type de lobjet auquel la fonction sapplique. Les valeurs possibles e e de objet peuvent tre e cond pour une variable de condition mutex pour un smaphore dexclusion mutuelle e opration dsigne lopration a raliser, par exemple create, exit ou init e e e e le suxe np indique, si il est prsent, quil sagit dune fontion non portable, cest-`-dire Hors e a Norme.
16.0.5
les noms de types
pthread[_objet]_t avec objet prenant comme valeur cond, mutex ou rien pour une thread.
128
16.0.6
Attributs dune activit e
Identication dune pthread : le TID de type pthread t obtenu par un appel ` la primitive : a pthread_t pthread_self(void); pour le processus propritaire e pid_t getpid(void); En POSIX, le fait de tuer la thread de numro 1 a pour eet de tuer le processus ainsi que e toutes les autres threads ventuelles du processus. e Pour tester lgalit de deux pthreads on utilise e e int pthread_equal(pthread_t tid1, pthread_t tid2);
16.0.7
Cration e
Cration et terminaison des activits e e

*p_tid, attr, *(*fonction) (void *arg), *arg
int pthread_create (pthread_t pthread_attr_t void void );
La cration et lactivation dune activit retourne -1 en cas dechec, 0 sinon. e e le tid de la nouvelle thread est plac ` ladresse p_tid ea attr attribut de lactivit (ordonnancement), utiliser pthread attr default e la param`tre fonction correspond ` la fonction excute par lactivit apr`s sa cration : il e a e e e e e sagit donc de son point dentre (comme la fonction main pour les processus). Un retour de e cette fonction correspondra ` la terminaison de cette activit. a e le param`tre arg est transmis ` la fonction au lancement de lactivit. e a e Terminaison a) les appels UNIX exit et donc exit terminent toutes les threads du processus. b) Terminaison dune thread int pthread_exit (int *p_status); p status code retour de la thread, comme dans les processus UNIX la thread est zombie e pour attendre la lecture du code de retour par une autre thread. A linverse des processus, comme il peut y avoir plusieurs threads qui attendent, la thread zombie nest pas libre par la lecture du ee p status, il faut pour cela utiliser une commande spciale qui permettra de librer eectivement e e lespace mmoire utilis par la thread. e e Cette destruction est explicitement demande par la commande e int pthread_detach (pthread_t *p_tid); Si un tel appel a lieu alors que lactivit est en cours dexcution, cela indique seulement qu` e e a lexcution de pthread_exit les ressources seront restitues. e e
16.1
Synchronisation
Trois mcanismes de synchronisation inter-activits : e e la primitive join les smaphores dexclusion mutuelle e les conditions (v`nements) e e
16.1. SYNCHRONISATION
129
extern int errno; Thread 1 access Thread 2
open
Lecture incorrecte
Fig. 16.2 Changement de la valeur errno par une autre thread
16.1.1
Le mod`le fork/join (Paterson) e
Les rendez-vous : join La primitive int pthread_join (pthread_t tid, int **status); permet de suspendre lexcution de lactivit courante jusqu` ce que lactivit tid excute e e a e e un appel (implicite ou explicite) ` pthread exit. Si lactivit tid est dj` termine, le retour est a e ea e immdiat, et le code de retour de lactivit vise est gal ` **status (double indirection). e e e e a La primitive retourne : 0 en cas de succ`s e -1 en cas derreur EINVAL si le tid est incorrect ESRCH activit inexistante e EDEADLOCK lattente de lactivit spcie conduit ` un interblocage. e e e a
16.1.2
Le probl`me de lexclusion mutuelle sur les variables gres par e e e le noyau
Il est ncessaire davoir plusieurs variables errno, une par activit. En eet cette variable e e globale pourrait tre change par une autre activit. Voir plus loin comment dnir des variables e e e e globales locales ` chaque activit. a e
16.1.3
Les smaphores dexclusion mutuelle e
Ces smaphores binaires permettent dassurer lexclusion mutuelle. e Il faut dnir un objet de type pthread mutex t qui correspond ` un ensemble dattributs e a de type pthread mutexattr t (on utilisera en gnral la constante pthread mutexattr default ). e e Initialiser la variable par un appel ` la fonction a int pthread_mutex_init(pthread_mutex_t *p_mutex, pthread_mutexattr_t attr); On pourra dtruire le smaphore par un appel ` la fonction e e a int pthread_mutex_destroy(pthread_mutex_t *p_mutex);
130
16.1.4
Utilisation des smaphores e
Opration P : e Un appel ` la fonction a pthread_mutex_lock (pthread_mutex_t *pmutex); permet ` une activit de raliser une opration P sur le smaphore. Si le smaphore est dj` a e e e e e ea utilis, lactivit est bloque jusqu` la ralisation de lopration V (par une autre activit) qui e e e a e e e lib`rera le smaphore. e e Opration P non bloquante : e pthread_mutex_trylock (pthread_mutex_t *pmutex); renvoie 1 si le smaphore est libre e 0 si le smaphore est occup par une autre activit e e e -1 en cas derreur. Opration V : e Un appel ` la fonction a pthread_mutex_unlock(pthread_mutex_t *pmutex); ralise la libration du smaphore dsign. e e e e e
16.1.5
Les conditions (v`nements) e e
Les conditions permettent de bloquer une activit sur une attente dv`nement. Pour cela e e e lactivit doit possder un smaphore, lactivit peut alors librer le smaphore sur lv`nement, e e e e e e e e cest-`-dire : elle lib`re le smaphore, se bloque en attente de lv`nement, ` la rception de a e e e e a e lv`nement elle reprend le smaphore. e e e Initialisation dune variable de type pthread_cond_t int pthread_cond_init (pthread_cond_t *p_cond, pthread_condattr_t attr); Lattente sur une condition int pthread_cond_wait (pthread_cond_t *p_cond, pthread_mutex_t *p_mutex); Trois tapes e 1. libration sur smaphore *p mutex e e 2. activit mise en sommeil sur lv`nement e e e 3. rception de lv`nement, rcupration du smaphore e e e e e e La condition est indpendante de lvnement et nest pas ncessairement valide ` la rception e e e e a e (cf. exemple). Exemple, le programme suivant : pthread_mutex_t m; pthread_cond_t cond; int condition = 0; void *ecoute(void *beurk) { pthread_mutex_lock(m); sleep(5); while (!condition) pthread_cond_wait(cond, m);
16.1. SYNCHRONISATION pthread_mutex_unlock(m); pthread_mutex_lock(print); printf(" Condition realisee\n"); pthread_mutex_unlock(print); } main() { pthread_t lathread; pthread_create(lathread, pthread_attr_default, ecoute, NULL); sleep(1); pthread_mutex_lock(m); condition = 1; pthread_mutex_unlock(m); pthread_cond_signal(cond); }
131
Un autre exemple dutilisation de condition avec deux threads qui utilisent deux tampons pour raliser la commande cp, avec une activit responsable de la lecture et lautre de lcriture. Les e e e conditions permettent de synchroniser les deux threads. Ici nous utilisons la syntaxe NeXT/MACH. #include <sdtio.h> #include <fcntl.h> #import <mach/cthreads.h> enum { BUFFER_A_LIRE = 1, BUFFER_A_ECRIRE = -1 }; mutex_t lock1; condition_t cond1; char int int int /* variables de protection et dexclusion */
buff1[BUFSIZ]; nb_lu1; etat1 = BUFFER_A_LIRE; ds, dd; /* descripteurs source et destination */
lire() /* activite lecture */ { for(;;) { /* lecture dans le buffer 1 */ mutex_lock(lock1); while (etat1 == BUFFER_A_ECRIRE) condition_wait(cond1, lock1); nb_lu1 = read(ds, buff1, BUFSIZ); if (nb_lu1 == 0) { etat1 = BUFFER_A_ECRIRE; condition_signal(cond1); mutex_unlock(lock1); break; } etat1 = BUFFER_A_ECRIRE; condition_signal(cond1); mutex_unlock(lock1);
132 } } ecrire() { for(;;) { /* ecriture du buffer 1 */ mutex_lock(lock1); while (etat1 == BUFFER_A_LIRE) condition_wait(cond1, lock1); if (nb_lu1 == 0) { mutex_unlock(lock1); exit(0); } write(dd, buff1, nb_lu1); mutex_unlock(lock1); etat1 = BUFFER_A_LIRE; condition_signal(cond1); } } main() { ds dd lock1 cond1
= = = =
open(argv[1], O_RDONLY); open(argv[2], O_WRONLY|O_TRUNC|O_CREAT, 0666); mutex_alloc(); condition_alloc();
cthread_fork((cthread_fn_t)lire, (any_t)0); ecrire(); /* la thread principale realise les ecritures */ }
16.2
16.2.1
Ordonnancement des activits e

Lordonnancement POSIX des activits e
Lordonnancement des activits DCE bas sur POSIX est tr`s similaire ` lordonnancement e e e a des activits sous MACH. Deux valeurs permettent de dnir le mode dordonnancement dune e e activit : e la politique et la priorit. e Pour manipuler ces deux valeurs, il vous faut crer un objet attribut dactivit (pthread_attr) en e e appelant pthread_attr_create(), puis changer les valeurs par dfaut avec les fonctions dcrites e e plus loin et crer la pthread avec cet objet pthread_attr. Ou bien la pthread peut elle-mme e e changer ses deux valeurs, priorit et politique. e Les fonctions sont : #include <pthread.h> pthread_attr_setsched(pthread_attr_t *attr, int politique); Les direntes politiques possibles sont : e e a SCHED FIFO La thread la plus prioritaire sexcute jusqu` ce quelle bloque. Si il y a plus dune pthread de priorit maximum, la premi`re qui obtient le cpu sexcute jusqu` ce e e e a quelle bloque.
` 16.3. LES VARIABLES SPECIFIQUES A UNE THREAD
133
SCHED RR Round Robin. La thread la plus prioritaire sexcute jusqu` ce quelle bloque. Les e a threads de mme priorit maximum sont organises avec le principe du tourniquet, cest-`e e e a dire quil existe un quantum de temps au bout duquel le cpu est prempt pour une autre e e thread (voire Chapitre 6 sur les Processus). SCHED OTHER Comportement par dfaut. Tous les threads sont dans le mme touniquet, il e e ny a pas de niveau de priorit, ceci permet labsence de famine. Mais les threads avec une e politique SCHED FIFO ou SCHED RR peuvent placer les threads SCHED OTHER en situation de famine. e SCHED FG NP (option DCE non portable) Mme politique que SCHED OTHER mais lordonnanceur peut faire voluer les priorits des threads pour assurer lquit. e e e e SCHED BG NP (option DCE non portable) Mme politique que SCHED FG NP, mais les threads e avec une politique SCHED FIFO ou SCHED RR peuvent placer les threads SCHED BG NP en situation de famine. pthread_attr_setprio(pthread_attr_t *attr, int prio); La priorit varie dans un intervalle dni par la politique : e e PRI OTHER MIN <= prio <= PRI OTHER MAX PRI FIFO MIN <= prio <= PRI FIFO MAX PRI RR MIN <= prio <= PRI RR MAX PRI FG MIN NP <= prio <= PRI FG MAX NP PRI BG MIN NP <= prio <= PRI BG MAX NP Ces deux fonctions retournent 0 en cas de succ`s et -1 sinon. La valeur de errno indiquant si e lerreur est une question de param`tres ou de permission. e Les deux fonctions que lon peut appeler sur une pthread pour changer sa priorit ou sa e politique sont : pthread_setprio(pthread_t *unepthread, int prio); pthread_setsched(pthread_t *unepthread, int politique, int prio); Il est possible de conna la priorit ou la politique dune pthread ou dun objet pthread attr tre e avec : pthread_attr_getprio(pthread_attr_t *attr,int prio); pthread_attr_getsched(pthread_attr_t *attr,int politique); pthread_getprio(pthread_t *unepthread, int prio); pthread_getsched(pthread_t *unepthread, int politique);
16.3
Les variables spciques ` une thread e a
Avec un processus multi-threads, nous sommes dans une situation de partage de donnes. e Toutes les donnes du processus sont ` priori manipulables par toutes les threads. Or certaines e a donnes sont critiques et dicilement partageables. Premi`rement ce sont les donnes de la bie e e blioth`que standard. Pour les fonctions de la biblioth`que standard, on peut rsoudre le probl`me e e e e en utilisant un smaphore dexclusion mutuelle pthread_mutex_t pour POSIX. e Mais certaines variables ne peuvent tre protges. Cest le cas de la variables errno, comme e e e nous lavons vu prcdemment. Pour cette variable, la solution est davoir une variable par thread. e e Ainsi le chier <errno.h> est modi et contient : e extern int *_errno(); #define errno (*_errno()) La valeur errno est obtenue par une fonction qui retourne la valeur de errno associe ` la e a thread qui fait lappel ` errno . a
134
16.3.1
Principe gnral des donnes spciques, POSIX e e e e
Lide des donnes spcique est de crer un vecteur pour chaque donne spcique. Ainsi e e e e e e pour des donnes spcique statiques, chaque thread poss`de son propre exemplaire. Les donnes e e e e spciques sont identies par des cls de type pthread_key_t. e e e
16.3.2
Cration de cls e e
La cration dune cl est lie ` la cration dun tableau statique (variable globale), initialis ` e e e a e ea NULL ` la cration. La fonction a e #include <pthread.h> int pthread_keycreate (pthread_key_t *p_cle, void (*destructeur)(void *valeur)); permet la cration du tableau, 0 succ`s et -1 echec. La structure pointe par p_cle nous e e e permettra dacc`der aux valeurs stockes, la cl est videmment la mme pour toutes les threads. Le e e e e e param`tre destructeur de type pointeur sur fonction prenant un pointeur sur void en param`tre e e et renvoyant void, donne ladresse dune fonction qui est excute ` la terminaison de la thread e e a (ce qui permet de faire le mnage). Si ce pointeur est nul, linformation nest pas dtruite ` la e e a terminaison de lactivit. e
16.3.3
Lecture/criture dune variable spcique e e
La fonction #include <pthread.h> int pthread_getspecific (pthread_key_t *p_cl, void **pvaleur); e permet la lecture de la valeur qui est copi ` ladresse pvaleur retourne 0 ou -1 selon que e a lappel ` russi ou non. La fonction a e #include <pthread.h> int pthread_setspecific (pthread_key_t *p_cl, void *valeur); e permet lcriture ` lemplacement spci de valeur retourne 0 ou -1 selon que lappel a russit e a e e e ou non.
16.4
Les fonctions standardes utilisant des zones statiques
Certaines fonctions standardes comme ttyname() ou readdir() retourne ladresse dune zone statique. Plusieurs threads en concurrence peuvent donc nous amener ` des situations incohrentes. a e La solution des smaphores dexclusion tant coteuse, ces fonctions sont rcrites pour la bie e u ee blioth`que de thread de faon ` tre rentrantes. e c ae e Attention les probl`mes de rentrance peuvent avoir lieu en utilisant des appels syst`mes non e e e rentrant dans les handlers de signaux ! Ceci sans utiliser de threads ! e
Chapitre 17
Clustering
Le clustering sont des techniques lis a lutilisation de grappes dordinateurs utilis comme e e un super ordinateur avec plusieurs processeurs. Lobjectif est le RAIP : Redundant Array of Inexpensive PROCESSOR. la station de trvail individuelle vielli a grande vitesse, une facon de recycler ceux qui sont en peu trop vieux (mais pas encore trops vieux) est de les rassembler dans votre premier cluster. De ces PC nous allons tirer un super calculateur, bien sur il est toujours plus rapide dachetter un G5 si on en a les moyens, pour les mainframes (je larme vous nen avez pas les moyens ou alors vous en avez deja plusieurs...)1 . Il existe direntes techniques de clustering pour dirent objectifs : e e Tolrence au pannes Google, le cluster est organis pour assurer la redondance des unit de e e e calcul pour assurer la continuit de service. e Super calculateur Earth Simulator,Plusieurs processeurs travaillant en mme temps permet e doptenir un super calculateur ` peu de frais, comme les processeurs qui compose chaque a noeud sont bon march. IL faut que le probl`me sy pr`te cest le cas des calculs mtorologiques e e e ee et des calculs de simulation ` grande chelle. a e Mont en charge Google, Le probl`me pour une application nest pas toujours un probl`me e e e de puissance de calcul parfois ce qui posse probl`me cest la quantit dentres sorties e e e qui faut assurer. Vous pouvez dailleurs facilement tester cette proprit en ralisant un ee e petit programme qui sans saturer lunit central sature compl`tement les entres sorties e e e while :;do; { cp grosfichier /tmp/$PID } &; done Ainsi le clustering a essentiellement pour objectif dutiliser le dicton lunion fait la force pour rsoudre une dicult de calcul. e e
17.1
Le clustering sous linux
Pour plus dinformation le vous conseil le site suivant qui vous donnera de bonnes rfrences. ee http://www-igm.univ-mlv.fr/~dr/Xpose2001/vayssade/
1 Cest evident si vous avez les moyens dacheter un mainframe vous avez les moyens dachetter un super-cluster haut de gamme.
135
136
CHAPITRE 17. CLUSTERING
Chapitre 18
Bibliographie
J.-M. Riet. La programation sous UNIX. Ediscience, 1993. Le manuel de rfrence. ee A.Tanenbaum. Syst`mes dexploitation, sysyt`mes centraliss, syst`mes distribus. Inter-Editions, e e e e e 1994. Cours gnral sur les syt`mes dexploitation. e e e M. Bach. The design of the UNIX operating system. 1986. Prentice-Hall, Englewood Clis, N.J. ISBN 0-13-201757-1 J. Beauquier & B. Brard Syst`mes dexploitation concepts et algorithmes. 1991. McGraw-Hill. e e ISBN 2-7042-1221-X W.R. Stevens, UNIX Network Programming. 1990 Prentice-Hall, Englewood Clis, N.J. W.R. Stevens, Advanced Programming in the UNIX Environnement Addison-Wesley ISBN 0201-56317-7
18.1
Webographie
Vous trouverez a lurl suivant une webographie : www-igm.univ-mlv.fr/ dr/Cours.html
137
Index
/dev/epoll, 156 /dev/null, 105 /dev/poll, 156 /dev/pty, 110 /dev/tty, 104 acc`s direct, 34 e acc`s squentiel, 34 e e Allocation contigu, 77 e appels syst`mes e exit, 38 accept, 178 brk, 60 cfgetispeed, 110 cfgetospeed, 110 cfsetispeed, 110 cfsetospeed, 110 chdir, 59 chroot, 59 close, 46 connect, 177 creat, 44 dup, 45 dup2, 46 exec, 51 execle, 61 execlp, 61 execv, 61 execve, 50, 61 execvp, 61 exit, 57 fchdir, 59 fcntl, 46 fork, 50, 51, 56, 61 getgrp2, 105 getmsg, 173 getpeername, 179 getpgrp, 59, 105 getpgrp2, 59 getpid, 59 getppid, 59 getsid, 106 getsockname, 179 getsockopt, 179 htonl, 179 138 introduction, 41 ioctl, 111 isatty, 103 kill, 113, 114 listen, 177 mkfifo, 100 mknod, 100 mmap, 92 munmap, 92 nice, 60 open, 41 pause, 120, 121 pipe, 97 poll, 155 putmsg, 173 putpmsg, 173 read, 44, 99 recv, 178 recvfrom, 178 recvmsg, 178 sbrk, 60 select, 153 send, 178 sendmsg, 178 sendto, 178 setgid, 59 setpgid, 105 setsid, 104 setsockopt, 179 setuid, 59 sigaction, 121 siginterrupt, 119 siglongjmp, 118 signal, 115 sigpause, 120 sigprocmask, 120 sigsetjmp, 118 sleep, 57 socket, 175 socketpair, 176 tcdrain, 110 tcflush, 110 tcgetattr, 109 tcgetgrp, 106 tcgetsid, 106
INDEX tcsetattr, 109 tcsetpgrp, 106 times, 58 ttyname, 104 ulimit, 60 umask, 60 write, 44, 100 arri`re plan, 105 e Best-t, 81 biblioth`ques, 5 e boot bloc, 10 buer cache, 25 buerisation, 35 bueriser, 25 chargement dynamique, 86 compactage, 81 dsarmer, 55 e Demand Paging, 86 Demand-Paging, 68 droits, 7 exclusion mutuelle, 63 famine, 63 FCFS, 65 s, 17 chier, 7 inodes, 9 ordinaires, 8 physiques, 8 spciaux, 8 e fo, 100 FILE, 31 First-t, 81 groupe, 7, 10 handler, 114 HotSwap, 182 inodes, 9, 11 interruption, 54 intr, 104, 113 lazy swapper, 86 load, 68 longjmp, 114 Mtadisque, 182 e masquer, 55 mkfo, 100 noyau, 5 ordonnancement, 63, 82 overlays, 85 page fault, 86 pages, 82 pendant, 114 physique, 103 pile, 50 pointeur de chier, 34 premption, 65 e premier plan, 105 priorit, 67 e proc, 22 processus, 49 $DATA$, 50 $TEXT$, 50 tats, 55, 57 e accumulateur, 53 changement de contexte, 53 commutation de mot dtat, 53, 54 e compteur ordinal, 53 context, 53 cration, 49 e decomposition, 49 format de chier, 50 mode dun, 55 mot dtat, 53 e niveau dinterruption, 54 struct proc, 49 recouvrement, 50 swapin, 57 swapout, 57 table des processus, 51 table des rgions par processus, 51 e struct user, 49 zone u, 51, 58 propritaire, 7, 10 e protocole, 175 pseudo-terminaux, 103, 110 quit, 104, 113 rfrence, 7 ee RAID, 181 redirection, 32 registre barri`re, 77 e registre base, 77 Round Robin, 66 SIGHUP, 104, 113 SIGINT, 113 signaux, 113 kill, 113 SJF, 65
139
140 static, 104 stdio.h, 31 stdlib atexit, 38 clearerr, 39 exit, 38 fclose, 36 feof, 33, 39 fflush, 36 fopen, 32 fread, 33 freopen, 32, 35 fseek, 34 ftell, 35 fwrite, 33 mkdir, 39 perror, 39 printf, 31 remove, 37 rename, 37 rewind, 35 rmdir, 39 scanf, 31 setbuf, 37 setbuffer, 37 setlignebuf, 37 setvbuf, 36 stderr, 31 stdin, 31 stdout, 31 system, 38 tmpfile, 33 tmpnam, 33 Xalloc, 51 super bloc, 10 susp, 104, 113 swap, 79, 85 synchronisation, 101 Syst`me de Gestion de Fichiers, 7 e tas, 50 terminal de contrle, 104 o termios, 106 tubes, 97 tubes nomms, 100 e Worst-t, 81
INDEX

Cours Système Linux

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cours Système Linux

Uploaded by

Copyright:

Available Formats

Cours Syst`me e

D.Revuz 17 fvrier 2005 e

Table des mati`res e

` TABLE DES MATIERES

le succ`s dUnix et de linux e

Des points forts

Des points faibles

Structure gnrale des syst`mes dexploitation e e e

Un syst`me dexploitation est un ensemble de procdures manuelles et automatiques qui permet e e

Les couches fonctionnelles

Utilisateurs user 1 user 2 user 3 user N

Applications Systme dexploitation

Fig. 1.1 Vue gnrale du syst`me e e e

SHELL make ls awk Hardware cc Kernel vi Applications

Fig. 1.2 Point de vue utilisateur

Niveau Noyau Niveau Materiel Materiel

Fig. 1.3 Architecture du noyau

Il existe un site tr`s agrable sur lhistoire des ordinateurs : e e http://www.computerhistory.org/ .

Syst`me de Gestion de Fichiers e

` CHAPITRE 2. SYSTEME DE GESTION DE FICHIERS

Fichiers ordinaires / Fichiers spciaux. e

Organisation utilisateur des Disques

2.4. LES INODES

nest pas un arbre car un chier peut avoir plusieurs rfrences ee

` CHAPITRE 2. SYSTEME DE GESTION DE FICHIERS

Organisation des disques System V

2.6. ADRESSAGE DES BLOCS DANS LES INODES

Plusieurs disques logiques sur un disque physique

Disque logique 1 Disque logique 2 Disque logique 3

Boot Bloc (vide)

Fig. 2.2 Organisation des blocs et des inodes (SYS V)

Adressage des blocs dans les inodes

Allocation des inodes dun disque

Allocation des blocs-disque

` CHAPITRE 2. SYSTEME DE GESTION DE FICHIERS

Blocs de donnes sur le disque

Fig. 2.3 Adressage direct et indirect des inode UNIX

Liste des inodes du Super Bloc inodes libres 18 83 19 48 20 Curseur vide

Fig. 2.4 Inodes libres dans le SuperBloc.

Liste des inodes du Super Bloc inodes libres 18 83 19 Curseur 20 vide

Fig. 2.5 Allocation dune inode.

2.8. ALLOCATION DES BLOCS-DISQUE

Fig. 2.6 Si le SuperBloc est vide.

Fig. 2.7 Libration dune inode avec le SuperBloc plein. e

Fig. 2.8 Le numro dinode infrieur au numro de rfrence. e e e ee

Fig. 2.9 Le numro dinode suprieur au numro de rfrence. e e e ee

` CHAPITRE 2. SYSTEME DE GESTION DE FICHIERS

Processus A allocation de l'inode I en sommeil pendant la lecture de l'inode (a)

temps (a) (b) (c) (d) (e) temps

2.8. ALLOCATION DES BLOCS-DISQUE

Bloc 211 311 308 305 302 301 214

Super Bloc Liste 109 vide

211 208 205 202 199

Super Bloc Liste 109 978

211 208 205 202 199

` CHAPITRE 2. SYSTEME DE GESTION DE FICHIERS

Super Bloc Liste 211 208 205 202 199 112

Bloc 211 311 308 305 302 301

Avantages et dsavantages du buer cache e

Le buer cache, structures de donnes. e

CHAPITRE 3. LE BUFFER CACHE

Prcdent sur hash queue Prcdent sur liste des libres

Suivant sur hash queue Suivant sur liste des libres

Fig. 3.1 Structure des enttes de Bloc du Buer Cache e