[BACK]Return to interruptions.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/interruptions.c between versions 1.71 and 1.78

version 1.71, 2011/09/15 19:30:38 version 1.78, 2011/09/20 09:51:43
Line 59  static volatile struct_liste_chainee_vol Line 59  static volatile struct_liste_chainee_vol
         = NULL;          = NULL;
 static volatile int                             code_erreur_gsl = 0;  static volatile int                             code_erreur_gsl = 0;
   
 static unsigned char                            *racine_segment;  unsigned char                                   *racine_segment;
   
 static pthread_mutex_t                          mutex_interruptions  static pthread_mutex_t                          mutex_interruptions
         = PTHREAD_MUTEX_INITIALIZER;          = PTHREAD_MUTEX_INITIALIZER;
Line 324  verrouillage_threads_concurrents(struct_ Line 324  verrouillage_threads_concurrents(struct_
                 == getpid()) && (pthread_equal((*((struct_thread *)                  == getpid()) && (pthread_equal((*((struct_thread *)
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
             if (pthread_mutex_lock(&((*(*((struct_thread *) (*l_element_courant)              while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
                     .donnee)).s_etat_processus).mutex_fork)) == -1)                      .donnee)).s_etat_processus).semaphore_fork)) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 351  deverrouillage_threads_concurrents(struc Line 351  deverrouillage_threads_concurrents(struc
                 == getpid()) && (pthread_equal((*((struct_thread *)                  == getpid()) && (pthread_equal((*((struct_thread *)
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
             if (pthread_mutex_unlock(&((*(*((struct_thread *)              if (sem_post(&((*(*((struct_thread *)
                     (*l_element_courant).donnee)).s_etat_processus)                      (*l_element_courant).donnee)).s_etat_processus)
                     .mutex_fork)) != 0)                      .semaphore_fork)) != 0)
             {              {
                 if (pthread_mutex_unlock(&mutex_liste_threads) != 0)                  if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                 {                  {
Line 1109  liberation_threads(struct_processus *s_e Line 1109  liberation_threads(struct_processus *s_e
   
             liberation_allocateur(s_etat_processus);              liberation_allocateur(s_etat_processus);
   
             pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));              sem_post(&((*s_etat_processus).semaphore_fork));
             pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));              sem_destroy(&((*s_etat_processus).semaphore_fork));
   
             liberation_contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              free(s_etat_processus);
Line 1298  verrouillage_gestionnaire_signaux(struct Line 1298  verrouillage_gestionnaire_signaux(struct
 {  {
     int         semaphore;      int         semaphore;
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
     {      {
         BUG(1, uprintf("Lock error !\n"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
Line 1308  verrouillage_gestionnaire_signaux(struct Line 1308  verrouillage_gestionnaire_signaux(struct
   
     if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)      if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1319  verrouillage_gestionnaire_signaux(struct Line 1319  verrouillage_gestionnaire_signaux(struct
     if (sem_post(semaphore_gestionnaires_signaux) == -1)      if (sem_post(semaphore_gestionnaires_signaux) == -1)
 #   endif  #   endif
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Lock error !\n"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
     }      }
Line 1330  verrouillage_gestionnaire_signaux(struct Line 1330  verrouillage_gestionnaire_signaux(struct
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)      if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
 #   endif  #   endif
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Lock error !\n"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
     }      }
   
     if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)      if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1352  verrouillage_gestionnaire_signaux(struct Line 1352  verrouillage_gestionnaire_signaux(struct
   
         if (pthread_mutex_lock(&mutex_liste_threads) != 0)          if (pthread_mutex_lock(&mutex_liste_threads) != 0)
         {          {
             pthread_mutex_lock(&((*s_etat_processus).mutex_fork));              sem_wait(&((*s_etat_processus).semaphore_fork));
             BUG(1, uprintf("Lock error !\n"));              BUG(1, uprintf("Lock error !\n"));
             return;              return;
         }          }
Line 1370  deverrouillage_gestionnaire_signaux(stru Line 1370  deverrouillage_gestionnaire_signaux(stru
   
     if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)      if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1381  deverrouillage_gestionnaire_signaux(stru Line 1381  deverrouillage_gestionnaire_signaux(stru
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)      if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
 #   endif  #   endif
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1394  deverrouillage_gestionnaire_signaux(stru Line 1394  deverrouillage_gestionnaire_signaux(stru
     {      {
         if (errno != EINTR)          if (errno != EINTR)
         {          {
             pthread_mutex_lock(&((*s_etat_processus).mutex_fork));              sem_wait(&((*s_etat_processus).semaphore_fork));
             BUG(1, uprintf("Unlock error !\n"));              BUG(1, uprintf("Unlock error !\n"));
             return;              return;
         }          }
Line 1402  deverrouillage_gestionnaire_signaux(stru Line 1402  deverrouillage_gestionnaire_signaux(stru
   
     if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)      if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          sem_wait(&((*s_etat_processus).semaphore_fork));
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
   
     if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
     {      {
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
Line 2251  scrutation_interruptions(struct_processu Line 2251  scrutation_interruptions(struct_processu
     // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à      // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
     // écrire.      // écrire.
   
     if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)  #   ifndef SEMAPHORES_NOMMES
           if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
   #   else
           if (sem_trywait(semaphore_queue_signaux) == 0)
   #   endif
     {      {
         if ((*s_queue_signaux).pointeur_lecture !=          if ((*s_queue_signaux).pointeur_lecture !=
                 (*s_queue_signaux).pointeur_ecriture)                  (*s_queue_signaux).pointeur_ecriture)
Line 2268  scrutation_interruptions(struct_processu Line 2272  scrutation_interruptions(struct_processu
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
         }          }
   
         sem_post(&((*s_queue_signaux).semaphore));  #       ifndef SEMAPHORES_NOMMES
               sem_post(&((*s_queue_signaux).semaphore));
   #       else
               sem_post(semaphore_queue_signaux);
   #       endif
     }      }
   
     // Interruptions qui arrivent depuis le groupe courant de threads.      // Interruptions qui arrivent depuis le groupe courant de threads.
Line 2364  envoi_signal_processus(pid_t pid, enum s Line 2372  envoi_signal_processus(pid_t pid, enum s
 {  {
     int                             segment;      int                             segment;
   
   #   ifndef IPCS_SYSV
   #       ifdef SEMAPHORES_NOMMES
               sem_t                   *semaphore;
   #       endif
   #   else
           int                         desc;
           key_t                       clef;
   #   endif
   
     struct_queue_signaux            *queue;      struct_queue_signaux            *queue;
   
     unsigned char                   *nom;      unsigned char                   *nom;
Line 2380  envoi_signal_processus(pid_t pid, enum s Line 2397  envoi_signal_processus(pid_t pid, enum s
             return(1);              return(1);
         }          }
   
         if (sem_wait(&((*s_queue_signaux).semaphore)) != 0)  #       ifndef SEMAPHORES_NOMMES
               while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               while(sem_wait(semaphore_queue_signaux) != 0)
   #       endif
         {          {
             return(1);              if (errno != EINTR)
               {
                   return(1);
               }
         }          }
   
         (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]          (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
Line 2394  envoi_signal_processus(pid_t pid, enum s Line 2418  envoi_signal_processus(pid_t pid, enum s
                 ((*s_queue_signaux).pointeur_ecriture + 1)                  ((*s_queue_signaux).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
         if (sem_post(&((*s_queue_signaux).semaphore)) != 0)  #       ifndef SEMAPHORES_NOMMES
               if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               if (sem_post(semaphore_queue_signaux) != 0)
   #       endif
         {          {
             return(1);              return(1);
         }          }
Line 2403  envoi_signal_processus(pid_t pid, enum s Line 2431  envoi_signal_processus(pid_t pid, enum s
     {      {
         // Le signal est envoyé depuis un processus distinct.          // Le signal est envoyé depuis un processus distinct.
   
         if ((nom = nom_segment(racine_segment, pid)) == NULL)  #       ifdef IPCS_SYSV
         {              if ((nom = nom_segment(racine_segment, pid)) == NULL)
             return(1);              {
         }                  return(1);
               }
   
               if ((desc = open(nom, O_RDWR)) == -1)
               {
                   free(nom);
                   return(1);
               }
   
               close(desc);
   
               if ((clef = ftok(nom, 1)) == -1)
               {
                   free(nom);
                   return(1);
               }
   
         if ((segment = shm_open(nom, O_RDWR, 0)) == -1)  
         {  
             free(nom);              free(nom);
             return(1);  
         }  
   
         free(nom);              if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1)
               {
                   return(1);
               }
   
         if ((queue = mmap(NULL, sizeof(struct_queue_signaux),              queue = shmat(segment, NULL, 0);
                 PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==  #       else // POSIX
                 MAP_FAILED)              if ((nom = nom_segment(racine_segment, pid)) == NULL)
         {              {
             close(segment);                  return(1);
             return(1);              }
         }  
   
         if (sem_wait(&((*queue).semaphore)) != 0)              if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
         {              {
             return(1);                  free(nom);
         }                  return(1);
               }
   
               free(nom);
   
               if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                       PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
                       MAP_FAILED)
               {
                   close(segment);
                   return(1);
               }
   #       endif
   
               // À ce moment, le segment de mémoire partagée est projeté
               // dans l'espace du processus.
   
   #       ifndef IPCS_SYSV // POSIX
   #           ifndef SEMAPHORES_NOMMES
                   while(sem_wait(&((*queue).semaphore)) != 0)
                   {
                       if (errno != EINTR)
                       {
                           return(1);
                       }
                   }
   #           else
                   if ((semaphore = sem_open2(pid)) == SEM_FAILED)
                   {
                       return(1);
                   }
   
                   while(sem_wait(semaphore) != 0)
                   {
                       if (errno != EINTR)
                       {
                           sem_close(semaphore);
                           return(1);
                       }
                   }
   #           endif
   #       else // IPCS_SYSV
               while(sem_wait(&((*queue).semaphore)) != 0)
               {
                   if (errno != EINTR)
                   {
                       return(1);
                   }
               }
   #       endif
   
         (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();          (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
         (*queue).queue[(*queue).pointeur_ecriture].signal = signal;          (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
Line 2435  envoi_signal_processus(pid_t pid, enum s Line 2525  envoi_signal_processus(pid_t pid, enum s
         (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)          (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
         if (sem_post(&((*queue).semaphore)) != 0)  #       ifndef IPCS_SYSV // POSIX
         {  #           ifndef SEMAPHORES_NOMMES
             return(1);                  if (sem_post(&((*queue).semaphore)) != 0)
         }                  {
                       return(1);
                   }
   #           else
                   if (sem_post(semaphore) != 0)
                   {
                       sem_close(semaphore);
                       return(1);
                   }
   
         if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                  if (sem_close(semaphore) != 0)
         {                  {
             close(segment);                      return(1);
             return(1);                  }
         }  #           endif
   
         close(segment);              if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
               {
                   close(segment);
                   return(1);
               }
   #       else // IPCS_SYSV
               if (sem_post(&((*queue).semaphore)) != 0)
               {
                   return(1);
               }
   
               if (shmdt(queue) != 0)
               {
                   return(1);
               }
   #       endif
     }      }
   
     return(0);      return(0);
Line 2593  creation_queue_signaux(struct_processus Line 2706  creation_queue_signaux(struct_processus
         }          }
   
         free(nom);          free(nom);
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
             sem_init(&((*s_queue_signaux).semaphore), 1, 1);              sem_init(&((*s_queue_signaux).semaphore), 1, 1);
 #       else  #       else
             (*s_queue_signaux).semaphore = sem_init2(0,              if ((semaphore_queue_signaux = sem_init2(1, getpid()))
                     sem_gestionnaires_signaux);                      == SEM_FAILED)
   
             if ((*s_queue_signaux).semaphore == SEM_FAILED)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 2614  creation_queue_signaux(struct_processus Line 2726  creation_queue_signaux(struct_processus
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #   else // SystemV  #   else // IPCS_SYSV
 #       ifndef OS2  #       ifndef OS2
             file                            *desc;              int                             segment;
               int                             support;
   
             key_t                           clef;              key_t                           clef;
   
             // Création d'un segment de données associé au PID du processus              // Création d'un segment de données associé au PID du processus
             // courant              // courant
   
             chemin = (*s_etat_processus).chemin_fichiers_temporaires;  
   
             if ((nom = nom_segment((*s_etat_processus)              if ((nom = nom_segment((*s_etat_processus)
                     .chemin_fichiers_temporaires, getpid())) == NULL)                      .chemin_fichiers_temporaires, getpid())) == NULL)
             {              {
Line 2632  creation_queue_signaux(struct_processus Line 2743  creation_queue_signaux(struct_processus
                 return;                  return;
             }              }
   
             if ((desc = fopen(nom, "w")) == NULL)              if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL,
                       S_IRUSR | S_IWUSR)) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                  (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                 return;                  return;
             }              }
   
             fclose(desc);  
   
             if ((clef = ftok(nom, 1)) == -1)              if ((clef = ftok(nom, 1)) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
               close(support);
             free(nom);              free(nom);
   
             if ((segment = shmget(clef,              if ((segment = shmget(clef, sizeof(struct_queue_signaux),
                     nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),  
                     IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)                      IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             fifos = shmat(segment, NULL, 0);              s_queue_signaux = shmat(segment, NULL, 0);
               f_queue_signaux = segment;
   
             if (((void *) fifos) == ((void *) -1))              if (((void *) s_queue_signaux) == ((void *) -1))
             {              {
                 if (shmctl(segment, IPC_RMID, 0) == -1)                  if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 2670  creation_queue_signaux(struct_processus Line 2781  creation_queue_signaux(struct_processus
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
 #       else // OS/2  #       else // OS/2
             if ((nom = nom_segment(NULL, getpid())) == NULL)              if ((nom = nom_segment(NULL, getpid())) == NULL)
             {              {
Line 2713  liberation_queue_signaux(struct_processu Line 2828  liberation_queue_signaux(struct_processu
 {  {
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
               if (shmdt(s_queue_signaux) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
 #       else // OS/2  #       else // OS/2
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
         sem_close(&((*s_queue_signaux).semaphore));  #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
   #       else
               sem_close(semaphore_queue_signaux);
   #       endif
   
         if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
         {          {
Line 2751  destruction_queue_signaux(struct_process Line 2875  destruction_queue_signaux(struct_process
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
             if (shmdt(fifos) == -1)              // Il faut commencer par éliminer le sémaphore.
   
               if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               unlink((*s_queue_signaux).semaphore.path);
   
               if (shmdt(s_queue_signaux) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             if (shmctl(segment, IPC_RMID, 0) == -1)              if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 2770  destruction_queue_signaux(struct_process Line 2904  destruction_queue_signaux(struct_process
                 return;                  return;
             }              }
   
             // FERMER LE FICHIER  
   
             unlink(nom);              unlink(nom);
             free(nom);              free(nom);
 #       else  #       else
Line 2785  destruction_queue_signaux(struct_process Line 2917  destruction_queue_signaux(struct_process
   
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
         sem_close(&((*s_queue_signaux).semaphore));  #       ifndef SEMAPHORES_NOMMES
         sem_destroy(&((*s_queue_signaux).semaphore));              sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   #       else
               sem_close(semaphore_queue_signaux);
               sem_destroy2(semaphore_queue_signaux, getpid());
   #       endif
   
         if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
         {          {
Removed from v.1.71  
changed lines
  Added in v.1.78

CVSweb interface <joel.bertrand@systella.fr>