Problème sur le contrôle du point de reprise

**Estudiante** · 24/06/2008, 15h49

Bonjour à tous !!

Avant toute chose je tiens juste à dire que l'application concernée n'est autre qu'un logiciel de discussion permettant de faire dialoguer 3 personnes.

Je viens vous demander votre aide car je suis bloqué sur un bug qui apparaît après la seconde connexion au 2ème message et cela va en empirant...

Un scanf réagit sur une interruption mais le programme est bloqué (ceci doit être une histoire de boîte aux lettres). Cette boîte aux lettres est gérée par des interruptions et visiblement SIGUSR1 et SIGUSR2 y sont pour quelque chose.

Merci par avance pour l'aide que vous pourrez bien entendu me porter.

Code C :

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
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
 
#define NMAXCLI  10
 
#define SEMLISTE  0
#define SEMMESG   1
 
#define MESSAGE   0
#define PIDS      1
 
 
key_t   kCle[3] ;
int     iSemid ;
int     iShmid[2] ;
 
struct sembuf sSembufSemaphore ;
 
char *  pcSegMemMessage ;
char    pcMessage[80];
 
pid_t   ppidPids[NMAXCLI] ; /* limitation Ã  NMAXCLI clients */
pid_t * ppidSegMemPids ; 
 
int     iMonNumero ;        /* index dans la table des PIDs */
int     iLast ;             /* dernier arrivÃ© */
 
/* Handle de USR1 et USR2 pour rÃ©ception de connexion */
void vSIGHandle (int iSig, siginfo_t  * siginfo, void * ptr) {
  int i ;
  pid_t emetteur = siginfo->si_pid ;
 
  switch (iSig) {
 
  case SIGUSR1:
    /* P(liste) */
    sSembufSemaphore.sem_num =  SEMLISTE ;  /* sÃ©maphore SEMLISTE */
    sSembufSemaphore.sem_flg =  0 ;         /* blocant */
    sSembufSemaphore.sem_op  = -1 ;         /* P(s) */
    semop (iSemid,&sSembufSemaphore,1) ;    /* Appel P(s) */
 
    /* RÃ©cupÃ©ration infos */
    for (i=0;i<NMAXCLI;i++)  ppidPids[i] = ppidSegMemPids [i+1] ;
    iLast = ppidSegMemPids [0] ;
 
    /* V(liste) */
    sSembufSemaphore.sem_num =  SEMLISTE ;  /* sÃ©maphore SEMLISTE */
    sSembufSemaphore.sem_flg =  0 ;         /* blocant */
    sSembufSemaphore.sem_op  =  1 ;         /* V(s) */
    semop (iSemid,&sSembufSemaphore,1) ;    /* Appel V(s) */
 
    /* Affichage des infos */
    printf ("\nSysteme : connexion de %6d\n(%6d) Moi  : ",ppidPids[iLast],getpid()) ;
    fflush (stdout) ;
 
    break ;
 
  case SIGUSR2:
    /* P(SEMMESG) */
    sSembufSemaphore.sem_num =  SEMMESG ;     /* sÃ©maphore SEMMESG */
    sSembufSemaphore.sem_flg =  0 ;     /* blocant */
    sSembufSemaphore.sem_op  = -1 ;     /* P(s) */
    semop (iSemid,&sSembufSemaphore,1) ; /* Appel P(s) */
 
    /* PrÃ©lever le message */
    sprintf (pcMessage,"%s",pcSegMemMessage) ;
 
    /* V(SEMMESG) */
    sSembufSemaphore.sem_num =  SEMMESG ;     /* sÃ©maphore SEMMESG */
    sSembufSemaphore.sem_flg =  0 ;     /* blocant */
    sSembufSemaphore.sem_op  =  1 ;     /* V(s) */
    semop (iSemid,&sSembufSemaphore,1) ; /* Appel V(s) */
 
    /* Consommer le message */
    printf ("\n(%6d) Mesg : %s\n(%6d) Moi  : ",emetteur,pcMessage,getpid()) ;
    fflush (stdout) ;
 
    break ;
 
  case SIGINT:
    /* ... */
 
    exit (EXIT_SUCCESS) ;
    break ;
  }
}
 
void vConnexion (void) {
  int i ;
  /* PrÃ©paration des infos */
 
  /* P(liste) */
  sSembufSemaphore.sem_num =  SEMLISTE ;  /* sÃ©maphore SEMLISTE */
  sSembufSemaphore.sem_flg =  0 ;         /* blocant */
  sSembufSemaphore.sem_op  = -1 ;         /* P(s) */
  semop (iSemid,&sSembufSemaphore,1) ;    /* Appel P(s) */
 
  /* AccÃ¨s au segments de mÃ©moire partagÃ©e */
  /* rÃ©cupÃ©rations des pids */
  for (i=0;i<NMAXCLI;i++)  { 
    ppidPids[i] = ppidSegMemPids [i+1] ;
  }
 
  /* ajout de l'entrÃ©e table ppidPids */
  for (i=0;i<NMAXCLI;i++) {
    if (ppidPids[i]==-1) {
      iMonNumero = i ;
      ppidPids[i] = getpid() ;
      break ;
    }
  }
 
  /* MAJ table ppidSegMemPids */
  for (i=0;i<NMAXCLI;i++) ppidSegMemPids [i+1] = ppidPids[i] ;
  ppidSegMemPids [0] = iMonNumero ;
 
 
  /* Notification des autres processus */
  for (i=0;i<NMAXCLI;i++) {
    if (i==iMonNumero) continue ;
    if (ppidPids[i]==-1) continue ;
    kill (ppidPids[i],SIGUSR1) ;
  }
 
  /* V(liste) */
  sSembufSemaphore.sem_num =  SEMLISTE ;  /* sÃ©maphore SEMLISTE */
  sSembufSemaphore.sem_flg =  0 ;         /* blocant */
  sSembufSemaphore.sem_op  =  1 ;         /* V(s) */
  semop (iSemid,&sSembufSemaphore,1) ;    /* Appel V(s) */
 
}
 
int main (int argc, char * argv []) {
  int i ;
  struct sigaction action_SIG  ;
 
  /***********************************************************************/
  /* inititalisations IPC */
  kCle[0] = ftok (argv[1],0) ;
  kCle[1] = ftok (argv[1],1) ;
  kCle[2] = ftok (argv[1],2) ;
 
  /* SÃ©maphores */
  iSemid = semget (kCle[0],2,IPC_CREAT|0666) ;
 
  /* Segment mÃ©moire pour les messages */
  iShmid[MESSAGE] = shmget (kCle[1],(int)(256*sizeof(char)),IPC_CREAT|0666) ;
  pcSegMemMessage = (char *) shmat (iShmid[MESSAGE],NULL,0) ;
 
  /* Segment MÃ©moire pour les pid's */
  iShmid[PIDS] = shmget (kCle[2],(int)((NMAXCLI+1)*sizeof(pid_t)),IPC_CREAT|0666) ;
  ppidSegMemPids = (pid_t *) shmat (iShmid[PIDS],NULL,0) ;
 
  /* initialisation signaux */
  action_SIG.sa_sigaction =  vSIGHandle ;
  sigemptyset (&action_SIG.sa_mask) ;
  action_SIG.sa_flags=SA_SIGINFO ;
 
  sigaction (SIGUSR1, &action_SIG, NULL) ;
  sigaction (SIGUSR2, &action_SIG, NULL) ;
  sigaction (SIGINT, &action_SIG, NULL) ;
 
  /***********************************************************************/
  /* connexion */
  vConnexion () ;
 
 
  /***********************************************************************/
 
  /* boucle des messages */
  while (1) {
    printf ("(%6d) Moi  : ",getpid()) ; fflush (stdout) ;
    scanf  ("%s",pcMessage) ;
 
    /* P(SEMMESG) */
    sSembufSemaphore.sem_num =  SEMMESG ; /* sÃ©maphore SEMMESG */
    sSembufSemaphore.sem_flg =  0 ;       /* blocant */
    sSembufSemaphore.sem_op  = -1 ;       /* P(s) */
    semop (iSemid,&sSembufSemaphore,1) ;  /* Appel P(s) */
 
    /* DÃ©poser le message */
    sprintf (pcSegMemMessage,"%s",pcMessage) ;
      /* Notification des autres processus */
    for (i=0;i<NMAXCLI;i++) {
      if (i==iMonNumero) continue ;
      if (ppidPids[i]==-1) continue ;
      kill (ppidPids[i],SIGUSR2) ;
    }
 
    /* V(SEMMESG) */
    sSembufSemaphore.sem_num =  SEMMESG ; /* sÃ©maphore SEMMESG */
    sSembufSemaphore.sem_flg =  0 ;       /* blocant */
    sSembufSemaphore.sem_op  =  1 ;       /* V(s) */
    semop (iSemid,&sSembufSemaphore,1) ;  /* Appel V(s) */
  }
 
  return EXIT_SUCCESS ;
}

**gangsoleil** · 24/06/2008, 17h05

Bonjour,

Un handler de signal doit en faire le moins possible. Dans l'idéal, il positionne une variable à une valeur, et c'est tout.

Essayes de modifier ton handler pour qu'il soit réduit au minimum (ca devrait pas mal changer ton code), et dis-nous si cela change quelque chose ou non (n'oublie pas de reposter ton code si tu as des soucis).

**Estudiante** · 26/06/2008, 00h45

Je pense que la solution a été trouvé en rajoutant tout simplement "|SA_RESTART" à la ligne 164 à l'étape initialisation des signaux remplacer "*action_SIG.sa_flags=SA_SIGINFO ;*" par "*action_SIG.sa_flags=(SA_SIGINFO|SA_RESTART) ;*"

Donc voila pour ce problème qui se résout sans encombres.

Bonne soirée

Problème sur le contrôle du point de reprise

Linux

Discussions similaires

Partager

Partager