Académique Documents
Professionnel Documents
Culture Documents
Cours Conception Systeme Exploitation
Cours Conception Systeme Exploitation
I. 1. Définitions
Un système informatique est relié au monde extérieur par des organes d’accès
appelés “périphériques” qui lui permettent de communiquer avec des usagers humains ou
avec des équipements divers.
I. 2. Fonctions
I. 3. Architecture
LOGICIEL D’APPLICATION
LOGICIEL DE BASE
MACHINE PHYSIQUE
I. 4. Logiciel de Base
Le Système d’Exploitation ;
Les outils et services fournis par le logiciel de base tels que les compilateurs, les
chargeurs, les éditeurs, les utilitaires, etc.
OUTILS ET SERVICES
(Compilateurs, Chargeurs, Editeurs, Utilitaires)
SYSTEME D’EXPLOITATION
L’Unité Centrale ;
La Mémoire Centrale ;
Ces divers éléments communiquent entre eux par l'intermédiaire du bus, lequel
est subdivisé en :
bus des données : qui achemine les données devant être traitées par le
processeur;
3
bus des commandes : qui achemine les commandes devant être exécutées par le
processeur.
MEMOIRE PROCESSEUR
CENTRALE CENTRALE
Une adresse physique : qui est l’adresse renvoyée par le processeur à la mémoire
centrale pour chercher une donnée dont l’adresse se trouve déjà dans un registre ;
Le dispositif de gestion des Entrées /Sorties est composé des éléments suivants :
Les Unités d’échanges : qui sont des dispositifs intercalés entre l’UCT et les unités
périphériques pour palier la disproportion de vitesse de fonctionnement entre
l’UCT (qui est un équipement électronique) et les unités périphériques (qui sont
des équipements électromécaniques). Ils effectuent le transfert d’information
entre l’UCT et les unités périphériques. Parmi les unités d’échange, on peut citer :
5
I.2. 4. La problématique
Les programmes systèmes : qui gèrent les opérations inhérentes à l’ordinateur lui-
même.
Les logiciels applicatifs (applications): qui exécutent le travail réel des utilisateurs.
Il y a bien des années, il est apparu de plus en plus évident qu’une des voies a
suivre était de décharger les programmeurs de la complexité du matériel. La solution ainsi
trouvée qui a évolué graduellement a été de placer une couche logicielle au dessus du
matériel, pour gérer toutes les parties du système, et présenter à l’utilisateur une interface
ou machine virtuelle plus facile à comprendre et à programmer. Cette couche logicielle,
c’est ce qu’on appelé Système d’exploitation.
équipements physiques similaires. La façon dont ces divers équipements sont conçu et
comment ils fonctionnent est du domaine de l’électronique.
FIGURE II.1
Cependant, cette distinction est quelque fois floue dans les systèmes
embarqués (lesquels peuvent ne pas avoir un mode noyau) ou les systèmes interprétés (tels
que les systèmes basés sur le Java qui utilise l’interprétation, pas le matériel, pour séparer
les composants).
9
2. Un gestionnaire de ressources :
ce que l’on appelle traditionnellement les Appels Système. Pour réellement comprendre ce
que fait un système d’exploitation, il convient d’examiner minutieusement cette interface
qui peut varier d’un système d’exploitation à un autre.
Dans notre cours, nous allons nous baser sur les appels système de MINIX 3 qui
peuvent ainsi être regroupé en deux grandes catégories (ce qui est du reste valable pour la
plupart des systèmes d’exploitation):
Un concept clé dans MINIX 3 et dans la plupart des systèmes d’exploitation est
celui des « processus ». Un processus est fondamentalement un programme en exécution.
Des appels système clé dans la gestion des processus, il y a ceux qui concernent
la création et la terminaison des processus. A titre d’exemple, considérons un processus
appelé Interpréteur de commande ou Shell qui lit une commande sur un terminal.
L’utilisateur tape juste une commande qui demande qu’un programme soit compilé. Le Shell
doit créer un nouveau processus qui va exécuter le compilateur. Quand ce processus a fini la
compilation, il exécute un appel système qui le termine lui-même.
11
FIGURE II.2
des signaux, par exemple pour retransmettre une présumée perte de message. Quand le
traitement du signal est traité, le processus redémarre dans l’état qu’i avait avant.
Les signaux sont les équivalents logiciels des interruptions matériels. Ils sont
générés par une variété de causes. Beaucoup d’alertes détectées au niveau matériel, comme
l’exécution d’une instruction illégales ou l’utilisation d’une adresse invalide, sont aussi
convertis en signaux d’alarme envoyés au processus coupable.
Pour fournir une place ou conserver les fichiers, MINIX 3 introduit le concept de
« Répertoire » comme un moyen de grouper les fichiers ensemble. Par exemple, un étudiant
peut avoir un répertoire pour chaque cours qu’il prend, un autre répertoire pour les
courriers électroniques, et encore un autre répertoire pour sa page web d’accueil. Les
appels systèmes seront nécessaires pour créer et supprimer ces répertoires. Les appels
systèmes sont aussi nécessaires pour placer un fichier existant dans un répertoire, et pour
supprimer un fichier d’un répertoire. Les entrées des répertoires peuvent être soit des
fichiers, soit des répertoires. Ce modèle a aussi favorisé l’émergence d’un système de
fichier hiérarchique tels que montré sur la figure II.3.
13
FIGURE II.3
Les hiérarchies des processus et des fichiers sont toutes les deux organisées en
arborescence, mais la ressemblance s’arrête là. Les hiérarchies des processus ne sont pas
souvent profondes (plus de 3 niveaux est inhabituel), alors que les hiérarchies des fichiers
contient habituellement 4, 5, et même plus de niveaux de profondeur. Les hiérarchies des
processus ont typiquement une durée de vie limitée, généralement quelques minutes le plus
souvent, alors que la hiérarchie des répertoires peut exister des années durant. Les droits de
propriétés, ainsi que les méthodes de protection aussi différent, selon qu’il s’agit des
processus ou des fichiers. Typiquement, seul un processus parent peut contrôler ou même
accéder à un processus fils, mais il existe presque toujours des mécanismes pour permettre
aux fichiers et répertoires d’être lu par un large group d’utilisateur que juste le
propriétaire.
Avant qu’un fichier ne puisse être lu ou écrit, il doit être ouvert, moment au
cours de laquelle les permissions sont vérifiées. Si l’accès est permis, le system retourne un
petit entier appelé un « Descripteur de Fichier » à utiliser dans les opérations qui suivent.
Si l’accès est prohibé, un code d’erreur (1) est retourné.
Considérons le cas illustrés à la figure II.4 (a). Avant l’appel système mount, le
système fichier racine sur le disque dur, et un second système de fichier sur le CD-ROM,
sont séparés et non pas de lien apparent.
FIGURE II.4
Au point (a), avant le montage, les fichiers sur le lecteur de disquette sont
inaccessibles. Au point (b), après le montage, ils font partie intégrante de la hiérarchie des
15
fichiers. Le système de fichier du CD-ROM est ainsi monté dans le répertoire b, permettant
ainsi des fichiers /b/x et /b/y. le plus souvent, les systèmes de fichier sont monté dans des
répertoires préalablement vides. De même, si un système possède plusieurs disques, ils
peuvent tous être monté dans le même répertoire.
La dernière caractéristique dont nous allons parler dans cet aperçu général des
processus concerne a la fois les processus et les fichiers il s’agit des tunnels. Un tunnel est
une sorte de pseudo-fichiers qui peu être utilisé pour connecter deux processus, tel que
illustré sur la FIGURE II.5. Si le processus A et B veulent communiquer en utilisant un tunnel,
ils doivent le créer à l’ avance. Quand le processus A veut envoyer des données au processus
B, il écrit dans le tunnel comme si ce dernier était un fichier de sortie. Le processus B peut
lire ces donnes en lisant dans le tunnel comme si ce dernier était un fichier d’entrée. Ainsi,
la communication entre processus en MINIX 3 est très semblable à une lecture et une
écriture ordinaire dans un fichier. Plus fort encore, la seule façon qu’un processus peut
découvrir qu’un fichier sortie sur dans laquelle il est entrain d’écrire n’est pas réellement un
fichier, mais un tunnel, est de faire appel a un appel system spécial.
FIGURE II.5
16
II.3.3. Le shell
Le système d’exploitation est le code qui supporte les appels systèmes. Les
éditeurs de code, les compilateurs, et les interpréteurs de commande ne font, sans aucun
doute partie intégrante du système d’exploitation, même si ils sont importants et utiles.
Dans ce qui suit nous allons nous parler brièvement de l’interpréteur de commande de MINIX
3 qu’on appelle « Shell ».
L’utilisateur pet spécifier que la sortie standards soit redirigée vers un fichier
par la commende : date >fichier.
Similairement, une entrée standard peut être redirigée comme suit : sort
<fifchier1 >fichier2. Dans ce cas, le programme de tri récupère des entrées dans le
fichier1 et les trie. Le résultat est ensuite envoyé dans fichie2
Les résultats d’une commande peuvent à leur tour être utilisés comme entrée
d’une autre commande en connectant ces deux commandes par un tube (pipe) comme suit :
Cat fichier1 fichiers2 fichier3 | sort >/dev/lp. La commande cat concatène les 3 fichiers
et envoie le résultat (via le tube |) en sortie à la commande de tri sort qui les trie par ordre
alphabétique. Le résultat de la commande sort est redirigé vers le fichier /dev/lp, qui ne
représente rien d’autre que l’imprimante. Si un utilisateur ajoute un & après la commande
ci-dessus, ceci lui permettra de continuer a travailler normalement pendant que le tri est en
train de se faire en background.
APPEL
APPEL DE PROCEDURE DESCRIPTION
SYSTEME
GESTION DES PROCESSUS
fork pid = fork () Créé un processus fils identique au parent.
waitpid pid = waitpid (pid, &statloc, opts) attend la fin d’un processus fils.
wait S = wait (&status) L’ancienne version de waitpid.
execve S = execve (name, argv, envp) Remplace l’image noyau d’un processus
Termine le processus en exécution et revoit
exit exit (status)
son état.
brk size = brk (addr) Fixe la taille d’un segment de données.
Retourne le numéro d’indentification du
getpid pid = getpid ()
processus appelant.
Retourne le numéro d’identification du
getpgrp pid = getpgrp ()
groupe du processus appelant.
Crée une nouvelle session et retourne son
setsid pid = setsid () numéro d’identification de groupe du
processus.
ptrace I = ptrace (req, pid, addr, data) Utiliser pour le débogage.
SIGNAUX
sigaction S = sigaction (sig, &act, &oldact) Définit l’action à prendre par les signaux.
sigreturn S = sigreturn (&context) Retourner d’un signal.
sigprocmask S = sigprocmask (how, &set, Examine ou change le mask du signal.
&old)
sigpending S = sigpending (set) Obtient l’ensemble des signaux bloqués.
Remplace le masque du signal et suspend le
sigsuspend S = sigsuspend (sigmask)
processus.
kill S = kill (pid, sig) Envoi un signal à un processus.
alarm S = alarm (seconds) Règle l’alarme de l’horloge.
Suspend le processus appelant jusqu’au
pause S = pause ()
prochain signal.
GESTION DE FICHIER
Manière obsolète de créer un nouveau
creat fd = creat (name, mode)
fichier.
Crée un i-node régulière, spécial ou
mknod fd = mknod (name, mode, addr)
répertoire.
Ouvre un fichier en lecture, en écriture ou
open fd = open (file, how, …)
les deux en même temps.
close S = close (fd) Ferme un fichier ouvert.
read n = read (fd, buffer, nbytes) Lit les données d’un fichier dans un
18
tampon.
Ecrit les données d’un fichier dans un
write n = write (fd, buffer, nbytes)
tampon.
lseek pos = lseek (fd, offset, whence) Bouge le pointer d’un fichier.
Obtient l’état des informations d’un
stat S = stat (name, &buf)
fichier.
Obtient l’état des informations d’un
fstat S = fstat (fd, &buf)
fichier.
Alloue un nouveau descripteur de fichier à
dup fd = dup (fd)
un fichier ouvert.
pipe S = pipe (&fd[0]) Crée un tunnel.
Exécute des opérations spéciales sur un
ioctl S= ioctl (fd, request, argp)
fichier.
access S = access (name, amode) Vérifie l’accessibilité d’un fichier.
rename S = rename (old, new) attribue un nouveau non de fichier.
Verrouillage d’un fichier et d’autres
fcntl S = fcntl (fd, cmd, …)
opérations.
GESTION DE REPERTOIRE ET DE SYSTEME DE FICHIER
mkdir S = mkdir (name, mode) Crée un nouveau répertoire.
rmdir S = rmdir (name) Supprime un répertoire vide.
Crée une nouvelle entrée name2 pointant
link S = link (name 1, name2)
vers name1.
unlink S = unlink (name) Supprime l’entrée d’un répertoire.
mount S = mount (special, name, flag) Monte un système de fichiers.
unmount S = unmount (special) Démonte un système de fichier.
Nettoie tous les blocs en cache sur le
sync S = sync ()
disque.
chdir S = chdir (dirname) Change le répertoire de travail.
chroot S = chroot (dirname) Change le répertoire racine.
PROTECTION
chmod S = chmod (name, mode) Change les bits de protection d’un fichier.
Obtient le numéro d’identification
getuid uid = getuid ()
utilisateur de l’appelant.
Obtient le numéro d’identification du
getgid gid = getgid ()
groupe de l’appelant.
Détermine le numéro d’identification
setuid S = setuid (uid)
utilisateur de l’appelant.
Détermine le numéro d’identification du
setgid S = setgid (gid)
groupe de l’appelant.
Change le propriétaire et le groupe d’un
chown S = chown (name, owner, group)
fichier.
umask oldmask = umask (complmode) Change le mode du masque.
GESTION DU TEMPS
time seconds = time (&seconds) Obtient le temps écoulé de puis le 1 er
Janvier 1970.
19
FIGURE II.6
L’appel système fork est le seul moyen en MINIX 3 pour créer un processus. Il
créée une copie exacte du processus original, incluant tous les descripteurs de fichier. Apres
le fork, le processus original (le parent) et la copie (le fils) sont autonomes. Toutes leurs
variables ont les mêmes valeurs au moment de l’exécution du fork puisque les données du
processus parents ont été copiées pour créer le processus fils. Les changements ultérieurs
qui pourraient subvenir dans l’un de ces deux processus n’affectera que le processus
concerné.
L’appel système fork retourne une valeur, qui est 0 dans le processus fils, et
égale à la valeur du numéro d’identification de processus ou PID du processus fils dans le
processus parent. Ceci permet donc aux deux processus de savoir qui est le processus parent
et qui est le processus fils.
Dans la plupart des cas, après un fork, le processus fils voudra exécuter des
codes différents du processus parent. Considérons le cas du shell ou interpréteur de
commande. Il lit une commande envoyé au terminal, créée un processus fils, attend que le
processus fils exécute la commande, et ensuite lit la commande suivante quand le processus
fils se termine. En attendant que le processus fils finisse, le processus parent exécute un
appel système waitpid, lequel temporise jusque qu’à ce que le processus fils se termine
(n’importe quel processus fils, s’il en existe plus d’un). Waitpid peut attendre la fin d’un
processus fils particulier ou de tout autre vieux processus fils en changeant la valeur du
premier paramètre pid à 1. Quand waitpid se termine, l’adresse référencée par le second
paramètre, statloc, sera remplacé par la valeur de l’état de terminaison (qui peut être
normal ou terminaison anormale et valeur de sortie). Des options variée sont aussi fournies,
et spécifiées par le 3ème paramètre. L’appel système waitpid a remplacé l’ancien appel
système wait devenu obsolète, mais néanmoins conservé pour des raisons de compatibilité.
20
III.1. Xxxxxxxxxxxxxxxxxxxx
III.2. Xxxxxxxxxxxxxxxxxx
III.3. Xxxxxxxxxxxxxxxxx
III.4. Xxxxxxxxxxxxxxxxxx
VI.1. Xxxxxxxxxxxxxxxxxxxxxx
VI.2. Xxxxxxxxxxxxxxxxxx
VI.3. xxxxxxxxxxxxxxxxxxxxxxxx
VI.4. xxxxxxxxxxxxxxxxxxxxxxxxxxx