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

Diff for /rpl/src/interruptions.c between versions 1.96 and 1.99

version 1.96, 2012/05/17 17:06:18 version 1.99, 2012/07/04 13:02:49
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.8    RPL/2 (R) version 4.1.9
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 88  thread_surveillance_signaux(void *argume Line 88  thread_surveillance_signaux(void *argume
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
 #       ifndef SEMAPHORES_NOMMES  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
         if (sem_wait(&(*s_queue_signaux).signalisation) == 0)          if (sem_wait(&(*s_queue_signaux).signalisation) == 0)
 #       else  #       else
         if(sem_wait(semaphore_signalisation) == 0)          if(sem_wait(semaphore_signalisation) == 0)
Line 99  thread_surveillance_signaux(void *argume Line 99  thread_surveillance_signaux(void *argume
                 break;                  break;
             }              }
   
   #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_post(&(*s_queue_signaux).signalisation);
   #           else
               sem_post(semaphore_signalisation);
   #           endif
   
             nombre_signaux_envoyes = 0;              nombre_signaux_envoyes = 0;
               sched_yield();
   
             // Dans un premier temps, on verrouille la queue des signaux              // Dans un premier temps, on verrouille la queue des signaux
             // affectée au processus courant pour vérifier s'il y a quelque              // affectée au processus courant pour vérifier s'il y a quelque
             // chose à traiter.              // chose à traiter.
   
 #           ifndef SEMAPHORES_NOMMES  #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             sem_wait(&(*s_queue_signaux).semaphore);              sem_wait(&(*s_queue_signaux).semaphore);
 #           else  #           else
             sem_wait(semaphore_queue_signaux);              sem_wait(semaphore_queue_signaux);
Line 118  thread_surveillance_signaux(void *argume Line 125  thread_surveillance_signaux(void *argume
                 raise(SIGALRM);                  raise(SIGALRM);
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             sem_post(&(*s_queue_signaux).semaphore);              sem_post(&(*s_queue_signaux).semaphore);
 #           else  #           else
             sem_post(semaphore_queue_signaux);              sem_post(semaphore_queue_signaux);
Line 310  retrait_thread(struct_processus *s_etat_ Line 317  retrait_thread(struct_processus *s_etat_
         return;          return;
     }      }
   
       // Le thread ne peut plus traiter de signaux explicites. Il convient
       // alors de corriger le sémaphore pour annuler les signaux en attente.
   
       while((*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus)
               .pointeur_signal_ecriture != (*(*((struct_thread *)
               (*l_element_courant).donnee)).s_etat_processus)
               .pointeur_signal_lecture)
       {
   #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
           sem_wait(&((*s_queue_signaux).signalisation));
   #       else
           sem_wait(semaphore_signalisation);
   #       endif
   
           (*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus)
                   .pointeur_signal_lecture = ((*(*((struct_thread *)
                   (*l_element_courant).donnee)).s_etat_processus)
                   .pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX;
       }
   
     free((void *) (*l_element_courant).donnee);      free((void *) (*l_element_courant).donnee);
     free((struct_liste_chainee_volatile *) l_element_courant);      free((struct_liste_chainee_volatile *) l_element_courant);
   
Line 1595  deverrouillage_gestionnaire_signaux(stru Line 1622  deverrouillage_gestionnaire_signaux(stru
     if (signal_test == SIGTEST) { signal_test = signal; return; }      if (signal_test == SIGTEST) { signal_test = signal; return; }
   
 // 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)
   
 void  void
Line 1674  inline static void Line 1701  inline static void
 signal_term(struct_processus *s_etat_processus, pid_t pid)  signal_term(struct_processus *s_etat_processus, pid_t pid)
 {  {
     struct_processus        *s_thread_principal;      struct_processus        *s_thread_principal;
     volatile sig_atomic_t   exclusion = 0;      pthread_mutex_t         exclusion = PTHREAD_MUTEX_INITIALIZER;
   
     verrouillage_gestionnaire_signaux(s_etat_processus);      verrouillage_gestionnaire_signaux(s_etat_processus);
   
Line 1696  signal_term(struct_processus *s_etat_pro Line 1723  signal_term(struct_processus *s_etat_pro
         {          {
             (*s_etat_processus).var_volatile_traitement_sigint = -1;              (*s_etat_processus).var_volatile_traitement_sigint = -1;
   
             while(exclusion == 1);              pthread_mutex_lock(&exclusion);
             exclusion = 1;  
   
             if ((*s_etat_processus).var_volatile_requete_arret == -1)              if ((*s_etat_processus).var_volatile_requete_arret == -1)
             {              {
                 deverrouillage_gestionnaire_signaux(s_etat_processus);                  deverrouillage_gestionnaire_signaux(s_etat_processus);
                 exclusion = 0;                  pthread_mutex_unlock(&exclusion);
                 return;                  return;
             }              }
   
             (*s_etat_processus).var_volatile_requete_arret = -1;              (*s_etat_processus).var_volatile_requete_arret = -1;
             (*s_etat_processus).var_volatile_alarme = -1;              (*s_etat_processus).var_volatile_alarme = -1;
   
             exclusion = 0;              pthread_mutex_unlock(&exclusion);
         }          }
     }      }
     else      else
Line 2371  scrutation_interruptions(struct_processu Line 2397  scrutation_interruptions(struct_processu
     // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à      // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à
     // écrire.      // écrire.
   
 #   ifndef SEMAPHORES_NOMMES  #   if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
         if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)          if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
 #   else  #   else
         if (sem_trywait(semaphore_queue_signaux) == 0)          if (sem_trywait(semaphore_queue_signaux) == 0)
Line 2391  scrutation_interruptions(struct_processu Line 2417  scrutation_interruptions(struct_processu
                     ((*s_queue_signaux).pointeur_lecture + 1)                      ((*s_queue_signaux).pointeur_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
 #           ifndef SEMAPHORES_NOMMES  #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             sem_wait(&((*s_queue_signaux).signalisation));              sem_wait(&((*s_queue_signaux).signalisation));
 #           else  #           else
             sem_wait(semaphore_signalisation);              sem_wait(semaphore_signalisation);
 #           endif  #           endif
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             sem_post(&((*s_queue_signaux).semaphore));              sem_post(&((*s_queue_signaux).semaphore));
 #       else  #       else
             sem_post(semaphore_queue_signaux);              sem_post(semaphore_queue_signaux);
Line 2422  scrutation_interruptions(struct_processu Line 2448  scrutation_interruptions(struct_processu
                     ((*s_etat_processus).pointeur_signal_lecture + 1)                      ((*s_etat_processus).pointeur_signal_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
 #           ifndef SEMAPHORES_NOMMES  #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             sem_wait(&((*s_queue_signaux).signalisation));              sem_wait(&((*s_queue_signaux).signalisation));
 #           else  #           else
             sem_wait(semaphore_signalisation);              sem_wait(semaphore_signalisation);
Line 2509  envoi_signal_processus(pid_t pid, enum s Line 2535  envoi_signal_processus(pid_t pid, enum s
 #   ifndef IPCS_SYSV  #   ifndef IPCS_SYSV
 #       ifdef SEMAPHORES_NOMMES  #       ifdef SEMAPHORES_NOMMES
             sem_t                   *semaphore;              sem_t                   *semaphore;
               sem_t                   *signalisation;
 #       endif  #       endif
 #   else  #   else
 #       ifndef OS2  #       ifndef OS2
Line 2533  envoi_signal_processus(pid_t pid, enum s Line 2560  envoi_signal_processus(pid_t pid, enum s
             return(1);              return(1);
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)              while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
 #       else  #       else
             while(sem_wait(semaphore_queue_signaux) != 0)              while(sem_wait(semaphore_queue_signaux) != 0)
Line 2554  envoi_signal_processus(pid_t pid, enum s Line 2581  envoi_signal_processus(pid_t pid, enum s
                 ((*s_queue_signaux).pointeur_ecriture + 1)                  ((*s_queue_signaux).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
 #       ifndef SEMAPHORES_NOMMES  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
             if (sem_post(&((*s_queue_signaux).semaphore)) != 0)              if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
 #       else  #       else
             if (sem_post(semaphore_queue_signaux) != 0)              if (sem_post(semaphore_queue_signaux) != 0)
Line 2562  envoi_signal_processus(pid_t pid, enum s Line 2589  envoi_signal_processus(pid_t pid, enum s
         {          {
             return(1);              return(1);
         }          }
   
   #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               if (sem_post(&((*s_queue_signaux).signalisation)) != 0)
   #       else
               if (sem_post(semaphore_signalisation) != 0)
   #       endif
           {
               return(1);
           }
     }      }
     else      else
     {      {
Line 2648  envoi_signal_processus(pid_t pid, enum s Line 2684  envoi_signal_processus(pid_t pid, enum s
                     return(1);                      return(1);
                 }                  }
   
                   if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
                           == SEM_FAILED)
                   {
                       return(1);
                   }
   
                 while(sem_wait(semaphore) != 0)                  while(sem_wait(semaphore) != 0)
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
                     {                      {
                         sem_close(semaphore);                          sem_close(semaphore);
                           sem_close(signalisation);
                         return(1);                          return(1);
                     }                      }
                 }                  }
Line 2679  envoi_signal_processus(pid_t pid, enum s Line 2722  envoi_signal_processus(pid_t pid, enum s
                 {                  {
                     return(1);                      return(1);
                 }                  }
   
                   if (sem_post(&((*queue).signalisation)) != 0)
                   {
                       return(1);
                   }
 #           else  #           else
                 if (sem_post(semaphore) != 0)                  if (sem_post(semaphore) != 0)
                 {                  {
                     sem_close(semaphore);                      sem_close(semaphore);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
Line 2690  envoi_signal_processus(pid_t pid, enum s Line 2739  envoi_signal_processus(pid_t pid, enum s
                 {                  {
                     return(1);                      return(1);
                 }                  }
   
                   if (sem_post(signalisation) != 0)
                   {
                       sem_close(signalisation);
                       return(1);
                   }
   
                   if (sem_close(signalisation) != 0)
                   {
                       return(1);
                   }
   
 #           endif  #           endif
   
             if (munmap(queue, sizeof(struct_queue_signaux)) != 0)              if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
Line 2703  envoi_signal_processus(pid_t pid, enum s Line 2764  envoi_signal_processus(pid_t pid, enum s
                 return(1);                  return(1);
             }              }
   
               if (sem_post(&((*queue).signalisation)) != 0)
               {
                   return(1);
               }
   
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if (shmdt(queue) != 0)                  if (shmdt(queue) != 0)
                 {                  {
Line 2714  envoi_signal_processus(pid_t pid, enum s Line 2780  envoi_signal_processus(pid_t pid, enum s
 #       endif  #       endif
     }      }
   
     kill(pid, SIGALRM);  
   
     return(0);      return(0);
 }  }
   
Line 2779  envoi_signal_thread(pthread_t tid, enum Line 2843  envoi_signal_thread(pthread_t tid, enum
         return(1);          return(1);
     }      }
   
     pthread_kill(tid, SIGALRM);  #   if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
       if (sem_post(&((*s_queue_signaux).signalisation)) != 0)
       {
           return(1);
       }
   #   else
       if (sem_post(semaphore_signalisation) != 0)
       {
           return(1);
       }
   #   endif
   
     return(0);      return(0);
 }  }
Line 2797  envoi_signal_contexte(struct_processus * Line 2871  envoi_signal_contexte(struct_processus *
             % LONGUEUR_QUEUE_SIGNAUX;              % LONGUEUR_QUEUE_SIGNAUX;
     pthread_mutex_unlock(&mutex_interruptions);      pthread_mutex_unlock(&mutex_interruptions);
   
     pthread_kill((*s_etat_processus_a_signaler).tid, SIGALRM);  #   if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
       if (sem_post(&((*s_queue_signaux).signalisation)) != 0)
       {
           return(1);
       }
   #   else
       if (sem_post(semaphore_signalisation) != 0)
       {
           return(1);
       }
   #   endif
   
     return(0);      return(0);
 }  }
Line 3058  liberation_queue_signaux(struct_processu Line 3142  liberation_queue_signaux(struct_processu
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
 #   ifndef SEMAPHORES_NOMMES  #   if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
     sem_post(&((*s_queue_signaux).signalisation));      sem_post(&((*s_queue_signaux).signalisation));
 #   else  #   else
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
Line 3117  destruction_queue_signaux(struct_process Line 3201  destruction_queue_signaux(struct_process
         unsigned char       *nom;          unsigned char       *nom;
 #   endif  #   endif
   
       // Incrémenter le sémaphore pour être sûr de le débloquer.
   
       (*s_queue_signaux).requete_arret = d_vrai;
   
   #   if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
       sem_post(&((*s_queue_signaux).signalisation));
   #   else
       sem_post(semaphore_signalisation);
   #   endif
   
       pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
             // Il faut commencer par éliminer le sémaphore.              // Il faut commencer par éliminer le sémaphore.
Removed from v.1.96  
changed lines
  Added in v.1.99

CVSweb interface <joel.bertrand@systella.fr>