[Debutant] Lecture non destructrice !
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:
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 ??
