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

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

version 1.65, 2011/09/09 12:23:25 version 1.66, 2011/09/10 20:45:06
Line 1457  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 1482  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 1719  deverrouillage_gestionnaire_signaux() Line 1718  deverrouillage_gestionnaire_signaux()
 }  }
   
 #define test_signal(signal) \  #define test_signal(signal) \
     if (signal_test == SIGTEST) { signal_test = signal; return; }      if (signal_test == SIGTEST) \
       { signal_test = initialisation_queue_interruptions(signal); return; }
   
 void  /*
 interruption1(SIGHANDLER_ARGS)   * 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
 {  {
     pid_t                   pid;  #   define                  SIGNAL_MAX      32
   #   define                  SIGNAL_BUFFER   1024
   #   define                  ECRITURE        0
   #   define                  LECTURE         1
   
     pthread_t               thread;      sig_atomic_t            nombre_interruptions_en_queue;
       int                     pointeur[SIGNAL_MAX][2];
   
     struct_processus        *s_etat_processus;      pid_t                   pid[SIGNAL_MAX][SIGNAL_BUFFER];
   } queue_interruptions;
   
     volatile sig_atomic_t   exclusion = 0;  pthread_mutex_t             mutex_signal = PTHREAD_MUTEX_INITIALIZER;
   
     test_signal(signal);  static inline int
     verrouillage_gestionnaire_signaux();  initialisation_queue_interruptions(int signal)
   {
       int         i;
   
 #   ifdef _BROKEN_SIGINFO      if (signal > SIGNAL_MAX)
     if ((signal == SIGINT) || (signal == SIGTERM))  
     {      {
         // Si l'interruption provient du clavier, il n'y a pas eu d'appel          return(signal + 1);
         // à queue_in().  
   
         pid = getpid();  
     }      }
     else  
       queue_interruptions.nombre_interruptions_en_queue = 0;
   
       for(i = 0; i < SIGNAL_MAX; i++)
     {      {
         pid = origine_signal(signal);          queue_interruptions.pointeur[i][ECRITURE] = 0;
           queue_interruptions.pointeur[i][LECTURE] = 0;
     }      }
   
       return(signal);
   }
   
   void
   interruption1(SIGHANDLER_ARGS)
   {
       pid_t               pid;
   
       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  #   else
     if (siginfo != NULL)  
     {      /*
         pid = (*siginfo).si_pid;       * Une vieille spécification POSIX permet au pointeur siginfo
     }       * d'être nul dans le cas d'un ^C envoyé depuis le clavier.
     else       * Solaris suit en particulier cette spécification.
     {       */
         pid = getpid();  
     }          if (siginfo != NULL)
           {
               pid = (*siginfo).si_pid;
           }
           else
           {
               pid = getpid();
           }
 #   endif  #   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;
   
       struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux();
   
     switch(signal)      switch(signal)
     {      {
         case SIGALRM :          case SIGALRM :
         {          {
             if (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 1790  interruption1(SIGHANDLER_ARGS) Line 1846  interruption1(SIGHANDLER_ARGS)
             }              }
             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 1802  interruption1(SIGHANDLER_ARGS) Line 1862  interruption1(SIGHANDLER_ARGS)
         case SIGINT :          case SIGINT :
         case SIGTERM :          case SIGTERM :
         {          {
             /*  
              * Une vieille spécification POSIX permet au pointeur siginfo  
              * d'être nul dans le cas d'un ^C envoyé depuis le clavier.  
              * Solaris suit en particulier cette spécification.  
              */  
   
 #           ifndef _BROKEN_SIGINFO  
             if (siginfo == NULL)  
             {  
                 kill(getpid(), signal);  
             }  
             else  
 #           endif  
             if (pid == getpid())              if (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)
                 {                  {
                     if (signal == SIGINT)                      if (signal == SIGINT)
Line 1880  interruption1(SIGHANDLER_ARGS) Line 1920  interruption1(SIGHANDLER_ARGS)
             }              }
             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 1904  interruption1(SIGHANDLER_ARGS) Line 1948  interruption1(SIGHANDLER_ARGS)
 void  void
 interruption2(SIGHANDLER_ARGS)  interruption2(SIGHANDLER_ARGS)
 {  {
     pid_t                   pid;      pid_t               pid;
   
     pthread_t               thread;  
   
     struct_processus        *s_etat_processus;  
   
     test_signal(signal);      test_signal(signal);
     verrouillage_gestionnaire_signaux();  
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
Line 1926  interruption2(SIGHANDLER_ARGS) Line 1965  interruption2(SIGHANDLER_ARGS)
     }      }
 #   endif  #   endif
   
 #   ifndef _BROKEN_SIGINFO      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)      if (siginfo == NULL)
     {      {
         /*          queue_interruptions.pid[SIGHUP][queue_interruptions.pointeur
          * Le signal SIGFSTP provient de la mort du processus de contrôle.                  [SIGHUP][ECRITURE]] = pid;
          * Sous certains systèmes (Linux...), la mort du terminal de contrôle          queue_interruptions.pointeur[SIGHUP][ECRITURE] =
          * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres                  (queue_interruptions.pointeur[SIGHUP][ECRITURE] + 1)
          * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo                  % SIGNAL_BUFFER;
          * non initialisée (pointeur NULL) issue de TERMIO.          queue_interruptions.nombre_interruptions_en_queue += 2;
          */  
   
         if (recherche_thread_principal(getpid(), &thread) == d_vrai)  
         {  
             pthread_kill(thread, SIGHUP);  
             deverrouillage_gestionnaire_signaux();  
             return;  
         }  
     }      }
     else  
 #   endif      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())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  
                 == NULL)  
         {  
             deverrouillage_gestionnaire_signaux();  
             return;  
         }  
   
         /*          /*
          *  0 => fonctionnement normal           *  0 => fonctionnement normal
          * -1 => requête           * -1 => requête
Line 1981  interruption2(SIGHANDLER_ARGS) Line 2027  interruption2(SIGHANDLER_ARGS)
     {      {
         // 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 1996  interruption2(SIGHANDLER_ARGS) Line 2044  interruption2(SIGHANDLER_ARGS)
 void  void
 interruption3(SIGHANDLER_ARGS)  interruption3(SIGHANDLER_ARGS)
 {  {
       // 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;
   
       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;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
Line 2491  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.65  
changed lines
  Added in v.1.66

CVSweb interface <joel.bertrand@systella.fr>