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

Diff for /rpl/src/interruptions.c between versions 1.201 and 1.212

version 1.201, 2019/02/09 13:36:42 version 1.212, 2025/04/15 10:17:56
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.31    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2019 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 70  thread_surveillance_signaux(void *argume Line 70  thread_surveillance_signaux(void *argume
     // nécessaires dans la queue des signaux et incrémentent le sémaphore.      // nécessaires dans la queue des signaux et incrémentent le sémaphore.
     // Le sémaphore est décrémenté lorsque le signal est effectivement traité.      // Le sémaphore est décrémenté lorsque le signal est effectivement traité.
   
     int                                     ios;  
     int                                     nombre_signaux_envoyes;      int                                     nombre_signaux_envoyes;
   
     struct_processus                        *s_etat_processus;      struct_processus                        *s_etat_processus;
Line 93  thread_surveillance_signaux(void *argume Line 92  thread_surveillance_signaux(void *argume
   
         if (sem_wait(semaphore_signalisation) == 0)          if (sem_wait(semaphore_signalisation) == 0)
         {          {
             while((ios = sem_wait(semaphore_arret_signalisation)) != 0)              while(sem_wait(semaphore_arret_signalisation) != 0)
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 117  thread_surveillance_signaux(void *argume Line 116  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.
   
             while((ios = sem_wait(semaphore_queue_signaux)) != 0)              while(sem_wait(semaphore_queue_signaux) != 0)
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 298  insertion_thread_surveillance(struct_pro Line 297  insertion_thread_surveillance(struct_pro
         return;          return;
     }      }
   
     if (pthread_mutex_lock(&mutex_liste_threads) != 0)      if (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 313  insertion_thread_surveillance(struct_pro Line 312  insertion_thread_surveillance(struct_pro
   
     liste_threads_surveillance = l_nouvel_objet;      liste_threads_surveillance = l_nouvel_objet;
   
     if (pthread_mutex_unlock(&mutex_liste_threads) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 436  retrait_thread_surveillance(struct_proce Line 435  retrait_thread_surveillance(struct_proce
     volatile struct_liste_chainee_volatile  *l_element_precedent;      volatile struct_liste_chainee_volatile  *l_element_precedent;
     volatile struct_liste_chainee_volatile  *l_element_courant;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
     if (pthread_mutex_lock(&mutex_liste_threads) != 0)      if (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 458  retrait_thread_surveillance(struct_proce Line 457  retrait_thread_surveillance(struct_proce
   
     if (l_element_courant == NULL)      if (l_element_courant == NULL)
     {      {
         pthread_mutex_unlock(&mutex_liste_threads);          pthread_mutex_unlock(&mutex_liste_threads_surveillance);
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
Line 475  retrait_thread_surveillance(struct_proce Line 474  retrait_thread_surveillance(struct_proce
     if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))      if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
             != 0)              != 0)
     {      {
         pthread_mutex_unlock(&mutex_liste_threads);          pthread_mutex_unlock(&mutex_liste_threads_surveillance);
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
Line 491  retrait_thread_surveillance(struct_proce Line 490  retrait_thread_surveillance(struct_proce
         if (pthread_mutex_unlock(&((*s_argument_thread)          if (pthread_mutex_unlock(&((*s_argument_thread)
                 .mutex_nombre_references)) != 0)                  .mutex_nombre_references)) != 0)
         {          {
             pthread_mutex_unlock(&mutex_liste_threads);              pthread_mutex_unlock(&mutex_liste_threads_surveillance);
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
Line 505  retrait_thread_surveillance(struct_proce Line 504  retrait_thread_surveillance(struct_proce
         if (pthread_mutex_unlock(&((*s_argument_thread)          if (pthread_mutex_unlock(&((*s_argument_thread)
                 .mutex_nombre_references)) != 0)                  .mutex_nombre_references)) != 0)
         {          {
             pthread_mutex_unlock(&mutex_liste_threads);              pthread_mutex_unlock(&mutex_liste_threads_surveillance);
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
     }      }
   
     if (pthread_mutex_unlock(&mutex_liste_threads) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 1381  liberation_threads(struct_processus *s_e Line 1380  liberation_threads(struct_processus *s_e
   
     liste_threads = NULL;      liste_threads = NULL;
   
       if (pthread_mutex_unlock(&mutex_liste_threads) == -1)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (pthread_mutex_lock(&mutex_liste_threads_surveillance) == -1)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     l_element_courant = liste_threads_surveillance;      l_element_courant = liste_threads_surveillance;
   
     while(l_element_courant != NULL)      while(l_element_courant != NULL)
Line 1392  liberation_threads(struct_processus *s_e Line 1403  liberation_threads(struct_processus *s_e
                 != 0)                  != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             pthread_mutex_unlock(&mutex_liste_threads);              pthread_mutex_unlock(&mutex_liste_threads_surveillance);
             return;              return;
         }          }
   
Line 1415  liberation_threads(struct_processus *s_e Line 1426  liberation_threads(struct_processus *s_e
                     .mutex_nombre_references)) != 0)                      .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 pthread_mutex_unlock(&mutex_liste_threads);                  pthread_mutex_unlock(&mutex_liste_threads_surveillance);
                 return;                  return;
             }              }
   
Line 1439  liberation_threads(struct_processus *s_e Line 1450  liberation_threads(struct_processus *s_e
                     .mutex_nombre_references)) != 0)                      .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 pthread_mutex_unlock(&mutex_liste_threads);                  pthread_mutex_unlock(&mutex_liste_threads_surveillance);
                 return;                  return;
             }              }
         }          }
Line 1451  liberation_threads(struct_processus *s_e Line 1462  liberation_threads(struct_processus *s_e
   
     liste_threads_surveillance = NULL;      liste_threads_surveillance = NULL;
   
     if (pthread_mutex_unlock(&mutex_liste_threads) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 1559  recherche_thread_principal(pid_t pid) Line 1570  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)
 {  {
       return;
   
 #   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 1575  verrouillage_gestionnaire_signaux(struct Line 1588  verrouillage_gestionnaire_signaux(struct
 static inline void  static inline void
 deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)  deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
 {  {
       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 2575  scrutation_interruptions(struct_processu Line 2590  scrutation_interruptions(struct_processu
             // Il y a un signal en attente dans le segment partagé. On le              // Il y a un signal en attente dans le segment partagé. On le
             // traite.              // traite.
   
               if (pthread_mutex_lock(&mutex_liste_threads) != 0)
               {
                   return;
               }
   
             envoi_interruptions(s_etat_processus,              envoi_interruptions(s_etat_processus,
                     (*s_queue_signaux).queue[(*s_queue_signaux)                      (*s_queue_signaux).queue[(*s_queue_signaux)
                     .pointeur_lecture].signal, (*s_queue_signaux).queue                      .pointeur_lecture].signal, (*s_queue_signaux).queue
Line 2593  scrutation_interruptions(struct_processu Line 2613  scrutation_interruptions(struct_processu
             }              }
 #           endif  #           endif
   
               if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
               {
                   return;
               }
   
             while(sem_wait(semaphore_signalisation) != 0)              while(sem_wait(semaphore_signalisation) != 0)
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 3304  envoi_signal_contexte(struct_processus * Line 3329  envoi_signal_contexte(struct_processus *
     (*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_kill((*s_etat_processus_a_signaler).tid, SIGUSR2);
     pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));      pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));
   
     if (sem_post(semaphore_signalisation) != 0)      if (sem_post(semaphore_signalisation) != 0)
Line 3530  creation_queue_signaux(struct_processus Line 3556  creation_queue_signaux(struct_processus
   
             sys_free(nom);              sys_free(nom);
   
             sem_init(&((*s_queue_signaux).semaphore), 1, 1);              if (sem_init(&((*s_queue_signaux).semaphore), 1, 1) != 0)
             sem_init(&((*s_queue_signaux).signalisation), 1, 0);              {
             sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1);                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (sem_init(&((*s_queue_signaux).signalisation), 1, 0) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   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;
Removed from v.1.201  
changed lines
  Added in v.1.212

CVSweb interface <joel.bertrand@systella.fr>