Communication entre processus

1

Systèmes d’exploitation

Chap. 4

Communication entre processus

2

Les chapitres

0. Programmation C

1. Introduction sur les systèmes d’exploitation 2. Les systèmes de gestion des fichiers

3. Les processus

4. La communication entre processus 5. La concurrence entre processus 6. L’ordonnanceur

Objectifs : maîtriser et utiliser conjointement les notions Informations Générales

SGD

Proc. _Commun.

3

Plan

Partie 1 : Les tubes Partie 2 : Les signaux

Partie 3 : Autres moyens de communication

Chap. 4 – Communication entre processus

4

Partie 1

Les tubes

Chap. 4 – Communication entre processus

5

1. Introduction aux tubes

Les tubes dans les terminaux : Ex: ls /etc | more

Tube

ls /etc more

Frappe d’un Ctrl+z par l’utilisateur

Chap. 4 – Communication entre processus

6

1. Introduction aux tubes

• Les tubes sont des mécanismes permettant aux processus de communiquer entre eux.

• Les tubes appartiennent au systèmes de fichiers UNIX, i.e ils sont décrits par un i-nœud.

• Les tubes peuvent donc être manipulés par l’intermédiaire de descripteurs de fichiers et par exemple des primitives

d’entrées/sorties bas niveau, i.e « read » et « write ».

• Les tubes sont des moyens de communication unidirectionnels.

Chap. 4 – Communication entre processus

7

1. Introduction aux tubes

• Un tube correspond au plus à deux entrées dans la table de

fichiers ouverts (une entrée en lecture et une entrée en écriture )

Processus 1 Tube Processus 2

Écriture Lecture

Tube

Lecture Écriture

Chap. 4 – Communication entre processus

8

1. Introduction aux tubes

• Les données ne sont pas formatées, elles apparaissent comme un flot de caractères. Le tube gère en file, c.-à-d. la première donnée écrite dans le tube est également la première donnée lue.

Processus 1 Processus 2

fifo : first in, first out

Chap. 4 – Communication entre processus

9

1. Introduction aux tubes

• Les tubes ont une capacité finie, ce qui introduit le concept de tube plein

• Les opérations d’écritures sont bloquantes

Processus 1 Processus 2

fifo

Chap. 4 – Communication entre processus

10

1. Introduction aux tubes

• Le nombre de lecteurs d’un tube est le nombre de descripteurs associés à l’entrée en lecture sur le tube.

• Si le nombre est nul, il est alors impossible d’écrire dans le tube

• Le nombre de rédacteurs d’un tube est le nombre de descripteurs associés à l’entrée en écriture sur le tube.

• Si ce nombre est nul, la primitive « read » détecte une fin de fichier. ( Tout est fichier sous UNIX !!!)

Chap. 4 – Communication entre processus

11

2. Créer un tube

a) La primitive pipe

#include <unistd.h>

int pipe( int p[2] );

• Permet de créer un tube.

• Le paramètre est un tableau de deux entiers qui va permettre de stocker les deux descripteurs.

• La primitive range dans p[0] le descripteur permettant de lire dans le tube et dans p[1] le descripteur permettant d’écrire dans le tube.

Chap. 4 – Communication entre processus

12

2. Créer un tube

b) Fichier contre tube

• Comme les tubes n’ont pas de noms, il est impossible de les ouvrir grâce à la primitive open. Par conséquent, un processus peut acquérir un descripteur sur un tube, soit en le créant, soit par héritage.

• Seul le processus ayant créé le tube et sa descendance peut y accéder. Si un processus perd son accès au descripteur sur le tube (avec la primitive

« close »), il n’y a aucun moyen de le récupérer par la suite.

• Les accès en lecture sont effectués par des appels « read » et « write », comme pour les fichiers

• Les lectures dans un tube sont « effaçantes », il s’agit bien d’une extraction des données du tube et non d’une consultation ( lseek n’a pas de sens ici !).

Chap. 4 – Communication entre processus

13

Exemple

Chap. 4 – Communication entre processus

14

3. Lecture dans un tube

nb_lu = read(p[0], buf, TAILLE_BUF);

1. Si le tube n’est pas vide et contient « taille » caractères, la primitive extrait du tube nb_lu = min (taille, TAILLE_BUF) caractères qui sont lus et placés en mémoire

2. Si le tube est vide

2.1. Si le nombre d’écrivains est nul, la fin du fichier est atteinte, aucun caractère n’est lu, et la primitive renvoie la valeur nb_lu = 0;

2.2 Si le nombre d’écrivains n’est pas nul

- si la lecture est bloquante (vrai par défaut), le processus est mis en sommeil jusqu’à ce que le tube ne soit plus vide.

- si la lecture n’est pas bloquante, le retour est immédiat et la valeur de retour est -1.

Chap. 4 – Communication entre processus

15

3. Lecture dans un tube

Il faut s’assurer qu’il n’y a pas d’interblocage !

(a) Situation d’interblocage int p[2];

pipe(p);

….

/* le tube est vide; il n’y a pas d’autre écrivain que ce processus*/

/* qui n’a pas fermé p[1] */

read(p[0], ch, 1); // BLOCAGE

…

write(p[1], ch, 1);

Chap. 4 – Communication entre processus

16

3. Lecture dans un tube

Il faut s’assurer qu’il n’y a pas d’interblocage !

(b) Situation d’interblocage de deux processus pipe(p1);

pipe(p2);

/* les deux tubes ont conservé les descripteurs p1[1] et p2[1] */

if (fork() == 0){

read(p1[0], ch, 1); // BLOCAGE sur tube p1 vide write(p2[1], ch, 1);

}else{

read(p2[0], ch, 1); // BLOCAGE sur tube p2 vide write(p1[1], ch, 1);

}

Chap. 4 – Communication entre processus

17

3. Lecture dans un tube

Il faut toujours fermer les descripteurs inutiles!!!!!

Chap. 4 – Communication entre processus

18

4. Écriture dans un tube

nb_ecrit = write( p[1], buf, n);

1. Si le nombre de lecteurs dans le tube est nul, le signal SIGPIPE est délivré au processus écrivain. Ce signal a comme action par défaut de terminer le

processus auquel il est délivré. Broken pipe

2. Si le nombre de lecteurs dans le tube n’est pas nul

2.1. Si l’écriture est bloquante, le retour de la primitive est le nombre de caractères écrits. Le processus est susceptible de passer à l’état endormi dans l’attente que le tube se vide.

2.2 Si l’écriture est non bloquante

- si n>PIPE_BUF, le retour est un nombre inférieur à n.

- si n ≤ PIPE_BUF, et s’il y a de la place, tout est écrit en une fois.

- si n ≤ PIPE_BUF, et s’il n’y a pas assez d’espaces libres, le retour est immédiat avec la valeur 0 ou -1 selon l’indicateur.

Chap. 4 – Communication entre processus

19

5. Fermeture d’un descripteur

#include <unistd.h>

close (int p[0]);

• Permet de fermer un descripteur.

• Il est également possible de ferme les descripteurs d’entrée et de sortie standard.

• La création d’un nouveau descripteur de tube après la fermeture d’une entrée/sortie standard à pour effet d’ouvrir cette entrée/sortie standard.

Chap. 4 – Communication entre processus

20

6. Copie de descripteur

#include <unistd.h>

int dup (int desc);

• Crée une copie d’un descripteur de fichier.

• Retourne le nouveau descripteur (le plus petit libre).

• Retourne -1 en cas d’erreur.

• L’ancien descripteur et le nouveau peuvent être utilisés de manière interchangeable, ils partagent la position courante dans le fichier.

Chap. 4 – Communication entre processus

21

Chap. 4 – Communication entre processus

22

Résultat

Chap. 4 – Communication entre processus

23

7. Les tubes nommés ou FIFO

Les tubes nommés ont été introduits dans la version III d’UNIX

• Leur but est de permettre à des processus sans lien de parenté particulier de communiquer par l’intermédiaire de tubes.

• Ils ont les caractéristiques des tubes et ont en plus une référence dans le système de fichiers.

• Tout processus connaissant la référence d’un tube nommé peut l’ouvrir avec la primitive « open ».

• Les fichiers correspondants à des tubes sont identifiés par ls.

Chap. 4 – Communication entre processus

24

7. Les tubes nommés ou FIFO

Exemple dans un terminal :

echo & cat

Tube

Écriture Lecture

Communication entre deux fenêtres X-window

Chap. 4 – Communication entre processus

25

7. Les tubes nommés ou FIFO

#include <sys/type.h>

#include <sys/stat.h>

int mkfifo (const char * pathname, mode_t mode);

• Permet de créer un tube nommé.

• « Pathname » désigne le nom relatif ou absolu du fichier associé au tube.

• Mode est le mode d’ouverture du fichier ainsi créé comme pour

« open ».

Chap. 4 – Communication entre processus

26

8. Utilisation du tube nommé

• Un processus connaissant le « nom » d’un tube peut l’ouvrir grâce à la primitive « open » et si les droits du tube le permettent.

• « open » est dans ce cas bloquant (une ouverture en lecture est bloquante tant qu’il n’y a aucun écrivain sur le tube et inversement).

• Le descripteur de fichier obtenu par « open » peut ensuite être utilisé comme tout autre descripteur.

• Il ne faut pas oublier de supprimer les fichiers associés aux tubes lorsque l’on en a plus besoin :

int unlink(const char *pathname);

Permet de supprimer « proprement » pathname du système de fichiers Pour plus d’information, lire « man 2 unlink »

Chap. 4 – Communication entre processus

27

Partie 2

Les signaux

1. Introduction aux signaux 2. Les appels système

3. Alarm et pause

4. L’appels système « sigaction »

5. Manipulation des ensembles de signaux

Chap. 4 – Communication entre processus

28

1. Introduction aux signaux

• Un signal est un moyen de communication entre processus sans communication de données.

Chap. 4 – Communication entre processus

29

1. Introduction aux signaux

• Un processus ne peut pas connaître l’identité du processus qu’il lui a envoyé le signal.

• Les signaux sont identifiés par un numéro entier et un nom symbolique

Chap. 4 – Communication entre processus

30

1. Introduction aux signaux

• Un signal peut être envoyé :

1) lors de la constatation d’une anomalie matérielle.

2) Suite à une frappe d’une combinaison de touches (Ctrl+C).

3) Par un autre processus utilisant la primitive « kill » ou l’appel système

« kill ».

• Lors de la réception d’un signal :

1) Le signal est ignorer.

2) Le programme se termine.

3) Le programme se termine et génère un fichier « core ».

• Un processus peut changer son comportement par défaut en

« déroutant le signal »

Chap. 4 – Communication entre processus

31

1. Introduction aux signaux

• SIGINT 2 signal d’interruption (Ctrl-C par exemple)

• SIGQUIT 3 quitter et créer un fichier core

• SIGKILL 9 fin du processus (non déroutable)

• SIGPIPE 13 écrire dans un tube sans lecteur (broken pipe)

• SIGALRM 14 signal déclenché après un certain nombre de secondes (horloge)

• SIGTERM 15 fin d’un processus

• SIGSTOP 19 suspension d’un processus (non déroutable)

Chap. 4 – Communication entre processus

32

2. Appels système

int kill (pid_t pid, int sig);

• Permet d’envoyer un signal « sig » au processus « pid ».

• Un signal n’est pas reçu lors de son envoi (asynchronisme)

• Il existe un délai entre l’envoi et la réception du signal.

Chap. 4 – Communication entre processus

33

2. Appels système

void signal (int num_sig, (void *f) (int))

• La primitive signal permet de définir le comportement du processus vis-à-vis d’un signal.

• num_sig est le signal correspondant et (*f)(int) est la fonction appeler.

Exemples :

1) signal (SIGINT, SIG_IGN); //le signal SIGINT(ctrl-c) est ignoré.

Chap. 4 – Communication entre processus

34

2. Appels système

Chap. 4 – Communication entre processus

35

3. Alarm et pause

#include <unistd.h>

int pause ();

• L’appel système « pause » suspend le processus courant jusqu’à réception d’un signal quelconque non ignoré.

#include <unistd.h>

unsigned int alarm (unsigned int);

• L’appel système « alarm » active une horloge qui déclenche un signal SIGALRM au bout du nombre de secondes demandé

Chap. 4 – Communication entre processus

36

3. Alarm et pause

// i = nbs,

Chap. 4 – Communication entre processus

37

4. L’appel système « sigaction »

• L’appel système « sigaction » permet également de dérouter un signal.

• Il n’y a pas comme pour « signal » de variantes d’interprétation suivant la version Unix (System V ou BSD )

• La structure de type « struct sigaction » contient les paramètres du déroutement.

int sigaction( int num_sig, const sigaction* act, struct sigaction * oldact);

Chap. 4 – Communication entre processus

38

Exemple

Chap. 4 – Communication entre processus

39

4. L’appel système « sigaction »

struct sigaction

struct sigaction{

void * sa_handler (int*);

sigset_t sa_mask;

int sa_flags;

}

• Le champ « sa_handler » désigne l’«action » qui est associée au signal (SIG_DFL ou SIG_IGN ou un pointeur de fonction à appeler pour traiter le signal)

Chap. 4 – Communication entre processus

40

4. L’appel système « sigaction »

• Le « sa_flags » indique des options qui vont modifier le traitement du signal (à combiner avec des « ou » bit à bit) :

« SA_ONESHOT » ou « SA_RESETHAND » restorent le comportement par défaut dès que le « handler » ou le détournement a été effectué.

« SA_RESTART » indique que certains appels système seront

automatiquement redémarrés s’ils sont interrompus par le traitement du signal (compatible BSD).

« SA_NOMASK » ou « SA_NODEFER » permet que le signal soit reçu pendant l’exécution de son propre traitement,

…

Chap. 4 – Communication entre processus

41

Exemple

Chap. 4 – Communication entre processus

42

5. Manipulation des ensembles de signaux

Un certain nombre de fonctions permettent de manipuler les signaux :

int sigemptyset (sigset_t *set); initialise à « vide » un ensemble de signaux;

int sigfillset (sigset_t *set); initialise à « plein » un ensemble de signaux;

int sigaddset (sigset_t *set, int num_sig); ajoute un signal à un ensemble;

int sigdelset (sigset_t *set, int num_sig); efface un signal à un ensemble;

int sigismember (const sigset_t *set, int num_sig); teste si un signal appartient à un ensemble.

Chacun retourne :

• -1 en cas d ’erreur.

• 0 en cas de succès sauf sigmember qui retour 1 si le signal appartient à l’ensemble et 0 sinon.

Chap. 4 – Communication entre processus

43

6. Blocage des ensembles de signaux

int sigprocmask (int op, const sigset_t *p_ens, sigset_t *p_ens_ancien);

• L’installation manuelle d’un masque de blocage des signaux est réalisée par un appel à la fonction « sigprocmask ».

• Le nouveau masque est construit à partir de l’ensemble pointé par « p_ens » et

éventuellement du masque antérieur dont la valeur est récupérée au retour à l’adresse

« p_ens_ancien ».

• Le paramètre op permet de déterminer le nouvel ensemble :

SIG_SETMASK *p_ens

SIG_BLOCK *p_ens U *p_ens_ancien SIG_UNBLOCK *p_ens_ancien - *p_ens

Chap. 4 – Communication entre processus

44

6. Blocage des ensembles de signaux

int sigpending ( sigset_t *p_ens);

• Le fonction « sigpending » fournit dans « p_ens », les signaux bloqués qui ont été envoyés et sont « pendants (non pris en compte, car bloqués) »

int sigsuspend ( const sigset_t * mask);

• Le fonction « sigsuspend » suspend le processus en cours jusqu’à l’arrivée d’un signal n’appartenant pas au masque.

Chap. 4 – Communication entre processus

45

Chap. 4 – Communication entre processus

46

Partie 3

Autres moyens de communication

Chap. 4 – Communication entre processus

47

1. Les IPC System V

Trois nouveaux mécanisme de communication :

• Les files de messages

• Les sémaphores

• Les segments de mémoire partagée

Chap. 4 – Communication entre processus

48

1. Les IPC System V

Les objets sont désignés par un identificateur unique :

#include <sys/type.h>

#include <ipc.h>

key_t ftok ( char* chemin_acces, int num)

L’entier retourné est une clé unique identifiant l’objet IPC pour tout processus

« chemin_acces » fait référence à un fichier

« num » permet de générer d’autres clés uniques

Chap. 4 – Communication entre processus

49

2. Création d’objets IPC

On attache à un objet IPC un certain nombre d’informations :

• Id du propriétaire

• Id du groupe

• Le mode d’accès

• Son identificateur

ftok()

msgget() semget() shmget()

Id unique clef

objet entier

Chap. 4 – Communication entre processus

50

2. Création d’objets IPC

Mode de création :

IPC_PRIVATE : clé privée, un nouvel objet sera créé dont l’identité ne pourra être demandée ultérieurement au système.

IPC_CREAT : Création, si l’objet n’existe pas déjà, il est créé.

IPC_CREAT | IPC_EXCL : Création, si l’objet existe déjà, une erreur est signalée.

Aucun mode précisé : erreur si l’objet n’existe pas.

Chap. 4 – Communication entre processus

51

3. Files de messages

L’objet « Message Queue » fonctionne suivant le modèle d’une file donc en FIFO

• Création : msgget()

Lors de la création, on spécifie les droits d’accès : read/write pour le propriétaire/groupe/autres en combinant avec IPC_XXXX

• Envoi de messages : msgsnd()

• Réception de message : msgrcv()

Les messages peuvent être retirés en fonction de leur type

• Opérations de contrôle : msgctl() (

)

Chap. 4 – Communication entre processus

52

Objet File de Messages

Chap. 4 – Communication entre processus

53

File de Messages

Processus

Serveur File de messages

Processus client

Processus client

Processus client

Processus client

Chap. 4 – Communication entre processus

54

Sémaphores

Processus client

Processus client

Processus client

Processus client

Ressource Critique

Exclusion mutuelle Imprimante

Chap. 4 – Communication entre processus

55

4. Sémaphores

Les objets « sémaphores » permettent de gérer un groupe de sémaphores par objet

• Création : semget()

• Manipulation : semop()

Quand plusieurs processus attendent le relâchement

d'une ressource, on n’a aucun moyen de déterminer

à l'avance celui qui

Chap. 4 – Communication entre processus

56

5. Segment de Mémoire Partagée

Communication par « variable partagée » à travers l’espace d’adressage des processus

• Création : shmget()

Le segment de mémoire partagée est créé mais non accessible. Là encore, il faut spécifier le mode d’accès

.

• Attachement à l’espace d’adressage : shmat()

Le segment est inclus dans l’espace d’adressage du processus demandeur à l’adresse indiquée suivant le cas par *shsmaddr.

• Détachement du segment : shmdt()

• Gestion du segment de mémoire partagée : shmctl()

Chap. 4 – Communication entre processus

57

Chap. 4 – Communication entre processus