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

Diff for /rpl/src/instructions_d5.c between versions 1.107 and 1.136

version 1.107, 2013/04/01 15:29:35 version 1.136, 2015/10/26 15:14:19
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.14    RPL/2 (R) version 4.1.23
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 767  instruction_der(struct_processus *s_etat Line 767  instruction_der(struct_processus *s_etat
             if ((s_objet_simplifie = simplification(s_etat_processus,              if ((s_objet_simplifie = simplification(s_etat_processus,
                     s_objet_resultat)) == NULL)                      s_objet_resultat)) == NULL)
             {              {
                   liberation(s_etat_processus, s_objet_resultat);
                 return;                  return;
             }              }
   
Line 819  instruction_detach(struct_processus *s_e Line 820  instruction_detach(struct_processus *s_e
     logical1                            drapeau;      logical1                            drapeau;
   
     pid_t                               ppid;      pid_t                               ppid;
     pid_t                               pid_final;  
   
     pthread_attr_t                      attributs;      pthread_attr_t                      attributs;
   
Line 1040  instruction_detach(struct_processus *s_e Line 1040  instruction_detach(struct_processus *s_e
         return;          return;
     }      }
   
     if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0)      if (pipe((*s_argument_thread).pipe_nombre_elements_attente) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 1058  instruction_detach(struct_processus *s_e Line 1058  instruction_detach(struct_processus *s_e
         return;          return;
     }      }
   
     if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     if (pipe((*s_argument_thread).pipe_injections) != 0)      if (pipe((*s_argument_thread).pipe_injections) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1088  instruction_detach(struct_processus *s_e Line 1082  instruction_detach(struct_processus *s_e
      * Le mutex suivant permet de copier un contexte propre.       * Le mutex suivant permet de copier un contexte propre.
      */       */
   
     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)      if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Line 1105  instruction_detach(struct_processus *s_e Line 1111  instruction_detach(struct_processus *s_e
     (*s_argument_thread).pid = fork();      (*s_argument_thread).pid = fork();
     deverrouillage_threads_concurrents(s_etat_processus);      deverrouillage_threads_concurrents(s_etat_processus);
   
       if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation_buffer))
               != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     (*s_argument_thread).thread_pere = pthread_self();      (*s_argument_thread).thread_pere = pthread_self();
     (*s_argument_thread).processus_detache = d_vrai;      (*s_argument_thread).processus_detache = d_vrai;
   
Line 1125  instruction_detach(struct_processus *s_e Line 1138  instruction_detach(struct_processus *s_e
          * Processus père           * Processus père
          */           */
   
           if (pthread_mutex_unlock(&mutex_liste_variables_partagees) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   
         if (variable_partagee == d_vrai)          if (variable_partagee == d_vrai)
         {          {
             liberation(s_etat_processus, s_copie);              liberation(s_etat_processus, s_copie);
Line 1172  instruction_detach(struct_processus *s_e Line 1191  instruction_detach(struct_processus *s_e
             return;              return;
         }          }
   
         if (close((*s_argument_thread).pipe_nombre_interruptions_attente[1])          if (close((*s_argument_thread).pipe_nombre_elements_attente[1])
                 != 0)                  != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1185  instruction_detach(struct_processus *s_e Line 1204  instruction_detach(struct_processus *s_e
             return;              return;
         }          }
   
         if (close((*s_argument_thread).pipe_nombre_objets_attente[1]) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
   
         if (close((*s_argument_thread).pipe_injections[0]) != 0)          if (close((*s_argument_thread).pipe_injections[0]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1268  instruction_detach(struct_processus *s_e Line 1281  instruction_detach(struct_processus *s_e
          * Processus fils           * Processus fils
          */           */
   
           pthread_mutex_destroy(&mutex_liste_variables_partagees);
   
           pthread_mutexattr_init(&attributs_mutex);
           pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
           pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
           pthread_mutexattr_destroy(&attributs_mutex);
   
           pthread_mutex_destroy(&mutex_liste_threads);
   
           pthread_mutexattr_init(&attributs_mutex);
           pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
           pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);
           pthread_mutexattr_destroy(&attributs_mutex);
   
           liberation_queue_signaux(s_etat_processus);
           creation_queue_signaux(s_etat_processus);
   
         if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)          if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
   
         liberation_queue_signaux(s_etat_processus);  
         creation_queue_signaux(s_etat_processus);  
         routine_recursive = 0;          routine_recursive = 0;
   
         (*s_etat_processus).pointeur_signal_lecture = 0;          (*s_etat_processus).pointeur_signal_lecture = 0;
Line 1317  instruction_detach(struct_processus *s_e Line 1345  instruction_detach(struct_processus *s_e
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
         else if (close((*s_argument_thread)          else if (close((*s_argument_thread)
                 .pipe_nombre_interruptions_attente[0]) != 0)                  .pipe_nombre_elements_attente[0]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
Line 1325  instruction_detach(struct_processus *s_e Line 1353  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
         else if (close((*s_argument_thread).pipe_nombre_objets_attente[0]) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
         }  
         else if (close((*s_argument_thread).pipe_injections[1]) != 0)          else if (close((*s_argument_thread).pipe_injections[1]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1376  instruction_detach(struct_processus *s_e Line 1400  instruction_detach(struct_processus *s_e
         // Envoi d'une donnée pour signaler le démarrage du processus au thread          // Envoi d'une donnée pour signaler le démarrage du processus 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));              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;
   
             pid_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],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_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],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1414  instruction_detach(struct_processus *s_e Line 1428  instruction_detach(struct_processus *s_e
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_final = -2;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1446  instruction_detach(struct_processus *s_e Line 1448  instruction_detach(struct_processus *s_e
         pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);          pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
         pthread_mutexattr_destroy(&attributs_mutex);          pthread_mutexattr_destroy(&attributs_mutex);
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_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],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1462  instruction_detach(struct_processus *s_e Line 1465  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               destruction_queue_signaux(s_etat_processus);
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
           pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));
   
           if (pthread_mutex_unlock(&((*s_etat_processus)
                   .protection_liste_mutexes)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
   
               caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1477  instruction_detach(struct_processus *s_e Line 1494  instruction_detach(struct_processus *s_e
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
         pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));          pthread_mutex_trylock(&((*s_etat_processus).mutex_interruptions));
   
         if (pthread_mutex_unlock(&((*s_etat_processus)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions))
                 .protection_liste_mutexes)) != 0)                  != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             pid_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],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1496  instruction_detach(struct_processus *s_e Line 1513  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               destruction_queue_signaux(s_etat_processus);
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
           pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux));
   
           if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux))
                   != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
   
               caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1583  instruction_detach(struct_processus *s_e Line 1614  instruction_detach(struct_processus *s_e
         (*s_etat_processus).presence_pipes = d_vrai;          (*s_etat_processus).presence_pipes = d_vrai;
         (*s_etat_processus).debug_programme = d_faux;          (*s_etat_processus).debug_programme = d_faux;
         (*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1];          (*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1];
         (*s_etat_processus).pipe_nombre_objets_attente = (*s_argument_thread)          (*s_etat_processus).pipe_nombre_elements_attente = (*s_argument_thread)
                 .pipe_nombre_objets_attente[1];                  .pipe_nombre_elements_attente[1];
         (*s_etat_processus).pipe_interruptions = (*s_argument_thread)          (*s_etat_processus).pipe_interruptions = (*s_argument_thread)
                 .pipe_interruptions[1];                  .pipe_interruptions[1];
         (*s_etat_processus).pipe_nombre_interruptions_attente =  
                 (*s_argument_thread).pipe_nombre_interruptions_attente[1];  
         (*s_etat_processus).pipe_injections =          (*s_etat_processus).pipe_injections =
                 (*s_argument_thread).pipe_injections[0];                  (*s_argument_thread).pipe_injections[0];
         (*s_etat_processus).pipe_nombre_injections =          (*s_etat_processus).pipe_nombre_injections =
Line 1602  instruction_detach(struct_processus *s_e Line 1631  instruction_detach(struct_processus *s_e
         (*s_etat_processus).thread_fusible = 0;          (*s_etat_processus).thread_fusible = 0;
         (*s_etat_processus).pid_erreur_processus_fils = getpid();          (*s_etat_processus).pid_erreur_processus_fils = getpid();
         (*s_etat_processus).sections_critiques = 0;          (*s_etat_processus).sections_critiques = 0;
           (*s_etat_processus).initialisation_scheduler = d_faux;
   
         if ((*s_etat_processus).profilage == d_vrai)          if ((*s_etat_processus).profilage == d_vrai)
         {          {
Line 1628  instruction_detach(struct_processus *s_e Line 1658  instruction_detach(struct_processus *s_e
          * par liberation_threads().           * par liberation_threads().
          */           */
   
         if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es;              (*s_etat_processus).erreur_systeme = d_es;
   
             pid_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],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_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],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1681  instruction_detach(struct_processus *s_e Line 1702  instruction_detach(struct_processus *s_e
                 close((*s_argument_thread2).pipe_acquittement[1]);                  close((*s_argument_thread2).pipe_acquittement[1]);
                 close((*s_argument_thread2).pipe_injections[1]);                  close((*s_argument_thread2).pipe_injections[1]);
                 close((*s_argument_thread2).pipe_nombre_injections[1]);                  close((*s_argument_thread2).pipe_nombre_injections[1]);
                 close((*s_argument_thread2).pipe_nombre_objets_attente[0]);                  close((*s_argument_thread2).pipe_nombre_elements_attente[0]);
                 close((*s_argument_thread2).pipe_interruptions[0]);                  close((*s_argument_thread2).pipe_interruptions[0]);
                 close((*s_argument_thread2)  
                         .pipe_nombre_interruptions_attente[0]);  
   
                 pthread_mutex_destroy(&((*s_argument_thread2).mutex));                  pthread_mutex_destroy(&((*s_argument_thread2).mutex));
   
Line 1709  instruction_detach(struct_processus *s_e Line 1728  instruction_detach(struct_processus *s_e
   
         (*s_etat_processus).l_base_pile_processus = NULL;          (*s_etat_processus).l_base_pile_processus = NULL;
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es;              (*s_etat_processus).erreur_systeme = d_es;
   
             pid_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],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_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],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1778  instruction_detach(struct_processus *s_e Line 1788  instruction_detach(struct_processus *s_e
   
         if ((*s_etat_processus).erreur_systeme != d_es)          if ((*s_etat_processus).erreur_systeme != d_es)
         {          {
             pid_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],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_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],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 1831  instruction_detach(struct_processus *s_e Line 1831  instruction_detach(struct_processus *s_e
   
         if ((*s_etat_processus).erreur_systeme != d_es)          if ((*s_etat_processus).erreur_systeme != d_es)
         {          {
             pid_final = -2;              caractere = 0;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_interruptions_attente[1],  
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[1],                      (*s_argument_thread).pipe_nombre_elements_attente[1],
                     &pid_final, sizeof(pid_final))) != sizeof(pid_final))                      &caractere, sizeof(caractere))) != sizeof(caractere))
             {              {
                 if (longueur_ecriture == -1)                  if (longueur_ecriture == -1)
                 {                  {
Line 2097  instruction_detach(struct_processus *s_e Line 2087  instruction_detach(struct_processus *s_e
             pthread_cancel((*s_etat_processus).thread_fusible);              pthread_cancel((*s_etat_processus).thread_fusible);
         }          }
   
         pid_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],
                 &pid_final, sizeof(pid_final))) != sizeof(pid_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],  
                 &pid_final, sizeof(pid_final))) != sizeof(pid_final))  
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2140  instruction_detach(struct_processus *s_e Line 2120  instruction_detach(struct_processus *s_e
         {          {
             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 2172  instruction_detach(struct_processus *s_e Line 2152  instruction_detach(struct_processus *s_e
         {          {
             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 2212  instruction_detach(struct_processus *s_e Line 2192  instruction_detach(struct_processus *s_e
   
         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 2256  instruction_detach(struct_processus *s_e Line 2235  instruction_detach(struct_processus *s_e
             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 2419  instruction_detach(struct_processus *s_e Line 2398  instruction_detach(struct_processus *s_e
   
                     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 2473  instruction_detach(struct_processus *s_e Line 2453  instruction_detach(struct_processus *s_e
                     {                      {
                         destruction_queue_signaux(s_etat_processus);                          destruction_queue_signaux(s_etat_processus);
   
                         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);
                     }                      }
                 }                  }
             }              }
   
             pthread_mutex_unlock(&((*s_etat_processus).mutex));              if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions))
                       != 0)
               {
                   destruction_queue_signaux(s_etat_processus);
   
                   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)              if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
             {              {
                 affectation_interruptions_logicielles(s_etat_processus);                  affectation_interruptions_logicielles(s_etat_processus);
             }              }
   
               if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_interruptions)) != 0)
               {
                   destruction_queue_signaux(s_etat_processus);
   
                   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));
   
             scrutation_interruptions(s_etat_processus);              scrutation_interruptions(s_etat_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 2813  instruction_detach(struct_processus *s_e Line 2815  instruction_detach(struct_processus *s_e
   
         closelog();          closelog();
   
         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_allocation));
           pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
           pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
         pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));          pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
         pthread_mutex_destroy(&mutex_sections_critiques);          pthread_mutex_destroy(&mutex_sections_critiques);
   
Line 2838  instruction_detach(struct_processus *s_e Line 2841  instruction_detach(struct_processus *s_e
         destruction_queue_signaux(s_etat_processus);          destruction_queue_signaux(s_etat_processus);
         liberation_contexte_cas(s_etat_processus);          liberation_contexte_cas(s_etat_processus);
         arret_thread_signaux(s_etat_processus);          arret_thread_signaux(s_etat_processus);
         free(s_etat_processus);          liberation_allocateur(s_etat_processus);
           liberation_allocateur_buffer(s_etat_processus);
           pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
           sys_free(s_etat_processus);
   
 #       ifdef DEBUG_MEMOIRE  #       ifdef DEBUG_MEMOIRE
         debug_memoire_verification();          debug_memoire_verification();
Line 2876  instruction_detach(struct_processus *s_e Line 2882  instruction_detach(struct_processus *s_e
                         (*(*l_element_courant).donnee).objet)).thread).pid ==                          (*(*l_element_courant).donnee).objet)).thread).pid ==
                         (*s_argument_thread).pid)                          (*s_argument_thread).pid)
                 {                  {
                     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)                      if (pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2885  instruction_detach(struct_processus *s_e Line 2892  instruction_detach(struct_processus *s_e
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
                     INCR_GRANULARITE(attente.tv_nsec);                      INCR_GRANULARITE(attente.tv_nsec);
   
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)                      if (pthread_mutex_lock(&((*s_etat_processus)
                               .mutex_pile_processus)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2905  instruction_detach(struct_processus *s_e Line 2913  instruction_detach(struct_processus *s_e
             (struct_liste_chainee **) &((*s_etat_processus)              (struct_liste_chainee **) &((*s_etat_processus)
             .l_base_pile_processus), s_objet_systeme) == d_erreur)              .l_base_pile_processus), s_objet_systeme) == d_erreur)
     {      {
         pthread_mutex_unlock(&((*s_etat_processus).mutex));          pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
         return;          return;
     }      }
   
     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             s_objet) == d_erreur)              s_objet) == d_erreur)
     {      {
         pthread_mutex_unlock(&((*s_etat_processus).mutex));          pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
         return;          return;
     }      }
   
Line 2939  instruction_detach(struct_processus *s_e Line 2947  instruction_detach(struct_processus *s_e
     if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart) != 0)      if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         pthread_mutex_unlock(&((*s_etat_processus).mutex));          pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
         return;          return;
     }      }
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)      if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
Removed from v.1.107  
changed lines
  Added in v.1.136

CVSweb interface <joel.bertrand@systella.fr>