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

Diff for /rpl/src/gestion_threads.c between versions 1.41 and 1.54

version 1.41, 2011/06/24 20:31:36 version 1.54, 2011/09/20 15:45:53
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.4    RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2011 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 46  lancement_thread(void *argument) Line 46  lancement_thread(void *argument)
   
     sig_atomic_t                registre_stop;      sig_atomic_t                registre_stop;
   
     sigset_t                    set;  
   
     ssize_t                     longueur_ecriture;      ssize_t                     longueur_ecriture;
   
     struct_descripteur_thread   *s_argument_thread;      struct_descripteur_thread   *s_argument_thread;
Line 78  lancement_thread(void *argument) Line 76  lancement_thread(void *argument)
     (*s_argument_thread).tid = pthread_self();      (*s_argument_thread).tid = pthread_self();
     (*s_argument_thread).thread_actif = d_vrai;      (*s_argument_thread).thread_actif = d_vrai;
   
 #   ifndef SEMAPHORES_NOMMES  
     if (pthread_setspecific(semaphore_fork_processus_courant,  
             &((*s_etat_processus).semaphore_fork)) != 0)  
 #   else  
     if (pthread_setspecific(semaphore_fork_processus_courant,  
             (*s_etat_processus).semaphore_fork) != 0)  
 #   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)  
             {  
                 break;  
             }  
         }  
   
         pthread_exit(NULL);  
     }  
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
   
         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)  
             {  
                 break;  
             }  
         }  
   
         pthread_exit(NULL);  
     }  
   
     insertion_thread(s_etat_processus, d_faux);      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
Line 163  lancement_thread(void *argument) Line 85  lancement_thread(void *argument)
             (*s_argument_thread).pipe_nombre_objets_attente[1],              (*s_argument_thread).pipe_nombre_objets_attente[1],
             "-", sizeof(unsigned char)) != sizeof(unsigned char))              "-", sizeof(unsigned char)) != sizeof(unsigned char))
     {      {
         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 202  lancement_thread(void *argument) Line 123  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;  
     }  
     else if (sigismember(&set, SIGSTART) == 0)  
     {      {
         while(sigismember(&set, SIGSTART) == 0)          scrutation_interruptions(s_etat_processus);
         {  
             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 154  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).var_volatile_alarme == 0)  
                     && ((*s_etat_processus).arret_depuis_abort == 0)  
                     && ((*s_etat_processus).at_exit != NULL))  
             {              {
                 (*s_etat_processus).var_volatile_requete_arret = 0;                  if (((*s_etat_processus).var_volatile_alarme == 0)
                 (*s_etat_processus).var_volatile_traitement_retarde_stop = -1;                          && ((*s_etat_processus).arret_depuis_abort == 0)
                           && ((*s_etat_processus).at_exit != NULL))
                   {
                       (*s_etat_processus).var_volatile_requete_arret = 0;
                       (*s_etat_processus).var_volatile_traitement_retarde_stop =
                               -1;
   
                 if (evaluation(s_etat_processus, (*s_etat_processus).at_exit,                      if (evaluation(s_etat_processus,
                         'E') == d_erreur)                              (*s_etat_processus).at_exit, 'E') == d_erreur)
                 {  
                     if (((*s_etat_processus).erreur_execution == d_ex) &&  
                             ((*s_etat_processus).erreur_systeme == d_es))  
                     {                      {
                         (*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;
                           }
                     }                      }
                 }                  }
             }              }
Line 488  lancement_thread(void *argument) Line 401  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
             {              {
                 if ((*s_etat_processus).arret_depuis_abort == -1)                  if ((*s_etat_processus).arret_depuis_abort == -1)
                 {                  {
                     kill((*(*((struct_processus_fils *) (*(*l_element_courant)                      envoi_signal_processus((*(*((struct_processus_fils *)
                             .donnee).objet)).thread).pid, SIGFABORT);                              (*(*l_element_courant)
                               .donnee).objet)).thread).pid, rpl_sigabort);
                 }                  }
                 else                  else
                 {                  {
                     kill((*(*((struct_processus_fils *) (*(*l_element_courant)                      envoi_signal_processus((*(*((struct_processus_fils *)
                             .donnee).objet)).thread).pid, SIGFSTOP);                              (*(*l_element_courant)
                               .donnee).objet)).thread).pid, rpl_sigstop);
                 }                  }
             }              }
         }          }
Line 551  lancement_thread(void *argument) Line 467  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 *)
Line 594  lancement_thread(void *argument) Line 510  lancement_thread(void *argument)
                 {                  {
                     if ((*s_etat_processus).arret_depuis_abort == -1)                      if ((*s_etat_processus).arret_depuis_abort == -1)
                     {                      {
                         pthread_kill((*(*((struct_processus_fils *)                          envoi_signal_thread((*(*((struct_processus_fils *)
                                 (*(*l_element_courant).donnee).objet)).thread)                                  (*(*l_element_courant).donnee).objet)).thread)
                                 .tid, SIGFABORT);                                  .tid, rpl_sigabort);
                     }                      }
                     else                      else
                     {                      {
                         pthread_kill((*(*((struct_processus_fils *)                          envoi_signal_thread((*(*((struct_processus_fils *)
                                 (*(*l_element_courant).donnee).objet)).thread)                                  (*(*l_element_courant).donnee).objet)).thread)
                                 .tid, SIGFSTOP);                                  .tid, rpl_sigstop);
                     }                      }
                 }                  }
   
Line 1068  lancement_thread(void *argument) Line 984  lancement_thread(void *argument)
     pthread_mutex_destroy(&((*s_etat_processus).mutex));      pthread_mutex_destroy(&((*s_etat_processus).mutex));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
   
     sem_destroy(&((*s_etat_processus).semaphore_fork));  #   ifndef SEMAPHORES_NOMMES
           sem_destroy(&((*s_etat_processus).semaphore_fork));
   #   else
           sem_destroy2((*s_etat_processus).semaphore_fork, getpid(), 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);
   
Removed from v.1.41  
changed lines
  Added in v.1.54

CVSweb interface <joel.bertrand@systella.fr>