[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.16 and 1.44

version 1.16, 2010/06/09 12:19:13 version 1.44, 2011/08/09 11:31:30
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.16    RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 53  surveillance_processus(void *argument) Line 53  surveillance_processus(void *argument)
   
     pid_t                           pid;      pid_t                           pid;
     pid_t                           pid_candidat;      pid_t                           pid_candidat;
       pid_t                           pid_erreur;
   
     pthread_t                       tid_candidat;      pthread_t                       tid_candidat;
   
Line 71  surveillance_processus(void *argument) Line 72  surveillance_processus(void *argument)
   
     unsigned char                   caractere;      unsigned char                   caractere;
   
     unsigned int                    tampon_erreur;      unsigned int                    tampon_erreur_execution;
       unsigned int                    tampon_erreur_systeme;
   
     sigemptyset(&masque);      sigemptyset(&masque);
     sigaddset(&masque, SIGINJECT);      sigaddset(&masque, SIGINJECT);
Line 100  surveillance_processus(void *argument) Line 102  surveillance_processus(void *argument)
         BUG(1, uprintf("General mutex error!\n"));          BUG(1, uprintf("General mutex error!\n"));
     }      }
   
   
     attente.tv_sec = 0;      attente.tv_sec = 0;
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
Line 924  surveillance_processus(void *argument) Line 925  surveillance_processus(void *argument)
                             (*s_etat_processus).erreur_systeme_processus_fils =                              (*s_etat_processus).erreur_systeme_processus_fils =
                                     d_es_processus;                                      d_es_processus;
                         }                          }
   
                           pthread_kill((*s_argument_thread).thread_pere,
                                   SIGINJECT);
                     }                      }
                 }                  }
                 else                  else
Line 1443  surveillance_processus(void *argument) Line 1447  surveillance_processus(void *argument)
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],      while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
             &((*s_etat_processus).erreur_execution_processus_fils),              &tampon_erreur_execution,
             sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=              sizeof((*s_etat_processus).erreur_execution_processus_fils)) !=
             sizeof((*s_etat_processus).erreur_execution_processus_fils))              sizeof((*s_etat_processus).erreur_execution_processus_fils))
     {      {
Line 1455  surveillance_processus(void *argument) Line 1459  surveillance_processus(void *argument)
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],      while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
             &tampon_erreur,              &tampon_erreur_systeme,
             sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=              sizeof((*s_etat_processus).erreur_systeme_processus_fils)) !=
             sizeof((*s_etat_processus).erreur_systeme_processus_fils))              sizeof((*s_etat_processus).erreur_systeme_processus_fils))
     {      {
Line 1463  surveillance_processus(void *argument) Line 1467  surveillance_processus(void *argument)
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
     }      }
   
     (*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur;  
   
     attente.tv_sec = 0;      attente.tv_sec = 0;
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],      while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0],
             &((*s_etat_processus).pid_erreur_processus_fils),              &pid_erreur,
             sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=              sizeof((*s_etat_processus).pid_erreur_processus_fils)) !=
             sizeof((*s_etat_processus).pid_erreur_processus_fils))              sizeof((*s_etat_processus).pid_erreur_processus_fils))
     {      {
Line 1478  surveillance_processus(void *argument) Line 1480  surveillance_processus(void *argument)
     }      }
   
     /*      /*
      * Si une erreur est déclarée dans le processus fils, le message  
      * d'erreur a déjà été affiché.  
      */  
   
     if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||  
             ((*s_etat_processus).erreur_execution_processus_fils != d_ex))  
     {  
         (*s_etat_processus).erreur_processus_fils = d_vrai;  
         (*s_etat_processus).invalidation_message_erreur = d_vrai;  
     }  
   
     /*  
      * Retrait du processus de la pile des processus       * Retrait du processus de la pile des processus
      */       */
   
Line 1504  surveillance_processus(void *argument) Line 1494  surveillance_processus(void *argument)
     }      }
     else      else
     {      {
           (*s_etat_processus).erreur_execution_processus_fils =
                   tampon_erreur_execution;
           (*s_etat_processus).erreur_systeme_processus_fils =
                   tampon_erreur_systeme;
           (*s_etat_processus).pid_erreur_processus_fils = pid_erreur;
   
           /*
            * Si une erreur est déclarée dans le processus fils, le message
            * d'erreur a déjà été affiché.
            */
   
           if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) ||
                   ((*s_etat_processus).erreur_execution_processus_fils != d_ex))
           {
               (*s_etat_processus).erreur_processus_fils = d_vrai;
               (*s_etat_processus).invalidation_message_erreur = d_vrai;
           }
   
         do          do
         {          {
             drapeau_fin = d_faux;              drapeau_fin = d_faux;
Line 1767  surveillance_processus(void *argument) Line 1775  surveillance_processus(void *argument)
                 {                  {
                     (*s_etat_processus).l_base_pile_processus =                      (*s_etat_processus).l_base_pile_processus =
                             (*l_element_courant).suivant;                              (*l_element_courant).suivant;
   
                     (*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).nombre_references--;  
   
                     // Cette référence ne peut être nulle car l'objet est encore  
                     // référencé par la liste des threads de surveillance.  
   
                     BUG((*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).nombre_references <= 0,  
                             uprintf("(*(*((struct_processus_fils *) "  
                             "(*(*l_element_courant).donnee).objet)).thread)"  
                             ".nombre_references = %d\n",  
                             (*(*((struct_processus_fils *)  
                             (*(*l_element_courant).donnee).objet)).thread)  
                             .nombre_references));  
   
                     free((*(*l_element_courant).donnee).objet);  
                     free((*l_element_courant).donnee);  
                     free(l_element_courant);  
   
                     l_element_courant = (struct_liste_chainee *)  
                             (*s_etat_processus).l_base_pile_processus;  
                 }                  }
                 else                  else
                 {                  {
                     (*l_element_precedent).suivant =                      (*l_element_precedent).suivant =
                             (*l_element_courant).suivant;                              (*l_element_courant).suivant;
   
                     (*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).nombre_references--;  
   
                     // Cette référence ne peut être nulle car l'objet est encore  
                     // référencé par la liste des threads de surveillance.  
   
                     BUG((*(*((struct_processus_fils *) (*(*l_element_courant)  
                             .donnee).objet)).thread).nombre_references <= 0,  
                             uprintf("(*(*((struct_processus_fils *) "  
                             "(*(*l_element_courant).donnee).objet)).thread)"  
                             ".nombre_references = %d\n",  
                             (*(*((struct_processus_fils *)  
                             (*(*l_element_courant).donnee).objet)).thread)  
                             .nombre_references));  
   
                     free((*(*l_element_courant).donnee).objet);  
                     free((*l_element_courant).donnee);  
                     free(l_element_courant);  
                 }                  }
   
                   liberation(s_etat_processus, (*l_element_courant).donnee);
                   free(l_element_courant);
   
                 break;                  break;
             }              }
             else              else
Line 1872  surveillance_processus(void *argument) Line 1842  surveillance_processus(void *argument)
     }      }
   
     pthread_exit(NULL);      pthread_exit(NULL);
       return(NULL);
 }  }
   
   
Line 3429  lecture_pipe(struct_processus *s_etat_pr Line 3400  lecture_pipe(struct_processus *s_etat_pr
 ================================================================================  ================================================================================
 */  */
   
 extern inline void  void
 scrutation_injection(struct_processus *s_etat_processus)  scrutation_injection(struct_processus *s_etat_processus)
 {  {
     fd_set                          ensemble_descripteurs;      fd_set                          ensemble_descripteurs;
   
 #   ifndef OpenBSD      logical1                        drapeau_erreur;
       logical1                        registre_arret_si_exception;
   
   #   if !defined(OpenBSD) && !defined(OS2)
         struct timespec             timeout;          struct timespec             timeout;
 #   else  #   else
         struct timeval              timeout;          struct timeval              timeout;
 #   endif  #   endif
   
     unsigned char                   tampon;      unsigned char                   tampon;
       unsigned char                   tampon_profilage[20];
   
     // Si on est dans le processus père, il n'y a rien à surveiller.      // Si on est dans le processus père, il n'y a rien à surveiller.
   
     if ((*s_etat_processus).var_volatile_processus_pere == 0)      if ((*s_etat_processus).var_volatile_processus_racine == 0)
     {      {
         FD_ZERO(&ensemble_descripteurs);          FD_ZERO(&ensemble_descripteurs);
         FD_SET((*s_etat_processus).pipe_nombre_injections,          FD_SET((*s_etat_processus).pipe_nombre_injections,
                 &ensemble_descripteurs);                  &ensemble_descripteurs);
   
 #       ifndef OpenBSD  #       if !defined(OpenBSD) && !defined(OS2)
         timeout.tv_sec = 0;          timeout.tv_sec = 0;
         timeout.tv_nsec = 0;          timeout.tv_nsec = 0;
   
Line 3487  scrutation_injection(struct_processus *s Line 3462  scrutation_injection(struct_processus *s
                 }                  }
             }              }
         }          }
   
           /*
            * Traitement de l'interruption d'injection
            */
   
           if (((*s_etat_processus).nombre_objets_injectes != 0) &&
                   ((*s_etat_processus).traitement_at_poke == 'N'))
           {
               if ((*s_etat_processus).at_poke != NULL)
               {
                   registre_arret_si_exception =
                           (*s_etat_processus).arret_si_exception;
                   (*s_etat_processus).arret_si_exception = d_vrai;
   
                   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] Traitement de l'interruption "
                                   "d'injection\n", (int) getpid());
                       }
                       else
                       {
                           printf("[%d] Start injection interrupt\n",
                                   (int) getpid());
                       }
   
                       fflush(stdout);
                   }
   
                   if ((*s_etat_processus).profilage == d_vrai)
                   {
                       sprintf(tampon_profilage, "Injection interrupt");
                       profilage(s_etat_processus, tampon_profilage);
   
                       if ((*s_etat_processus).erreur_systeme != d_es)
                       {
                           return;
                       }
                   }
   
                   (*s_etat_processus).traitement_at_poke = 'Y';
                   drapeau_erreur = evaluation(s_etat_processus,
                           (*s_etat_processus).at_poke, 'E');
                   (*s_etat_processus).traitement_at_poke = 'N';
   
                   if ((*s_etat_processus).profilage == d_vrai)
                   {
                       profilage(s_etat_processus, NULL);
                   }
   
                   if (drapeau_erreur == d_absence_erreur)
                   {
                       (*s_etat_processus).arret_si_exception =
                               registre_arret_si_exception;
                   }
                   else
                   {
                       if ((((*s_etat_processus).erreur_execution != d_ex) ||
                               ((*s_etat_processus).exception != d_ep) ||
                               ((*s_etat_processus).erreur_systeme != d_es)) &&
                               ((*s_etat_processus).core == d_vrai) &&
                               ((*s_etat_processus)
                               .var_volatile_traitement_sigint == 0))
                       {
                           printf("\n");
                           
                           if ((*s_etat_processus).langue == 'F')
                           {
                               printf("+++Information : "
                                       "Génération du fichier rpl-core "
                                       "[%d]\n", (int) getpid());
                           }
                           else
                           {
                               printf("+++Information : "
                                       "Writing rpl-core file [%d]\n",
                                       (int) getpid());
                           }
   
                           rplcore(s_etat_processus);
   
                           if ((*s_etat_processus).langue == 'F')
                           {
                               printf("+++Information : "
                                       "Processus tracé [%d]\n",
                                       (int) getpid());
                           }
                           else
                           {
                               printf("+++Information : Done [%d]\n",
                                       (int) getpid());
                           }
   
                           printf("\n");
                           fflush(stdout);
                       }
   
                   }
   
                   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] Fin de l'interruption d'injection\n",
                                   (int) getpid());
                       }
                       else
                       {
                           printf("[%d] Stop injection interrupt\n",
                                   (int) getpid());
                       }
   
                       fflush(stdout);
                   }
   
                   if ((drapeau_erreur == d_erreur) &&
                           ((*s_etat_processus).erreur_execution == d_ex))
                   {
                       if (((*s_etat_processus).erreur_execution == d_ex) &&
                               ((*s_etat_processus).erreur_systeme == d_es))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_evaluation;
                       }
                   }
               }
           }
   
     }      }
   
     return;      return;
Line 3505  scrutation_injection(struct_processus *s Line 3613  scrutation_injection(struct_processus *s
 ================================================================================  ================================================================================
 */  */
   
 inline int test_arret(struct_processus *s_etat_processus)  int
   test_arret(struct_processus *s_etat_processus)
 {  {
     return((int) (*s_etat_processus).var_volatile_requete_arret);      return((int) (*s_etat_processus).var_volatile_requete_arret);
 }  }
Removed from v.1.16  
changed lines
  Added in v.1.44

CVSweb interface <joel.bertrand@systella.fr>