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

Diff for /rpl/src/interruptions.c between versions 1.13 and 1.17

version 1.13, 2010/04/30 15:01:14 version 1.17, 2010/05/22 21:45:50
Line 366  retrait_thread_surveillance(struct_proce Line 366  retrait_thread_surveillance(struct_proce
         return;          return;
     }      }
   
     // l_element_courant->donnee n'est pas bonne lorsque ça part en vrille.  
     if (l_element_precedent == NULL)      if (l_element_precedent == NULL)
     {      {
         liste_threads_surveillance = (*l_element_courant).suivant;          liste_threads_surveillance = (*l_element_courant).suivant;
Line 1156  liberation_threads(struct_processus *s_e Line 1155  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 1239  liberation_threads(struct_processus *s_e Line 1244  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 1432  recherche_thread_principal(pid_t pid, pt Line 1440  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 1963  interruption5(int signal, siginfo_t *sig Line 1971  interruption5(int signal, siginfo_t *sig
             return;              return;
         }          }
   
         if (signal == SIGFABORT)  
         {  
             (*s_etat_processus).arret_depuis_abort = -1;  
         }  
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             if (signal == SIGFSTOP)              printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
             {                      (unsigned long long) pthread_self());
                 printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),              fflush(stdout);
                         (unsigned long long) pthread_self());  
                 fflush(stdout);  
             }  
             else  
             {  
                 printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),  
                         (unsigned long long) pthread_self());  
                 fflush(stdout);  
             }  
         }          }
   
         /*          /*
Line 2009  interruption5(int signal, siginfo_t *sig Line 2003  interruption5(int signal, siginfo_t *sig
             return;              return;
         }          }
   
         if (signal == SIGFABORT)  
         {  
             (*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 (recherche_thread_principal(getpid(), &thread) == d_vrai)
Line 2142  interruption9(int signal, siginfo_t *sig Line 2131  interruption9(int signal, siginfo_t *sig
         fflush(stdout);          fflush(stdout);
     }      }
   
     pthread_kill((*s_etat_processus).tid_processus_pere, SIGFABORT);  
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux();
       interruption11(signal, siginfo, context);
     return;      return;
 }  }
   
Line 2185  interruption10(int signal, siginfo_t *si Line 2174  interruption10(int signal, siginfo_t *si
     }      }
   
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux();
       return;
   }
   
   void
   interruption11(int signal, siginfo_t *siginfo, void *context)
   {
       pthread_t               thread;
       struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
       if ((*siginfo).si_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;      return;
 }  }
   
Removed from v.1.13  
changed lines
  Added in v.1.17

CVSweb interface <joel.bertrand@systella.fr>