172 lines
6.0 KiB
Markdown
172 lines
6.0 KiB
Markdown
### La communication via les tubes
|
||
|
||
#### tubes sans nom
|
||
Liaison unidirectionnelle. La taille maximale est approximativement de 4Ko. Ils existent via le _shell_ et l’appel système ```pipe()```. Lecture FIFO.
|
||
|
||
```c
|
||
#include <unistd.h>
|
||
int pipe(int desc[2]); /* ou int *tubEDesc */
|
||
```
|
||
|
||
Cela correspond à la création d’un nouveau tube anonyme. En cas de réussite, il y aura location d’un noted sur le disque des tubes, de deux entrées dans la tables des fichiers ouverts (une en lecture et une en écriture et pour chacune des entrées d’un descripteur dans la table des descripteurs du processus appelant:
|
||
- ```desc[0]``` correspond au descripteur en lecture sur le tube
|
||
- ```desc[1]``` correspond au descripteur en écriture sur le tube
|
||
Un appel réussi renvoie 0, si échec alors -1 (et la variable ```errno``` est positionnée (```EMFILE``` table des descripteurs du proc. pleine ou ```ENFILE``` table des fic ouverts du sys. pleine).
|
||
|
||
Les tubes anonymes ne sont pas des « fichiers » comme les autres les appels ```open, stat, access, link, unlink, rename, chmod, chown``` et ```lseek``` ne sont pas autorisés. On peut accéder à des informations (et les modifier) via les appels : ```fstat``` et ```fcntl```.
|
||
|
||
Le processus usuel pour la communication inter-processus :
|
||
1- le processus père créé un tube sans nom avec ```pipe()```
|
||
2- le processus père créé les fils
|
||
3- les processus écrivains ferment l'accès en lecture du tube
|
||
4- les processus lesteurs ferment l'accès en écriture du tube
|
||
5- communication via ```read``` et ```write```
|
||
6- fermeture des tubes quand plus besoin de communiquer
|
||
|
||
```c
|
||
#include <sys/types.h>
|
||
#include <unistd.h>
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
#define R 0
|
||
#define W 1
|
||
|
||
int main ( ) {
|
||
int fd[2] ;
|
||
char message[100] ;
|
||
int nboctets ;
|
||
char *phrase = " message envoye au pere par le fils " ;
|
||
|
||
pipe ( fd ) ;
|
||
if (fork() == 0) {
|
||
close ( fd[R] ) ;
|
||
write ( fd[W] , phrase , strlen (phrase) + 1 ) ;
|
||
close ( fd[W] ) ;
|
||
}
|
||
else {
|
||
close ( fd[W] ) ;
|
||
nboctets = read ( fd[R] , message , 100 ) ;
|
||
printf ( " Lecture %d octets : %s\n" , nboctets , message ) ;
|
||
close ( fd [R] ) ;
|
||
}
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
Si on veut structurer les échanges, on a intérêt à prévoir un protocole de communication.
|
||
|
||
> Comment un shell exécute une commande comme ```ls | wc```. Dans un premier temps, le tube est créé avec la commande pipe(). Puis un processus fils est créé. Ce processus fils héritera des accès en entrée et en sortie du tube. Ensuite, le processus parent ferme son accès à la sortie du tube et fait pointer ```STDOUT``` sur l’entrée du tube. Dans le même temps, le processus fils ferme son accès à l’entrée du tube et redirige ```STDIN``` sur la sortie du tube. Finalement, les deux processus sont remplacés par les programmes ```ls``` et ```wc```.
|
||
|
||
On peut faire de la communication bi-directionnelle en utilisant 2 tubes.
|
||
|
||
L'algo de lecture pour ```read(p, buf, TAILLE_BUF)```:
|
||
|
||
```swift
|
||
if tube(p) != vide then
|
||
let taille = size(p) in
|
||
buf = extract(p, min(taille, TAILLE_BUF))
|
||
else
|
||
if nb(writer, p) == 0 then
|
||
return 0
|
||
else
|
||
if read is Bloquant then
|
||
process = wait
|
||
else
|
||
return -1
|
||
errno = EAGAIN (* O_NONBLOCK *)
|
||
```
|
||
|
||
> Attention à l'interblocage
|
||
|
||
Pour le cas du ```write(p, buffer, tailleBuf)```. On a la garantie que si la taille à écrire est inférieure à la ```PIPE_BUF``` alors l'écriture est atomique. Si ce n'est pas le cas, c'est le système qui décide...
|
||
|
||
```swift
|
||
if nb(lecteur(p) == 0) then
|
||
receive(SIGPIPE) (* si signal capté => return -1 et errno = EPIPE *)
|
||
else
|
||
if write is bloquant then
|
||
wait until all is written
|
||
else
|
||
if n > PIPE_BUF then return m (* m < n *)
|
||
if n ≤ PIPE_BUF and freesize(p) > n then GOOD
|
||
if n ≤ PIPE_BUF and freesize(p) < n then return -1
|
||
```
|
||
|
||
On peut utiliser ```dup``` et ```dup2 ``` pour dupliquer. Cela permet de rediriger les E/S standards sur un tube.
|
||
|
||
#### A faire en exercice de TP
|
||
Avec exemple :
|
||
- écriture dans un tube sans lecteur
|
||
- ecriture dns un tube plein
|
||
|
||
|
||
#### tubes nommés
|
||
Il a été rajouté un autre type de tube qui facilite un peu les choses en rajoutant les fonctionnalités suivantes :
|
||
- Ils ont chacun un nom qui existe dans le système de fichiers (une entrée dans la table des fichiers).
|
||
- Ils sont considérés comme des fichiers spéciaux.
|
||
- Ils peuvent être utilisés par des processus indépendants, à condition qu’ils s’exécutent sur une même machine.
|
||
- Ils existeront jusqu’à ce qu’ils soient supprimés explicitement.
|
||
- Ils sont de capacité plus grande, d’environ 40 Ko.
|
||
|
||
Ainsi, deux processus sans relation parent-enfant peuvent échanger des données au moyen des tubes nommés.
|
||
|
||
```man
|
||
SYNOPSIS
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
|
||
int
|
||
mkfifo(const char *path, mode_t mode);
|
||
|
||
DESCRIPTION
|
||
mkfifo() creates a new fifo file with name path. The access permissions are
|
||
specified by mode and restricted by the umask(2) of the calling process.
|
||
|
||
The fifo's owner ID is set to the process's effective user ID. The fifo's
|
||
group ID is set to that of the parent directory in which it is created.
|
||
|
||
RETURN VALUES
|
||
A 0 return value indicates success. A -1 return value indicates an error,
|
||
and an error code is stored in errno.
|
||
```
|
||
|
||
On peut créer des tubes depuis le shell ```makefifo my_tube```. On obtient alors :
|
||
|
||
```sh
|
||
bash-4.4$ ls -l my_tube
|
||
prw-r--r-- 1 pvalarcher staff 0 9 oct 05:48 my_tube
|
||
bash-4.4$
|
||
```
|
||
|
||
|
||
### TD
|
||
Complétez le programme suivant afin de rendre la communication
|
||
bidirectionnelle entre 2 processus sans laisser de zombies. Le père
|
||
dort 2 secondes après avoir envoyé son message au fils et le fils dort 4
|
||
secondes après avoir envoyé son message au père. On n’a pas besoin
|
||
de variables additionnelles.
|
||
|
||
```c
|
||
#include <sys/types.h>
|
||
#include <unistd.h>
|
||
#include <stdio.h>
|
||
#define R 0
|
||
#define W 1
|
||
|
||
int main() {
|
||
int fdp[2], // père
|
||
fdf[2]; // fils
|
||
|
||
char message[100]; // pour récupérer un message
|
||
|
||
char *phrasef = "message envoyé au père par le fils";
|
||
|
||
char *phrasep = "message envoyé au fils par le père";
|
||
// À COMPLÉTER !!
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|