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

Diff for /rpl/src/interruptions.c between versions 1.31 and 1.86

version 1.31, 2010/08/17 14:15:20 version 1.86, 2011/11/18 20:24:40
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.18    RPL/2 (R) version 4.1.4
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 57  static volatile struct_liste_chainee_vol Line 57  static volatile struct_liste_chainee_vol
         = NULL;          = NULL;
 static volatile struct_liste_chainee_volatile   *liste_threads_surveillance  static volatile struct_liste_chainee_volatile   *liste_threads_surveillance
         = NULL;          = NULL;
   static volatile int                             code_erreur_gsl = 0;
   
   unsigned char                                   *racine_segment;
   
   static pthread_mutex_t                          mutex_interruptions
           = PTHREAD_MUTEX_INITIALIZER;
   
 void  void
 modification_pid_thread_pere(struct_processus *s_etat_processus)  modification_pid_thread_pere(struct_processus *s_etat_processus)
Line 74  modification_pid_thread_pere(struct_proc Line 80  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)
 {  {
     sigset_t                                    oldset;  
     sigset_t                                    set;  
   
     volatile struct_liste_chainee_volatile      *l_nouvel_objet;      volatile struct_liste_chainee_volatile      *l_nouvel_objet;
   
     sigfillset(&set);  
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
     if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))      if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
             == NULL)              == NULL)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
     }      }
   
     if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)      if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
     }      }
Line 108  insertion_thread(struct_processus *s_eta Line 102  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;
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_lock(&mutex_liste_threads) != 0)
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {          return;
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }      }
   
     (*l_nouvel_objet).suivant = liste_threads;      (*l_nouvel_objet).suivant = liste_threads;
     liste_threads = l_nouvel_objet;      liste_threads = l_nouvel_objet;
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     if (sem_post(&semaphore_liste_threads) != 0)  
 #   else  
     if (sem_post(semaphore_liste_threads) != 0)  
 #   endif  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
     return;      return;
 }  }
   
Line 149  void Line 124  void
 insertion_thread_surveillance(struct_processus *s_etat_processus,  insertion_thread_surveillance(struct_processus *s_etat_processus,
         struct_descripteur_thread *s_argument_thread)          struct_descripteur_thread *s_argument_thread)
 {  {
     sigset_t                                    oldset;  
     sigset_t                                    set;  
   
     volatile struct_liste_chainee_volatile      *l_nouvel_objet;      volatile struct_liste_chainee_volatile      *l_nouvel_objet;
   
     sigfillset(&set);  
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
     if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))      if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
             == NULL)              == NULL)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_lock(&mutex_liste_threads) != 0)
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {          return;
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }      }
   
     pthread_mutex_lock(&((*s_argument_thread).mutex));      pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
     (*s_argument_thread).nombre_references++;      (*s_argument_thread).nombre_references++;
     pthread_mutex_unlock(&((*s_argument_thread).mutex));      pthread_mutex_unlock(&((*s_argument_thread).mutex_nombre_references));
   
     (*l_nouvel_objet).suivant = liste_threads_surveillance;      (*l_nouvel_objet).suivant = liste_threads_surveillance;
     (*l_nouvel_objet).donnee = (void *) s_argument_thread;      (*l_nouvel_objet).donnee = (void *) s_argument_thread;
   
     liste_threads_surveillance = l_nouvel_objet;      liste_threads_surveillance = l_nouvel_objet;
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     if (sem_post(&semaphore_liste_threads) != 0)  
 #   else  
     if (sem_post(semaphore_liste_threads) != 0)  
 #   endif  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
     return;      return;
 }  }
   
 void  void
 retrait_thread(struct_processus *s_etat_processus)  retrait_thread(struct_processus *s_etat_processus)
 {  {
     sigset_t                                oldset;  
     sigset_t                                set;  
   
     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;
   
     sigfillset(&set);      if (pthread_mutex_lock(&mutex_liste_threads) != 0)
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {          return;
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }      }
   
     l_element_precedent = NULL;      l_element_precedent = NULL;
Line 256  retrait_thread(struct_processus *s_etat_ Line 187  retrait_thread(struct_processus *s_etat_
   
     if (l_element_courant == NULL)      if (l_element_courant == NULL)
     {      {
 #       ifndef SEMAPHORES_NOMMES          pthread_mutex_unlock(&mutex_liste_threads);
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
Line 277  retrait_thread(struct_processus *s_etat_ Line 201  retrait_thread(struct_processus *s_etat_
         (*l_element_precedent).suivant = (*l_element_courant).suivant;          (*l_element_precedent).suivant = (*l_element_courant).suivant;
     }      }
   
     if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
   
 #       ifndef SEMAPHORES_NOMMES  
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
         return;  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  
     if (sem_post(&semaphore_liste_threads) != 0)  
 #   else  
     if (sem_post(semaphore_liste_threads) != 0)  
 #   endif  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
   
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
         return;          return;
     }      }
   
     free((void *) (*l_element_courant).donnee);      free((void *) (*l_element_courant).donnee);
     free((struct_liste_chainee_volatile *) l_element_courant);      free((struct_liste_chainee_volatile *) l_element_courant);
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
     return;      return;
 }  }
   
Line 316  void Line 217  void
 retrait_thread_surveillance(struct_processus *s_etat_processus,  retrait_thread_surveillance(struct_processus *s_etat_processus,
         struct_descripteur_thread *s_argument_thread)          struct_descripteur_thread *s_argument_thread)
 {  {
     sigset_t                                set;  
     sigset_t                                oldset;  
   
     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;
   
     sigfillset(&set);      if (pthread_mutex_lock(&mutex_liste_threads) != 0)
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {          return;
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }      }
   
     l_element_precedent = NULL;      l_element_precedent = NULL;
Line 357  retrait_thread_surveillance(struct_proce Line 242  retrait_thread_surveillance(struct_proce
   
     if (l_element_courant == NULL)      if (l_element_courant == NULL)
     {      {
 #       ifndef SEMAPHORES_NOMMES          pthread_mutex_unlock(&mutex_liste_threads);
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
Line 378  retrait_thread_surveillance(struct_proce Line 256  retrait_thread_surveillance(struct_proce
         (*l_element_precedent).suivant = (*l_element_courant).suivant;          (*l_element_precedent).suivant = (*l_element_courant).suivant;
     }      }
   
     if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)      if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
               != 0)
     {      {
 #       ifndef SEMAPHORES_NOMMES          pthread_mutex_unlock(&mutex_liste_threads);
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
Line 400  retrait_thread_surveillance(struct_proce Line 272  retrait_thread_surveillance(struct_proce
   
     if ((*s_argument_thread).nombre_references == 0)      if ((*s_argument_thread).nombre_references == 0)
     {      {
         if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_argument_thread)
                   .mutex_nombre_references)) != 0)
         {          {
 #           ifndef SEMAPHORES_NOMMES              pthread_mutex_unlock(&mutex_liste_threads);
             sem_post(&semaphore_liste_threads);  
 #           else  
             sem_post(semaphore_liste_threads);  
 #           endif  
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   
         pthread_mutex_destroy(&((*s_argument_thread).mutex));          pthread_mutex_destroy(&((*s_argument_thread).mutex));
           pthread_mutex_destroy(&((*s_argument_thread).mutex_nombre_references));
         free(s_argument_thread);          free(s_argument_thread);
     }      }
     else      else
     {      {
         if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_argument_thread)
                   .mutex_nombre_references)) != 0)
         {          {
 #           ifndef SEMAPHORES_NOMMES              pthread_mutex_unlock(&mutex_liste_threads);
             sem_post(&semaphore_liste_threads);  
 #           else  
             sem_post(semaphore_liste_threads);  
 #           endif  
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
     }      }
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     if (sem_post(&semaphore_liste_threads) != 0)  
 #   else  
     if (sem_post(semaphore_liste_threads) != 0)  
 #   endif  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     free((struct_liste_chainee_volatile *) l_element_courant);      free((struct_liste_chainee_volatile *) l_element_courant);
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
   
     return;      return;
 }  }
   
Line 460  verrouillage_threads_concurrents(struct_ Line 310  verrouillage_threads_concurrents(struct_
 {  {
     volatile struct_liste_chainee_volatile  *l_element_courant;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_lock(&mutex_liste_threads) != 0)
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {          return;
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }      }
   
     l_element_courant = liste_threads;      l_element_courant = liste_threads;
Line 482  verrouillage_threads_concurrents(struct_ Line 325  verrouillage_threads_concurrents(struct_
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)                  while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
                     .donnee)).s_etat_processus).semaphore_fork)) == -1)                          .donnee)).s_etat_processus).semaphore_fork)) == -1)
 #           else  #           else
             while(sem_wait((*(*((struct_thread *) (*l_element_courant)                  while(sem_wait((*(*((struct_thread *) (*l_element_courant)
                     .donnee)).s_etat_processus).semaphore_fork) == -1)                          .donnee)).s_etat_processus).semaphore_fork) == -1)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 {                  return;
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }              }
         }          }
   
Line 517  deverrouillage_threads_concurrents(struc Line 357  deverrouillage_threads_concurrents(struc
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*(*((struct_thread *)                  if (sem_post(&((*(*((struct_thread *)
                     (*l_element_courant).donnee)).s_etat_processus)                          (*l_element_courant).donnee)).s_etat_processus)
                     .semaphore_fork)) != 0)                          .semaphore_fork)) != 0)
 #           else  #           else
             if (sem_post((*(*((struct_thread *)                  if (sem_post((*(*((struct_thread *)
                     (*l_element_courant).donnee)).s_etat_processus)                          (*l_element_courant).donnee)).s_etat_processus)
                     .semaphore_fork) != 0)                          .semaphore_fork) != 0)
 #           endif  #           endif
             {              {
 #               ifndef SEMAPHORES_NOMMES                  if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                 if (sem_post(&semaphore_liste_threads) != 0)  
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
 #               else  
                 if (sem_post(semaphore_liste_threads) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
 #               endif  
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 548  deverrouillage_threads_concurrents(struc Line 380  deverrouillage_threads_concurrents(struc
         l_element_courant = (*l_element_courant).suivant;          l_element_courant = (*l_element_courant).suivant;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     if (sem_post(&semaphore_liste_threads) != 0)  
 #   else  
     if (sem_post(semaphore_liste_threads) != 0)  
 #   endif  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 566  liberation_threads(struct_processus *s_e Line 394  liberation_threads(struct_processus *s_e
 {  {
     logical1                                    suppression_variables_partagees;      logical1                                    suppression_variables_partagees;
   
     sigset_t                                    oldset;  
     sigset_t                                    set;  
   
     struct_descripteur_thread                   *s_argument_thread;      struct_descripteur_thread                   *s_argument_thread;
   
     struct_processus                            *candidat;      struct_processus                            *candidat;
Line 582  liberation_threads(struct_processus *s_e Line 407  liberation_threads(struct_processus *s_e
     volatile struct_liste_chainee_volatile      *l_element_courant;      volatile struct_liste_chainee_volatile      *l_element_courant;
     volatile struct_liste_chainee_volatile      *l_element_suivant;      volatile struct_liste_chainee_volatile      *l_element_suivant;
   
     sigfillset(&set);      if (pthread_mutex_lock(&mutex_liste_threads) == -1)
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {          return;
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }      }
   
     l_element_courant = liste_threads;      l_element_courant = liste_threads;
Line 676  liberation_threads(struct_processus *s_e Line 490  liberation_threads(struct_processus *s_e
                 s_argument_thread = (struct_descripteur_thread *)                  s_argument_thread = (struct_descripteur_thread *)
                         (*((struct_liste_chainee *) element_courant)).donnee;                          (*((struct_liste_chainee *) element_courant)).donnee;
   
                 if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)                  if (pthread_mutex_lock(&((*s_argument_thread)
                           .mutex_nombre_references)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     sem_post(&semaphore_liste_threads);                      pthread_mutex_unlock(&mutex_liste_threads);
                     return;                      return;
                 }                  }
   
Line 700  liberation_threads(struct_processus *s_e Line 515  liberation_threads(struct_processus *s_e
                     close((*s_argument_thread)                      close((*s_argument_thread)
                             .pipe_nombre_interruptions_attente[0]);                              .pipe_nombre_interruptions_attente[0]);
   
                     if (pthread_mutex_unlock(&((*s_argument_thread).mutex))                      if (pthread_mutex_unlock(&((*s_argument_thread)
                             != 0)                              .mutex_nombre_references)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         sem_post(&semaphore_liste_threads);                          pthread_mutex_unlock(&mutex_liste_threads);
                         return;                          return;
                     }                      }
   
                     pthread_mutex_destroy(&((*s_argument_thread).mutex));                      pthread_mutex_destroy(&((*s_argument_thread).mutex));
                       pthread_mutex_destroy(&((*s_argument_thread)
                               .mutex_nombre_references));
   
                     if ((*s_argument_thread).processus_detache == d_faux)                      if ((*s_argument_thread).processus_detache == d_faux)
                     {                      {
Line 723  liberation_threads(struct_processus *s_e Line 540  liberation_threads(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
                     if (pthread_mutex_unlock(&((*s_argument_thread).mutex))                      if (pthread_mutex_unlock(&((*s_argument_thread)
                             != 0)                              .mutex_nombre_references)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         sem_post(&semaphore_liste_threads);                          pthread_mutex_unlock(&mutex_liste_threads);
                         return;                          return;
                     }                      }
                 }                  }
Line 796  liberation_threads(struct_processus *s_e Line 613  liberation_threads(struct_processus *s_e
                 }                  }
             }              }
   
             for(i = 0; i < (*s_etat_processus).nombre_variables; i++)              liberation_arbre_variables(s_etat_processus,
             {                      (*s_etat_processus).s_arbre_variables, d_faux);
                 pthread_mutex_trylock(&((*(*s_etat_processus)  
                         .s_liste_variables[i].objet).mutex));  
                 pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables[i].objet).mutex));  
   
                 // Les variables de niveau 0 sont des définitions qui  
                 // ne sont pas copiées entre threads.  
                 if ((*s_etat_processus).s_liste_variables[i].niveau > 0)  
                 {  
                     liberation(s_etat_processus,  
                             (*s_etat_processus).s_liste_variables[i].objet);  
                 }  
   
                 free((*s_etat_processus).s_liste_variables[i].nom);  
             }  
   
             free((*s_etat_processus).s_liste_variables);  
   
             for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)              for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
             {              {
Line 1321  liberation_threads(struct_processus *s_e Line 1121  liberation_threads(struct_processus *s_e
             liberation_allocateur(s_etat_processus);              liberation_allocateur(s_etat_processus);
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             sem_post(&((*s_etat_processus).semaphore_fork));                  sem_post(&((*s_etat_processus).semaphore_fork));
             sem_destroy(&((*s_etat_processus).semaphore_fork));                  sem_destroy(&((*s_etat_processus).semaphore_fork));
 #           else  #           else
             sem_post((*s_etat_processus).semaphore_fork);                  sem_post((*s_etat_processus).semaphore_fork);
             sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);                  sem_close((*s_etat_processus).semaphore_fork);
 #           endif  #           endif
   
               liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
Line 1350  liberation_threads(struct_processus *s_e Line 1151  liberation_threads(struct_processus *s_e
         s_argument_thread = (struct_descripteur_thread *)          s_argument_thread = (struct_descripteur_thread *)
                 (*l_element_courant).donnee;                  (*l_element_courant).donnee;
   
         if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             sem_post(&semaphore_liste_threads);              pthread_mutex_unlock(&mutex_liste_threads);
             return;              return;
         }          }
   
Line 1373  liberation_threads(struct_processus *s_e Line 1175  liberation_threads(struct_processus *s_e
             close((*s_argument_thread).pipe_interruptions[0]);              close((*s_argument_thread).pipe_interruptions[0]);
             close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);              close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
   
             if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_argument_thread)
                       .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 sem_post(&semaphore_liste_threads);                  pthread_mutex_unlock(&mutex_liste_threads);
                 return;                  return;
             }              }
   
             pthread_mutex_destroy(&((*s_argument_thread).mutex));              pthread_mutex_destroy(&((*s_argument_thread).mutex));
               pthread_mutex_destroy(&((*s_argument_thread)
                       .mutex_nombre_references));
   
             if ((*s_argument_thread).processus_detache == d_faux)              if ((*s_argument_thread).processus_detache == d_faux)
             {              {
Line 1394  liberation_threads(struct_processus *s_e Line 1199  liberation_threads(struct_processus *s_e
         }          }
         else          else
         {          {
             if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_argument_thread)
                       .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 sem_post(&semaphore_liste_threads);                  pthread_mutex_unlock(&mutex_liste_threads);
                 return;                  return;
             }              }
         }          }
Line 1409  liberation_threads(struct_processus *s_e Line 1215  liberation_threads(struct_processus *s_e
   
     liste_threads_surveillance = NULL;      liste_threads_surveillance = NULL;
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     if (sem_post(&semaphore_liste_threads) != 0)  
 #   else  
     if (sem_post(semaphore_liste_threads) != 0)  
 #   endif  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
     return;      return;
 }  }
   
Line 1461  recherche_thread(pid_t pid, pthread_t ti Line 1260  recherche_thread(pid_t pid, pthread_t ti
     return(s_etat_processus);      return(s_etat_processus);
 }  }
   
 static logical1  static struct_processus *
 recherche_thread_principal(pid_t pid, pthread_t *thread)  recherche_thread_principal(pid_t pid)
 {  {
     volatile struct_liste_chainee_volatile      *l_element_courant;      volatile struct_liste_chainee_volatile      *l_element_courant;
   
Line 1486  recherche_thread_principal(pid_t pid, pt Line 1285  recherche_thread_principal(pid_t pid, pt
          * Le processus n'existe plus. On ne distribue aucun signal.           * Le processus n'existe plus. On ne distribue aucun signal.
          */           */
   
         return(d_faux);          return(NULL);
     }      }
   
     (*thread) = (*((struct_thread *) (*l_element_courant).donnee)).tid;      return((*((struct_thread *) (*l_element_courant).donnee))
               .s_etat_processus);
     return(d_vrai);  
 }  }
   
   
Line 1512  recherche_thread_principal(pid_t pid, pt Line 1310  recherche_thread_principal(pid_t pid, pt
 // les sémaphores sont déjà bloqués par un gestionnaire de signal.  // les sémaphores sont déjà bloqués par un gestionnaire de signal.
   
 static inline void  static inline void
 verrouillage_gestionnaire_signaux()  verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
 {  {
     int         semaphore;      int         semaphore;
   
     sigset_t    oldset;  #   ifndef SEMAPHORES_NOMMES
     sigset_t    set;      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
     sem_t       *sem;      if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     if ((sem = pthread_getspecific(semaphore_fork_processus_courant))  
             != NULL)  
     {      {
         if (sem_post(sem) != 0)          BUG(1, uprintf("Lock error !\n"));
         {          return;
             BUG(1, uprintf("Lock error !\n"));  
             return;  
         }  
     }      }
   
     // Il faut respecteur l'atomicité des deux opérations suivantes !      // Il faut respecteur l'atomicité des deux opérations suivantes !
   
     sigfillset(&set);      if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)  
 #   else  
     while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)  #       ifndef SEMAPHORES_NOMMES
         {          sem_wait(&((*s_etat_processus).semaphore_fork));
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       else
             BUG(1, uprintf("Unlock error !\n"));          sem_wait((*s_etat_processus).semaphore_fork);
             return;  #       endif
         }          BUG(1, uprintf("Unlock error !\n"));
           return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
Line 1556  verrouillage_gestionnaire_signaux() Line 1343  verrouillage_gestionnaire_signaux()
     if (sem_post(semaphore_gestionnaires_signaux) == -1)      if (sem_post(semaphore_gestionnaires_signaux) == -1)
 #   endif  #   endif
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       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"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
     }      }
Line 1567  verrouillage_gestionnaire_signaux() Line 1358  verrouillage_gestionnaire_signaux()
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)      if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
 #   endif  #   endif
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       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"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
     if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)  
 #   else  
     if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)  
 #   endif  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1591  verrouillage_gestionnaire_signaux() Line 1386  verrouillage_gestionnaire_signaux()
         // par un thread concurrent. On essaye donc de le bloquer jusqu'à          // par un thread concurrent. On essaye donc de le bloquer jusqu'à
         // ce que ce soit possible.          // ce que ce soit possible.
   
 #       ifndef SEMAPHORES_NOMMES          if (pthread_mutex_lock(&mutex_liste_threads) != 0)
         while(sem_trywait(&semaphore_liste_threads) == -1)  
 #       else  
         while(sem_trywait(semaphore_liste_threads) == -1)  
 #       endif  
         {          {
             if ((errno != EINTR) && (errno != EAGAIN))  #           ifndef SEMAPHORES_NOMMES
             {              sem_wait(&((*s_etat_processus).semaphore_fork));
                 pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #           else
               sem_wait((*s_etat_processus).semaphore_fork);
                 while(sem_wait(sem) == -1)  #           endif
                 {              BUG(1, uprintf("Lock error !\n"));
                     if (errno != EINTR)              return;
                     {  
                         BUG(1, uprintf("Lock error !\n"));  
                         return;  
                     }  
                 }  
   
                 BUG(1, uprintf("Lock error !\n"));  
                 return;  
             }  
   
             sched_yield();  
         }          }
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
   
     return;      return;
 }  }
   
 static inline void  static inline void
 deverrouillage_gestionnaire_signaux()  deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
 {  {
     int         semaphore;      int         semaphore;
   
     sem_t       *sem;  
   
     sigset_t    oldset;  
     sigset_t    set;  
   
     // Il faut respecteur l'atomicité des deux opérations suivantes !      // Il faut respecteur l'atomicité des deux opérations suivantes !
   
     sigfillset(&set);      if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)  
 #   else  
     while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1)  
 #   endif  
     {      {
         if (errno != EINTR)  #       ifndef SEMAPHORES_NOMMES
         {          sem_wait(&((*s_etat_processus).semaphore_fork));
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       else
             BUG(1, uprintf("Unlock error !\n"));          sem_wait((*s_etat_processus).semaphore_fork);
             return;  #       endif
         }          BUG(1, uprintf("Unlock error !\n"));
           return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
Line 1659  deverrouillage_gestionnaire_signaux() Line 1425  deverrouillage_gestionnaire_signaux()
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)      if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
 #   endif  #   endif
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1672  deverrouillage_gestionnaire_signaux() Line 1442  deverrouillage_gestionnaire_signaux()
     {      {
         if (errno != EINTR)          if (errno != EINTR)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #           ifndef SEMAPHORES_NOMMES
               sem_wait(&((*s_etat_processus).semaphore_fork));
   #           else
               sem_wait((*s_etat_processus).semaphore_fork);
   #           endif
             BUG(1, uprintf("Unlock error !\n"));              BUG(1, uprintf("Unlock error !\n"));
             return;              return;
         }          }
     }      }
   
 #   ifndef SEMAPHORES_NOMMES      if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
     if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)  
 #   else  
     if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0)  
 #   endif  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
   
     if ((sem = pthread_getspecific(semaphore_fork_processus_courant))  #   ifndef SEMAPHORES_NOMMES
             != NULL)      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
       while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         while(sem_wait(sem) == -1)          if (errno != EINTR)
         {          {
             if (errno != EINTR)              BUG(1, uprintf("Unlock error !\n"));
             {              return;
                 pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
                 BUG(1, uprintf("Unlock error !\n"));  
                 return;  
             }  
         }          }
     }      }
   
     if (semaphore == 1)      if (semaphore == 1)
     {      {
 #       ifndef SEMAPHORES_NOMMES          if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
         if (sem_post(&semaphore_liste_threads) != 0)  
 #       else  
         if (sem_post(semaphore_liste_threads) != 0)  
 #       endif  
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
   
             BUG(1, uprintf("Unlock error !\n"));              BUG(1, uprintf("Unlock error !\n"));
             return;              return;
         }          }
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
   
     return;      return;
 }  }
   
 #ifdef _BROKEN_SIGINFO  #define test_signal(signal) \
       if (signal_test == SIGTEST) { signal_test = signal; return; }
 static int              *fifos;  
 static int              segment;  
 static int              segment_mutexes;  
 static int              longueur_queue;  
 static int              nombre_queues;  
   
 static pthread_mutex_t  *mutexes;  
   
 static unsigned char    *chemin = NULL;  // Récupération des signaux
   // - SIGINT (arrêt au clavier)
   // - SIGTERM (signal d'arrêt en provenance du système)
   
 unsigned char *  void
 nom_segment(unsigned char *chemin, pid_t pid)  interruption1(int signal)
 {  {
     unsigned char               *fichier;      test_signal(signal);
   
     if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *      switch(signal)
             sizeof(unsigned char))) == NULL)  
     {      {
         return(NULL);          case SIGINT:
     }              envoi_signal_processus(getpid(), rpl_sigint);
               break;
   
     sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);          case SIGTERM:
               envoi_signal_processus(getpid(), rpl_sigterm);
               break;
   
     return(fichier);          case SIGUSR1:
               envoi_signal_processus(getpid(), rpl_sigalrm);
               break;
       }
   
       return;
 }  }
   
 unsigned char *  inline static void
 nom_segment_mutexes(unsigned char *chemin, pid_t pid)  signal_alrm(struct_processus *s_etat_processus, pid_t pid)
 {  {
     unsigned char               *fichier;      struct_processus        *s_thread_principal;
   
     if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *      verrouillage_gestionnaire_signaux(s_etat_processus);
             sizeof(unsigned char))) == NULL)  
     {  
         return(NULL);  
     }  
   
     sprintf(fichier, "%s/RPL-SIGMUTEXES-%d", chemin, (int) pid);      if (pid == getpid())
       {
           // Si pid est égal à getpid(), le signal à traiter est issu
           // du même processus que celui qui va le traiter, mais d'un thread
           // différent.
   
     return(fichier);          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
 }          {
               printf("[%d] RPL/SIGALRM (thread %llu)\n", (int) getpid(),
                       (unsigned long long) pthread_self());
               fflush(stdout);
           }
   
 int          if ((*s_etat_processus).pid_processus_pere != getpid())
 queue_de_signal(int signal)          {
 {              // On n'est pas dans le processus père, on remonte le signal.
     switch(signal)              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                       rpl_sigalrm);
           }
           else
           {
               // On est dans le processus père, on effectue un arrêt d'urgence.
               (*s_etat_processus).var_volatile_alarme = -1;
               (*s_etat_processus).var_volatile_requete_arret = -1;
           }
       }
       else
     {      {
         case SIGINT:          // Le signal est issu d'un processus différent. On recherche le
             BUG(1, uprintf("SIGINT is not queued as it does not "          // thread principal pour remonter le signal.
                     "come from program itself !\n"));  
             return(0);          if ((s_thread_principal = recherche_thread_principal(getpid()))
         case SIGTSTP:                  != NULL)
             return(1);          {
         case SIGCONT:              envoi_signal_contexte(s_thread_principal, rpl_sigalrm);
             return(2);          }
         case SIGURG:  
             return(3);  
         case SIGPIPE:  
             return(4);  
         case SIGALRM:  
             return(5);  
         case SIGFSTOP:  
             return(6);  
         case SIGSTART:  
             return(7);  
         case SIGINJECT:  
             return(8);  
         case SIGABORT:  
             return(9);  
         case SIGFABORT:  
             return(10);  
     }      }
   
     return(-1);      deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
 }  }
   
 void  inline static void
 creation_fifos_signaux(struct_processus *s_etat_processus)  signal_term(struct_processus *s_etat_processus, pid_t pid)
 {  {
     file                            *desc;      struct_processus        *s_thread_principal;
       volatile sig_atomic_t   exclusion = 0;
     int                             i;  
   
     key_t                           clef;  
   
     pthread_mutexattr_t             attributs_mutex;  
   
     unsigned char                   *nom;  
   
     /*  
      * Signaux utilisés  
      * SIGINT, SIGTSTP, SIGCONT, SIGURG, SIGPIPE, SIGALRM, SIGFSTOP,  
      * SIGSTART, SIGINJECT, SIGABORT, SIGFABORT  
      */  
   
     // Création d'un segment de données associé au PID du processus courant  
   
     chemin = (*s_etat_processus).chemin_fichiers_temporaires;      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,      if (pid == getpid())
             getpid())) == NULL)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         return;          {
     }              printf("[%d] RPL/SIGTERM (thread %llu)\n", (int) getpid(),
                       (unsigned long long) pthread_self());
               fflush(stdout);
           }
   
     /*          if ((*s_etat_processus).pid_processus_pere != getpid())
      * Structure d'une queue          {
      * 0 : pointeur en lecture sur le premier emplacement libre (int)              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
      * 1 : pointeur en écriture sur le premier emplacement à lire (int)                      rpl_sigterm);
      * 2 : longueur de la queue (int)          }
      * 3 : éléments restants (int)          else
      * 4 à 4 + (2) : queue (int)          {
      * 5 : mutex              (*s_etat_processus).var_volatile_traitement_sigint = -1;
      */  
   
     nombre_queues = 11;              while(exclusion == 1);
     longueur_queue = 256;              exclusion = 1;
   
     if ((desc = fopen(nom, "w")) == NULL)              if ((*s_etat_processus).var_volatile_requete_arret == -1)
     {              {
         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                  deverrouillage_gestionnaire_signaux(s_etat_processus);
         return;                  exclusion = 0;
     }                  return;
               }
   
     fclose(desc);              (*s_etat_processus).var_volatile_requete_arret = -1;
               (*s_etat_processus).var_volatile_alarme = -1;
   
     if ((clef = ftok(nom, 1)) == -1)              exclusion = 0;
     {          }
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }      }
       else
     free(nom);  
   
     if ((segment = shmget(clef,  
             nombre_queues * (longueur_queue + 4) * sizeof(int),  
             IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          if ((s_thread_principal = recherche_thread_principal(getpid()))
         return;                  != NULL)
           {
               envoi_signal_contexte(s_thread_principal, rpl_sigterm);
           }
     }      }
   
     fifos = shmat(segment, NULL, 0);      deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
   }
   
     if (((void *) fifos) == ((void *) -1))  inline static void
     {  signal_int(struct_processus *s_etat_processus, pid_t pid)
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  {
         return;      struct_processus        *s_thread_principal;
     }      volatile sig_atomic_t   exclusion = 0;
   
     for(i = 0; i < nombre_queues; i++)      verrouillage_gestionnaire_signaux(s_etat_processus);
     {  
         fifos[(i * (longueur_queue + 4))] = 0;  
         fifos[(i * (longueur_queue + 4)) + 1] = 0;  
         fifos[(i * (longueur_queue + 4)) + 2] = longueur_queue;  
         fifos[(i * (longueur_queue + 4)) + 3] = longueur_queue;  
     }  
   
     if ((nom = nom_segment_mutexes((*s_etat_processus)      if (pid == getpid())
             .chemin_fichiers_temporaires, getpid())) == NULL)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         return;          {
     }              printf("[%d] RPL/SIGINT (thread %llu)\n", (int) getpid(),
                       (unsigned long long) pthread_self());
               fflush(stdout);
           }
   
     if ((desc = fopen(nom, "w")) == NULL)          if ((*s_etat_processus).pid_processus_pere != getpid())
     {          {
         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
         return;                      rpl_sigint);
     }          }
           else
           {
               (*s_etat_processus).var_volatile_traitement_sigint = -1;
   
     fclose(desc);              while(exclusion == 1);
               exclusion = 1;
   
     if ((clef = ftok(nom, 1)) == -1)              if ((*s_etat_processus).var_volatile_requete_arret == -1)
     {              {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  deverrouillage_gestionnaire_signaux(s_etat_processus);
         return;                  exclusion = 0;
     }                  return;
               }
   
     free(nom);              if ((*s_etat_processus).langue == 'F')
               {
                   printf("+++Interruption\n");
               }
               else
               {
                   printf("+++Interrupt\n");
               }
   
     if ((segment_mutexes = shmget(clef,              fflush(stdout);
             nombre_queues * sizeof(pthread_mutex_t),  
             IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     mutexes = shmat(segment_mutexes, NULL, 0);              (*s_etat_processus).var_volatile_requete_arret = -1;
               (*s_etat_processus).var_volatile_alarme = -1;
   
     if (((void *) mutexes) == ((void *) -1))              exclusion = 0;
     {          }
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }      }
       else
     /*  
      * Création et initialisation d'un mutex par queue. Ce mutex n'est pas  
      * dans le premier segment parce qu'il peut y avoir des problèmes  
      * d'alignements sur certaines architectures.  
      */  
   
     pthread_mutexattr_init(&attributs_mutex);  
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);  
   
     for(i = 0; i < nombre_queues; i++)  
     {      {
         pthread_mutex_init(&(mutexes[i]), &attributs_mutex);          if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
           {
               envoi_signal_contexte(s_thread_principal, rpl_sigint);
           }
     }      }
   
     pthread_mutexattr_destroy(&attributs_mutex);      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
   // Récupération des signaux
   // - SIGFSTP
   //
   // ATTENTION :
   // Le signal SIGFSTP provient de la mort du processus de contrôle.
   // Sous certains systèmes (Linux...), la mort du terminal de contrôle
   // se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
   // (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
   // non initialisée (pointeur NULL) issue de TERMIO.
   
 void  void
 liberation_fifos_signaux(struct_processus *s_etat_processus)  interruption2(int signal)
 {  {
     if (shmdt(fifos) == -1)      test_signal(signal);
     {      envoi_signal_processus(getpid(), rpl_sigtstp);
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if (shmdt(mutexes) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     return;      return;
 }  }
   
 void  static inline void
 destruction_fifos_signaux(struct_processus *s_etat_processus)  signal_tstp(struct_processus *s_etat_processus, pid_t pid)
 {  {
     int                 i;      struct_processus        *s_thread_principal;
   
     unsigned char       *nom;      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if (shmdt(fifos) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if (shmctl(segment, IPC_RMID, 0) == -1)      if (pid == getpid())
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     for(i = 0; i < nombre_queues; i++)  
     {      {
         pthread_mutex_destroy(&(mutexes[i]));          /*
     }           *  0 => fonctionnement normal
            * -1 => requête
            *  1 => requête acceptée en attente de traitement
            */
   
     if (shmdt(mutexes) == -1)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {          {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              printf("[%d] RPL/SIGTSTP (thread %llu)\n", (int) getpid(),
         return;                      (unsigned long long) pthread_self());
     }              fflush(stdout);
           }
   
     if (shmctl(segment_mutexes, IPC_RMID, 0) == -1)          if ((*s_etat_processus).var_volatile_processus_pere == 0)
     {          {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
         return;                      rpl_sigtstp);
           }
           else
           {
               (*s_etat_processus).var_volatile_requete_arret2 = -1;
           }
     }      }
       else
     if ((nom = nom_segment_mutexes((*s_etat_processus)  
             .chemin_fichiers_temporaires, getpid())) == NULL)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          // Envoi d'un signal au thread maître du groupe.
         return;  
     }  
   
     unlink(nom);  
     free(nom);  
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,          if ((s_thread_principal = recherche_thread_principal(getpid()))
             getpid())) == NULL)                  != NULL)
     {          {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              envoi_signal_contexte(s_thread_principal, rpl_sigtstp);
         return;          }
     }      }
   
     unlink(nom);      deverrouillage_gestionnaire_signaux(s_etat_processus);
     free(nom);  
   
     return;      return;
 }  }
   
 int  void
 queue_in(pid_t pid, int signal)  interruption3(int signal)
 {  {
     int             *base;      // Si on passe par ici, c'est qu'il est impossible de récupérer
     int             *buffer;      // l'erreur d'accès à la mémoire. On sort donc du programme quitte à
     int             *projection_fifos;      // ce qu'il reste des processus orphelins.
     int             queue;  
     int             identifiant;  
   
     key_t           clef;      unsigned char       message_1[] = "+++System : Uncaught access violation\n"
                                   "+++System : Aborting !\n";
       unsigned char       message_2[] = "+++System : Stack overflow\n"
                                   "+++System : Aborting !\n";
   
     pthread_mutex_t *projection_mutexes;      test_signal(signal);
   
     unsigned char   *nom;      if (pid_processus_pere == getpid())
       {
     queue = queue_de_signal(signal);          kill(pid_processus_pere, SIGUSR1);
       }
   
     // Ouverture des projections  
   
     if ((nom = nom_segment(chemin, pid)) == NULL)      if (signal != SIGUSR2)
     {      {
         return(-1);          write(STDERR_FILENO, message_1, strlen(message_1));
     }      }
       else
     if ((clef = ftok(nom, 1)) == -1)  
     {      {
         free(nom);          write(STDERR_FILENO, message_2, strlen(message_2));
         return(-1);  
     }      }
   
     free(nom);      _exit(EXIT_FAILURE);
   }
     while((identifiant = shmget(clef,  
             nombre_queues * (longueur_queue + 4) * sizeof(int),  
             S_IRUSR | S_IWUSR)) == -1);  
   
     projection_fifos = shmat(identifiant, NULL, 0);  
   
     if ((nom = nom_segment_mutexes(chemin, pid)) == NULL)  static void
   sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
   {
       switch((*((volatile int *) arg1)))
     {      {
         return(-1);          case 1:
     }              longjmp(contexte_ecriture, -1);
               break;
   
     if ((clef = ftok(nom, 1)) == -1)          case 2:
     {              longjmp(contexte_impression, -1);
         free(nom);              break;
         return(-1);  
     }      }
   
     free(nom);      return;
   }
     while((identifiant = shmget(clef,  
             nombre_queues * sizeof(pthread_mutex_t),  
             S_IRUSR | S_IWUSR)) == -1);  
   
     projection_mutexes = shmat(identifiant, NULL, 0);  
   
     if (pthread_mutex_lock(&(projection_mutexes[queue])) != 0)  void
   interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
   {
       if ((urgence == 0) && (routine_recursive != 0))
     {      {
         return(-1);          // On peut tenter de récupérer le dépassement de pile. Si la variable
           // 'routine_recursive' est non nulle, on récupère l'erreur.
   
           sigsegv_leave_handler(sortie_interruption_depassement_pile,
                   (void *) &routine_recursive, NULL, NULL);
     }      }
   
     base = &(projection_fifos[(longueur_queue + 4) * queue]);      // Ici, la panique est totale et il vaut mieux quitter l'application.
     buffer = &(base[4]);      interruption3(SIGUSR2);
       return;
   }
   
     // base[1] contient le prochain élément à écrire  
     buffer[base[1]++] = (int) pid;  
     base[1] %= base[2];  
   
     // base[3] contient le nombre d'éléments non lus  int
     if (base[3] <= 0)  interruption_violation_access(void *adresse_fautive, int gravite)
     {  {
         pthread_mutex_unlock(&(projection_mutexes[queue]));      unsigned char       message[] = "+++System : Trying to catch access "
         shmdt(projection_mutexes);                                  "violation\n";
         shmdt(projection_fifos);  
         return(-1);  
     }  
   
     base[3]--;      static int          compteur_erreur = 0;
   
     if (pthread_mutex_unlock(&(projection_mutexes[queue])) != 0)      if ((gravite == 0) && (routine_recursive != 0))
     {      {
         shmdt(projection_mutexes);          // Il peut s'agir d'un dépassement de pile.
         shmdt(projection_fifos);  
         return(-1);  
     }  
   
     // Fermeture des projections  
     shmdt(projection_mutexes);  
     shmdt(projection_fifos);  
     return(0);  
 }  
   
 pid_t          sigsegv_leave_handler(sortie_interruption_depassement_pile,
 origine_signal(int signal)                  (void *) &routine_recursive, NULL, NULL);
 {      }
     int             *base;  
     int             *buffer;  
     int             pid;  
     int             queue;  
   
     queue = queue_de_signal(signal);      // On est dans une bonne vieille violation d'accès. On essaie
       // de fermer au mieux l'application.
   
     BUG(queue == -1, uprintf("[%d] Unknown signal %d in this context\n",      compteur_erreur++;
             (int) getpid(), signal));  
   
     if (pthread_mutex_lock(&(mutexes[queue])) != 0)      if (compteur_erreur >= 2)
     {      {
         return(-1);          // Erreurs multiples, on arrête l'application.
           interruption3(SIGSEGV);
           return(0);
     }      }
   
     base = &(fifos[(longueur_queue + 4) * queue]);      write(STDERR_FILENO, message, strlen(message));
     buffer = &(base[4]);  
     pid = buffer[base[0]++];  
     base[0] %= base[2];  
     base[3]++;  
   
     if (base[3] > base[2])      if (pid_processus_pere == getpid())
     {      {
         pthread_mutex_unlock(&(mutexes[queue]));          longjmp(contexte_initial, -1);
         return(-1);          return(1);
     }      }
     if (pthread_mutex_unlock(&(mutexes[queue])) != 0)      else
     {      {
         perror("unlock");          longjmp(contexte_processus, -1);
         return(-1);          return(1);
     }      }
   
     return((pid_t) pid);      // On renvoie 0 parce qu'on décline toute responsabilité quant à la
       // suite des événements...
       return(0);
 }  }
   
 #endif  // Traitement de rpl_sigstart
   
 void  static inline void
 interruption1(SIGHANDLER_ARGS)  signal_start(struct_processus *s_etat_processus, pid_t pid)
 {  {
     pid_t                   pid;      struct_processus        *s_thread_principal;
   
     pthread_t               thread;      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     struct_processus        *s_etat_processus;      if (pid == getpid())
   
     volatile sig_atomic_t   exclusion = 0;  
   
 #   ifdef _BROKEN_SIGINFO  
     if (signal == SIGINT)  
     {      {
         // Si l'interruption provient du clavier, il n'y a pas eu d'appel          (*s_etat_processus).demarrage_fils = d_vrai;
         // à queue_in().  
   
         pid = getpid();  
     }      }
     else      else
     {      {
         pid = origine_signal(signal);          // Envoi d'un signal au thread maître du groupe.
     }  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();  
   
     switch(signal)          if ((s_thread_principal = recherche_thread_principal(getpid()))
     {                  != NULL)
         case SIGALRM :  
         {          {
             if (pid == getpid())              envoi_signal_contexte(s_thread_principal, rpl_sigstart);
             {  
                 if ((s_etat_processus = recherche_thread(getpid(),  
                         pthread_self())) == NULL)  
                 {  
                     deverrouillage_gestionnaire_signaux();  
                      return;  
                 }  
   
                 if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)  
                 {  
                     printf("[%d] SIGALRM (thread %llu)\n", (int) getpid(),  
                             (unsigned long long) pthread_self());  
                     fflush(stdout);  
                 }  
   
                 if ((*s_etat_processus).pid_processus_pere != getpid())  
                 {  
                     kill((*s_etat_processus).pid_processus_pere, signal);  
                 }  
                 else  
                 {  
                     (*s_etat_processus).var_volatile_alarme = -1;  
                     (*s_etat_processus).var_volatile_requete_arret = -1;  
                 }  
             }  
             else  
             {  
                 if (recherche_thread_principal(getpid(), &thread) == d_vrai)  
                 {  
                     pthread_kill(thread, signal);  
                 }  
             }  
   
             break;  
         }          }
       }
   
         case SIGINT :      deverrouillage_gestionnaire_signaux(s_etat_processus);
         {      return;
             /*  }
              * Une vieille spécification POSIX permet au pointeur siginfo  
              * d'être nul dans le cas d'un ^C envoyé depuis le clavier.  
              * Solaris suit en particulier cette spécification.  
              */  
   
 #           ifndef _BROKEN_SIGINFO  
             if (siginfo == NULL)  
             {  
                 kill(getpid(), signal);  
             }  
             else  
 #           endif  
             if (pid == getpid())  
             {  
                 if ((s_etat_processus = recherche_thread(getpid(),  
                         pthread_self())) == NULL)  
                 {  
                     deverrouillage_gestionnaire_signaux();  
                     return;  
                 }  
   
                 if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)  
                 {  
                     printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),  
                             (unsigned long long) pthread_self());  
                     fflush(stdout);  
                 }  
   
                 if ((*s_etat_processus).pid_processus_pere != getpid())  
                 {  
                     kill((*s_etat_processus).pid_processus_pere, signal);  
                 }  
                 else  
                 {  
                     (*s_etat_processus).var_volatile_traitement_sigint = -1;  
   
                     while(exclusion == 1);  
                     exclusion = 1;  
   
                     if ((*s_etat_processus).var_volatile_requete_arret == -1)  
                     {  
                         deverrouillage_gestionnaire_signaux();  
                         exclusion = 0;  
                         return;  
                     }  
   
                     if (strncmp(getenv("LANG"), "fr", 2) == 0)  
                     {  
                         printf("+++Interruption\n");  
                     }  
                     else  
                     {  
                         printf("+++Interrupt\n");  
                     }  
   
                     fflush(stdout);  // Traitement de rpl_sigcont
   
                     (*s_etat_processus).var_volatile_requete_arret = -1;  static inline void
                     (*s_etat_processus).var_volatile_alarme = -1;  signal_cont(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
                     exclusion = 0;      verrouillage_gestionnaire_signaux(s_etat_processus);
                 }  
             }  
             else  
             {  
                 if (recherche_thread_principal(getpid(), &thread) == d_vrai)  
                 {  
                     pthread_kill(thread, signal);  
                 }  
             }  
   
             break;      if (pid == getpid())
         }      {
           (*s_etat_processus).redemarrage_processus = d_vrai;
       }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
         default :          if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
         {          {
             BUG(1, uprintf("[%d] Unknown signal %d in this context\n",              envoi_signal_contexte(s_thread_principal, rpl_sigcont);
                     (int) getpid(), signal));  
             break;  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  // Traitement de rpl_sigstop
 interruption2(SIGHANDLER_ARGS)  
 {  
     pid_t                   pid;  
   
     pthread_t               thread;  
   
     struct_processus        *s_etat_processus;  static inline void
   signal_stop(struct_processus *s_etat_processus, pid_t pid)
 #   ifdef _BROKEN_SIGINFO  {
     pid = origine_signal(signal);      struct_processus        *s_thread_principal;
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();  
   
 #   ifndef _BROKEN_SIGINFO      verrouillage_gestionnaire_signaux(s_etat_processus);
     if (siginfo == NULL)  
     {  
         /*  
          * Le signal SIGFSTP provient de la mort du processus de contrôle.  
          * Sous certains systèmes (Linux...), la mort du terminal de contrôle  
          * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres  
          * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo  
          * non initialisée (pointeur NULL) issue de TERMIO.  
          */  
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)  
         {  
             pthread_kill(thread, SIGHUP);  
             deverrouillage_gestionnaire_signaux();  
             return;  
         }  
     }  
     else  
 #   endif  
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
         {          {
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux(s_etat_processus);
             return;              return;
         }          }
   
         /*  
          *  0 => fonctionnement normal  
          * -1 => requête  
          *  1 => requête acceptée en attente de traitement  
          */  
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             printf("[%d] SIGTSTP (thread %llu)\n", (int) getpid(),              printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
                     (unsigned long long) pthread_self());                      (unsigned long long) pthread_self());
             fflush(stdout);              fflush(stdout);
         }          }
   
         if ((*s_etat_processus).var_volatile_processus_pere == 0)          /*
            * var_globale_traitement_retarde_stop :
            *  0 -> traitement immédiat
            *  1 -> traitement retardé (aucun signal reçu)
            * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
            */
   
           if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
         {          {
             kill((*s_etat_processus).pid_processus_pere, signal);              (*s_etat_processus).var_volatile_requete_arret = -1;
         }          }
         else          else
         {          {
             (*s_etat_processus).var_volatile_requete_arret2 = -1;              (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
         }          }
     }      }
     else      else
     {      {
         // Envoi d'un signal au thread maître du groupe.          // Envoi d'un signal au thread maître du groupe.
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)          if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
         {          {
             pthread_kill(thread, SIGTSTP);              envoi_signal_contexte(s_thread_principal, rpl_sigstop);
             deverrouillage_gestionnaire_signaux();  
             return;  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  // Traitement de rpl_siginject
 interruption3(SIGHANDLER_ARGS)  
 {  
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;  
   
     static int              compteur = 0;  static inline void
   signal_inject(struct_processus *s_etat_processus, pid_t pid)
 #   ifdef _BROKEN_SIGINFO  {
     pid = origine_signal(signal);      verrouillage_gestionnaire_signaux(s_etat_processus);
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux(s_etat_processus);
         return;          return;
     }      }
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGINJECT (thread %llu)\n", (int) getpid(),
                 (unsigned long long) pthread_self());                  (unsigned long long) pthread_self());
         fflush(stdout);          fflush(stdout);
     }      }
   
     if ((*s_etat_processus).var_volatile_recursivite == -1)      deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
   }
   
   // Récupération des signaux
   // - SIGPIPE
   
   void
   interruption5(int signal)
   {
       unsigned char       message[] = "+++System : SIGPIPE\n"
                                   "+++System : Aborting !\n";
   
       test_signal(signal);
   
       if (pid_processus_pere == getpid())
     {      {
         // Segfault dans un appel de fonction récursive          envoi_signal_processus(pid_processus_pere, rpl_sigalrm);
         deverrouillage_gestionnaire_signaux();  
         longjmp(contexte, -1);  
     }      }
     else  
       write(STDERR_FILENO, message, strlen(message));
       return;
   }
   
   static inline void
   signal_urg(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
     {      {
         // Segfault dans une routine interne          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
         if (strncmp(getenv("LANG"), "fr", 2) == 0)                  == NULL)
         {          {
             printf("+++Système : Violation d'accès (dépassement de pile)\n");              deverrouillage_gestionnaire_signaux(s_etat_processus);
               return;
         }          }
         else  
           if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             printf("+++System : Access violation (stack overflow)\n");              printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),
                       (unsigned long long) pthread_self());
               fflush(stdout);
         }          }
   
         fflush(stdout);          (*s_etat_processus).var_volatile_alarme = -1;
           (*s_etat_processus).var_volatile_requete_arret = -1;
         compteur++;      }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
         if (compteur > 1)          if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
         {          {
             deverrouillage_gestionnaire_signaux();              envoi_signal_contexte(s_thread_principal, rpl_sigurg);
             exit(EXIT_FAILURE);  
         }  
         else  
         {  
             deverrouillage_gestionnaire_signaux();  
             longjmp(contexte_initial, -1);  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  // Traitement de rpl_sigabort
 interruption4(SIGHANDLER_ARGS)  
 {  
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;  
   
 #   ifdef _BROKEN_SIGINFO  static inline void
     pid = origine_signal(signal);  signal_abort(struct_processus *s_etat_processus, pid_t pid)
 #   else  {
     pid = (*siginfo).si_pid;      struct_processus        *s_thread_principal;
 #   endif  
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux(s_etat_processus);
         return;          return;
     }      }
   
     /*  
      * Démarrage d'un processus fils ou gestion de SIGCONT (SUSPEND)  
      */  
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] SIGSTART/SIGCONT (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGABORT (thread %llu)\n", (int) getpid(),
                 (unsigned long long) pthread_self());                  (unsigned long long) pthread_self());
         fflush(stdout);          fflush(stdout);
     }      }
   
     deverrouillage_gestionnaire_signaux();  
     return;  
 }  
   
 void  
 interruption5(SIGHANDLER_ARGS)  
 {  
     pid_t                   pid;  
   
     pthread_t               thread;  
   
     struct_processus        *s_etat_processus;  
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();  
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
         {          {
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux(s_etat_processus);
             return;              return;
         }          }
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          (*s_etat_processus).arret_depuis_abort = -1;
         {  
             printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),  
                     (unsigned long long) pthread_self());  
             fflush(stdout);  
         }  
   
         /*          /*
          * var_globale_traitement_retarde_stop :           * var_globale_traitement_retarde_stop :
Line 2550  interruption5(SIGHANDLER_ARGS) Line 2116  interruption5(SIGHANDLER_ARGS)
     }      }
     else      else
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          (*s_etat_processus).arret_depuis_abort = -1;
                 == NULL)  
         {  
             deverrouillage_gestionnaire_signaux();  
             return;  
         }  
   
         // Envoi d'un signal au thread maître du groupe.          // Envoi d'un signal au thread maître du groupe.
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)          if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
         {          {
             pthread_kill(thread, signal);              envoi_signal_contexte(s_thread_principal, rpl_sigabort);
             deverrouillage_gestionnaire_signaux();  
             return;  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
   // Récupération des signaux
   // - SIGHUP
   
 void  void
 interruption6(SIGHANDLER_ARGS)  interruption4(int signal)
 {  {
     pid_t                   pid;      test_signal(signal);
       envoi_signal_processus(getpid(), rpl_sighup);
       return;
   }
   
     struct_processus        *s_etat_processus;  static inline void
   signal_hup(struct_processus *s_etat_processus, pid_t pid)
   {
       file                    *fichier;
   
 #   ifdef _BROKEN_SIGINFO      unsigned char           nom[8 + 64 + 1];
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux(s_etat_processus);
         return;          return;
     }      }
   
       snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),
               (unsigned long) pthread_self());
   
       if ((fichier = fopen(nom, "w+")) != NULL)
       {
           fclose(fichier);
   
           freopen(nom, "w", stdout);
           freopen(nom, "w", stderr);
       }
   
       freopen("/dev/null", "r", stdin);
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] SIGINJECT/SIGQUIT (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
                 (unsigned long long) pthread_self());                  (unsigned long long) pthread_self());
         fflush(stdout);          fflush(stdout);
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  void
 interruption7(SIGHANDLER_ARGS)  traitement_exceptions_gsl(const char *reason, const char *file,
           int line, int gsl_errno)
 {  {
     pid_t                   pid;      code_erreur_gsl = gsl_errno;
       envoi_signal_processus(getpid(), rpl_sigexcept);
     struct_processus        *s_etat_processus;      return;
   }
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();  static inline void
   signal_except(struct_processus *s_etat_processus, pid_t pid)
   {
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux(s_etat_processus);
         return;          return;
     }      }
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      (*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl;
       deverrouillage_gestionnaire_signaux(s_etat_processus);
   
       return;
   }
   
   static inline void
   envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,
           pid_t pid_source)
   {
       switch(signal)
     {      {
         printf("[%d] SIGPIPE (thread %llu)\n", (int) getpid(),          case rpl_signull:
                 (unsigned long long) pthread_self());              break;
         fflush(stdout);  
     }  
   
     (*s_etat_processus).var_volatile_requete_arret = -1;          case rpl_sigint:
     deverrouillage_gestionnaire_signaux();              signal_int(s_etat_processus, pid_source);
               break;
   
           case rpl_sigterm:
               signal_term(s_etat_processus, pid_source);
               break;
   
           case rpl_sigstart:
               signal_start(s_etat_processus, pid_source);
               break;
   
           case rpl_sigcont:
               signal_cont(s_etat_processus, pid_source);
               break;
   
           case rpl_sigstop:
               signal_stop(s_etat_processus, pid_source);
               break;
   
           case rpl_sigabort:
               signal_abort(s_etat_processus, pid_source);
               break;
   
           case rpl_sigurg:
               signal_urg(s_etat_processus, pid_source);
               break;
   
           case rpl_siginject:
               signal_inject(s_etat_processus, pid_source);
               break;
   
           case rpl_sigalrm:
               signal_alrm(s_etat_processus, pid_source);
               break;
   
           case rpl_sighup:
               signal_hup(s_etat_processus, pid_source);
               break;
   
           case rpl_sigtstp:
               signal_tstp(s_etat_processus, pid_source);
               break;
   
           case rpl_sigexcept:
               signal_except(s_etat_processus, pid_source);
               break;
   
           default:
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("+++System : Spurious signal (%d) !\n", signal);
               }
               else
               {
                   printf("+++System : Signal inconnu (%d) !\n", signal);
               }
   
               break;
       }
   
     BUG(1, printf("[%d] SIGPIPE\n", (int) getpid()));  
     return;      return;
 }  }
   
 void  void
 interruption8(SIGHANDLER_ARGS)  scrutation_interruptions(struct_processus *s_etat_processus)
 {  {
     pid_t                   pid;      // Interruptions qui arrivent sur le processus depuis un
       // processus externe.
     pthread_t               thread;  
   
     struct_processus        *s_etat_processus;      // Les pointeurs de lecture pointent sur les prochains éléments
       // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
       // écrire.
   
 #   ifdef _BROKEN_SIGINFO  #   ifndef SEMAPHORES_NOMMES
     pid = origine_signal(signal);          if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
 #   else  #   else
     pid = (*siginfo).si_pid;          if (sem_trywait(semaphore_queue_signaux) == 0)
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     if (pid == getpid())  
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((*s_queue_signaux).pointeur_lecture !=
                 == NULL)                  (*s_queue_signaux).pointeur_ecriture)
         {          {
             deverrouillage_gestionnaire_signaux();              // Il y a un signal en attente dans le segment partagé. On le
             return;              // traite.
         }  
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)              envoi_interruptions(s_etat_processus,
         {                      (*s_queue_signaux).queue[(*s_queue_signaux)
             printf("[%d] SIGURG (thread %llu)\n", (int) getpid(),                      .pointeur_lecture].signal, (*s_queue_signaux).queue
                     (unsigned long long) pthread_self());                      [(*s_queue_signaux).pointeur_lecture].pid);
             fflush(stdout);              (*s_queue_signaux).pointeur_lecture =
                       ((*s_queue_signaux).pointeur_lecture + 1)
                       % LONGUEUR_QUEUE_SIGNAUX;
         }          }
   
         (*s_etat_processus).var_volatile_alarme = -1;  #       ifndef SEMAPHORES_NOMMES
         (*s_etat_processus).var_volatile_requete_arret = -1;              sem_post(&((*s_queue_signaux).semaphore));
   #       else
               sem_post(semaphore_queue_signaux);
   #       endif
     }      }
     else  
     {  
         // Envoi d'un signal au thread maître du groupe.  
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)      // Interruptions qui arrivent depuis le groupe courant de threads.
   
       if (pthread_mutex_trylock(&mutex_interruptions) == 0)
       {
           if ((*s_etat_processus).pointeur_signal_lecture !=
                   (*s_etat_processus).pointeur_signal_ecriture)
         {          {
             pthread_kill(thread, SIGURG);              // Il y a un signal dans la queue du thread courant. On le traite.
             deverrouillage_gestionnaire_signaux();  
             return;              envoi_interruptions(s_etat_processus,
                       (*s_etat_processus).signaux_en_queue
                       [(*s_etat_processus).pointeur_signal_lecture],
                       getpid());
               (*s_etat_processus).pointeur_signal_lecture =
                       ((*s_etat_processus).pointeur_signal_lecture + 1)
                       % LONGUEUR_QUEUE_SIGNAUX;
         }          }
   
           pthread_mutex_unlock(&mutex_interruptions);
     }      }
   
     deverrouillage_gestionnaire_signaux();  
     return;      return;
 }  }
   
 void  /*
 interruption9(SIGHANDLER_ARGS)  ================================================================================
     Fonction renvoyant le nom du segment de mémoire partagée en fonction
     du pid du processus.
   ================================================================================
     Entrée : Chemin absolue servant de racine, pid du processus
   --------------------------------------------------------------------------------
     Sortie : NULL ou nom du segment
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
   static unsigned char *
   nom_segment(unsigned char *chemin, pid_t pid)
 {  {
     pid_t                   pid;      unsigned char               *fichier;
   
   #   ifdef IPCS_SYSV // !POSIX
   #       ifndef OS2 // !OS2
   
               if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
                       sizeof(unsigned char))) == NULL)
               {
                   return(NULL);
               }
   
               sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
   #       else // OS2
               if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   return(NULL);
               }
   
               sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid);
   #       endif // OS2
   #   else // POSIX
   
           if ((fichier = malloc((1 + 256 + 1) *
                   sizeof(unsigned char))) == NULL)
           {
               return(NULL);
           }
   
           sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
   #   endif
   
     struct_processus        *s_etat_processus;      return(fichier);
   }
   
   
   /*
   ================================================================================
     Fonctions d'envoi d'un signal à un thread ou à un processus.
   ================================================================================
     Entrée : processus et signal
   --------------------------------------------------------------------------------
     Sortie : erreur
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
 #   ifdef _BROKEN_SIGINFO  int
     pid = origine_signal(signal);  envoi_signal_processus(pid_t pid, enum signaux_rpl signal)
   {
   #   ifndef OS2
           int                         segment;
   #   endif
   
   #   ifndef IPCS_SYSV
   #       ifdef SEMAPHORES_NOMMES
               sem_t                   *semaphore;
   #       endif
 #   else  #   else
     pid = (*siginfo).si_pid;  #       ifndef OS2
               int                     desc;
               key_t                   clef;
   #       endif
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();      struct_queue_signaux            *queue;
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      unsigned char                   *nom;
     {  
         deverrouillage_gestionnaire_signaux();  
         return;  
     }  
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
       // mémoire puis d'y inscrire le signal à traiter.
   
       if (pid == getpid())
     {      {
         printf("[%d] SIGABORT/SIGPROF (thread %llu)\n", (int) getpid(),          // Le signal est envoyé au même processus.
                 (unsigned long long) pthread_self());  
         fflush(stdout);          if (s_queue_signaux == NULL)
     }          {
               return(1);
           }
   
     deverrouillage_gestionnaire_signaux();  #       ifndef SEMAPHORES_NOMMES
               while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               while(sem_wait(semaphore_queue_signaux) != 0)
   #       endif
           {
               if (errno != EINTR)
               {
                   return(1);
               }
           }
   
           (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   .pid = pid;
           (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   .signal = signal;
   
           (*s_queue_signaux).pointeur_ecriture =
                   ((*s_queue_signaux).pointeur_ecriture + 1)
                   % LONGUEUR_QUEUE_SIGNAUX;
   
 #   ifdef _BROKEN_SIGINFO  #       ifndef SEMAPHORES_NOMMES
     if (queue_in(getpid(), signal) != 0)              if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               if (sem_post(semaphore_queue_signaux) != 0)
   #       endif
           {
               return(1);
           }
       }
       else
     {      {
         return;          // Le signal est envoyé depuis un processus distinct.
   
   #       ifdef IPCS_SYSV
               if ((nom = nom_segment(racine_segment, pid)) == NULL)
               {
                   return(1);
               }
   
   #           ifndef OS2 // SysV
                   if ((desc = open(nom, O_RDWR)) == -1)
                   {
                       free(nom);
                       return(1);
                   }
   
                   close(desc);
   
                   if ((clef = ftok(nom, 1)) == -1)
                   {
                       free(nom);
                       return(1);
                   }
   
                   free(nom);
   
                   if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
                           == -1)
                   {
                       return(1);
                   }
   
                   queue = shmat(segment, NULL, 0);
   #           else // OS/2
                   if (DosGetNamedSharedMem((PVOID) &queue, nom,
                           PAG_WRITE | PAG_READ) != 0)
                   {
                       free(nom);
                       return(1);
                   }
   
                   free(nom);
   #           endif
   #       else // POSIX
               if ((nom = nom_segment(racine_segment, pid)) == NULL)
               {
                   return(1);
               }
   
               if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
               {
                   free(nom);
                   return(1);
               }
   
               free(nom);
   
               if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                       PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
                       MAP_FAILED)
               {
                   close(segment);
                   return(1);
               }
   #       endif
   
               // À ce moment, le segment de mémoire partagée est projeté
               // dans l'espace du processus.
   
   #       ifndef IPCS_SYSV // POSIX
   #           ifndef SEMAPHORES_NOMMES
                   while(sem_wait(&((*queue).semaphore)) != 0)
                   {
                       if (errno != EINTR)
                       {
                           return(1);
                       }
                   }
   #           else
                   if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
                   {
                       return(1);
                   }
   
                   while(sem_wait(semaphore) != 0)
                   {
                       if (errno != EINTR)
                       {
                           sem_close(semaphore);
                           return(1);
                       }
                   }
   #           endif
   #       else // IPCS_SYSV
               while(sem_wait(&((*queue).semaphore)) != 0)
               {
                   if (errno != EINTR)
                   {
                       return(1);
                   }
               }
   #       endif
   
           (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
           (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
   
           (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                   % LONGUEUR_QUEUE_SIGNAUX;
   
   #       ifndef IPCS_SYSV // POSIX
   #           ifndef SEMAPHORES_NOMMES
                   if (sem_post(&((*queue).semaphore)) != 0)
                   {
                       return(1);
                   }
   #           else
                   if (sem_post(semaphore) != 0)
                   {
                       sem_close(semaphore);
                       return(1);
                   }
   
                   if (sem_close(semaphore) != 0)
                   {
                       return(1);
                   }
   #           endif
   
               if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
               {
                   close(segment);
                   return(1);
               }
   #       else // IPCS_SYSV
               if (sem_post(&((*queue).semaphore)) != 0)
               {
                   return(1);
               }
   
   #           ifndef OS2 // SysV
                   if (shmdt(queue) != 0)
                   {
                       return(1);
                   }
   #           else // OS/2
                   // Pendant de DosGetNamedSHaredMem()
   #           endif
   #       endif
     }      }
   
     interruption11(signal);      return(0);
 #   else  
     interruption11(signal, siginfo, context);  
 #   endif  
     return;  
 }  }
   
 void  int
 interruption10(SIGHANDLER_ARGS)  envoi_signal_thread(pthread_t tid, enum signaux_rpl signal)
 {  {
     file                    *fichier;      // Un signal est envoyé d'un thread à un autre thread du même processus.
   
     pid_t                   pid;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
     struct_processus        *s_etat_processus;      struct_processus                        *s_etat_processus;
   
     unsigned char           nom[8 + 64 + 1];      if (pthread_mutex_lock(&mutex_liste_threads) != 0)
       {
 #   ifdef _BROKEN_SIGINFO          return(1);
     pid = origine_signal(signal);      }
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     verrouillage_gestionnaire_signaux();      l_element_courant = liste_threads;
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      while(l_element_courant != NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          if (((*((struct_thread *) (*l_element_courant).donnee)).pid
         return;                  == getpid()) && (pthread_equal((*((struct_thread *)
     }                  (*l_element_courant).donnee)).tid, tid) != 0))
           {
               break;
           }
   
     snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),          l_element_courant = (*l_element_courant).suivant;
             (unsigned long) pthread_self());      }
   
     if ((fichier = fopen(nom, "w+")) != NULL)      if (l_element_courant == NULL)
     {      {
         fclose(fichier);          pthread_mutex_unlock(&mutex_liste_threads);
           return(1);
       }
   
         freopen(nom, "w", stdout);      if (pthread_mutex_lock(&mutex_interruptions) != 0)
         freopen(nom, "w", stderr);      {
           pthread_mutex_unlock(&mutex_liste_threads);
           return(1);
     }      }
   
     freopen("/dev/null", "r", stdin);      s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
               .s_etat_processus;
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      (*s_etat_processus).signaux_en_queue
               [(*s_etat_processus).pointeur_signal_ecriture] = signal;
       (*s_etat_processus).pointeur_signal_ecriture =
               ((*s_etat_processus).pointeur_signal_ecriture + 1)
               % LONGUEUR_QUEUE_SIGNAUX;
   
       if (pthread_mutex_unlock(&mutex_interruptions) != 0)
     {      {
         printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(),          pthread_mutex_unlock(&mutex_liste_threads);
                 (unsigned long long) pthread_self());          return(1);
         fflush(stdout);  
     }      }
   
     deverrouillage_gestionnaire_signaux();      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     return;      {
           return(1);
       }
   
       return(0);
 }  }
   
 void  int
 interruption11(SIGHANDLER_ARGS)  envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
           enum signaux_rpl signal)
 {  {
     pid_t                   pid;      pthread_mutex_lock(&mutex_interruptions);
       (*s_etat_processus_a_signaler).signaux_en_queue
               [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] =
               signal;
       (*s_etat_processus_a_signaler).pointeur_signal_ecriture =
               ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1)
               % LONGUEUR_QUEUE_SIGNAUX;
       pthread_mutex_unlock(&mutex_interruptions);
   
     pthread_t               thread;      return(0);
   }
   
     struct_processus        *s_etat_processus;  
   
 #   ifdef _BROKEN_SIGINFO  /*
     pid = origine_signal(signal);  ================================================================================
 #   else    Fonction créant un segment de mémoire partagée destiné à contenir
     pid = (*siginfo).si_pid;    la queue des signaux.
 #   endif  ================================================================================
     Entrée : structure de description du processus
   --------------------------------------------------------------------------------
     Sortie : Néant
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
     verrouillage_gestionnaire_signaux();  void
   creation_queue_signaux(struct_processus *s_etat_processus)
   {
       unsigned char                   *nom;
   
     if (pid == getpid())      racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
     {  
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  #   ifndef IPCS_SYSV // POSIX
                 == NULL)          if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
                   getpid())) == NULL)
         {          {
             deverrouillage_gestionnaire_signaux();              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         (*s_etat_processus).arret_depuis_abort = -1;          if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
                   S_IRUSR | S_IWUSR)) == -1)
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)  
         {          {
             printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),              free(nom);
                     (unsigned long long) pthread_self());              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             fflush(stdout);              return;
         }          }
   
         /*          if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
          * var_globale_traitement_retarde_stop :  
          *  0 -> traitement immédiat  
          *  1 -> traitement retardé (aucun signal reçu)  
          * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)  
          */  
   
         if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)  
         {          {
             (*s_etat_processus).var_volatile_requete_arret = -1;              free(nom);
         }              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         else              return;
         {  
             (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;  
         }          }
     }  
     else          s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
     {                  PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  
                 == NULL)          if (((void *) s_queue_signaux) == ((void *) -1))
         {          {
             deverrouillage_gestionnaire_signaux();              if (shm_unlink(nom) == -1)
               {
                   free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               free(nom);
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         (*s_etat_processus).arret_depuis_abort = -1;          free(nom);
   
         // Envoi d'un signal au thread maître du groupe.  #       ifndef SEMAPHORES_NOMMES
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
   #       else
               if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
                       == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   #       endif
   
           (*s_queue_signaux).pointeur_lecture = 0;
           (*s_queue_signaux).pointeur_ecriture = 0;
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)          if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
         {          {
             pthread_kill(thread, signal);              (*s_etat_processus).erreur_systeme = d_es_processus;
             deverrouillage_gestionnaire_signaux();  
             return;              return;
         }          }
     }  #   else // IPCS_SYSV
   #       ifndef OS2
               int                             segment;
               int                             support;
   
               key_t                           clef;
   
               // Création d'un segment de données associé au PID du processus
               // courant
   
               if ((nom = nom_segment((*s_etat_processus)
                       .chemin_fichiers_temporaires, getpid())) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL,
                       S_IRUSR | S_IWUSR)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
   
               if ((clef = ftok(nom, 1)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               close(support);
               free(nom);
   
               if ((segment = shmget(clef, sizeof(struct_queue_signaux),
                       IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               s_queue_signaux = shmat(segment, NULL, 0);
               f_queue_signaux = segment;
   
               if (((void *) s_queue_signaux) == ((void *) -1))
               {
                   if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
   #       else // OS/2
               if ((nom = nom_segment(NULL, getpid())) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom,
                       sizeof(struct_queue_signaux),
                       PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
               {
                   free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               free(nom);
   
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
   #       endif
   #   endif
   
     deverrouillage_gestionnaire_signaux();  
     return;      return;
 }  }
   
   
   /*
   ================================================================================
     Fonction libérant le segment de mémoire partagée destiné à contenir
     la queue des signaux.
   ================================================================================
     Entrée : structure de description du processus
   --------------------------------------------------------------------------------
     Sortie : Néant
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
 void  void
 traitement_exceptions_gsl(const char *reason, const char *file,  liberation_queue_signaux(struct_processus *s_etat_processus)
         int line, int gsl_errno)  
 {  {
     struct_processus        *s_etat_processus;  #   ifdef IPCS_SYSV // SystemV
   #       ifndef OS2
               if (shmdt(s_queue_signaux) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   #       else // OS/2
   #       endif
   #   else // POSIX
   #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
   #       else
               sem_close(semaphore_queue_signaux);
   #       endif
   
     verrouillage_gestionnaire_signaux();          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)          close(f_queue_signaux);
     {  #   endif
         deverrouillage_gestionnaire_signaux();  
         return;  
     }  
   
     (*s_etat_processus).var_volatile_exception_gsl = gsl_errno;  
     deverrouillage_gestionnaire_signaux();  
     return;      return;
 }  }
   
 #ifdef _BROKEN_SIGINFO  
   
 #undef kill  /*
 #undef pthread_kill  ================================================================================
     Fonction détruisant le segment de mémoire partagée destiné à contenir
     la queue des signaux.
   ================================================================================
     Entrée : structure de description du processus
   --------------------------------------------------------------------------------
     Sortie : Néant
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
 int  void
 rpl_kill(pid_t pid, int signal)  destruction_queue_signaux(struct_processus *s_etat_processus)
 {  {
     /*  #   ifndef OS2
      * Lorsqu'on veut interrompre le processus pid, on ouvre le segment          unsigned char       *nom;
      * correspondant au processus en question et ou ajoute le pid dans la  #   endif
      * queue.  
      */  
   
     if ((signal != 0) && (signal != SIGINT))  #   ifdef IPCS_SYSV // SystemV
     {  #       ifndef OS2
         if (queue_in(pid, signal) != 0)              // Il faut commencer par éliminer le sémaphore.
   
               if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               unlink((*s_queue_signaux).semaphore.path);
   
               if (shmdt(s_queue_signaux) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if ((nom = nom_segment((*s_etat_processus)
                       .chemin_fichiers_temporaires, getpid())) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               unlink(nom);
               free(nom);
   #       else
               sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   
               if (DosFreeMem(s_queue_signaux) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   #       endif
   #   else // POSIX
   #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   #       else
               sem_close(semaphore_queue_signaux);
               sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
   #       endif
   
           if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
         {          {
             return(-1);              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
         }          }
     }  
   
     return(kill(pid, signal));          if ((nom = nom_segment(NULL, getpid())) == NULL)
 }          {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
 int          close(f_queue_signaux);
 rpl_pthread_kill(pthread_t tid, int signal)  
 {          if (shm_unlink(nom) != 0)
     if ((signal != 0) && (signal != SIGINT))  
     {  
         if (queue_in(getpid(), signal) != 0)  
         {          {
             return(-1);              free(nom);
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
         }          }
     }  
   
     return(pthread_kill(tid, signal));          free(nom);
 }  #   endif
   
 #endif      return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.31  
changed lines
  Added in v.1.86

CVSweb interface <joel.bertrand@systella.fr>