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

Diff for /rpl/src/interruptions.c between versions 1.105 and 1.106

version 1.105, 2012/10/09 15:27:45 version 1.106, 2012/10/14 21:37:11
Line 121  thread_surveillance_signaux(void *argume Line 121  thread_surveillance_signaux(void *argume
             if ((*s_queue_signaux).pointeur_lecture !=              if ((*s_queue_signaux).pointeur_lecture !=
                     (*s_queue_signaux).pointeur_ecriture)                      (*s_queue_signaux).pointeur_ecriture)
             {              {
                   // Attention : raise() envoit le signal au thread appelant !
                   // kill() l'envoie au processus appelant, donc dans notre
                   // cas à un thread aléatoire du processus, ce qui nous
                   // convient tout à fait puisqu'il s'agit de débloquer les
                   // appels système lents.
   
                 nombre_signaux_envoyes++;                  nombre_signaux_envoyes++;
                 raise(SIGALRM);                  kill(getpid(), SIGALRM);
             }              }
   
 #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)  #           if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV)
Line 1604  deverrouillage_gestionnaire_signaux(stru Line 1610  deverrouillage_gestionnaire_signaux(stru
     return;      return;
 }  }
   
   /*
   ================================================================================
     Fonctions de gestion des signaux dans les threads.
   
     Lorsqu'un processus reçoit un signal, il appelle le gestionnaire de signal
     associé qui ne fait qu'envoyer au travers de write() le signal
     reçus dans un pipe. Un second thread est bloqué sur ce pipe et
     effectue le traitement adéquat pour le signal donné.
   ================================================================================
   */
   
 #define test_signal(signal) \  #define test_signal(signal) \
     if (signal_test == SIGTEST) { signal_test = signal; return; }      if (signal_test == SIGTEST) { signal_test = signal; return; }
   
   static int          pipe_signaux;
   
   logical1
   lancement_thread_signaux(struct_processus *s_etat_processus)
   {
       pthread_attr_t                  attributs;
   
       void                            *argument;
   
       if (pipe((*s_etat_processus).pipe_signaux) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(d_erreur);
       }
   
       pipe_signaux = (*s_etat_processus).pipe_signaux[1];
   
       if (pthread_attr_init(&attributs) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(d_erreur);
       }
   
       if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(d_erreur);
       }
   
       argument = (*s_etat_processus).pipe_signaux;
   
       if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs,
               thread_signaux, argument) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(d_erreur);
       }
   
       return(d_absence_erreur);
   }
   
   logical1
   arret_thread_signaux(struct_processus *s_etat_processus)
   {
       unsigned char       signal;
       ssize_t             n;
   
       signal = (unsigned char ) (rpl_sigmax & 0xFF);
   
       do
       {
           n = write((*s_etat_processus).pipe_signaux[1], &signal, sizeof(signal));
   
           if (n < 0)
           {
               return(d_erreur);
           }
       } while(n != 1);
   
       pthread_join((*s_etat_processus).thread_signaux, NULL);
   
       close((*s_etat_processus).pipe_signaux[0]);
       close((*s_etat_processus).pipe_signaux[1]);
   
       return(d_absence_erreur);
   }
   
   void *
   thread_signaux(void *argument)
   {
       int                     *pipe;
   
       sigset_t                masque;
   
       struct pollfd           fds;
   
       unsigned char           signal;
   
       pipe = (int *) argument;
       fds.fd = pipe[0];
       fds.events = POLLIN;
       fds.revents = 0;
   
       sigfillset(&masque);
       pthread_sigmask(SIG_BLOCK, &masque, NULL);
   
       do
       {
           if (poll(&fds, 1, -1) == -1)
           {
               pthread_exit(NULL);
           }
   
           read(fds.fd, &signal, 1);
   
           if (signal != (0xFF & rpl_sigmax))
           {
               envoi_signal_processus(getpid(), signal);
               // Un signal SIGALRM est envoyé par le thread de surveillance
               // des signaux jusqu'à ce que les signaux soient tous traités.
           }
       } while(signal != (0xFF & rpl_sigmax));
   
       pthread_exit(NULL);
   }
   
 // Récupération des signaux  // Récupération des signaux
 // - SIGINT  (arrêt au clavier)  // - SIGINT  (arrêt au clavier)
 // - SIGTERM (signal d'arrêt en provenance du système)  // - SIGTERM (signal d'arrêt en provenance du système)
Line 1614  deverrouillage_gestionnaire_signaux(stru Line 1737  deverrouillage_gestionnaire_signaux(stru
 void  void
 interruption1(int signal)  interruption1(int signal)
 {  {
       unsigned char       signal_tronque;
   
     test_signal(signal);      test_signal(signal);
   
     switch(signal)      switch(signal)
     {      {
         case SIGINT:          case SIGINT:
             envoi_signal_processus(getpid(), rpl_sigint);              signal_tronque = (unsigned char) (rpl_sigint & 0xFF);
               write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             break;              break;
   
         case SIGTERM:          case SIGTERM:
             envoi_signal_processus(getpid(), rpl_sigterm);              signal_tronque = (unsigned char) (rpl_sigterm & 0xFF);
               write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             break;              break;
   
         case SIGUSR1:          case SIGUSR1:
             envoi_signal_processus(getpid(), rpl_sigalrm);              signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
               write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
             break;              break;
   
         default:          default:
Line 1638  interruption1(int signal) Line 1766  interruption1(int signal)
     return;      return;
 }  }
   
   // Récupération des signaux
   // - SIGFSTP
   //
   // ATTENTION :
   // Le signal SIGFSTP provient de la mort du processus de contrôle.
   // Sous certains systèmes (Linux...), la mort du terminal de contrôle
   // se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres
   // (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo
   // non initialisée (pointeur NULL) issue de TERMIO.
   
   void
   interruption2(int signal)
   {
       unsigned char       signal_tronque;
   
       test_signal(signal);
   
       signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
       write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
       return;
   }
   
   void
   interruption3(int signal)
   {
       // Si on passe par ici, c'est qu'il est impossible de récupérer
       // l'erreur d'accès à la mémoire. On sort donc du programme quitte à
       // ce qu'il reste des processus orphelins.
   
       unsigned char       message_1[] = "+++System : Uncaught access violation\n"
                                   "+++System : Aborting !\n";
       unsigned char       message_2[] = "+++System : Stack overflow\n"
                                   "+++System : Aborting !\n";
   
       test_signal(signal);
   
       if (pid_processus_pere == getpid())
       {
           kill(pid_processus_pere, SIGUSR1);
       }
   
       if (signal != SIGUSR2)
       {
           write(STDERR_FILENO, message_1, strlen(message_1));
       }
       else
       {
           write(STDERR_FILENO, message_2, strlen(message_2));
       }
   
       _exit(EXIT_FAILURE);
   }
   
   // Récupération des signaux
   // - SIGHUP
   
   void
   interruption4(int signal)
   {
       unsigned char       signal_tronque;
   
       test_signal(signal);
   
       signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
       write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
       return;
   }
   
   // Récupération des signaux
   // - SIGPIPE
   
   void
   interruption5(int signal)
   {
       unsigned char       message[] = "+++System : SIGPIPE\n"
                                   "+++System : Aborting !\n";
       unsigned char       signal_tronque;
   
       test_signal(signal);
   
       if (pid_processus_pere == getpid())
       {
           signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
           write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
       }
   
       write(STDERR_FILENO, message, strlen(message));
       return;
   }
   
 inline static void  inline static void
 signal_alrm(struct_processus *s_etat_processus, pid_t pid)  signal_alrm(struct_processus *s_etat_processus, pid_t pid)
 {  {
Line 1807  signal_int(struct_processus *s_etat_proc Line 2025  signal_int(struct_processus *s_etat_proc
     return;      return;
 }  }
   
 // Récupération des signaux  
 // - SIGFSTP  
 //  
 // ATTENTION :  
 // Le signal SIGFSTP provient de la mort du processus de contrôle.  
 // Sous certains systèmes (Linux...), la mort du terminal de contrôle  
 // se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres  
 // (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo  
 // non initialisée (pointeur NULL) issue de TERMIO.  
   
 void  
 interruption2(int signal)  
 {  
     test_signal(signal);  
     envoi_signal_processus(getpid(), rpl_sigtstp);  
     return;  
 }  
   
 static inline void  static inline void
 signal_tstp(struct_processus *s_etat_processus, pid_t pid)  signal_tstp(struct_processus *s_etat_processus, pid_t pid)
 {  {
Line 1872  signal_tstp(struct_processus *s_etat_pro Line 2072  signal_tstp(struct_processus *s_etat_pro
     return;      return;
 }  }
   
 void  
 interruption3(int signal)  
 {  
     // Si on passe par ici, c'est qu'il est impossible de récupérer  
     // l'erreur d'accès à la mémoire. On sort donc du programme quitte à  
     // ce qu'il reste des processus orphelins.  
   
     unsigned char       message_1[] = "+++System : Uncaught access violation\n"  
                                 "+++System : Aborting !\n";  
     unsigned char       message_2[] = "+++System : Stack overflow\n"  
                                 "+++System : Aborting !\n";  
   
     test_signal(signal);  
   
     if (pid_processus_pere == getpid())  
     {  
         kill(pid_processus_pere, SIGUSR1);  
     }  
   
     if (signal != SIGUSR2)  
     {  
         write(STDERR_FILENO, message_1, strlen(message_1));  
     }  
     else  
     {  
         write(STDERR_FILENO, message_2, strlen(message_2));  
     }  
   
     _exit(EXIT_FAILURE);  
 }  
   
   
 static void  static void
 sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)  sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
 {  {
Line 1921  sortie_interruption_depassement_pile(voi Line 2089  sortie_interruption_depassement_pile(voi
     return;      return;
 }  }
   
   
 void  void
 interruption_depassement_pile(int urgence, stackoverflow_context_t scp)  interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
 {  {
Line 1939  interruption_depassement_pile(int urgenc Line 2106  interruption_depassement_pile(int urgenc
     return;      return;
 }  }
   
   
 int  int
 interruption_violation_access(void *adresse_fautive, int gravite)  interruption_violation_access(void *adresse_fautive, int gravite)
 {  {
Line 2115  signal_inject(struct_processus *s_etat_p Line 2281  signal_inject(struct_processus *s_etat_p
     return;      return;
 }  }
   
 // Récupération des signaux  
 // - SIGPIPE  
   
 void  
 interruption5(int signal)  
 {  
     unsigned char       message[] = "+++System : SIGPIPE\n"  
                                 "+++System : Aborting !\n";  
   
     test_signal(signal);  
   
     if (pid_processus_pere == getpid())  
     {  
         envoi_signal_processus(pid_processus_pere, rpl_sigalrm);  
     }  
   
     write(STDERR_FILENO, message, strlen(message));  
     return;  
 }  
   
 static inline void  static inline void
 signal_urg(struct_processus *s_etat_processus, pid_t pid)  signal_urg(struct_processus *s_etat_processus, pid_t pid)
Line 2228  signal_abort(struct_processus *s_etat_pr Line 2375  signal_abort(struct_processus *s_etat_pr
     return;      return;
 }  }
   
 // Récupération des signaux  
 // - SIGHUP  
   
 void  
 interruption4(int signal)  
 {  
     test_signal(signal);  
     envoi_signal_processus(getpid(), rpl_sighup);  
     return;  
 }  
   
 static inline void  static inline void
 signal_hup(struct_processus *s_etat_processus, pid_t pid)  signal_hup(struct_processus *s_etat_processus, pid_t pid)
Removed from v.1.105  
changed lines
  Added in v.1.106

CVSweb interface <joel.bertrand@systella.fr>