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

Diff for /rpl/src/interruptions.c between versions 1.9 and 1.66

version 1.9, 2010/04/21 13:45:50 version 1.66, 2011/09/10 20:45:06
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.15    RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 82  insertion_thread(struct_processus *s_eta Line 82  insertion_thread(struct_processus *s_eta
     sigfillset(&set);      sigfillset(&set);
     pthread_sigmask(SIG_BLOCK, &set, &oldset);      pthread_sigmask(SIG_BLOCK, &set, &oldset);
   
 #   ifndef SEMAPHORES_NOMMES  
     while(sem_wait(&semaphore_liste_threads) == -1)  
 #   else  
     while(sem_wait(semaphore_liste_threads) == -1)  
 #   endif  
     {  
         if (errno != EINTR)  
         {  
             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)
     {      {
 #       ifndef SEMAPHORES_NOMMES  
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          pthread_sigmask(SIG_SETMASK, &oldset, NULL);
         sigpending(&set);          sigpending(&set);
   
Line 113  insertion_thread(struct_processus *s_eta Line 92  insertion_thread(struct_processus *s_eta
         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)
     {      {
 #       ifndef SEMAPHORES_NOMMES  
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          pthread_sigmask(SIG_SETMASK, &oldset, NULL);
         sigpending(&set);          sigpending(&set);
   
Line 136  insertion_thread(struct_processus *s_eta Line 108  insertion_thread(struct_processus *s_eta
     (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =      (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus =
             s_etat_processus;              s_etat_processus;
   
   #   ifndef SEMAPHORES_NOMMES
       while(sem_wait(&semaphore_liste_threads) == -1)
   #   else
       while(sem_wait(semaphore_liste_threads) == -1)
   #   endif
       {
           if (errno != EINTR)
           {
               pthread_sigmask(SIG_SETMASK, &oldset, NULL);
               sigpending(&set);
   
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
       }
   
       (*l_nouvel_objet).suivant = liste_threads;
     liste_threads = l_nouvel_objet;      liste_threads = l_nouvel_objet;
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
Line 168  insertion_thread_surveillance(struct_pro Line 157  insertion_thread_surveillance(struct_pro
     sigfillset(&set);      sigfillset(&set);
     pthread_sigmask(SIG_BLOCK, &set, &oldset);      pthread_sigmask(SIG_BLOCK, &set, &oldset);
   
       if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))
               == NULL)
       {
           pthread_sigmask(SIG_SETMASK, &oldset, NULL);
           sigpending(&set);
   
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     while(sem_wait(&semaphore_liste_threads) == -1)      while(sem_wait(&semaphore_liste_threads) == -1)
 #   else  #   else
Line 184  insertion_thread_surveillance(struct_pro Line 183  insertion_thread_surveillance(struct_pro
         }          }
     }      }
   
     if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile)))      pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
             == NULL)      (*s_argument_thread).nombre_references++;
     {      pthread_mutex_unlock(&((*s_argument_thread).mutex_nombre_references));
 #       ifndef SEMAPHORES_NOMMES  
         sem_post(&semaphore_liste_threads);  
 #       else  
         sem_post(semaphore_liste_threads);  
 #       endif  
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
         sigpending(&set);  
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     (*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;
Line 289  retrait_thread(struct_processus *s_etat_ Line 277  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);  
     free((struct_liste_chainee_volatile *) l_element_courant);  
   
     if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0)      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;
Line 319  retrait_thread(struct_processus *s_etat_ Line 304  retrait_thread(struct_processus *s_etat_
         return;          return;
     }      }
   
       free((void *) (*l_element_courant).donnee);
       free((struct_liste_chainee_volatile *) l_element_courant);
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);      pthread_sigmask(SIG_SETMASK, &oldset, NULL);
     sigpending(&set);      sigpending(&set);
     return;      return;
Line 390  retrait_thread_surveillance(struct_proce Line 378  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)  
     {      {
   #       ifndef SEMAPHORES_NOMMES
           sem_post(&semaphore_liste_threads);
   #       else
           sem_post(semaphore_liste_threads);
   #       endif
         pthread_sigmask(SIG_SETMASK, &oldset, NULL);          pthread_sigmask(SIG_SETMASK, &oldset, NULL);
         sigpending(&set);          sigpending(&set);
   
Line 409  retrait_thread_surveillance(struct_proce Line 401  retrait_thread_surveillance(struct_proce
   
     if ((*s_argument_thread).nombre_references == 0)      if ((*s_argument_thread).nombre_references == 0)
     {      {
         if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_argument_thread)
                   .mutex_nombre_references)) != 0)
         {          {
   #           ifndef SEMAPHORES_NOMMES
               sem_post(&semaphore_liste_threads);
   #           else
               sem_post(semaphore_liste_threads);
   #           endif
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              pthread_sigmask(SIG_SETMASK, &oldset, NULL);
             sigpending(&set);              sigpending(&set);
   
Line 419  retrait_thread_surveillance(struct_proce Line 417  retrait_thread_surveillance(struct_proce
         }          }
   
         pthread_mutex_destroy(&((*s_argument_thread).mutex));          pthread_mutex_destroy(&((*s_argument_thread).mutex));
           pthread_mutex_destroy(&((*s_argument_thread).mutex_nombre_references));
         free(s_argument_thread);          free(s_argument_thread);
     }      }
     else      else
     {      {
         if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_argument_thread)
                   .mutex_nombre_references)) != 0)
         {          {
   #           ifndef SEMAPHORES_NOMMES
               sem_post(&semaphore_liste_threads);
   #           else
               sem_post(semaphore_liste_threads);
   #           endif
             pthread_sigmask(SIG_SETMASK, &oldset, NULL);              pthread_sigmask(SIG_SETMASK, &oldset, NULL);
             sigpending(&set);              sigpending(&set);
   
Line 446  retrait_thread_surveillance(struct_proce Line 451  retrait_thread_surveillance(struct_proce
         return;          return;
     }      }
   
       free((struct_liste_chainee_volatile *) l_element_courant);
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);      pthread_sigmask(SIG_SETMASK, &oldset, NULL);
     sigpending(&set);      sigpending(&set);
   
     return;      return;
 }  }
   
Line 626  liberation_threads(struct_processus *s_e Line 634  liberation_threads(struct_processus *s_e
             close((*s_etat_processus).pipe_nombre_objets_attente);              close((*s_etat_processus).pipe_nombre_objets_attente);
             close((*s_etat_processus).pipe_nombre_interruptions_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)
             {              {
                 free((*s_etat_processus).nom_fichier_impression);                  free((*s_etat_processus).nom_fichier_impression);
Line 667  liberation_threads(struct_processus *s_e Line 677  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;
                       sem_post(&semaphore_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_objets_attente[0]);
                       close((*s_argument_thread).pipe_interruptions[0]);
                       close((*s_argument_thread)
                               .pipe_nombre_interruptions_attente[0]);
   
                       if (pthread_mutex_unlock(&((*s_argument_thread)
                               .mutex_nombre_references)) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           sem_post(&semaphore_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;
                           sem_post(&semaphore_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 735  liberation_threads(struct_processus *s_e Line 803  liberation_threads(struct_processus *s_e
                 }                  }
             }              }
   
             for(i = 0; i < (*s_etat_processus).nombre_variables; i++)              liberation_arbre_variables(s_etat_processus,
             {                      (*s_etat_processus).s_arbre_variables, d_faux);
                 pthread_mutex_trylock(&((*(*s_etat_processus)  
                         .s_liste_variables[i].objet).mutex));  
                 pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables[i].objet).mutex));  
   
                 // Les variables de niveau 0 sont des définitions qui  
                 // ne sont pas copiées entre threads.  
                 if ((*s_etat_processus).s_liste_variables[i].niveau > 0)  
                 {  
                     liberation(s_etat_processus,  
                             (*s_etat_processus).s_liste_variables[i].objet);  
                 }  
   
                 free((*s_etat_processus).s_liste_variables[i].nom);  
             }  
   
             free((*s_etat_processus).s_liste_variables);  
   
             for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)              for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
             {              {
Line 1153  liberation_threads(struct_processus *s_e Line 1204  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 1236  liberation_threads(struct_processus *s_e Line 1293  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 1258  liberation_threads(struct_processus *s_e Line 1318  liberation_threads(struct_processus *s_e
             sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);              sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
 #           endif  #           endif
   
               liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
Line 1280  liberation_threads(struct_processus *s_e Line 1341  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;
               sem_post(&semaphore_liste_threads);
             return;              return;
         }          }
   
Line 1302  liberation_threads(struct_processus *s_e Line 1357  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_objets_attente[0]);
               close((*s_argument_thread).pipe_interruptions[0]);
               close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
   
               if (pthread_mutex_unlock(&((*s_argument_thread)
                       .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                   sem_post(&semaphore_liste_threads);
                 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;
                   sem_post(&semaphore_liste_threads);
                 return;                  return;
             }              }
         }          }
Line 1379  recherche_thread(pid_t pid, pthread_t ti Line 1457  recherche_thread(pid_t pid, pthread_t ti
     return(s_etat_processus);      return(s_etat_processus);
 }  }
   
 static logical1  static struct_processus *
 recherche_thread_principal(pid_t pid, pthread_t *thread)  recherche_thread_principal(pid_t pid)
 {  {
     volatile struct_liste_chainee_volatile      *l_element_courant;      volatile struct_liste_chainee_volatile      *l_element_courant;
   
Line 1404  recherche_thread_principal(pid_t pid, pt Line 1482  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 1426  recherche_thread_principal(pid_t pid, pt Line 1503  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
Line 1510  verrouillage_gestionnaire_signaux() Line 1587  verrouillage_gestionnaire_signaux()
         // ce que ce soit possible.          // ce que ce soit possible.
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_trywait(&semaphore_liste_threads) == -1)          while(sem_wait(&semaphore_liste_threads) == -1)
 #       else  #       else
         while(sem_trywait(semaphore_liste_threads) == -1)          while(sem_wait(semaphore_liste_threads) == -1)
 #       endif  #       endif
         {          {
             if ((errno != EINTR) && (errno != EAGAIN))              if (errno != EINTR)
             {              {
                 pthread_sigmask(SIG_SETMASK, &oldset, NULL);                  pthread_sigmask(SIG_SETMASK, &oldset, NULL);
   
Line 1531  verrouillage_gestionnaire_signaux() Line 1608  verrouillage_gestionnaire_signaux()
                 BUG(1, uprintf("Lock error !\n"));                  BUG(1, uprintf("Lock error !\n"));
                 return;                  return;
             }              }
   
             sched_yield();  
         }          }
     }      }
   
Line 1642  deverrouillage_gestionnaire_signaux() Line 1717  deverrouillage_gestionnaire_signaux()
     return;      return;
 }  }
   
   #define test_signal(signal) \
       if (signal_test == SIGTEST) \
       { signal_test = initialisation_queue_interruptions(signal); return; }
   
   /*
    * Les interruptions sont mise en mémoire puis traitées depuis
    * la fonction scrutation_injection() parce que les fonctions pthread*()
    * ne sont pas 'async signal safe'.
    *
    * Les interruptions sont ainsi empilées dans un buffer circulaire puis
    * traitées au fur et à mesure.
    */
   
   static struct
   {
   #   define                  SIGNAL_MAX      32
   #   define                  SIGNAL_BUFFER   1024
   #   define                  ECRITURE        0
   #   define                  LECTURE         1
   
       sig_atomic_t            nombre_interruptions_en_queue;
       int                     pointeur[SIGNAL_MAX][2];
   
       pid_t                   pid[SIGNAL_MAX][SIGNAL_BUFFER];
   } queue_interruptions;
   
   pthread_mutex_t             mutex_signal = PTHREAD_MUTEX_INITIALIZER;
   
   static inline int
   initialisation_queue_interruptions(int signal)
   {
       int         i;
   
       if (signal > SIGNAL_MAX)
       {
           return(signal + 1);
       }
   
       queue_interruptions.nombre_interruptions_en_queue = 0;
   
       for(i = 0; i < SIGNAL_MAX; i++)
       {
           queue_interruptions.pointeur[i][ECRITURE] = 0;
           queue_interruptions.pointeur[i][LECTURE] = 0;
       }
   
       return(signal);
   }
   
 void  void
 interruption1(int signal, siginfo_t *siginfo, void *context)  interruption1(SIGHANDLER_ARGS)
 {  {
     pthread_t               thread;      pid_t               pid;
   
     struct_processus        *s_etat_processus;      test_signal(signal);
   
   #   ifdef _BROKEN_SIGINFO
           if ((signal == SIGINT) || (signal == SIGTERM))
           {
               // Si l'interruption provient du clavier, il n'y a pas eu d'appel
               // à queue_in().
   
               pid = getpid();
           }
           else
           {
               pid = origine_signal(signal);
           }
   #   else
   
       /*
        * Une vieille spécification POSIX permet au pointeur siginfo
        * d'être nul dans le cas d'un ^C envoyé depuis le clavier.
        * Solaris suit en particulier cette spécification.
        */
   
           if (siginfo != NULL)
           {
               pid = (*siginfo).si_pid;
           }
           else
           {
               pid = getpid();
           }
   #   endif
   
       queue_interruptions.pid[signal][queue_interruptions.pointeur
               [signal][ECRITURE]] = pid;
       queue_interruptions.pointeur[signal][ECRITURE] =
               (queue_interruptions.pointeur[signal][ECRITURE] + 1)
               % SIGNAL_BUFFER;
       queue_interruptions.nombre_interruptions_en_queue++;
       return;
   }
   
   static void
   corps_interruption1(struct_processus *s_etat_processus, int signal, pid_t pid)
   {
     volatile sig_atomic_t   exclusion = 0;      volatile sig_atomic_t   exclusion = 0;
   
       struct_processus        *s_thread_principal;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     switch(signal)      switch(signal)
     {      {
         case SIGALRM :          case SIGALRM :
         {          {
             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] SIGALRM (thread %llu)\n", (int) getpid(),                      printf("[%d] SIGALRM (thread %llu)\n", (int) getpid(),
Line 1685  interruption1(int signal, siginfo_t *sig Line 1846  interruption1(int signal, siginfo_t *sig
             }              }
             else              else
             {              {
                 if (recherche_thread_principal(getpid(), &thread) == d_vrai)                  if ((s_thread_principal = recherche_thread_principal(getpid()))
                           != NULL)
                 {                  {
                     pthread_kill(thread, signal);                      while((*s_etat_processus).signal_a_traiter == d_vrai);
                       (*s_etat_processus).signal = signal;
                       (*s_etat_processus).origine_signal = getpid();
                       (*s_etat_processus).signal_a_traiter = d_vrai;
                 }                  }
             }              }
   
Line 1695  interruption1(int signal, siginfo_t *sig Line 1860  interruption1(int signal, siginfo_t *sig
         }          }
   
         case SIGINT :          case SIGINT :
           case SIGTERM :
         {          {
             /*              if (pid == getpid())
              * Une vieille spécification POSIX permet au pointeur siginfo  
              * d'être nul dans le cas d'un ^C envoyé depuis le clavier.  
              * Solaris suit en particulier cette spécification.  
              */  
   
             if (siginfo == NULL)  
             {              {
                 kill(getpid(), signal);  
             }  
             else 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)                  if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                 {                  {
                     printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),                      if (signal == SIGINT)
                             (unsigned long long) pthread_self());                      {
                           printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),
                                   (unsigned long long) pthread_self());
                       }
                       else
                       {
                           printf("[%d] SIGTERM (thread %llu)\n", (int) getpid(),
                                   (unsigned long long) pthread_self());
                       }
   
                     fflush(stdout);                      fflush(stdout);
                 }                  }
   
Line 1740  interruption1(int signal, siginfo_t *sig Line 1898  interruption1(int signal, siginfo_t *sig
                         return;                          return;
                     }                      }
   
                     if (strncmp(getenv("LANG"), "fr", 2) == 0)                      if (signal == SIGINT)
                     {  
                         printf("+++Interruption\n");  
                     }  
                     else  
                     {                      {
                         printf("+++Interrupt\n");                          if (strncmp(getenv("LANG"), "fr", 2) == 0)
                     }                          {
                               printf("+++Interruption\n");
                           }
                           else
                           {
                               printf("+++Interrupt\n");
                           }
   
                     fflush(stdout);                          fflush(stdout);
                       }
   
                     (*s_etat_processus).var_volatile_requete_arret = -1;                      (*s_etat_processus).var_volatile_requete_arret = -1;
                     (*s_etat_processus).var_volatile_alarme = -1;                      (*s_etat_processus).var_volatile_alarme = -1;
Line 1759  interruption1(int signal, siginfo_t *sig Line 1920  interruption1(int signal, siginfo_t *sig
             }              }
             else              else
             {              {
                 if (recherche_thread_principal(getpid(), &thread) == d_vrai)                  if ((s_thread_principal = recherche_thread_principal(getpid()))
                           != NULL)
                 {                  {
                     pthread_kill(thread, signal);                      while((*s_etat_processus).signal_a_traiter == d_vrai);
                       (*s_etat_processus).signal = signal;
                       (*s_etat_processus).origine_signal = getpid();
                       (*s_etat_processus).signal_a_traiter = d_vrai;
                 }                  }
             }              }
   
Line 1781  interruption1(int signal, siginfo_t *sig Line 1946  interruption1(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption2(int signal, siginfo_t *siginfo, void *context)  interruption2(SIGHANDLER_ARGS)
 {  {
     pthread_t               thread;      pid_t               pid;
     struct_processus        *s_etat_processus;  
   
     verrouillage_gestionnaire_signaux();      test_signal(signal);
   
     if (siginfo == NULL)  #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       if (siginfo != NULL)
     {      {
         /*          pid = (*siginfo).si_pid;
          * Le signal SIGFSTP provient de la mort du processus de contrôle.  
          * Sous certains systèmes (Linux...), la mort du terminal de contrôle  
          * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres  
          * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo  
          * non initialisée (pointeur NULL) issue de TERMIO.  
          */  
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)  
         {  
             pthread_kill(thread, SIGHUP);  
             deverrouillage_gestionnaire_signaux();  
             return;  
         }  
     }      }
     else if ((*siginfo).si_pid == getpid())      else
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          pid = getpid();
                 == NULL)      }
         {  #   endif
             deverrouillage_gestionnaire_signaux();  
             return;      queue_interruptions.pid[signal][queue_interruptions.pointeur
         }              [signal][ECRITURE]] = pid;
       queue_interruptions.pointeur[signal][ECRITURE] =
               (queue_interruptions.pointeur[signal][ECRITURE] + 1)
               % SIGNAL_BUFFER;
   
       /*
        * Le signal SIGFSTP provient de la mort du processus de contrôle.
        * Sous certains systèmes (Linux...), la mort du terminal de contrôle
        * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
        * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
        * non initialisée (pointeur NULL) issue de TERMIO.
        */
   
       if (siginfo == NULL)
       {
           queue_interruptions.pid[SIGHUP][queue_interruptions.pointeur
                   [SIGHUP][ECRITURE]] = pid;
           queue_interruptions.pointeur[SIGHUP][ECRITURE] =
                   (queue_interruptions.pointeur[SIGHUP][ECRITURE] + 1)
                   % SIGNAL_BUFFER;
           queue_interruptions.nombre_interruptions_en_queue += 2;
       }
   
       return;
   }
   
   static void
   corps_interruption2(struct_processus *s_etat_processus, int signal, pid_t pid)
   {
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux();
   
       if (pid == getpid())
       {
         /*          /*
          *  0 => fonctionnement normal           *  0 => fonctionnement normal
          * -1 => requête           * -1 => requête
Line 1840  interruption2(int signal, siginfo_t *sig Line 2027  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);              while((*s_etat_processus).signal_a_traiter == d_vrai);
             deverrouillage_gestionnaire_signaux();              (*s_etat_processus).signal = signal;
             return;              (*s_etat_processus).origine_signal = getpid();
               (*s_etat_processus).signal_a_traiter = d_vrai;
         }          }
     }      }
   
Line 1853  interruption2(int signal, siginfo_t *sig Line 2042  interruption2(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption3(int signal, siginfo_t *siginfo, void *context)  interruption3(SIGHANDLER_ARGS)
 {  {
     struct_processus        *s_etat_processus;      // 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[] = "+++System : Uncaught access violation\n"
                                   "+++System : Aborting !\n;
   
     static int              compteur = 0;      if (pid_processus_pere == getpid())
       {
           kill(pid_processus_pere, SIGALRM);
       }
   
       write(STDERR_FILENO, message, strlen(message));
       _exit(EXIT_FAILURE);
   }
   
   void INTERRUPTION3_A_FIXER()
   {
       pthread_t               thread;
   
       struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
Line 1885  interruption3(int signal, siginfo_t *sig Line 2093  interruption3(int signal, siginfo_t *sig
         // Segfault dans une routine interne          // Segfault dans une routine interne
         if (strncmp(getenv("LANG"), "fr", 2) == 0)          if (strncmp(getenv("LANG"), "fr", 2) == 0)
         {          {
             printf("+++Système : Violation d'accès (dépassement de pile)\n");              printf("+++Système : Violation d'accès\n");
         }          }
         else          else
         {          {
             printf("+++System : Access violation (stack overflow)\n");              printf("+++System : Access violation\n");
         }          }
   
         fflush(stdout);          fflush(stdout);
   
         compteur++;          (*s_etat_processus).compteur_violation_d_acces++;
   
         if (compteur > 1)          if ((*s_etat_processus).compteur_violation_d_acces > 1)
         {          {
               // On vient de récupérer plus d'une erreur de segmentation
               // dans le même processus ou le même thread. L'erreur n'est pas
               // récupérable et on sort autoritairement du programme. Il peut
               // rester des processus orphelins en attente !
   
               if (strncmp(getenv("LANG"), "fr", 2) == 0)
               {
                   printf("+++Système : Violation d'accès, tentative de "
                           "terminaison de la tâche\n");
                   printf("             (defauts multiples)\n");
               }
               else
               {
                   printf("+++System : Access violation, trying to kill task "
                           "(multiple defaults)\n");
               }
   
               fflush(stdout);
   
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux();
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
         else          else
         {          {
               // Première erreur de segmentation. On essaie de terminer
               // proprement le thread ou le processus. Le signal ne peut être
               // envoyé que depuis le même processus.
   
               if (recherche_thread_principal(getpid(), &thread) == d_vrai)
               {
                   if (pthread_equal(thread, pthread_self()) != 0)
                   {
                       deverrouillage_gestionnaire_signaux();
   
                       if ((*s_etat_processus).pid_processus_pere != getpid())
                       {
                           // On est dans le thread principal d'un processus.
   
                           longjmp(contexte_processus, -1);
                       }
                       else
                       {
                           // On est dans le thread principal du processus
                           // père.
   
                           longjmp(contexte_initial, -1);
                       }
                   }
                   else
                   {
                       // On est dans un thread fils d'un thread principal.
   
                       deverrouillage_gestionnaire_signaux();
                       longjmp(contexte_thread, -1);
                   }
               }
   
               // Là, on ramasse les miettes puisque le thread n'existe plus
               // dans la base (corruption de la mémoire).
   
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux();
             longjmp(contexte_initial, -1);              longjmp(contexte_initial, -1);
         }          }
Line 1913  interruption3(int signal, siginfo_t *sig Line 2176  interruption3(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption4(int signal, siginfo_t *siginfo, void *context)  interruption4(SIGHANDLER_ARGS)
 {  {
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
Line 1941  interruption4(int signal, siginfo_t *sig Line 2205  interruption4(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption5(int signal, siginfo_t *siginfo, void *context)  interruption5(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((*siginfo).si_pid == getpid())  #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
       if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
Line 1982  interruption5(int signal, siginfo_t *sig Line 2256  interruption5(int signal, siginfo_t *sig
     }      }
     else      else
     {      {
           if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                   == NULL)
           {
               deverrouillage_gestionnaire_signaux();
               return;
           }
   
         // Envoi d'un signal au thread maître du groupe.          // Envoi d'un signal au thread maître du groupe.
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)          if (recherche_thread_principal(getpid(), &thread) == d_vrai)
         {          {
             pthread_kill(thread, SIGFSTOP);              pthread_kill(thread, signal);
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux();
             return;              return;
         }          }
Line 1997  interruption5(int signal, siginfo_t *sig Line 2278  interruption5(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption6(int signal, siginfo_t *siginfo, void *context)  interruption6(SIGHANDLER_ARGS)
 {  {
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
Line 2021  interruption6(int signal, siginfo_t *sig Line 2303  interruption6(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption7(int signal, siginfo_t *siginfo, void *context)  interruption7(SIGHANDLER_ARGS)
 {  {
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
Line 2048  interruption7(int signal, siginfo_t *sig Line 2331  interruption7(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption8(int signal, siginfo_t *siginfo, void *context)  interruption8(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((*siginfo).si_pid == getpid())  #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
       if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
Line 2091  interruption8(int signal, siginfo_t *sig Line 2384  interruption8(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption9(int signal, siginfo_t *siginfo, void *context)  interruption9(SIGHANDLER_ARGS)
 {  {
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
Line 2110  interruption9(int signal, siginfo_t *sig Line 2404  interruption9(int signal, siginfo_t *sig
         fflush(stdout);          fflush(stdout);
     }      }
   
     pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP);  #   ifdef _BROKEN_SIGINFO
       if (queue_in(getpid(), signal) != 0)
       {
           return;
       }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux();
       interruption11(signal);
   #   else
       deverrouillage_gestionnaire_signaux();
       interruption11(signal, siginfo, context);
   #   endif
     return;      return;
 }  }
   
 void  void
 interruption10(int signal, siginfo_t *siginfo, void *context)  interruption10(SIGHANDLER_ARGS)
 {  {
     file                    *fichier;      file                    *fichier;
   
Line 2124  interruption10(int signal, siginfo_t *si Line 2428  interruption10(int signal, siginfo_t *si
   
     unsigned char           nom[8 + 64 + 1];      unsigned char           nom[8 + 64 + 1];
   
       test_signal(signal);
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
Line 2157  interruption10(int signal, siginfo_t *si Line 2462  interruption10(int signal, siginfo_t *si
 }  }
   
 void  void
   interruption11(SIGHANDLER_ARGS)
   {
       pid_t                   pid;
   
       pthread_t               thread;
   
       struct_processus        *s_etat_processus;
   
       test_signal(signal);
       verrouillage_gestionnaire_signaux();
   
   #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
       if (pid == getpid())
       {
           if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                   == NULL)
           {
               deverrouillage_gestionnaire_signaux();
               return;
           }
   
           (*s_etat_processus).arret_depuis_abort = -1;
   
           if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
           {
               printf("[%d] SIGFABORT (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)
           {
               (*s_etat_processus).var_volatile_requete_arret = -1;
           }
           else
           {
               (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
           }
       }
       else
       {
           if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                   == NULL)
           {
               deverrouillage_gestionnaire_signaux();
               return;
           }
   
           (*s_etat_processus).arret_depuis_abort = -1;
   
           // Envoi d'un signal au thread maître du groupe.
   
           if (recherche_thread_principal(getpid(), &thread) == d_vrai)
           {
               pthread_kill(thread, signal);
               deverrouillage_gestionnaire_signaux();
               return;
           }
       }
   
       deverrouillage_gestionnaire_signaux();
       return;
   }
   
   void
 traitement_exceptions_gsl(const char *reason, const char *file,  traitement_exceptions_gsl(const char *reason, const char *file,
         int line, int gsl_errno)          int line, int gsl_errno)
 {  {
Line 2175  traitement_exceptions_gsl(const char *re Line 2557  traitement_exceptions_gsl(const char *re
     return;      return;
 }  }
   
   static inline void
   structation_interruptions_elementaires(struct_processus *s_etat_processus,
           int signal, pid_t pid)
   {
       switch(signal)
       {
           case SIGINT:
           case SIGTERM:
           case SIGALRM:
           {
               corps_interruption1(s_etat_processus, signal, pid);
               break;
           }
   
           case SIGTSTP:
           {
               corps_interruption2(s_etat_processus, signal, pid);
           }
       }
   
       return;
   }
   
   void
   scrutation_interruptions(struct_processus *s_etat_processus)
   {
       int             i;
   
       // Interruption par processus.
   
       if (pthread_mutex_lock(&mutex_signal) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (queue_interruptions.nombre_interruptions_en_queue > 0)
       {
           for(i = 0; i < SIGNAL_MAX; i++)
           {
               if ((queue_interruptions.pointeur[i][ECRITURE] -
                       queue_interruptions.pointeur[i][LECTURE]) != 0)
               {
                   // Il y a une interruption dans la queue.
   
                   queue_interruptions.nombre_interruptions_en_queue--;
                   scrutation_interruptions_elementaires(s_etat_processus, i,
                           queue_interruptions.pid[signal]
                           [queue_interruptions.pointeur[signal][LECTURE]]);
                   queue_interruptions.pointeur[signal][LECTURE] =
                           (queue_interruptions.pointeur[signal][LECTURE] + 1)
                           % SIGNAL_BUFFER;
               }
           }
       }
   
       if (pthread_mutex_unlock(&mutex_signal) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       // Interruption par thread
   
       if ((*s_etat_processus).signal_a_traiter == d_vrai)
       {
           (*s_etat_processus).signal_a_traiter = d_faux;
           scrutation_interruptions_elementaires(s_etat_processus,
                   (*s_etat_processus).signal, (*s_etat_processus).origine_signal);
       }
   
       return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.9  
changed lines
  Added in v.1.66

CVSweb interface <joel.bertrand@systella.fr>