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

Diff for /rpl/src/interruptions.c between versions 1.180 and 1.193

version 1.180, 2016/07/20 16:23:59 version 1.193, 2017/08/02 14:41:36
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.25    RPL/2 (R) version 4.1.27
   Copyright (C) 1989-2016 Dr. BERTRAND Joël    Copyright (C) 1989-2017 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 65  thread_surveillance_signaux(void *argume Line 65  thread_surveillance_signaux(void *argume
 {  {
     // Cette fonction est lancée dans un thread créé par processus pour      // Cette fonction est lancée dans un thread créé par processus pour
     // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du      // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du
     // signal SIGALRM. Les processus externes n'envoient plus un signal au      // signal SIGUSR2. Les processus externes n'envoient plus un signal au
     // processus ou au thread à signaler mais positionnent les informations      // processus ou au thread à signaler mais positionnent les informations
     // nécessaires dans la queue des signaux et incrémentent le sémaphore.      // nécessaires dans la queue des signaux et incrémentent le sémaphore.
     // Le sémaphore est décrémenté lorsque le signal est effectivement traité.      // Le sémaphore est décrémenté lorsque le signal est effectivement traité.
Line 93  thread_surveillance_signaux(void *argume Line 93  thread_surveillance_signaux(void *argume
   
         if (sem_wait(semaphore_signalisation) == 0)          if (sem_wait(semaphore_signalisation) == 0)
         {          {
             if (sem_wait(semaphore_arret_signalisation) != 0)              while((ios = sem_wait(semaphore_arret_signalisation)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  if (errno != EINTR)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                   }
             }              }
   
             if ((*s_queue_signaux).requete_arret == d_vrai)              if ((*s_queue_signaux).requete_arret == d_vrai)
Line 132  thread_surveillance_signaux(void *argume Line 135  thread_surveillance_signaux(void *argume
                 // appels système lents.                  // appels système lents.
   
                 nombre_signaux_envoyes++;                  nombre_signaux_envoyes++;
                 kill(getpid(), SIGALRM);                  kill(getpid(), SIGUSR2);
                 sched_yield();                  sched_yield();
             }              }
   
Line 165  thread_surveillance_signaux(void *argume Line 168  thread_surveillance_signaux(void *argume
                     {                      {
                         nombre_signaux_envoyes++;                          nombre_signaux_envoyes++;
                         pthread_kill((*((struct_thread *)                          pthread_kill((*((struct_thread *)
                                 (*l_element_courant).donnee)).tid, SIGALRM);                                  (*l_element_courant).donnee)).tid, SIGUSR2);
                         sched_yield();                          sched_yield();
                     }                      }
   
Line 1626  thread_signaux(void *argument) Line 1629  thread_signaux(void *argument)
         if (signal != (0xFF & rpl_sigmax))          if (signal != (0xFF & rpl_sigmax))
         {          {
             envoi_signal_processus(getpid(), signal, d_faux);              envoi_signal_processus(getpid(), signal, d_faux);
             // Un signal SIGALRM est envoyé par le thread de surveillance              // Un signal SIGUSR2 est envoyé par le thread de surveillance
             // des signaux jusqu'à ce que les signaux soient tous traités.              // des signaux jusqu'à ce que les signaux soient tous traités.
         }          }
     } while(signal != (0xFF & rpl_sigmax));      } while(signal != (0xFF & rpl_sigmax));
Line 1682  interruption1(int signal) Line 1685  interruption1(int signal)
             break;              break;
   
         default:          default:
             // SIGALRM              // SIGUSR2
             break;              break;
     }      }
   
Line 2025  sortie_interruption_depassement_pile(voi Line 2028  sortie_interruption_depassement_pile(voi
     return;      return;
 }  }
   
   #ifdef HAVE_SIGSEGV_RECOVERY
 void  void
 interruption_depassement_pile(int urgence, stackoverflow_context_t scp)  interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
 {  {
Line 2041  interruption_depassement_pile(int urgenc Line 2045  interruption_depassement_pile(int urgenc
     interruption3(SIGUSR2);      interruption3(SIGUSR2);
     return;      return;
 }  }
   #endif
   
 int  int
 interruption_violation_access(void *adresse_fautive, int gravite)  interruption_violation_access(void *adresse_fautive, int gravite)
Line 2054  interruption_violation_access(void *adre Line 2059  interruption_violation_access(void *adre
     {      {
         // Il peut s'agir d'un dépassement de pile.          // Il peut s'agir d'un dépassement de pile.
   
         sigsegv_leave_handler(sortie_interruption_depassement_pile,  #       ifdef HAVE_SIGSEGV_RECOVERY
                 (void *) &routine_recursive, NULL, NULL);              sigsegv_leave_handler(sortie_interruption_depassement_pile,
                       (void *) &routine_recursive, NULL, NULL);
   #       else
               sortie_interruption_depassement_pile((void *) &routine_recursive,
                       NULL, NULL);
   #       endif
     }      }
   
     // On est dans une bonne vieille violation d'accès. On essaie      // On est dans une bonne vieille violation d'accès. On essaie
Line 3407  creation_queue_signaux(struct_processus Line 3417  creation_queue_signaux(struct_processus
 #       endif  #       endif
 #   endif  #   endif
   
       (*s_queue_signaux).controle = getpid();
   
       if (lancement_thread_signaux(s_etat_processus) == d_erreur)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     // Lancement du thread de récupération des signaux.      // Lancement du thread de récupération des signaux.
   
     if (pthread_attr_init(&attributs) != 0)      if (pthread_attr_init(&attributs) != 0)
Line 3435  creation_queue_signaux(struct_processus Line 3453  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
     (*s_queue_signaux).controle = getpid();  
   
 #   ifndef IPCS_SYSV  #   ifndef IPCS_SYSV
     if (msync(s_queue_signaux, sizeof(s_queue_signaux),      if (msync(s_queue_signaux, sizeof(s_queue_signaux),
             MS_ASYNC | MS_INVALIDATE) != 0)              MS_ASYNC | MS_INVALIDATE) != 0)
Line 3446  creation_queue_signaux(struct_processus Line 3462  creation_queue_signaux(struct_processus
     }      }
 #           endif  #           endif
   
     if (lancement_thread_signaux(s_etat_processus) == d_erreur)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     return;      return;
 }  }
   
Line 3519  destruction_queue_signaux(struct_process Line 3529  destruction_queue_signaux(struct_process
         unsigned char       *nom;          unsigned char       *nom;
 #   endif  #   endif
   
     sem_wait(semaphore_arret_signalisation);      // On dépile les interruptions pour arrêter les SIGUSR2 sur
       // le processus courant.
   
       scrutation_interruptions(s_etat_processus);
   
       while(sem_wait(semaphore_arret_signalisation) != 0)
       {
           if (errno != EINTR)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
       }
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
 #   ifndef IPCS_SYSV  #   ifndef IPCS_SYSV
Line 3531  destruction_queue_signaux(struct_process Line 3554  destruction_queue_signaux(struct_process
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
     pthread_join((*s_queue_signaux).thread_signaux, NULL);  
       if ((*s_queue_signaux).controle == getpid())
       {
           pthread_join((*s_queue_signaux).thread_signaux, NULL);
       }
       else
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
     arret_thread_signaux(s_etat_processus);      arret_thread_signaux(s_etat_processus);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
Removed from v.1.180  
changed lines
  Added in v.1.193

CVSweb interface <joel.bertrand@systella.fr>