Pipe ou tube sous Unix

Le pipe (ou tube en français) permet de chaîner des processus. Les données produites par le premier processus sont reprises par le second qui les tranforme.

Tube anonyme

En shell, vous utiliserez le symbole | (combinaison des touches Alt Gr et 6) pour faire le chaînage. Le plus classique étant une commande du style:

cat fichier | more

La commande cat permet de lire le contenu d'un fichier et de l'afficher sur le stdout. Le | permet de modifier la destination du stdout qui est normalement l'écran, il est remplacé ici pour permettre l'envoi vers le stdin (qui est normalement le clavier) de la commande more qui gérera la pagination sur l'écran.

Le pipe permet donc une communication inter-processus en modifiant la sortie (stdout) d'un processus et l'entrée (stdin) du suivant. La sortie du processus alimentant l'entrée du suivant, vous en déduirez facilement que ce mécanisme ne fonctionne qu'en sens unique !

Ce genre de pipe est dit "tube anonyme". Seules les processus se trouvant dans un même environnement (donc fork) peuvent accéder à ce pipe. Les tubes sont gérés comme une pile fifo et l'information disparait sitôt la lecture faite. Le multi-tâches prend alors tout son intérêt ici, puisque les processus fonctionneront en parallèles: Le processus 1 produit une donnée et l'envoi dans le pipe pour que le processus 2 le transforme. Pendant ce temps, le processus 1 peut produire une nouvelle donnée. La pile FIFO permettant de gérer les différences de temps d'exécution des processus pour traiter ces données.

Tube anonyme en C

En C, vous pourrez créer un tube anonyme à partir de la commande pipe:

#include <unistd.h>

int pipe(int fildes[2]);

En entrée:

fildes est un tableau contenant deux descripteurs de fichier. Le premier (fildes[0]) contient le descripteur à utiliser en lecture de données du tube. Le second (fildes[1]) sera utilisé pour envoyer les données dans le tube.

En sortie:

0 si tout est ok

-1 si erreur avec errno à:

• EMFILE pour trop de file descriptors utilisés dans le processus
• ENFILE LA table de gestions des fichiers est pleine
• EFAULT pour filedes non valide

Ensuite, utilisez les commandes write (pour écrire dans le tube), read (pour lire les données présentes dans le tube) et close (pour fermer les tubes) comme pour des fichiers normaux (cf. gestion des fichiers)...

Exemple de tube anonyme en C

Création d'un processus qui se fork pour envoi de données via un tube entre un processus père et son fils.

(cf. les processus pour le fork pour obtenir un même environnement, les signaux pour wait utilisé pour synchroniser la fin du traitement)

#include <stdio.h> #include <sys/signal.h> #include <string.h> #include <unistd.h> main() { int i, p[2], count; char buffer[6]; /* création du pipe */ pipe(p); /* On vide le buffer */ memset (buffer, 0, 6); /* création du fils qui recevra les données */ i=fork(); /* Le fils... */ if (i== 0){ close (p[1]); count = read(p[0],buffer,5); fprintf(stdout,"fils en lecture: lu %d caractères : %s\n",count,buffer); close (p[0]); fprintf (stdout, "Fin du proessus fils\n"); } else { /* Envoyer les données au fils */ close (p[0]); fprintf(stdout,"Le père va envoyer les données au fils...\n"); count = write(p[1],"salut",5); /* Attendons la fin du fils avant de quitter */ int waitFils; /* On ne traitera pas ici l'information de retour du fils... */ wait (&waitFils); /* fermeture du pipe */ fprintf (stdout, "Fin du proessus père\n"); close(p[1]); } }

Tubes nommés

Les tubes nommés sont similaires aux tubes anonymes. La différence étant qu'ils peuvent être utilisés dans des environnements différents. Les processus peuvent donc être indépendants.

Cependant, il faudra utiliser la commande mknode pour créer le pipe nommé. Les deux processus devant être capables de retrouver le pipe en question dans le système de fichiers:

mknode monPipe p

où monPipe est le nom du tube et sera de type p (pour pipe). Dans cet exemple, il sera créé dans le répertoire courant.

Il reste ensuite à utiliser les fonctions open(), read(), write() et close pour accéder au tube (cf. gestion des fichiers).

Annexes

Il existe une autre solution pour échanger des données entre processus: la communications inter-processus (IPC)