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

Diff for /rpl/src/gestion_processus.c between versions 1.62 and 1.106

version 1.62, 2013/03/20 17:11:44 version 1.106, 2025/04/15 10:17:51
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 47  surveillance_processus(void *argument) Line 47  surveillance_processus(void *argument)
     logical1                        drapeau;      logical1                        drapeau;
     logical1                        drapeau_fin;      logical1                        drapeau_fin;
     logical1                        drapeau_fin_scrutation;      logical1                        drapeau_fin_scrutation;
     logical1                        drapeau_interruptions_traitees;      logical1                        drapeau_elements_traites;
     logical1                        drapeau_objets_traites;  
   
     pid_t                           pid;      pid_t                           pid;
     pid_t                           pid_candidat;  
     pid_t                           pid_erreur;      pid_t                           pid_erreur;
   
     pthread_t                       tid_candidat;  
   
     ssize_t                         iostat;      ssize_t                         iostat;
     ssize_t                         longueur_ecriture;      ssize_t                         longueur_ecriture;
   
Line 81  surveillance_processus(void *argument) Line 77  surveillance_processus(void *argument)
     s_argument_thread = argument;      s_argument_thread = argument;
     s_etat_processus = (*s_argument_thread).s_etat_processus;      s_etat_processus = (*s_argument_thread).s_etat_processus;
   
     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;
         BUG(1, uprintf("General mutex error!\n"));          BUG(1, uprintf("General mutex error!\n"));
     }      }
   
     insertion_thread_surveillance(s_etat_processus, s_argument_thread);      nombre_threads_surveillance_processus++;
   
     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;
         BUG(1, uprintf("General mutex error!\n"));          BUG(1, uprintf("General mutex error!\n"));
     }      }
   
       insertion_thread_surveillance(s_etat_processus, s_argument_thread);
   
     attente.tv_sec = 0;      attente.tv_sec = 0;
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     status = 0;      status = 0;
   
     drapeau_interruptions_traitees = d_faux;      drapeau_elements_traites = d_faux;
     drapeau_objets_traites = d_faux;  
   
     if ((*s_etat_processus).debug == d_vrai)      if ((*s_etat_processus).debug == d_vrai)
         if (((*s_etat_processus).type_debug &          if (((*s_etat_processus).type_debug &
Line 146  surveillance_processus(void *argument) Line 143  surveillance_processus(void *argument)
      */       */
   
     while(read_atomic(s_etat_processus,      while(read_atomic(s_etat_processus,
             (*s_argument_thread).pipe_nombre_objets_attente[0],              (*s_argument_thread).pipe_nombre_elements_attente[0],
             &caractere, sizeof(caractere)) == 0)              &caractere, sizeof(caractere)) == 0)
     {      {
         if ((*s_etat_processus).var_volatile_requete_arret != 0)          if ((*s_etat_processus).var_volatile_requete_arret != 0)
         {          {
             drapeau_objets_traites = d_vrai;              drapeau_elements_traites = d_vrai;
             drapeau_interruptions_traitees = d_vrai;  
         }          }
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
Line 166  surveillance_processus(void *argument) Line 162  surveillance_processus(void *argument)
              * Le processus est un processus détaché.               * Le processus est un processus détaché.
              */               */
   
             // Scrutation de l'envoi de données par le fils.              if (drapeau_elements_traites == d_vrai)
   
             pid_candidat = 0;  
   
             if (drapeau_objets_traites == d_vrai)  
             {              {
                 nanosleep(&attente, NULL);                  nanosleep(&attente, NULL);
             }              }
             else if ((iostat = read_atomic(s_etat_processus,              else if ((iostat = read_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[0],                      (*s_argument_thread).pipe_nombre_elements_attente[0],
                     &pid_candidat, sizeof(pid_candidat))) == 0)                      &caractere, sizeof(caractere))) == 0)
             {              {
                 // Rien dans le pipe                  // Rien dans le pipe
   
                 nanosleep(&attente, NULL);                  nanosleep(&attente, NULL);
             }              }
             else if (iostat != sizeof(pid_candidat))              else if (iostat == sizeof(caractere))
             {  
                 (*s_etat_processus).erreur_systeme_processus_fils =  
                         d_es_processus;  
             }  
             else  
             {              {
                 // Un pid est dans le pipe. On vérifie que les deux pids                  // Un objet supplémentaire est dans le pipe correspondant
                 // correspondent.                  // au processus surveillé par ce thread.
   
                 if (pid_candidat == -2)                  if (pthread_mutex_lock(&((*s_etat_processus)
                 {                          .mutex_pile_processus)) != 0)
                     drapeau_objets_traites = d_vrai;  
                 }  
                 else if (pid_candidat == -1)  
                 {                  {
                       (*s_etat_processus).erreur_systeme_processus_fils =
                               d_es_processus;
                 }                  }
                 else if ((iostat = read_atomic(s_etat_processus,  
                         (*s_argument_thread).pipe_nombre_objets_attente[0],                  l_element_courant = (struct_liste_chainee *)
                         &pid_candidat, sizeof(pid_candidat))) ==                          (*s_etat_processus).l_base_pile_processus;
                         sizeof(pid_candidat))  
                   while(l_element_courant != NULL)
                 {                  {
                     if ((*s_argument_thread).pid != pid_candidat)                      if ((*(*((struct_processus_fils *)
                               (*(*l_element_courant).donnee).objet))
                               .thread).processus_detache == d_faux)
                     {                      {
                         (*s_etat_processus).erreur_systeme_processus_fils =                          l_element_courant = (*l_element_courant)
                                 d_es_processus;                                  .suivant;
                         BUG(1, printf("Spurious process identifier"));                          continue;
                     }                      }
   
                     // Un objet supplémentaire est dans le pipe correspondant                      if ((*(*((struct_processus_fils *)
                     // au processus surveillé par ce thread.                              (*(*l_element_courant).donnee).objet))
                               .thread).pid == (*s_argument_thread).pid)
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)  
                     {                      {
                         (*s_etat_processus).erreur_systeme_processus_fils =                          break;
                                 d_es_processus;  
                     }                      }
                     else  
                     {  
                         l_element_courant = (struct_liste_chainee *)  
                                 (*s_etat_processus).l_base_pile_processus;  
   
                         while(l_element_courant != NULL)                      l_element_courant = (*l_element_courant).suivant;
                         {                  }
                             if ((*(*((struct_processus_fils *)  
                                     (*(*l_element_courant).donnee).objet))  
                                     .thread).processus_detache == d_faux)  
                             {  
                                 l_element_courant = (*l_element_courant)  
                                         .suivant;  
                                 continue;  
                             }  
   
                             if ((*(*((struct_processus_fils *)                  BUG(l_element_courant == NULL,
                                     (*(*l_element_courant).donnee).objet))                          printf("Process or thread not found"));
                                     .thread).pid == pid_candidat)  
                             {  
                                 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] Données en provenance "  
                                                 "du processus %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Data from process %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                 }  
   
                                 if (pthread_mutex_lock(                  switch(caractere)
                                         &((*(*((struct_processus_fils *)                  {
                                         (*(*l_element_courant).donnee).objet))                      case 1:
                                         .thread).mutex)) != 0)                      case 2:
                       {
                           if ((*s_etat_processus).debug == d_vrai)
                               if (((*s_etat_processus).type_debug &
                                       d_debug_processus) != 0)
                           {
                               if ((*s_etat_processus).langue == 'F')
                               {
                                   if (caractere == 1)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      printf("[%d] Données en provenance "
                                             d_es_processus;                                              "du processus %d\n", (int) getpid(),
                                               (int) (*s_argument_thread).pid);
                                 }                                  }
                                   else
                                 (*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).nombre_objets_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      printf("[%d] Interrution logicielle "
                                             d_es_processus;                                              "en provenance du processus "
                                               "%d\n", (int) getpid(),
                                               (int) (*s_argument_thread).pid);
                                 }                                  }
   
                                 while((longueur_ecriture =                                  fflush(stdout);
                                         write_atomic(s_etat_processus,                              }
                                         (*(*((struct_processus_fils *)                              else
                                         (*(*l_element_courant).donnee).objet))                              {
                                         .thread).pipe_acquittement[1], "-",                                  if (caractere == 1)
                                         sizeof(unsigned char))) !=  
                                         sizeof(unsigned char))  
                                 {                                  {
                                     if (longueur_ecriture == -1)                                      printf("[%d] Data from process %d\n",
                                     {                                              (int) getpid(),
                                         (*s_etat_processus)                                              (int) (*s_argument_thread).pid);
                                                 .erreur_systeme_processus_fils =  
                                                 d_es_processus;  
                                     }  
                                 }                                  }
                                   else
                                 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] Software interrupt "
                                     {                                              "from process %d\n", (int) getpid(),
                                         printf("[%d] Données acquittées "                                              (int) (*s_argument_thread).pid);
                                                 "en provenance du "  
                                                 "processus %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Data acknowklegment "  
                                                 "from process %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                 }                                  }
   
                                 break;                                  fflush(stdout);
                             }                              }
   
                             l_element_courant = (*l_element_courant).suivant;  
                         }                          }
   
                         BUG(l_element_courant == NULL,                          if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
                                 printf("Process or thread not found"));                                  (*(*l_element_courant).donnee).objet))
                                   .thread).mutex)) != 0)
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))  
                                 != 0)  
                         {                          {
                             (*s_etat_processus).erreur_systeme_processus_fils =                              (*s_etat_processus).erreur_systeme =
                                     d_es_processus;                                      d_es_processus;
                         }                          }
   
                         envoi_signal_thread((*s_argument_thread).thread_pere,                          if (caractere == 1)
                                 rpl_siginject);                          {
                     }                              (*(*((struct_processus_fils *)
                 }                                      (*(*l_element_courant).donnee).objet))
                 else                                      .thread).nombre_objets_dans_pipe++;
                 {                          }
                     (*s_etat_processus).erreur_systeme_processus_fils =                          else
                             d_es_processus;                          {
                 }                              (*(*((struct_processus_fils *)
             }                                      (*(*l_element_courant).donnee).objet))
                                       .thread).nombre_interruptions_dans_pipe++;
             // Scrutation de l'envoi d'interruptions par le fils.  
   
             if (drapeau_interruptions_traitees == d_vrai)                              if (pthread_mutex_lock(&((*s_etat_processus)
             {                                      .mutex_interruptions)) != 0)
                 nanosleep(&attente, NULL);                              {
             }                                  (*s_etat_processus).erreur_systeme =
             else if ((iostat = read_atomic(s_etat_processus,                                          d_es_processus;
                     (*s_argument_thread).pipe_nombre_interruptions_attente[0],                              }
                     &pid_candidat, sizeof(pid_candidat))) == 0)  
             {  
                 // Rien dans le pipe  
   
                 nanosleep(&attente, NULL);                              (*s_etat_processus)
             }                                      .nombre_interruptions_non_affectees++;
             else if (iostat != sizeof(pid_candidat))  
             {  
                 (*s_etat_processus).erreur_systeme_processus_fils =  
                         d_es_processus;  
             }  
             else  
             {  
                 // Un pid est dans le pipe. On vérifie que les deux pids  
                 // correspondent.  
   
                 if (pid_candidat == -2)                              if (pthread_mutex_unlock(&((*s_etat_processus)
                 {                                      .mutex_interruptions)) != 0)
                     drapeau_interruptions_traitees = d_vrai;                              {
                 }                                  (*s_etat_processus).erreur_systeme =
                 else if (pid_candidat == -1)                                          d_es_processus;
                 {                              }
                 }                          }
                 else if ((iostat = read_atomic(s_etat_processus,  
                         (*s_argument_thread).pipe_nombre_interruptions_attente  
                         [0], &pid_candidat, sizeof(pid_candidat)))  
                         == sizeof(pid_candidat))  
                 {  
                     if ((*s_argument_thread).pid != pid_candidat)  
                     {  
                         (*s_etat_processus).erreur_systeme_processus_fils =  
                                 d_es_processus;  
                         BUG(1, printf("Spurious interrupt"));  
                     }  
   
                     // Une interruption supplémentaire est dans le pipe  
                     // correspondant au processus surveillé par ce thread.  
   
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)                          if (pthread_mutex_unlock(
                     {                                  &((*(*((struct_processus_fils *)
                         (*s_etat_processus).erreur_systeme_processus_fils =                                  (*(*l_element_courant).donnee).objet))
                                 d_es_processus;                                  .thread).mutex)) != 0)
                     }                          {
                     else                              (*s_etat_processus).erreur_systeme =
                     {                                      d_es_processus;
                         l_element_courant = (struct_liste_chainee *)                          }
                                 (*s_etat_processus).l_base_pile_processus;  
   
                         while(l_element_courant != NULL)                          while((longueur_ecriture =
                                   write_atomic(s_etat_processus,
                                   (*(*((struct_processus_fils *)
                                   (*(*l_element_courant).donnee).objet))
                                   .thread).pipe_acquittement[1], "-",
                                   sizeof(unsigned char))) !=
                                   sizeof(unsigned char))
                         {                          {
                             if ((*(*((struct_processus_fils *)                              if (longueur_ecriture == -1)
                                     (*(*l_element_courant).donnee).objet))  
                                     .thread).processus_detache == d_faux)  
                             {                              {
                                 l_element_courant = (*l_element_courant)                                  (*s_etat_processus)
                                         .suivant;                                          .erreur_systeme_processus_fils =
                                 continue;                                          d_es_processus;
                             }                              }
                           }
   
                             if ((*(*((struct_processus_fils *)                          if ((*s_etat_processus).debug == d_vrai)
                                     (*(*l_element_courant).donnee).objet))                              if (((*s_etat_processus).type_debug &
                                     .thread).pid == pid_candidat)                                      d_debug_processus) != 0)
                           {
                               if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 if ((*s_etat_processus).debug == d_vrai)                                  if (caractere == 1)
                                     if (((*s_etat_processus).type_debug &  
                                             d_traitement_interruption) != 0)  
                                 {                                  {
                                     if ((*s_etat_processus).langue == 'F')                                      printf("[%d] Données acquittées "
                                     {                                              "en provenance du "
                                         printf("[%d] Interrution logicielle "                                              "processus %d\n", (int) getpid(),
                                                 "en provenance du processus "                                              (int) (*s_argument_thread).pid);
                                                 "%d\n", (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Software interrupt "  
                                                 "from process %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                 }                                  }
                                   else
                                 if (pthread_mutex_lock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                 }  
   
                                 (*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee)  
                                         .objet)).thread)  
                                         .nombre_interruptions_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      printf("[%d] Interruption logicielle "
                                             d_es_processus;                                              "acquittée en provenance "
                                               "du processus %d\n", (int) getpid(),
                                               (int) (*s_argument_thread).pid);
                                 }                                  }
   
                                 (*s_etat_processus)                                  fflush(stdout);
                                         .nombre_interruptions_non_affectees++;                              }
                               else
                                 while((longueur_ecriture =                              {
                                         write_atomic(s_etat_processus,                                  if (caractere == 1)
                                         (*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).pipe_acquittement[1], "-",  
                                         sizeof(unsigned char))) !=  
                                         sizeof(unsigned char))  
                                 {                                  {
                                     if (longueur_ecriture == -1)                                      printf("[%d] Data acknowklegment "
                                     {                                              "from process %d\n", (int) getpid(),
                                         (*s_etat_processus)                                              (int) (*s_argument_thread).pid);
                                                 .erreur_systeme_processus_fils =  
                                                 d_es_processus;  
                                     }  
                                 }                                  }
                                   else
                                 if ((*s_etat_processus).debug == d_vrai)  
                                     if (((*s_etat_processus).type_debug &  
                                             d_traitement_interruption) != 0)  
                                 {                                  {
                                     if ((*s_etat_processus).langue == 'F')                                      printf("[%d] Software interrupt "
                                     {                                              "acknowklegment from "
                                         printf("[%d] Interruption logicielle "                                              "process %d\n", (int) getpid(),
                                                 "acquittée en provenance "                                              (int) (*s_argument_thread).pid);
                                                 "du processus %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Software interrupt "  
                                                 "acknowklegment from "  
                                                 "process %d\n",  
                                                 (int) getpid(),  
                                                 (int) (*s_argument_thread).pid);  
                                         fflush(stdout);  
                                     }  
                                 }                                  }
   
                                 break;                                  fflush(stdout);
                             }                              }
   
                             l_element_courant = (*l_element_courant).suivant;  
                         }                          }
   
                         BUG(l_element_courant == NULL,                          envoi_signal_thread(NULL,
                                 printf("Process or thread not found"));                                  (*s_argument_thread).thread_pere,
                                   rpl_siginject);
                           break;
                       }
   
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))                      case 0:
                                 != 0)                      {
                         {                          break;
                             (*s_etat_processus).erreur_systeme_processus_fils =                      }
                                     d_es_processus;  
                         }  
   
                         envoi_signal_thread((*s_argument_thread).thread_pere,                      default:
                                 rpl_siginject);                      {
                           (*s_etat_processus).erreur_systeme_processus_fils =
                                   d_es_processus;
                           BUG(1, printf("Spurious interprocess data"));
                     }                      }
                 }                  }
                 else  
                   if (pthread_mutex_unlock(&((*s_etat_processus)
                           .mutex_pile_processus)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme_processus_fils =                      (*s_etat_processus).erreur_systeme_processus_fils =
                             d_es_processus;                              d_es_processus;
                 }                  }
             }              }
               else
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
               }
   
             if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0)              if ((pid = waitpid((*s_argument_thread).pid, &status, WNOHANG)) < 0)
             {              {
Line 556  surveillance_processus(void *argument) Line 417  surveillance_processus(void *argument)
              * Le processus n'est pas détaché.               * Le processus n'est pas détaché.
              */               */
   
             // Scrutation de l'envoi de données par le fils.              if (drapeau_elements_traites == d_vrai)
   
             tid_candidat = (pthread_t) 0;  
   
             if (drapeau_objets_traites == d_vrai)  
             {              {
                 nanosleep(&attente, NULL);                  nanosleep(&attente, NULL);
             }              }
             else if ((iostat = read_atomic(s_etat_processus,              else if ((iostat = read_atomic(s_etat_processus,
                     (*s_argument_thread).pipe_nombre_objets_attente[0],                      (*s_argument_thread).pipe_nombre_elements_attente[0],
                     &tid_candidat, sizeof(tid_candidat))) == 0)                      &caractere, sizeof(caractere))) == 0)
             {              {
                 // Rien dans le pipe                  // Rien dans le pipe
   
                 nanosleep(&attente, NULL);                  nanosleep(&attente, NULL);
             }              }
             else if (iostat != sizeof(tid_candidat))              else if (iostat == sizeof(caractere))
             {  
                 (*s_etat_processus).erreur_systeme_processus_fils =  
                         d_es_processus;  
             }  
             else  
             {              {
                 // Un pid est dans le pipe. On vérifie que les deux pids                  // Un objet supplémentaire est dans le pipe correspondant
                 // correspondent.                  // au processus surveillé par ce thread.
   
                 if (tid_candidat == (pthread_t) -2)                  if (pthread_mutex_lock(&((*s_etat_processus)
                 {                          .mutex_pile_processus)) != 0)
                     drapeau_objets_traites = d_vrai;  
                 }  
                 else if (tid_candidat == (pthread_t) -1)  
                 {                  {
                       (*s_etat_processus).erreur_systeme_processus_fils =
                               d_es_processus;
                 }                  }
                 else if ((iostat = read_atomic(s_etat_processus,  
                         (*s_argument_thread).pipe_nombre_objets_attente[0],                  l_element_courant = (struct_liste_chainee *)
                         &tid_candidat, sizeof(tid_candidat))) ==                          (*s_etat_processus).l_base_pile_processus;
                         sizeof(tid_candidat))  
                   while(l_element_courant != NULL)
                 {                  {
                     if (pthread_equal((*s_argument_thread).tid,                      if ((*(*((struct_processus_fils *)
                                 tid_candidat) == 0)                              (*(*l_element_courant).donnee).objet))
                               .thread).processus_detache == d_vrai)
                     {                      {
                         (*s_etat_processus).erreur_systeme_processus_fils =                          l_element_courant = (*l_element_courant).suivant;
                                 d_es_processus;                          continue;
                         BUG(1, printf("Spurious thread identifier"));  
                     }                      }
   
                     // Un objet supplémentaire est dans le pipe correspondant                      if ((*(*((struct_processus_fils *)
                     // au processus surveillé par ce thread.                              (*(*l_element_courant).donnee).objet))
                               .thread).tid == (*s_argument_thread).tid)
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)  
                     {                      {
                         (*s_etat_processus).erreur_systeme_processus_fils =                          break;
                                 d_es_processus;  
                     }                      }
                     else  
                     {  
                         l_element_courant = (struct_liste_chainee *)  
                                 (*s_etat_processus).l_base_pile_processus;  
   
                         while(l_element_courant != NULL)                      l_element_courant = (*l_element_courant).suivant;
                         {                  }
                             if ((*(*((struct_processus_fils *)  
                                     (*(*l_element_courant).donnee).objet))  
                                     .thread).processus_detache == d_vrai)  
                             {  
                                 l_element_courant = (*l_element_courant)  
                                         .suivant;  
                                 continue;  
                             }  
   
                             if (pthread_equal((*(*((struct_processus_fils *)                  BUG(l_element_courant == NULL,
                                     (*(*l_element_courant).donnee).objet))                          printf("Process or thread not found"));
                                     .thread).tid, tid_candidat) != 0)  
                             {  
                                 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] Données en provenance "  
                                                 "du thread %llu\n",  
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Data from thread %llu\n",  
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                 }  
   
                                 if (pthread_mutex_lock(                  switch(caractere)
                                         &((*(*((struct_processus_fils *)                  {
                                         (*(*l_element_courant).donnee).objet))                      case 1:
                                         .thread).mutex)) != 0)                      case 2:
                       {
                           if ((*s_etat_processus).debug == d_vrai)
                               if (((*s_etat_processus).type_debug &
                                       d_debug_processus) != 0)
                           {
                               if ((*s_etat_processus).langue == 'F')
                               {
                                   if (caractere == 1)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      printf("[%d] Données en provenance "
                                             d_es_processus;                                              "du thread %llu\n", (int) getpid(),
                                               (unsigned long long)
                                               (*s_argument_thread).tid);
                                 }                                  }
                                   else
                                 (*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).nombre_objets_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      printf("[%d] Interrution logicielle "
                                             d_es_processus;                                              "en provenance du thread "
                                               "%llu\n", (int) getpid(),
                                               (unsigned long long)
                                               (*s_argument_thread).tid);
                                 }                                  }
   
                                 while((longueur_ecriture =                                  fflush(stdout);
                                         write_atomic(s_etat_processus,                              }
                                         (*(*((struct_processus_fils *)                              else
                                         (*(*l_element_courant).donnee).objet))                              {
                                         .thread).pipe_acquittement[1], "-",                                  if (caractere == 1)
                                         sizeof(unsigned char))) !=  
                                         sizeof(unsigned char))  
                                 {                                  {
                                     if (longueur_ecriture == -1)                                      printf("[%d] Data from thread %llu\n",
                                     {                                              (int) getpid(), (unsigned long long)
                                         (*s_etat_processus)                                              (*s_argument_thread).tid);
                                                 .erreur_systeme_processus_fils =  
                                                 d_es_processus;  
                                     }  
                                 }                                  }
                                   else
                                 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] Software interrupt "
                                     {                                              "from thread %llu\n",
                                         printf("[%d] Données acquittées "                                              (int) getpid(), (unsigned long long)
                                                 "en provenance du thread "                                              (*s_argument_thread).tid);
                                                 "%llu\n", (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Data acknowklegment "  
                                                 "from thread %llu\n",  
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                 }                                  }
   
                                 break;                                  fflush(stdout);
                             }                              }
   
                             l_element_courant = (*l_element_courant).suivant;  
                         }                          }
   
                         BUG(l_element_courant == NULL,                          if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
                                 printf("Process or thread not found\n"));                                  (*(*l_element_courant).donnee).objet))
                                   .thread).mutex)) != 0)
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))  
                                 != 0)  
                         {                          {
                             (*s_etat_processus).erreur_systeme_processus_fils =                              (*s_etat_processus).erreur_systeme =
                                     d_es_processus;                                      d_es_processus;
                         }                          }
                     }  
                 }  
                 else  
                 {  
                     (*s_etat_processus).erreur_systeme_processus_fils =  
                             d_es_processus;  
                 }  
             }  
   
             // Scrutation de l'envoi d'interruptions par le fils.                          if (caractere == 1)
                           {
             if (drapeau_interruptions_traitees == d_vrai)                              (*(*((struct_processus_fils *)
             {                                      (*(*l_element_courant).donnee).objet))
                 nanosleep(&attente, NULL);                                      .thread).nombre_objets_dans_pipe++;
             }                          }
             else if ((iostat = read_atomic(s_etat_processus,                          else
                     (*s_argument_thread).pipe_nombre_interruptions_attente[0],                          {
                     &tid_candidat, sizeof(tid_candidat))) == 0)                              (*(*((struct_processus_fils *)
             {                                      (*(*l_element_courant).donnee).objet))
                 // Rien dans le pipe                                      .thread).nombre_interruptions_dans_pipe++;
   
                 nanosleep(&attente, NULL);                              if (pthread_mutex_lock(&((*s_etat_processus)
             }                                      .mutex_interruptions)) != 0)
             else if (iostat != sizeof(tid_candidat))                              {
             {                                  (*s_etat_processus).erreur_systeme =
                 (*s_etat_processus).erreur_systeme_processus_fils =                                          d_es_processus;
                         d_es_processus;                              }
             }  
             else  
             {  
                 // Un pid est dans le pipe. On vérifie que les deux pids  
                 // correspondent.  
   
                 if (tid_candidat == (pthread_t) -2)                              (*s_etat_processus)
                 {                                      .nombre_interruptions_non_affectees++;
                     drapeau_interruptions_traitees = d_vrai;  
                 }  
                 else if (tid_candidat == (pthread_t) -1)  
                 {  
                 }  
                 else if ((iostat = read_atomic(s_etat_processus,  
                         (*s_argument_thread).pipe_nombre_interruptions_attente  
                         [0], &tid_candidat, sizeof(tid_candidat))) ==  
                         sizeof(tid_candidat))  
                 {  
                     if (pthread_equal((*s_argument_thread).tid,  
                             tid_candidat) == 0)  
                     {  
                         (*s_etat_processus).erreur_systeme_processus_fils =  
                                 d_es_processus;  
                         BUG(1, printf("Spurious interrupt"));  
                     }  
   
                     // Une interruption supplémentaire est dans le pipe                              if (pthread_mutex_unlock(&((*s_etat_processus)
                     // correspondant au processus surveillé par ce thread.                                      .mutex_interruptions)) != 0)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                               }
                           }
   
                     if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)                          if (pthread_mutex_unlock(
                     {                                  &((*(*((struct_processus_fils *)
                         (*s_etat_processus).erreur_systeme_processus_fils =                                  (*(*l_element_courant).donnee).objet))
                                 d_es_processus;                                  .thread).mutex)) != 0)
                     }                          {
                     else                              (*s_etat_processus).erreur_systeme =
                     {                                      d_es_processus;
                         l_element_courant = (struct_liste_chainee *)                          }
                                 (*s_etat_processus).l_base_pile_processus;  
   
                         while(l_element_courant != NULL)                          while((longueur_ecriture =
                                   write_atomic(s_etat_processus,
                                   (*(*((struct_processus_fils *)
                                   (*(*l_element_courant).donnee).objet))
                                   .thread).pipe_acquittement[1], "-",
                                   sizeof(unsigned char))) !=
                                   sizeof(unsigned char))
                         {                          {
                             if ((*(*((struct_processus_fils *)                              if (longueur_ecriture == -1)
                                     (*(*l_element_courant).donnee).objet))  
                                     .thread).processus_detache == d_vrai)  
                             {                              {
                                 l_element_courant = (*l_element_courant)                                  (*s_etat_processus)
                                         .suivant;                                          .erreur_systeme_processus_fils =
                                 continue;                                          d_es_processus;
                             }                              }
                           }
   
                             if (pthread_equal((*(*((struct_processus_fils *)                          if ((*s_etat_processus).debug == d_vrai)
                                     (*(*l_element_courant).donnee).objet))                              if (((*s_etat_processus).type_debug &
                                     .thread).tid, tid_candidat) != 0)                                      d_debug_processus) != 0)
                           {
                               if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 if ((*s_etat_processus).debug == d_vrai)                                  if (caractere == 1)
                                     if (((*s_etat_processus).type_debug &  
                                             d_debug_processus) != 0)  
                                 {                                  {
                                     if ((*s_etat_processus).langue == 'F')                                      printf("[%d] Données acquittées "
                                     {                                              "en provenance du "
                                         printf("[%d] Interrution logicielle "                                              "thread %llu\n", (int) getpid(),
                                                 "en provenance du thread "                                              (unsigned long long)
                                                 "%llu\n", (int) getpid(),                                              (*s_argument_thread).tid);
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Software interrupt "  
                                                 "from thread %llu\n",  
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                 }                                  }
                                   else
                                 if (pthread_mutex_lock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      printf("[%d] Interruption logicielle "
                                             d_es_processus;                                              "acquittée en provenance "
                                 }                                              "du thread %llu\n", (int) getpid(),
                                               (unsigned long long)
                                 (*(*((struct_processus_fils *)                                              (*s_argument_thread).tid);
                                         (*(*l_element_courant).donnee)  
                                         .objet)).thread)  
                                         .nombre_interruptions_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                 }                                  }
   
                                 (*s_etat_processus)                                  fflush(stdout);
                                         .nombre_interruptions_non_affectees++;                              }
                               else
                                 while((longueur_ecriture =                              {
                                         write_atomic(s_etat_processus,                                  if (caractere == 1)
                                         (*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).pipe_acquittement[1], "-",  
                                         sizeof(unsigned char))) !=  
                                         sizeof(unsigned char))  
                                 {                                  {
                                     if (longueur_ecriture == -1)                                      printf("[%d] Data acknowklegment "
                                     {                                              "from thread %d\n", (int) getpid(),
                                         (*s_etat_processus)                                              (unsigned long long)
                                                 .erreur_systeme_processus_fils =                                              (*s_argument_thread).tid);
                                                 d_es_processus;  
                                     }  
                                 }                                  }
                                   else
                                 if ((*s_etat_processus).debug == d_vrai)  
                                     if (((*s_etat_processus).type_debug &  
                                             d_traitement_interruption) != 0)  
                                 {                                  {
                                     if ((*s_etat_processus).langue == 'F')                                      printf("[%d] Software interrupt "
                                     {                                              "acknowklegment from "
                                         printf("[%d] Interruption logicielle "                                              "thread %d\n", (int) getpid(),
                                                 "acquittée en provenance "                                              (unsigned long long)
                                                 "du thread %llu\n",                                              (*s_argument_thread).tid);
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Software interrupt "  
                                                 "acknowklegment from "  
                                                 "thread %llu\n",  
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                 }                                  }
   
                                 break;                                  fflush(stdout);
                             }                              }
                           }
   
                             l_element_courant = (*l_element_courant).suivant;                          if (pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus)) != 0)
                           {
                               (*s_etat_processus).erreur_systeme_processus_fils =
                                       d_es_processus;
                         }                          }
   
                         BUG(l_element_courant == NULL,                          envoi_signal_thread(NULL,
                                 printf("Process or thread not found"));                                  (*s_argument_thread).thread_pere,
                                   rpl_siginject);
   
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))                          if (pthread_mutex_lock(&((*s_etat_processus)
                                 != 0)                                  .mutex_pile_processus)) != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme_processus_fils =                              (*s_etat_processus).erreur_systeme_processus_fils =
                                     d_es_processus;                                      d_es_processus;
                         }                          }
   
                         envoi_signal_thread((*s_argument_thread).thread_pere,                          break;
                                 rpl_siginject);                      }
   
                       case 0:
                       {
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme_processus_fils =
                                   d_es_processus;
                           BUG(1, printf("Spurious interprocess data"));
                     }                      }
                 }                  }
                 else  
                   if (pthread_mutex_unlock(&((*s_etat_processus)
                           .mutex_pile_processus)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme_processus_fils =                      (*s_etat_processus).erreur_systeme_processus_fils =
                             d_es_processus;                              d_es_processus;
                 }                  }
             }              }
               else
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
               }
   
             if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)              if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
             {              {
Line 962  surveillance_processus(void *argument) Line 703  surveillance_processus(void *argument)
      * reste plus rien dans les tuyaux...       * reste plus rien dans les tuyaux...
      */       */
   
     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_processus_fils =          (*s_etat_processus).erreur_systeme_processus_fils =
                 d_es_processus;                  d_es_processus;
Line 1010  surveillance_processus(void *argument) Line 751  surveillance_processus(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 (drapeau_objets_traites == d_faux)          if (drapeau_elements_traites == d_faux)
         {          {
             if ((*s_argument_thread).processus_detache == d_vrai)              while(l_element_courant != NULL)
             {              {
                 while(l_element_courant != NULL)                  if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                           .donnee).objet)).thread).processus_detache
                           == d_vrai)
                 {                  {
                     if ((*(*((struct_processus_fils *) (*(*l_element_courant)                      if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                             .donnee).objet)).thread).processus_detache  
                             == d_faux)  
                     {  
                         l_element_courant = (*l_element_courant).suivant;  
                         continue;  
                     }  
   
                     if ((*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).pid ==                              .donnee).objet)).thread).pid ==
                             (*s_argument_thread).pid)                              (*s_argument_thread).pid)
                     {                      {
                         while(read_atomic(s_etat_processus, (*s_argument_thread)                          while(read_atomic(s_etat_processus, (*s_argument_thread)
                                 .pipe_nombre_objets_attente[0],                                  .pipe_nombre_elements_attente[0],
                                 &pid_candidat, sizeof(pid_candidat)) ==                                  &caractere, sizeof(caractere)) ==
                                 sizeof(pid_candidat))                                  sizeof(caractere))
                         {                          {
                             /*                              if (caractere == 0)
                              * -1 est renvoyé par l'instruction SWI  
                              */  
   
                             if (pid_candidat == -2)  
                             {  
                                 break;  
                             }  
                             else if (pid_candidat == -1)  
                             {                              {
                                   continue;
                             }                              }
                             else if (read_atomic(s_etat_processus,  
                                     (*s_argument_thread)                              if ((*s_etat_processus).debug == d_vrai)
                                     .pipe_nombre_objets_attente[0],                                  if (((*s_etat_processus).type_debug &
                                     &pid_candidat, sizeof(pid_candidat)) ==                                          d_debug_processus) != 0)
                                     sizeof(pid_candidat))  
                             {                              {
                                 if ((*s_etat_processus).debug == d_vrai)                                  if ((*s_etat_processus).langue == 'F')
                                     if (((*s_etat_processus).type_debug &  
                                             d_debug_processus) != 0)  
                                 {                                  {
                                     if ((*s_etat_processus).langue == 'F')                                      if (caractere == 1)
                                     {                                      {
                                         printf("[%d] Données en provenance du "                                          printf("[%d] Données en provenance du "
                                                 "processus %d (processus "                                                  "processus %d (processus "
                                                 "arrêté)\n", (int) getpid(),                                                  "arrêté)\n", (int) getpid(),
                                                 (int) (*s_argument_thread).pid);                                                  (int) (*s_argument_thread).pid);
                                         fflush(stdout);  
                                     }                                      }
                                     else                                      else
                                     {                                      {
                                           printf("[%d] Interruption en "
                                                   "provenance du "
                                                   "processus %d (processus "
                                                   "arrêté)\n", (int) getpid(),
                                                   (int) (*s_argument_thread).pid);
                                       }
   
                                       fflush(stdout);
                                   }
                                   else
                                   {
                                       if (caractere == 1)
                                       {
                                         printf("[%d] Data from process %d "                                          printf("[%d] Data from process %d "
                                                 "(processus stopped)\n",                                                  "(processus stopped)\n",
                                                 (int) getpid(),                                                  (int) getpid(),
                                                 (int) (*s_argument_thread).pid);                                                  (int) (*s_argument_thread).pid);
                                         fflush(stdout);  
                                     }                                      }
                                       else
                                       {
                                           printf("[%d] Interrupt from process %d "
                                                   "(processus stopped)\n",
                                                   (int) getpid(),
                                                   (int) (*s_argument_thread).pid);
                                       }
   
                                       fflush(stdout);
                                 }                                  }
                               }
   
                                 if (pthread_mutex_lock(                              if (pthread_mutex_lock(
                                         &((*(*((struct_processus_fils *)                                      &((*(*((struct_processus_fils *)
                                       (*(*l_element_courant).donnee).objet))
                                       .thread).mutex)) != 0)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                               }
   
                               if (caractere == 1)
                               {
                                   (*(*((struct_processus_fils *)
                                         (*(*l_element_courant).donnee).objet))                                          (*(*l_element_courant).donnee).objet))
                                         .thread).mutex)) != 0)                                          .thread).nombre_objets_dans_pipe++;
                               }
                               else
                               {
                                   (*(*((struct_processus_fils *)
                                           (*(*l_element_courant).donnee).objet))
                                           .thread)
                                           .nombre_interruptions_dans_pipe++;
   
                                   if (pthread_mutex_lock(&((*s_etat_processus)
                                           .mutex_interruptions)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
                                 }                                  }
   
                                 (*(*((struct_processus_fils *)                                  (*s_etat_processus)
                                         (*(*l_element_courant).donnee).objet))                                          .nombre_interruptions_non_affectees++;
                                         .thread).nombre_objets_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(&((*s_etat_processus)
                                         &((*(*((struct_processus_fils *)                                          .mutex_interruptions)) != 0)
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
                                 }                                  }
                             }                              }
   
                               if (pthread_mutex_unlock(
                                       &((*(*((struct_processus_fils *)
                                       (*(*l_element_courant).donnee).objet))
                                       .thread).mutex)) != 0)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                               }
                         }                          }
   
                         break;                          break;
                     }                      }
   
                     l_element_courant = (*l_element_courant).suivant;  
                 }                  }
             }                  else
             else  
             {  
                 while(l_element_courant != NULL)  
                 {                  {
                     if ((*(*((struct_processus_fils *) (*(*l_element_courant)                      if ((*(*((struct_processus_fils *) (*(*l_element_courant)
                             .donnee).objet)).thread).processus_detache                              .donnee).objet)).thread).tid ==
                             == d_vrai)                              (*s_argument_thread).tid)
                     {  
                         l_element_courant = (*l_element_courant).suivant;  
                         continue;  
                     }  
   
                     if (pthread_equal((*(*((struct_processus_fils *)  
                             (*(*l_element_courant).donnee).objet)).thread).tid,  
                             (*s_argument_thread).tid) != 0)  
                     {                      {
                         while(read_atomic(s_etat_processus, (*s_argument_thread)                          while(read_atomic(s_etat_processus, (*s_argument_thread)
                                 .pipe_nombre_objets_attente[0],                                  .pipe_nombre_elements_attente[0],
                                 &tid_candidat, sizeof(tid_candidat)) ==                                  &caractere, sizeof(caractere)) ==
                                 sizeof(tid_candidat))                                  sizeof(caractere))
                         {                          {
                             /*                              if (caractere == 0)
                              * -1 est renvoyé par l'instruction SWI  
                              */  
   
                             if (tid_candidat == (pthread_t) -2)  
                             {  
                                 break;  
                             }  
                             else if (tid_candidat == (pthread_t) -1)  
                             {                              {
                                   continue;
                             }                              }
                             else if (read_atomic(s_etat_processus,  
                                     (*s_argument_thread)                              if ((*s_etat_processus).debug == d_vrai)
                                     .pipe_nombre_objets_attente[0],                                  if (((*s_etat_processus).type_debug &
                                     &tid_candidat, sizeof(tid_candidat)) ==                                          d_debug_processus) != 0)
                                     sizeof(tid_candidat))  
                             {                              {
                                 if ((*s_etat_processus).debug == d_vrai)                                  if ((*s_etat_processus).langue == 'F')
                                     if (((*s_etat_processus).type_debug &  
                                             d_debug_processus) != 0)  
                                 {                                  {
                                     if ((*s_etat_processus).langue == 'F')                                      if (caractere == 1)
                                     {                                      {
                                         printf("[%d] Données en provenance du "                                          printf("[%d] Données en provenance du "
                                                 "thread %llu (thread "                                                  "thread %llu (processus "
                                                 "arrêté)\n", (int) getpid(),                                                  "arrêté)\n", (int) getpid(),
                                                 (unsigned long long)                                                  (unsigned long long)
                                                 (*s_argument_thread).tid);                                                  (*s_argument_thread).tid);
                                         fflush(stdout);  
                                     }                                      }
                                     else                                      else
                                     {                                      {
                                         printf("[%d] Data from thread %llu "                                          printf("[%d] Interruption en "
                                                 "(thread stopped)\n",                                                  "provenance du "
                                                 (int) getpid(),                                                  "thread %llu (processus "
                                                   "arrêté)\n", (int) getpid(),
                                                 (unsigned long long)                                                  (unsigned long long)
                                                 (*s_argument_thread).tid);                                                  (*s_argument_thread).tid);
                                         fflush(stdout);  
                                     }                                      }
                                 }  
   
                                 if (pthread_mutex_lock(                                      fflush(stdout);
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                 }                                  }
                                   else
                                 (*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).nombre_objets_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      if (caractere == 1)
                                             d_es_processus;  
                                 }  
                             }  
                         }  
   
                         break;  
                     }  
   
                     l_element_courant = (*l_element_courant).suivant;  
                 }  
             }  
         }  
   
         l_element_courant = (struct_liste_chainee *)  
                 (*s_etat_processus).l_base_pile_processus;  
   
         if (drapeau_interruptions_traitees == d_faux)  
         {  
             if ((*s_argument_thread).processus_detache == d_vrai)  
             {  
                 while(l_element_courant != NULL)  
                 {  
                     if ((*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).processus_detache  
                             == d_faux)  
                     {  
                         l_element_courant = (*l_element_courant).suivant;  
                         continue;  
                     }  
   
                     if ((*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).pid ==  
                             (*s_argument_thread).pid)  
                     {  
                         while(read_atomic(s_etat_processus, (*s_argument_thread)  
                                 .pipe_nombre_interruptions_attente[0],  
                                 &pid_candidat, sizeof(pid_candidat)) ==  
                                 sizeof(pid_candidat))  
                         {  
                             if (pid_candidat == -2)  
                             {  
                                 break;  
                             }  
                             else if (pid_candidat == -1)  
                             {  
                             }  
                             else if (read_atomic(s_etat_processus,  
                                     (*s_argument_thread)  
                                     .pipe_nombre_interruptions_attente[0],  
                                     &pid_candidat, sizeof(pid_candidat)) ==  
                                     sizeof(pid_candidat))  
                             {  
                                 if ((*s_etat_processus).debug == d_vrai)  
                                     if (((*s_etat_processus).type_debug &  
                                             d_traitement_interruption) != 0)  
                                 {  
                                     if ((*s_etat_processus).langue == 'F')  
                                     {                                      {
                                         printf("[%d] Interruption logicielle "                                          printf("[%d] Data from thread %llu "
                                                 "en provenance du processus %d"                                                  "(processus stopped)\n",
                                                 " (processus arrêté)\n",  
                                                 (int) getpid(),                                                  (int) getpid(),
                                                 (int) (*s_argument_thread).pid);                                                  (unsigned long long)
                                         fflush(stdout);                                                  (*s_argument_thread).pid);
                                     }                                      }
                                     else                                      else
                                     {                                      {
                                         printf("[%d] Software interrupt "                                          printf("[%d] Interrupt from thread "
                                                 "from process %d (processus "                                                  "%llu (processus stopped)\n",
                                                 "stopped)\n", (int) getpid(),                                                  (int) getpid(),
                                                 (int) (*s_argument_thread).pid);                                                  (unsigned long long)
                                         fflush(stdout);                                                  (*s_argument_thread).pid);
                                     }                                      }
                                 }  
   
                                 if (pthread_mutex_lock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                 }  
   
                                 (*(*((struct_processus_fils *)                                      fflush(stdout);
                                         (*(*l_element_courant).donnee)  
                                         .objet)).thread)  
                                         .nombre_interruptions_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                 }                                  }
   
                                 (*s_etat_processus)  
                                         .nombre_interruptions_non_affectees++;  
                             }                              }
                         }  
   
                         break;  
                     }  
   
                     l_element_courant = (*l_element_courant).suivant;  
                 }  
             }  
             else  
             {  
                 while(l_element_courant != NULL)  
                 {  
                     if ((*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).processus_detache  
                             == d_vrai)  
                     {  
                         l_element_courant = (*l_element_courant).suivant;  
                         continue;  
                     }  
   
                     if (pthread_equal((*(*((struct_processus_fils *)                              if (pthread_mutex_lock(
                             (*(*l_element_courant).donnee).objet)).thread).tid,                                      &((*(*((struct_processus_fils *)
                             (*s_argument_thread).tid) != 0)                                      (*(*l_element_courant).donnee).objet))
                     {                                      .thread).mutex)) != 0)
                         while(read_atomic(s_etat_processus, (*s_argument_thread)  
                                 .pipe_nombre_interruptions_attente[0],  
                                 &tid_candidat, sizeof(tid_candidat)) ==  
                                 sizeof(tid_candidat))  
                         {  
                             if (tid_candidat == (pthread_t) -2)  
                             {                              {
                                 break;                                  (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                             }                              }
                             else if (tid_candidat == (pthread_t) -1)  
                               if (caractere == 1)
                             {                              {
                                   (*(*((struct_processus_fils *)
                                           (*(*l_element_courant).donnee).objet))
                                           .thread).nombre_objets_dans_pipe++;
                             }                              }
                             else if (read_atomic(s_etat_processus,                              else
                                     (*s_argument_thread)  
                                     .pipe_nombre_interruptions_attente[0],  
                                     &tid_candidat, sizeof(tid_candidat)) ==  
                                     sizeof(tid_candidat))  
                             {                              {
                                 if ((*s_etat_processus).debug == d_vrai)                                  (*(*((struct_processus_fils *)
                                     if (((*s_etat_processus).type_debug &  
                                             d_traitement_interruption) != 0)  
                                 {  
                                     if ((*s_etat_processus).langue == 'F')  
                                     {  
                                         printf("[%d] Interruption logicielle "  
                                                 "en provenance du thread %llu"  
                                                 " (thread arrêté)\n",  
                                                 (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                     else  
                                     {  
                                         printf("[%d] Software interrupt "  
                                                 "from thread %llu (thread "  
                                                 "stopped)\n", (int) getpid(),  
                                                 (unsigned long long)  
                                                 (*s_argument_thread).tid);  
                                         fflush(stdout);  
                                     }  
                                 }  
   
                                 if (pthread_mutex_lock(  
                                         &((*(*((struct_processus_fils *)  
                                         (*(*l_element_courant).donnee).objet))                                          (*(*l_element_courant).donnee).objet))
                                         .thread).mutex)) != 0)                                          .thread)
                                           .nombre_interruptions_dans_pipe++;
   
                                   if (pthread_mutex_lock(&((*s_etat_processus)
                                           .mutex_interruptions)) != 0)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
                                 }                                  }
   
                                 (*(*((struct_processus_fils *)                                  (*s_etat_processus)
                                         (*(*l_element_courant).donnee)                                          .nombre_interruptions_non_affectees++;
                                         .objet)).thread)  
                                         .nombre_interruptions_dans_pipe++;  
   
                                 if (pthread_mutex_unlock(                                  if (pthread_mutex_unlock(&((*s_etat_processus)
                                         &((*(*((struct_processus_fils *)                                          .mutex_interruptions)) != 0)
                                         (*(*l_element_courant).donnee).objet))  
                                         .thread).mutex)) != 0)  
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
                                             d_es_processus;                                              d_es_processus;
                                 }                                  }
                               }
   
                                 (*s_etat_processus)                              if (pthread_mutex_unlock(
                                         .nombre_interruptions_non_affectees++;                                      &((*(*((struct_processus_fils *)
                                       (*(*l_element_courant).donnee).objet))
                                       .thread).mutex)) != 0)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                             }                              }
                         }                          }
   
                         break;                          break;
                     }                      }
   
                     l_element_courant = (*l_element_courant).suivant;  
                 }                  }
   
                   l_element_courant = (*l_element_courant).suivant;
             }              }
         }          }
   
         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_processus_fils =              (*s_etat_processus).erreur_systeme_processus_fils =
                     d_es_processus;                      d_es_processus;
Line 1481  surveillance_processus(void *argument) Line 1089  surveillance_processus(void *argument)
         (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;          (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
     }      }
   
     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_processus_fils = d_es_processus;          (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
     }      }
Line 1675  surveillance_processus(void *argument) Line 1283  surveillance_processus(void *argument)
                 }                  }
   
                 if (close((*s_argument_thread)                  if (close((*s_argument_thread)
                         .pipe_nombre_objets_attente[0]) != 0)                          .pipe_nombre_elements_attente[0]) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme_processus_fils =                      (*s_etat_processus).erreur_systeme_processus_fils =
                             d_es_processus;                              d_es_processus;
Line 1688  surveillance_processus(void *argument) Line 1296  surveillance_processus(void *argument)
                             d_es_processus;                              d_es_processus;
                 }                  }
   
                 if (close((*s_argument_thread)  
                         .pipe_nombre_interruptions_attente[0]) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme_processus_fils =  
                             d_es_processus;  
                 }  
   
                 drapeau_fin = d_vrai;                  drapeau_fin = d_vrai;
             }              }
             else              else
             {              {
                 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_processus_fils =                      (*s_etat_processus).erreur_systeme_processus_fils =
                             d_es_processus;                              d_es_processus;
Line 1709  surveillance_processus(void *argument) Line 1311  surveillance_processus(void *argument)
                 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_processus_fils =                      (*s_etat_processus).erreur_systeme_processus_fils =
                             d_es_processus;                              d_es_processus;
Line 1826  surveillance_processus(void *argument) Line 1429  surveillance_processus(void *argument)
             fflush(stdout);              fflush(stdout);
         }          }
   
           if (pthread_mutex_unlock(&((*s_etat_processus)
                   .mutex_pile_processus)) != 0)
           {
               (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
           }
   
         retrait_thread_surveillance(s_etat_processus, s_argument_thread);          retrait_thread_surveillance(s_etat_processus, s_argument_thread);
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_lock(&((*s_etat_processus)
                   .mutex_pile_processus)) != 0)
           {
               (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
           }
   
           nombre_threads_surveillance_processus--;
   
           if (pthread_mutex_unlock(&((*s_etat_processus)
                   .mutex_pile_processus)) != 0)
         {          {
             (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;              (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
         }          }
     }      }
   
     pthread_exit(NULL);      pthread_exit(NULL);
     return(NULL);  
 }  }
   
   
Line 1991  ecriture_pipe(struct_processus *s_etat_p Line 1608  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_vecteur *) (*s_objet).objet))                  &((*((struct_vecteur *) (*s_objet).objet))
                 .taille), sizeof(unsigned long))) != sizeof(unsigned long))                  .taille), sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2044  ecriture_pipe(struct_processus *s_etat_p Line 1661  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_vecteur *) (*s_objet).objet))                  &((*((struct_vecteur *) (*s_objet).objet))
                 .taille), sizeof(unsigned long))) != sizeof(unsigned long))                  .taille), sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2097  ecriture_pipe(struct_processus *s_etat_p Line 1714  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_vecteur *) (*s_objet).objet))                  &((*((struct_vecteur *) (*s_objet).objet))
                 .taille), sizeof(unsigned long))) != sizeof(unsigned long))                  .taille), sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2150  ecriture_pipe(struct_processus *s_etat_p Line 1767  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),                  &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2166  ecriture_pipe(struct_processus *s_etat_p Line 1783  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),                  &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2225  ecriture_pipe(struct_processus *s_etat_p Line 1842  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),                  &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2241  ecriture_pipe(struct_processus *s_etat_p Line 1858  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),                  &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2300  ecriture_pipe(struct_processus *s_etat_p Line 1917  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),                  &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2316  ecriture_pipe(struct_processus *s_etat_p Line 1933  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),                  &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2510  ecriture_pipe(struct_processus *s_etat_p Line 2127  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),                  &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2652  ecriture_pipe(struct_processus *s_etat_p Line 2269  ecriture_pipe(struct_processus *s_etat_p
   
         while((longueur_ecriture = write_atomic(s_etat_processus, pipe,          while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
                 &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),                  &((*((struct_tableau *) (*s_objet).objet)).nombre_elements),
                 sizeof(unsigned long))) != sizeof(unsigned long))                  sizeof(integer8))) != sizeof(integer8))
         {          {
             if (longueur_ecriture == -1)              if (longueur_ecriture == -1)
             {              {
Line 2796  lecture_pipe(struct_processus *s_etat_pr Line 2413  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
                 (*s_objet).objet)).taille),                  (*s_objet).objet)).taille),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 2840  lecture_pipe(struct_processus *s_etat_pr Line 2457  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
                 (*s_objet).objet)).taille),                  (*s_objet).objet)).taille),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 2884  lecture_pipe(struct_processus *s_etat_pr Line 2501  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *)
                 (*s_objet).objet)).taille),                  (*s_objet).objet)).taille),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 2928  lecture_pipe(struct_processus *s_etat_pr Line 2545  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                 (*s_objet).objet)).nombre_lignes),                  (*s_objet).objet)).nombre_lignes),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 2939  lecture_pipe(struct_processus *s_etat_pr Line 2556  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                 (*s_objet).objet)).nombre_colonnes),                  (*s_objet).objet)).nombre_colonnes),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 2996  lecture_pipe(struct_processus *s_etat_pr Line 2613  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                 (*s_objet).objet)).nombre_lignes),                  (*s_objet).objet)).nombre_lignes),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 3007  lecture_pipe(struct_processus *s_etat_pr Line 2624  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                 (*s_objet).objet)).nombre_colonnes),                  (*s_objet).objet)).nombre_colonnes),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 3064  lecture_pipe(struct_processus *s_etat_pr Line 2681  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                 (*s_objet).objet)).nombre_lignes),                  (*s_objet).objet)).nombre_lignes),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 3075  lecture_pipe(struct_processus *s_etat_pr Line 2692  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *)
                 (*s_objet).objet)).nombre_colonnes),                  (*s_objet).objet)).nombre_colonnes),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 3222  lecture_pipe(struct_processus *s_etat_pr Line 2839  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe,          while(read_atomic(s_etat_processus, pipe,
                 &((*((struct_fonction *) (*s_objet).objet))                  &((*((struct_fonction *) (*s_objet).objet))
                 .nombre_arguments), sizeof(unsigned long)) !=                  .nombre_arguments), sizeof(integer8)) !=
                 sizeof(unsigned long))                  sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 3343  lecture_pipe(struct_processus *s_etat_pr Line 2960  lecture_pipe(struct_processus *s_etat_pr
   
         while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)          while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *)
                 (*s_objet).objet)).nombre_elements),                  (*s_objet).objet)).nombre_elements),
                 sizeof(unsigned long)) != sizeof(unsigned long))                  sizeof(integer8)) != sizeof(integer8))
         {          {
             nanosleep(&attente, NULL);              nanosleep(&attente, NULL);
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
Line 3396  lecture_pipe(struct_processus *s_etat_pr Line 3013  lecture_pipe(struct_processus *s_etat_pr
 void  void
 scrutation_injection(struct_processus *s_etat_processus)  scrutation_injection(struct_processus *s_etat_processus)
 {  {
     fd_set                          ensemble_descripteurs;  
   
     logical1                        drapeau_erreur;      logical1                        drapeau_erreur;
     logical1                        registre_arret_si_exception;      logical1                        registre_arret_si_exception;
   
 #   ifdef PSELECT      struct pollfd                   fds;
         struct timespec             timeout;  
 #   else  
         struct timeval              timeout;  
 #   endif  
   
     unsigned char                   tampon;      unsigned char                   tampon;
     unsigned char                   tampon_profilage[20];      unsigned char                   tampon_profilage[20];
   
     // Si on est dans le processus père, il n'y a rien à surveiller.  
   
     scrutation_interruptions(s_etat_processus);      scrutation_interruptions(s_etat_processus);
   
       // Si on est dans le processus père, il n'y a rien à surveiller.
   
     if ((*s_etat_processus).var_volatile_processus_racine == 0)      if ((*s_etat_processus).var_volatile_processus_racine == 0)
     {      {
         FD_ZERO(&ensemble_descripteurs);          fds.fd = (*s_etat_processus).pipe_nombre_injections;
         FD_SET((*s_etat_processus).pipe_nombre_injections,          fds.events = POLLIN;
                 &ensemble_descripteurs);          fds.revents = 0;
   
 #       ifdef PSELECT          if (poll(&fds, 1, 0) > 0)
         timeout.tv_sec = 0;  
         timeout.tv_nsec = 0;  
   
         if (pselect((*s_etat_processus).pipe_nombre_injections + 1,  
                 &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)  
 #       else  
         timeout.tv_sec = 0;  
         timeout.tv_usec = 0;  
   
         if (select((*s_etat_processus).pipe_nombre_injections + 1,  
                 &ensemble_descripteurs, NULL, NULL, &timeout) > 0)  
 #       endif  
         {          {
             if (read_atomic(s_etat_processus,              if (read_atomic(s_etat_processus,
                     (*s_etat_processus).pipe_nombre_injections,                      (*s_etat_processus).pipe_nombre_injections,
Line 3589  scrutation_injection(struct_processus *s Line 3188  scrutation_injection(struct_processus *s
                 }                  }
             }              }
         }          }
   
     }      }
   
     return;      return;
Removed from v.1.62  
changed lines
  Added in v.1.106

CVSweb interface <joel.bertrand@systella.fr>