Diff for /rpl/src/interruptions.c between versions 1.58 and 1.64

version 1.58, 2011/07/25 07:45:00 version 1.64, 2011/09/04 07:46:08
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.2    RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2011 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 1318  liberation_threads(struct_processus *s_e Line 1318  liberation_threads(struct_processus *s_e
             sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);              sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
 #           endif  #           endif
   
               liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
Line 1990  interruption2(SIGHANDLER_ARGS) Line 1991  interruption2(SIGHANDLER_ARGS)
 void  void
 interruption3(SIGHANDLER_ARGS)  interruption3(SIGHANDLER_ARGS)
 {  {
     pid_t                   pid;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     static int              compteur = 0;  
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux();
Line 2028  interruption3(SIGHANDLER_ARGS) Line 2021  interruption3(SIGHANDLER_ARGS)
         // Segfault dans une routine interne          // Segfault dans une routine interne
         if (strncmp(getenv("LANG"), "fr", 2) == 0)          if (strncmp(getenv("LANG"), "fr", 2) == 0)
         {          {
             printf("+++Système : Violation d'accès (dépassement de pile)\n");              printf("+++Système : Violation d'accès\n");
         }          }
         else          else
         {          {
             printf("+++System : Access violation (stack overflow)\n");              printf("+++System : Access violation\n");
         }          }
   
         fflush(stdout);          fflush(stdout);
   
         compteur++;          (*s_etat_processus).compteur_violation_d_acces++;
   
         if (compteur > 1)          if ((*s_etat_processus).compteur_violation_d_acces > 1)
         {          {
               // 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
               // récupérable et on sort autoritairement du programme. Il peut
               // rester des processus orphelins en attente !
   
               if (strncmp(getenv("LANG"), "fr", 2) == 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);
   
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux();
             exit(EXIT_FAILURE);              exit(EXIT_FAILURE);
         }          }
         else          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)
               {
                   if (pthread_equal(thread, pthread_self()) != 0)
                   {
                       deverrouillage_gestionnaire_signaux();
   
                       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();
                       longjmp(contexte_thread, -1);
                   }
               }
   
               // Là, on ramasse les miettes puisque le thread n'existe plus
               // dans la base (corruption de la mémoire).
   
             deverrouillage_gestionnaire_signaux();              deverrouillage_gestionnaire_signaux();
             longjmp(contexte_initial, -1);              longjmp(contexte_initial, -1);
         }          }
Line 2058  interruption3(SIGHANDLER_ARGS) Line 2106  interruption3(SIGHANDLER_ARGS)
 void  void
 interruption4(SIGHANDLER_ARGS)  interruption4(SIGHANDLER_ARGS)
 {  {
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux();
Line 2166  interruption5(SIGHANDLER_ARGS) Line 2206  interruption5(SIGHANDLER_ARGS)
 void  void
 interruption6(SIGHANDLER_ARGS)  interruption6(SIGHANDLER_ARGS)
 {  {
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux();
Line 2198  interruption6(SIGHANDLER_ARGS) Line 2230  interruption6(SIGHANDLER_ARGS)
 void  void
 interruption7(SIGHANDLER_ARGS)  interruption7(SIGHANDLER_ARGS)
 {  {
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux();
Line 2285  interruption8(SIGHANDLER_ARGS) Line 2309  interruption8(SIGHANDLER_ARGS)
 void  void
 interruption9(SIGHANDLER_ARGS)  interruption9(SIGHANDLER_ARGS)
 {  {
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux();
Line 2330  interruption10(SIGHANDLER_ARGS) Line 2346  interruption10(SIGHANDLER_ARGS)
 {  {
     file                    *fichier;      file                    *fichier;
   
     pid_t                   pid;  
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     unsigned char           nom[8 + 64 + 1];      unsigned char           nom[8 + 64 + 1];
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)      if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)
     {      {
         deverrouillage_gestionnaire_signaux();          deverrouillage_gestionnaire_signaux();

Removed from v.1.58  
changed lines
  Added in v.1.64


CVSweb interface <joel.bertrand@systella.fr>