Processus et gestion de processus

(1)

A 2015, AG 2021JLA 2015, AG 2021

Processus et gestion de processus

Processus GNU/Linux Communication

Comm. Inter.

(2)

IUT BM J.-L. Anthoine, Arnaud.Giersch@univ-fcomte.fr

JLA 2015, AG 2021JLA 2015, AG 2021

Communications entre processus Signaux

Tubes

Tubes nommés

UNIX – GNU/Linux

GNU/Linux Communication

Comm. Inter.

(3)

A 2015, AG 2021JLA 2015, AG 2021

Communication entre processus

La communication entre processus est un problème courant dans les systèmes

d'exploitation multiprogrammé

Plusieurs processus concourent à la

réalisation d'une même tâche pour cela ils doivent :

Partager l'utilisation d'une

ressource : une variable, un tampon, un fichier, une base de données … cette ressource étant évidemment non partageable

Échanger des données : valeur

d'une variable, lignes d'un fichier ...

Comm. Inter.

(4)

JLA 2015, AG 2021JLA 2015, AG 2021

Communication entre processus : exclusion mutuelle

Comm. Inter.

La partage d'une ressource non partageable est réalisé par un mécanisme d'exclusion

mutuelle

Cette technique garanti qu'à tout instant un seul processus utilise la ressource

Les parties de code des processus utilisant la ressource sont appelées section critique Le mécanisme d'exclusion mutuelle garanti qu'à tout instant un seul processus exécute sa section critique

On dit que la section critique est exécutée de

manière atomique

(5)

A 2015, AG 2021JLA 2015, AG 2021

Communication entre processus : exclusion mutuelle

Comm. Inter.

4

Variable partagée i

void main(){

… … … … … … … … }

void main(){

… … … … … … … … }

void main(){

… … … … … … … … }

void main(){

… … … … … … … … } Processus 1

Processus 2 Processus 3

Processus 4

X X

X

(6)

JLA 2015, AG 2021JLA 2015, AG 2021

Partage d'une variable sans outil de synchronisation

Comm. Inter.

(7)

A 2015, AG 2021JLA 2015, AG 2021

Partage de variable

par l'intermédiaire d'un fichier

Un processus père et un processus utilise un entier contenu dans un fichier

Le père initialise l'entier à 1 et l'écrit dans le fichier

Chaque processus fils lit l'entier l'incémente et l'écrit dans le fichier

Si le partage est correcte la valeur écrite doit être : 1, 2, 3, 4, ...

Comm. Inter.

(8)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Tampon = contenu d'un fichier

void main(){

… … Lire

Incrémenter Écrire

… … … }

void main(){

… … …Lire

Incrémenter Écrire

… … }

Tampon de communication

(9)

A 2015, AG 2021JLA 2015, AG 2021

Algorithme

Père :

Crée le fichier tampon Crée le processus fils

Initialise le contenu du tampon à 1

Boucle dans la lecture, incrémentation, écriture de la variable

Lorsque la variable > max le père arrête le fils par envoi d'un signal SIGTERM

Fils :

Boucle dans la lecture, incrémentation, écriture de la variable

Comm. Inter.

(10)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Programme

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include <unistd.h>

#include <fcntl.h>

#include <stdlib.h>

#include <signal.h>

int main (int narg, char * arg []) { int tampon, fils, variable;

tampon=open("/tmp/tampon",O_RDWR|O_CREAT|

O_TRUNC,S_IRWXU);

if ( tampon < 0) {

perror("Ouverture de /tmp/tampon");

return EXIT_FAILURE;

}

fils=fork();

if ( fils == -1 ){

perror("Echec de la création du fils");

unlink("/tmp/tampon");

}

(11)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Programme

if (fils == 0 ) { while (1){

/* Lecture du tampon */

lseek(tampon, 0, SEEK_SET);

if ( read(tampon,(void *)&variable,4) != 4 ){

perror("Fils erreur de lecture");

}

fprintf(stderr,"\tFils valeur lue : %d\n",variable);

variable++;

fprintf(stderr,"\tFils valeur écrite : %d\n",variable);

if (write(tampon,(void *)&variable,4) == -1){

perror("Fils erreur d'écriture");

}

if ( variable % 3 == 0 ) sleep(1);

}

return EXIT_SUCCESS;

}

(12)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Programme

/* Processus père */

variable=1;

fprintf(stderr,"Père valeur écrite : %d\n",variable);

perror("Père erreur d'écriture");

kill(fils, SIGTERM); /* pour tuer le fils */

}

while( variable < 18 ){

if ( read(tampon,(void *)&variable,4) != 4 ){

perror("Père erreur de lecture");

}

fprintf(stderr,"Père valeur lue : %d\n",variable);

variable++;

kill(fils, SIGTERM); /* pour tuer le fils */

}

if ( variable % 2 == 0) sleep(1);

}

(13)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Programme

/* Terminaison du fils */

kill(fils,SIGTERM);

}

(14)

JLA 2015, AG 2021JLA 2015, AG 202

(15)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Exclusion mutuelle : verrou fichier

Un processus père et un processus utilise et incrémente chacun à leur tour une variable contenue dans un fichier

Pour garantir un accès à la variable en exclusion mutuelle chaque processus verrouille le fichier tampon en utilisation exclusive à l'aide de la primitive flock

#include <sys/file.h>

int flock(int fd, int operation);

Operation : LOCK_SH : partagé, LOCK_EX :

exclusif, LOCK_UN : supprime le verrou

(16)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Algorithme : Père :

Créer le fichier tampon et initialise la variable à 1

Crée un processus fils Tant que variable < max

Poser le verrou

Lire et incrémenter la variable Écrire la variable

Libérer le verrou

Exclusion mutuelle : verrou fichier

(17)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Fils :

Ouvrir le fichier tampon Tant que vrai

Poser le verrou

Lire et incrémenter la variable Écrire la variable

Libérer le verrou

Afin d'obtenir une exécution alternée des

processus chaque processus attends lorsque la variable est multiple de 3 dans le père, 2 dans le fils

Exclusion mutuelle : verrou fichier

(18)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Exclusion mutuelle : verrou fichier

#include <signal.h>

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <stdlib.h>

#include <sys/file.h>

int main (int narg, char * arg []) { int tampon, variable;

pid_t fils;

tampon=open("/tmp/tampon",O_RDWR|O_CREAT|

O_TRUNC,S_IRWXU);

if ( tampon < 0) {

}

variable=1;

if (write(tampon,(void *)&variable,4) != 4){

}

(19)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Exclusion mutuelle : verrou fichier

fils=fork();

if ( fils == -1 ){

}

if ( fils == 0 ) {

/* fermeture et ouverture du tampon pour flock */

(void) close(tampon);

tampon=open("/tmp/tampon",O_RDWR);

if ( tampon < 0) {

}

(20)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Exclusion mutuelle : verrou fichier

while (1){ /* Pose du verrou exclusif */

if ( flock( tampon, LOCK_EX ) < 0) { perror("Fils : échec pose du verrou");

} /* Lecture du tampon */

variable=0;

if ( read(tampon,(void *)&variable,4 ) != 4){

perror("Fils erreur lecture");

}

fprintf(stderr,"\tFils valeur lue : %d\n",variable);

variable++;

fprintf(stderr,"\tFils valeur écrite : %d\n",variable);

fflush(stderr);

if (write(tampon,(void *)&variable,4) != 4 ){

} /*Suppression du verrou */

if ( flock( tampon, LOCK_UN ) < 0) {

perror("Fils : echec suppression du verrou");

}

if ( variable % 3 == 0 ) sleep(1);

}

(21)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

variable=1;

while( variable < 20 ){

/* Pose du verrou exclusif */

if ( flock( tampon, LOCK_EX ) < 0) {

perror("Père : échec pose du verrou");

}

variable=0;

if ( read(tampon,(void *)&variable,4) != 4){

perror("Père erreur lecture");

}

variable++;

fflush(stderr);

if (write(tampon,(void *)&variable,4) != 4 ){

}

/*Suppression du verrou */

if ( flock( tampon, LOCK_UN ) < 0) {

perror("Fils : echec suppression du verrou");

}

if ( variable % 2 == 0) sleep(1);

}

(22)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

kill(fils,SIGTERM);

(void) wait((int*) NULL);

}

(23)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

(24)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Communication entre processus : synchronisation

L'échange de donnée est souvent réglé par un mécanisme de synchronisation et

l'utilisation d'un tampon de communication Un processus élabore une donnée et la dépose dans un tampon et envoie une information à un second processus pour l'informer de la disponibilité des données Le second processus extrait la donnée du tampon et informe le premier processus que le tampon est vide

L'exécution conditionnelle d'un processus

par un autre est appelé synchronisation

(25)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Communication entre processus : synchronisation

void main(){

… … … S1 … … … … }

void main(){

… … … … S2 … … … }

Le processus 2 ne peut aller au delà de S2 tant que le processus 1 n'est pas arrivé en S1

(26)

JLA 2015, AG 2021JLA 2015, AG 2021

Le problème du producteur consommateur

Problème classique de communication inter- processus

Un producteur dépose dans un tampon des productions qui sont utilisées par un

processus consommateur Il faut s'assurer que :

Toutes les productions sont consommées dans l'ordre

Aucune n'est dupliquée c'est dire consommée deux fois

Aucune n'est perdue

Comm. Inter.

(27)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Le problème du producteur consommateur

Ce problème peut être solutionné de plusieurs manières

Une approche consiste à le considérer comme un double problème de

synchronisation :

S1 : le producteur produit une donnée, la dépose dans le tampon puis synchronise le consommateur

S2 : le consommateur extrait la donnée du

tampon puis synchronise le producteur

(28)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Le problème du producteur consommateur

void main(){

… …

produire() …

… … … }

void main(){

… … … …

consommer() …

… … }

production

Tampon de communication

consomme

produit produire()

… ...

consommer() …

… ...

(29)

A 2015, AG 2021JLA 2015, AG 2021

Communications entre processus Signaux

Tubes

Tubes nommés

UNIX – GNU/Linux

Comm. Inter.

(30)

JLA 2015, AG 2021JLA 2015, AG 2021

Signaux

La primitive :

#include <sys/types.h>

#include <signal.h>

int kill(pid_t pid, int sig);

permet d'envoyer le signal sig au processus pid

Contrairement à ce que son nom laisse supposer cette primitive ne termine pas le processus mais envoie un signal à un ou plusieurs processus

Comm. Inter.

(31)

A 2015, AG 2021JLA 2015, AG 2021

Signaux : droits

Si l'UID effectif du processus émetteur est 0 il peut envoyer un signal à tout processus ( root)

UID réel ou effectif de l'émetteur doit être égal à l'UID effectif de la cible

Dans le cas particulier du signal SIGCONT il suffit que l'émetteur appartienne au même groupe de processus que la cible

Comm. Inter.

(32)

JLA 2015, AG 2021JLA 2015, AG 2021

Signaux : fonctionnement

Si pid est > 0 le signal de numéro sig est envoyé au processus de numéro pid : le signal est envoyé par un processus à un autre processus

Si pid = 0 le signal est envoyé à tous les processus du groupe auquel appartient le

processus émetteur : permet par exemple de terminer, en envoyant le signal SIGTERM, tous les processus appartenant à un groupe donné. C'est utilisé par le shell pour terminer tous les processus de la session lorsqu'un utilisateur se déconnecte

Comm. Inter.

(33)

A 2015, AG 2021JLA 2015, AG 2021

Signaux : fonctionnement

Si pid < -1 le signal est envoyé à tous les processus appartenant au groupe |pid| : permet de terminer (SIGTERM) un démon est tous ses processus fils

Si pid = -1 le signal est envoyé à tous les processus du système sauf le le processus init de numéro 1 : utilisé par exemple lors de l'arrêt du système pour terminer tous les

processus existants

Si sig = 0 rien n'est envoyé cela permet de tester l'existence du processus d'identifiant pid

Comm. Inter.

(34)

JLA 2015, AG 2021JLA 2015, AG 2021

Producteur-Consommateur réalisé à l'aide de signaux

Le tampon est matérialisé par le contenu d'un fichier

Chaque processus lit puis écrit à son tour la valeur d'une variable qu'il incrémente de un Chaque processus joue donc alternativement le rôle de producteur et de consommateur

Dans l'exemple les deux processus utilisent un signal pour informer l'autre de la

disponibilité de la donnée

L'échange est réalisé entre un processus père et son fils l'envoi de signal nécessitant de connaître le numéro du destinataire

Comm. Inter.

(35)

A 2015, AG 2021JLA 2015, AG 2021

Producteur-Consommateur réalisé à l'aide de signaux

Comm. Inter.

(36)

JLA 2015, AG 2021JLA 2015, AG 2021

Traitement des signaux

Comm. Inter.

#define _GNU_SOURCE /* traitement des signaux BSD */

#define _BSD_SOURCE

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <stdlib.h>

#include <signal.h>

/* traitement du signal SIGTERM (15) envoyé par le fils au pere */

void sigterm( int s){

fprintf(stderr,"Signal SIGTERM reçu\n");

wait((int*) NULL);

exit(EXIT_SUCCESS);

}

(37)

A 2015, AG 2021JLA 2015, AG 2021

Traitement des signaux

Comm. Inter.

/* traitement du signal SIGUSR1 (10) envoyé par le fils au père */

void sigusr1( int s){

fprintf(stderr,"Père signal %d reçu\n",s);

return;

}

/* traitement du signal SIGUSR2 (12) envoyé par le père au fils */

void sigusr2( int s){

fprintf(stderr,"Fils signal %d reçu\n",s);

return;

}

(38)

JLA 2015, AG 2021JLA 2015, AG 2021

Ouverture du fichier et création du processus fils

Comm. Inter.

int main (int narg, char * arg []) { int tampon, fils, variable;

tampon=open("/tmp/tampon",O_RDWR|O_CREAT|O_TRUNC,S_IRWXU);

if ( tampon < 0) {

}

switch ( fils=fork() ){

case -1 :

(39)

JLA 2015, AG 2021JLA 2015, AG 2021

Processus fils

Comm. Inter.

case 0 :

if ( signal(SIGUSR2, sigusr2) == SIG_ERR ){

perror("Traistement de SIGUSR2 par le fils");

kill(getppid(), SIGTERM); /* pour avertir le père */

}

while (1){ /* Attente du signal SIGUSR2 pour lire */

pause();

read(tampon,(void *)&variable,4);

fprintf(stderr,"Fils valeur lue : %d\n",variable);

variable++;

fprintf(stderr,"Fils valeur écrite : %d\n",variable);

kill(getppid(), SIGTERM); /* pour avertir le père */

}

kill(getppid(), SIGUSR1);

}

(40)

JLA 2015, AG 2021JLA 2015, AG 2021

Mise en place du traitement du signal dans le père

Comm. Inter.

if ( signal(SIGUSR1, sigusr1) == SIG_ERR ){

perror("Traistement de SIGUSR1 par le père");

kill(fils, SIGTERM); /* pour terminer le fils */

/* autoterminaison */

kill(getpid(),SIGTERM);

}

(41)

JLA 2015, AG 2021JLA 2015, AG 2021

Producteur-Consommateur réalisé à l'aide de signaux

Comm. Inter.

sleep(1); /* pour que le fils s'exécute en premier */

variable=1;

while( variable != 11 ){

kill(fils, SIGTERM);

}

kill(fils, SIGUSR2);

pause(); /* Attente du signal SIGUSR1 pour lire */

read(tampon,(void *)&variable,4);

variable++;

}

kill(fils,SIGTERM);

/* autoterminaison */

kill(getpid(),SIGTERM);

(42)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

Exécution

(43)

A 2015, AG 2021JLA 2015, AG 2021

Remarques

Le sleep(1) dans le processus père après création du fils garanti que le processus fils va s'exécuter en premier et mettre en place le traitement du signal SIGUSR2 avant que le père n'émette le premier signal

Cette double synchronisation du processus père par le fils et inversement peut être

réalisée sans problème avec deux processus indépendants il suffit de commencer chaque processus par une lecture sur l'entrée

standard, du numéro de processus de l'autre

Comm. Inter.

(44)

JLA 2015, AG 2021JLA 2015, AG 2021

Communications entre processus Signaux

Tubes

Tubes nommés

UNIX – GNU/Linux

Comm. Inter.

(45)

A 2015, AG 2021JLA 2015, AG 2021

Tube

Un tube est une structure de communication créée et gérée par la système en mémoire C'est un outil de communication car il est

possible d'en lire le contenu et d'y écrire des données

De synchronisation :

Le SE garanti que toute opération d'une taille inférieure à PIPE_BUFF, défini dans limits.h, est réalisée de manière atomique

Les données sont lues dans l'ordre ou elle ont été écrites

Comm. Inter.

(46)

JLA 2015, AG 2021JLA 2015, AG 2021

Tube

La lecture d'un tube vide est

bloquante si il existe un écrivain au moins du tube = un processus dans lequel le descripteur d'écriture est valide

L'écriture d'un tube plein est

bloquante si il existe un lecteur au moins du tube = un processus dans lequel le descripteur de lecture est valide

L'écriture d'un tube sans lecteur déclenche le signal SIGPIPE qui par défaut arrête le

processus

Comm. Inter.

(47)

A 2015, AG 2021JLA 2015, AG 2021

Tube : création

Primitive :

#include <unistd.h>

int pipe(int pipefd[2]);

Crée et ouvre un tube dont les descripteurs de bas niveau sont :

pipefd[0] en lecture pipefd[1] en écriture Retourne :

= 0 en cas de réussite

< 0 en cas d'échec

Comm. Inter.

(48)

JLA 2015, AG 2021JLA 2015, AG 2021

Tube : création

Un tube ne peut être ouvert, la primitive pipe crée et ouvre le tube

Après fermeture le tube devient inaccessible Pour l'utiliser à haut niveau il faut utiliser

fdopen

Les descripteurs étant transmis dans

l'héritage durant fork l'utilisation d'un tube entre deux processus implique que le tube ait été créé par un ancêtre commun

Comm. Inter.

(49)

A 2015, AG 2021JLA 2015, AG 2021

Exemple : tube de communication entre deux processus

Les tubes de communication permettent à deux processus de communiquer

Une utilisation classique consiste à rediriger : la sortie standard du premier dans le tube

L'entrée standard du second depuis le tube

Comm. Inter.

(50)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

ls -l -a répertoire | wc

(51)

A 2015, AG 2021JLA 2015, AG 2021

ls -l -a répertoire | wc

Ce programme C est équivalent à la commande ls -l -a | wc

Le programme comporte deux processus Le père exécute la commande wc

Le fils la commande ls -l -a répertoire

A la terminaison du fils le processus père recevra EOF comme résultat de lecture ce qui rend inutile l'attente de la fin du fils

Comm. Inter.

(52)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

ls -l -a répertoire | wc : création du tube

#include <unistd.h>

#include <stdlib.h>

#include<stdio.h>

int main(int narg, char ** argv){

pid_t fils;

int tube[2];

/* Verification de l'existence d'un paramètre au moins */

if ( narg < 2 ){

fprintf(stderr,"Il faut un paramètre au moins : le répertoire\n");

}

if ( pipe(tube) != 0) {

perror("Création du tube");

}

(53)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

ls -l -a répertoire | wc : processus fils

/* creation du fils 1 executant ls -l -a*/

fils=fork();

switch ( fils ) { case -1 :

perror("Pere : echec du fork");

return 1;

case 0 :

close (tube[0]); /*lecture tube jamais utilise */

close (1); /* redirection de stdout */

dup (tube[1]);

/* fermeture de descripteurs non utilises devenus inutiles */

close (tube[1]);

/* on peut maintenant lancer l'execution de ls -l */

fprintf(stderr,"On lance ls -l -a %s\n",*(argv+1));

execlp("ls","ls","-l", "-a", *(argv+1), (char*)NULL);

perror("Echec de l'execution du programme ls");

}

(54)

JLA 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

ls -l -a répertoire | wc : processus père

/* Processus pere on peut maintenant lancer l'execution de wc -l */

close (tube[1]); /* jamais utilise */

close (0); /* redirection de stdin */

dup (tube[0]);

/* fermeture de descripteurs non utilises devenus inutiles */

close (tube[0]);

execlp("wc","wc",(char*)NULL);

perror("Echec de l'execution de wc");

}

(55)

A 2015, AG 2021JLA 2015, AG 2021

Producteur-Consommateur réalisé à l'aide de tubes

Comm. Inter.

(56)

JLA 2015, AG 2021JLA 2015, AG 2021

Producteur-Consommateur réalisé à l'aide de tubes

Les processus échangeant des informations dans les deux sens il est nécessaire d'utiliser 2 tubes

Le premier père_fils permet l'échange dans le sens père → fils

Le second fils_père dans le sens fils → père Le processus père termine l'exécution

lorsque la valeur lue est 10, il ferme alors le descripteur en écriture du tube père_fils

Le fils lisant un tube vide sans écrivain reçoit 0 et se termine

Comm. Inter.

(57)

A 2015, AG 2021JLA 2015, AG 2021

Initialisation

Comm. Inter.

#include <signal.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

int main (int narg, char * arg []) {

int pere_fils[2], fils_pere[2], fils, variable, n;

if (pipe(pere_fils)){ /* création des tubes */

perror("Création du premier tube");

}

if (pipe(fils_pere)){

perror("Création du second tube");

}

(58)

JLA 2015, AG 2021JLA 2015, AG 2021

Processus fils

Comm. Inter.

switch ( fils=fork() ){

case -1 :

case 0 :

/* fermeture des descripteurs */

close(pere_fils[1]); close(fils_pere[0]);

while (1){

n=read(pere_fils[0],(void *)&variable,4);

if ( n == 0 ) {

close(fils_pere[1]);close(pere_fils[0]);

}

fprintf(stderr,"Fils valeur lue : %d\n",variable);

variable++;

if (write(fils_pere[1],(void *)&variable,4) == -1){

}

fprintf(stderr,"Fils valeur écrite : %d\n",variable);

}

} /* Fin switch */

(59)

A 2015, AG 2021JLA 2015, AG 2021

Processus père

Comm. Inter.

close(pere_fils[0]); close(fils_pere[1]);

variable=1;

while( variable != 11 ){

if (write(pere_fils[1],(void *)&variable,4) == -1){

}

read(fils_pere[0],(void *)&variable,4);

variable++;

}

close(pere_fils[1]);

wait((int*)NULL);

}

(60)

JLA 2015, AG 2021JLA 2015, AG 2021

Exécution

Comm. Inter.

(61)

A 2015, AG 2021JLA 2015, AG 2021

Communications entre processus Signaux

Tubes

Tubes nommés

UNIX – GNU/Linux

Comm. Inter.

(62)

JLA 2015, AG 2021JLA 2015, AG 2021

Tube nommé

Les tubes ne peuvent être utilisés entre deux processus que si le tube a été créé dans un ancêtre commun

Les tubes nommés étant des éléments du système de fichier ils peuvent être utilisés entre 2 processus quelconque

La primitive mknod ou la fonction de

bibliothèque mkfifo permettent de créer le tube

Chaque processus désirant utiliser le tube doit l'ouvrir à l'aide de la primitive open, conseillé, ou avec fopen

Comm. Inter.

(63)

A 2015, AG 2021JLA 2015, AG 2021

Tube nommé

Comm. Inter.

L'ouverture d'un tube en lecture est

bloquante jusqu'à l'ouverture du tube en écriture

L'ouverture d'un tube en écriture est

bloquante jusqu'à l'ouverture du tube en lecture

Le tube nommé est un outil de

synchronisation et de communication si les

opérations effectuées sont d'une longueur

inférieure PIPE_BUF

(64)

JLA 2015, AG 2021JLA 2015, AG 2021

Client-serveur utilisant un tube nommé

Comm. Inter.

Exemple similaire au principe de

communication utilisé entre le serveur X et ses différents clients les fenêtres graphiques Le serveur créé un tube et y lit les requêtes des clients : une commande à exécuter

La commande est exécutée en utilisant la fonction de bibliothèque system qui évite l'analyse de la commande pour en trouver les paramètres

system créé un processus fils pour exécuter

la commande

(65)

A 2015, AG 2021JLA 2015, AG 2021

Serveur : créateur et lecteur du tube

Comm. Inter.

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <stdio.h>

int main (int narg, char * arg []) { int d;

FILE * fifo;

char commande[256];

/* creation du tube nomme */

if ( mkfifo("/tmp/commande",0700) < 0 ){

if ( errno != EEXIST ) {

perror("Création du tube nommé");

} else

fprintf(stderr,"Le tube nommé existe il n'est pas créé\n");

}

(66)

JLA 2015, AG 2021JLA 2015, AG 2021

Serveur : créateur et lecteur du tube

Comm. Inter.

/* ouverture du tube en lecture */

if ( (d = open("/tmp/commande",O_RDONLY)) < 0 ){

perror("Echec de l'ouverture du tube nommé avec open");

unlink("/tmp/commande");

}

if ( (fifo = fdopen(d, "r")) == NULL ){

perror("Echec de l'ouverture du tube nommé avec fopen");

close(d);

unlink("/tmp/commande");

}

while(1) {

/* lecture de la commande à exécuter */

if ( fgets(commande, 256, fifo) == commande ){

fprintf(stderr,"Exécution de commande -%s-",commande);

system(commande);

} }

}

(67)

A 2015, AG 2021JLA 2015, AG 2021

Client : écrivain du tube

Comm. Inter.

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <stdio.h>

#include <string.h>

int main (int narg, char * arg []) { int d;

FILE * fifo;

char commande[256];

/* ouverture du tube en lecture */

if ( (d = open("/tmp/commande",O_WRONLY)) < 0 ){

perror("Echec de l'ouverture du tube nommé avec open");

}

if ( (fifo = fdopen(d,"w")) == NULL){

perror("Echec de l'ouverture du tube nommé avec fopen");

}

(68)

JLA 2015, AG 2021JLA 2015, AG 2021

Client : écrivain du tube

Comm. Inter.

*commande='\0';

while(1) {

/* lecture de la commande à exécuter */

fprintf(stdout,"Commande à exécuter : ");

if ( fgets(commande, 256, stdin) != NULL) { if (strlen(commande) != 1){

/* la commande n'est pas vide */

if (fputs(commande, fifo) != EOF ) { fprintf(stderr,"flush fifo\n");

fflush(fifo);

}

else {

fprintf(stderr,"Le tube nommé à été fermé\n");

break;

} } else

break;

} }

fclose(fifo);

}

(69)

A 2015, AG 2021JLA 2015, AG 2021

Comm. Inter.

(70)

JLA 2015, AG 2021JLA 2015, AG 2021

Client : écrivain du tube

Comm. Inter.

(71)

A 2015, AG 2021JLA 2015, AG 2021

Serveur : lecteur du tube

Comm. Inter.