Systèmes d’exploitation et

Programmation système

[Link]@[Link]

ENS Rennes

2020-2021
 Premier chapitre
Introduction

Qu’est ce qu’un système d’exploitation ?

Interfaces du système d’exploitation

Protection des ressources

Conclusion
Qu’est ce qu’un système d’exploitation

Logiciel entre les applications et le matériel

▶ Offre une interface unifiée du matériel aux applications
▶ Protège les ressources (et les applis entre elles)
▶ Virtualise les ressources

Firefox Emacs VLC

Système d’exploitation

Son

Disques durs
Matériel Cartes graphiques

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 7/61

Rôle de l’OS : intermédiaire matériel ↔ applications

Deux fonctions complémentaires

▶ Adaptation d’interface : offre une interface plus pratique que le matériel
▶ Dissimule les détails de mise en œuvre (abstraction)
▶ Dissimule les limitations physiques (taille mémoire) et le partage des ressources

▶ Gestion des ressources (mémoire, processeur, disque, réseau, affichage, etc.)

▶ Alloue les ressources aux applications qui le demandent
▶ Partage les ressources entre les applications
▶ Protège les applications les unes des autres ; empêche l’usage abusif de
ressources

Firefox Emacs VLC

Système d’exploitation

Son

Disques durs
Matériel Cartes graphiques

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 8/61

Historique d’UNIX
1965 MULTICS : projet de système
1970 1980 1990 2000 2010
ambitieux (Bell Labs)
FreeBSD
closed source
shared source
open source
NetBSD 1969 Bell Labs se retire de
TCP/IP OpenBSD Multics, Début de Unics
BSD Berkeley Software Distribution Open Solaris
Bill Joy
SunOS (Stanford) Solaris (SUN)
1970 Unix projet Bell Labs officiel
Darwin
NextStep
MacOS X
1973 Réécriture en C
Xenix (Microsoft/SCO)
Distribution source aux universités
GNU project
Richard Stallman
Commercialisation par AT&T
Linux

Rewrite Minix
Linus Torvalds
80-90 Unix War : BSD vs. System V
in C Andrew Tannenbaum

Unix Time-Sharing System Plan 9

90-10 Effort de normalisation :
Thompson & Richie (Bell Labs)
System V UnixWare (Univel/SCO)
Posix1(88) processus, signaux, tubes
AT&T
HP-UX Posix1.b(93) semaphores, shared
AIX (IBM)
memory
IRIX (SGI)
Posix1.c (95) threads
OS/360 (for mainframes) z/OS (IBM)

Services For Unix

Posix2 (92) interpreteur
(Microsoft) Posix :2001, Posix :2004, Posix :2008
Mises à jour
Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 9/61
 Premier chapitre
Introduction

Qu’est ce qu’un système d’exploitation ?

Interfaces du système d’exploitation

Protection des ressources

Conclusion
Les deux interfaces d’un système d’exploitation

▶ Interface de programmation (Application Programming Interface)

▶ Utilisable à partir des programmes s’exécutant sous le système
▶ Composée d’un ensemble d’appels systèmes (procédures spéciales)
▶ Interface de commande ou interface de l’utilisateur
▶ Utilisable par un usager humain, sous forme textuelle ou graphique
▶ Composée d’un ensemble de commandes
▶ Textuelles (exemple en UNIX : rm *.o)
▶ Graphiques (exemple : déplacer l’icone d’un fichier vers la corbeille)

Exemple sous UNIX :

Première interface Deuxième interface
de commande de commande

Interface de
Shell 2 Shell 1
programmation
Noyau UNIX

▶ Tout est spécifié par POSIX (syntaxe + sémantique) pour la portabilité.

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 11/61

Exemple d’usage des interfaces d’UNIX

while (nb_lus = read(fich1, buf, BUFFSIZE )) {

▶ Interface de programmation if ((nb_lus == -1) && (errno != EINTR)) {
break; /* erreur */
Ci-contre : programme copiant un } else if (nb_lus > 0) {
fichier dans un autre pos_buff = buf;
a_ecrire = nb_lus;
(read et write : appels système) while (nb_ecrits =
write(fich2,pos_buff,a_ecrire)) {
▶ Interface de commande if ((nb_ecrits == -1) && (errno != EINTR))
break; /* erreur */
Commande shell : else if (a_ecrire == 0)
$ cp fich1 fich2 break; /* fini */
else if (nb_ecrits > 0) {
recopie fich1 dans fich2 pos_buff += nb_ecrits;
a_ecrire -= nb_ecrits;
} } } }

▶ Documentation
man 1 <nom> : documentation des commandes (par défaut)
man 2 <nom> : documentation des appels système
man 3 <nom> : documentation des fonctions
d’autres sections, mais plus rares. Voir man 7 man ;)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 12/61

Découpage en couches du système

Programmes utilisateurs
Niveau utilisateur Utilisateur
Bibliothèques
▶ Applications utilisateur mode utilisateur
Appel système
▶ Logiciels de base Trappe
mode superviseur
▶ Bibliothèque système
▶ Appels de fonction Système de Gestion des
Noyau gestion de processus
fichiers Contrôle
Niveau noyau péripériques
▶ Gestion des processus Contrôle/programmation
▶ Système de fichier

(c) Philippe Marquet, CC-BY-NC-SA.

Matériel Interruption
Périphériques
▶ Gestion de la mémoire

Niveau matériel OS = bibliothèque système + noyau

▶ Firmware, controleur, SOC (d’où le nom GNU/Linux)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 13/61

 Premier chapitre
Introduction

Qu’est ce qu’un système d’exploitation ?

Interfaces du système d’exploitation

Protection des ressources

Conclusion
Protection des ressources (rapide introduction)
Méthodes d’isolation des programmes (et utilisateurs) dangereux
▶ Préemption : ne donner aux applications que ce qu’on peut leur reprendre
▶ Interposition : pas d’accès direct, vérification de la validité de chaque accès
▶ Mode privilégié : certaines instructions machines réservées à l’OS
Exemples de ressources protégées
▶ Processeur : préemption
▶ Interruptions (matérielles) à intervalles réguliers → contrôle à l’OS
▶ (l’OS choisit le programme devant s’exécuter ensuite)
▶ Mémoire : interposition (validité de tout accès mémoire vérifiée au préalable)
▶ Exécution : mode privilégié (espace noyau) ou normal (espace utilisateur)
▶ Le CPU bloque certaines instructions assembleur (E/S) en mode utilisateur

programme appel continue

utilisateur syscall Changement de contexte mode bit = 1
exécution
Espace utilisateur
Espace noyau Interruption logicielle
exécute mode bit = 0
syscall

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 15/61

Limites de la protection
Les systèmes réels ont des failles
Les systèmes ne protègent pas de tout
▶ while true ; do mkdir toto; cd toto; done (en shell)
▶ while(1) { fork(); } (en C)
▶ while(1) { char *a=malloc(512); *a=’1’; } (en C)

Réponse classique de l’OS : gel (voire pire)

On suppose que les utilisateurs ne sont pas mal intentionnés (erreur ?)

Unix was not designed to stop people from doing stupid things,
because that would also stop them from doing clever things.
– Doug Gwyn

Deux types de solutions

Technique : mise en place de quotas
Sociale : “éduquer” les utilisateurs trop gourmands

Martin Quinson Systèmes d’exploitation et Programmation Système Chap I : Introduction 16/61

 Deuxième chapitre
Processus
Introduction

Utilisation des processus UNIX

Mémoire virtuelle
Création des processus dans Unix
Quelques interactions entre processus dans Unix

Réalisation des processus UNIX

Communication par signaux

Principe et utilité
Terminaux, sessions et groupe en Unix
Exemples d’utilisation des signaux

Conclusion
Ne pas confondre processus et programme

Qu’est ce qu’un processus ?

▶ Entité dynamique représentant l’exécution d’un programme sur un processeur
▶ Mémoire (données, code) + état d’exécution (registres, fichiers ouverts)

▶ Programme : ▶ Processus :
Code + données (passif) Programme en cours d’exécution

Pile
int i;
Tas
int main() {
printf("Salut\n"); Données int i;
} Code main()

▶ Vous pouvez utiliser le même programme que moi,

mais ça ne sera pas le même processus que moi
▶ Même différence qu’entre classe d’objet et instance d’objet

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 19/61

Utilité des processus : simplicité

▶ Simplifier en isolant chaque activité de l’ordinateur dans un processus séparé

emacs
DOOM OS
WWWOSls DOOM
emacs WWW
ls

▶ L’OS s’occupe de chacun de la même façon, chacun ne s’occupe que de l’OS

▶ (la décomposition est une réponse classique à la complexité)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 20/61

Utilité des processus : efficacité

▶ Les communications bloquent les processus

(communication au sens large : réseau, disque ; utilisateur, autre programme)
⇒ recouvrement des calculs et des communications

emacs (attente de l’utilisateur)

gcc
sans recouvrement

emacs temps gagné

gcc (bloqué)
avec recouvrement t

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 21/61

Parallélisme et pseudo-parallélisme

Processus ; Parallélisme sur multi-processeurs

Que faire quand deux processus sont prêts à s’exécuter ?

▶ Si deux processeurs, tout va bien.
▶ Si non, FCFS ? Mauvaise interactivité !

▶ Pseudo-parallélisme = chacun son tour

▶ Autre exécution pseudo-parallèle

Le pseudo-parallélisme
▶ fonctionne grâce aux interruptions matérielles régulières rendant contrôle à OS
▶ permet également de recouvrir calcul et communications
On y reviendra.

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 22/61

Relations entre processus

Compétition
▶ Plusieurs processus veulent accéder à une ressource exclusive
(i.e. ne pouvant être utilisée que par un seul à la fois) :
▶ Processeur (cas du pseudo-parallélisme)
▶ Imprimante, carte son
▶ Une solution possible parmi d’autres :
FCFS : premier arrivé, premier servi (les suivants attendent leur tour)

Coopération
▶ Plusieurs processus collaborent à une tâche commune
▶ Souvent, ils doivent se synchroniser :
▶ p1 produit un fichier, p2 imprime le fichier
▶ p1 met à jour un fichier, p2 consulte le fichier
▶ La synchronisation se ramène à :
p2 doit attendre que p1 ait franchi un certain point de son exécution

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 23/61

Faire attendre un processus
Primordial pour les interactions entre processus
Attente active
Processus 1 Processus 2
while (ressource occupée) ressource occupée = true;
{ }; utiliser ressource;
ressource occupée = true; ressource occupée = false;
... ...
▶ Gaspillage de ressource si pseudo-parallélisme
▶ Problème d’atomicité (race condition – on y reviendra)

Blocage du processus
▶ Définition d’un nouvel état de processus : bloqué
(exécution suspendue ; réveil explicite par un autre processus ou par le
système)
blocage ...
actif bloqué sleep(5); /* se bloquer pour 5 secondes */
réveil ...

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 24/61

 Deuxième chapitre
Processus
Introduction

Utilisation des processus UNIX

Mémoire virtuelle
Création des processus dans Unix
Quelques interactions entre processus dans Unix

Réalisation des processus UNIX

Communication par signaux

Principe et utilité
Terminaux, sessions et groupe en Unix
Exemples d’utilisation des signaux

Conclusion
Processus UNIX

▶ Processus = exécution d’un programme Adresses hautes

▶ Commande (du langage de commande) Pile
d’exécution
▶ Application
Trou dans
l’espace
d’adressage
▶ Un processus comprend :
▶ Une mémoire qui lui est propre (mémoire virtuelle) Tas
▶ Contexte d’exécution (pile, registres du processeur) (cf. malloc)
Données
globales
▶ Les processus sont identifiés par leur pid
Code
▶ Commande ps : liste des processus
▶ Commande top : montre l’activité du processeur (réservé)
▶ Primitive getpid() : renvoie le pid du processus
Adresses basses
courant

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 26/61

Vie et mort des processus
Tout processus a un début et une fin
▶ Début : création par un autre processus
▶ init est le processus originel : pid=1 (launchd sous mac)
Créé par le noyau au démarrage, il lance les autres processus système
▶ Fin
▶ Auto-destruction (à la fin du programme) (par exit)
▶ Destruction par un autre processus (par kill)
▶ Destruction par l’OS (en cas de violation de protection et autres)
▶ Certains processus ne se terminent pas avant l’arrêt de la machine
▶ Nommés ≪démons≫ (disk and execution monitor → daemon)
▶ Réalisent des fonctions du système (login utilisateurs, impression, serveur web)

Création de processus dans UNIX

▶ Dans le langage de commande :
▶ Chaque commande est exécutée dans un processus séparé
▶ On peut créer des processus en (pseudo-)parallèle :
$ prog1 & prog2 & # crée deux processus pour exécuter prog1 et prog2
$ prog1 & prog1 & # lance deux instances de prog1
▶ Par l’API : clonage avec l’appel système fork (cf. transparent suivant)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 27/61

Création des processus dans Unix (1/3)

Appel système pid t fork()

▶ Effet : clone le processus appelant
▶ Le processus créé (fils) est une copie conforme du processus créateur (père)
Copies conformes comme une bactérie qui se coupe en deux
▶ Ils se reconnaissent par la valeur de retour de fork() :
▶ Pour le père : le pid du fils (ou –1 si erreur) n=fork() n=235

▶ Pour le fils : 0 n=0

Exemple :
if (fork() != 0) {
printf("je suis le père, mon PID est %d\n", getpid());
} else {
printf("je suis le fils, mon PID est %d; mon père est %d\n",
getpid(), getppid());
/* en général exec(), (exécution d’un nouveau programme) */
}

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 28/61

Création des processus dans Unix (2/3)

Duplication du processus père ⇒ duplication de l’espace d’adressage

int i=3;
if (fork() != 0) {
printf("je suis le père, mon PID est %d\n", getpid());
i += 4;
} else {
printf("je suis le fils, mon PID est %d; mon père est %d\n",
getpid(), getppid());
i += 9;
}
printf("pour %d, i = %d\n", getpid(), i);

je suis le fils, mon PID est 10271; mon père est 10270
pour 10271, i =
i=3 i+=4
je suis le père, mon PID est 10270
pour 10270, i = i+=9

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 29/61

Création des processus dans Unix (3/3)
testClonage.c
int main() {
if (fork() != 0) {
printf("je suis le père, mon PID est %d\n", getpid());
sleep(10) /* blocage pendant 10 secondes */
exit(0);
} else {
printf("je suis le fils, mon PID est %d\n", getpid());
sleep(10) /* blocage pendant 10 secondes */
exit(0);
}
}

$ gcc -o testClonage testClonage.c

$ ./testClonage & ps
je suis le fils, mon PID est 3148
je suis le père, mon PID est 3147 testClonage 3148
[2] 3147
3147
PID TTY TIME CMD
2989 pts/0 00:00:00 bash
bash 2989
3147 pts/0 00:00:00 testClonage ps 3149
3148 pts/0 00:00:00 testClonage printf
3149 pts/0 00:00:00 ps
$

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 30/61

Hiérarchie de processus Unix

1 Processus init

Système

Utilisateur 1 Utilisateur 2

▶ Quelques appels systèmes utiles :

▶ getpid() : obtenir le numéro du processus
▶ getppid() : obtenir le numéro du père
▶ getuid() : obtenir le numéro d’usager (auquel appartient le processus)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 31/61

Quelques interactions entre processus (1/2)

Envoyer un signal à un autre processus

▶ En langage de commande, kill <pid> tue pid (plus de détails plus tard)

Faire attendre un processus

▶ sleep(n) : se bloquer pendant n secondes
▶ pause() : se bloquer jusqu’à la réception d’un signal (cf. plus tard)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 32/61

Quelques interactions entre processus (2/2)

Synchronisation entre un processus père et ses fils

▶ Fin d’un processus : exit(etat)
etat est un code de fin (convention : 0 si ok, code d’erreur sinon – cf. errno)
▶ Le père attend la fin de l’un des fils : pid t wait(int *ptr etat)
retour : pid du fils qui a terminé ; code de fin stocké dans ptr etat
▶ Attendre la fin du fils pid :
pid t waitpid(pid t pid, int *ptr etat, int options)
▶ Processus zombie : terminé, mais le père n’a pas appelé wait().
Il ne peut plus s’exécuter, mais consomme encore des ressources. À éviter.
zombie
fils fils
bloqué
père père
fork wait fork wait

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 33/61

Faire attendre un processus

Fonction sleep()
▶ Bloque le processus courant pour le nombre de secondes indiqué
▶ unsigned int sleep(unsigned int seconds);
▶ usleep() et nanosleep() offrent meilleures résolutions (micro, nanoseconde)
mais interfaces plus compliquées et pas portables

Exercice : la fonction somnole (à compléter)

Écrire une fonction qui affiche à chaque seconde le temps restant à dormir :
void somnole(unsigned int secondes) {

Exemple d’affichage :
Déjà dormi 1 secondes sur 3
Déjà dormi 2 secondes sur 3
Déjà dormi 3 secondes sur 3
}

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 34/61

Exemple de synchronisation entre père et fils
testClone2.c
int main() {
if (fork() != 0) {
printf("je suis le père, mon PID est %d\n", getpid());
while (1) ; /* boucle sans fin sans attendre le fils */
} else {
printf("je suis le fils, mon PID est %d\n", getpid());
sleep(2) /* blocage pendant 2 secondes */
printf("fin du fils\n");
exit(0);
} }

$ gcc -o testClone2 testClone2.c

$ ./testClone2
je suis le fils, mon PID est 3271
je suis le père, mon PID est 3270
Il y a un zombie
fin du fils
testClone2 3271
->l’utilisateur tape <ctrl-Z> (suspendre)
Suspended 3270
$ ps bash 2989
PID TTY TIME CMD ps 3272
2989 pts/0 00:00:00 bash
3270 pts/0 00:00:03 testClone2
3271 pts/0 00:00:00 testClone2 <defunct>
3272 pts/0 00:00:00 ps
$

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 35/61

Autre exemple de synchronisation père fils
testClone3.c
#include <sys/types.h>
#include <sys/wait.h> (suite de testClone3.c)
int main() {
if (fork() != 0) { } else { /* correspond au if (fork() != 0)*/
int statut; pid_t fils; printf("je suis le fils, PID=%d\n",
printf("Le père (%d) attend.\n", getpid()); getpid());
fils = wait(&statut); sleep(2) /* blocage pendant 2 secondes */
if (WIFEXITED(statut)) { printf("fin du fils\n");
printf("%d : fils %d terminé (code %d)\n", exit(1);
getpid(), fils, WEXITSTATUS(statut)); } }
};
exit(0);

$ ./testClone3 Il n’y a pas de zombie

je suis le fils, PID=3312 sleep exit
Le père (3311) attend
testClone3 3312
fin du fils wait
3311: fils 3312 terminé (code 1) 3311
$ ps bash 2989
PID TTY TIME CMD
2989 pts/0 00:00:00 bash ps 3313
3313 pts/0 00:00:00 ps
$

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 36/61

Exécution d’un programme spécifié sous UNIX
Appels systèmes exec
▶ Pour faire exécuter un nouveau programme par un processus
▶ Souvent utilisé immédiatement après la création d’un processus :
fork+exec = lancement d’un programme dans un nouveau processus
▶ Effet : remplace la mémoire virtuelle du processus par le programme
▶ Plusieurs variantes existent selon le mode de passage des paramètres
(tableau, liste, passage de variables d’environnement)
▶ C’est aussi une primitive du langage de commande (même effet)

Exemple :
main() {
if (fork() == 0) {

execl("/bin/ls", "ls", "-a", 0); /* le fils exécute : /bin/ls -a .. */

} else {
wait(NULL); /* le père attend la fin du fils */
}
exit(0);
}

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 37/61

Exécution d’un programme spécifié sous UNIX
Appels systèmes exec
▶ Pour faire exécuter un nouveau programme par un processus
▶ Souvent utilisé immédiatement après la création d’un processus :
fork+exec = lancement d’un programme dans un nouveau processus
▶ Effet : remplace la mémoire virtuelle du processus par le programme
▶ Plusieurs variantes existent selon le mode de passage des paramètres
(tableau, liste, passage de variables d’environnement)
▶ C’est aussi une primitive du langage de commande (même effet)

Exemple :
main() {
if (fork() == 0) {

code=execl("/bin/ls", "ls", "-a", 0); /* le fils exécute : /bin/ls -a .. */

if (code != 0) { ... } /* Problème dans l’appel système; cf. valeur de errno */
} else {
wait(NULL); /* le père attend la fin du fils */
}
exit(0);
}

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 37/61

L’exemple du shell

Exécution d’une commande en premier plan

sh sh wait() sh
fork()
(pid père) (pid père) (pid père)

$ commande sh (pid fils)

exec(command) exit()
▶ 4 syscalls : fork, exec, exit, wait
command
(pid fils)

Exécution d’une commande en tâche de fond

sh sh

D’après Philippe Marquet, CC-BY-NC-SA.

fork()
$ commande & (pid père) (pid père)

sh (pid fils)

▶ Le shell ne fait pas wait() exec(command) exit()

▶ Il n’est plus bloqué command

(pid fils)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 38/61

Résumé du début du deuxième chapitre

▶ Utilité des processus

▶
▶
▶
▶ Interface UNIX
▶ Création :
▶ résultat=0 →
▶ résultat>0 →
▶ résultat<0 →
▶ Attendre un fils : deux façons
▶
▶
▶ Processus zombie :
▶ Bloquer le processus courant : deux façons
▶ Jusqu’au prochain signal :
▶ Pendant 32 secondes :
▶ Appel système exec() :

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 39/61

 Deuxième chapitre
Processus
Introduction

Utilisation des processus UNIX

Mémoire virtuelle
Création des processus dans Unix
Quelques interactions entre processus dans Unix

Réalisation des processus UNIX

Communication par signaux

Principe et utilité
Terminaux, sessions et groupe en Unix
Exemples d’utilisation des signaux

Conclusion
Réalisation des processus
Processus = mémoire virtuelle + flot d’exécution
L’OS fournit ces deux ressources en allouant les ressources physiques

Objectif maintenant :
En savoir assez sur le fonctionnement de l’OS pour utiliser les processus
Pile
▶ À propos de mémoire Tas
▶ Organisation interne de la mémoire virtuelle d’un processus Unix Données
Code

▶ À propos de processeur
▶ Pseudo-parallélisme : allocation successive aux processus par tranches de temps

Objectifs repoussés à plus tard :

▶ Les autres ressources : disque (chapitre ??), réseau (seconde moitié du
module)
▶ Détails de conception sous le capot

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 41/61

Allocation du processeur aux processus
Pseudo-parallélisme
Principe
▶ Allocation successive aux processus par tranches de temps fixées
(multiplexage du processeur par préemption)
Avantages
▶ Partage équitable du processeur entre processus (gestion + protection)
▶ Recouvrement calcul et communications (ou interactions)
Fonctionnement
▶ Interruptions matérielles (top d’horloge, I/O, . . .) rendent le contrôle à l’OS
▶ L’OS ordonnance les processus (choisit le prochain à bénéficier de la ressource)
▶ Il réalise la commutation de processus pour passer le contrôle à l’heureux élu

horloge IO
p1 prêt bloqué ▶ quantum : ≈10ms
p2 exécution (≈ millions d’instructions à 1Ghz)
p3
▶ temps de commutation : ≈0,5ms
quantum ▶ yield() rend la main volontairement

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 42/61

Structure de la mémoire virtuelle d’un processus
0xefffffff Adresses hautes ▶ Pile : pour la récursivité
MAXINT Cadre0 ▶ Cadres de fonction (frame)
Cadre1 Segment
octets stack ▶ Arguments des fonctions
(4Go/4To) Pile ▶ Adresse de retour
▶ Variables locales (non statique)
Trous dans Bibliothèques ▶ Bibliothèques dynamiques
l’espace
d’adressage dynamiques ▶ Code chargé ... dynamiquement
▶ Intercalé dans l’espace d’adresses
Tas ▶ Données
(cf. malloc) ▶ Tas : malloc()
Segment
data Section
▶ globales et static (modifiables)
Globales BSS ▶ Variables constantes
Constantes Section ▶ exec lit l’exécutable et initialise la
data
mémoire correspondante
Code Segment Section
text text ▶ Noyau : infos sur le processus
Noyau Sections de “Process Control Block”
l’exécutable
(protégé) Segments du (pid, autorisations, fichiers ouverts, . . .)
0x00000000 Adresses basses processus
(parfois au dessus de la pile)
Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 43/61
Communication inter-processus (IPC) dans Unix

Aspect central de la programmation système

Moyens de communication entre processus sous Unix

▶ Signaux : suite de cette séance
▶ Fichiers et tubes (pipes, FIFOs) : partie 3.
▶ Files de messages : pas étudié [cette année]
▶ Mémoire partagée et sémaphores : partie 5.
▶ Sockets (dans les réseaux, mais aussi en local) : fin du semestre

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 44/61

 Deuxième chapitre
Processus
Introduction

Utilisation des processus UNIX

Mémoire virtuelle
Création des processus dans Unix
Quelques interactions entre processus dans Unix

Réalisation des processus UNIX

Communication par signaux

Principe et utilité
Terminaux, sessions et groupe en Unix
Exemples d’utilisation des signaux

Conclusion
Signaux

Définition : événement asynchrone

▶ Émis par l’OS ou un processus
▶ Destiné à un (ou plusieurs) processus

Intérêts et limites
▶ Simplifient le contrôle d’un ensemble de processus (comme le shell)
▶ Pratiques pour traiter des événements liés au temps
▶ Mécanisme de bas niveau à manipuler avec précaution
(risque de perte de signaux en particulier)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 46/61

Signaux

Définition : événement asynchrone

▶ Émis par l’OS ou un processus
▶ Destiné à un (ou plusieurs) processus

Intérêts et limites
▶ Simplifient le contrôle d’un ensemble de processus (comme le shell)
▶ Pratiques pour traiter des événements liés au temps
▶ Mécanisme de bas niveau à manipuler avec précaution
(risque de perte de signaux en particulier)

Comparaison avec les interruptions matérielles :

▶ Analogie : la réception déclenche l’exécution d’un gestionnaire (handler )
▶ Différences : interruption reçue par processeur ; signal reçu par processus
Certains signaux traduisent la réception d’une interruption (on y revient)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 46/61

Fonctionnement des signaux

1) Arrivée du signal

processus

4) Retour de l’exécution au point d’interruption

2) Déroutement de l’exécution

3) Exécution du gestionnaire

Remarques (on va détailler)

▶ On ne peut évidement signaler que ses propres processus (même uid)
▶ Différents signaux, identifiés par un nom symbolique (et un entier)
▶ Gestionnaire par défaut pour chacun
▶ Gestionnaire vide ⇒ ignoré
▶ On peut changer le gestionnaire (sauf exceptions)
▶ On peut bloquer un signal : mise en attente, délivré qu’après déblocage
▶ Limites aux traitements possibles dans le gestionnaire (ex : pas de signal())
Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 47/61
Quelques exemples de signaux

Nom symbolique Cause/signification Par défaut

SIGINT frappe du caractère <ctrl-c> terminaison
SIGTSTP frappe du caractère <ctrl-z> suspension
SIGSTOP blocage d’un processus (*) suspension
SIGCONT continuation d’un processus stoppé reprise
SIGTERM demande de terminaison terminaison
SIGKILL terminaison immédiate (*) terminaison
SIGSEGV erreur de segmentation terminaison
(violation de protection mémoire) +core dump
SIGALRM top d’horloge (réglée avec alarm) teminaison
SIGCHLD terminaison d’un fils ignoré
SIGUSR1 pas utilisés par le système terminaison
SIGUSR2 (disponibles pour l’utilisateur) terminaison
▶ KILL et STOP : ni bloquables ni ignorables ; gestionnaire non modifiable.
▶ Valeurs numériques associées (ex : SIGKILL=9), mais pas portable
▶ Voir man 7 signal pour d’autres signaux (section 7 du man : conventions)
core dump : copie image mémoire sur disque (premières mémoires : toriques → core ; dump=vidanger)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 48/61

États d’un signal

Signal pendant (pending )

▶ Arrivé au destinataire, mais pas encore traité

Signal traité
▶ Le gestionnaire a commencé (et peut-être même fini)

Pendant, mais pas traité ? Est-ce possible ?

▶ Il est bloqué, càd retardé : il sera délivré lorsque débloqué
▶ Lors de l’exécution du gestionnaire d’un signal, ce signal est bloqué

Attention : au plus un signal pendant de chaque type

▶ L’information est codée sur un seul bit
▶ S’il arrive un autre signal du même type, le second est perdu

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 49/61

 Deuxième chapitre
Processus
Introduction

Utilisation des processus UNIX

Mémoire virtuelle
Création des processus dans Unix
Quelques interactions entre processus dans Unix

Réalisation des processus UNIX

Communication par signaux

Principe et utilité
Terminaux, sessions et groupe en Unix
Exemples d’utilisation des signaux

Conclusion
États d’un travail

Entrée clavier
Commande Commande &

Travail en Travail en
premier plan arrière-plan
Ctrl-C

Signaux

Travail
suspendu

▶ Travail (job) = (groupe de) processus lancé par une commande au shell
▶ Seul le travail en premier plan peut recevoir des signaux du clavier
▶ Les autres sont manipulés par des commandes

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 51/61

États d’un travail

Entrée clavier
Commande Commande &

Travail en Travail en
premier plan arrière-plan
Ctrl-C

Signaux

Ctrl-Z Travail
suspendu

▶ Travail (job) = (groupe de) processus lancé par une commande au shell
▶ Seul le travail en premier plan peut recevoir des signaux du clavier
▶ Les autres sont manipulés par des commandes

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 51/61

États d’un travail

Entrée clavier
Commande Commande &

Travail en Travail en
premier plan arrière-plan
Ctrl-C

Signaux fg %<job>

Ctrl-Z Travail
suspendu

▶ Travail (job) = (groupe de) processus lancé par une commande au shell
▶ Seul le travail en premier plan peut recevoir des signaux du clavier
▶ Les autres sont manipulés par des commandes

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 51/61

États d’un travail

Entrée clavier
Commande Commande &

Travail en Travail en
premier plan arrière-plan
Ctrl-C

Signaux fg %<job> bg %<job>

Ctrl-Z Travail
suspendu

▶ Travail (job) = (groupe de) processus lancé par une commande au shell
▶ Seul le travail en premier plan peut recevoir des signaux du clavier
▶ Les autres sont manipulés par des commandes

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 51/61

États d’un travail

Entrée clavier
Commande Commande &

Travail en Travail en
fg %<job>
premier plan arrière-plan
Ctrl-C

Signaux fg %<job> bg %<job>

Ctrl-Z Travail
suspendu

▶ Travail (job) = (groupe de) processus lancé par une commande au shell
▶ Seul le travail en premier plan peut recevoir des signaux du clavier
▶ Les autres sont manipulés par des commandes

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 51/61

Terminaux, sessions et groupes en Unix

▶ Une session est associée à un terminal, donc au login d’un utilisateur par shell
Le processus de ce shell est le leader de la session.
▶ Plusieurs groupes de processus par session. On dit plusieurs travaux (jobs)

▶ Au plus un travail interactif (avant-plan, foreground)

Interagissent avec l’utilisateur via le terminal, seuls à pouvoir lire le terminal
▶ Plusieurs travaux en arrière plan (background)
Lancés avec & ; Exécution en travail de fond
▶ Signaux SIGINT (frappe de <ctrl-c>) et SIGTSTP (frappe de <ctrl-z>)
sont passés au groupe interactif et non aux groupes d’arrière-plan

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 52/61

Exemple avec les sessions et groupes Unix
loop.c
int main() {
printf"processus %d, groupe %d\n", getpid(), getpgrp());
while(1) ;
}

$ loop & loop & ps $ bg %1

processus 10468, groupe 10468 [1] loop &
[1] 10468 $ fg %2
processus 10469, groupe 10469 loop
[2] 10469 [frappe de control-C]
PID TTY TIME CMD $ ps
5691 pts/0 00:00:00 bash PID TTY TIME CMD
10468 pts/0 00:00:00 loop 5691 pts/0 00:00:00 bash
10469 pts/0 00:00:00 loop 10468 pts/0 00:02:53 loop
10470 pts/0 00:00:00 ps 10474 pts/0 00:00:00 ps
$ fg %1 $ [frappe de control-C]
loop $ ps
[frappe de control-Z] PID TTY TIME CMD
Suspended 5691 pts/0 00:00:00 bash
$ jobs 10468 pts/0 00:02:57 loop
[1] + Suspended loop 10475 pts/0 00:00:00 ps
[2] - Running loop $

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 53/61

Exemple de travaux

Shell

Commande Commande &

Commande &

pid=5123 p5 pid=5600 p4 pid=5804

p1 pgid=5123 pgid=5600 pgid=5804

p2 p3 p6 pid=5610
pgid=5600
pid=5124 pid=5125
pgid=5123 pgid=5123

▶ Signaux ctrl-c et ctrl-z adressés à tous les processus du groupe jaune

▶ Commandes shell fg, bg et stop pour travaux bleus

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 54/61

 Deuxième chapitre
Processus
Introduction

Utilisation des processus UNIX

Mémoire virtuelle
Création des processus dans Unix
Quelques interactions entre processus dans Unix

Réalisation des processus UNIX

Communication par signaux

Principe et utilité
Terminaux, sessions et groupe en Unix
Exemples d’utilisation des signaux

Conclusion
Envoyer un signal à un autre processus

Interfaces
▶ Langage de commande : kill -NOM victime

#include <signal.h>
▶ Appel système :
int kill(pid_t victime, int sig);

Sémantique : à qui est envoyé le signal ?

▶ Si victime > 0, au processus tel que pid = victime
▶ Si victime = 0, à tous les processus du même groupe (pgid) que l’émetteur
▶ Si victime = −1 :
▶ Si super-utilisateur, à tous les processus sauf système et émetteur
▶ Si non, à tous les processus dont l’utilisateur est propriétaire
▶ Si victime < −1, aux processus tels que pgid = |victime| (tout le groupe)

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 56/61

Redéfinir le gestionnaire associé à un signal (POSIX)
Structure à utiliser pour décrire un gestionnaire
struct sigaction {
void (*sa handler)(int); /* gestionnaire, interface simple */
void (* sa_sigaction) (int, siginfo_t *, void *); /* gestionnaire, interface complète */
sigset t sa mask; /* signaux à bloquer pendant le traitement */
int sa flags; /* options */
}

▶ Gestionnaires particuliers : sig dfl : action par défaut ; sig ign : ignorer signal
▶ Deux types de gestionnaires
▶ sa handler() connait le numéro du signal
▶ sa sigaction() a plus d’infos

Primitive à utiliser pour installer un nouveau gestionnaire

#include <signal.h>
int sigaction(int sig, const struct sigaction *newaction, struct sigaction *oldaction);

▶ Voir man sigaction pour les détails

Autre interface existante : ANSI C

▶ Peut-être un peu plus simple, mais bien moins puissante et pas thread-safe

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 57/61

Exemple 1 : traitement d’une interruption du clavier
▶ Par défaut, Ctrl-C tue le processus ; pour survivre : il suffit de redéfinir le
gestionnaire de SIGINT
test-int.c
#include <signal.h>
void handler(int sig) { /* nouveau gestionnaire */
printf("signal SIGINT reçu !\n");
exit(0); $ ./test-int
} [frappe de ctrl-c]
int main() { signal SIGINT reçu !
struct sigaction nvt,old; $
memset(&nvt, 0, sizeof(nvt));
nvt.sa_handler = &handler;
sigaction(SIGINT, &nvt, &old); /*installe le gestionnaire*/
pause (); /* attend un signal */
printf("Ceci n’est jamais affiché.\n");;
}

Exercice : modifier ce programme pour qu’il continue après un ctrl-c

Note : il doit rester interruptible, i.e. on doit pouvoir le tuer d’un ctrl-c de plus

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 58/61

Exemple 2 : temporisation
unsigned int alarm(unsigned int nb sec)
▶ nb sec > 0 : demande l’envoi de SIGALRM après environ nb sec secondes
▶ nb sec = 0 : annulation de toute demande précédente
▶ Retour : nombre de secondes restantes sur l’alarme précédente
▶ Attention, sleep() réalisé avec alarm() ⇒ mélange dangereux

#include <signal.h>
void handler(int sig) {
printf("Entrez un nombre avant 5 sec:");
printf("trop tard !\n");
alarm(5);
exit(1);
scanf("%d", &reponse);
}
restant = alarm(0);
int main() {
printf("bien reçu (en %d secondes)\n",
struct sigaction nvt,old;
5 - restant);
int reponse,restant;
exit (0);
memset(&nvt, 0, sizeof(nvt));
}
nvt.sa_handler = handler;
sigaction(SIGALRM, &nvt, &old);

5s trop tard ! < 5s désarme le minuteur

bien reçu (en 2 secondes)
attente entrée attente
entrée clavier

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 59/61

Exemple 3 : synchronisation père-fils

▶ Fin ou suspension d’un processus ⇒ sigchld automatique à son père

▶ Traitement par défaut : ignorer ce signal

▶ Application : wait() pour éviter les zombies mangeurs de ressources

C’est ce que fait le processus init (celui dont le pid est 1)
#include <signal.h>
void handler(int sig) { /* nouveau gestionnaire */
pid t pid;
int statut;
pid = waitpid(-1, &statut, 0); /* attend un fils quelconque */
return;
}
int main() {
struct sigaction nvt,old;
memset(&nvt, 0, sizeof(nvt));
nvt.sa_handler = &handler;
sigaction(SIGCHLD, &nvt, &old); /* installe le gestionnaire */
... <création d’un certain nombre de fils> ...
exit (0);
}

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 60/61

Résumé de la fin du deuxième chapitre

▶ Quelques définitions
▶ pgid :
▶ Travail d’avant-plan, d’arrière-plan :
▶ Communication par signaux
▶ Envoyer un signal <NOM> à <victime> :
▶ Langage commande :
▶ API :
victime > 0 :
victime = 0 :
victime = −1 :
victime < −1 :
▶ Changer le gestionnaire d’un signal :
▶ Exemples de signaux
▶ sigint, sigstop :
▶ sigterm, sigkill :
▶ sigalarm :
▶ sigchld :

Martin Quinson Systèmes d’exploitation et Programmation Système Chap II : Processus 61/61