Verrouillage d'un fifo accessible par plusieurs prog

**v4np13** · 18/04/2007, 18h31

Bonjour,
je dois créer une mini application "client-serveur" avec des fifos (pas des sockets, des fifos). Pour l'instant, ça fonctionne en mono utilisateur et je dois le passer en multi-utilisateurs.

Problème: le fifo du serveur (auquel j'envoie les requêtes) devient une ressource critique. Je pensais à le verrouiller du coté client:
-verrouillage écriture (pour les autres clients)
-écriture de la requete
-déverrouillage

Cela à l'aide de la fonction fcntl(). Je me demandais si mon raisonnement était possible. Il me semble que non, si je verrouille en écriture, je ne saurais plus écrire dans le fifo avant le déverouillage. Comment pourrais-je faire?

Merci d'avance

**Franck.H** · 18/04/2007, 21h02

Je t'aurais bien dit une sémaphore mais je ne pense pas qu'on puisse les utiliser en dehors de l'utilisation des Threads, il faut sinon créer un système similaire mais sans Thread alors

Bien sûr, ce n'est qu'une idée en passant donc bloquer à la lecture pendant l'écriture et vice versa.

**v4np13** · 18/04/2007, 21h15

Dans le programme client, je n'utilise pas de threads. Inutile puisqu'on lance plusieurs fois le même prog. C'est dans le serveur que j'utilise les threads, mais je n'ai pas besoin de verrouillage là-bas. En regardant sur internet, j'ai essayé ceci (dans le client):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    // Ouvreture du fifo requête
    fdW = open("/tmp/requete", O_WRONLY);
    if (fdW == -1) {
      perror("Erreur d'ouverture du fichier serveur");
      return -1;
    }
 
    //Verrouillage
    verrou.l_type = F_RDLCK; //bloque l'écriture aux autres processus (donc autres clients)
    verrou.l_whence = 0;
    verrou.l_start = 0;
    verrou.l_len = 0;
 
    if (fcntl(fdW, F_SETLKW, &verrou)== -1){
      perror("Erreur de verrouillage");
    }
 
    //Envoi de la requête
    nbWrite = write(fdW, &requete, sizeof(requete));
    if (nbWrite < sizeof(requete)) {
      perror("Erreur d'écriture");
    }
 
    //Déverrouillage
    verrou.l_type = F_UNLCK; 
    if (fcntl(fdW, F_SETLKW, &verrou)== -1){
      perror("Erreur de deverrouillage");
    }
 
    close(fdW);

Mais là, il me dit: Erreur de verrouillage: Bad file descriptor

Pourtant après l'affichage de l'erreur, il m'affiche bien la réponse, donc la requête a bien été envoyé et traitée par le serveur ==> le descripteur est bon.

Je n'ai jamais fait de verrouillage avant, mais j'ai l'impression que ça vient du fait que ce soit pas un fichier, mais un fifo (pipe). Je me trompe?

**mchk0123** · 18/04/2007, 22h19

Juste comme ça histoire de dire ... les fifos (pipe) ça ne s'ouvre pas avec "popen()" au lieu de "open()" ?

**v4np13** · 18/04/2007, 22h34

popen retourne un FILE * et pour mes opérations de lecture/écriture, j'ai besoin d'un descripteur (int).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
FILE *popen(const char *command, const char *type);
 
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

**mchk0123** · 18/04/2007, 22h44

Pourquoi ne pas utiliser "fileno()" dans ce cas pour récupérer un handle int à partir du FILE* ?

**v4np13** · 18/04/2007, 22h55

Je viens d'essayer en remplaçant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fdW = open("/tmp/requete", O_WRONLY);

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fdW = fileno(popen("/tmp/requete","w"));

Et j'obtiens la même erreur bad file descriptor

Mais je pense que les deux bouts de codes sont équivalents.

**mchk0123** · 18/04/2007, 23h05

Je disais une bétise, pour ouvrir un tube il faut utiliser la fonction "pipe()".

**v4np13** · 18/04/2007, 23h17

La fonction pipe() ouvre un pipe anonyme, donc uniquement accessible dans un même programme et ne crée pas de fichier.

La fonction mkfifo() ouvre un pipe nommé (fifo) et crée en même temps un fichier de type pipe, c'est via ce fichier que je fais mes échanges entre les progs clients et le prog serveur.

Le fifo que j'utilise ci-dessus est créé dans le programme serveur qui est lancé en background avant le(s) client(s). Comme ceci dans serveur.c:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// Création du tube nommé du serveur
  if ((mkfifo("/tmp/requete", 00700) < 0) && (errno != EEXIST)) {
    perror("Erreur à la création du fifo");
    return -1;
  }

**mchk0123** · 18/04/2007, 23h29

Je suppose que tu as déjà vérifié que ton tube /tmp/requete est bien crée en faisant un "ls".

Je en connais pas trop Linux, mais est-ce que tu as vérifié s'il n'existe pas un flag à fctnl du type "SHARED_OPEN" ; car j'ai vraiment l'impression que c'est ton lock qui génère le "Bad Descriptor".

Au fait tu est bien sur que le "Bad Descriptor" à lieu lors de l'open ?

Enfin, sous Linux un tube est un fichier comme un autre, donc il devrait être possible de le locker (sauf indication contraire dans les pages de man).

**v4np13** · 18/04/2007, 23h36

ls /tmp/ j'ai testé mes fifos existent bien.

L'open se passe sans problème autrement il me retournerait une erreur avant le verrouillage.

La "nouvelle" fonction pour moi dans celle citées, c'est fnctl. Je ne la maîtrise pas, et je n'ai pas trouvé assez d'exemples de verrouillage, beaucoup de page man sur google mais pas assez d'exemples concrets (je préfère le concret pour comprendre).

**mchk0123** · 18/04/2007, 23h53

Ton pipe /tmp/request il est mono ou bi-directionnel ?

Car je viens de lire que les verrous en écriture sont exclusifs, donc pas possible de faire un lock à la fois sur le serveur et le client.

De plus sur AIX http://www.unet.univie.ac.at/aix/lib...trf1/fcntl.htm, visiblement fcntl ne peut pas être utilisé pour locker une fifo.

Peut-être que sur Linux c'est pareil. Dommage !

**v4np13** · 18/04/2007, 23h59

Voici des info sur le retour d'erreur:

EBADF fd is not an open file descriptor, or the command was F_SETLK or F_SETLKW and the file descriptor open mode doesn’t match with the type of lock requested.

Donc ce serait un problème de paramétrage du verrou...

Edit: le fifo en question est mono-directionnel: client ->serveur. J'en utilise d'autres pour les échanges du serveur vers le client

Pour le verrouillage, je me base sur ce pdf (chapitre 12).

**souviron34** · 19/04/2007, 01h20

d'après ce que tu dis du diagnostic et du man, ce serait pas qu'il faut rajouter un flag à O_WRONLY pour open ??

Je suis pas sur Linux, là, mais tu dois avoir un flag qui permet le SETFLK..

**v4np13** · 19/04/2007, 02h01

Je ne comprends pas bien ce que tu veux dire avec le O_WRONLY, j'ouvre le fifo comme cela pour le moment. Le problème doit venir du verrouillage.

Si je comprends bien ce que je fais, voici ce qui devrait se passer si on a 2 clients en même temps:

lancement du serveur en background, création du fifo (en boucle)
lancement du premier client: (en boucle)
- ouverture du fifo en écriture
- verrouillage de l'écriture pour les autres clients
- écriture de la requête
- déverrouillage
- fermeture du fifo
lancement du deuxième client: (en boucle)
- ouverture du fifo en écriture
- verrouillage de l'écriture pour les autres clients
- écriture de la requête
- déverrouillage
- fermeture du fifo
Quitte client 1
Quitte client 2
Kill du serveur manuellement par la suite

**mchk0123** · 22/04/2007, 09h49

Pour reprendre ce que dit souviron, si je traduit :

EBADF fd is not an open file descriptor, or the command was F_SETLK or F_SETLKW and the file descriptor open mode doesn’t match with the type of lock requested.

En Français, cela donne :

EBADF fd n'est pas un descripteur de fichier ouvert, ou la commande est F_SETLK ou F_SETLKW et le mode d'ouverture du descripteur ne correspond pas au type de verouillage demandé.

Autrement dit, ton fnctl plante car il manque un flag dans ton open ! CQFD.

**v4np13** · 22/04/2007, 11h05

C'est bon, j'ai trouvé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
   // Ouverture du fifo pour la requête
    fdW = open("/tmp/requete", O_WRONLY);
    if (fdW == -1) {
      perror("Erreur d'ouverture du fichier serveur");
      return -1;
    }
 
    //Verrouillage
    verrou.l_type = F_WRLCK;
    verrou.l_whence = SEEK_SET;
    verrou.l_start = 0;
    verrou.l_len = 0;
 
    if (fcntl(fdW, F_SETLK, &verrou)== -1){
      perror("Erreur de verrouillage");
      return -1;
    }
 
    //Envoi de la requete
    nbWrite = write(fdW, &requete, sizeof(requete));
    if (nbWrite < sizeof(requete)) {
      perror("Erreur d'écriture");
      return -1;
    }
 
    //Déverrouillage
    verrou.l_type = F_UNLCK; 
    if (fcntl(fdW, F_SETLKW, &verrou)== -1){
      perror("Erreur de deverrouillage");
      return -1;
    }
 
    close(fdW);

Ce qui était mauvais, c'est ceci: (ancien code)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
    //Verrouillage
    verrou.l_type = F_RDLCK; //bloque l'écriture aux autres processus (donc autres clients)
    verrou.l_whence = 0;
    verrou.l_start = 0;
    verrou.l_len = 0;
 
    if (fcntl(fdW, F_SETLKW, &verrou)== -1){
      perror("Erreur de verrouillage");
    }

Merci à vous pour votre aide

**mchk0123** · 22/04/2007, 17h16

N'oublie pas de flager le post avec le bouton

!

Verrouillage d'un fifo accessible par plusieurs prog

Réseau C

Discussions similaires

Partager

Partager