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

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

version 1.7, 2010/04/07 13:45:09 version 1.212, 2025/04/15 10:17:56
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.14    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 52  typedef struct liste_chainee_volatile Line 52  typedef struct liste_chainee_volatile
     volatile void                           *donnee;      volatile void                           *donnee;
 } struct_liste_chainee_volatile;  } struct_liste_chainee_volatile;
   
   
 static volatile struct_liste_chainee_volatile   *liste_threads  static volatile struct_liste_chainee_volatile   *liste_threads
         = 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 void *
   thread_surveillance_signaux(void *argument)
   {
       // Cette fonction est lancée dans un thread créé par processus pour
       // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du
       // signal SIGUSR2. Les processus externes n'envoient plus un signal au
       // processus ou au thread à signaler mais positionnent les informations
       // nécessaires dans la queue des signaux et incrémentent le sémaphore.
       // Le sémaphore est décrémenté lorsque le signal est effectivement traité.
   
       int                                     nombre_signaux_envoyes;
   
       struct_processus                        *s_etat_processus;
   
       struct timespec                         attente;
   
       volatile struct_liste_chainee_volatile  *l_element_courant;
   
       sigset_t                                set;
   
       sigfillset(&set);
       pthread_sigmask(SIG_BLOCK, &set, NULL);
   
       s_etat_processus = (struct_processus *) argument;
   
       for(;;)
       {
           attente.tv_sec = 0;
           attente.tv_nsec = GRANULARITE_us * 1000;
   
           if (sem_wait(semaphore_signalisation) == 0)
           {
               while(sem_wait(semaphore_arret_signalisation) != 0)
               {
                   if (errno != EINTR)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                   }
               }
   
               if ((*s_queue_signaux).requete_arret == d_vrai)
               {
                   sem_post(semaphore_arret_signalisation);
                   sem_post(semaphore_signalisation);
   
                   break;
               }
   
               sem_post(semaphore_signalisation);
   
               nombre_signaux_envoyes = 0;
   
               // Dans un premier temps, on verrouille la queue des signaux
               // affectée au processus courant pour vérifier s'il y a quelque
               // chose à traiter.
   
               while(sem_wait(semaphore_queue_signaux) != 0)
               {
                   if (errno != EINTR)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                   }
               }
   
               if ((*s_queue_signaux).pointeur_lecture !=
                       (*s_queue_signaux).pointeur_ecriture)
               {
                   // Attention : raise() envoit le signal au thread appelant !
                   // kill() l'envoie au processus appelant, donc dans notre
                   // cas à un thread aléatoire du processus, ce qui nous
                   // convient tout à fait puisqu'il s'agit de débloquer les
                   // appels système lents.
   
                   nombre_signaux_envoyes++;
                   kill(getpid(), SIGUSR2);
                   sched_yield();
               }
   
               sem_post(semaphore_queue_signaux);
               sem_post(semaphore_arret_signalisation);
   
               // Dans un second temps, on balaye toutes les queues de signaux
               // des threads du processus courant.
   
               // Attention : l'ordre de verrouillage des mutexes est important
               // pour éviter les conditions bloquantes !
   
               pthread_mutex_lock(&mutex_liste_threads);
   
               l_element_courant = liste_threads;
   
               while(l_element_courant != NULL)
               {
                   if ((*((struct_thread *) (*l_element_courant).donnee)).pid
                           == getpid())
                   {
                       pthread_mutex_lock(&((*(*((struct_thread *)
                               (*l_element_courant).donnee)).s_etat_processus)
                               .mutex_signaux));
   
                       if ((*(*((struct_thread *) (*l_element_courant).donnee))
                               .s_etat_processus).pointeur_signal_ecriture !=
                               (*(*((struct_thread *) (*l_element_courant)
                               .donnee)).s_etat_processus).pointeur_signal_lecture)
                       {
                           nombre_signaux_envoyes++;
                           pthread_kill((*((struct_thread *)
                                   (*l_element_courant).donnee)).tid, SIGUSR2);
                           sched_yield();
                       }
   
                       pthread_mutex_unlock(&((*(*((struct_thread *)
                               (*l_element_courant).donnee)).s_etat_processus)
                               .mutex_signaux));
                   }
   
                   l_element_courant = (*l_element_courant).suivant;
               }
   
               pthread_mutex_unlock(&mutex_liste_threads);
   
               // Nanosleep
   
               if (nombre_signaux_envoyes > 0)
               {
                   nanosleep(&attente, NULL);
               }
           }
           else
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
               }
           }
       }
   
       pthread_exit(NULL);
   }
   
 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 216  modification_pid_thread_pere(struct_proc
 void  void
 insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)  insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal)
 {  {
     sigset_t                                    oldset;      int                                         ios;
     sigset_t                                    set;  
   
     volatile struct_liste_chainee_volatile      *l_nouvel_objet;  
   
     sigfillset(&set);  
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
     while(sem_wait(&semaphore_liste_threads) == -1)      struct timespec                             attente;
     {  
         if (errno != EINTR)  
         {  
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;      volatile struct_liste_chainee_volatile      *l_nouvel_objet;
             return;  
         }  
     }  
   
     if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))      if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
             == NULL)              == NULL)
     {      {
         sem_post(&semaphore_liste_threads);  
         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;
     }      }
   
     (*l_nouvel_objet).suivant = liste_threads;  
   
     if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)      if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL)
     {      {
         sem_post(&semaphore_liste_threads);  
         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 124  insertion_thread(struct_processus *s_eta Line 242  insertion_thread(struct_processus *s_eta
     (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =      (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
             s_etat_processus;              s_etat_processus;
   
     liste_threads = l_nouvel_objet;      attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
     if (sem_post(&semaphore_liste_threads) != 0)      while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          if (ios != EBUSY)
         sigpending(&set);          {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
   
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
       }
   
       (*l_nouvel_objet).suivant = liste_threads;
       liste_threads = l_nouvel_objet;
   
       if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
       {
         (*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 144  void Line 288  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);  
   
     while(sem_wait(&semaphore_liste_threads) == -1)  
     {  
         if (errno != EINTR)  
         {  
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
     }  
   
     if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))      if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
             == NULL)              == NULL)
     {      {
         sem_post(&semaphore_liste_threads);  
         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 (pthread_mutex_lock(&mutex_liste_threads_surveillance) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
       (*s_argument_thread).nombre_references++;
       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;
   
     if (sem_post(&semaphore_liste_threads) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
     {      {
         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;      int                                     ios;
     sigset_t                                set;  
       struct timespec                         attente;
   
     volatile struct_liste_chainee_volatile  *l_element_precedent;      volatile struct_liste_chainee_volatile  *l_element_precedent;
     volatile struct_liste_chainee_volatile  *l_element_courant;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
     sigfillset(&set);      attente.tv_sec = 0;
     pthread_sigmask(SIG_BLOCK, &set, &oldset);      attente.tv_nsec = GRANULARITE_us * 1000;
   
     while(sem_wait(&semaphore_liste_threads) == -1)      while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
     {      {
         if (errno != EINTR)          if (ios != EBUSY)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              (*s_etat_processus).erreur_systeme = d_es_processus;
             sigpending(&set);              return;
           }
   
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
           {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
   
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
     }      }
   
     l_element_precedent = NULL;      l_element_precedent = NULL;
Line 236  retrait_thread(struct_processus *s_etat_ Line 379  retrait_thread(struct_processus *s_etat_
   
     if (l_element_courant == NULL)      if (l_element_courant == NULL)
     {      {
         sem_post(&semaphore_liste_threads);          pthread_mutex_unlock(&mutex_liste_threads);
         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 253  retrait_thread(struct_processus *s_etat_ Line 393  retrait_thread(struct_processus *s_etat_
         (*l_element_precedent).suivant = (*l_element_courant).suivant;          (*l_element_precedent).suivant = (*l_element_courant).suivant;
     }      }
   
     free((void *) (*l_element_courant).donnee);      if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
     free((struct_liste_chainee_volatile *) l_element_courant);  
   
     if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
   
         sem_post(&semaphore_liste_threads);  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
         return;          return;
     }      }
   
     if (sem_post(&semaphore_liste_threads) != 0)      // Le thread ne peut plus traiter de signaux explicites. Il convient
       // alors de corriger le sémaphore pour annuler les signaux en attente.
   
       while((*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus)
               .pointeur_signal_ecriture != (*(*((struct_thread *)
               (*l_element_courant).donnee)).s_etat_processus)
               .pointeur_signal_lecture)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          while(sem_wait(semaphore_signalisation) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
   
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          (*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus)
         sigpending(&set);                  .pointeur_signal_lecture = ((*(*((struct_thread *)
         return;                  (*l_element_courant).donnee)).s_etat_processus)
                   .pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX;
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);      free((void *) (*l_element_courant).donnee);
     sigpending(&set);      free((struct_liste_chainee_volatile *) l_element_courant);
   
     return;      return;
 }  }
   
Line 284  void Line 432  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_surveillance) != 0)
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
     while(sem_wait(&semaphore_liste_threads) == -1)  
     {      {
         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 321  retrait_thread_surveillance(struct_proce Line 457  retrait_thread_surveillance(struct_proce
   
     if (l_element_courant == NULL)      if (l_element_courant == NULL)
     {      {
         sem_post(&semaphore_liste_threads);          pthread_mutex_unlock(&mutex_liste_threads_surveillance);
         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 338  retrait_thread_surveillance(struct_proce Line 471  retrait_thread_surveillance(struct_proce
         (*l_element_precedent).suivant = (*l_element_courant).suivant;          (*l_element_precedent).suivant = (*l_element_courant).suivant;
     }      }
   
     free((struct_liste_chainee_volatile *) l_element_courant);      if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
               != 0)
     if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)  
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          pthread_mutex_unlock(&mutex_liste_threads_surveillance);
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
Line 357  retrait_thread_surveillance(struct_proce Line 487  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)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              pthread_mutex_unlock(&mutex_liste_threads_surveillance);
             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)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              pthread_mutex_unlock(&mutex_liste_threads_surveillance);
             sigpending(&set);  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
     }      }
   
     if (sem_post(&semaphore_liste_threads) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
     {      {
         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);      free((struct_liste_chainee_volatile *) l_element_courant);
     sigpending(&set);  
     return;      return;
 }  }
   
 void  void
 verrouillage_threads_concurrents(struct_processus *s_etat_processus)  verrouillage_threads_concurrents(struct_processus *s_etat_processus)
 {  {
       int                                     ios;
   
       struct timespec                         attente;
   
     volatile struct_liste_chainee_volatile  *l_element_courant;      volatile struct_liste_chainee_volatile  *l_element_courant;
   
     while(sem_wait(&semaphore_liste_threads) == -1)      attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
       while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
     {      {
         if (errno != EINTR)          if (ios != EBUSY)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   
           if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
   
           while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
           {
               if (errno != EINTR)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
     }      }
   
     l_element_courant = liste_threads;      l_element_courant = liste_threads;
Line 417  verrouillage_threads_concurrents(struct_ Line 567  verrouillage_threads_concurrents(struct_
                 == getpid()) && (pthread_equal((*((struct_thread *)                  == getpid()) && (pthread_equal((*((struct_thread *)
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
             while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)  #           ifndef SEMAPHORES_NOMMES
                     .donnee)).s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
                           .donnee)).s_etat_processus).semaphore_fork)) == -1)
   #           else
                   while(sem_wait((*(*((struct_thread *) (*l_element_courant)
                           .donnee)).s_etat_processus).semaphore_fork) == -1)
   #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 447  deverrouillage_threads_concurrents(struc Line 602  deverrouillage_threads_concurrents(struc
                 == getpid()) && (pthread_equal((*((struct_thread *)                  == getpid()) && (pthread_equal((*((struct_thread *)
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
             if (sem_post(&((*(*((struct_thread *)  #           ifndef SEMAPHORES_NOMMES
                     (*l_element_courant).donnee)).s_etat_processus)                  if (sem_post(&((*(*((struct_thread *)
                     .semaphore_fork)) != 0)                          (*l_element_courant).donnee)).s_etat_processus)
                           .semaphore_fork)) != 0)
   #           else
                   if (sem_post((*(*((struct_thread *)
                           (*l_element_courant).donnee)).s_etat_processus)
                           .semaphore_fork) != 0)
   #           endif
             {              {
                 if (sem_post(&semaphore_liste_threads) != 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;
                     return;                      return;
Line 465  deverrouillage_threads_concurrents(struc Line 626  deverrouillage_threads_concurrents(struc
         l_element_courant = (*l_element_courant).suivant;          l_element_courant = (*l_element_courant).suivant;
     }      }
   
     if (sem_post(&semaphore_liste_threads) != 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;
         return;          return;
Line 479  liberation_threads(struct_processus *s_e Line 640  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;
   
     unsigned long                               i;      struct_liste_variables_partagees            *l_element_partage_courant;
       struct_liste_variables_partagees            *l_element_partage_suivant;
   
       struct_liste_variables_statiques            *l_element_statique_courant;
       struct_liste_variables_statiques            *l_element_statique_suivant;
   
       integer8                                    i;
   
     void                                        *element_candidat;      void                                        *element_candidat;
     void                                        *element_courant;      void                                        *element_courant;
Line 495  liberation_threads(struct_processus *s_e Line 659  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);  
   
     while(sem_wait(&semaphore_liste_threads) == -1)  
     {      {
         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 536  liberation_threads(struct_processus *s_e Line 693  liberation_threads(struct_processus *s_e
             close((*s_etat_processus).pipe_injections);              close((*s_etat_processus).pipe_injections);
             close((*s_etat_processus).pipe_nombre_injections);              close((*s_etat_processus).pipe_nombre_injections);
             close((*s_etat_processus).pipe_interruptions);              close((*s_etat_processus).pipe_interruptions);
             close((*s_etat_processus).pipe_nombre_objets_attente);              close((*s_etat_processus).pipe_nombre_elements_attente);
             close((*s_etat_processus).pipe_nombre_interruptions_attente);  
               liberation(s_etat_processus, (*s_etat_processus).at_exit);
   
             if ((*s_etat_processus).nom_fichier_impression != NULL)              if ((*s_etat_processus).nom_fichier_impression != NULL)
             {              {
Line 580  liberation_threads(struct_processus *s_e Line 738  liberation_threads(struct_processus *s_e
                     .l_base_pile_processus;                      .l_base_pile_processus;
             while(element_courant != NULL)              while(element_courant != NULL)
             {              {
                 pthread_mutex_trylock(&((*(*((struct_liste_chainee *)                  s_argument_thread = (struct_descripteur_thread *)
                         element_courant)).donnee).mutex));                          (*((struct_liste_chainee *) element_courant)).donnee;
                 pthread_mutex_unlock(&((*(*((struct_liste_chainee *)  
                         element_courant)).donnee).mutex));                  if (pthread_mutex_lock(&((*s_argument_thread)
                 liberation(s_etat_processus,                          .mutex_nombre_references)) != 0)
                         (*((struct_liste_chainee *) element_courant)).donnee);                  {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       pthread_mutex_unlock(&mutex_liste_threads);
                       return;
                   }
   
                   (*s_argument_thread).nombre_references--;
   
                   BUG((*s_argument_thread).nombre_references < 0,
                           printf("(*s_argument_thread).nombre_references = %d\n",
                           (int) (*s_argument_thread).nombre_references));
   
                   if ((*s_argument_thread).nombre_references == 0)
                   {
                       close((*s_argument_thread).pipe_objets[0]);
                       close((*s_argument_thread).pipe_acquittement[1]);
                       close((*s_argument_thread).pipe_injections[1]);
                       close((*s_argument_thread).pipe_nombre_injections[1]);
                       close((*s_argument_thread).pipe_nombre_elements_attente[0]);
                       close((*s_argument_thread).pipe_interruptions[0]);
   
                       if (pthread_mutex_unlock(&((*s_argument_thread)
                               .mutex_nombre_references)) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           pthread_mutex_unlock(&mutex_liste_threads);
                           return;
                       }
   
                       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).destruction_objet == d_vrai)
                           {
                               liberation(s_etat_processus, (*s_argument_thread)
                                       .argument);
                           }
                       }
   
                       free(s_argument_thread);
                   }
                   else
                   {
                       if (pthread_mutex_unlock(&((*s_argument_thread)
                               .mutex_nombre_references)) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           pthread_mutex_unlock(&mutex_liste_threads);
                           return;
                       }
                   }
   
                 element_suivant = (*((struct_liste_chainee *) element_courant))                  element_suivant = (*((struct_liste_chainee *) element_courant))
                         .suivant;                          .suivant;
                 free((struct_liste_chainee *) element_courant);                  free(element_courant);
                 element_courant = element_suivant;                  element_courant = element_suivant;
             }              }
   
               (*s_etat_processus).l_base_pile_processus = NULL;
   
             pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));              pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));
             pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));              pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));
             liberation(s_etat_processus, (*s_etat_processus).indep);              liberation(s_etat_processus, (*s_etat_processus).indep);
Line 648  liberation_threads(struct_processus *s_e Line 862  liberation_threads(struct_processus *s_e
                 }                  }
             }              }
   
             for(i = 0; i < (*s_etat_processus).nombre_variables; i++)  
             {  
                 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++)  
             {  
                 pthread_mutex_trylock(&((*(*s_etat_processus)  
                         .s_liste_variables_statiques[i].objet).mutex));  
                 pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_statiques[i].objet).mutex));  
   
                 liberation(s_etat_processus, (*s_etat_processus)  
                         .s_liste_variables_statiques[i].objet);  
                 free((*s_etat_processus).s_liste_variables_statiques[i].nom);  
             }  
   
             free((*s_etat_processus).s_liste_variables_statiques);  
   
             // Ne peut être effacé qu'une seule fois              // Ne peut être effacé qu'une seule fois
             if (suppression_variables_partagees == d_faux)              if (suppression_variables_partagees == d_faux)
             {              {
                 suppression_variables_partagees = d_vrai;                  suppression_variables_partagees = d_vrai;
   
                 for(i = 0; i < (*(*s_etat_processus)                  liberation_arbre_variables_partagees(s_etat_processus,
                         .s_liste_variables_partagees).nombre_variables; i++)                          (*(*s_etat_processus).s_arbre_variables_partagees));
                 {                  (*(*s_etat_processus).s_arbre_variables_partagees) = NULL;
                     pthread_mutex_trylock(&((*(*(*s_etat_processus)  
                             .s_liste_variables_partagees).table[i].objet)  
                             .mutex));  
                     pthread_mutex_unlock(&((*(*(*s_etat_processus)  
                             .s_liste_variables_partagees).table[i].objet)  
                             .mutex));  
   
                     liberation(s_etat_processus, (*(*s_etat_processus)                  l_element_partage_courant = (*(*s_etat_processus)
                             .s_liste_variables_partagees).table[i].objet);                          .l_liste_variables_partagees);
                     free((*(*s_etat_processus).s_liste_variables_partagees)  
                             .table[i].nom);  
                 }  
   
                 if ((*(*s_etat_processus).s_liste_variables_partagees).table                  while(l_element_partage_courant != NULL)
                         != NULL)  
                 {                  {
                     free((struct_variable_partagee *) (*(*s_etat_processus)                      l_element_partage_suivant =
                             .s_liste_variables_partagees).table);                              (*l_element_partage_courant).suivant;
                       free(l_element_partage_courant);
                       l_element_partage_courant = l_element_partage_suivant;
                 }                  }
   
                 pthread_mutex_trylock(&((*(*s_etat_processus)                  (*(*s_etat_processus).l_liste_variables_partagees) = NULL;
                         .s_liste_variables_partagees).mutex));              }
                 pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_partagees).mutex));              liberation_arbre_variables(s_etat_processus,
                       (*s_etat_processus).s_arbre_variables, d_faux);
   
               l_element_statique_courant = (*s_etat_processus)
                       .l_liste_variables_statiques;
   
               while(l_element_statique_courant != NULL)
               {
                   l_element_statique_suivant =
                       (*l_element_statique_courant).suivant;
                   free(l_element_statique_courant);
                   l_element_statique_courant = l_element_statique_suivant;
             }              }
   
             element_courant = (*s_etat_processus).l_base_pile;              element_courant = (*s_etat_processus).l_base_pile;
Line 1066  liberation_threads(struct_processus *s_e Line 1249  liberation_threads(struct_processus *s_e
                 element_courant = element_suivant;                  element_courant = element_suivant;
             }              }
   
   /*
   ================================================================================
     À noter : on ne ferme pas la connexion car la conséquence immédiate est
     une destruction de l'objet pour le processus père.
   ================================================================================
   
             element_courant = (*s_etat_processus).s_connecteurs_sql;              element_courant = (*s_etat_processus).s_connecteurs_sql;
             while(element_courant != NULL)              while(element_courant != NULL)
             {              {
Line 1149  liberation_threads(struct_processus *s_e Line 1338  liberation_threads(struct_processus *s_e
   
                 element_courant = element_suivant;                  element_courant = element_suivant;
             }              }
   */
   
               (*s_etat_processus).s_connecteurs_sql = NULL;
   
             element_courant = (*s_etat_processus).s_marques;              element_courant = (*s_etat_processus).s_marques;
             while(element_courant != NULL)              while(element_courant != NULL)
Line 1163  liberation_threads(struct_processus *s_e Line 1355  liberation_threads(struct_processus *s_e
   
             liberation_allocateur(s_etat_processus);              liberation_allocateur(s_etat_processus);
   
             sem_post(&((*s_etat_processus).semaphore_fork));  #           ifndef SEMAPHORES_NOMMES
             sem_destroy(&((*s_etat_processus).semaphore_fork));                  sem_post(&((*s_etat_processus).semaphore_fork));
                   sem_destroy(&((*s_etat_processus).semaphore_fork));
             free(s_etat_processus);  #           else
                   sem_post((*s_etat_processus).semaphore_fork);
                   sem_close((*s_etat_processus).semaphore_fork);
   #           endif
   
               liberation_contexte_cas(s_etat_processus);
               liberation_allocateur_buffer(s_etat_processus);
               sys_free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
         }          }
Line 1181  liberation_threads(struct_processus *s_e Line 1380  liberation_threads(struct_processus *s_e
   
     liste_threads = NULL;      liste_threads = NULL;
   
       if (pthread_mutex_unlock(&mutex_liste_threads) == -1)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (pthread_mutex_lock(&mutex_liste_threads_surveillance) == -1)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     l_element_courant = liste_threads_surveillance;      l_element_courant = liste_threads_surveillance;
   
     while(l_element_courant != NULL)      while(l_element_courant != NULL)
Line 1188  liberation_threads(struct_processus *s_e Line 1399  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;
   
         close((*s_argument_thread).pipe_objets[0]);          if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
         close((*s_argument_thread).pipe_acquittement[1]);                  != 0)
         close((*s_argument_thread).pipe_injections[1]);  
         close((*s_argument_thread).pipe_nombre_injections[1]);  
         close((*s_argument_thread).pipe_nombre_objets_attente[0]);  
         close((*s_argument_thread).pipe_interruptions[0]);  
         close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);  
   
         if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
               pthread_mutex_unlock(&mutex_liste_threads_surveillance);
             return;              return;
         }          }
   
Line 1210  liberation_threads(struct_processus *s_e Line 1415  liberation_threads(struct_processus *s_e
   
         if ((*s_argument_thread).nombre_references == 0)          if ((*s_argument_thread).nombre_references == 0)
         {          {
             if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)              close((*s_argument_thread).pipe_objets[0]);
               close((*s_argument_thread).pipe_acquittement[1]);
               close((*s_argument_thread).pipe_injections[1]);
               close((*s_argument_thread).pipe_nombre_injections[1]);
               close((*s_argument_thread).pipe_nombre_elements_attente[0]);
               close((*s_argument_thread).pipe_interruptions[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;
                   pthread_mutex_unlock(&mutex_liste_threads_surveillance);
                 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).destruction_objet == d_vrai)
                   {
                       liberation(s_etat_processus, (*s_argument_thread).argument);
                   }
               }
   
             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)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                   pthread_mutex_unlock(&mutex_liste_threads_surveillance);
                 return;                  return;
             }              }
         }          }
Line 1235  liberation_threads(struct_processus *s_e Line 1462  liberation_threads(struct_processus *s_e
   
     liste_threads_surveillance = NULL;      liste_threads_surveillance = NULL;
   
     if (sem_post(&semaphore_liste_threads) != 0)      if (pthread_mutex_unlock(&mutex_liste_threads_surveillance) != 0)
     {      {
         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 1254  recherche_thread(pid_t pid, pthread_t ti Line 1478  recherche_thread(pid_t pid, pthread_t ti
   
     struct_processus                            *s_etat_processus;      struct_processus                            *s_etat_processus;
   
       if (pthread_mutex_lock(&mutex_liste_threads) != 0)
       {
           return(NULL);
       }
   
     l_element_courant = liste_threads;      l_element_courant = liste_threads;
   
     while(l_element_courant != NULL)      while(l_element_courant != NULL)
Line 1274  recherche_thread(pid_t pid, pthread_t ti Line 1503  recherche_thread(pid_t pid, pthread_t ti
          * Le processus n'existe plus. On ne distribue aucun signal.           * Le processus n'existe plus. On ne distribue aucun signal.
          */           */
   
           pthread_mutex_unlock(&mutex_liste_threads);
         return(NULL);          return(NULL);
     }      }
   
     s_etat_processus = (*((struct_thread *)      s_etat_processus = (*((struct_thread *)
             (*l_element_courant).donnee)).s_etat_processus;              (*l_element_courant).donnee)).s_etat_processus;
   
       if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
       {
           return(NULL);
       }
   
     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 1308  recherche_thread_principal(pid_t pid, pt Line 1543  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 1330  recherche_thread_principal(pid_t pid, pt Line 1564  recherche_thread_principal(pid_t pid, pt
 */  */
   
 // Les routines suivantes sont uniquement appelées depuis les gestionnaires  // Les routines suivantes sont uniquement appelées depuis les gestionnaires
 // des signaux asynchrones. Elles de doivent pas bloquer dans le cas où  // des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où
 // 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;      return;
   
     sigset_t    oldset;  
     sigset_t    set;  
   
     sem_t       *sem;  
   
     if ((sem = pthread_getspecific(semaphore_fork_processus_courant))  #   ifndef SEMAPHORES_NOMMES
             != NULL)      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         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 !      return;
   }
   
     sigfillset(&set);  static inline void
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus)
   {
       return;
   
     while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)  #   ifndef SEMAPHORES_NOMMES
       while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
       while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         if (errno != EINTR)          if (errno != EINTR)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
             BUG(1, uprintf("Unlock error !\n"));              BUG(1, uprintf("Unlock error !\n"));
             return;              return;
         }          }
     }      }
   
     if (sem_post(&semaphore_gestionnaires_signaux) == -1)      return;
   }
   
   /*
   ================================================================================
     Fonctions de gestion des signaux dans les threads.
   
     Lorsqu'un processus reçoit un signal, il appelle le gestionnaire de signal
     associé qui ne fait qu'envoyer au travers de write() le signal
     reçus dans un pipe. Un second thread est bloqué sur ce pipe et
     effectue le traitement adéquat pour le signal donné.
   ================================================================================
   */
   
   #define test_signal(signal) \
       if (signal_test == SIGTEST) { signal_test = signal; return; }
   
   static int          pipe_signaux;
   
   logical1
   lancement_thread_signaux(struct_processus *s_etat_processus)
   {
       pthread_attr_t                  attributs;
   
       if (pipe((*s_etat_processus).pipe_signaux) != 0)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          (*s_etat_processus).erreur_systeme = d_es_processus;
         BUG(1, uprintf("Lock error !\n"));          return(d_erreur);
         return;  
     }      }
   
     if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)      pipe_signaux = (*s_etat_processus).pipe_signaux[1];
   
       if (pthread_attr_init(&attributs) != 0)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          (*s_etat_processus).erreur_systeme = d_es_processus;
         BUG(1, uprintf("Lock error !\n"));          return(d_erreur);
         return;  
     }      }
   
     if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)      if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          (*s_etat_processus).erreur_systeme = d_es_processus;
         BUG(1, uprintf("Unlock error !\n"));          return(d_erreur);
         return;  
     }      }
   
     if (semaphore == 1)      if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,
               thread_signaux, s_etat_processus) != 0)
     {      {
         // Le semaphore ne peut être pris par le thread qui a appelé          (*s_etat_processus).erreur_systeme = d_es_processus;
         // le gestionnaire de signal car le signal est bloqué par ce thread          return(d_erreur);
         // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que      }
         // par un thread concurrent. On essaye donc de le bloquer jusqu'à  
         // ce que ce soit possible.  
   
         while(sem_trywait(&semaphore_liste_threads) == -1)      if (pthread_attr_destroy(&attributs) != 0)
         {      {
             if ((errno != EINTR) && (errno != EAGAIN))          (*s_etat_processus).erreur_systeme = d_es_processus;
             {          return(d_erreur);
                 pthread_sigmask(SIG_SETMASK, &oldset, NULL);      }
   
                 while(sem_wait(sem) == -1)      return(d_absence_erreur);
                 {  }
                     if (errno != EINTR)  
                     {  
                         BUG(1, uprintf("Lock error !\n"));  
                         return;  
                     }  
                 }  
   
                 BUG(1, uprintf("Lock error !\n"));  logical1
                 return;  arret_thread_signaux(struct_processus *s_etat_processus)
             }  {
       unsigned char       signal;
       ssize_t             n;
   
       signal = (unsigned char ) (rpl_sigmax & 0xFF);
   
       do
       {
           n = write_atomic(s_etat_processus, (*s_etat_processus).pipe_signaux[1],
                   &signal, sizeof(signal));
   
             sched_yield();          if (n < 0)
           {
               return(d_erreur);
         }          }
     }      } while(n != 1);
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);      pthread_join((*s_etat_processus).thread_signaux, NULL);
     sigpending(&set);  
   
     return;      close((*s_etat_processus).pipe_signaux[1]);
       return(d_absence_erreur);
 }  }
   
 static inline void  void *
 deverrouillage_gestionnaire_signaux()  thread_signaux(void *argument)
 {  {
     int         semaphore;      int                     *pipe;
   
     sem_t       *sem;      sigset_t                masque;
   
     sigset_t    oldset;      struct pollfd           fds;
     sigset_t    set;  
   
     // Il faut respecteur l'atomicité des deux opérations suivantes !      struct_processus        *s_etat_processus;
   
     sigfillset(&set);      unsigned char           signal;
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
       s_etat_processus = (struct_processus *) argument;
       pipe = (*s_etat_processus).pipe_signaux;
       fds.fd = pipe[0];
       fds.events = POLLIN;
   
     while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1)      sigfillset(&masque);
       pthread_sigmask(SIG_BLOCK, &masque, NULL);
   
       do
     {      {
         if (errno != EINTR)          fds.revents = 0;
   
           while(poll(&fds, 1, -1) == -1)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              if (errno != EINTR)
             BUG(1, uprintf("Unlock error !\n"));              {
             return;                  close((*s_etat_processus).pipe_signaux[0]);
                   pthread_exit(NULL);
               }
         }          }
     }  
   
     if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0)          if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)
     {          {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);              close((*s_etat_processus).pipe_signaux[0]);
         BUG(1, uprintf("Unlock error !\n"));              pthread_exit(NULL);
         return;          }
     }  
           if (signal != (0xFF & rpl_sigmax))
           {
               envoi_signal_processus(getpid(), signal, d_faux);
               // Un signal SIGUSR2 est envoyé par le thread de surveillance
               // des signaux jusqu'à ce que les signaux soient tous traités.
           }
       } while(signal != (0xFF & rpl_sigmax));
   
       close((*s_etat_processus).pipe_signaux[0]);
       pthread_exit(NULL);
   }
   
   
   static inline void
   _write(int fd, const void *buf, size_t count)
   {
       ssize_t         ios;
   
     while(sem_wait(&semaphore_gestionnaires_signaux) == -1)      while((ios = write(fd, buf, count)) == -1)
     {      {
         if (errno != EINTR)          if (errno != EINTR)
         {          {
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              break;
             BUG(1, uprintf("Unlock error !\n"));  
             return;  
         }          }
     }      }
   
     if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0)      return;
   }
   
   
   // Récupération des signaux
   // - SIGINT  (arrêt au clavier)
   // - SIGTERM (signal d'arrêt en provenance du système)
   
   void
   interruption1(int signal)
   {
       unsigned char       signal_tronque;
   
       test_signal(signal);
   
       switch(signal)
     {      {
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          case SIGINT:
         BUG(1, uprintf("Unlock error !\n"));              signal_tronque = (unsigned char) (rpl_sigint & 0xFF);
         return;              _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
               break;
   
           case SIGTERM:
               signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);
               _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
               break;
   
           case SIGUSR1:
               signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
               _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
               break;
   
           default:
               // SIGUSR2
               break;
     }      }
   
     if ((sem = pthread_getspecific(semaphore_fork_processus_courant))      return;
             != NULL)  }
   
   // 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
   interruption2(int signal)
   {
       unsigned char       signal_tronque;
   
       test_signal(signal);
   
       signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
       _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
       return;
   }
   
   void
   interruption3(int signal)
   {
       // Si on passe par ici, c'est qu'il est impossible de récupérer
       // l'erreur d'accès à la mémoire. On sort donc du programme quitte à
       // ce qu'il reste des processus orphelins.
   
       unsigned char       message_1[] = "+++System : Uncaught access violation\n"
                                   "+++System : Aborting !\n";
       unsigned char       message_2[] = "+++System : Stack overflow\n"
                                   "+++System : Aborting !\n";
   
       test_signal(signal);
   
       if (pid_processus_pere == getpid())
     {      {
         while(sem_wait(sem) == -1)          kill(pid_processus_pere, SIGUSR1);
         {  
             if (errno != EINTR)  
             {  
                 pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
                 BUG(1, uprintf("Unlock error !\n"));  
                 return;  
             }  
         }  
     }      }
   
     if (semaphore == 1)  #   pragma GCC diagnostic push
     {  #   pragma GCC diagnostic ignored "-Wunused-result"
         if (sem_post(&semaphore_liste_threads) != 0)  
         {  
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
   
             BUG(1, uprintf("Unlock error !\n"));      if (signal != SIGUSR2)
             return;      {
         }          write(STDERR_FILENO, message_1, strlen(message_1));
       }
       else
       {
           write(STDERR_FILENO, message_2, strlen(message_2));
     }      }
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  #   pragma GCC diagnostic pop
     sigpending(&set);  
   
     return;      _exit(EXIT_FAILURE);
 }  }
   
   // Récupération des signaux
   // - SIGHUP
   
 void  void
 interruption1(int signal, siginfo_t *siginfo, void *context)  interruption4(int signal)
 {  {
     pthread_t               thread;      unsigned char       signal_tronque;
   
     struct_processus        *s_etat_processus;      test_signal(signal);
   
       signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
       _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
     volatile sig_atomic_t   exclusion = 0;      return;
   }
   
     verrouillage_gestionnaire_signaux();  // Récupération des signaux
   // - SIGPIPE
   
     switch(signal)  void
   interruption5(int signal)
   {
       unsigned char       message[] = "+++System : SIGPIPE\n"
                                   "+++System : Aborting !\n";
       unsigned char       signal_tronque;
   
       test_signal(signal);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
       if (pid_processus_pere == getpid())
     {      {
         case SIGALRM :          signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
         {          _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             if ((*siginfo).si_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)      write(STDERR_FILENO, message, strlen(message));
                 {  
                     printf("[%d] SIGALRM (thread %llu)\n", (int) getpid(),  
                             (unsigned long long) pthread_self());  
                     fflush(stdout);  
                 }  
   
                 if ((*s_etat_processus).pid_processus_pere != getpid())  #   pragma GCC diagnostic pop
                 {  
                     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;      return;
         }  }
   
   inline static void
   signal_alrm(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       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.
   
         case SIGINT :          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             /*              printf("[%d] RPL/SIGALRM (thread %llu)\n", (int) getpid(),
              * Une vieille spécification POSIX permet au pointeur siginfo                      (unsigned long long) pthread_self());
              * d'être nul dans le cas d'un ^C envoyé depuis le clavier.              fflush(stdout);
              * Solaris suit en particulier cette spécification.          }
              */  
   
             if (siginfo == NULL)          if ((*s_etat_processus).pid_processus_pere != getpid())
             {          {
                 kill(getpid(), signal);              // On n'est pas dans le processus père, on remonte le signal.
             }              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
             else if ((*siginfo).si_pid == getpid())                      rpl_sigalrm, d_faux);
             {          }
                 if ((s_etat_processus = recherche_thread(getpid(),          else
                         pthread_self())) == NULL)          {
                 {              // On est dans le processus père, on effectue un arrêt d'urgence.
                     deverrouillage_gestionnaire_signaux();              (*s_etat_processus).var_volatile_alarme = -1;
                     return;              (*s_etat_processus).var_volatile_requete_arret = -1;
                 }          }
       }
       else
       {
           // Le signal est issu d'un processus différent. On recherche le
           // thread principal pour remonter le signal.
   
                 if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          if ((s_thread_principal = recherche_thread_principal(getpid()))
                 {                  != NULL)
                     printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),          {
                             (unsigned long long) pthread_self());              envoi_signal_contexte(s_thread_principal, rpl_sigalrm);
                     fflush(stdout);          }
                 }      }
   
                 if ((*s_etat_processus).pid_processus_pere != getpid())      deverrouillage_gestionnaire_signaux(s_etat_processus);
                 {      return;
                     kill((*s_etat_processus).pid_processus_pere, signal);  }
                 }  
                 else  
                 {  
                     (*s_etat_processus).var_volatile_traitement_sigint = -1;  
   
                     while(exclusion == 1);  inline static void
                     exclusion = 1;  signal_term(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
       pthread_mutex_t         exclusion = PTHREAD_MUTEX_INITIALIZER;
   
                     if ((*s_etat_processus).var_volatile_requete_arret == -1)      verrouillage_gestionnaire_signaux(s_etat_processus);
                     {  
                         deverrouillage_gestionnaire_signaux();  
                         exclusion = 0;  
                         return;  
                     }  
   
                     if (strncmp(getenv("LANG"), "fr", 2) == 0)      if (pid == getpid())
                     {      {
                         printf("+++Interruption\n");          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                     }          {
                     else              printf("[%d] RPL/SIGTERM (thread %llu)\n", (int) getpid(),
                     {                      (unsigned long long) pthread_self());
                         printf("+++Interrupt\n");              fflush(stdout);
                     }          }
   
                     fflush(stdout);          if ((*s_etat_processus).pid_processus_pere != getpid())
           {
               envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                       rpl_sigterm, d_faux);
           }
           else
           {
               (*s_etat_processus).var_volatile_traitement_sigint = -1;
   
                     (*s_etat_processus).var_volatile_requete_arret = -1;              pthread_mutex_lock(&exclusion);
                     (*s_etat_processus).var_volatile_alarme = -1;  
   
                     exclusion = 0;              if ((*s_etat_processus).var_volatile_requete_arret == -1)
                 }  
             }  
             else  
             {              {
                 if (recherche_thread_principal(getpid(), &thread) == d_vrai)                  deverrouillage_gestionnaire_signaux(s_etat_processus);
                 {                  pthread_mutex_unlock(&exclusion);
                     pthread_kill(thread, signal);                  return;
                 }  
             }              }
   
             break;              (*s_etat_processus).var_volatile_requete_arret = -1;
         }              (*s_etat_processus).var_volatile_alarme = -1;
   
         default :              pthread_mutex_unlock(&exclusion);
           }
       }
       else
       {
           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_sigterm);
                     (int) getpid(), signal));  
             break;  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  inline static void
 interruption2(int signal, siginfo_t *siginfo, void *context)  signal_int(struct_processus *s_etat_processus, pid_t pid)
 {  {
     pthread_t               thread;      struct_processus        *s_thread_principal;
     struct_processus        *s_etat_processus;      pthread_mutex_t         exclusion = PTHREAD_MUTEX_INITIALIZER;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if (siginfo == NULL)      if (pid == getpid())
     {      {
         /*          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
          * Le signal SIGFSTP provient de la mort du processus de contrôle.          {
          * Sous certains systèmes (Linux...), la mort du terminal de contrôle              printf("[%d] RPL/SIGINT (thread %llu)\n", (int) getpid(),
          * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres                      (unsigned long long) pthread_self());
          * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo              fflush(stdout);
          * non initialisée (pointeur NULL) issue de TERMIO.          }
          */  
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)          if ((*s_etat_processus).pid_processus_pere != getpid())
         {          {
             pthread_kill(thread, SIGHUP);              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
             deverrouillage_gestionnaire_signaux();                      rpl_sigint, d_faux);
             return;          }
           else
           {
               (*s_etat_processus).var_volatile_traitement_sigint = -1;
   
               pthread_mutex_lock(&exclusion);
   
               if ((*s_etat_processus).var_volatile_requete_arret == -1)
               {
                   deverrouillage_gestionnaire_signaux(s_etat_processus);
                   pthread_mutex_unlock(&exclusion);
                   return;
               }
   
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("+++Interruption\n");
               }
               else
               {
                   printf("+++Interrupt\n");
               }
   
               fflush(stdout);
   
               (*s_etat_processus).var_volatile_requete_arret = -1;
               (*s_etat_processus).var_volatile_alarme = -1;
   
               pthread_mutex_unlock(&exclusion);
         }          }
     }      }
     else if ((*siginfo).si_pid == getpid())      else
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_thread_principal = recherche_thread_principal(getpid()))
                 == NULL)                  != NULL)
         {          {
             deverrouillage_gestionnaire_signaux();              envoi_signal_contexte(s_thread_principal, rpl_sigint);
             return;  
         }          }
       }
   
       deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
   }
   
   static inline void
   signal_tstp(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
       {
         /*          /*
          *  0 => fonctionnement normal           *  0 => fonctionnement normal
          * -1 => requête           * -1 => requête
Line 1686  interruption2(int signal, siginfo_t *sig Line 2082  interruption2(int signal, siginfo_t *sig
   
         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/SIGTSTP (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)          if ((*s_etat_processus).var_volatile_processus_pere == 0)
         {          {
             kill((*s_etat_processus).pid_processus_pere, signal);              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                       rpl_sigtstp, d_faux);
         }          }
         else          else
         {          {
Line 1704  interruption2(int signal, siginfo_t *sig Line 2101  interruption2(int signal, siginfo_t *sig
     {      {
         // 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_sigtstp);
             deverrouillage_gestionnaire_signaux();  
             return;  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
   static void
   sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
   {
       switch((*((volatile int *) arg1)))
       {
           case 1:
               longjmp(contexte_ecriture, -1);
               break;
   
           case 2:
               longjmp(contexte_impression, -1);
               break;
       }
   
       return;
   }
   
   #ifdef HAVE_SIGSEGV_RECOVERY
 void  void
 interruption3(int signal, siginfo_t *siginfo, void *context)  interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
 {  {
     struct_processus        *s_etat_processus;      if ((urgence == 0) && (routine_recursive != 0))
       {
           // 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.
   
     static int              compteur = 0;          sigsegv_leave_handler(sortie_interruption_depassement_pile,
                   (void *) &routine_recursive, NULL, NULL);
       }
   
     verrouillage_gestionnaire_signaux();      // Ici, la panique est totale et il vaut mieux quitter l'application.
       interruption3(SIGUSR2);
       return;
   }
   #endif
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)  int
   interruption_violation_access(void *adresse_fautive, int gravite)
   {
       unsigned char       message[] = "+++System : Trying to catch access "
                                   "violation\n";
   
       static int          compteur_erreur = 0;
   
       if ((gravite == 0) && (routine_recursive != 0))
     {      {
         deverrouillage_gestionnaire_signaux();          // Il peut s'agir d'un dépassement de pile.
         return;  
   #       ifdef HAVE_SIGSEGV_RECOVERY
               sigsegv_leave_handler(sortie_interruption_depassement_pile,
                       (void *) &routine_recursive, NULL, NULL);
   #       else
               sortie_interruption_depassement_pile((void *) &routine_recursive,
                       NULL, NULL);
   #       endif
     }      }
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      // On est dans une bonne vieille violation d'accès. On essaie
       // de fermer au mieux l'application.
   
       compteur_erreur++;
   
       if (compteur_erreur >= 2)
     {      {
         printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),          // Erreurs multiples, on arrête l'application.
                 (unsigned long long) pthread_self());          interruption3(SIGSEGV);
         fflush(stdout);          return(0);
       }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
       write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
       if (pid_processus_pere == getpid())
       {
           longjmp(contexte_initial, -1);
           return(1);
     }      }
       else
       {
           longjmp(contexte_processus, -1);
           return(1);
       }
   
       // On renvoie 0 parce qu'on décline toute responsabilité quant à la
       // suite des événements...
       return(0);
   }
   
   // Traitement de rpl_sigstart
   
     if ((*s_etat_processus).var_volatile_recursivite == -1)  static inline void
   signal_start(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
     {      {
         // Segfault dans un appel de fonction récursive          (*s_etat_processus).demarrage_fils = d_vrai;
         deverrouillage_gestionnaire_signaux();  
         longjmp(contexte, -1);  
     }      }
     else      else
     {      {
         // Segfault dans une routine interne          // Envoi d'un signal au thread maître du groupe.
         if (strncmp(getenv("LANG"), "fr", 2) == 0)  
           if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
         {          {
             printf("+++Système : Violation d'accès (dépassement de pile)\n");              envoi_signal_contexte(s_thread_principal, rpl_sigstart);
         }          }
         else      }
   
       deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
   }
   
   // Traitement de rpl_sigcont
   
   static inline void
   signal_cont(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
       {
           (*s_etat_processus).redemarrage_processus = d_vrai;
       }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
           if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
         {          {
             printf("+++System : Access violation (stack overflow)\n");              envoi_signal_contexte(s_thread_principal, rpl_sigcont);
         }          }
       }
   
         fflush(stdout);      deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
   }
   
         compteur++;  // Traitement de rpl_sigstop
   
         if (compteur > 1)  static inline void
   signal_stop(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
       {
           if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
           {
               printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
                       (unsigned long long) pthread_self());
               fflush(stdout);
           }
   
           /*
            * 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)
         {          {
             deverrouillage_gestionnaire_signaux();              (*s_etat_processus).var_volatile_requete_arret = -1;
             exit(EXIT_FAILURE);  
         }          }
         else          else
         {          {
             deverrouillage_gestionnaire_signaux();              (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
             longjmp(contexte_initial, -1);          }
       }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
           if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
           {
               envoi_signal_contexte(s_thread_principal, rpl_sigstop);
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  // Traitement de rpl_siginject
 interruption4(int signal, siginfo_t *siginfo, void *context)  
 {  
     struct_processus        *s_etat_processus;  
   
     verrouillage_gestionnaire_signaux();  static inline void
   signal_inject(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;
     }      }
   
     /*  
      * 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/SIGINJECT (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  
 interruption5(int signal, siginfo_t *siginfo, void *context)  static inline void
   signal_urg(struct_processus *s_etat_processus, pid_t pid)
 {  {
     pthread_t               thread;      struct_processus        *s_thread_principal;
     struct_processus        *s_etat_processus;  
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux(s_etat_processus);
   
     if ((*siginfo).si_pid == getpid())      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)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),              printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),
                     (unsigned long long) pthread_self());                      (unsigned long long) pthread_self());
             fflush(stdout);              fflush(stdout);
         }          }
   
           (*s_etat_processus).var_volatile_alarme = -1;
           (*s_etat_processus).var_volatile_requete_arret = -1;
       }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
           if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
           {
               envoi_signal_contexte(s_thread_principal, rpl_sigurg);
           }
       }
   
       deverrouillage_gestionnaire_signaux(s_etat_processus);
       return;
   }
   
   // Traitement de rpl_sigabort
   
   static inline void
   signal_abort(struct_processus *s_etat_processus, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
       {
           deverrouillage_gestionnaire_signaux(s_etat_processus);
           return;
       }
   
       if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
       {
           printf("[%d] RPL/SIGABORT (thread %llu)\n", (int) getpid(),
                   (unsigned long long) pthread_self());
           fflush(stdout);
       }
   
       if (pid == getpid())
       {
           (*s_etat_processus).arret_depuis_abort = -1;
   
         /*          /*
          * var_globale_traitement_retarde_stop :           * var_globale_traitement_retarde_stop :
          *  0 -> traitement immédiat           *  0 -> traitement immédiat
Line 1846  interruption5(int signal, siginfo_t *sig Line 2412  interruption5(int signal, siginfo_t *sig
     }      }
     else      else
     {      {
           (*s_etat_processus).arret_depuis_abort = -1;
   
         // 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, SIGFSTOP);              envoi_signal_contexte(s_thread_principal, rpl_sigabort);
             deverrouillage_gestionnaire_signaux();  
             return;  
         }          }
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
 void  
 interruption6(int signal, siginfo_t *siginfo, void *context)  static inline void
   signal_hup(struct_processus *s_etat_processus, pid_t pid)
 {  {
     struct_processus        *s_etat_processus;      file                    *fichier;
   
     verrouillage_gestionnaire_signaux();      unsigned char           nom[8 + 64 + 1];
   
       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-%llu-%llu",
               (unsigned long long) getpid(),
               (unsigned long long) pthread_self());
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
       if ((fichier = fopen(nom, "w+")) != NULL)
       {
           fclose(fichier);
   
           freopen(nom, "w", stdout);
           freopen(nom, "w", stderr);
       }
   
       freopen("/dev/null", "r", stdin);
   
   #   pragma GCC diagnostic pop
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] 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(int signal, siginfo_t *siginfo, void *context)  traitement_exceptions_gsl(const char *reason, const char *file,
           int line, int gsl_errno)
 {  {
     struct_processus        *s_etat_processus;      code_erreur_gsl = gsl_errno;
       envoi_signal_processus(getpid(), rpl_sigexcept, d_faux);
       return;
   }
   
     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);  
     }          case rpl_sigint:
               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;
   
     (*s_etat_processus).var_volatile_requete_arret = -1;          case rpl_sigstop:
     deverrouillage_gestionnaire_signaux();              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 : Signal inconnu (%d) !\n", signal);
               }
               else
               {
                   printf("+++System : Spurious signal (%d) !\n", signal);
               }
   
               break;
       }
   
     BUG(1, printf("[%d] SIGPIPE\n", (int) getpid()));  
     return;      return;
 }  }
   
 void  void
 interruption8(int signal, siginfo_t *siginfo, void *context)  scrutation_interruptions(struct_processus *s_etat_processus)
 {  {
     pthread_t               thread;      // Interruptions qui arrivent sur le processus depuis un
     struct_processus        *s_etat_processus;      // processus externe.
   
     verrouillage_gestionnaire_signaux();      // Les pointeurs de lecture pointent sur les prochains éléments
       // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
       // écrire.
   
     if ((*siginfo).si_pid == getpid())      if (sem_trywait(semaphore_queue_signaux) == 0)
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          while((*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 (pthread_mutex_lock(&mutex_liste_threads) != 0)
               {
                   return;
               }
   
               envoi_interruptions(s_etat_processus,
                       (*s_queue_signaux).queue[(*s_queue_signaux)
                       .pointeur_lecture].signal, (*s_queue_signaux).queue
                       [(*s_queue_signaux).pointeur_lecture].pid);
               (*s_queue_signaux).pointeur_lecture =
                       ((*s_queue_signaux).pointeur_lecture + 1)
                       % LONGUEUR_QUEUE_SIGNAUX;
   
   #           ifndef IPCS_SYSV
               if (msync(s_queue_signaux, sizeof(s_queue_signaux),
                       MS_ASYNC | MS_INVALIDATE) != 0)
               {
                   sem_post(semaphore_queue_signaux);
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   #           endif
   
               if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
               {
                   return;
               }
   
               while(sem_wait(semaphore_signalisation) != 0)
               {
                   if (errno != EINTR)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
               }
         }          }
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          sem_post(semaphore_queue_signaux);
       }
   
       // Interruptions qui arrivent depuis le groupe courant de threads.
   
       if (pthread_mutex_trylock(&mutex_liste_threads) == 0)
       {
           if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)
         {          {
             printf("[%d] SIGURG (thread %llu)\n", (int) getpid(),              while((*s_etat_processus).pointeur_signal_lecture !=
                     (unsigned long long) pthread_self());                      (*s_etat_processus).pointeur_signal_ecriture)
             fflush(stdout);              {
                   // Il y a un signal dans la queue du thread courant.
                   // On le traite.
   
                   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;
   
                   while(sem_wait(semaphore_signalisation) != 0)
                   {
                       if (errno != EINTR)
                       {
                           if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
   
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
                   }
               }
   
               pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));
         }          }
   
         (*s_etat_processus).var_volatile_alarme = -1;          pthread_mutex_unlock(&mutex_liste_threads);
         (*s_etat_processus).var_volatile_requete_arret = -1;      }
   
       return;
   }
   
   
   /*
   ================================================================================
     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)
   {
       unsigned char               *fichier;
   
   #   ifdef IPCS_SYSV // !POSIX
   #       ifndef OS2 // !OS2
   
               if ((fichier = sys_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 = sys_malloc((10 + 256 + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   return(NULL);
               }
   
               sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid);
   #       endif // OS2
   #   else // POSIX
   
           if ((fichier = sys_malloc((1 + 256 + 1) *
                   sizeof(unsigned char))) == NULL)
           {
               return(NULL);
           }
   
           sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
   #   endif
   
       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
   ================================================================================
   */
   
   int
   envoi_signal_processus(pid_t pid, enum signaux_rpl signal,
           logical1 test_ouverture)
   {
   #   ifndef OS2
           int                         segment;
   #   endif
   
   #   ifndef IPCS_SYSV
           sem_t                       *semaphore;
           sem_t                       *signalisation;
   #   else
           sem_t                       *semaphore;
           sem_t                       *signalisation;
   #       ifndef OS2
               int                     desc;
               key_t                   clef;
   #       endif
   #   endif
   
       struct_queue_signaux            *queue;
   
       struct timespec                 attente;
   
       unsigned char                   *nom;
   
       // 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())
       {
           // Le signal est envoyé au même processus.
   
           if (s_queue_signaux == NULL)
           {
               return(1);
           }
   
           while(sem_wait(semaphore_queue_signaux) != 0)
           {
               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;
   
   #       ifndef IPCS_SYSV
           if (msync(s_queue_signaux, sizeof(s_queue_signaux),
                   MS_ASYNC | MS_INVALIDATE) != 0)
           {
               sem_post(semaphore_queue_signaux);
               return(1);
           }
   #       endif
   
           if (sem_post(semaphore_queue_signaux) != 0)
           {
               return(1);
           }
   
           if (sem_post(semaphore_signalisation) != 0)
           {
               return(1);
           }
     }      }
     else      else
     {      {
         // Envoi d'un signal au thread maître du groupe.          // 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 (test_ouverture == d_vrai)
                   {
                       attente.tv_sec = 0;
                       attente.tv_nsec = GRANULARITE_us * 1000;
   
                       while((desc = open(nom, O_RDWR)) == -1)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                   }
                   else
                   {
                       if ((desc = open(nom, O_RDWR)) == -1)
                       {
                           sys_free(nom);
                           return(1);
                       }
                   }
   
                   close(desc);
   
                   if ((clef = ftok(nom, 1)) == -1)
                   {
                       sys_free(nom);
                       return(1);
                   }
   
                   sys_free(nom);
   
                   if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
                           == -1)
                   {
                       return(1);
                   }
   
                   queue = shmat(segment, NULL, 0);
   #           else // OS/2
                   if (test_ouverture == d_vrai)
                   {
                       attente.tv_sec = 0;
                       attente.tv_nsec = GRANULARITE_us * 1000;
   
                       while(DosGetNamedSharedMem((PVOID) &queue, nom,
                               PAG_WRITE | PAG_READ) != 0)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                   }
                   else
                   {
                       if (DosGetNamedSharedMem((PVOID) &queue, nom,
                               PAG_WRITE | PAG_READ) != 0)
                       {
                           sys_free(nom);
                           return(1);
                       }
                   }
   
                   sys_free(nom);
   #           endif
   #       else // POSIX
               if ((nom = nom_segment(racine_segment, pid)) == NULL)
               {
                   return(1);
               }
   
               if (test_ouverture == d_vrai)
               {
                   attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)                  while((segment = shm_open(nom, O_RDWR, 0)) == -1)
                   {
                       nanosleep(&attente, NULL);
                       INCR_GRANULARITE(attente.tv_nsec);
                   }
               }
               else
               {
                   if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
                   {
                       sys_free(nom);
                       return(1);
                   }
               }
   
               sys_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.
   
           if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
         {          {
             pthread_kill(thread, SIGURG);  #           ifndef IPCS_SYSV // POSIX
             deverrouillage_gestionnaire_signaux();                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
             return;                  {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
               return(1);
           }
   
           if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
                   == SEM_FAILED)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(semaphore);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       sem_close(semaphore);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(semaphore);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(semaphore);
               return(1);
           }
   
           while(sem_wait(semaphore) != 0)
           {
               if (errno != EINTR)
               {
   #               ifndef IPCS_SYSV // POSIX
                       if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE)
                               != 0)
                       {
                           munmap(queue, sizeof(struct_queue_signaux));
                           sem_close(semaphore);
                           sem_close(signalisation);
                           close(segment);
                           return(1);
                       }
   
                       if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                       {
                           sem_close(semaphore);
                           sem_close(signalisation);
                           close(segment);
                           return(1);
                       }
   
                       close(segment);
   #               else // IPCS_SYSV
   #                   ifndef OS2 // SysV
                           if (shmdt(queue) != 0)
                           {
                               sem_close(semaphore);
                               sem_close(signalisation);
                               return(1);
                           }
   #                   else // OS/2
                           // Pendant de DosGetNamedSHaredMem()
   #                   endif
   #               endif
   
                   sem_close(semaphore);
                   sem_close(signalisation);
                   return(1);
               }
           }
   
           (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
           (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
   
           (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                   % LONGUEUR_QUEUE_SIGNAUX;
   
           if (sem_post(semaphore) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(semaphore);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       sem_close(semaphore);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(semaphore);
                           sem_close(signalisation);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(semaphore);
               sem_close(signalisation);
               return(1);
           }
   
           if (sem_close(semaphore) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(signalisation);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(signalisation);
               return(1);
           }
   
           if (sem_post(signalisation) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           sem_close(signalisation);
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(signalisation);
               return(1);
           }
   
           if (sem_close(signalisation) != 0)
           {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   
                   close(segment);
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               return(1);
         }          }
   
   #       ifndef IPCS_SYSV // POSIX
               if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
               {
                   munmap(queue, sizeof(struct_queue_signaux));
                   close(segment);
                   return(1);
               }
   
               if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
               {
                   close(segment);
                   return(1);
               }
   
               close(segment);
   #       else // IPCS_SYSV
   #           ifndef OS2 // SysV
                   if (shmdt(queue) != 0)
                   {
                       return(1);
                   }
   #           else // OS/2
                   // Pendant de DosGetNamedSHaredMem()
   #           endif
   #       endif
     }      }
   
     deverrouillage_gestionnaire_signaux();      return(0);
     return;  
 }  }
   
 void  int
 interruption9(int signal, siginfo_t *siginfo, void *context)  envoi_signal_thread(struct_processus *s_contexte,
           pthread_t tid, enum signaux_rpl signal)
 {  {
     struct_processus        *s_etat_processus;      // Un signal est envoyé d'un thread à un autre thread du même processus.
   
     verrouillage_gestionnaire_signaux();      int                                     ios;
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      struct timespec                         attente;
   
       volatile struct_liste_chainee_volatile  *l_element_courant;
   
       struct_processus                        *s_etat_processus;
   
       if (s_contexte != NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          attente.tv_sec = 0;
         return;          attente.tv_nsec = GRANULARITE_us * 1000;
   
           while((ios = pthread_mutex_trylock(&mutex_liste_threads)) != 0)
           {
               if (ios != EBUSY)
               {
                   return(1);
               }
   
               if (sem_post(&((*s_contexte).semaphore_fork)) != 0)
               {
                   return(1);
               }
   
               nanosleep(&attente, NULL);
               INCR_GRANULARITE(attente.tv_nsec);
   
               while(sem_wait(&((*s_contexte).semaphore_fork)) != 0)
               {
                   if (errno != EINTR)
                   {
                       return(1);
                   }
               }
           }
       }
       else
       {
           if (pthread_mutex_lock(&mutex_liste_threads) != 0)
           {
               return(1);
           }
     }      }
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      l_element_courant = liste_threads;
   
       while(l_element_courant != NULL)
     {      {
         printf("[%d] SIGABORT/SIGPROF (thread %llu)\n", (int) getpid(),          if (((*((struct_thread *) (*l_element_courant).donnee)).pid
                 (unsigned long long) pthread_self());                  == getpid()) && (pthread_equal((*((struct_thread *)
         fflush(stdout);                  (*l_element_courant).donnee)).tid, tid) != 0))
           {
               break;
           }
   
           l_element_courant = (*l_element_courant).suivant;
     }      }
   
     pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP);      if (l_element_courant == NULL)
     deverrouillage_gestionnaire_signaux();      {
     return;          pthread_mutex_unlock(&mutex_liste_threads);
           return(1);
       }
   
       s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee))
               .s_etat_processus;
   
       if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
       {
           pthread_mutex_unlock(&mutex_liste_threads);
           return(1);
       }
   
       (*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(&((*s_etat_processus).mutex_signaux)) != 0)
       {
           pthread_mutex_unlock(&mutex_liste_threads);
           return(1);
       }
   
       if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
       {
           return(1);
       }
   
       if (sem_post(semaphore_signalisation) != 0)
       {
           return(1);
       }
   
       return(0);
   }
   
   int
   envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler,
           enum signaux_rpl signal)
   {
       pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_signaux));
       (*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_kill((*s_etat_processus_a_signaler).tid, SIGUSR2);
       pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux));
   
       if (sem_post(semaphore_signalisation) != 0)
       {
           return(1);
       }
   
       return(0);
 }  }
   
   
   /*
   ================================================================================
     Fonction créant un 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
 interruption10(int signal, siginfo_t *siginfo, void *context)  creation_queue_signaux(struct_processus *s_etat_processus)
 {  {
     file                    *fichier;      pthread_attr_t                  attributs;
   
     struct_processus        *s_etat_processus;      unsigned char                   *nom;
   
     unsigned char           nom[8 + 64 + 1];      racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
   
     verrouillage_gestionnaire_signaux();  #   ifndef IPCS_SYSV // POSIX
           if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
                   getpid())) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)          if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
                   S_IRUSR | S_IWUSR)) == -1)
           {
               if (errno != EEXIST)
               {
                   sys_free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("+++Attention : Le segment de mémoire %s préexiste !\n",
                           nom);
               }
               else
               {
                   printf("+++Warning: %s memory segment preexists!\n", nom);
               }
   
               if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_TRUNC,
                       S_IRUSR | S_IWUSR)) == -1)
               {
                   sys_free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
           }
   
           if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
           {
               sys_free(nom);
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
                   PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
   
           if (((void *) s_queue_signaux) == ((void *) -1))
           {
               if (shm_unlink(nom) == -1)
               {
                   sys_free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               sys_free(nom);
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           sys_free(nom);
   
           if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
                   == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if ((semaphore_signalisation = sem_init2(0, getpid(),
                   SEM_SIGNALISATION)) == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
                   SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
           (*s_queue_signaux).pointeur_lecture = 0;
           (*s_queue_signaux).pointeur_ecriture = 0;
   
           (*s_queue_signaux).requete_arret = d_faux;
   
           if (msync(s_queue_signaux, sizeof(struct_queue_signaux),
                   MS_ASYNC | MS_INVALIDATE) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               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);
               sys_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;
               }
   
               if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
                       == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               if ((semaphore_signalisation = sem_init2(0, getpid(),
                       SEM_SIGNALISATION)) == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               if ((semaphore_arret_signalisation = sem_init2(1, getpid(),
                       SEM_ARRET_SIGNALISATION)) == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
               (*s_queue_signaux).requete_arret = d_faux;
   #       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)
               {
                   sys_free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               sys_free(nom);
   
               if (sem_init(&((*s_queue_signaux).semaphore), 1, 1) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (sem_init(&((*s_queue_signaux).signalisation), 1, 0) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
               (*s_queue_signaux).requete_arret = d_faux;
   #       endif
   #   endif
   
       (*s_queue_signaux).controle = getpid();
   
       if (lancement_thread_signaux(s_etat_processus) == d_erreur)
     {      {
         deverrouillage_gestionnaire_signaux();          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(),      // Lancement du thread de récupération des signaux.
             (unsigned long) pthread_self());  
   
     if ((fichier = fopen(nom, "w+")) != NULL)      if (pthread_attr_init(&attributs) != 0)
     {      {
         fclose(fichier);          (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
         freopen(nom, "w", stdout);      if (pthread_attr_setdetachstate(&attributs,
         freopen(nom, "w", stderr);              PTHREAD_CREATE_JOINABLE) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
     }      }
   
     freopen("/dev/null", "r", stdin);      if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
               thread_surveillance_signaux, s_etat_processus) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (pthread_attr_destroy(&attributs) != 0)
     {      {
         printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(),          (*s_etat_processus).erreur_systeme = d_es_processus;
                 (unsigned long long) pthread_self());          return;
         fflush(stdout);      }
   
   #   ifndef IPCS_SYSV
       if (msync(s_queue_signaux, sizeof(s_queue_signaux),
               MS_ASYNC | MS_INVALIDATE) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
     }      }
   #   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
           sem_close(semaphore_queue_signaux);
           sem_close(semaphore_signalisation);
           sem_close(semaphore_arret_signalisation);
   
     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
   
       return;
   }
   
   
   /*
   ================================================================================
     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
   ================================================================================
   */
   
   void
   destruction_queue_signaux(struct_processus *s_etat_processus)
   {
   #   ifndef OS2
           unsigned char       *nom;
   #   endif
   
       // On dépile les interruptions pour arrêter les SIGUSR2 sur
       // le processus courant.
   
       scrutation_interruptions(s_etat_processus);
   
       while(sem_wait(semaphore_arret_signalisation) != 0)
       {
           if (errno != EINTR)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
       }
   
       (*s_queue_signaux).requete_arret = d_vrai;
   
   #   ifndef IPCS_SYSV
       msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
   #   endif
   
       sem_post(semaphore_arret_signalisation);
   
       // Incrémenter le sémaphore pour être sûr de le débloquer.
   
       sem_post(semaphore_signalisation);
   
       if ((*s_queue_signaux).controle == getpid())
       {
           pthread_join((*s_queue_signaux).thread_signaux, NULL);
       }
       else
     {      {
         deverrouillage_gestionnaire_signaux();          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     (*s_etat_processus).var_volatile_exception_gsl = gsl_errno;      arret_thread_signaux(s_etat_processus);
     deverrouillage_gestionnaire_signaux();  
   #   ifdef IPCS_SYSV // SystemV
   #       ifndef OS2
               // Il faut commencer par éliminer le sémaphore.
   
               if (semctl((*semaphore_queue_signaux).sem, 0, IPC_RMID) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               unlink((*semaphore_queue_signaux).path);
               sys_free((*semaphore_queue_signaux).path);
   
               if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               unlink((*semaphore_signalisation).path);
               sys_free((*semaphore_signalisation).path);
   
               if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
               unlink((*semaphore_arret_signalisation).path);
               sys_free((*semaphore_arret_signalisation).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);
               sys_free(nom);
   #       else
               sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   
               sem_close(&((*s_queue_signaux).signalisation));
               sem_destroy(&((*s_queue_signaux).signalisation));
   
               sem_close(&((*s_queue_signaux).arret_signalisation));
               sem_destroy(&((*s_queue_signaux).arret_signalisation));
   
               if (DosFreeMem(s_queue_signaux) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   #       endif
   #   else // POSIX
           sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
           sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
           sem_destroy2(semaphore_arret_signalisation, getpid(),
                   SEM_ARRET_SIGNALISATION);
   
           if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if ((nom = nom_segment(NULL, getpid())) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           close(f_queue_signaux);
   
           if (shm_unlink(nom) != 0)
           {
               sys_free(nom);
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           sys_free(nom);
   #   endif
   
     return;      return;
 }  }
   
Removed from v.1.7  
changed lines
  Added in v.1.212

CVSweb interface <joel.bertrand@systella.fr>