Diff for /rpl/src/interruptions.c between versions 1.137 and 1.211

version 1.137, 2013/09/06 10:30:56 version 1.211, 2024/01/17 16:57:17
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.16    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2024 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 65  thread_surveillance_signaux(void *argume Line 65  thread_surveillance_signaux(void *argume
 {  {
     // Cette fonction est lancée dans un thread créé par processus pour      // Cette fonction est lancée dans un thread créé par processus pour
     // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du      // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du
     // signal SIGALRM. Les processus externes n'envoient plus un signal au      // signal SIGUSR2. Les processus externes n'envoient plus un signal au
     // processus ou au thread à signaler mais positionnent les informations      // processus ou au thread à signaler mais positionnent les informations
     // 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é.
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)              while(sem_wait(semaphore_arret_signalisation) != 0)
             if (sem_wait(&(*s_queue_signaux).arret_signalisation) != 0)  
 #           else  
             if (sem_wait(semaphore_arret_signalisation) != 0)  
 #           endif  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  if (errno != EINTR)
                   {
                       (*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_signalisation);              sem_post(semaphore_signalisation);
 #           endif  
   
             nombre_signaux_envoyes = 0;              nombre_signaux_envoyes = 0;
             sched_yield();  
   
             // Dans un premier temps, on verrouille la queue des signaux              // Dans un premier temps, on verrouille la queue des signaux
             // 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)              while(sem_wait(semaphore_queue_signaux) != 0)
             sem_wait(&(*s_queue_signaux).semaphore);              {
 #           else                  if (errno != EINTR)
             sem_wait(semaphore_queue_signaux);                  {
 #           endif                      (*s_etat_processus).erreur_systeme = d_es_processus;
                   }
               }
   
             if ((*s_queue_signaux).pointeur_lecture !=              if ((*s_queue_signaux).pointeur_lecture !=
                     (*s_queue_signaux).pointeur_ecriture)                      (*s_queue_signaux).pointeur_ecriture)
Line 149  thread_surveillance_signaux(void *argume Line 134  thread_surveillance_signaux(void *argume
                 // appels système lents.                  // appels système lents.
   
                 nombre_signaux_envoyes++;                  nombre_signaux_envoyes++;
                 kill(getpid(), SIGALRM);                  kill(getpid(), SIGUSR2);
                   sched_yield();
             }              }
   
 #           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              sem_post(semaphore_arret_signalisation);
   
             // 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 180  thread_surveillance_signaux(void *argume Line 163  thread_surveillance_signaux(void *argume
                     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 !=
                             (*(*((struct_thread *) (*l_element_courant)                              (*(*((struct_thread *) (*l_element_courant)
                             .donnee)).s_etat_processus)                              .donnee)).s_etat_processus).pointeur_signal_lecture)
                             .pointeur_signal_lecture)  
                     {                      {
                         nombre_signaux_envoyes++;                          nombre_signaux_envoyes++;
                         pthread_kill((*((struct_thread *)                          pthread_kill((*((struct_thread *)
                                 (*l_element_courant).donnee)).tid, SIGALRM);                                  (*l_element_courant).donnee)).tid, SIGUSR2);
                           sched_yield();
                     }                      }
   
                     pthread_mutex_unlock(&((*(*((struct_thread *)                      pthread_mutex_unlock(&((*(*((struct_thread *)
Line 233  modification_pid_thread_pere(struct_proc Line 216  modification_pid_thread_pere(struct_proc
 void  void
 insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)  insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)
 {  {
       int                                         ios;
   
       struct timespec                             attente;
   
     volatile struct_liste_chainee_volatile      *l_nouvel_objet;      volatile struct_liste_chainee_volatile      *l_nouvel_objet;
   
     if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))      if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
Line 255  insertion_thread(struct_processus *s_eta Line 242  insertion_thread(struct_processus *s_eta
     (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =      (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
             s_etat_processus;              s_etat_processus;
   
     if (pthread_mutex_lock(&mutex_liste_threads) != 0)      attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
       while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          if (ios != EBUSY)
         return;          {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
   
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
     }      }
   
     (*l_nouvel_objet).suivant = liste_threads;      (*l_nouvel_objet).suivant = liste_threads;
Line 286  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 301  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 313  insertion_thread_surveillance(struct_pro Line 324  insertion_thread_surveillance(struct_pro
 void  void
 retrait_thread(struct_processus *s_etat_processus)  retrait_thread(struct_processus *s_etat_processus)
 {  {
       int                                     ios;
   
       struct timespec                         attente;
   
     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)      attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
       while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          if (ios != EBUSY)
         return;          {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
   
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
     }      }
   
     l_element_precedent = NULL;      l_element_precedent = NULL;
Line 368  retrait_thread(struct_processus *s_etat_ Line 407  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 400  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 422  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 439  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 455  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 469  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 488  retrait_thread_surveillance(struct_proce Line 523  retrait_thread_surveillance(struct_proce
 void  void
 verrouillage_threads_concurrents(struct_processus *s_etat_processus)  verrouillage_threads_concurrents(struct_processus *s_etat_processus)
 {  {
       int                                     ios;
   
       struct timespec                         attente;
   
     volatile struct_liste_chainee_volatile  *l_element_courant;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
     if (pthread_mutex_lock(&mutex_liste_threads) != 0)      attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
       while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          if (ios != EBUSY)
         return;          {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
   
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
     }      }
   
     l_element_courant = liste_threads;      l_element_courant = liste_threads;
Line 512  verrouillage_threads_concurrents(struct_ Line 575  verrouillage_threads_concurrents(struct_
                         .donnee)).s_etat_processus).semaphore_fork) == -1)                          .donnee)).s_etat_processus).semaphore_fork) == -1)
 #           endif  #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  if (errno != EINTR)
                 return;                  {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
             }              }
         }          }
   
Line 796  liberation_threads(struct_processus *s_e Line 862  liberation_threads(struct_processus *s_e
                 }                  }
             }              }
   
             // ne peut être effacé qu'une seule fois              // Ne peut être effacé qu'une seule fois
             if (suppression_variables_partagees == d_faux)              if (suppression_variables_partagees == d_faux)
             {              {
                 suppression_variables_partagees = d_vrai;                  suppression_variables_partagees = d_vrai;
   
                 liberation_arbre_variables_partagees(s_etat_processus,                  liberation_arbre_variables_partagees(s_etat_processus,
                         (*(*s_etat_processus).s_arbre_variables_partagees));                          (*(*s_etat_processus).s_arbre_variables_partagees));
                   (*(*s_etat_processus).s_arbre_variables_partagees) = NULL;
   
                 l_element_partage_courant = (*(*s_etat_processus)                  l_element_partage_courant = (*(*s_etat_processus)
                         .l_liste_variables_partagees);                          .l_liste_variables_partagees);
Line 814  liberation_threads(struct_processus *s_e Line 881  liberation_threads(struct_processus *s_e
                     free(l_element_partage_courant);                      free(l_element_partage_courant);
                     l_element_partage_courant = l_element_partage_suivant;                      l_element_partage_courant = l_element_partage_suivant;
                 }                  }
   
                   (*(*s_etat_processus).l_liste_variables_partagees) = NULL;
             }              }
   
             liberation_arbre_variables(s_etat_processus,              liberation_arbre_variables(s_etat_processus,
Line 1295  liberation_threads(struct_processus *s_e Line 1364  liberation_threads(struct_processus *s_e
 #           endif  #           endif
   
             liberation_contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              liberation_allocateur_buffer(s_etat_processus);
               sys_free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
         }          }
Line 1310  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 1321  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 1344  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 1368  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 1380  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 1488  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 1498  verrouillage_gestionnaire_signaux(struct Line 1582  verrouillage_gestionnaire_signaux(struct
         return;          return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  
     if (sem_post(&semaphore_gestionnaires_signaux) == -1)  
 #   else  
     if (sem_post(semaphore_gestionnaires_signaux) == -1)  
 #   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;  
     }  
   
     return;      return;
 }  }
   
 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 1556  lancement_thread_signaux(struct_processu Line 1627  lancement_thread_signaux(struct_processu
 {  {
     pthread_attr_t                  attributs;      pthread_attr_t                  attributs;
   
     void                            *argument;  
   
     if (pipe((*s_etat_processus).pipe_signaux) != 0)      if (pipe((*s_etat_processus).pipe_signaux) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1578  lancement_thread_signaux(struct_processu Line 1647  lancement_thread_signaux(struct_processu
         return(d_erreur);          return(d_erreur);
     }      }
   
     argument = (*s_etat_processus).pipe_signaux;  
   
     if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,      if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,
             thread_signaux, argument) != 0)              thread_signaux, s_etat_processus) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(d_erreur);
       }
   
       if (pthread_attr_destroy(&attributs) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return(d_erreur);          return(d_erreur);
Line 1600  arret_thread_signaux(struct_processus *s Line 1673  arret_thread_signaux(struct_processus *s
   
     do      do
     {      {
         n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal));          n = write_atomic(s_etat_processus, (*s_etat_processus).pipe_signaux[1],
                   &signal, sizeof(signal));
   
         if (n < 0)          if (n < 0)
         {          {
Line 1610  arret_thread_signaux(struct_processus *s Line 1684  arret_thread_signaux(struct_processus *s
   
     pthread_join((*s_etat_processus).thread_signaux, NULL);      pthread_join((*s_etat_processus).thread_signaux, NULL);
   
     close((*s_etat_processus).pipe_signaux[0]);  
     close((*s_etat_processus).pipe_signaux[1]);      close((*s_etat_processus).pipe_signaux[1]);
   
     return(d_absence_erreur);      return(d_absence_erreur);
 }  }
   
Line 1625  thread_signaux(void *argument) Line 1697  thread_signaux(void *argument)
   
     struct pollfd           fds;      struct pollfd           fds;
   
       struct_processus        *s_etat_processus;
   
     unsigned char           signal;      unsigned char           signal;
   
     pipe = (int *) argument;      s_etat_processus = (struct_processus *) argument;
       pipe = (*s_etat_processus).pipe_signaux;
     fds.fd = pipe[0];      fds.fd = pipe[0];
     fds.events = POLLIN;      fds.events = POLLIN;
     fds.revents = 0;  
   
     sigfillset(&masque);      sigfillset(&masque);
     pthread_sigmask(SIG_BLOCK, &masque, NULL);      pthread_sigmask(SIG_BLOCK, &masque, NULL);
   
     do      do
     {      {
         if (poll(&fds, 1, -1) == -1)          fds.revents = 0;
   
           while(poll(&fds, 1, -1) == -1)
         {          {
             pthread_exit(NULL);              if (errno != EINTR)
               {
                   close((*s_etat_processus).pipe_signaux[0]);
                   pthread_exit(NULL);
               }
         }          }
   
         read(fds.fd, &signal, 1);          if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)
           {
               close((*s_etat_processus).pipe_signaux[0]);
               pthread_exit(NULL);
           }
   
         if (signal != (0xFF & rpl_sigmax))          if (signal != (0xFF & rpl_sigmax))
         {          {
             envoi_signal_processus(getpid(), signal);              envoi_signal_processus(getpid(), signal, d_faux);
             // Un signal SIGALRM est envoyé par le thread de surveillance              // Un signal SIGUSR2 est envoyé par le thread de surveillance
             // des signaux jusqu'à ce que les signaux soient tous traités.              // des signaux jusqu'à ce que les signaux soient tous traités.
         }          }
     } while(signal != (0xFF & rpl_sigmax));      } while(signal != (0xFF & rpl_sigmax));
   
       close((*s_etat_processus).pipe_signaux[0]);
     pthread_exit(NULL);      pthread_exit(NULL);
 }  }
   
   
   static inline void
   _write(int fd, const void *buf, size_t count)
   {
       ssize_t         ios;
   
       while((ios = write(fd, buf, count)) == -1)
       {
           if (errno != EINTR)
           {
               break;
           }
       }
   
       return;
   }
   
   
 // Récupération des signaux  // Récupération des signaux
 // - SIGINT  (arrêt au clavier)  // - SIGINT  (arrêt au clavier)
 // - SIGTERM (signal d'arrêt en provenance du système)  // - SIGTERM (signal d'arrêt en provenance du système)
Line 1670  interruption1(int signal) Line 1773  interruption1(int signal)
     {      {
         case SIGINT:          case SIGINT:
             signal_tronque = (unsigned char) (rpl_sigint & 0xFF);              signal_tronque = (unsigned char) (rpl_sigint & 0xFF);
             write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));              _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             break;              break;
   
         case SIGTERM:          case SIGTERM:
             signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);              signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);
             write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));              _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             break;              break;
   
         case SIGUSR1:          case SIGUSR1:
             signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);              signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
             write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));              _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             break;              break;
   
         default:          default:
             // SIGALRM              // SIGUSR2
             break;              break;
     }      }
   
Line 1709  interruption2(int signal) Line 1812  interruption2(int signal)
     test_signal(signal);      test_signal(signal);
   
     signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);      signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
     write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));      _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
     return;      return;
 }  }
   
Line 1732  interruption3(int signal) Line 1836  interruption3(int signal)
         kill(pid_processus_pere, SIGUSR1);          kill(pid_processus_pere, SIGUSR1);
     }      }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if (signal != SIGUSR2)      if (signal != SIGUSR2)
     {      {
         write(STDERR_FILENO, message_1, strlen(message_1));          write(STDERR_FILENO, message_1, strlen(message_1));
Line 1741  interruption3(int signal) Line 1848  interruption3(int signal)
         write(STDERR_FILENO, message_2, strlen(message_2));          write(STDERR_FILENO, message_2, strlen(message_2));
     }      }
   
   #   pragma GCC diagnostic pop
   
     _exit(EXIT_FAILURE);      _exit(EXIT_FAILURE);
 }  }
   
Line 1755  interruption4(int signal) Line 1864  interruption4(int signal)
     test_signal(signal);      test_signal(signal);
   
     signal_tronque = (unsigned char) (rpl_sighup & 0xFF);      signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
     write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));      _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
     return;      return;
 }  }
   
Line 1771  interruption5(int signal) Line 1881  interruption5(int signal)
   
     test_signal(signal);      test_signal(signal);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);          signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
         write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));          _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
     }      }
   
     write(STDERR_FILENO, message, strlen(message));      write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1805  signal_alrm(struct_processus *s_etat_pro Line 1921  signal_alrm(struct_processus *s_etat_pro
         {          {
             // On n'est pas dans le processus père, on remonte le signal.              // On n'est pas dans le processus père, on remonte le signal.
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigalrm);                      rpl_sigalrm, d_faux);
         }          }
         else          else
         {          {
Line 1850  signal_term(struct_processus *s_etat_pro Line 1966  signal_term(struct_processus *s_etat_pro
         if ((*s_etat_processus).pid_processus_pere != getpid())          if ((*s_etat_processus).pid_processus_pere != getpid())
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigterm);                      rpl_sigterm, d_faux);
         }          }
         else          else
         {          {
Line 1888  inline static void Line 2004  inline static void
 signal_int(struct_processus *s_etat_processus, pid_t pid)  signal_int(struct_processus *s_etat_processus, pid_t pid)
 {  {
     struct_processus        *s_thread_principal;      struct_processus        *s_thread_principal;
     volatile sig_atomic_t   exclusion = 0;      pthread_mutex_t         exclusion = PTHREAD_MUTEX_INITIALIZER;
   
     verrouillage_gestionnaire_signaux(s_etat_processus);      verrouillage_gestionnaire_signaux(s_etat_processus);
   
Line 1904  signal_int(struct_processus *s_etat_proc Line 2020  signal_int(struct_processus *s_etat_proc
         if ((*s_etat_processus).pid_processus_pere != getpid())          if ((*s_etat_processus).pid_processus_pere != getpid())
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigint);                      rpl_sigint, d_faux);
         }          }
         else          else
         {          {
             (*s_etat_processus).var_volatile_traitement_sigint = -1;              (*s_etat_processus).var_volatile_traitement_sigint = -1;
   
             while(exclusion == 1);              pthread_mutex_lock(&exclusion);
             exclusion = 1;  
   
             if ((*s_etat_processus).var_volatile_requete_arret == -1)              if ((*s_etat_processus).var_volatile_requete_arret == -1)
             {              {
                 deverrouillage_gestionnaire_signaux(s_etat_processus);                  deverrouillage_gestionnaire_signaux(s_etat_processus);
                 exclusion = 0;                  pthread_mutex_unlock(&exclusion);
                 return;                  return;
             }              }
   
Line 1934  signal_int(struct_processus *s_etat_proc Line 2049  signal_int(struct_processus *s_etat_proc
             (*s_etat_processus).var_volatile_requete_arret = -1;              (*s_etat_processus).var_volatile_requete_arret = -1;
             (*s_etat_processus).var_volatile_alarme = -1;              (*s_etat_processus).var_volatile_alarme = -1;
   
             exclusion = 0;              pthread_mutex_unlock(&exclusion);
         }          }
     }      }
     else      else
Line 1975  signal_tstp(struct_processus *s_etat_pro Line 2090  signal_tstp(struct_processus *s_etat_pro
         if ((*s_etat_processus).var_volatile_processus_pere == 0)          if ((*s_etat_processus).var_volatile_processus_pere == 0)
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigtstp);                      rpl_sigtstp, d_faux);
         }          }
         else          else
         {          {
Line 2014  sortie_interruption_depassement_pile(voi Line 2129  sortie_interruption_depassement_pile(voi
     return;      return;
 }  }
   
   #ifdef HAVE_SIGSEGV_RECOVERY
 void  void
 interruption_depassement_pile(int urgence, stackoverflow_context_t scp)  interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
 {  {
Line 2030  interruption_depassement_pile(int urgenc Line 2146  interruption_depassement_pile(int urgenc
     interruption3(SIGUSR2);      interruption3(SIGUSR2);
     return;      return;
 }  }
   #endif
   
 int  int
 interruption_violation_access(void *adresse_fautive, int gravite)  interruption_violation_access(void *adresse_fautive, int gravite)
Line 2043  interruption_violation_access(void *adre Line 2160  interruption_violation_access(void *adre
     {      {
         // Il peut s'agir d'un dépassement de pile.          // Il peut s'agir d'un dépassement de pile.
   
         sigsegv_leave_handler(sortie_interruption_depassement_pile,  #       ifdef HAVE_SIGSEGV_RECOVERY
                 (void *) &routine_recursive, NULL, NULL);              sigsegv_leave_handler(sortie_interruption_depassement_pile,
                       (void *) &routine_recursive, NULL, NULL);
   #       else
               sortie_interruption_depassement_pile((void *) &routine_recursive,
                       NULL, NULL);
   #       endif
     }      }
   
     // On est dans une bonne vieille violation d'accès. On essaie      // On est dans une bonne vieille violation d'accès. On essaie
Line 2059  interruption_violation_access(void *adre Line 2181  interruption_violation_access(void *adre
         return(0);          return(0);
     }      }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(STDERR_FILENO, message, strlen(message));      write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         longjmp(contexte_initial, -1);          longjmp(contexte_initial, -1);
Line 2320  signal_hup(struct_processus *s_etat_proc Line 2447  signal_hup(struct_processus *s_etat_proc
             (unsigned long long) getpid(),              (unsigned long long) getpid(),
             (unsigned long long) pthread_self());              (unsigned long long) pthread_self());
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if ((fichier = fopen(nom, "w+")) != NULL)      if ((fichier = fopen(nom, "w+")) != NULL)
     {      {
         fclose(fichier);          fclose(fichier);
Line 2330  signal_hup(struct_processus *s_etat_proc Line 2460  signal_hup(struct_processus *s_etat_proc
   
     freopen("/dev/null", "r", stdin);      freopen("/dev/null", "r", stdin);
   
   #   pragma GCC diagnostic pop
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
Line 2346  traitement_exceptions_gsl(const char *re Line 2478  traitement_exceptions_gsl(const char *re
         int line, int gsl_errno)          int line, int gsl_errno)
 {  {
     code_erreur_gsl = gsl_errno;      code_erreur_gsl = gsl_errno;
     envoi_signal_processus(getpid(), rpl_sigexcept);      envoi_signal_processus(getpid(), rpl_sigexcept, d_faux);
     return;      return;
 }  }
   
Line 2450  scrutation_interruptions(struct_processu Line 2582  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 2462  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 2470  scrutation_interruptions(struct_processu Line 2603  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)  #           ifndef IPCS_SYSV
             while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)              if (msync(s_queue_signaux, sizeof(s_queue_signaux),
 #           else                      MS_ASYNC | MS_INVALIDATE) != 0)
             while(sem_wait(semaphore_signalisation) != 0)              {
                   sem_post(semaphore_queue_signaux);
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
 #           endif  #           endif
   
               if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
               {
                   return;
               }
   
               while(sem_wait(semaphore_signalisation) != 0)
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 2484  scrutation_interruptions(struct_processu Line 2628  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.
   
     if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)      if (pthread_mutex_trylock(&mutex_liste_threads) == 0)
     {      {
         while((*s_etat_processus).pointeur_signal_lecture !=          if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)
                 (*s_etat_processus).pointeur_signal_ecriture)  
         {          {
             // Il y a un signal dans la queue du thread courant. On le traite.              while((*s_etat_processus).pointeur_signal_lecture !=
                       (*s_etat_processus).pointeur_signal_ecriture)
               {
                   // Il y a un signal dans la queue du thread courant.
                   // On le traite.
   
             envoi_interruptions(s_etat_processus,                  envoi_interruptions(s_etat_processus,
                     (*s_etat_processus).signaux_en_queue                          (*s_etat_processus).signaux_en_queue
                     [(*s_etat_processus).pointeur_signal_lecture],                          [(*s_etat_processus).pointeur_signal_lecture],
                     getpid());                          getpid());
             (*s_etat_processus).pointeur_signal_lecture =                  (*s_etat_processus).pointeur_signal_lecture =
                     ((*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(semaphore_signalisation) != 0)
             while(sem_wait(&((*s_queue_signaux).signalisation)) != 0)  
 #           else  
             while(sem_wait(semaphore_signalisation) != 0)  
 #           endif  
             {  
                 if (errno != EINTR)  
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      if (errno != EINTR)
                     return;                      {
                           if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
   
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
                 }                  }
             }              }
   
               pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));
         }          }
   
         pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));          pthread_mutex_unlock(&mutex_liste_threads);
     }      }
   
     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 2549  nom_segment(unsigned char *chemin, pid_t Line 2698  nom_segment(unsigned char *chemin, pid_t
 #   ifdef IPCS_SYSV // !POSIX  #   ifdef IPCS_SYSV // !POSIX
 #       ifndef OS2 // !OS2  #       ifndef OS2 // !OS2
   
             if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *              if ((fichier = sys_malloc((strlen(chemin) + 1 + 256 + 1) *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                 return(NULL);                  return(NULL);
Line 2557  nom_segment(unsigned char *chemin, pid_t Line 2706  nom_segment(unsigned char *chemin, pid_t
   
             sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);              sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
 #       else // OS2  #       else // OS2
             if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))              if ((fichier = sys_malloc((10 + 256 + 1) * sizeof(unsigned char)))
                     == NULL)                      == NULL)
             {              {
                 return(NULL);                  return(NULL);
Line 2567  nom_segment(unsigned char *chemin, pid_t Line 2716  nom_segment(unsigned char *chemin, pid_t
 #       endif // OS2  #       endif // OS2
 #   else // POSIX  #   else // POSIX
   
         if ((fichier = malloc((1 + 256 + 1) *          if ((fichier = sys_malloc((1 + 256 + 1) *
                 sizeof(unsigned char))) == NULL)                  sizeof(unsigned char))) == NULL)
         {          {
             return(NULL);              return(NULL);
Line 2593  nom_segment(unsigned char *chemin, pid_t Line 2742  nom_segment(unsigned char *chemin, pid_t
 */  */
   
 int  int
 envoi_signal_processus(pid_t pid, enum signaux_rpl signal)  envoi_signal_processus(pid_t pid, enum signaux_rpl signal,
           logical1 test_ouverture)
 {  {
 #   ifndef OS2  #   ifndef OS2
         int                         segment;          int                         segment;
 #   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 2613  envoi_signal_processus(pid_t pid, enum s Line 2763  envoi_signal_processus(pid_t pid, enum s
   
     struct_queue_signaux            *queue;      struct_queue_signaux            *queue;
   
       struct timespec                 attente;
   
     unsigned char                   *nom;      unsigned char                   *nom;
   
     // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en      // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
Line 2627  envoi_signal_processus(pid_t pid, enum s Line 2779  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 2796  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)  #       ifndef IPCS_SYSV
             if (sem_post(&((*s_queue_signaux).semaphore)) != 0)          if (msync(s_queue_signaux, sizeof(s_queue_signaux),
 #       else                  MS_ASYNC | MS_INVALIDATE) != 0)
             if (sem_post(semaphore_queue_signaux) != 0)          {
               sem_post(semaphore_queue_signaux);
               return(1);
           }
 #       endif  #       endif
   
           if (sem_post(semaphore_queue_signaux) != 0)
         {          {
             return(1);              return(1);
         }          }
   
 #       if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)          if (sem_post(semaphore_signalisation) != 0)
             if (sem_post(&((*s_queue_signaux).signalisation)) != 0)  
 #       else  
             if (sem_post(semaphore_signalisation) != 0)  
 #       endif  
         {          {
             return(1);              return(1);
         }          }
Line 2677  envoi_signal_processus(pid_t pid, enum s Line 2826  envoi_signal_processus(pid_t pid, enum s
             }              }
   
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if ((desc = open(nom, O_RDWR)) == -1)                  if (test_ouverture == d_vrai)
                 {                  {
                     free(nom);                      attente.tv_sec = 0;
                     return(1);                      attente.tv_nsec = GRANULARITE_us * 1000;
   
                       while((desc = open(nom, O_RDWR)) == -1)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                   }
                   else
                   {
                       if ((desc = open(nom, O_RDWR)) == -1)
                       {
                           sys_free(nom);
                           return(1);
                       }
                 }                  }
   
                 close(desc);                  close(desc);
   
                 if ((clef = ftok(nom, 1)) == -1)                  if ((clef = ftok(nom, 1)) == -1)
                 {                  {
                     free(nom);                      sys_free(nom);
                     return(1);                      return(1);
                 }                  }
   
                 free(nom);                  sys_free(nom);
   
                 if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))                  if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
                         == -1)                          == -1)
Line 2701  envoi_signal_processus(pid_t pid, enum s Line 2864  envoi_signal_processus(pid_t pid, enum s
   
                 queue = shmat(segment, NULL, 0);                  queue = shmat(segment, NULL, 0);
 #           else // OS/2  #           else // OS/2
                 if (DosGetNamedSharedMem((PVOID) &queue, nom,                  if (test_ouverture == d_vrai)
                         PAG_WRITE | PAG_READ) != 0)  
                 {                  {
                     free(nom);                      attente.tv_sec = 0;
                     return(1);                      attente.tv_nsec = GRANULARITE_us * 1000;
   
                       while(DosGetNamedSharedMem((PVOID) &queue, nom,
                               PAG_WRITE | PAG_READ) != 0)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                   }
                   else
                   {
                       if (DosGetNamedSharedMem((PVOID) &queue, nom,
                               PAG_WRITE | PAG_READ) != 0)
                       {
                           sys_free(nom);
                           return(1);
                       }
                 }                  }
   
                 free(nom);                  sys_free(nom);
 #           endif  #           endif
 #       else // POSIX  #       else // POSIX
             if ((nom = nom_segment(racine_segment, pid)) == NULL)              if ((nom = nom_segment(racine_segment, pid)) == NULL)
Line 2716  envoi_signal_processus(pid_t pid, enum s Line 2894  envoi_signal_processus(pid_t pid, enum s
                 return(1);                  return(1);
             }              }
   
             if ((segment = shm_open(nom, O_RDWR, 0)) == -1)              if (test_ouverture == d_vrai)
             {              {
                 free(nom);                  attente.tv_sec = 0;
                 return(1);                  attente.tv_nsec = GRANULARITE_us * 1000;
   
                   while((segment = shm_open(nom, O_RDWR, 0)) == -1)
                   {
                       nanosleep(&attente, NULL);
                       INCR_GRANULARITE(attente.tv_nsec);
                   }
               }
               else
               {
                   if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
                   {
                       sys_free(nom);
                       return(1);
                   }
             }              }
   
             free(nom);              sys_free(nom);
   
             if ((queue = mmap(NULL, sizeof(struct_queue_signaux),              if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                     PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==                      PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
Line 2733  envoi_signal_processus(pid_t pid, enum s Line 2925  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)  #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     if (errno != EINTR)                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                     {                      {
                         return(1);                          return(1);
                     }                      }
                 }  #               else // OS/2
 #           else                      // Pendant de DosGetNamedSHaredMem()
                 if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)  #               endif
   #           endif
               return(1);
           }
   
           if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
                   == SEM_FAILED)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(semaphore);
                     return(1);                      return(1);
                 }                  }
   
                 if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                         == SEM_FAILED)  
                 {                  {
                       close(segment);
                       sem_close(semaphore);
                     return(1);                      return(1);
                 }                  }
   
                 while(sem_wait(semaphore) != 0)                  close(segment);
                 {  #           else // IPCS_SYSV
                     if (errno != EINTR)  #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                     {                      {
                         sem_close(semaphore);                          sem_close(semaphore);
                         sem_close(signalisation);  
                         return(1);                          return(1);
                     }                      }
                 }  #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
 #           endif  #           endif
 #       else // IPCS_SYSV  
             while(sem_wait(&((*queue).semaphore)) != 0)              sem_close(semaphore);
               return(1);
           }
   
           while(sem_wait(semaphore) != 0)
           {
               if (errno != EINTR)
             {              {
                 if (errno != EINTR)  #               ifndef IPCS_SYSV // POSIX
                 {                      if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE)
                     return(1);                              != 0)
                 }                      {
                           munmap(queue, sizeof(struct_queue_signaux));
                           sem_close(semaphore);
                           sem_close(signalisation);
                           close(segment);
                           return(1);
                       }
   
                       if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                       {
                           sem_close(semaphore);
                           sem_close(signalisation);
                           close(segment);
                           return(1);
                       }
   
                       close(segment);
   #               else // IPCS_SYSV
   #                   ifndef OS2 // SysV
                           if (shmdt(queue) != 0)
                           {
                               sem_close(semaphore);
                               sem_close(signalisation);
                               return(1);
                           }
   #                   else // OS/2
                           // Pendant de DosGetNamedSHaredMem()
   #                   endif
   #               endif
   
                   sem_close(semaphore);
                   sem_close(signalisation);
                   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 3043  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 (sem_post(semaphore) != 0)
 #           ifndef SEMAPHORES_NOMMES          {
                 if (sem_post(&((*queue).semaphore)) != 0)  #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(semaphore);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (sem_post(&((*queue).signalisation)) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                       close(segment);
                       sem_close(semaphore);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
 #           else  
                 if (sem_post(semaphore) != 0)                  close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(semaphore);
                           sem_close(signalisation);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(semaphore);
               sem_close(signalisation);
               return(1);
           }
   
           if (sem_close(semaphore) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     sem_close(semaphore);                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                     sem_close(signalisation);                      sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (sem_close(semaphore) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                       close(segment);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (sem_post(signalisation) != 0)                  close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(signalisation);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(signalisation);
               return(1);
           }
   
           if (sem_post(signalisation) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                     sem_close(signalisation);                      sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (sem_close(signalisation) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(signalisation);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(signalisation);
               return(1);
           }
   
           if (sem_close(signalisation) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                       close(segment);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
 #           endif  #           endif
   
             if (munmap(queue, sizeof(struct_queue_signaux)) != 0)              return(1);
           }
   
   #       ifndef IPCS_SYSV // POSIX
               if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
             {              {
                   munmap(queue, sizeof(struct_queue_signaux));
                 close(segment);                  close(segment);
                 return(1);                  return(1);
             }              }
 #       else // IPCS_SYSV  
             if (sem_post(&((*queue).semaphore)) != 0)  
             {  
                 return(1);  
             }  
   
             if (sem_post(&((*queue).signalisation)) != 0)              if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
             {              {
                   close(segment);
                 return(1);                  return(1);
             }              }
   
               close(segment);
   #       else // IPCS_SYSV
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if (shmdt(queue) != 0)                  if (shmdt(queue) != 0)
                 {                  {
Line 2851  envoi_signal_processus(pid_t pid, enum s Line 3214  envoi_signal_processus(pid_t pid, enum s
 }  }
   
 int  int
 envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)  envoi_signal_thread(struct_processus *s_contexte,
           pthread_t tid, enum signaux_rpl signal)
 {  {
     // Un signal est envoyé d'un thread à un autre thread du même processus.      // Un signal est envoyé d'un thread à un autre thread du même processus.
   
       int                                     ios;
   
       struct timespec                         attente;
   
     volatile struct_liste_chainee_volatile  *l_element_courant;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
     struct_processus                        *s_etat_processus;      struct_processus                        *s_etat_processus;
   
     if (pthread_mutex_lock(&mutex_liste_threads) != 0)      if (s_contexte != NULL)
     {      {
         return(1);          attente.tv_sec = 0;
           attente.tv_nsec = GRANULARITE_us * 1000;
   
           while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
           {
               if (ios != EBUSY)
               {
                   return(1);
               }
   
               if (sem_post(&((*s_contexte).semaphore_fork)) != 0)
               {
                   return(1);
               }
   
               nanosleep(&attente, NULL);
               INCR_GRANULARITE(attente.tv_nsec);
   
               while(sem_wait(&((*s_contexte).semaphore_fork)) != 0)
               {
                   if (errno != EINTR)
                   {
                       return(1);
                   }
               }
           }
       }
       else
       {
           if (pthread_mutex_lock(&mutex_liste_threads) != 0)
           {
               return(1);
           }
     }      }
   
     l_element_courant = liste_threads;      l_element_courant = liste_threads;
Line 2910  envoi_signal_thread(pthread_t tid, enum Line 3310  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 2936  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 (!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 2987  creation_queue_signaux(struct_processus Line 3374  creation_queue_signaux(struct_processus
         if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,          if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
                 S_IRUSR | S_IWUSR)) == -1)                  S_IRUSR | S_IWUSR)) == -1)
         {          {
             free(nom);              if (errno != EEXIST)
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              {
             return;                  sys_free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("+++Attention : Le segment de mémoire %s préexiste !\n",
                           nom);
               }
               else
               {
                   printf("+++Warning: %s memory segment preexists!\n", nom);
               }
   
               if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_TRUNC,
                       S_IRUSR | S_IWUSR)) == -1)
               {
                   sys_free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
         }          }
   
         if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)          if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
         {          {
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 3006  creation_queue_signaux(struct_processus Line 3414  creation_queue_signaux(struct_processus
         {          {
             if (shm_unlink(nom) == -1)              if (shm_unlink(nom) == -1)
             {              {
                 free(nom);                  sys_free(nom);
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         free(nom);          sys_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;
   
         (*s_queue_signaux).requete_arret = d_faux;          (*s_queue_signaux).requete_arret = d_faux;
   
         if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))          if (msync(s_queue_signaux, sizeof(struct_queue_signaux),
                   MS_ASYNC | MS_INVALIDATE) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 3086  creation_queue_signaux(struct_processus Line 3489  creation_queue_signaux(struct_processus
             }              }
   
             close(support);              close(support);
             free(nom);              sys_free(nom);
   
             if ((segment = shmget(clef, sizeof(struct_queue_signaux),              if ((segment = shmget(clef, sizeof(struct_queue_signaux),
                     IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)                      IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
Line 3111  creation_queue_signaux(struct_processus Line 3514  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 3129  creation_queue_signaux(struct_processus Line 3549  creation_queue_signaux(struct_processus
                     sizeof(struct_queue_signaux),                      sizeof(struct_queue_signaux),
                     PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)                      PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
             {              {
                 free(nom);                  sys_free(nom);
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             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;
Line 3146  creation_queue_signaux(struct_processus Line 3580  creation_queue_signaux(struct_processus
 #       endif  #       endif
 #   endif  #   endif
   
     // Lancement du thread de récupération des signaux.      (*s_queue_signaux).controle = getpid();
   
     if (pthread_attr_init(&attributs) != 0)      if (lancement_thread_signaux(s_etat_processus) == d_erreur)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     if (pthread_attr_setdetachstate(&attributs,      // Lancement du thread de récupération des signaux.
             PTHREAD_CREATE_JOINABLE) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
 #   ifdef SCHED_OTHER      if (pthread_attr_init(&attributs) != 0)
     if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
 #   ifdef PTHREAD_EXPLICIT_SCHED      if (pthread_attr_setdetachstate(&attributs,
     if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)              PTHREAD_CREATE_JOINABLE) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
 #   ifdef PTHREAD_SCOPE_SYSTEM      if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
     if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)              thread_surveillance_signaux, s_etat_processus) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
     if (pthread_attr_destroy(&attributs) != 0)      if (pthread_attr_destroy(&attributs) != 0)
     {      {
Line 3191  creation_queue_signaux(struct_processus Line 3616  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
     if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,  #   ifndef IPCS_SYSV
             thread_surveillance_signaux, s_etat_processus) != 0)      if (msync(s_queue_signaux, sizeof(s_queue_signaux),
               MS_ASYNC | MS_INVALIDATE) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   #   endif
   
     return;      return;
 }  }
Line 3218  creation_queue_signaux(struct_processus Line 3645  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);  
 #   endif  
   
     (*s_queue_signaux).requete_arret = d_vrai;  
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  
     sem_post(&((*s_queue_signaux).arret_signalisation));  
 #   else  
     sem_post(semaphore_arret_signalisation);  
 #   endif  
   
     // 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);  
 #   endif  
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);  
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
             if (shmdt(s_queue_signaux) == -1)              if (shmdt(s_queue_signaux) == -1)
Line 3252  liberation_queue_signaux(struct_processu Line 3655  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 3692  destruction_queue_signaux(struct_process
         unsigned char       *nom;          unsigned char       *nom;
 #   endif  #   endif
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)      // On dépile les interruptions pour arrêter les SIGUSR2 sur
     sem_wait(&((*s_queue_signaux).arret_signalisation));      // le processus courant.
 #   else  
     sem_wait(semaphore_arret_signalisation);      scrutation_interruptions(s_etat_processus);
 #   endif  
       while(sem_wait(semaphore_arret_signalisation) != 0)
       {
           if (errno != EINTR)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
       }
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
 #   if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  #   ifndef IPCS_SYSV
     sem_post(&((*s_queue_signaux).arret_signalisation));      msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
 #   else  
     sem_post(semaphore_arret_signalisation);  
 #   endif  #   endif
   
       sem_post(semaphore_arret_signalisation);
   
     // 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);      if ((*s_queue_signaux).controle == getpid())
       {
           pthread_join((*s_queue_signaux).thread_signaux, NULL);
       }
       else
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       arret_thread_signaux(s_etat_processus);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       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);              sys_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);              sys_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);              sys_free((*semaphore_arret_signalisation).path);
   
             if (shmdt(s_queue_signaux) == -1)              if (shmdt(s_queue_signaux) == -1)
             {              {
Line 3369  destruction_queue_signaux(struct_process Line 3781  destruction_queue_signaux(struct_process
             }              }
   
             unlink(nom);              unlink(nom);
             free(nom);              sys_free(nom);
 #       else  #       else
             sem_close(&((*s_queue_signaux).semaphore));              sem_close(&((*s_queue_signaux).semaphore));
             sem_destroy(&((*s_queue_signaux).semaphore));              sem_destroy(&((*s_queue_signaux).semaphore));
Line 3387  destruction_queue_signaux(struct_process Line 3799  destruction_queue_signaux(struct_process
             }              }
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
 #       ifndef SEMAPHORES_NOMMES          sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
             sem_destroy(&((*s_queue_signaux).semaphore));          sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
             sem_destroy(&((*s_queue_signaux).signalisation));          sem_destroy2(semaphore_arret_signalisation, getpid(),
             sem_destroy(&((*s_queue_signaux).arret_signalisation));                  SEM_ARRET_SIGNALISATION);
 #       else  
             sem_close(semaphore_queue_signaux);  
             sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);  
   
             sem_close(semaphore_signalisation);  
             sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);  
   
             sem_close(semaphore_arret_signalisation);  
             sem_destroy2(semaphore_arret_signalisation, getpid(),  
                     SEM_ARRET_SIGNALISATION);  
 #       endif  
   
         if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
         {          {
Line 3419  destruction_queue_signaux(struct_process Line 3820  destruction_queue_signaux(struct_process
   
         if (shm_unlink(nom) != 0)          if (shm_unlink(nom) != 0)
         {          {
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         free(nom);          sys_free(nom);
 #   endif  #   endif
   
     return;      return;

Removed from v.1.137  
changed lines
  Added in v.1.211


CVSweb interface <joel.bertrand@systella.fr>