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

Diff for /rpl/src/interruptions.c between versions 1.80 and 1.81

version 1.80, 2011/09/20 15:45:53 version 1.81, 2011/09/21 09:09:22
Line 1510  interruption1(int signal) Line 1510  interruption1(int signal)
             envoi_signal_processus(getpid(), rpl_sigterm);              envoi_signal_processus(getpid(), rpl_sigterm);
             break;              break;
   
         case SIGALRM:          case SIGUSR1:
             envoi_signal_processus(getpid(), rpl_sigalrm);              envoi_signal_processus(getpid(), rpl_sigalrm);
             break;              break;
     }      }
Line 1760  interruption3(int signal) Line 1760  interruption3(int signal)
     // l'erreur d'accès à la mémoire. On sort donc du programme quitte à      // l'erreur d'accès à la mémoire. On sort donc du programme quitte à
     // ce qu'il reste des processus orphelins.      // ce qu'il reste des processus orphelins.
   
     unsigned char       message[] = "+++System : Uncaught access violation\n"      unsigned char       message_1[] = "+++System : Uncaught access violation\n"
                                   "+++System : Aborting !\n";
       unsigned char       message_2[] = "+++System : Stack overflow\n"
                                 "+++System : Aborting !\n";                                  "+++System : Aborting !\n";
   
     test_signal(signal);      test_signal(signal);
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         kill(pid_processus_pere, SIGALRM);          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));
     }      }
   
     write(STDERR_FILENO, message, strlen(message));  
     _exit(EXIT_FAILURE);      _exit(EXIT_FAILURE);
 }  }
   
 #if 0  
 // Utiliser libsigsegv  static void
 void INTERRUPTION3_A_FIXER()  sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
 {  {
     pthread_t               thread;      switch((*((volatile int *) arg1)))
       {
           case 1:
               longjmp(contexte_ecriture, -1);
               break;
   
     struct_processus        *s_etat_processus;          case 2:
               longjmp(contexte_impression, -1);
               break;
       }
   
     test_signal(signal);      return;
     verrouillage_gestionnaire_signaux(s_etat_processus);  }
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)  
     {  
         deverrouillage_gestionnaire_signaux(s_etat_processus);  
         return;  
     }  
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)  void
   interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
   {
       if ((urgence == 0) && (routine_recursive != 0))
     {      {
         printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),          // On peut tenter de récupérer le dépassement de pile. Si la variable
                 (unsigned long long) pthread_self());          // 'routine_recursive' est non nulle, on récupère l'erreur.
         fflush(stdout);  
     }  
   
     if ((*s_etat_processus).var_volatile_recursivite == -1)          sigsegv_leave_handler(sortie_interruption_depassement_pile,
     {                  (void *) &routine_recursive, NULL, NULL);
         // Segfault dans un appel de fonction récursive  
         deverrouillage_gestionnaire_signaux(s_etat_processus);  
         longjmp(contexte, -1);  
     }      }
     else  
     {  
         // Segfault dans une routine interne  
         if (strncmp(getenv("LANG"), "fr", 2) == 0)  
         {  
             printf("+++Système : Violation d'accès\n");  
         }  
         else  
         {  
             printf("+++System : Access violation\n");  
         }  
   
         fflush(stdout);      // Ici, la panique est totale et il vaut mieux quitter l'application.
       interruption3(SIGUSR2);
       return;
   }
   
         (*s_etat_processus).compteur_violation_d_acces++;  
   
         if ((*s_etat_processus).compteur_violation_d_acces > 1)  int
         {  interruption_violation_access(void *adresse_fautive, int gravite)
             // On vient de récupérer plus d'une erreur de segmentation  {
             // dans le même processus ou le même thread. L'erreur n'est pas      unsigned char       message[] = "+++System : Trying to catch access "
             // récupérable et on sort autoritairement du programme. Il peut                                  "violation\n";
             // rester des processus orphelins en attente !  
   
             if (strncmp(getenv("LANG"), "fr", 2) == 0)      static int              compteur_erreur = 0;
             {  
                 printf("+++Système : Violation d'accès, tentative de "  
                         "terminaison de la tâche\n");  
                 printf("             (defauts multiples)\n");  
             }  
             else  
             {  
                 printf("+++System : Access violation, trying to kill task "  
                         "(multiple defaults)\n");  
             }  
   
             fflush(stdout);      if ((gravite == 0) && (routine_recursive != 0))
       {
           // Il peut s'agir d'un dépassement de pile.
   
             deverrouillage_gestionnaire_signaux(s_etat_processus);          sigsegv_leave_handler(sortie_interruption_depassement_pile,
             exit(EXIT_FAILURE);                  (void *) &routine_recursive, NULL, NULL);
         }      }
         else  
         {  
             // Première erreur de segmentation. On essaie de terminer  
             // proprement le thread ou le processus. Le signal ne peut être  
             // envoyé que depuis le même processus.  
   
             if (recherche_thread_principal(getpid(), &thread) == d_vrai)      // On est dans une bonne vieille violation d'accès. On essaie
             {      // de fermer au mieux l'application.
                 if (pthread_equal(thread, pthread_self()) != 0)  
                 {  
                     deverrouillage_gestionnaire_signaux(s_etat_processus);  
   
                     if ((*s_etat_processus).pid_processus_pere != getpid())  
                     {  
                         // On est dans le thread principal d'un processus.  
   
                         longjmp(contexte_processus, -1);  
                     }  
                     else  
                     {  
                         // On est dans le thread principal du processus  
                         // père.  
   
                         longjmp(contexte_initial, -1);  
                     }  
                 }  
                 else  
                 {  
                     // On est dans un thread fils d'un thread principal.  
   
                     deverrouillage_gestionnaire_signaux(s_etat_processus);  
                     longjmp(contexte_thread, -1);  
                 }  
             }  
   
             // Là, on ramasse les miettes puisque le thread n'existe plus      compteur_erreur++;
             // dans la base (corruption de la mémoire).  
   
             deverrouillage_gestionnaire_signaux(s_etat_processus);      if (compteur_erreur >= 2)
             longjmp(contexte_initial, -1);      {
         }          // Erreurs multiples, on arrête l'application.
           interruption3(SIGSEGV);
           return(0);
     }      }
   
     deverrouillage_gestionnaire_signaux(s_etat_processus);      write(STDERR_FILENO, message, strlen(message));
     return;  
       if (pid_processus_pere == getpid())
       {
           longjmp(contexte_initial, -1);
           return(1);
       }
       else
       {
           longjmp(contexte_processus, -1);
           return(1);
       }
   
       // On renvoie 0 parce qu'on décline toute responsabilité quant à la
       // suite des événements...
       return(0);
 }  }
 #endif  
   
 // Traitement de rpl_sigstart  // Traitement de rpl_sigstart
   
Removed from v.1.80  
changed lines
  Added in v.1.81

CVSweb interface <joel.bertrand@systella.fr>