Diff for /rpl/src/gestion_threads.c between versions 1.12 and 1.83

version 1.12, 2010/04/28 07:05:38 version 1.83, 2013/05/30 09:41:41
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.15    RPL/2 (R) version 4.1.14
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2013 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 38 Line 38
 void *  void *
 lancement_thread(void *argument)  lancement_thread(void *argument)
 {  {
     int                         status;      int                                 status;
   
     pid_t                       ppid;      pid_t                               ppid;
   
     pthread_t                   tid_final;      sig_atomic_t                        registre_stop;
   
     sig_atomic_t                registre_stop;      ssize_t                             longueur_ecriture;
   
     sigset_t                    set;      struct_descripteur_thread           *s_argument_thread;
   
     ssize_t                     longueur_ecriture;      struct_liste_chainee                *l_element_courant;
       struct_liste_chainee                *l_element_suivant;
   
     struct_descripteur_thread   *s_argument_thread;      struct_liste_variables_statiques    *l_element_statique_courant;
       struct_liste_variables_statiques    *l_element_statique_suivant;
   
     struct_liste_chainee        *l_element_courant;      struct_objet                        *s_objet_temporaire;
     struct_liste_chainee        *l_element_suivant;  
   
     struct_objet                *s_objet_temporaire;      struct_processus                    *s_etat_processus;
   
     struct_processus            *s_etat_processus;      struct sigaction                    action;
       struct sigaction                    registre;
   
     struct sigaction            action;      struct timespec                     attente;
     struct sigaction            registre;  
   
     struct timespec             attente;      unsigned char                       caractere;
       unsigned char                       *message;
   
     unsigned char               *message;      unsigned int                        erreur;
   
     unsigned int                erreur;      integer8                            i;
   
     unsigned long               i;  
   
     attente.tv_sec = 0;      attente.tv_sec = 0;
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     s_argument_thread = (struct_descripteur_thread *) argument;      s_argument_thread = (struct_descripteur_thread *) argument;
     (*s_argument_thread).tid = pthread_self();  
     (*s_argument_thread).thread_actif = d_vrai;  
     s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;      s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     if (pthread_setspecific(semaphore_fork_processus_courant,          sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
             &((*s_etat_processus).semaphore_fork)) != 0)  
 #   else  #   else
     if (pthread_setspecific(semaphore_fork_processus_courant,          if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
             (*s_etat_processus).semaphore_fork) != 0)                  pthread_self(), SEM_FORK)) == SEM_FAILED)
 #   endif  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
   
         pthread_mutex_unlock(&((*s_etat_processus).mutex));  
   
         pthread_mutex_lock(&((*s_argument_thread).mutex));  
         pthread_mutex_unlock(&((*s_argument_thread).mutex));  
   
         (*s_argument_thread).thread_actif = d_faux;  
   
         tid_final = -2;  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                 &tid_final, sizeof(tid_final))) != sizeof(tid_final))  
         {  
             if (longueur_ecriture == -1)  
             {  
                 break;  
             }  
         }  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_argument_thread).pipe_nombre_objets_attente[1],  
                 &tid_final, sizeof(tid_final))) != sizeof(tid_final))  
         {          {
             if (longueur_ecriture == -1)              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             {              return(NULL);
                 break;  
             }  
         }          }
   #   endif
   
         pthread_exit(NULL);      (*s_argument_thread).tid = pthread_self();
     }      insertion_thread(s_etat_processus, d_faux);
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 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;
           return(NULL);
       }
   
         pthread_mutex_lock(&((*s_argument_thread).mutex));      (*s_argument_thread).thread_actif = d_vrai;
         pthread_mutex_unlock(&((*s_argument_thread).mutex));  
   
         (*s_argument_thread).thread_actif = d_faux;  
   
         tid_final = -2;  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                 &tid_final, sizeof(tid_final))) != sizeof(tid_final))  
         {  
             if (longueur_ecriture == -1)  
             {  
                 break;  
             }  
         }  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_argument_thread).pipe_nombre_objets_attente[1],  
                 &tid_final, sizeof(tid_final))) != sizeof(tid_final))  
         {  
             if (longueur_ecriture == -1)  
             {  
                 break;  
             }  
         }  
   
         pthread_exit(NULL);      if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(NULL);
     }      }
   
     insertion_thread(s_etat_processus, d_faux);  
   
     // Envoi d'une donnée pour signaler le démarrage du thread au thread      // Envoi d'une donnée pour signaler le démarrage du thread au thread
     // de surveillance.      // de surveillance.
   
       caractere = 0;
   
     if (write_atomic(s_etat_processus,      if (write_atomic(s_etat_processus,
             (*s_argument_thread).pipe_nombre_objets_attente[1],              (*s_argument_thread).pipe_nombre_elements_attente[1],
             "-", sizeof(unsigned char)) != sizeof(unsigned char))              &caractere, sizeof(caractere)) != sizeof(caractere))
     {      {
         pthread_mutex_unlock(&((*s_etat_processus).mutex));  
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
   
         pthread_mutex_lock(&((*s_argument_thread).mutex));          pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 171  lancement_thread(void *argument) Line 120  lancement_thread(void *argument)
   
         (*s_argument_thread).thread_actif = d_faux;          (*s_argument_thread).thread_actif = d_faux;
   
         tid_final = -2;  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_argument_thread).pipe_nombre_interruptions_attente[1],                  (*s_argument_thread).pipe_nombre_elements_attente[1],
                 &tid_final, sizeof(tid_final))) != sizeof(tid_final))                  &caractere, sizeof(caractere))) != sizeof(caractere))
         {  
             if (longueur_ecriture == -1)  
             {  
                 break;  
             }  
         }  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_argument_thread).pipe_nombre_objets_attente[1],  
                 &tid_final, sizeof(tid_final))) != sizeof(tid_final))  
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 202  lancement_thread(void *argument) Line 139  lancement_thread(void *argument)
         (*s_etat_processus).instruction_courante = NULL;          (*s_etat_processus).instruction_courante = NULL;
     }      }
   
     set = (*s_argument_thread).set;      // Attente de la réception du signal rpl_sigstart.
   
     if (sigpending(&set) != 0)      for((*s_etat_processus).demarrage_fils = d_faux;;)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          scrutation_interruptions(s_etat_processus);
     }  
     else if (sigismember(&set, SIGSTART) == 0)  
     {  
         while(sigismember(&set, SIGSTART) == 0)  
         {  
             if (sigpending(&set) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
             }  
   
             nanosleep(&attente, NULL);          if ((*s_etat_processus).demarrage_fils == d_vrai)
           {
               break;
         }          }
   
           nanosleep(&attente, NULL);
     }      }
   
     if ((*s_etat_processus).debug == d_vrai)      if ((*s_etat_processus).debug == d_vrai)
Line 238  lancement_thread(void *argument) Line 170  lancement_thread(void *argument)
         fflush(stdout);          fflush(stdout);
     }      }
   
     if (pthread_sigmask(SIG_SETMASK, &((*s_argument_thread).oldset), NULL) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
     }  
   
     sigpending(&set);  
   
     (*s_etat_processus).pid_erreur_processus_fils = getpid();      (*s_etat_processus).pid_erreur_processus_fils = getpid();
   
     // Évaluation de l'objet      // Évaluation de l'objet
   
     if ((*s_etat_processus).erreur_systeme == d_es)      if ((*s_etat_processus).erreur_systeme == d_es)
     {      {
         if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')          if (setjmp(contexte_thread) == 0)
                 == d_erreur)  
         {          {
             if (((*s_etat_processus).erreur_execution == d_ex) &&              if (evaluation(s_etat_processus, (*s_argument_thread).argument, 'E')
                     ((*s_etat_processus).erreur_systeme == d_es))                      == d_erreur)
             {              {
                 (*s_etat_processus).erreur_execution =                  if (((*s_etat_processus).erreur_execution == d_ex) &&
                         d_ex_erreur_evaluation;                          ((*s_etat_processus).erreur_systeme == d_es))
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_evaluation;
                   }
             }              }
         }              else
         else  
         {  
             if ((*s_etat_processus).at_exit != NULL)  
             {              {
                 if (evaluation(s_etat_processus, (*s_etat_processus).at_exit,                  if (((*s_etat_processus).arret_depuis_abort == 0)
                         'E') == d_erreur)                          && ((*s_etat_processus).at_exit != NULL))
                 {                  {
                     if (((*s_etat_processus).erreur_execution == d_ex) &&                      (*s_etat_processus).var_volatile_requete_arret = 0;
                             ((*s_etat_processus).erreur_systeme == d_es))                      (*s_etat_processus).var_volatile_alarme = 0;
                       (*s_etat_processus).var_volatile_traitement_sigint = 0;
   
                       if ((*s_etat_processus).profilage == d_vrai)
                       {
                           profilage(s_etat_processus, "ATEXIT");
                       }
   
                       if (evaluation(s_etat_processus,
                               (*s_etat_processus).at_exit, 'E') == d_erreur)
                     {                      {
                         (*s_etat_processus).erreur_execution =                          if (((*s_etat_processus).erreur_execution == d_ex) &&
                                 d_ex_erreur_evaluation;                                  ((*s_etat_processus).erreur_systeme == d_es))
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_evaluation;
                           }
                       }
   
                       if ((*s_etat_processus).profilage == d_vrai)
                       {
                           profilage(s_etat_processus, NULL);
                     }                      }
                 }                  }
             }              }
Line 289  lancement_thread(void *argument) Line 232  lancement_thread(void *argument)
         pthread_cancel((*s_etat_processus).thread_fusible);          pthread_cancel((*s_etat_processus).thread_fusible);
     }      }
   
     tid_final = -2;      caractere = 0;
   
     while((longueur_ecriture = write_atomic(s_etat_processus,      while((longueur_ecriture = write_atomic(s_etat_processus,
             (*s_argument_thread).pipe_nombre_interruptions_attente[1],              (*s_argument_thread).pipe_nombre_elements_attente[1],
             &tid_final, sizeof(tid_final))) != sizeof(tid_final))              &caractere, sizeof(caractere))) != sizeof(caractere))
     {  
         if (longueur_ecriture == -1)  
         {  
             break;  
         }  
     }  
   
     while((longueur_ecriture = write_atomic(s_etat_processus,  
             (*s_argument_thread).pipe_nombre_objets_attente[1],  
             &tid_final, sizeof(tid_final))) != sizeof(tid_final))  
     {      {
         if (longueur_ecriture == -1)          if (longueur_ecriture == -1)
         {          {
Line 332  lancement_thread(void *argument) Line 265  lancement_thread(void *argument)
     {      {
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_argument_thread).pipe_erreurs[1],                  (*s_argument_thread).pipe_erreurs[1],
                 &((*s_etat_processus).erreur_execution),                  (int *) &((*s_etat_processus).erreur_execution),
                 sizeof((*s_etat_processus).erreur_execution))) !=                  sizeof((*s_etat_processus).erreur_execution))) !=
                 sizeof((*s_etat_processus).erreur_execution))                  sizeof((*s_etat_processus).erreur_execution))
         {          {
Line 364  lancement_thread(void *argument) Line 297  lancement_thread(void *argument)
     {      {
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_argument_thread).pipe_erreurs[1],                  (*s_argument_thread).pipe_erreurs[1],
                 &((*s_etat_processus).erreur_systeme),                  (int *) &((*s_etat_processus).erreur_systeme),
                 sizeof((*s_etat_processus).erreur_systeme))) !=                  sizeof((*s_etat_processus).erreur_systeme))) !=
                 sizeof((*s_etat_processus).erreur_systeme))                  sizeof((*s_etat_processus).erreur_systeme))
         {          {
Line 406  lancement_thread(void *argument) Line 339  lancement_thread(void *argument)
   
     close((*s_argument_thread).pipe_erreurs[1]);      close((*s_argument_thread).pipe_erreurs[1]);
     close((*s_argument_thread).pipe_interruptions[1]);      close((*s_argument_thread).pipe_interruptions[1]);
     close((*s_argument_thread).pipe_nombre_interruptions_attente[1]);      close((*s_argument_thread).pipe_nombre_elements_attente[1]);
     close((*s_argument_thread).pipe_objets[1]);      close((*s_argument_thread).pipe_objets[1]);
     close((*s_argument_thread).pipe_nombre_objets_attente[1]);  
     close((*s_argument_thread).pipe_injections[0]);      close((*s_argument_thread).pipe_injections[0]);
     close((*s_argument_thread).pipe_nombre_injections[0]);      close((*s_argument_thread).pipe_nombre_injections[0]);
     close((*s_argument_thread).pipe_acquittement[0]);      close((*s_argument_thread).pipe_acquittement[0]);
Line 448  lancement_thread(void *argument) Line 380  lancement_thread(void *argument)
         l_element_courant = l_element_suivant;          l_element_courant = l_element_suivant;
     }      }
   
     pthread_mutex_lock(&((*s_etat_processus).mutex));      pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
   
     l_element_courant = (struct_liste_chainee *)      l_element_courant = (struct_liste_chainee *)
             (*s_etat_processus).l_base_pile_processus;              (*s_etat_processus).l_base_pile_processus;
Line 483  lancement_thread(void *argument) Line 415  lancement_thread(void *argument)
   
             if ((*s_etat_processus).var_volatile_alarme != 0)              if ((*s_etat_processus).var_volatile_alarme != 0)
             {              {
                 kill((*(*((struct_processus_fils *) (*(*l_element_courant)                  envoi_signal_processus((*(*((struct_processus_fils *)
                         .donnee).objet)).thread).pid, SIGURG);                          (*(*l_element_courant)
                           .donnee).objet)).thread).pid, rpl_sigurg);
             }              }
             else              else
             {              {
                 kill((*(*((struct_processus_fils *) (*(*l_element_courant)                  if ((*s_etat_processus).arret_depuis_abort == -1)
                         .donnee).objet)).thread).pid, SIGFSTOP);                  {
                       envoi_signal_processus((*(*((struct_processus_fils *)
                               (*(*l_element_courant)
                               .donnee).objet)).thread).pid, rpl_sigabort);
                   }
                   else
                   {
                       envoi_signal_processus((*(*((struct_processus_fils *)
                               (*(*l_element_courant)
                               .donnee).objet)).thread).pid, rpl_sigstop);
                   }
             }              }
         }          }
         else          else
Line 523  lancement_thread(void *argument) Line 466  lancement_thread(void *argument)
                         (*(*l_element_courant).donnee).objet)).thread).mutex))                          (*(*l_element_courant).donnee).objet)).thread).mutex))
                         != 0)                          != 0)
                 {                  {
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
   
                     pthread_mutex_lock(&((*s_argument_thread).mutex));                      pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 538  lancement_thread(void *argument) Line 482  lancement_thread(void *argument)
                         (*(*l_element_courant).donnee).objet)).thread)                          (*(*l_element_courant).donnee).objet)).thread)
                         .thread_actif == d_vrai)                          .thread_actif == d_vrai)
                 {                  {
                     pthread_kill((*(*((struct_processus_fils *)                      envoi_signal_thread((*(*((struct_processus_fils *)
                             (*(*l_element_courant).donnee).objet)).thread).tid,                              (*(*l_element_courant).donnee).objet)).thread).tid,
                             SIGURG);                              rpl_sigurg);
                 }                  }
   
                 if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)                  if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
                         (*(*l_element_courant).donnee).objet)).thread)                          (*(*l_element_courant).donnee).objet)).thread)
                         .mutex)) != 0)                          .mutex)) != 0)
                 {                  {
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
   
                     pthread_mutex_lock(&((*s_argument_thread).mutex));                      pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 564  lancement_thread(void *argument) Line 509  lancement_thread(void *argument)
                         (*(*l_element_courant).donnee).objet)).thread).mutex))                          (*(*l_element_courant).donnee).objet)).thread).mutex))
                         != 0)                          != 0)
                 {                  {
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
   
                     pthread_mutex_lock(&((*s_argument_thread).mutex));                      pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 579  lancement_thread(void *argument) Line 525  lancement_thread(void *argument)
                         (*(*l_element_courant).donnee).objet)).thread)                          (*(*l_element_courant).donnee).objet)).thread)
                         .thread_actif == d_vrai)                          .thread_actif == d_vrai)
                 {                  {
                     pthread_kill((*(*((struct_processus_fils *)                      if ((*s_etat_processus).arret_depuis_abort == -1)
                             (*(*l_element_courant).donnee).objet)).thread).tid,                      {
                             SIGFSTOP);                          envoi_signal_thread((*(*((struct_processus_fils *)
                                   (*(*l_element_courant).donnee).objet)).thread)
                                   .tid, rpl_sigabort);
                       }
                       else
                       {
                           envoi_signal_thread((*(*((struct_processus_fils *)
                                   (*(*l_element_courant).donnee).objet)).thread)
                                   .tid, rpl_sigstop);
                       }
                 }                  }
   
                 if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)                  if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
                         (*(*l_element_courant).donnee).objet)).thread).mutex))                          (*(*l_element_courant).donnee).objet)).thread).mutex))
                         != 0)                          != 0)
                 {                  {
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
   
                     pthread_mutex_lock(&((*s_argument_thread).mutex));                      pthread_mutex_lock(&((*s_argument_thread).mutex));
Line 621  lancement_thread(void *argument) Line 577  lancement_thread(void *argument)
         l_element_courant = (struct_liste_chainee *)          l_element_courant = (struct_liste_chainee *)
                 (*s_etat_processus).l_base_pile_processus;                  (*s_etat_processus).l_base_pile_processus;
   
         if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)  
         {  
             affectation_interruptions_logicielles(s_etat_processus);  
         }  
   
         registre_stop = (*s_etat_processus)          registre_stop = (*s_etat_processus)
                 .var_volatile_traitement_retarde_stop;                  .var_volatile_traitement_retarde_stop;
         (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;          (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
   
         for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *)          for(i = 0; i < (*(*((struct_processus_fils *)
                 (*(*l_element_courant).donnee).objet)).thread)                  (*(*l_element_courant).donnee).objet)).thread)
                 .nombre_objets_dans_pipe; i++)                  .nombre_objets_dans_pipe; i++)
         {          {
Line 648  lancement_thread(void *argument) Line 599  lancement_thread(void *argument)
   
                 if (sigaction(SIGPIPE, &action, &registre) != 0)                  if (sigaction(SIGPIPE, &action, &registre) != 0)
                 {                  {
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
   
                     if (registre_stop == 0)                      if (registre_stop == 0)
                     {                      {
Line 699  lancement_thread(void *argument) Line 651  lancement_thread(void *argument)
   
                 if (sigaction(SIGPIPE, &registre, NULL) != 0)                  if (sigaction(SIGPIPE, &registre, NULL) != 0)
                 {                  {
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
   
                     (*s_etat_processus).erreur_systeme = d_es_signal;                      (*s_etat_processus).erreur_systeme = d_es_signal;
                     exit(EXIT_FAILURE);                      exit(EXIT_FAILURE);
Line 717  lancement_thread(void *argument) Line 670  lancement_thread(void *argument)
             }              }
         }          }
   
         pthread_mutex_unlock(&((*s_etat_processus).mutex));          if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0)
           {
               pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
   
               (*s_etat_processus).erreur_systeme = d_es_processus;
               exit(EXIT_FAILURE);
           }
   
           if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
           {
               affectation_interruptions_logicielles(s_etat_processus);
           }
   
           if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions))
                   != 0)
           {
               pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
   
               (*s_etat_processus).erreur_systeme = d_es_processus;
               exit(EXIT_FAILURE);
           }
   
           pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
         pthread_mutex_lock(&((*s_etat_processus).mutex));          pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
     }      }
   
     pthread_mutex_unlock(&((*s_etat_processus).mutex));      pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
   
     l_element_courant = (*s_etat_processus).s_sockets;      l_element_courant = (*s_etat_processus).s_sockets;
   
Line 859  lancement_thread(void *argument) Line 834  lancement_thread(void *argument)
         (*s_etat_processus).instruction_derniere_erreur = NULL;          (*s_etat_processus).instruction_derniere_erreur = NULL;
     }      }
   
     for(i = 0; i < (*s_etat_processus).nombre_variables; i++)      liberation_arbre_variables(s_etat_processus,
     {              (*s_etat_processus).s_arbre_variables, d_faux);
         // Les définitions ne sont pas libérées parce qu'elles sont partagées  
         // avec le thread père.  
   
         if ((*s_etat_processus).s_liste_variables[i].niveau != 0)      l_element_statique_courant = (*s_etat_processus)
         {              .l_liste_variables_statiques;
             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);      while(l_element_statique_courant != NULL)
   
     for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)  
     {      {
         liberation(s_etat_processus,          l_element_statique_suivant = (*l_element_statique_courant).suivant;
                 (*s_etat_processus).s_liste_variables_statiques[i].objet);          free(l_element_statique_courant);
         free((*s_etat_processus).s_liste_variables_statiques[i].nom);          l_element_statique_courant = l_element_statique_suivant;
     }      }
   
     free((*s_etat_processus).s_liste_variables_statiques);  
   
     l_element_courant = (*s_etat_processus).l_base_pile;      l_element_courant = (*s_etat_processus).l_base_pile;
     while(l_element_courant != NULL)      while(l_element_courant != NULL)
     {      {
Line 1008  lancement_thread(void *argument) Line 971  lancement_thread(void *argument)
   
     liberation(s_etat_processus, (*s_argument_thread).argument);      liberation(s_etat_processus, (*s_argument_thread).argument);
     liberation(s_etat_processus, (*s_etat_processus).at_exit);      liberation(s_etat_processus, (*s_etat_processus).at_exit);
       liberation(s_etat_processus, (*s_etat_processus).at_poke);
   
     for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)      for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
     {      {
Line 1054  lancement_thread(void *argument) Line 1018  lancement_thread(void *argument)
     liberation_allocateur(s_etat_processus);      liberation_allocateur(s_etat_processus);
   
     retrait_thread(s_etat_processus);      retrait_thread(s_etat_processus);
     pthread_mutex_destroy(&((*s_etat_processus).mutex));      pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
       pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
       pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
       pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
   
   #   ifndef SEMAPHORES_NOMMES
           sem_destroy(&((*s_etat_processus).semaphore_fork));
   #   else
           sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
                   pthread_self(), SEM_FORK);
   #   endif
   
       liberation_contexte_cas(s_etat_processus);
     free((*s_etat_processus).localisation);      free((*s_etat_processus).localisation);
     free(s_etat_processus);      free(s_etat_processus);
   
     pthread_mutex_lock(&((*s_argument_thread).mutex));      pthread_mutex_lock(&((*s_argument_thread).mutex));
       (*s_argument_thread).thread_actif = d_faux;
     pthread_mutex_unlock(&((*s_argument_thread).mutex));      pthread_mutex_unlock(&((*s_argument_thread).mutex));
   
     (*s_argument_thread).thread_actif = d_faux;  
     pthread_exit(NULL);      pthread_exit(NULL);
       return(NULL);
 }  }
   
 // vim: ts=4  // vim: ts=4

Removed from v.1.12  
changed lines
  Added in v.1.83


CVSweb interface <joel.bertrand@systella.fr>