[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.3 and 1.45

version 1.3, 2010/02/10 10:14:20 version 1.45, 2011/09/10 20:45:06
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.11    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);
     sigaddset(&masque, SIGFSTOP);      sigaddset(&masque, SIGFSTOP);
       sigaddset(&masque, SIGFABORT);
     sigaddset(&masque, SIGURG);      sigaddset(&masque, SIGURG);
     sigaddset(&masque, SIGALRM);      sigaddset(&masque, SIGALRM);
     sigaddset(&masque, SIGCONT);      sigaddset(&masque, SIGCONT);
Line 84  surveillance_processus(void *argument) Line 87  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)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           BUG(1, uprintf("General mutex error!\n"));
       }
   
     insertion_thread_surveillance(s_etat_processus, s_argument_thread);      insertion_thread_surveillance(s_etat_processus, s_argument_thread);
   
       if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           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 713  surveillance_processus(void *argument) Line 729  surveillance_processus(void *argument)
                         }                          }
   
                         BUG(l_element_courant == NULL,                          BUG(l_element_courant == NULL,
                                 printf("Process or thread not found"));                                  printf("Process or thread not found\n"));
   
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))                          if (pthread_mutex_unlock(&((*s_etat_processus).mutex))
                                 != 0)                                  != 0)
Line 909  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 1428  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 1440  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 1448  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 1463  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 1489  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 1752  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;
   
                     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;
                     free(l_element_courant);  
                 }                  }
   
                   liberation(s_etat_processus, (*l_element_courant).donnee);
                   free(l_element_courant);
   
                 break;                  break;
             }              }
             else              else
Line 1774  surveillance_processus(void *argument) Line 1794  surveillance_processus(void *argument)
             }              }
         }          }
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)          if ((*s_etat_processus).debug == d_vrai)
         {              if (((*s_etat_processus).type_debug &
             (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;                      d_debug_processus) != 0)
         }  
     }  
   
     if ((*s_etat_processus).debug == d_vrai)  
         if (((*s_etat_processus).type_debug &  
                 d_debug_processus) != 0)  
     {  
         if ((*s_argument_thread).processus_detache == d_vrai)  
         {          {
             if ((*s_etat_processus).langue == 'F')              if ((*s_argument_thread).processus_detache == d_vrai)
             {              {
                 printf("[%d] Arrêt du thread de surveillance du"                  if ((*s_etat_processus).langue == 'F')
                         " processus %d\n", (int) getpid(),                  {
                         (int) (*s_argument_thread).pid);                      printf("[%d] Arrêt du thread de surveillance du"
                               " processus %d\n", (int) getpid(),
                               (int) (*s_argument_thread).pid);
                   }
                   else
                   {
                       printf("[%d] Stop monitoring of process %d", (int) getpid(),
                               (int) (*s_argument_thread).pid);
                   }
             }              }
             else              else
             {              {
                 printf("[%d] Stop monitoring of process %d", (int) getpid(),                  if ((*s_etat_processus).langue == 'F')
                         (int) (*s_argument_thread).pid);                  {
                       printf("[%d] Arrêt du thread de surveillance du"
                               " thread %llu\n", (int) getpid(),
                               (unsigned long long) (*s_argument_thread)
                               .tid);
                   }
                   else
                   {
                       printf("[%d] Stop monitoring of thread %llu",
                               (int) getpid(),
                               (unsigned long long) (*s_argument_thread)
                               .tid);
                   }
             }              }
   
               fflush(stdout);
         }          }
         else  
           retrait_thread_surveillance(s_etat_processus, s_argument_thread);
   
           if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
         {          {
             if ((*s_etat_processus).langue == 'F')              (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus;
             {  
                 printf("[%d] Arrêt du thread de surveillance du"  
                         " thread %llu\n", (int) getpid(),  
                         (unsigned long long) (*s_argument_thread)  
                         .tid);  
             }  
             else  
             {  
                 printf("[%d] Stop monitoring of thread %llu", (int) getpid(),  
                         (unsigned long long) (*s_argument_thread)  
                         .tid);  
             }  
         }          }
   
         fflush(stdout);  
     }      }
   
     retrait_thread_surveillance(s_etat_processus, s_argument_thread);  
   
     pthread_exit(NULL);      pthread_exit(NULL);
       return(NULL);
 }  }
   
   
Line 3378  lecture_pipe(struct_processus *s_etat_pr Line 3400  lecture_pipe(struct_processus *s_etat_pr
 ================================================================================  ================================================================================
 */  */
   
 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;
   
     struct timespec                 timeout;      logical1                        drapeau_erreur;
       logical1                        registre_arret_si_exception;
   
   #   if !defined(OpenBSD) && !defined(OS2)
           struct timespec             timeout;
   #   else
           struct timeval              timeout;
   #   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)      scrutation_interruptions(s_etat_processus);
   
       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);
   
   #       if !defined(OpenBSD) && !defined(OS2)
         timeout.tv_sec = 0;          timeout.tv_sec = 0;
         timeout.tv_nsec = 0;          timeout.tv_nsec = 0;
   
         if (pselect((*s_etat_processus).pipe_nombre_injections + 1,          if (pselect((*s_etat_processus).pipe_nombre_injections + 1,
                 &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0)                  &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 3424  scrutation_injection(struct_processus *s Line 3464  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 3432  scrutation_injection(struct_processus *s Line 3605  scrutation_injection(struct_processus *s
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction de test du draeau d'arrêt    Fonction de test du drapeau d'arrêt
 ================================================================================  ================================================================================
   Entrées : pointeur sur une structure    Entrées : pointeur sur une structure
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 3442  scrutation_injection(struct_processus *s Line 3615  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.3  
changed lines
  Added in v.1.45

CVSweb interface <joel.bertrand@systella.fr>