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

Diff for /rpl/src/interruptions.c between versions 1.68 and 1.69

version 1.68, 2011/09/14 17:55:59 version 1.69, 2011/09/15 17:51:43
Line 59  static volatile struct_liste_chainee_vol Line 59  static volatile struct_liste_chainee_vol
         = NULL;          = NULL;
 static volatile int                             code_erreur_gsl = 0;  static volatile int                             code_erreur_gsl = 0;
   
   static unsigned char                            *racine_segment;
   
 static pthread_mutex_t                          mutex_interruptions  static pthread_mutex_t                          mutex_interruptions
         = PTHREAD_MUTEX_INITIALIZER;          = PTHREAD_MUTEX_INITIALIZER;
   
Line 1832  void INTERRUPTION3_A_FIXER() Line 1834  void INTERRUPTION3_A_FIXER()
 static inline void  static inline void
 signal_start(struct_processus *s_etat_processus, pid_t pid)  signal_start(struct_processus *s_etat_processus, pid_t pid)
 {  {
     (*s_etat_processus).demarrage_fils = d_vrai;      struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
       {
           (*s_etat_processus).demarrage_fils = d_vrai;
       }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
           if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
           {
               envoi_signal_contexte(s_thread_principal, rpl_sigstart);
           }
       }
   
       deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
Line 1841  signal_start(struct_processus *s_etat_pr Line 1862  signal_start(struct_processus *s_etat_pr
 static inline void  static inline void
 signal_cont(struct_processus *s_etat_processus, pid_t pid)  signal_cont(struct_processus *s_etat_processus, pid_t pid)
 {  {
     (*s_etat_processus).redemarrage_processus = d_vrai;      struct_processus        *s_thread_principal;
   
       verrouillage_gestionnaire_signaux(s_etat_processus);
   
       if (pid == getpid())
       {
           (*s_etat_processus).redemarrage_processus = d_vrai;
       }
       else
       {
           // Envoi d'un signal au thread maître du groupe.
   
           if ((s_thread_principal = recherche_thread_principal(getpid()))
                   != NULL)
           {
               envoi_signal_contexte(s_thread_principal, rpl_sigcont);
           }
       }
   
       deverrouillage_gestionnaire_signaux(s_etat_processus);
     return;      return;
 }  }
   
Line 1865  signal_stop(struct_processus *s_etat_pro Line 1905  signal_stop(struct_processus *s_etat_pro
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             printf("[%d] RPL/SIGFSTOP (thread %llu)\n", (int) getpid(),              printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
                     (unsigned long long) pthread_self());                      (unsigned long long) pthread_self());
             fflush(stdout);              fflush(stdout);
         }          }
Line 1888  signal_stop(struct_processus *s_etat_pro Line 1928  signal_stop(struct_processus *s_etat_pro
     }      }
     else      else
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  
                 == NULL)  
         {  
             deverrouillage_gestionnaire_signaux(s_etat_processus);  
             return;  
         }  
   
         // Envoi d'un signal au thread maître du groupe.          // Envoi d'un signal au thread maître du groupe.
   
         if ((s_thread_principal = recherche_thread_principal(getpid()))          if ((s_thread_principal = recherche_thread_principal(getpid()))
Line 2026  signal_abort(struct_processus *s_etat_pr Line 2059  signal_abort(struct_processus *s_etat_pr
   
         (*s_etat_processus).arret_depuis_abort = -1;          (*s_etat_processus).arret_depuis_abort = -1;
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)  
         {  
             printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),  
                     (unsigned long long) pthread_self());  
             fflush(stdout);  
         }  
   
         /*          /*
          * var_globale_traitement_retarde_stop :           * var_globale_traitement_retarde_stop :
          *  0 -> traitement immédiat           *  0 -> traitement immédiat
Line 2051  signal_abort(struct_processus *s_etat_pr Line 2077  signal_abort(struct_processus *s_etat_pr
     }      }
     else      else
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  
                 == NULL)  
         {  
             deverrouillage_gestionnaire_signaux(s_etat_processus);  
             return;  
         }  
   
         (*s_etat_processus).arret_depuis_abort = -1;          (*s_etat_processus).arret_depuis_abort = -1;
   
         // Envoi d'un signal au thread maître du groupe.          // Envoi d'un signal au thread maître du groupe.
Line 2114  signal_hup(struct_processus *s_etat_proc Line 2133  signal_hup(struct_processus *s_etat_proc
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
                 (unsigned long long) pthread_self());                  (unsigned long long) pthread_self());
         fflush(stdout);          fflush(stdout);
     }      }
Line 2153  static inline void Line 2172  static inline void
 envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,  envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal,
         pid_t pid_source)          pid_t pid_source)
 {  {
     unsigned char       message[] = "+++System : Spurious signa !\n";  uprintf("Signal : %d\n", signal);
   
     switch(signal)      switch(signal)
     {      {
           case rpl_signull:
               break;
   
         case rpl_sigint:          case rpl_sigint:
             signal_int(s_etat_processus, pid_source);              signal_int(s_etat_processus, pid_source);
             break;              break;
Line 2206  envoi_interruptions(struct_processus *s_ Line 2227  envoi_interruptions(struct_processus *s_
             break;              break;
   
         default:          default:
             write(STDERR_FILENO, message, strlen(message));              if ((*s_etat_processus).langue == 'F')
               {
                   printf("+++System : Spurious signal (%d) !\n", signal);
               }
               else
               {
                   printf("+++System : Signal inconnu (%d) !\n", signal);
               }
   
             break;              break;
     }      }
   
Line 2238  scrutation_interruptions(struct_processu Line 2267  scrutation_interruptions(struct_processu
             (*s_queue_signaux).pointeur_lecture =              (*s_queue_signaux).pointeur_lecture =
                     ((*s_queue_signaux).pointeur_lecture + 1)                      ((*s_queue_signaux).pointeur_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   uprintf("Traité\n");
         }          }
   
         pthread_mutex_unlock(&((*s_queue_signaux).mutex));          pthread_mutex_unlock(&((*s_queue_signaux).mutex));
Line 2267  scrutation_interruptions(struct_processu Line 2297  scrutation_interruptions(struct_processu
     return;      return;
 }  }
   
   /*
   ================================================================================
     Fonction renvoyant le nom du segment de mémoire partagée en fonction
     du pid du processus.
   ================================================================================
     Entrée : Chemin absolue servant de racine, pid du processus
   --------------------------------------------------------------------------------
     Sortie : NULL ou nom du segment
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
   static unsigned char *
   nom_segment(unsigned char *chemin, pid_t pid)
   {
       unsigned char               *fichier;
   
   #   ifdef IPCS_SYSV // !POSIX
   #       ifndef OS2 // !OS2
   
               if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
                       sizeof(unsigned char))) == NULL)
               {
                   return(NULL);
               }
   
               sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
   #       else // OS2
               if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   return(NULL);
               }
   
               sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid);
   #       endif // OS2
   #   else // POSIX
   
           if ((fichier = malloc((1 + 256 + 1) *
                   sizeof(unsigned char))) == NULL)
           {
               return(NULL);
           }
   
           sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
   #   endif
   
       return(fichier);
   }
   
   
 int  int
 envoi_signal_processus(pid_t pid, enum signaux_rpl signal)  envoi_signal_processus(pid_t pid, enum signaux_rpl signal)
 {  {
       int                             segment;
   
       struct_queue_signaux            *queue;
   
       unsigned char                   *nom;
   
     // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en      // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
     // mémoire puis d'y inscrire le signal à traiter.      // mémoire puis d'y inscrire le signal à traiter.
   
       if (pid == getpid())
       {
           // Le signal est envoyé au même processus.
   
           if (s_queue_signaux == NULL)
           {
               return(1);
           }
   
           if (pthread_mutex_lock(&((*s_queue_signaux).mutex)) != 0)
           {
               return(1);
           }
   
           (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   .pid = pid;
           (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
                   .signal = signal;
   
           (*s_queue_signaux).pointeur_ecriture =
                   ((*s_queue_signaux).pointeur_ecriture + 1)
                   % LONGUEUR_QUEUE_SIGNAUX;
   
           if (pthread_mutex_unlock(&((*s_queue_signaux).mutex)) != 0)
           {
               return(1);
           }
       }
       else
       {
           // Le signal est envoyé depuis un processus distinct.
   
           if ((nom = nom_segment(racine_segment, pid)) == NULL)
           {
               return(1);
           }
   
           if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
           {
               free(nom);
               return(1);
           }
   
           free(nom);
   
           if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                   PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
                   MAP_FAILED)
           {
               close(segment);
               return(1);
           }
   
   uprintf("Lock\n");
           if (pthread_mutex_lock(&((*queue).mutex)) != 0)
           {
   uprintf("Unlock (error)\n");
               return(1);
           }
   
           (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
           (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
   
           (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                   % LONGUEUR_QUEUE_SIGNAUX;
   
   uprintf("Unlock\n");
           if (pthread_mutex_unlock(&((*queue).mutex)) != 0)
           {
   uprintf("Unlock failed\n");
               return(1);
           }
   
           if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
           {
               close(segment);
               return(1);
           }
   
           close(segment);
       }
   
     return(0);      return(0);
 }  }
   
Line 2358  envoi_signal_contexte(struct_processus * Line 2528  envoi_signal_contexte(struct_processus *
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction renvoyant le nom du segment de mémoire partagée en fonction  
   du pid du processus.  
 ================================================================================  
   Entrée : Chemin absolue servant de racine, pid du processus  
 --------------------------------------------------------------------------------  
   Sortie : NULL ou nom du segment  
 --------------------------------------------------------------------------------  
   Effet de bord : Néant  
 ================================================================================  
 */  
   
 static unsigned char *  
 nom_segment(unsigned char *chemin, pid_t pid)  
 {  
     unsigned char               *fichier;  
   
 #   ifdef IPCS_SYSV // !POSIX  
 #       ifndef OS2 // !OS2  
   
             if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *  
                     sizeof(unsigned char))) == NULL)  
             {  
                 return(NULL);  
             }  
   
             sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);  
 #       else // OS2  
             if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))  
                     == NULL)  
             {  
                 return(NULL);  
             }  
   
             sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid);  
 #       endif // OS2  
 #   else // POSIX  
   
         if ((fichier = malloc((1 + 256 + 1) *  
                 sizeof(unsigned char))) == NULL)  
         {  
             return(NULL);  
         }  
   
         sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);  
 #   endif  
   
     return(fichier);  
 }  
   
   
 /*  
 ================================================================================  
   Fonction créant un segment de mémoire partagée destiné à contenir    Fonction créant un segment de mémoire partagée destiné à contenir
   la queue des signaux.    la queue des signaux.
 ================================================================================  ================================================================================
Line 2424  nom_segment(unsigned char *chemin, pid_t Line 2542  nom_segment(unsigned char *chemin, pid_t
 void  void
 creation_queue_signaux(struct_processus *s_etat_processus)  creation_queue_signaux(struct_processus *s_etat_processus)
 {  {
     int                             segment;  
   
     pthread_mutexattr_t             attributs_mutex;      pthread_mutexattr_t             attributs_mutex;
   
     unsigned char                   *nom;      unsigned char                   *nom;
   
       racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;
   
 #   ifndef IPCS_SYSV // POSIX  #   ifndef IPCS_SYSV // POSIX
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,      if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,
Line 2439  creation_queue_signaux(struct_processus Line 2557  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
     if ((segment = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,      if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
             S_IRUSR | S_IWUSR)) == -1)              S_IRUSR | S_IWUSR)) == -1)
     {      {
         free(nom);          free(nom);
Line 2447  creation_queue_signaux(struct_processus Line 2565  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
     if (ftruncate(segment, sizeof(struct_queue_signaux)) == -1)      if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
     {      {
         free(nom);          free(nom);
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2455  creation_queue_signaux(struct_processus Line 2573  creation_queue_signaux(struct_processus
     }      }
   
     s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),      s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
             PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0);              PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
     close(segment);  
   
     if (((void *) s_queue_signaux) == ((void *) -1))      if (((void *) s_queue_signaux) == ((void *) -1))
     {      {
Line 2482  creation_queue_signaux(struct_processus Line 2599  creation_queue_signaux(struct_processus
     (*s_queue_signaux).pointeur_lecture = 0;      (*s_queue_signaux).pointeur_lecture = 0;
     (*s_queue_signaux).pointeur_ecriture = 0;      (*s_queue_signaux).pointeur_ecriture = 0;
   
       if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
 #   else // SystemV  #   else // SystemV
 #   ifndef OS2  #   ifndef OS2
   
Line 2591  liberation_queue_signaux(struct_processu Line 2714  liberation_queue_signaux(struct_processu
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
           close(f_queue_signaux);
 #   endif  #   endif
   
     return;      return;
Line 2637  destruction_queue_signaux(struct_process Line 2762  destruction_queue_signaux(struct_process
         return;          return;
     }      }
   
       // FERMER LE FICHIER
   
     unlink(nom);      unlink(nom);
     free(nom);      free(nom);
   
Line 2648  destruction_queue_signaux(struct_process Line 2775  destruction_queue_signaux(struct_process
         return;          return;
     }      }
   
       // FERMER LE FICHIER
   
 #   endif  #   endif
 #   else // POSIX  #   else // POSIX
   
Line 2663  destruction_queue_signaux(struct_process Line 2792  destruction_queue_signaux(struct_process
         return;          return;
     }      }
   
       close(f_queue_signaux);
   
     if (shm_unlink(nom) != 0)      if (shm_unlink(nom) != 0)
     {      {
         free(nom);          free(nom);
Removed from v.1.68  
changed lines
  Added in v.1.69

CVSweb interface <joel.bertrand@systella.fr>