[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.24 and 1.25

version 1.24, 2010/06/02 10:28:45 version 1.25, 2010/06/04 07:48:20
Line 838  instruction_detach(struct_processus *s_e Line 838  instruction_detach(struct_processus *s_e
     ssize_t                     longueur_ecriture;      ssize_t                     longueur_ecriture;
   
     struct_descripteur_thread   *s_argument_thread;      struct_descripteur_thread   *s_argument_thread;
       struct_descripteur_thread   *s_argument_thread2;
   
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_precedent;      struct_liste_chainee        *l_element_precedent;
Line 1296  instruction_detach(struct_processus *s_e Line 1297  instruction_detach(struct_processus *s_e
          * Processus fils           * Processus fils
          */           */
   
           if ((*s_etat_processus).debug == d_vrai)
               if (((*s_etat_processus).type_debug &
                       d_debug_processus) != 0)
           {
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("[%d] Lancement du processus fils %d de %d\n",
                           (int) getpid(), (int) getpid(), (int) ppid);
               }
               else
               {
                   printf("[%d] Start child process %d from %d\n", (int) getpid(),
                           (int) getpid(), (int) ppid);
               }
   
               fflush(stdout);
           }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         sem_post(&semaphore_gestionnaires_signaux);          sem_post(&semaphore_gestionnaires_signaux);
         sem_destroy(&semaphore_gestionnaires_signaux);          sem_destroy(&semaphore_gestionnaires_signaux);
Line 1389  instruction_detach(struct_processus *s_e Line 1408  instruction_detach(struct_processus *s_e
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
   
           if ((*s_etat_processus).debug == d_vrai)
               if (((*s_etat_processus).type_debug &
                       d_debug_processus) != 0)
           {
               if ((*s_etat_processus).langue == 'F')
               {
                   printf("[%d] Libération des objets du processus père\n",
                           (int) getpid());
               }
               else
               {
                   printf("[%d] Freeing parent process memory\n", getpid());
               }
   
               fflush(stdout);
           }
   
         l_element_courant = (*s_etat_processus).liste_mutexes;          l_element_courant = (*s_etat_processus).liste_mutexes;
         while(l_element_courant != NULL)          while(l_element_courant != NULL)
         {          {
Line 1450  instruction_detach(struct_processus *s_e Line 1486  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1479  instruction_detach(struct_processus *s_e Line 1516  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1509  instruction_detach(struct_processus *s_e Line 1547  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1554  instruction_detach(struct_processus *s_e Line 1593  instruction_detach(struct_processus *s_e
             (*s_etat_processus).pile_origine_interruptions[i] = NULL;              (*s_etat_processus).pile_origine_interruptions[i] = NULL;
         }          }
   
         if ((*s_etat_processus).debug == d_vrai)  
             if (((*s_etat_processus).type_debug &  
                     d_debug_processus) != 0)  
         {  
             if ((*s_etat_processus).langue == 'F')  
             {  
                 printf("[%d] Lancement du processus fils %d de %d\n",  
                         (int) getpid(), (int) getpid(), (int) ppid);  
             }  
             else  
             {  
                 printf("[%d] Start child process %d from %d\n", (int) getpid(),  
                         (int) getpid(), (int) ppid);  
             }  
   
             fflush(stdout);  
         }  
   
         /*          /*
          * On bloque l'exécution du processus fils jusqu'à ce que           * On bloque l'exécution du processus fils jusqu'à ce que
          * le père ait renseigné correctement la pile des processus.           * le père ait renseigné correctement la pile des processus.
Line 1641  instruction_detach(struct_processus *s_e Line 1662  instruction_detach(struct_processus *s_e
         }          }
   
         /*          /*
          * Initialisation de la pile des processus           * Initialisation de la pile des processus. Cette pile est effacée
            * par liberation_threads().
          */           */
   
           if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es;
   
               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,
                       (*s_argument_thread).pipe_nombre_objets_attente[1],
                       &pid_final, sizeof(pid_final))) != sizeof(pid_final))
               {
                   if (longueur_ecriture == -1)
                   {
                       break;
                   }
               }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
         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;
   
         while(l_element_courant != NULL)          while(l_element_courant != NULL)
         {          {
             l_element_suivant = (*l_element_courant).suivant;              s_argument_thread2 = (struct_descripteur_thread *)
                       (*l_element_courant).donnee;
   
               (*s_argument_thread2).nombre_references--;
   
             if ((*((*(struct_processus_fils *) (*(*l_element_courant).donnee)              BUG((*s_argument_thread2).nombre_references < 0,
                     .objet)).thread).processus_detache == d_faux)                      printf("(*s_argument_thread).nombre_references = %d\n",
                       (int) (*s_argument_thread2).nombre_references));
   
               if ((*s_argument_thread2).nombre_references == 0)
             {              {
                 liberation(s_etat_processus, (*((*(struct_processus_fils *)                  close((*s_argument_thread2).pipe_objets[0]);
                         (*(*l_element_courant).donnee).objet)).thread)                  close((*s_argument_thread2).pipe_acquittement[1]);
                         .argument);                  close((*s_argument_thread2).pipe_injections[1]);
             }                  close((*s_argument_thread2).pipe_nombre_injections[1]);
                   close((*s_argument_thread2).pipe_nombre_objets_attente[0]);
                   close((*s_argument_thread2).pipe_interruptions[0]);
                   close((*s_argument_thread2)
                           .pipe_nombre_interruptions_attente[0]);
   
             free((*(*l_element_courant).donnee).objet);                  pthread_mutex_destroy(&((*s_argument_thread2).mutex));
             free((*l_element_courant).donnee);  
             free(l_element_courant);                  if ((*s_argument_thread2).processus_detache == d_faux)
                   {
                       if ((*s_argument_thread2).destruction_objet == d_vrai)
                       {
                           liberation(s_etat_processus,
                                   (*s_argument_thread2).argument);
                       }
                   }
   
                   free(s_argument_thread2);
               }
   
               l_element_suivant = (*l_element_courant).suivant;
               free((struct_liste_chainee *) l_element_courant);
             l_element_courant = l_element_suivant;              l_element_courant = l_element_suivant;
         }          }
   
         (*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)
           {
               (*s_etat_processus).erreur_systeme = d_es;
   
               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,
                       (*s_argument_thread).pipe_nombre_objets_attente[1],
                       &pid_final, sizeof(pid_final))) != sizeof(pid_final))
               {
                   if (longueur_ecriture == -1)
                   {
                       break;
                   }
               }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
               exit(EXIT_FAILURE);
           }
   
         /*          /*
          * Initialisation de la pile système           * Initialisation de la pile système
          */           */
Line 1728  instruction_detach(struct_processus *s_e Line 1831  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1779  instruction_detach(struct_processus *s_e Line 1883  instruction_detach(struct_processus *s_e
                 }                  }
             }              }
   
               BUG(1, uprintf("Process management error line %d\n", __LINE__));
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
   
Line 1885  instruction_detach(struct_processus *s_e Line 1990  instruction_detach(struct_processus *s_e
   
         sigpending(&set);          sigpending(&set);
   
           if ((*s_etat_processus).debug == d_vrai)
           {
               if (((*s_etat_processus).type_debug & d_debug_processus)
                       != 0)
               {
                   if ((*s_etat_processus).langue == 'F')
                   {
                       printf("[%d] Évaluation de l'objet détaché\n", getpid());
                   }
                   else
                   {
                       printf("[%d] Évaluation of detached object\n", getpid());
                   }
               }
           }
   
         if ((*s_etat_processus).erreur_systeme == d_es)          if ((*s_etat_processus).erreur_systeme == d_es)
         {          {
             if (variable_partagee == d_faux)              if (variable_partagee == d_faux)
Removed from v.1.24  
changed lines
  Added in v.1.25

CVSweb interface <joel.bertrand@systella.fr>