Inf 132 PDF

UNIVERSITE DE DOUALA
Faculté des Sciences
Département de Mathématiques et Informatique

Licence 1 Informatique
INF 132
Système d'exploitation
(Linux)
Année Académique 2019/2020
Dr TCHOUPE T. Maurice
Objectif
2
Objectif
comprendre, décrire l’architecture et le fonctionnement des
systèmes d’exploitation
utiliser le SE Linux
Pré-requis
Afin de suivre ce cours sans difficulté, il serait intéressant:
d’être familier avec l’utilisation de base d’un système
d’exploitation :Windows, MS-DOS, …
de posséder quelques notions d’algorithmique
Posséder des connaissances sur l'architecture des ordinateurs
Déroulement du Cours
CM=30h, TD=15h, TP=15h
Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice
Programme
3
Théorie des SE
Définition et rôle d’un SE
Gestion des fichiers
Gestion des processus
Gestion de la mémoire
Gestion des E/S
Etude du SE Linux
Installation,
Commandes de bases
Programmation en Shell
Bibliographie
4
Tanenbaum A. Systèmes d’exploitation, Pearson Education, Paris

2003, 2e éd.
Armspach, J.-P.,Colin, P., Ostré-Waerzeggers, F. LINUX.
Initiation et utilisation, Dunod, Paris 2004
Garrels, M. Bash Guide for Beginners, téléchargeable sur The
Linux Documentation Project, http://www.tldp.org/guides.html ;
où sur le réseau pédagogique R:/GTR/savary
Cooper, M. Advanced Bash-Scripting Guide, plus complet que
le précédent, sur le même site.
Chiesa Jean Yves , support d cours Système, Université de Rouen
De nombreuses références internet

5
Théorie des SE

6
Un système informatique, qu’est ce que c’est ?

7
En anglais « Operating System (OS) »

Qu’est-ce que c’est ?
« Programme assurant la gestion de l’ordinateur et de
ses périphériques » [www.dicofr.com]
C’est une couche logicielle, dont le rôle est de gérer les
périphériques et de fournir aux programmes utilisateur
une interface simplifiée avec le matériel.

8
A quoi ça sert ?
à simplifier la vie des utilisateurs et des programmeurs:
machine virtuelle (abstraite)
à gérer les ressources de la machine d’une manière
efficace
Les ressources d’un ordinateur sont :
• le processeur,
• les mémoires,
• les périphériques

Système d’exploitation en tant que machine
virtuelle (1/3)
9
L’architecture au niveau du langage machine est lourde à

programmer, surtout pour les entrées/sorties.
Par exemple, dans les contrôleurs de disquette des PC actuels
une opération basique de lecture exige 13 paramètres de bas
niveau compactés dans 9 octets. Ces paramètres précisent :
L’adresse du bloc qui doit être lu
Nombre de secteurs par piste
Longueur de l’espace inter-secteur
etc.
Sans l’existence du SE un programmeur devrait connaître tous ces
détails et les indiquer explicitement pour chaque lecture sur
disquette.
De plus il devrait personnellement contrôler les arrêts et
redémarrages du moteur du lecteur disquette.
virtuelle (2/3)
10
appel système
Programme utilisateur
<ouvrir_fichier “TP/expr.txt”>
Système d’exploitation
Pilote de disquette Pilote d’imprimante Pilote d’écran
<démarrer moteur>
<lire_secteur(début_secteur_5,param1_5, param2_5,…, param12_5)>
…
<arrêter_moteur>
Contrôleur de disquette

virtuelle (3/3)
11
Le système d’exploitation présente au programmeur une interface d’accès

aux ressources de l’ordinateur (sous forme d’appels système).
Grâce à cette interface le programmeur peut faire abstraction des détails
de fonctionnement des ressources (comme ceux listés sur le transparent
précédent).
Cette interface est basée sur des objets abstraits dont les plus importants
sont les fichiers et les processus.
Exemple :
Le programmeur voit un disque comme une collection de fichiers qui
peuvent être ouverts, lus, écrits et fermés.
Le SE gère l’allocation de secteurs aux fichiers, le chargement des
fichiers en mémoire, la cohérence entre les fichiers en mémoire et leur
copies sur le disque, le chargement et déchargement des pages (dans
le cas de la mémoire virtuelle), etc.
Ces actions sont transparentes pour le programmeur, c’est-à-dire il n’est
pas obligé de les connaître pour se servir du disque.
12
Le système d’exploitation en tant que machine

virtuelle se présente comme une couche logicielle qui
permet l’utilisation du matériel et coordonne les
différents programmes d’application.
Le but est aussi de rendre l’ensemble transparent et
facile à utiliser vis à vis de l’utilisateur (IHM).

Tâches du système d’exploitation - résumé
13
Gestion de
fichiers
Gestion de Gestion de
la mémoire processus
Gestion Gestion des

d’utilisateurs entrées/sorties
Les programmes utilisateur peuvent accéder à ces différentes fonctionnalités à

l’aide des appels système.

14
FONCTIONS D’UN SYSTEME D’EXPLOITATION ABORDEES DANS

LE COURS
Gérer les processus, leur existence simultanée, leur coexistence dans la
mémoire centrale, le temps qui leur est alloué.
Fournir aux processus les moyens d’accès à toutes les ressources en
terme de mémoire et d’entrées sorties dont ils ont besoin. Chaque
processus doit pouvoir s’imaginer qu’il dispose de la machine toute
entière.
Offrir une interface d’utilisation la plus conviviale possible. Cela inclut
l’IHM (langage de commande, interface graphique), mais aussi le
système de fichiers, qui permet de gérer la permanence des données
entre les exécutions de programme.
Optimiser l’utilisation des différents éléments composant le système
informatique, disques, mémoire, périphériques et capteurs divers. C’est
le rôle du sous système d’entrées-sorties.
Offrir une interface de programmation la plus simple et la plus
puissante possible.
STRUCTURE D’UN SYSTEME
15
D’EXPLOITATION MODERNE : UNIX

STRUCTURE D’UN SYSTEME
16
D’EXPLOITATION MODERNE : UNIX
Caractéristiques
Le noyau (kernel) : ensemble de fonctions système assurant la
gestion de la mémoire, des E/S et des processus.
Un système de fichiers hiérarchisé.
Un/plusieurs interpréteurs de commandes (shell).
Processus asynchrones (arrière plan).
Réentrant (partage du "texte") texte=instruction.
Mécanisme de communication (synchronisation).
E/S généralisées (intégrées au SGF).
Ré allocation (redirection) des E/S et d’un processus.
Nombreux utilitaires de programmation.
Mécanisme de protection de mémoire en cas d’erreur de
programmation.
Interfaces utilisateurs graphiques
17
Système de fichiers UNIX/Linux

Le Système de Fichiers: LE SGF D’UNIX
18
Le fichier UNIX est une suite éventuellement vide

d’octets contenant une information quelconque. Aucune
supposition n’est faite par le système sur la structure de
ces octets (ASCII, binaire ou toute autre catégorie.).
L’interprétation des bits contenus dans les fichiers est de
l’entière responsabilité de l’utilisateur.
Unix fait la différence dans les noms de fichiers entre
les majuscules et les minuscules (case-sensitive). En
théorie, tous les caractères du clavier sont autorisés dans
les noms de fichiers. En pratique, il vaut mieux s’abstenir
d’utiliser des caractères trop exotiques, risquant en
particulier d’être interprétés par certains programmes.
C'est notamment le cas de * ou ? et de . en début de nom.
19
Hiérarchie des répertoires.

Le système de fichiers est perçu par l’utilisateur comme une hiérarchie de
répertoires et de sous répertoires. A la racine de l’arbre se trouve le répertoire
de nom /. Il n’existe pas de notions de disque comme dans MSDOS ou VMS.
Les différents disques logiques (partitions de disques physiques) du système ou
des systèmes constituent chacun un système de fichier avec une racine. Chacun
de ces système de fichiers est raccroché dans l’arbre au démarrage du système
ou explicitement par la commande mount.
Hard disk Diskette Hard disk
/ / /
x y z
a b a b
x y z
c d c d
p q r q q r
Deux systèmes de fichiers séparés Après le montage

20

Un fichier peut être dénommé par son chemin absolu ou par son
chemin relatif au répertoire courant. Dans la plus grande généralité,
le chemin absolu est du type :
<nom de machine>.[<nom de domaine>]/<chemin absolu>/<nom
de fichier>
On peut utiliser des extensions sur les noms de fichiers comme dans
MSDOS, mais elles n’ont aucune signification pour le système lui même.
Elles en ont éventuellement pour les bureaux de type graphique, qui
peuvent alors associer une icône particulière à une extension donnée. La
seule information qui indique quelque chose au système est le fait que le
fichier ait été marqué comme « exécutable » (voir plus loin la notion de
contrôle d'accès). C’est à cette seule condition que le système acceptera
de lancer son exécution, sans d’ailleurs vérifier si le fichier en question
est réellement exécutable.

21

22
Hiérarchie d’un système de fichiers
Le détail des répertoires systèmes varie d'une implémentation à une autre. Il existe malgré
tout des ressemblances.
/bin : commandes de base
/dev : périphériques
/dev/fdx : lecteur de disquette
/dev/hdx : partition de disque dur ide (hda, hdb, hdb, hdc)
/dev/sdx : partition de disque dur scsi
/dev/cdrom : comme le nom l’indique
/dev/lpx : imprimante
/dev/mem : mémoire .
/etc : fichiers de configuration et d’installation
/home : fichiers utilisateurs
/lib : bibliothèques de programmes
/sbin : commandes d’administration
/usr : programmes et utilitaires mis à disposition des utilisateurs
/opt : programmes du système local (voir aussi /usr/bin ou /usr/local/bin)

23
Copie, déplacement, liens sur les fichiers.

Voir les commandes ls (affichage de contenus de fichiers), cp
(copie de fichiers), mv (déplacement de fichiers), rm (suppression
de fichiers), mkdir (création de répertoires), cd (changement de
répertoire), rmdir (suppression de répertoire).
Le système de fichiers peut contenir plusieurs entrées qui font
référence au même fichier physique réel. C’est la notion de lien
physique et de lien symbolique.
ln crée des liens physiques entre fichiers.
ln -s crée des liens symboliques entre fichiers. Il s’agit en quelque
sorte d’un raccourci pour désigner le fichier. Le système effectue
automatiquement le déréférencement, sauf pour quelques opérations
comme rm qui détruit le lien et non le fichier pointé par le lien.

24
Contrôles d'accès
On distingue trois classes d’utilisateurs :
le propriétaire (u : user, par défaut créateur),
le groupe (g : group, par défaut groupe principal du
créateur) et
le reste du monde (o : others).
Chaque classe peut se voir affecter sur un fichier les
droits
de lecture (r : read),
d’écriture (w : write) et
d'exécution (x : execute).

25
Contrôles d'accès

26
sticky bit, set uid, set gid :
Exemple: voir ci-dessous

27
Contrôles d'accès
La commande ls -l permet de connaître le détail des droits sur un
fichier: le type de fichier (catalogue, fichier ordinaire ou spécial),
les droits d'accès pour les différents utilisateurs, le nombre de lien
du fichier, les noms du propriétaire et du groupe, la taille du
fichier en nombre de caractères et la date de dernière
modification
ls -l /etc/passwd
-r--r--r-- 1 root sys 8620 Jan 21 12:41 /etc/passwd
ls -l /bin/passwd
-rwsr-sr-x 1 root sys 16686 Jul 30 12:41 /bin/passwd
La commande passwd (fichier/bin/passwd) a le "set-uid" bit positionné
(indication s en lieu et place de x pour le bit exécution par le
propriétaire) et donc au travers de cette commande tout utilisateur peut
modifier le fichier /etc/passwd (en l'occurrence changer son mot de
passe.)
28
Contrôles d'accès
La commande chmod permet de modifier les droits sur un fichier (noter la descente
récursive d’une sous arborescence avec l’option -r). ) pour pouvoir l’utiliser sur un fichier, il
faut en être le propriétaire.
Syntaxe: chmod <mode> <reférenceFichier>
Il existe deux syntaxe: la notation symbolique et la notation octale
notation octale: Les modes peuvent être absolus et sont alors obtenus par combinaison des
nombres octaux
4000 positionne le "set-uid" bit
2000 positionne le "set-gid" bit
1000 positionne le "sticky" bit
0400 lisible par le propriétaire
0040 lisible par les membres du groupe propriétaire
0001 exécutable par les autres utilisateurs
…
exemple
$ chmod 664 exemples/toto
$ ls -l exemples/toto
-rw-rw-r-- 1 jmr ens 84 Jan 27 19:09 exemples/toto
29
Contrôles d'accès
La commande chmod permet de modifier les droits sur un fichier (noter la descente récursive d’une sous arborescence
avec l’option -r). ) pour pouvoir l’utiliser sur un fichier, il faut en être le propriétaire.
Syntaxe: chmod <mode> <reférenceFichier>
Il existe deux syntaxe: la notation symbolique et la notation octale
notation symbolique: les modes peuvent être symboliques et ils ont alors la forme:
[<quit>] <permission> <operation>
<quit> est une combinaison des lettres: u pour le propriétaire, g pour le groupe, o pour les autres,
a pour tous.
<permission> est: + pour autoriser, - pour interdire, = imposer certaines permissions et supprimer
les autres;
<opération> est une combinaison des lettrez: r pour lire, w pour écrire, x pour exécuter, s pour le
"set-uid" (bit associé à u) ou le "set-gid" (associé à g); t pour le "sticky" bit.
Exemples:
-rw-r----- 1 jmr ens 84 Jan 27 19:09 exemples/toto
$ chmod go+r exemples/toto
-rw-r--r-- 1 jmr ens 84 Jan 27 19:09 exemples/toto

30
Contrôles d'accès
Exemples:
$ ls -l ../c/bks
-rwx--x--x 1 jmr ens 9282 Nov 13 13:27 ../c/bks
$ chmod u+t ../c/bks
$ chmod u+s ../c/bks
$ ls -l ../c/bks
-rws--x--t 1 jmr ens 9282 Nov 13 13:27 ../c/bks
$ chmod g+s ../c/bks
$ ls -l ../c/bks
-rws--s--t 1 jmr ens 9282 Nov 13 13:27 ../c/bks
$ ls -l /tmp/toto
-rw-r--r-- 1 jmr ens 200 Jan 27 18:51 /tmp/toto
$ chmod g=w /tmp/toto
$ ls -l /tmp/toto
-rw--w-r-- 1 jmr ens 200 Jan 27 18:51 /tmp/toto

31
Contrôles d'accès
chown permet de modifier le propriétaire d’un fichier,
syntaxe: chown <nom> <refFich>
Exemple:
$ chown root exemples/toto
-rw-rw-r-- 1 root ens 84 Jan 27 19:09 exemples/toto
chgrp <groupe> <refFichier> … permet de changer le

groupe d’un fichier.
-rw-rw-r-- 1 root ens 84 Jan 27 19:09 exemples/toto
chgrp sys exemples/toto
-rw-rw-r-- 1 root sys 84 Jan 27 19:09 exemples/toto
32
Recherche de fichiers.
find permet de rechercher un ou des fichiers dans le
système de fichier. On recherche récursivement, en
partant d’un répertoire des fichiers ou des répertoires
suivant certains critères (nom de fichier, éventuellement
avec joker, type de fichier, nom de l’utilisateur ou du
groupe, droits d’accès, type de fichier).
test peut entre autres opérations, tester les
caractéristiques d’un fichier et renvoyer une valeur de
retour 0 si vrai et 1 si faux. Très utile dans les scripts de
langage de commandes (nous en reparlerons).

Quelques appels système relatifs aux fichiers
33
On peut également inter-agir sur le SF par programme

à travers des appels systèmes.
Appel système Description
df = open(nom, mode,…) Ouverture en lecture, écriture, etc.
s = close(df) Fermeture d’un fichier ouvert
n = read(df, buffer, nb_octets) Lecture d’un nombre d’octets d’un fichier vers un buffer
n = write(df, buffer, nb_octets) Ecriture d’un nombre d’octets d’un buffer vers un fichier
pos = lseek(df, offset, org) Déplacement du pointeur de fichier
Obtention d’informations sur le fichier (périphérique, i-
node, nb de liens durs sur le fichier, propriétaire, groupe,
s = stat(nom, &buf) taille, date de création date du dernier accès, date de la
dernière modification)
s = fstat(df, &buf) Idem, à partir du descripteur de fichier
Quelques appels système relatifs aux répertoires
34
On peut aussi interagir avec le SF par programme au moyen d'appels systèmes
Appel système Description

s = mkdir(chemin, mode) Création d’un nouveau répertoire.
s = rmdir(chemin) Suppression d’un répertoire
s = link(fichier, lien) Création d’un lien
s = unlink(chemin) Suppression d’un lien (et éventuellement du fichier)
s = chdir(chemin) Changement du répertoire courant
dir = opendir(chemin) Ouverture d’un répertoire en lecture
s = closedir(dir) Fermeture d’un répertoire
dirent = readdir(dir) Lecture d’une entrée du répertoire
rewinddir(dir) Retour au début du répertoire pour une nouvelle lecture

Redirections
stdout stdout
0 1 stdin
0 1 fichier
stdin
Processus
Processus
2 stderr 2 stderr
Lorsqu’un processus démarre de façon standard, 3 fichiers spéciaux sont

ouverts automatiquement :
• Entrée standard (stdin) – descripteur 0, par défaut équivalent au clavier
• Sortie standard (stdout) – descripteur 1, par défaut équivalent à l’écran
• Sortie erreur standard (stderr) - descripteur 2, par défaut équivalent à
l’écran
Ces 3 entrées/sorties peuvent être redirigées afin que la lecture/écriture se
fasse à partir/vers d’autres fichiers.
Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE
35 T. Maurice
Redirections - exemples
Commande shell Description
Trie les lignes tapées au clavier; écrit le résultat trié à
sort
l’écran
sort < f1 Trie les lignes du fichier f1; écrit le résultat trié à l’écran
Trie les lignes tapées au clavier; écrit le résultat trié dans le
sort > f2
fichier f2 (si f2 existait avant il est efface et recréé)
Trie les lignes tapées au clavier; attache le résultat trié à la
sort >> f2
fin du fichier f2 (si f2 n’existait pas avant il créé)
Trie les lignes tapées au clavier; écrit le résultat trié à
sort 2> f3 l’écran. Les messages d’erreur éventuels sont écrits dans le
fichier f3.
…………………………………………………………..
sort <f1 >f2 2>f3
…………………………………………………………..
…………………………………………………………..
sort < f1 2>> f3
…………………………………………………………..
(ls -l toto > f1) 2> f2 36

Vers les tubes - exemple
Problème : compter le nombre de mots uniques dans une liste .

sort –u <f1 >f2 #Trie l’entrée standard en laissant
#une occurrence unique de chaque ligne
wc –l <f2 #word count : affiche sur la sortie
#standard le nombre de lignes
#dans l’entrée standard
Fichier f1 Fichier f2
demain stdout
hier
stdin 0 1 demain
stdin 0 1
stdout
sort –u <f1
mardi dimanche
Processus exécutant
wc –l <f1
lundi hier
demain lundi
lundi mardi 5
>f2
dimanche
2 stderr 2 stderr

37 T. Maurice
Tubes
Un tube = un flot de données entre deux processus obtenu par la redirection

de la sortie standard d’un processus vers l’entrée standard d’un autre processus
sans création de fichier intermédiaire.
Meilleure solution pour le problème précédent :
sort –u <f1 | wc -l
Fichier f1
demain stdout
hier
stdin 0 1 0 1
stdin
sort –u <f1
mardi stdout
wc –l <f1
lundi
demain
lundi 5
>f2
dimanche
2 stderr 2 stderr

38 T. Maurice
Le Système de Fichiers: MISE EN
OEUVRE DU S.G.F. UNIX
39
Les différents types de fichiers

Fichiers ordinaires(-) : suite d’octets sans structure et sans marque de fin
de fichier. Seule le mémorisation de la longueur permet de détecter la
fin du fichier.
Fichiers répertoires(d) : un fichier contenant des noms de fichiers.
Liens symboliques(l) : contient seulement le chemin et le nom du fichier à
atteindre.
Tubes nommés(p) : fichiers particuliers contenant des caractères, gérés
comme des tubes entre un processus producteur et un processus
consommateur.
Fichiers spéciaux(c, p ou b) :
permettent aux processus de « voir » les périphériques comme des fichiers.
Un programme n’a ainsi pas à se soucier de l’endroit où il écrit.
Les fichiers spéciaux sont regroupés par convention dans le répertoire dev.
Ils ne contiennent pas de données.

40
Structure d’un disque

Chaque système de fichier UNIX implémente un ensemble
de concepts communs dérivés du système de fichier
d’origine. Les fichiers sont représentés par des « inodes »,
les répertoires sont des fichiers simples contenant des listes
d’entrées et les périphériques sont traités comme des fichiers
(il suffit d’émettre des demandes de lecture/écriture sur des
fichiers spéciaux).
Un disque se décompose en un bloc de boot, et des volumes
(partitions). Chaque volume contenant un système de fichiers.
Chaque système de fichiers se compose d’un superbloc,
d’une table des inodes, et des blocs de données où sont
stockés les fichiers.

41

42
Chacun de ces groupes est constitué de blocs logiques, contenant un

multiple de 512 octets (variable selon la version du système, les
décisions de formatage, .). La taille d’un bloc logique est fixe dans
un système de fichier. On peut par contre choisir une taille
différente de bloc selon le système de fichier et son utilisation
prévue.
Les systèmes de fichiers sur les disques se répartissent dans des
blocs de tailles fixe correspondant à des unités d’entrée-sorties du
contrôleur. La lecture ou l’écriture d’un élément du fichier nécessite le
transfert intégral du bloc qui contient cet élément. Lors d’un transfert
de données d’un disque physique vers la mémoire, le temps du
transfert des données est composé du temps de positionnement de
la tête devant le bloc à lire, puis du temps de lecture du bloc et. Ce
dernier est négligeable devant le temps de positionnement. La
question de la taille des blocs est donc une recherche de compromis
entre la rapidité et l’espace perdu sur le disque.

43
Les inodes
Chaque fichier est représenté par une structure nommée inode.
Un inode contient la description (pour le SGF) d’un fichier:
Propriétaire, groupe, type de fichier, permissions
Date d.accès, de modification et de dernier accès à l.inode
Taille
Description des blocs constituant le fichier
Etat de l’inode
N° de périhérique logique
N° de l’inode
Pointeurs sur d’autres inodes en mémoire
Compteur de référence indiquant le nombre d’instances du fichier
actuellement ouvertes
Zone de verrous

44
Les inodes
Chaque inode permet de retrouver l’ensemble des blocs de données
constituant un fichier.
Une première série de 10 entrées contiennent chacune le numéro de
bloc d’un bloc de données du disque.
Simple indirection : une onzième entrée contient le numéro d.un bloc de
données qui contient lui même 256 entrées référençant chacune un bloc de
données du disque.
Double indirection : une douzième entrée contient le numéro d.un bloc de
données qui contient 256 entrées référençant chacune un bloc de données du
disque.
Enfin triple indirection : une treizième entrée contient le numéro d.un bloc de
données qui contient 256 entrées référençant chacune un bloc de données qui
contient 256 entrées référençant chacune un bloc de données du disque.

45
Les inodes

46
Les inodes
Remarque : Un fichier peut avoir plusieurs liens donc
plusieurs noms. Il suffit pour cela qu’ils pointent sur le
même inode (celui du fichier).
L’inode n°2 est l’inode racine du système de fichiers.

47
Répertoires
Un répertoire est un fichier comme les autres.
Chaque répertoire peut contenir des fichiers ou des
répertoires.
Les répertoires sont structurés en arbre hiérarchique (plus
exactement en graphe sans cycle).
Les données contenues dans un fichier de type répertoire
sont une suite d’éléments contenant chacun un numéro
d’inode et le nom du fichier.
Lorsque un processus a besoin d’un fichier, le noyau parcourt
les différents répertoires jusqu’à trouver le nom recherché.
Celui-ci fournit alors un numéro d’inode, qui est chargé en
mémoire et utilisé dans la suite du processus.

48
Gestion de processus

LES PROCESSUS
49
Un processus est un programme en cours d’exécution.
Si un programme peut être caractérisé par la suite de ses instructions, un
processus va être caractérisé par cette même suite d’instruction,
auxquelles il convient de rajouter un ensemble de données qui vont
varier au cours du temps. Ainsi, à un instant t donné, il s’ajoute à ces
instructions exécutables la valeur des différents registres du processeur (qui
la plupart du temps va caractériser l’instruction suivante exécutable), la
valeur du compteur ordinal (qui détermina la position atteinte dans
l’exécution du programme), les valeurs des différentes variables dans la
mémoire.
Un même programme peut être lancé plusieurs fois par le même
utilisateur ou par des utilisateurs différents.
Le résultat de chacun de ces lancements, le temps d’exécution, le contenu
de la mémoire lors de l’exécution, parfois même la quantité de mémoire
occupée par les données seront pratiquement toujours différents. C'est
même ce qui fait fondamentalement la puissance de l’informatique, par
opposition aux automatismes. Il y aura bien un programme et plusieurs
processus.
Processus = programme en cours d’exécution
50
Environnement d’un processus
Espace d’adressage Registres Etat Divers caractéristiques

• Pointeurs sur segments de (élu,
PC • Process ID (PID)
code, de données et de pile prêt, • Group ID (GID)
FFFF bloqué)
pile SP • Parent process ID (PPID)
• Priorité
Drapeaux • Date de lancement
données . • Temps UC utilisé
.
. • Répertoire courant
code • Fichiers ouverts
0000
• …
Tous les processus sont recensés dans une table de processus, où une entrée
décrit un processus.
LES PROCESSUS
51
Certains processus n'appartiennent pas à un utilisateur en
particulier. Ils sont nécessaire au fonctionnement du système dans
son ensemble , ou bien à une partie du système. C'est le cas par
exemple des très nombreux processus tournant en arrière plan
sous Unix (démons), et permettant de gérer l'imprimante, le
réseau, la mémoire, l'écran, etc.. On parlera dans ce cas de
processus systèmes, par opposition aux processus utilisateurs,
appartenant à un utilisateur particulier.
Dans un système Unix, la commande ps permet de visualiser les
processus en cours d'exécution. Sous Windows 9x, la séquence de
touches ctrl-alt-del permet de voir la liste des processus en cours.
Sous Windows NT, plusieurs outils permettent cette même
visualisation, sous différentes formes et avec plus ou moins de
détails : le gestionnaire de tâches, la liste des services, …
LES PROCESSUS
52
Dans un système d’exploitation traditionnel, on

verra qu’un processus est caractérisé par un flux de
contrôle unique, et un espace d’adressage unique.
Sauf opération particulière (mémoire partagée ou
fichiers mappés en mémoire), plusieurs processus ne
partagent jamais le même espace mémoire.
Ce cas de figure peut être un désavantage dans
certaines circonstances. C'est pour cette raison
qu'ont émergé ces dernières années les processus
légers (lightweight process) nommés communément
threads
LES PROCESSUS
53
Les threads permettent différents flots d’exécution au sein d’un même

processus, avec une marge importante d.indépendance les uns par
rapport aux autres. Ils partagent, contrairement aux processus, un
même espace d’adressage, les fichiers ouverts et d’autres
ressources. Ils peuvent également interagir plus facilement les uns vis
à vis des autres. Enfin, et c.est souvent ce qui justifie grandement leur
existence, leurs création par le système d’exploitation est
généralement plus rapide que celle de processus, dans la mesure ou
il n’y a pas de copie de mémoire à réaliser. Les threads sont ainsi
bien adaptés à des processus client/serveur, le serveur étant alors
implémenté sous forme d’un thread particulier (dispatcher), chargé
de mettre en activité un pool de threads serveurs (workers).
Les concepts liés à l’existence des threads sont relativement
similaires à ceux des processus, avec quelques complications
supplémentaires dues à la coexistence des threads à l'intérieur du
processus. Nous reviendrons plus tard sur le sujet.

Création de processus
54
Exemple : sous UNIX, l’interpréteur de commandes (shell) est un

processus qui :
• saisit une commande au clavier
• crée un processus fils en lui indiquant quel programme
exécuter pour réaliser la commande (sous Unix, fork est le
seul appel système de création de processus)
• Attend que le processus fils se termine (si le processus fils est
en avant plan) ou continue la saisie (si le processus fils est en
arrière plan)
La création d’un processus peut aussi se faire à partir d’un
programme.

Terminaison de processus
55
Un processus peut se terminer suite à l’un des 4 événements :

• Sortie normale, lorsque le processus a terminé sa tâche (sous Unix
par l’appel système exit)
• Sortie suite à une erreur (e.g. division par 0, inexistence d’un
fichier passé en paramètre)
• Tué par un autre processus (sous Unix par l’appel système kill)

Hiérarchie de processus (sous UNIX)
56
Si le processus A crée le processus B, A est le parent de B, B est le fils de A. B peut

à son tour créer des processus. Un processus avec tous ses descendants forment un
groupe de processus représenté par un arbre de processus.
Exemple : void main() void main()
{int i; {int i;
fork(); fork();
i = i+1; i = i+1;
void main() fork(); fork();
{int i; i = i-1;} i = i-1;}
fork(); Processus B Processus D
i = i+1;
fork();
A
void main()
i = i-1;} {int i;
fork(); B C
i = i+1;
Processus A
fork();
i = i-1;}
Support : Système d'exploitation (Linux)
D
//Par: Dr TCHOUPE T. Maurice
Processus C
scheduling
time
Ordonnancement des processus sharing
57
Dans un système multitâche plusieurs processus sont en cours simultanément,

mais le processeur ne peut, à un moment donné, exécuter qu’une instruction
(d’un programme) à la fois. Le processeur travaille donc en temps partagé.
L’ordonnanceur (scheduler) est le module du SE qui s’occupe de sélectionner le
processus suivant à exécuter parmi ceux qui sont prêts.
PC (unique)
FFFF
Programme C Processus C
Programme B Processus B
0000 Programme A Processus A
temps
Algorithmes d’ordonnancement (1/2)
58
1. Tourniquet (round robin) : chaque processus a un intervalle fixe de temps de

processeur (quantum). Le processeur est donné à un autre processus lorsque
• le temps prévu pour le processus en cours s’est écoulé
• le processus courant se bloque (e.g. en attendant une saisie au clavier)
quantum Mise en oeuvre par une file d’attente :

P1
File de processus prêts :
P6 P2 P1 P2 P3 P4 P5 P6
Après le quantum de P1 :
P5 P3 P2 P3 P4 P5 P6 P1
P4
59
2. Ordonnancement avec priorité : chaque processus a sa priorité et on lance le

processus prêt dont la priorité est la plus élevée. La priorité du processus en
cours diminue au fur et mesure de son temps pris dans le processeur. Lorsque
cette priorité baisse en dessous de celle d’un autre processus en attente, le
processus courant cède sa place dans le processeur.

60
1. Tourniquet avec priorité : les processus attendent dans plusieurs files selon
leurs priorités. La file de la plus grande priorité est servie d’abord. A
l’intérieur d’une file l’ordonnancement se fait selon la méthode de tourniquet.
Processus prêts
Têtes de files
Priorité 4 (Priorité la plus élevée)
Priorité 3
Priorité 2
Priorité 1 (Priorité la plus basse)
2. Le plus court d’abord (pour minimiser le temps moyen d’exécution)
8 4 4 4 4 4 4 8
A B C D B C D A
Temps moyen = (8+12+16+20)/4 = 14 Temps moyen = (4+8+12+20)/4 = 11
Etats d’un processus
61
ETATS
Elu (running) = en cours
d’exécution TRANSITIONS
Prêt (ready, runnable) = Elu 1 = le processus se
2 bloque en attente
suspendu
temporairement pour d’événement
3
permettre l’exécution 1 Prêt 2 = l’ordonnanceur
d’un autre processus choisit un autre
Bloqué (blocked) = processus
attendant un événement 3 = l’ordonnanceur
extérieur, e.g. appui Bloqué 4 choisit ce processus
d’une touche au clavier, 4 = l’événement
pour pouvoir continuer attendu survient

Etats d’un processus (cas d'UNIX)
62
Plus précisément, dans le système UNIX, les différents états d'un processus
peuvent être caractérisés comme suit :
Le processus est prêt en mémoire. Il ne s'exécute pas, mais il est
chargé en mémoire et est prêt à s'exécuter dès que le noyau l'élira
comme processus actif.
Le processus s'exécute en « mode noyau », c'est à dire qu'il fait appel
à une fonction du noyau du système (read, write, fork, exec, .) .
Le processus s'exécute en « mode utilisateur », c'est à dire qu'il réalise
des calculs d'une fonction de bibliothèque (+, -, strcpy, .) .
Le processus est « préempté », c'est à dire que le noyau a effectué un
changement de contexte pour élire (« donner la main à ») un autre
processus.
Le processus est « zombie ». Il a provoqué un appel à une instruction
de terminaison (exit), et n'aura donc plus besoin du CPU, mais son père
n'a pas encore pris connaissance de ses codes de retour et de ses
statistiques d'exécution. Cet état est typique des processus UNIX. Il est
normalement très transitoire. C.est un état terminal.
63
Le processus est endormi en mémoire. Il a provoqué une

instruction de mise en sommeil volontaire (sleep). Il n'a pas
besoin d'être élu par l'ordonnanceur.
Il existe ensuite un certain nombre d'états qui sont liés à la
gestion de la mémoire principale et de la mémoire
secondaire . Il existe un processus du noyau ( le swapper ),
qui se charge de « faire de la place » en mémoire vive
(mémoire principale), en utilisant le disque comme zone
de stockage temporaire (mémoire secondaire).
Le processus est prêt à s'exécuter, mais le swapper l'a
transféré sur disque. Il devra de nouveau être ramené
en mémoire avant de pouvoir continuer son exécution.
Idem si il était préalablement endormi ou préempté .
64

65
Communication entre processus

Communication inter-processus
66
Souvent différents processus ne sont pas totalement indépendants : ils doivent

échanger des informations.
Exemple : processus A est dédié à la gestion d’une imprimante, processus B
désire imprimer un document. B doit communiquer à A le nom et l’emplacement
du fichier qu’il veut imprimer.
Il existe deux méthodes classiques de communication inter-processus : des
variables partagées (shared variables) et l’échange de messages (message
passing).
Exemple de variables partagées : plusieurs processus veulent imprimer leurs
résultats sur une imprimante commune. Les noms des fichiers à imprimer sont
placés dans un tableau spécial fonctionnant comme une file : les variables
partagées début et fin indiquent le premier et le dernier fichier dans la file.

Variables partagées
67
Supposons que processus B veut imprimer un fichier (nommé F_b). Le nom du fichier
est placé dans un tableau spécial fonctionnant comme une file : les variables
partagées tête et queue indiquent le premier fichier dans la file et l’endroit
d’insertion d’un nouveau fichier.
5 6 7 8 9
après I1
Fich.c TP17.c CV.doc Test.ps
Processus B : tête queue

<qb ← queue> //I1
<charger fichier 5 6 7 8 9
après I2
F_b dans [qb]> //I2 Fich.c TP17.c CV.doc Test.ps F_b
<queue← qb+1> //I3

tête queue
5 6 7 8 9
après I3
Fich.c TP17.c CV.doc Test.ps F_b
Support : Système d'exploitation (Linux) tête //Par: Dr TCHOUPE T. queue

Maurice
Conflits d’accès aux variables partagées (1/2)
68
Exemple : Deux processus B et C veulent placer au même moment leurs fichiers (F_b
et F_c) dans la file d’impression. L’ordonnancement de ces processus est tel que
leurs instructions s’exécutent alternativement : I1b, I1c, I2b, I2c, I3b, I3c.
5 6 7 8 9
Processus B : qb 9 Fich.c TP17.c CV.doc Test.ps
après
I1b
<qb ← queue>
tête queue
//I1b
<charger fichier qb 9 5 6 7 8 9
Fich.c TP17.c CV.doc Test.ps après
F_b dans [queue]> //I2b I1c
qc 9
<queue← qb+1> //I3b tête queue
Processus C : qb 9 5 6 7 8 9
Fich.c TP17.c CV.doc Test.ps après
<qc ← queue>
F_b
//I1c qc 9 I2b
<charger fichier tête queue
F_c dans [queue]> //I2c qb 9 5 6 7 8 9
<queue← qc+1> //I3c Fich.c TP17.c CV.doc Test.ps F_c après
qc
Support : Système d'exploitation (Linux) 9 //Par: Dr TCHOUPE T. Maurice I2c
tête queue
Conflits d’accès aux variables partagées (2/2)
Processus B : qb 9 5 6 7 8 9
69<qb ← queue> Fich.c TP17.c CV.doc Test.ps après
F_c
qc 9 I3b
//I1b
tête queue
<charger fichier
F_b dans [queue]> //I2b qb 9 5 6 7 8 9
<queue← qb+1> //I3b Fich.c TP17.c CV.doc Test.ps F_c
après
qc 9 I3c
Processus C : tête queue
<qc ← queue> //I1c Problème : Le fichier F_b ne sera jamais imprimé,
<charger fichier car il a été écrasé par F_c.
F_c dans [queue]> //I2c Source du problème : la variable partagée queue
<queue← qc+1> //I3c est lue est modifiée par deux processus à la fois.
Les conflits d’accès concurrents aux variables partagées ont plusieurs solutions
possibles (sémaphores, moniteurs, …).
L’idée commune de ces solutions est l’exclusion mutuelle : une variable partagée ne
doit pas être lue ni modifiée par plus d’un processus à la fois. Si d’autres processus
veulent y accéder ils doiventSupport
attendre que le premier processus ait fini.
: Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice
Echange de messages
70
Les mécanismes de communication par variables partagées conviennent bien à
des processus qui tournent sur le même processeur ou sur plusieurs processeurs
possédant une mémoire commune.
Pour les systèmes distribués, i.e. constitués de plusieurs processeurs ayant chacun
leur propre mémoire et reliés par un réseau local, la communication inter-
processus peut se faire par échange de message :
• Un processus peut envoyer un message par réseau à un destinateur précis :
send(destination, message)
• Un autre processus peut “consommer” un message par :
receive(source, message)
• Les problèmes qui se posent :
– Perte de message lors du passage par réseau - nécessité d’acquittement
– Perte d’acquittement - nécessité de retransmission d’un message
– Reconnaissance d’un message envoyé 2 fois (à cause de perte
d’acquittement)
– Authentification des processus envoyant et recevant le message, etc.
71
Gestion de la mémoire
(voir support annexe)

72
Le SHELL et la programmation en SHELL:

LE LANGAGE DE COMMANDE

Scripts Shell
73
Le nom de shell désigne l’interpréteur de commandes du système

UNIX.
Le shell est à la fois un langage de programmation et un interpréteur
de commande.
Le shell, lancé automatiquement dès le login interactif sur le système
Unix, réalise l’interface (en mode texte) entre l’utilisateur et le système
UNIX. Les programmes shell sont donc interprétés par celui-ci.
Comme le shell entoure virtuellement l’ensemble des commandes, les
demandes faites par le programme se traduisent souvent par un
appel à une commande et on dit qu’il interprète un langage de
commande.
Par la suite, on confondra par abus de langage, les termes «
interpréteur de langage de commande » et « langage de commande
».

Scripts Shell
74
Les commandes exécutées par le shell peuvent

provenir soit:
du terminal (mode interactif),
soit d’un fichier (mode batch). On peut en effet créer
des fichiers de commandes ce qui permet en quelque
sorte aux utilisateurs de fabriquer leurs propres
commandes. Ces commandes possèdent les mêmes
prérogatives que les commandes définies dans les
répertoires /bin et /usr/bin. De cette manière, il est
possible à un utilisateur de se façonner un
environnement sur mesure.

Scripts Shell
75
Les interpréteurs de commandes sous UNIX

Sous UNIX, l’interpréteur de commande n’est pas unique :
l’utilisateur, à sa convenance, peut choisir parmi plusieurs :
(Bourne-shell ou sh : en standard, le plus ancien historiquement,
Korn-shell (ksh : conçu comme une extension du Bourne-shell),
C-shell (csh : dont la syntaxe est proche de celle du langage C),
Bourne Again Shell (bash : le plus répandu sous Linux),
...
Les programmes conçus pour sh peuvent, à quelques détails
près, être interprétés par les autres shells.

Scripts Shell
76
Comment lancer l’exécution d’un programme schell

Un programme shell (batch) est contenu dans un fichier.
Pour le lancer, on peut utiliser trois méthodes :
rendre le fichier exécutable par chmod +x fich. Puis il ne
reste plus qu’à taper fich [paramètres] chaque fois qu’on
veut le lancer. Le shell constatera que ce fichier contient des
commandes et les interprétera.
sh [-options] fich [paramètres]
Cette commande permet de forcer l'exécution du fichier ded
commandes en créant un nouveau processus shell (prenant ses
données dans le fichier de commandes)

Scripts Shell
77
Comment lancer l’exécution d’un programme schell

Ces deux dernières manières de procéder ont pour
inconvénient de créer un nouveau processus descendant du
processus SHELL courant d’où la commande est lancée et qui
dans certain cas peut être gênant.
généralement, on aimerait que le fichier de commande soit
interprété dans le même processus que celui du shell pour
cela, on redirige momentanément l’entrée standard du shell
interactif courant au moyen de la commande
. <reference fichier commande>
ainsi la commande $ . com1 exécute le script com1.

Scripts Shell: lexique
78
Le shell interprète des instructions séparées par des séparateurs. Les

instructions étant de sortes très différentes, nous utiliserons le
vocabulaire suivant :
une commande est une instruction analogue à un appel de sous-
programme dont le code est exécutable par la machine.
Par exemple cp et rm, sont des commandes.
une commande interne est une instruction analogue à un appel de sous-
programme interne au shell. Son action est réalisée par le shell lui-
même.
Par exemple exit est une commande interne au shell.
une instruction est une commande interne qui est une structure de
contrôle if, while, for, sont des instructions du shell.
une phrase, ou une ligne de commande, est une composition
syntaxiquement correcte de commandes, commandes internes et
instructions que sait interpréter le shell.
Les séparateurs de phrases sont le retour chariot (rc) et le ;

Scripts Shell: lexique
79
Dans une phrase, les séparateurs sont le blanc et la

tabulation, leur nombre étant quelconque.
Les mots du langage sont constitués avec les caractères
lettres, chiffres et souligné. Ils commencent par une
lettre ou un souligné. On peut utiliser des caractères
spéciaux à condition de les invalider.
Les mots désignent les variables, les symboles du
langage et les noms des fichiers. On pourra placer des
commentaires à condition de les faire précéder d’un
dièse (#) et de les terminer par un (rc).

Scripts Shell: caractères génériques
80
Les caractères génériques portent aussi le nom de caractères jokers.

Ils servent à remplacer un caractère quelconque ou n’importe quelle
chaîne, même vide (comme les jokers remplacent n’importe quelle
carte).
Lorsque le shell rencontre un mot comportant un caractère joker, il
tente de remplacer ce caractère par toutes les solutions possibles.
On obtient ainsi plusieurs combinaisons contenant le mot. Ces
caractères sont le point d’interrogation, l’étoile et les crochets.
? remplace un caractère quelconque sauf le retour cariot (rc).
* remplace n’importe quelle chaîne de caractères, même vide, ne
comportant pas de (rc).
[ ] remplace un caractère:
parmi ceux énumérés entre les crochets ou
un caractère parmi ceux qui ne sont pas énumérés si la liste commence par un
point d’exclamation.

Scripts Shell: caractères génériques
81
Lorsque le shell interprète les caractères génériques, il ne les remplace pas s’il ne
trouve aucun nom de fichier à mettre en correspondance. Par exemple:
rm * supprime tous les fichiers du répertoire courant ainsi que tous les sous-répertoires
vides.
ls -l t*.c liste tous les fichiers du répertoire courant commençant par t et se terminant par
.c.
ls -l *.? liste tous les fichiers du répertoire courant se terminant par . suivi d’un seul
caractère.
cp [a-e]*.* .. copie tous les fichiers du répertoire courant commençant par une des cinq
premières lettres de l’alphabet, et contenant au moins un point dans leur nom, même en
dernière position. La copie se fait dans le répertoire père.
La commande ls -l ??? vous donnera les contenus de tous les répertoires écrits avec
seulement 3 lettres.
La commande ls -l ??e* liste le contenu des répertoires commençant par 2 lettres
quelconques suivies d’un e et de n’importe quoi y compris un blanc.
La commande ls -l [A-Z,a-e]* liste le contenu des répertoires commençant par une lettre
majuscule ou par une minuscule comprise entre a et e. On aurait aussi pu écrire : ls -l [A-
e]* .

Scripts Shell: Caractères spéciaux
82
Le caractère de continuation \ placé en fin de ligne

indique que la phrase en cours n’est pas terminée et
qu’elle se poursuit sur la ligne suivante. Le (rc) est
ainsi transformé en espace.
Les caractères spéciaux ont une signification dans le
langage à moins qu’ils ne soient invalidés.
Un caractère spécial devient un caractère normal
s’il est précédé du caractère \ ou s’il est situé dans
un parenthésage particulier.
Les caractères spéciaux sont: & | < > $ () ’ " ‘ {} \

Scripts Shell:Variables et paramètres
83
Les variables sont désignées par des mots : elles ne

se déclarent pas.
Il n’existe aucune notion de type.
Par convention, les variables sont écrites en lettres
majuscules.
Les paramètres désignent l’ensemble des chaînes de
caractères que l’on écrit à la suite du nom d’un
fichier shell lors de son exécution.

Scripts Shell: Variables Utilisateurs
84
L’initialisation d’une variable se fait par une affectation,

réalisée par le signe = (Pas d’espace de chaque côté de l’
= ).
L’utilisation le la variable se fait avec le signe $.
La valeur affectée à la variable peut être une valeur
numérique, une chaîne, le résultat d’une commande, une liste
de commandes parenthèsées.
$ HOME=/home/IUP2/etudiant #$==Invite de commande
$ echo $HOME
/home/Iogin_name
$
Si la variable n’a pas été initialisée ou si elle comporte une
erreur d’écriture, la commande renvoie une chaîne vide. Si
l’on oublie le $, echo HOME renvoie HOME

Scripts Shell
85
Traitement des quotes

Les chaînes de caractères doivent être encadrées par des quotes (.).
$ TEMPS=’Il faut beau’
$ echo $TEMPS
Il fait beau
$
Traitement des accents graves
Toute commande entre accents graves sera exécutée et le résultat
affecté à la variable.
$ EN_LIGNE=`who | cut –f 1 –d " "`
$ echo $EN_LIGNE
root
chiesa
lerest
$

Scripts Shell
86
Paramètres
Les paramètres sont initialisés si on les tape à la suite du
nom du fichier.
Ils portent les numéros de 1 à 9 précédés du $.
$1 est une expression dont la valeur est celle du premier
paramètre effectif placé après une commande simple.
$2, pour le deuxième, . et
$9 pour le neuvième.
$0 existe et désigne la commande elle-même.
Notons, tout de suite, que cette technique ne limite pas le
nombre de paramètres à 9, comme nous le verrons par la
suite.

Scripts Shell: Variables prédéfinies
87
Il existe des variables prédéfinies. Parmi celles-ci :

# nombre de paramètres effectifs d’une commande
? code de retour d’une commande
$ numéro du processus shell en cours
! numéro du dernier processus lancé en arrière-plan
HOME nom du répertoire personnel
PATH règle de recherche des commandes
PS1 invite primaire du shell (par défaut $)
PS2 invite secondaire du shell (par défaut >)
On peut détruire une variable par la commande interne

unset, sauf les variables PATH, PS1 et PS2.

Scripts Shell: Expansion des variables
88
La substitution de valeur d’une variable ou d’un

paramètre permet d’évaluer conditionnellement la
valeur de la variable ou du paramètre. Ce mécanisme
sert à donner des "valeurs par défaut" à des variables
dont on ne sait pas si elles sont initialisées. Ainsi :
${VAR:-mot} délivre $VAR si la variable VAR est initialisée,
sinon initialise avec mot.
${VAR:=mot} assigne mot à VAR si la variable n’est pas
initialisée, puis évalue $VAR.
${VAR:?mot} délivre $VAR si la variable est initialisée, sinon
affiche le nom de la variable suivi de :, puis mot, et termine
le processus shell en cours.

Scripts Shell: Expansion des variables
89
Exemples
1) ESSAI=${VAR:-mot} VAR n’étant pas initialisée, ESSAI est initialisé par mot
(équivalent à ESSAI=mot) ($VAR n’existe pas).
VAR=init
ESSAI=${VAR:-mot} VAR étant initialisée par init, ESSAI est initialisé par $VAR
(équivalent à ESSAI=$VAR).
2) ESSAI=${VAR:=mot} VAR n’étant pas initialisée, VAR est initialisée par mot et
ESSAI devient équivalent à $VAR (équivalent à VAR=mot, ESSAI=$VAR, donc
ESSAI=mot)
VAR=init
ESSAI=${VAR:=mot} VAR étant initialisée par init, ESSAI devient équivalent à
$VAR (équivalent à ESSAI=$VAR)
3) ESSAI=${VAR:?mot} VAR n’étant pas initialisée, affiche VAR: et mot puis
arrête le processus shell en cours.
VAR=init
ESSAI=${VAR:?mot} VAR étant initialisée par init, ESSAI devient équivalent à
$VAR (équivalent à ESSAI=$VAR) et le processus shell se continue.

Scripts Shell: Portée et environnement
90
La portée d’une variable est le processus qui l’a créée.

Pour être visible dans les autres processus shell qui
seront créés par la suite, une variable doit être
exportée par la commande interne export : elle est
alors placée dans l’environnement du processus,
environnement dont hériteront ses fils.
On lance export PATH pour exporter les chemins de
recherche de nos commandes (réalisé dans .profile).
La liste des variables exportées dans l’environnement
est obtenue par la commande env.
La liste de toutes les variables est obtenue par la
commande set.

Scripts Shell: Portée et environnement
91
Il est possible (en bash) de créer des variables

locales aux fonctions qui les utilisent. Par exemple :
#!/bin/bash
HELLO=Hello
function hello {
local HELLO=World
echo $HELLO
}
echo $HELLO
hello
echo $HELLO

Scripts Shell: expressions, lecture et
92
affichage
Le calcul d’expression sur des variables est
supporté par le shell sous certaines contraintes. $ A=3
$ B=2
Tout d’abord, les opérateurs arithmétiques sont en $ Echo 1+3
nombre réduit : +-*/ et % (le reste). $ 1+3
Ensuite, les calculs sont réalisés en nombre entiers $ echo $[1+3]
seulement. $4
Enfin, il faut utiliser le [ ] pour réaliser l’évaluation. $ echo $[A+B]
Par exemple : $5
$ echo $[A/B]
$1
$ echo $[A/B]|bc –l
$ 1.5
La dernière ligne montre comment utiliser la commande calculateur bc pour se sortir de
l’impasse des nombres entiers.

93
affichage
Les comparaisons arithmétiques :
lt (<), gt (>), le (<=), ge (>=), eq (==), ne ( !=).
Les comparaisons de chaînes sont facilement compréhensibles,
simplement il faut veiller à ne pas confondre avec des comparaisons
arithmétiques :
s1=s2 , s1>s2, s1<s2, -n s1 (« s1 nest pas vide »), -z s1 (« s1 est vide »).
Les comparaisons sur les fichiers :
-r f (« f existe et a le droit de lecture r »),
-w f (« f existe et a le droit w »),
-x f (« f existe et a le droit x »),
-f f (« f existe et est un fichier ordinaire »),
-d r (« le répertoire r existe »),
-u f (« f existe et a le bit set UID »),
-s f (« f existe et n’est pas de longueur nulle »).
94
affichage
Les lectures et les écritures sont réalisées par des commandes
internes du shell.
La commande interne read permet dinitialiser des variables en mode
conversationnel et admet comme paramètre une ou plusieurs variables
séparées par un séparateur de mots.
Elle initialise la première avec la première chaîne tapée, le séparateur au
clavier étant aussi le blanc (ou le TAB).
Elle initialise la deuxième avec la deuxième chaîne, ... et elle initialise la
dernière avec toutes les chaînes de fin de ligne.
#!/bin/bash
echo Please, enter your firstname and lastname
read FN LN
echo "Hi! $LN, $FN !"
La commande echo permet dafficher la valeur dune variable et est
souvent une commande interne. Nous en avons déjà vu de nombreux
usages.

Scripts Shell: boucles et conditionnelles
95
Les mots-clés sont :

if then else fi case esac for while
until do done select
NUM=0
Boucle for
for PARAM in $*
for indice in liste
do
do
NUM=èxpr $NUM + 1`
liste_de_commandes echo "paramètre $NUM = $PARAM"
done done
La liste_de_commandes est for USER in `cat liste`
exécutée pour chaque valeur de do
l’indice (une variable non elm $USER –s " fichier message " < message
déclarée) prise dans la suite de
mots indiquée dans liste après le done
in .

96
Boucle while
while liste_de_commandes_1
do NUM=0
while [ $1 ] #tant que $1 existe, [ ] commande
liste_de_commandes_2 test
done do
La liste_de_commandes_1 est NUM=èxpr $NUM + 1`
exécutée. Si le code de retour echo "paramètre $NUM = $1"
shift #décale les paramètres
de la dernière commande de
done
liste_de_commandes_1 est 0
(vrai), alors la
liste_de_commandes_2 est
exécutée et la boucle continue.

97
boucle until
until liste_de_commandes_1
do NUM=0
liste_de_commandes_2 until [ $# -eq 0 ] #jusqu’à ce que le nombre de
done #paramètres soit nul
do
La liste_de_commandes_1 est NUM=èxpr $NUM + 1`
exécutée. Dès que le code de echo "paramètre $NUM = $1"
retour de la dernière
shift #décale les paramètres
commande de
done
liste_de_commandes_1 est 0
(vrai), la liste_de_commande_2
n’est plus exécutée et la boucle
s’arrête.

98
Sélection if
if liste_de_commandes_1
then
liste_de_commandes_2
else
liste_de_commandes_3
fi
On teste le code de retour de la dernière commande de
liste_de_commandes_1 ;
s’il est égal à 0, liste_de_commandes_2 est exécutée
sinon c’est liste_de_commandes_3 qui l’est.
L’existence de else liste_de_commandes_3 n’est pas obligatoire.
Le code de retour de la structure est 0 si liste_de_commandes_2 est
exécutée sinon c’est celui de la dernière commande de
liste_de_commandes_3.

99
Sélection if
On peut imbriquer les structures if comme dans le cas suivant :
if...
then...
else if...
then...
else...
fi
fi
On peut aussi écrire else if : elif (dans ce cas, un seul fi terminal)
La structure if suivante :
if commande_1
then
commande_2
fi
peut s’écrire commande_1 && commande_2

100
Sélection if: Exemple :

Indiquer si les fichiers d’un répertoire sont des fichiers
(ordinaires ou spéciaux) ou des sous-répertoires.
for FICH in *
do
if [ -d $FICH ] # $FICH est-il un répertoire ?
then
echo "répertoire : $FICH"
else
echo "fichier : $FICH"
fi
done

101
Sélection case
case expression in
cas_1)
liste_de_commandes_1 ;;
cas_2)
liste_de_commandes_2 ;;
. ..
cas_n)
liste_de_commandes_n ;;
esac
L’interpréteur de commandes cherche une équivalence entre la chaîne expression
et un des cas_i en suivant l’ordre de leur définition. Si une équivalence est trouvée
alors la liste_de_commandes associée est exécutée et la structure est terminée.
Comme le caractère * représente toute chaîne de caractères, on l’utilise comme
cas par défaut. Si aucun cas ne convient, la structure case ne fait rien.

102
Sélection case
Exemple : Préciser si le paramètre est un chiffre, une lettre
ou une suite de caractères.
NUM=0
for PARAM in $*
do
NUM=èxpr $NUM + 1`
case $PARAM in
[0-9]) echo "le paramètre $NUM est un chiffre: $PARAM" ;;
[a-z]|[A-Z]) echo "le paramètre $NUM est une lettre: $PARAM" ;;
*) echo "le paramètre $NUM contient plusieurs caractères: $PARAM";;
esac
done

Scripts Shell: les commandes
103
Les commandes correspondent aux instructions du

langage de programmation.
Une commande simple est une liste de mots séparés par
des espaces.
Le premier est le nom de la commande,
les autres sont les options et les paramètres.
Une commande délivre en retour une valeur appelée
code de retour.
Un code de retour nul indique une exécution sans erreur.
Les valeurs positives et négatives ont des significations
propres à chaque commande.

104
Les commandes peuvent être exécutées de différentes

manières :
exécution séquentielle : commandes séparées par un ;
exécution asynchrone : commande terminée par un & (même
priorité que ;)
exécution conditionnée :
commandes séparées par && : exécution de la partie droite
conditionnée par un code de retour nul de ce qui précède
(priorité supérieure à &)
commandes séparées par || : exécution de la suite conditionnée
par un code de retour non nul de ce qui précède (priorité
identique à &&)
On peut aussi les trouver sous forme de pipe | :
la sortie standard du processus situé à gauche est connectée par un
tube à l’entrée standard du processus situé à droite.
105
Commandes internes
Une commande interne est une commande prédéfinie dans le shell pour
laquelle il n’existe pas de fichier exécutable portant son nom.
pwd imprime le répertoire courant
cd change de répertoire
mkdir crée un répertoire
rmdir supprime un répertoire
echo affiche ses arguments
read lit une entrée au clavier
export « export » une variable (la rend visible au processus appelant)
break sortir d’une boucle (for, .).
continue continuer à l’itération suivante d’une boucle (for, ..).
exit quitter le programme avec, en code de retour, celui de la dernière
commande exécutée (fin du shell en cours).
return idem pour quitte

106
Commandes internes
. fichier exécuter les commandes du fichier sans créer un nouveau processus
: instruction vide du shell.
set list_args fournir les valeurs des paramètres effectifs correspondant aux
paramètres formels 1, 2, ... Permet ainsi de paramétrer les sous-programmes réalisés
par eval : il suffit pour cela que les commandes contenues dans la variable $VAR
soient paramétrées en faisant référence à $1, $2 ...
eval $VAR le contenu de la variable $VAR est considéré comme une liste de
commandes shell. Cela ressemble à un appel de sous-programme sans paramètre
shift les paramètres formels sont renommés: $2->$1 ; $3->$2... Utile lorsqu’une
commande a plus de 9 paramètres (exemple page 47).
On a déjà noté que les paramètres formels d’une commande sont désignés par des
chiffres et ce sont des paramètres de position : 0 représente le nom de la commande
paramétrée, 1 le premier paramètre, 2 le deuxième et ainsi de suite jusqu’à 9. La
notation $* est équivalente à "$1$2...", tandis que la notation $@ est équivalente à
"$1""$2".... On rappellera que $# renvoie le nombre de paramètres de la commande
test expr
[ expr ] test

107
Commandes externes
Toutes les commandes peuvent être utilisées dans les scripts shell.
Certaines commandes sont des grands classiques des scripts :
awk recherche d'expressions régulières et enchaînement d.action
si trouvées .
grep recherche d'expressions régulières et impression de la ligne
les contenant
wc compte de mots
sort tri
bc calculateur

108
PARENTHESAGES
Les parenthésages servent à regrouper des séquences de mots ou à isoler des mots.
Ils sont multiples et ont des significations spécifiques:
{...} regroupement de commandes, parenthésage ordinaire ; délimite aussi la portée de
l’opérateur de prise de valeur $.
(...) entoure une liste de commandes qui sont exécutées par un nouveau processus UNIX.
’...’ (quotes) parenthésage dans lequel aucun caractère, sauf ’, n’a de signification spéciale.
"..." (guillemets) parenthésage dans lequel aucun caractère, sauf ‘ " et $ n’a de signification
spéciale.
‘...‘ (accents graves) exécution de la phrase placée entre les accents graves; délivre la sortie
standard des commandes situées dans ce parenthésage. Les caractères spéciaux à l’intérieur du
parenthésage ne sont interprétés qu’à l’exécution de la phrase.
Le rôle des parenthésages par ’ et " est d’éviter une utilisation fastidieuse du
caractère \ quand il faut banaliser plusieurs caractères spéciaux dans une
commande. Bien entendu, on ne peut pas banaliser le caractère quote dans un
parenthésage quote, ni le caractère guillemet dans un parenthésage guillemet.

109
SOUS-PROGRAMMES
Procédure
Un texte écrit en shell et stocké dans un fichier constitue une procédure shell.
Dans le texte, les paramètres formels ont pour noms 1, 2...9 et leurs valeurs sont désignées par
$1,..., $9.
L’activation de la procédure peut se faire en exécutant la commande sh suivie du nom du fichier
(avec certaines options si l’on veut) ou en rendant le fichier exécutable ce qui fabrique une
nouvelle commande appelée sous-programme shell.
Fonction
Une fonction est un sous-programme local à un processus shell.
Elle n’est pas exécutée par un nouveau processus shell et n’est pas stockée seule dans un fichier.
Elle se déclare, un peu comme en C, dans le programme qui l’utilise :
nom()
{
corps de la fonction
}

110
SOUS-PROGRAMMES
Les parenthèses ne servent qu’à distinguer le nom d’une fonction du nom d’une
variable.
Exemple:
L’exemple suivant reprend l’écriture d’un programme shell utilisant 3 fonctions (menu, erreur et
traitement) appelées par un programme principal.(sélection if). Ce programme réclame un
paramètre, et seulement un, et celui-ci doit être obligatoirement un fichier ordinaire. Le
programme principal effectue ces vérifications, appelle menu et traitement si c.est correct
sinon lance erreur qui affiche le message correspondant à l.erreur faite.

111
menu()
{
..
Remarques :
} On notera la différence entre les paramètres
traitemement() passés au shell-script et ceux passés aux
{
fonctions. Le $1 (le nom du fichier à traiter) du
..
} programme n.est pas le $1 de erreur (le
erreur() nombre de paramètres passés au programme).
{ Les variables créées dans des sous-
if [ $1 -eq 1 ]
then
programmes ne sont pas purement locales à ces
echo "Le fichier $2 n'existe pas" fonctions, elles sont reconnues dans tout le
else fichier shell. En revanche, non seulement, elles
echo "Donnez un seul paramètre, pas $1"
sont détruites à la fin de l’exécution du fichier
fi
} shell mais encore, elles ne sont pas visibles dans
if [ -f $1 -a $# -eq 1 ] les processus engendrés. On peut les y rendre
then visibles par la commande interne export. Une
menu
traitement $1
fonction n’est pas exportable.
else
erreur $# $1
Support
fi : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice
Scripts Shell: exécution d'un script shell
112
Après avoir effectué les éventuelles substitutions de paramètres,
le shell traite les redirections,
puis examine le premier mot de la commande.
S’il est suivi d’un signe = cela signifie que c’est une affectation de
variable.
S’il correspond à une commande interne, à une commande structurée
(for, if...) ou à une activation de fonction, la commande est exécutée
dans le processus shell en cours.
Dans le cas contraire, il y a création d’un nouveau processus auquel
est passée en paramètre la commande.
Les règles de recherche des commandes sont fixées par la variable
PATH qui est initialisée à la connexion.

Scripts Shell: exécution d'un script shell
113
Paramètres de la commande sh
Lorsqu’un processus est créé par la commande sh, plusieurs
options définissant le mode d’exécution peuvent être indiquées.
Les plus utiles sont :
-v imprime les lignes telles qu’elles sont lues par le processus
shell
-x imprime les commandes telles qu’elles sont exécutées, après
les substitutions de paramètres.
Elles sont très intéressantes pour détecter d’éventuelles erreurs
de syntaxe. On les utilise de la manière suivante : sh -v proc.
On peut aussi les inclure dans un fichier shell en écrivant dans
la procédure : set -v ou set -x

114
Contrôle des processus

Lorsque des commandes sont lancées en arrière-plan et
qu’il est nécessaire de synchroniser la suite d’un
programme shell avec la fin de ces commandes, le
programme shell doit se bloquer en attente de la fin de
ces commandes par la commande interne wait.
wait num suspend l’exécution jusqu’à ce que le
processus de n° num, ou tous les processus lancés en
arrière-plan, se terminent.

Inf 132 PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Inf 132 PDF

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSITE DE DOUALA

Faculté des Sciences

Département de Mathématiques et Informatique

Année Académique 2019/2020

Tanenbaum A. Systèmes d’exploitation, Pearson Education, Paris

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Un système informatique, qu’est ce que c’est ?

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

En anglais « Operating System (OS) »

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

L’architecture au niveau du langage machine est lourde à

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Le système d’exploitation présente au programmeur une interface d’accès

Le système d’exploitation en tant que machine

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Gestion Gestion des

Les programmes utilisateur peuvent accéder à ces différentes fonctionnalités à

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

FONCTIONS D’UN SYSTEME D’EXPLOITATION ABORDEES DANS

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Système de fichiers UNIX/Linux

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Le fichier UNIX est une suite éventuellement vide

Hiérarchie des répertoires.

Deux systèmes de fichiers séparés Après le montage

Hiérarchie des répertoires.

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Hiérarchie des répertoires.

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Copie, déplacement, liens sur les fichiers.

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

sticky bit, set uid, set gid :

Exemple: voir ci-dessous

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

chgrp <groupe> <refFichier> … permet de changer le

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

On peut également inter-agir sur le SF par programme

On peut aussi interagir avec le SF par programme au moyen d'appels systèmes

Appel système Description

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Lorsqu’un processus démarre de façon standard, 3 fichiers spéciaux sont

(ls -l toto > f1) 2> f2 36

Problème : compter le nombre de mots uniques dans une liste .

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE

Un tube = un flot de données entre deux processus obtenu par la redirection

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE

Les différents types de fichiers

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Structure d’un disque

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Chacun de ces groupes est constitué de blocs logiques, contenant un

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice

Support : Système d'exploitation (Linux) //Par: Dr TCHOUPE T. Maurice