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

Diff for /rpl/src/interruptions.c between versions 1.140 and 1.141

version 1.140, 2014/03/15 11:04:21 version 1.141, 2014/04/23 13:43:01
Line 90  thread_surveillance_signaux(void *argume Line 90  thread_surveillance_signaux(void *argume
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
 #       if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
         if (sem_wait(&(*s_queue_signaux).signalisation) == 0)  
 #       else  
         if (sem_wait(semaphore_signalisation) == 0)          if (sem_wait(semaphore_signalisation) == 0)
 #       endif  
         {          {
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
             if (sem_wait(&(*s_queue_signaux).arret_signalisation) != 0)  
 #           else  
             if (sem_wait(semaphore_arret_signalisation) != 0)              if (sem_wait(semaphore_arret_signalisation) != 0)
 #           endif  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
             }              }
   
             if ((*s_queue_signaux).requete_arret == d_vrai)              if ((*s_queue_signaux).requete_arret == d_vrai)
             {              {
 #               if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
                 sem_post(&(*s_queue_signaux).arret_signalisation);  
                 sem_post(&(*s_queue_signaux).signalisation);  
 #               else  
                 sem_post(semaphore_arret_signalisation);                  sem_post(semaphore_arret_signalisation);
                 sem_post(semaphore_signalisation);                  sem_post(semaphore_signalisation);
 #               endif  
   
                 break;                  break;
             }              }
   
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
             sem_post(&(*s_queue_signaux).arret_signalisation);  
             sem_post(&(*s_queue_signaux).signalisation);  
 #           else  
             sem_post(semaphore_arret_signalisation);              sem_post(semaphore_arret_signalisation);
             sem_post(semaphore_signalisation);              sem_post(semaphore_signalisation);
 #           endif  
   
             nombre_signaux_envoyes = 0;              nombre_signaux_envoyes = 0;
             sched_yield();              sched_yield();
Line 133  thread_surveillance_signaux(void *argume Line 115  thread_surveillance_signaux(void *argume
             // affectée au processus courant pour vérifier s'il y a quelque              // affectée au processus courant pour vérifier s'il y a quelque
             // chose à traiter.              // chose à traiter.
   
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
             sem_wait(&(*s_queue_signaux).semaphore);  
 #           else  
             sem_wait(semaphore_queue_signaux);              sem_wait(semaphore_queue_signaux);
 #           endif  
   
             if ((*s_queue_signaux).pointeur_lecture !=              if ((*s_queue_signaux).pointeur_lecture !=
                     (*s_queue_signaux).pointeur_ecriture)                      (*s_queue_signaux).pointeur_ecriture)
Line 152  thread_surveillance_signaux(void *argume Line 130  thread_surveillance_signaux(void *argume
                 kill(getpid(), SIGALRM);                  kill(getpid(), SIGALRM);
             }              }
   
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
             sem_post(&(*s_queue_signaux).semaphore);  
 #           else  
             sem_post(semaphore_queue_signaux);              sem_post(semaphore_queue_signaux);
 #           endif  
   
             // Dans un second temps, on balaye toutes les queues de signaux              // Dans un second temps, on balaye toutes les queues de signaux
             // des threads du processus courant.              // des threads du processus courant.
Line 368  retrait_thread(struct_processus *s_etat_ Line 342  retrait_thread(struct_processus *s_etat_
             (*l_element_courant).donnee)).s_etat_processus)              (*l_element_courant).donnee)).s_etat_processus)
             .pointeur_signal_lecture)              .pointeur_signal_lecture)
     {      {
 #       if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
         while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)  
 #       else  
         while(sem_wait(semaphore_signalisation) != 0)          while(sem_wait(semaphore_signalisation) != 0)
 #       endif  
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
Line 2450  scrutation_interruptions(struct_processu Line 2420  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 (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)      if (sem_trywait(semaphore_queue_signaux) == 0)
         if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)  
 #   else  
         if (sem_trywait(semaphore_queue_signaux) == 0)  
 #   endif  
     {      {
         while((*s_queue_signaux).pointeur_lecture !=          while((*s_queue_signaux).pointeur_lecture !=
                 (*s_queue_signaux).pointeur_ecriture)                  (*s_queue_signaux).pointeur_ecriture)
Line 2470  scrutation_interruptions(struct_processu Line 2436  scrutation_interruptions(struct_processu
                     ((*s_queue_signaux).pointeur_lecture + 1)                      ((*s_queue_signaux).pointeur_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)              if (msync(s_queue_signaux, sizeof(s_queue_signaux),
             while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)                      MS_ASYNC | MS_INVALIDATE) != 0)
 #           else              {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             while(sem_wait(semaphore_signalisation) != 0)              while(sem_wait(semaphore_signalisation) != 0)
 #           endif  
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 2484  scrutation_interruptions(struct_processu Line 2453  scrutation_interruptions(struct_processu
             }              }
         }          }
   
 #       if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)          sem_post(semaphore_queue_signaux);
             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 2508  scrutation_interruptions(struct_processu Line 2473  scrutation_interruptions(struct_processu
                     ((*s_etat_processus).pointeur_signal_lecture + 1)                      ((*s_etat_processus).pointeur_signal_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
             while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)  
 #           else  
             while(sem_wait(semaphore_signalisation) != 0)              while(sem_wait(semaphore_signalisation) != 0)
 #           endif  
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 2528  scrutation_interruptions(struct_processu Line 2489  scrutation_interruptions(struct_processu
     return;      return;
 }  }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction renvoyant le nom du segment de mémoire partagée en fonction    Fonction renvoyant le nom du segment de mémoire partagée en fonction
Line 2600  envoi_signal_processus(pid_t pid, enum s Line 2562  envoi_signal_processus(pid_t pid, enum s
 #   endif  #   endif
   
 #   ifndef IPCS_SYSV  #   ifndef IPCS_SYSV
 #       ifdef SEMAPHORES_NOMMES          sem_t                       *semaphore;
             sem_t                   *semaphore;          sem_t                       *signalisation;
             sem_t                   *signalisation;  
 #       endif  
 #   else  #   else
           sem_t                       *semaphore;
           sem_t                       *signalisation;
 #       ifndef OS2  #       ifndef OS2
             int                     desc;              int                     desc;
             key_t                   clef;              key_t                   clef;
Line 2627  envoi_signal_processus(pid_t pid, enum s Line 2589  envoi_signal_processus(pid_t pid, enum s
             return(1);              return(1);
         }          }
   
 #       if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)          while(sem_wait(semaphore_queue_signaux) != 0)
             while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)  
 #       else  
             while(sem_wait(semaphore_queue_signaux) != 0)  
 #       endif  
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
Line 2648  envoi_signal_processus(pid_t pid, enum s Line 2606  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 (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)          if (msync(s_queue_signaux, sizeof(s_queue_signaux),
             if (sem_post(&((*s_queue_signaux).semaphore)) != 0)                  MS_ASYNC | MS_INVALIDATE) != 0)
 #       else  
             if (sem_post(semaphore_queue_signaux) != 0)  
 #       endif  
         {          {
             return(1);              return(1);
         }          }
   
 #       if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)          if (sem_post(semaphore_queue_signaux) != 0)
             if (sem_post(&((*s_queue_signaux).signalisation)) != 0)          {
 #       else              return(1);
             if (sem_post(semaphore_signalisation) != 0)          }
 #       endif  
           if (sem_post(semaphore_signalisation) != 0)
         {          {
             return(1);              return(1);
         }          }
Line 2733  envoi_signal_processus(pid_t pid, enum s Line 2689  envoi_signal_processus(pid_t pid, enum s
             }              }
 #       endif  #       endif
   
             // À ce moment, le segment de mémoire partagée est projeté          // À ce moment, le segment de mémoire partagée est projeté
             // dans l'espace du processus.          // dans l'espace du processus.
   
 #       ifndef IPCS_SYSV // POSIX          if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
 #           ifndef SEMAPHORES_NOMMES          {
                 while(sem_wait(&((*queue).semaphore)) != 0)              return(1);
                 {          }
                     if (errno != EINTR)  
                     {  
                         return(1);  
                     }  
                 }  
 #           else  
                 if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)  
                 {  
                     return(1);  
                 }  
   
                 if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))          if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
                         == SEM_FAILED)                  == SEM_FAILED)
                 {          {
                     return(1);              return(1);
                 }          }
   
                 while(sem_wait(semaphore) != 0)          while(sem_wait(semaphore) != 0)
                 {          {
                     if (errno != EINTR)              if (errno != EINTR)
                     {  
                         sem_close(semaphore);  
                         sem_close(signalisation);  
                         return(1);  
                     }  
                 }  
 #           endif  
 #       else // IPCS_SYSV  
             while(sem_wait(&((*queue).semaphore)) != 0)  
             {              {
                 if (errno != EINTR)                  sem_close(semaphore);
                 {                  sem_close(signalisation);
                     return(1);                  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 2783  envoi_signal_processus(pid_t pid, enum s Line 2719  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;
   
 #       ifndef IPCS_SYSV // POSIX          if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
 #           ifndef SEMAPHORES_NOMMES          {
                 if (sem_post(&((*queue).semaphore)) != 0)              sem_close(semaphore);
                 {              sem_close(signalisation);
                     return(1);              return(1);
                 }          }
   
                 if (sem_post(&((*queue).signalisation)) != 0)  
                 {  
                     return(1);  
                 }  
 #           else  
                 if (sem_post(semaphore) != 0)  
                 {  
                     sem_close(semaphore);  
                     sem_close(signalisation);  
                     return(1);  
                 }  
   
                 if (sem_close(semaphore) != 0)          if (sem_post(semaphore) != 0)
                 {          {
                     return(1);              sem_close(semaphore);
                 }              sem_close(signalisation);
               return(1);
           }
   
                 if (sem_post(signalisation) != 0)          if (sem_close(semaphore) != 0)
                 {          {
                     sem_close(signalisation);              return(1);
                     return(1);          }
                 }  
   
                 if (sem_close(signalisation) != 0)          if (sem_post(signalisation) != 0)
                 {          {
                     return(1);              sem_close(signalisation);
                 }              return(1);
           }
   
 #           endif          if (sem_close(signalisation) != 0)
           {
               return(1);
           }
   
   #       ifndef IPCS_SYSV // POSIX
             if (munmap(queue, sizeof(struct_queue_signaux)) != 0)              if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
             {              {
                 close(segment);                  close(segment);
                 return(1);                  return(1);
             }              }
 #       else // IPCS_SYSV  #       else // IPCS_SYSV
             if (sem_post(&((*queue).semaphore)) != 0)  
             {  
                 return(1);  
             }  
   
             if (sem_post(&((*queue).signalisation)) != 0)  
             {  
                 return(1);  
             }  
   
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if (shmdt(queue) != 0)                  if (shmdt(queue) != 0)
                 {                  {
Line 2910  envoi_signal_thread(pthread_t tid, enum Line 2830  envoi_signal_thread(pthread_t tid, enum
         return(1);          return(1);
     }      }
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     if (sem_post(&((*s_queue_signaux).signalisation)) != 0)  
     {  
         return(1);  
     }  
 #   else  
     if (sem_post(semaphore_signalisation) != 0)      if (sem_post(semaphore_signalisation) != 0)
     {      {
         return(1);          return(1);
     }      }
 #   endif  
   
     return(0);      return(0);
 }  }
Line 2938  envoi_signal_contexte(struct_processus * Line 2851  envoi_signal_contexte(struct_processus *
             % LONGUEUR_QUEUE_SIGNAUX;              % LONGUEUR_QUEUE_SIGNAUX;
     pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));      pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     if (sem_post(&((*s_queue_signaux).signalisation)) != 0)  
     {  
         return(1);  
     }  
 #   else  
     if (sem_post(semaphore_signalisation) != 0)      if (sem_post(semaphore_signalisation) != 0)
     {      {
         return(1);          return(1);
     }      }
 #   endif  
   
     return(0);      return(0);
 }  }
Line 3018  creation_queue_signaux(struct_processus Line 2924  creation_queue_signaux(struct_processus
   
         free(nom);          free(nom);
   
 #       ifndef SEMAPHORES_NOMMES          if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
             sem_init(&((*s_queue_signaux).semaphore), 1, 1);                  == SEM_FAILED)
             sem_init(&((*s_queue_signaux).signalisation), 1, 0);          {
             sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);              (*s_etat_processus).erreur_systeme = d_es_processus;
 #       else              return;
             if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))          }
                     == SEM_FAILED)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             if ((semaphore_signalisation = sem_init2(0, getpid(),          if ((semaphore_signalisation = sem_init2(0, getpid(),
                     SEM_SIGNALISATION)) == SEM_FAILED)                  SEM_SIGNALISATION)) == SEM_FAILED)
             {          {
                 (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;              return;
             }          }
   
             if ((semaphore_arret_signalisation = sem_init2(1, getpid(),          if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
                     SEM_ARRET_SIGNALISATION)) == SEM_FAILED)                  SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
             {          {
                 (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;              return;
             }          }
 #       endif  
   
         (*s_queue_signaux).pointeur_lecture = 0;          (*s_queue_signaux).pointeur_lecture = 0;
         (*s_queue_signaux).pointeur_ecriture = 0;          (*s_queue_signaux).pointeur_ecriture = 0;
Line 3111  creation_queue_signaux(struct_processus Line 3011  creation_queue_signaux(struct_processus
                 return;                  return;
             }              }
   
             sem_init(&((*s_queue_signaux).semaphore), 1, 1);              if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
             sem_init(&((*s_queue_signaux).signalisation), 1, 0);                      == SEM_FAILED)
             sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);              {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               if ((semaphore_signalisation = sem_init2(0, getpid(),
                       SEM_SIGNALISATION)) == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
                       SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
             (*s_queue_signaux).pointeur_lecture = 0;              (*s_queue_signaux).pointeur_lecture = 0;
             (*s_queue_signaux).pointeur_ecriture = 0;              (*s_queue_signaux).pointeur_ecriture = 0;
Line 3218  creation_queue_signaux(struct_processus Line 3135  creation_queue_signaux(struct_processus
 void  void
 liberation_queue_signaux(struct_processus *s_etat_processus)  liberation_queue_signaux(struct_processus *s_etat_processus)
 {  {
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     sem_wait(&((*s_queue_signaux).arret_signalisation));  
 #   else  
     sem_wait(semaphore_arret_signalisation);      sem_wait(semaphore_arret_signalisation);
 #   endif  
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)      msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
     sem_post(&((*s_queue_signaux).arret_signalisation));  
 #   else  
     sem_post(semaphore_arret_signalisation);      sem_post(semaphore_arret_signalisation);
 #   endif  
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     sem_post(&((*s_queue_signaux).signalisation));  
 #   else  
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
 #   endif  
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
Line 3252  liberation_queue_signaux(struct_processu Line 3158  liberation_queue_signaux(struct_processu
 #       else // OS/2  #       else // OS/2
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
 #       ifndef SEMAPHORES_NOMMES          sem_close(semaphore_queue_signaux);
             // Rien à faire, les sémaphores sont anonymes.          sem_close(semaphore_signalisation);
 #       else          sem_close(semaphore_arret_signalisation);
             sem_close(semaphore_queue_signaux);  
             sem_close(semaphore_signalisation);  
             sem_close(semaphore_arret_signalisation);  
 #       endif  
   
         if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
         {          {
Line 3293  destruction_queue_signaux(struct_process Line 3195  destruction_queue_signaux(struct_process
         unsigned char       *nom;          unsigned char       *nom;
 #   endif  #   endif
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     sem_wait(&((*s_queue_signaux).arret_signalisation));  
 #   else  
     sem_wait(semaphore_arret_signalisation);      sem_wait(semaphore_arret_signalisation);
 #   endif  
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
       msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     sem_post(&((*s_queue_signaux).arret_signalisation));  
 #   else  
     sem_post(semaphore_arret_signalisation);      sem_post(semaphore_arret_signalisation);
 #   endif  
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     sem_post(&((*s_queue_signaux).signalisation));  
 #   else  
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
 #   endif  
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
Line 3321  destruction_queue_signaux(struct_process Line 3211  destruction_queue_signaux(struct_process
 #       ifndef OS2  #       ifndef OS2
             // Il faut commencer par éliminer le sémaphore.              // Il faut commencer par éliminer le sémaphore.
   
             if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)              if (semctl((*semaphore_queue_signaux).sem, 0, IPC_RMID) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
             unlink((*s_queue_signaux).semaphore.path);              unlink((*semaphore_queue_signaux).path);
             free((*s_queue_signaux).semaphore.path);              free((*semaphore_queue_signaux).path);
   
             if (semctl((*s_queue_signaux).signalisation.sem, 0, IPC_RMID) == -1)              if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
             unlink((*s_queue_signaux).signalisation.path);              unlink((*semaphore_signalisation).path);
             free((*s_queue_signaux).signalisation.path);              free((*semaphore_signalisation).path);
   
             if (semctl((*s_queue_signaux).arret_signalisation.sem, 0, IPC_RMID)              if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1)
                     == -1)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
             unlink((*s_queue_signaux).arret_signalisation.path);              unlink((*semaphore_arret_signalisation).path);
             free((*s_queue_signaux).arret_signalisation.path);              free((*semaphore_arret_signalisation).path);
   
             if (shmdt(s_queue_signaux) == -1)              if (shmdt(s_queue_signaux) == -1)
             {              {
Line 3387  destruction_queue_signaux(struct_process Line 3276  destruction_queue_signaux(struct_process
             }              }
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
 #       ifndef SEMAPHORES_NOMMES          sem_close(semaphore_queue_signaux);
             sem_destroy(&((*s_queue_signaux).semaphore));          sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
             sem_destroy(&((*s_queue_signaux).signalisation));  
             sem_destroy(&((*s_queue_signaux).arret_signalisation));  
 #       else  
             sem_close(semaphore_queue_signaux);  
             sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);  
   
             sem_close(semaphore_signalisation);          sem_close(semaphore_signalisation);
             sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);          sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
   
             sem_close(semaphore_arret_signalisation);          sem_close(semaphore_arret_signalisation);
             sem_destroy2(semaphore_arret_signalisation, getpid(),          sem_destroy2(semaphore_arret_signalisation, getpid(),
                     SEM_ARRET_SIGNALISATION);                  SEM_ARRET_SIGNALISATION);
 #       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.140  
changed lines
  Added in v.1.141

CVSweb interface <joel.bertrand@systella.fr>