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

Diff for /rpl/src/interruptions.c between versions 1.133 and 1.134

version 1.133, 2013/05/28 22:09:55 version 1.134, 2013/05/30 09:41:41
Line 175  thread_surveillance_signaux(void *argume Line 175  thread_surveillance_signaux(void *argume
                 {                  {
                     pthread_mutex_lock(&((*(*((struct_thread *)                      pthread_mutex_lock(&((*(*((struct_thread *)
                             (*l_element_courant).donnee)).s_etat_processus)                              (*l_element_courant).donnee)).s_etat_processus)
                             .mutex_interruptions));                              .mutex_signaux));
   
                     if ((*(*((struct_thread *) (*l_element_courant).donnee))                      if ((*(*((struct_thread *) (*l_element_courant).donnee))
                             .s_etat_processus).pointeur_signal_ecriture !=                              .s_etat_processus).pointeur_signal_ecriture !=
Line 190  thread_surveillance_signaux(void *argume Line 190  thread_surveillance_signaux(void *argume
   
                     pthread_mutex_unlock(&((*(*((struct_thread *)                      pthread_mutex_unlock(&((*(*((struct_thread *)
                             (*l_element_courant).donnee)).s_etat_processus)                              (*l_element_courant).donnee)).s_etat_processus)
                             .mutex_interruptions));                              .mutex_signaux));
                 }                  }
   
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
Line 1488  recherche_thread_principal(pid_t pid) Line 1488  recherche_thread_principal(pid_t pid)
 static inline void  static inline void
 verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)  verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
 {  {
     int         semaphore;  
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #   else  #   else
Line 1500  verrouillage_gestionnaire_signaux(struct Line 1498  verrouillage_gestionnaire_signaux(struct
         return;          return;
     }      }
   
     // Il faut respecteur l'atomicité des deux opérations suivantes !  
   
     if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Unlock error !\n"));  
         return;  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     if (sem_post(&semaphore_gestionnaires_signaux) == -1)      if (sem_post(&semaphore_gestionnaires_signaux) == -1)
 #   else  #   else
Line 1528  verrouillage_gestionnaire_signaux(struct Line 1513  verrouillage_gestionnaire_signaux(struct
         return;          return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  
     if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)  
 #   else  
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)  
 #   endif  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Lock error !\n"));  
         return;  
     }  
   
     if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Unlock error !\n"));  
         return;  
     }  
   
 /*  
     if (semaphore == 1)  
     {  
         // Le semaphore ne peut être pris par le thread qui a appelé  
         // le gestionnaire de signal car le signal est bloqué par ce thread  
         // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que  
         // par un thread concurrent. On essaye donc de le bloquer jusqu'à  
         // ce que ce soit possible.  
   
         if (pthread_mutex_lock(&mutex_liste_threads) != 0)  
         {  
 #           ifndef SEMAPHORES_NOMMES  
             sem_wait(&((*s_etat_processus).semaphore_fork));  
 #           else  
             sem_wait((*s_etat_processus).semaphore_fork);  
 #           endif  
             BUG(1, uprintf("Lock error !\n"));  
             return;  
         }  
     }  
     */  
   
     return;      return;
 }  }
   
 static inline void  static inline void
 deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)  deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
 {  {
     int         semaphore;  
   
     // Il faut respecteur l'atomicité des deux opérations suivantes !  
   
     if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Unlock error !\n"));  
         return;  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  
     if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)  
 #   else  
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)  
 #   endif  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Unlock error !\n"));  
         return;  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_gestionnaires_signaux) == -1)  
 #   else  
     while(sem_wait(semaphore_gestionnaires_signaux) == -1)  
 #   endif  
     {  
         if (errno != EINTR)  
         {  
 #           ifndef SEMAPHORES_NOMMES  
             sem_wait(&((*s_etat_processus).semaphore_fork));  
 #           else  
             sem_wait((*s_etat_processus).semaphore_fork);  
 #           endif  
             BUG(1, uprintf("Unlock error !\n"));  
             return;  
         }  
     }  
   
     if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)  
     {  
 #       ifndef SEMAPHORES_NOMMES  
         sem_wait(&((*s_etat_processus).semaphore_fork));  
 #       else  
         sem_wait((*s_etat_processus).semaphore_fork);  
 #       endif  
         BUG(1, uprintf("Unlock error !\n"));  
         return;  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #   else  #   else
Line 1654  deverrouillage_gestionnaire_signaux(stru Line 1532  deverrouillage_gestionnaire_signaux(stru
         }          }
     }      }
   
     /*  
     if (semaphore == 1)  
     {  
         if (pthread_mutex_unlock(&mutex_liste_threads) != 0)  
         {  
             BUG(1, uprintf("Unlock error !\n"));  
             return;  
         }  
     }  
     */  
   
     return;      return;
 }  }
   
Line 2626  scrutation_interruptions(struct_processu Line 2493  scrutation_interruptions(struct_processu
   
     // Interruptions qui arrivent depuis le groupe courant de threads.      // Interruptions qui arrivent depuis le groupe courant de threads.
   
     if (pthread_mutex_trylock(&((*s_etat_processus).mutex_interruptions)) == 0)      if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)
     {      {
         while((*s_etat_processus).pointeur_signal_lecture !=          while((*s_etat_processus).pointeur_signal_lecture !=
                 (*s_etat_processus).pointeur_signal_ecriture)                  (*s_etat_processus).pointeur_signal_ecriture)
Line 2655  scrutation_interruptions(struct_processu Line 2522  scrutation_interruptions(struct_processu
             }              }
         }          }
   
         pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions));          pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));
     }      }
   
     return;      return;
Line 3020  envoi_signal_thread(pthread_t tid, enum Line 2887  envoi_signal_thread(pthread_t tid, enum
     s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))      s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
             .s_etat_processus;              .s_etat_processus;
   
     if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0)      if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
     {      {
         pthread_mutex_unlock(&mutex_liste_threads);          pthread_mutex_unlock(&mutex_liste_threads);
         return(1);          return(1);
Line 3032  envoi_signal_thread(pthread_t tid, enum Line 2899  envoi_signal_thread(pthread_t tid, enum
             ((*s_etat_processus).pointeur_signal_ecriture + 1)              ((*s_etat_processus).pointeur_signal_ecriture + 1)
             % LONGUEUR_QUEUE_SIGNAUX;              % LONGUEUR_QUEUE_SIGNAUX;
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) != 0)      if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0)
     {      {
         pthread_mutex_unlock(&mutex_liste_threads);          pthread_mutex_unlock(&mutex_liste_threads);
         return(1);          return(1);
Line 3062  int Line 2929  int
 envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,  envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
         enum signaux_rpl signal)          enum signaux_rpl signal)
 {  {
     pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_interruptions));      pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_signaux));
     (*s_etat_processus_a_signaler).signaux_en_queue      (*s_etat_processus_a_signaler).signaux_en_queue
             [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =              [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =
             signal;              signal;
     (*s_etat_processus_a_signaler).pointeur_signal_ecriture =      (*s_etat_processus_a_signaler).pointeur_signal_ecriture =
             ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)              ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)
             % LONGUEUR_QUEUE_SIGNAUX;              % LONGUEUR_QUEUE_SIGNAUX;
     pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_interruptions));      pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
     if (sem_post(&((*s_queue_signaux).signalisation)) != 0)      if (sem_post(&((*s_queue_signaux).signalisation)) != 0)
Removed from v.1.133  
changed lines
  Added in v.1.134

CVSweb interface <joel.bertrand@systella.fr>