[Debutant] Lecture non destructrice !

**Treuze** · 17/05/2006, 21h09

Bonjour ,

Comme vous pourrez le voir , j ai une boucle infinie ds mon programme ...
Mais celle ci contient des instructions de lecture ds un tube ce qui est cense bloquer la boucle

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <signal.h>
#include <errno.h>
#include <sys/wait.h>
#include <unistd.h>
#include <signal.h>
#include <sys/select.h>
#include <semaphore.h>
#include <pthread.h>
 
#define CLE_IPCMSG 123
#define CLE_SEM_ATELIER 456
#define CLE_SEM_SALLE_ATTENTE 789
 
#define LECTURE 0
#define ECRITURE 1
 
struct message{
  long mtype;
  int pid;  
};
 
pid_t pidaccueil;
 
int msgid;
 
int pipe_accueil_mecano[2];
int pipe_mecano_client[2];
int pipe_client_accueil[2];
 
int sem_salle_attente;
int sem_atelier;
 
pthread_mutex_t client_thread;
 
int processusaccueil();
int processusclient();
void processusmecano();
int traitanterreur();
int traitanterreurmsg(){}
 
int main(void)
{
  int i;    
  if ((msgid = msgget(CLE_IPCMSG,IPC_CREAT | 0660)) == -1)
        perror("Erreur lors de la creation de la file de message :\n");
 
  /*if ((sem_atelier = semget((key_t)CLE_SEM_ATELIER,IPC_CREAT|IPC_EXCL)) == -1)
        traitanterreur(1);
  if ((sem_salle_attente = semget((key_t)CLE_SEM_SALLE_ATTENTE,IPC_CREAT|IPC_EXCL)) == -1)
    traitanterreur(1);*/
  pthread_mutex_init(&client_thread,NULL);
  if (pipe(pipe_accueil_mecano) == -1)
        traitanterreur(2);
  if (pipe(pipe_mecano_client) == -1)
        traitanterreur(3);
  if (pipe(pipe_client_accueil) == -1)
    traitanterreur(6);
 
  printf("Bienvenue au garage !!!\n");
  switch(fork())
    {
    case -1 :
      traitanterreur(4);
      break;
 
    case  0 :
      processusaccueil();
      break;
    }
 
for (i = 0;i<=2;i++){
  switch(fork())
    {
    case -1 :
      traitanterreur(6);
      break;
 
    case 0 :
      processusclient();
      break;
    }
  }
  switch(fork())
   {
    case -1 : 
      traitanterreur(7);
      break;
 
    case 0 :
      processusmecano();
      break;
   }
 
  exit(EXIT_SUCCESS);
}
 
int processusaccueil()
{
 
      struct message client;
 
      int taille_message = sizeof(client) - sizeof(long);
      int pidclient;
      int nbreclient;
      nbreclient = 0;
      pidaccueil = getpid();
 
      while(1){    
 
    if ((close(pipe_client_accueil[ECRITURE])) == -1){
        perror("close pipe client accueil ecriture");
            exit(1);
        }
 
      if ((read(pipe_client_accueil[LECTURE],&pidclient,sizeof(int))) == -1){
        perror("read pipe client accueil");
        }
 
        printf("accueil a  lu :%d \n",pidclient);
 
      if ((close(pipe_client_accueil[LECTURE])) == -1){
        perror("close pipe client accueil lecture");
        exit(1);
            }
 
    nbreclient++;
 
      if (nbreclient <=  1){
 
        if ((close(pipe_accueil_mecano[LECTURE])) == -1){
            perror("close pipe acceuil mecano lecture");
            exit(1);
            }
 
        if ((write(pipe_accueil_mecano[ECRITURE],&pidclient,sizeof(int))) == -1){
            perror("write pipe accueil mecano");
            exit(1);
            }
 
        printf("Envoi du client au mecano\n");
 
        if ((close(pipe_accueil_mecano[ECRITURE])) == -1){
            perror("close pipe accueil mecano ecriture");
            exit(1);
            } 
 
        printf("Client envoye au mecano\n");
                nbreclient--;
        }
 
      else {
        client.pid = pidclient;
        msgsnd(msgid,&client,taille_message,IPC_NOWAIT);
        }
    }
  exit (0) ;
}
 
int processusclient()
{
 
  int pid;
  pid = getpid();
  sleep(5);
  if ((close (pipe_client_accueil[LECTURE])) == -1){
    perror(" close pipe client accueil lecture");
    exit(1);
    }
 
  if ((write (pipe_client_accueil[ECRITURE],&pid,sizeof(int))) == -1){
    perror("write client accueil");
    exit(1);
    }
 
  printf("client a fini d ecrire\n");
 
  if ((close (pipe_client_accueil[ECRITURE])) == -1){
    perror("close pipe client accueil ecriture");
    exit(1);
    }
 
 
 
  exit(0) ;
}
 
void processusmecano(){
 
  int pidclient;
 
  while(1){
      if ((close (pipe_accueil_mecano[ECRITURE])) == -1 ){
        perror("close pipe accueil mecano ecriture");
        exit(2);
    }
 
      if ((read (pipe_accueil_mecano[LECTURE],&pidclient,sizeof(int))) == -1){
        perror("read pipe accueil mecano");
        exit(2);
    }
 
      if ((close (pipe_accueil_mecano[LECTURE])) == -1){
        perror("close pipe accueil mecano lecture");
        exit(2);
    }
 
      printf("Voiture en reparation\n");
      sleep(5);
      printf("Voiture repare\n");}
  exit(0);
}
 
int traitanterreur(int erreur)
{
  switch(erreur){
  case 1 :
    printf("Erreur lors de la creation de la semaphore\n");
    break;
  case 2 :
    printf("Erreur lors de la creation du pipe accueil -> mecano\n");
    break;
  case 3 :
    printf("Erreur lors de la creation du pipe mecano -> client\n");
    break;
  case 4 :
    printf("Erreur de la creation du processus accueil\n");
    break;
  case 5 :
    printf("Erreur lors de la def. du signal accueil\n");
    break;
  }
  exit(erreur);
}

En theroie , ca devait se passser comme ca :
le processus pere cree 2 fils clients
le premier envoie son pid au proc. acceuil
celui ci envoie au garage
le garage repare la voiture

Pdt ce temps :
le 2eme client envoie son pid a l accueil
l accueil finit sa boucle et lit le 2eme pid
...

A la place j ai une sortie qui ressemble a :
accueil a lu 12432
envoi du client au mecano
client envoye
et ca recommence a l infini!

Normalement le pid du premier client aurait du etre efface alros pk elle est relu ??

**D[r]eadLock** · 18/05/2006, 08h12

Salut,

Tu ne teste pas si le read a bien marché et en plus tu ne "réinitialise" pas la valeur de ton PID lu, du coup, même si la lecture foire, tu continue avec la même valeur !!

Ensuite, tu ferme le pipe, alors que tu es a l'interieur d'une boucle (tes while(1)), comment espère-tu lire quelque-chose de "valable" sur un pipe fermé

?

Rq: si tu veux débugger plus facilement, tu peux mettre le PID du processus qui écrit (et les variables qu'il utilise) à chaque fois

Code :

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

printf("[%d] Voiture reparée %d\n", getpid(), pidclient)

Bon courrage...

**Treuze** · 18/05/2006, 14h20

Sur tes conseils j ai rajoute des tests apres chaque appels systemes et j obtiens des erreus lors de la fermeture des tubes client accueil[ecriture] et accueil mecano [ecriture]
Perror me dit pour ces 2 tubes : bad file descriptor

Qu est ce ca veut dire ???

Je ne vois pas ce que tu veux dire par reinitialise la valeur du pid...

**D[r]eadLock** · 18/05/2006, 14h45

Dans tes boucles (infinies!) tu ferme plusieurs fois le meme file descriptor ! Ca ne te choque pas de "fermer" plusieurs fois le tube ??

Et pour renitialiser c'etait juste de le mettre par exemple a 0 ou -1 avant d'appeler pour que tu t'appercoive que le "read" ne lisait rien.

**Treuze** · 18/05/2006, 15h23

Je pensais que la fonction read ou write ouvrait le descripteur de fichier...

Dans ce cas comment faire pour reeouvrir le descripteur de fichier ?

J ai regarde la fonction open mais c pour ouvrir un fichier et non un descripteur de fichier

**Treuze** · 18/05/2006, 18h22

Bon j ai enleve tous les close() et ca marche ... Apres je me demande si tres propre tous ca...

[Debutant] Lecture non destructrice !

C

Discussions similaires

Partager

Partager