Introduction à l'Informatique

Cours 2
kn@lri.fr
http://www.lri.fr/~kn
 Plan

1 Présentation du cours ✓
2 Le système Unix ✓
3 Le système Unix (2)
3.1 Gestion des processus
3.2 Script shells
 Dé�nitions

Programme : séquences d'instructions e�ectuant une tâche sur un ordinateur.

Exécutable : �chier binaire contenant des instructions machines interprétables par le

microprocesseur.

Processus : instance d'un programme (≡ « un programme en cours d'exécution »).

3 / 42
 Exécuter un programme ?
Pour exécuter un programme on peut

◆ Cliquer sur l'icône de l'exécutable, dans une interface graphique

◆ Entre le chemin vers le �chier exécutable dans le terminal (ou simplement son nom, si
le �chier est dans un répertoire prédé�ni).

Le programme s'exécute… oui mais comment ?

4 / 42
Microprocesseur

5 / 42
 Modèle de Von Neumann
Proposé par John Von Neumann en 1945
Un processeur

◆ Une Unité Arithmétique et Logique (ALU) : calcul

◆ Un banc de registres : opérandes et résultats
◆ Une unité de contrôle : exécution

De la mémoire
Des périphériques d'entrée/sortie

6 / 42
 Jeu d'instructions
Un processeur est un circuit programmable. Il sait exécuter un certain nombre
d'opérations (arithmétiques, logiques, lecture/écriture en mémoire, …).
L'ensemble de ces instructions s'appelle le jeu d'instruction
Chaque instruction possède une représentation en binaire (suite de 0 et de 1)
Par exemple, sur les processeur Intel, 01101001 représente la multiplication

7 / 42
 Mémoire et registre

◆ La mémoire est un grand tableau d'octets (8 bits)

◆ L'indice d'une case dans le tableau s'appelle une adresse
◆ Un registre une petite case mémoire, située au sein du processeur sur laquelle le
processeur peut travailler (additionner deux registres, faire la négation d'un registre,
écrire un registre en mémoire, …)

8 / 42
 Fonctionnement de l'architecture de Von Neumann

◆ Les instructions du programmes sont stockées en mémoire

◆ L'unité de contrôle possède un registre spécial : PC (program counter) qui indique
l'adresse de la prochaine instruction à exécuter

1. L'unité de contrôle lit en mémoire la prochaine instruction et la décode (ex: 01101001

= multiplier)
2. Si besoin les opérandes sont stockées dans des registres
3. L'ALU e�ectue l'opération et sauve le résultat dans un nouveau registre (opération
arithmétique)
4. Ou le processeur copie un registre dans la mémoire (opération d'écriture)
5. PC se positionne sur l'adresse de l'instruction suivante, et on recommence en 1

9 / 42
 Et donc quand on exécute un programme ?
Un �chier exécutable est un �chier contenant des instructions machines (comme
01101001).

Lorsqu'on l'exécute :

1. Le système d'exploitation lit le �chier, il le copie dans une zone de la mémoire

2. Il copie l'adresse du début de la zone dans PC

10 / 42
 Plusieurs processus ?
Le modèle de Von Neumann seul ne permet pas d'exécuter « plusieurs programmes à la
fois »
Les processeurs modernes possèdent aussi des alarmes con�gurables
Le système d'exploitation con�gure une alarme pour interrompre le processeur toutes
les X㎲
Lors de cette interruption une portion de code spéciale est exécutée : le gestionnaire
de processus

11 / 42
 Exemple

1. Exécution d'un jeu pendant 50㎲

2. Interruption : le code spécial sauvegarde les registres et l'état du processeur, puis
restaure les registres d'un autre programme (par exemple �refox)
3. Exécution de �refox pendant 50㎲
4. Interruption : sauvegarde des registres puis, restauration de l'état d'un autre
programme
5. Exécution du processus qui dessine le bureau pendant 50 ㎲
…
6. On remets dans les registre toutes les valeurs sauvées en 2, le jeu reprend comme si
de rien n'était

C'est le ordonanceur de processus qui décide quel programme a la main et pour combien
de temps (priorité aux tâches critiques par exemple)
Le système d'exploitation stocke pour chaque processus un ensemble d'informations, le
PCB (Process Control Block).

12 / 42
 Proccess Control Block
Le PCB contient:

◆ l'identi�cateur du processus (pid)

◆ l'état du processus (en attente, en exécution, bloqué, …)
◆ le compteur d'instructions (i.e. où on en est dans le programme)
◆ le contexte courant (état des registres, …)
◆ position dans la �le d'attente de priorité globale
◆ informations mémoire (zones allouées, zones accessibles, zones partagées)
◆ listes des �chiers ouverts (en lecture, en écriture), liste des connexions ouvertes, …
…

13 / 42
 Opérations sur les processus

◆ création et destruction de processus

◆ suspension et reprise
◆ duplication (fork)
◆ modi�cation de la priorité
◆ modi�cation des permissions

14 / 42
 États d'un processus
Un processus change d'état au cours de son exécution

Nouveau : le processus est en cours de création

Exécution : le processus s'exécute
En attente : le processus attend un évènement particulier (saisie au clavier,
écriture sur le disque, …)
Prêt : le processus est prêt à reprendre son exécution et attend que l'OS
lui rende la main
terminé : le processus a �ni son exécution

15 / 42
 États d'un processus
L'OS détermine et modi�e l'état d'un processus:

◆ En fonction d'évènements internes au processus:

◆ lecture d'un �chier (si le contenu n'est pas disponible, le processus passe de « prêt »
à « en attente »)
◆ le processus attends volontairement pendant x secondes

…
◆ En fonction d'évènements externes au processus:
◆ un �chier devient disponible
◆ un timer arrive à 0
◆ le matériel déclenche une interruption

16 / 42
 États d'un processus

Nouveau mise en route

par l'ordonnanceur

Prêt En exécution
interruption
par l'ordonnanceur

terminaison
fin E/S
normale
int. traitée
…
En attente attente E/S
interruption
terminaison
Terminé
anormale

17 / 42
 La commande ps
Permet d'avoir des informations sur les processus en cours d'exécution (voir « man ps »
pour les options):
$ ps -o user,pid,state,cmd x
USER PID S CMD
…
kim 27030 Z [chrome] <defunct>
kim 27072 S ∕opt∕google∕chrome∕chrome --type=renderer
kim 29146 S bash
kim 29834 S evince
kim 29858 S emacs cours.xhtml
kim 29869 R ps -o user,pid,state,cmd x

18 / 42
 États des processus (sous Linux)
R : Running (en cours d'exécution)
S: Interruptible sleep (en attente, interruptible)
D : Uninterruptible sleep (en attente, non-interruptible)
T: Stopped (interrompu)
Z: Zombie (terminé mais toujours listé par le système)

19 / 42
 Signaux
L'OS peut envoyer des signaux à un processus. Sur réception d'un signal, un processus
peut interrompre son comportement normal et exécuter son gestionnaire de signal.
Quelques signaux:
Nom Code Description
INT/TERM 2,15 demande au processus de se terminer
QUIT 3 interrompt le processus et produit un dump
KILL 9 interrompt le processus immédiatement
SEGV 11 signale au processus une erreur mémoire
STOP 24 suspend l'exécution du processus
CONT 28 reprend l'exécution d'un processus suspendu

20 / 42
 Processus et terminal
Un processus est lié au terminal dans lequel il est lancé. Si on exécute un programme
dans un terminal et que le processus ne rend pas la main, le terminal est bloqué
$ gedit
On peut envoyer au processus le signal STOP en tapant
ctrl-Z
dans le terminal:
$ gedit
^Z
[1]+ Stopped gedit
Le processus est suspendu, la fenêtre est gelée (ne répond plus).

21 / 42
 Processus et terminal
On peut reprendre l'exécution du programme de deux manières:

$ fg
Reprend l'exécution du processus et le remet en avant plan (terminal bloqué)

$ bg
Reprend l'exécution du processus et le remet en arrière plan (terminal libre)
On peut lancer un programme directement en arrière plan en faisant:
$ gedit &

On peut envoyer un signal à un processus avec la commande « kill [-signal] pid »

$ kill -9 2345

22 / 42
 Processus et entrées/sorties
Le terminal et le processus sont liés par trois �chiers spéciaux:

1. L'entrée standard (stdin), reliée au clavier

2. La sortie standard (stdout), reliée à l'a�chage
3. La sortie d'erreur (stderr), reliée à l'a�chage

Dans le shell, on peut utiliser les opérateurs <, > et 2> pour récupérer le contenu de
stdin, stdout et stderr:

$ sort < toto.txt

$ ls -l > liste_fichiers.txt
$ ls -l * 2> erreurs.txt

23 / 42
 Shell et entrées/sorties
Dans le shell, l'opérateur | permet d'enchaîner la sortie d'un programme avec l'entrée
d'un autre:
$ ls -l *.txt | sort -n -r -k 5 | head -n 1

1. a�che la liste détaillée des �chiers textes

2. trie (et a�che) l'entrée standard par ordre numérique décroissant selon le 5ème
champ
3. a�che la première ligne de l'entrée standard

-rw-rw-r 1 kim kim 1048576 Sep 24 09:20 large.txt

24 / 42
 Fonctionnement des redirections

cmd < fichier :

�chier est ouvert en lecture avant le lancement de cmd, le contenu est redirigé vers
l'entrée standard de cmd.
cmd > fichier :
�chier est ouvert en écriture avant le lancement de cmd. Si �chier n'existe pas il est
créé. S'il existe il est tronqué à la taille 0. La sortie standard de cmd est redirigée vers
�chier.
cmd >> fichier :
�chier est ouvert en écriture avant le lancement de cmd. Si �chier n'existe pas il est
créé. S'il existe, le curseur d'écriture est placé en �n de �chier. La sortie standard de
cmd est redirigée vers �chier.
cmd 2> fichier :
Comme > mais avec la sortie d'erreur
cmd 2>> fichier :
Comme >> mais avec la sortie d'erreur

25 / 42
 Attention à l'ordre d'exécution !
Quelques exemples de commandes problématiques :
$ sort fichier.txt > fichier.txt
fichier.txt devient vide ! Il est ouvert en écriture et tronqué avant l'exécution de la
commande.
$ sort < fichier.txt > fichier.txt
fichier.txt devient vide ! Il est ouvert en écriture et tronqué avant l'exécution de la
commande.
$ sort < fichier.txt >> fichier.txt
fichier.txt contient son contenu original, suivi de son contenu trié !

$ cat < fichier.txt >> fichier.txt

fichier.txt est rempli jusqu'à saturation de l'espace disque !

26 / 42
 Quelques explications (1/2)
La commande sort doit trier son entrée standard. Elle doit donc la lire intégralement
avant de produire la moindre sortie. Pour
$ sort < fichier.txt >> fichier.txt
on a donc :

1. Ouverture de �chier.txt en lecture

2. Ouverture de �chier.txt en écriture, avec le curseur positionné en �n
3. Lecture de toute l'entrée
4. Écriture de toute la sortie en �n de �chier.txt

27 / 42
 Quelques explications (2/2)
La commande cat ré-a�che son entrée standard sur sa sortie standard. Elle peut donc
lire le �chier morceaux par morceaux et les a�cher au fur et à mesure. Supposons que
�chier.txt contient AB :
$ cat < fichier.txt >> fichier.txt

1. Ouverture de �chier.txt en lecture

2. Ouverture de �chier.txt en écriture, avec le curseur positionné en �n
3. Lecture de A (et positionnement du curseur de lecture sur B)
4. Écriture de A en �n de �chier �chier.txt
5. Lecture de B (et positionnement du curseur de lecture sur A)
6. Écriture de B en �n de �chier �chier.txt
7. Lecture de A (et positionnement du curseur de lecture sur B)
8. Écriture de A en �n de �chier �chier.txt
9. …

28 / 42
 Conseils…
On évitera toujours de manipuler le même �chier en entrée et en sortie. Il vaut mieux
rediriger vers un �chier temporaire, puis renommer ce dernier (avec la commande mv).

29 / 42
 Enchainement de commandes et code de sortie
Sous Unix, chaque commande renvoie un code de sortie (un entier entre 0 et 255).
Par convention, un code de 0 signi�e terminaison normale, un code di�érent de 0 une
erreur. On peut enchaîner des commandes de plusieurs façons :

cmd1 ; cmd2
cmd2 est exécutée après cmd1
cmd1 && cmd2
cmd2 est exécutée après cmd1 si cette dernière réussit (code de sortie 0)
cmd1 || cmd2
cmd2 est exécutée après cmd1 si cette dernière échoue (code de sortie di�érent de 0)

30 / 42
 La commande test
La commande test permet de tester des conditions sur les �chiers passés en arguments.
Si le test est vrai, la code de sortie est 0, sinon c'est 1
Les options permettent de spéci�er les tests.

31 / 42
 La commande test (exemples)
L'option -f permet de tester si un �chier existe :

$ test -f toto.txt

La commande sort avec le code de sortie 0 si le �chier toto.txt existe et 1 sinon.

Comment s'en servir ?

$ test -f toto.txt && echo "Ok" || echo "Pas ok"

La commande a�che "Ok" si le �chier existe et "Pas ok" sinon.

32 / 42
 Plan

1 Présentation du cours ✓
2 Le système Unix ✓
3 Le système Unix (2)
3.1 Gestion des processus ✓
3.2 Script shells
 Retour sur les exécutables
On a vu qu'un �chier exécutable est censé contenir des instructions machines.
Un humain ne peut pas écrire directement des instructions machines en binaire.

1. On peut utiliser un compilateur : Un programme qui transforme un �chier texte

contenant le code source d'un programme (par exemple en C++) en instructions
machines. (cf. les futurs cours d'Intro Prog Impérative).
2. On peut aussi utiliser un interpréteur : Un progamme qui lit des instructions dans un
�chier texte et les exécutes.

◆ Le langage C++, utilisé en Intro. Prog. Impérative est compilé.

◆ Le langage du shell et la langage Python sont interprétés.

34 / 42
 Exécutables pour langages interprétés
Est-il possible d'écrire des programmes en shell ou en Python et d'en faire des �chiers
exécutables ?
Oui !
On procède de la façon suivante

1. On crée un �chier texte (ex: test.sh) contenant le code dans le langage choisi (par
exemple le shell)
2. On indique en début de �chier un commentaire spécial (appelé shebang) :

#!∕bin∕bash

Cette ligne commence par #! est suivie du chemin vers le programme qui interprète
le langage (bash, python3, …)
3. On rend ce �chier exécutable. On peut ensuite l'exécuter.

$ chmod 755 test.sh

$ .∕test.sh

35 / 42
 Que fait le système d'exploitation ?
Lorsque l'on essaye d'exécuter une commande :

◆ Soit la commande est un �chier binaire, le système la copie en mémoire et con�gure

le processeur pour qu'il exécute la première instruction.
◆ Soit le �chier commence par une ligne de la forme :

#!∕chemin∕vers∕un∕programme
...
texte
...

Le texte du �chier est copié sur l'entrée standard du programme dont le chemin est
donné (« comme si un utilisateur avait saisi les lignes au clavier »)

36 / 42
 Script Shell
On peut utiliser cette fonctionalité pour écrire des scripts shell.

◆ Permet de combiner plusieurs commandes pour réaliser des traitements complexes

◆ Permet de stocker une fois pour toute une longue liste de commandes plutôt que de
la saisir à chaque fois
◆ Comme dans tous les langages, on peut dé�nir des variables
◆ On peut aussi utiliser des structures de contrôle avancées (boucles, tests, …)

37 / 42
 Dé�nitions de variables
On peut dé�nir des variables au moyen de la notation
VARIABLE=contenu
et on peut utiliser la variable avec la notation $VARIABLE

◆ Attention, pas d'espace autour du =

◆ nom de variable en majuscule ou minuscule
◆ contenu est une chaine de caractères. Si elle contient des espaces, utiliser " ... "
exemple de dé�nition :

i=123
j="Ma super chaine"
TOTO=titi
echo $TOTO
exemple d'utilisation: echo $j $i $TOTO
a�che « Ma super chaine 123 titi »

38 / 42
 Variables spéciales
Les variables $1, $2, … contiennent les arguments passés au script sur la ligne de
commande.
La variable $0 contient le chemin vers le script en cours d'exécution
Attention, il est recommandé de toujours encadrer l'utilisation d'une variable par des
guillemets "

39 / 42
 Conditionnelle
La syntaxe est :
if commande
then
...
else
...
fi
commande est évaluée. Si elle se termine avec succès, la branche then est prise. Si elle se
termine avec un code d'erreur, la branche else est prise. On peut utiliser la commande
test qui permet de tester plusieurs conditions (existance d'un �chier, égalités de deux
nombres, ...) et se termine par un succès si le teste est vrai et par un code d'erreur dans
le cas contraire

40 / 42
 Exemple de script
On est dans le �chier backup.sh :
#!∕bin∕bash
INPUT="$1"
if test -f "$INPUT"
then
cp "$INPUT" "$INPUT".bak
echo "Sauvegarde du fichier $INPUT réussie"
else
echo "Erreur, le fichier $INPUT n'existe pas"
fi
On suppose que le script possède les bonnes permissions, qu'il se trouve dans le
répertoire courant, et qu'un unique �chier doc.txt se trouve dans ce même répertoire

$ .∕backup.sh doc.txt
Sauvegarde du fichier doc.txt réussie
$ ls
backup.sh doc.txt doc.txt.bak
$ .∕backup.sh toto.txt
Erreur, le fichier toto.txt n'existe pas

41 / 42
 Conclusion

◆ On s'arrête la pour les commandes de base du shell.

◆ Outil précieux qui permet de scripter plusieurs tâches d'administration système
(renommer des �chiers en masse, exécuter une même action dans plusieurs répertoires,
…)
◆ Expose les concepts systèmes utile à la programmation en général (chemin,

permission, utilisateurs, …)

42 / 42