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

Diff for /rpl/src/interruptions.c between versions 1.30 and 1.50

version 1.30, 2010/08/17 11:59:28 version 1.50, 2011/06/20 17:54:21
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.18    RPL/2 (R) version 4.1.0.prerelease.1
   Copyright (C) 1989-2010 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 183  insertion_thread_surveillance(struct_pro Line 183  insertion_thread_surveillance(struct_pro
         }          }
     }      }
   
     pthread_mutex_lock(&((*s_argument_thread).mutex));      pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references));
     (*s_argument_thread).nombre_references++;      (*s_argument_thread).nombre_references++;
     pthread_mutex_unlock(&((*s_argument_thread).mutex));      pthread_mutex_unlock(&((*s_argument_thread).mutex_nombre_references));
   
     (*l_nouvel_objet).suivant = liste_threads_surveillance;      (*l_nouvel_objet).suivant = liste_threads_surveillance;
     (*l_nouvel_objet).donnee = (void *) s_argument_thread;      (*l_nouvel_objet).donnee = (void *) s_argument_thread;
Line 378  retrait_thread_surveillance(struct_proce Line 378  retrait_thread_surveillance(struct_proce
         (*l_element_precedent).suivant = (*l_element_courant).suivant;          (*l_element_precedent).suivant = (*l_element_courant).suivant;
     }      }
   
     if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)      if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
               != 0)
     {      {
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         sem_post(&semaphore_liste_threads);          sem_post(&semaphore_liste_threads);
Line 400  retrait_thread_surveillance(struct_proce Line 401  retrait_thread_surveillance(struct_proce
   
     if ((*s_argument_thread).nombre_references == 0)      if ((*s_argument_thread).nombre_references == 0)
     {      {
         if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_argument_thread)
                   .mutex_nombre_references)) != 0)
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             sem_post(&semaphore_liste_threads);              sem_post(&semaphore_liste_threads);
Line 415  retrait_thread_surveillance(struct_proce Line 417  retrait_thread_surveillance(struct_proce
         }          }
   
         pthread_mutex_destroy(&((*s_argument_thread).mutex));          pthread_mutex_destroy(&((*s_argument_thread).mutex));
           pthread_mutex_destroy(&((*s_argument_thread).mutex_nombre_references));
         free(s_argument_thread);          free(s_argument_thread);
     }      }
     else      else
     {      {
         if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_unlock(&((*s_argument_thread)
                   .mutex_nombre_references)) != 0)
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             sem_post(&semaphore_liste_threads);              sem_post(&semaphore_liste_threads);
Line 676  liberation_threads(struct_processus *s_e Line 680  liberation_threads(struct_processus *s_e
                 s_argument_thread = (struct_descripteur_thread *)                  s_argument_thread = (struct_descripteur_thread *)
                         (*((struct_liste_chainee *) element_courant)).donnee;                          (*((struct_liste_chainee *) element_courant)).donnee;
   
                 if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)                  if (pthread_mutex_lock(&((*s_argument_thread)
                           .mutex_nombre_references)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     sem_post(&semaphore_liste_threads);                      sem_post(&semaphore_liste_threads);
Line 700  liberation_threads(struct_processus *s_e Line 705  liberation_threads(struct_processus *s_e
                     close((*s_argument_thread)                      close((*s_argument_thread)
                             .pipe_nombre_interruptions_attente[0]);                              .pipe_nombre_interruptions_attente[0]);
   
                     if (pthread_mutex_unlock(&((*s_argument_thread).mutex))                      if (pthread_mutex_unlock(&((*s_argument_thread)
                             != 0)                              .mutex_nombre_references)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         sem_post(&semaphore_liste_threads);                          sem_post(&semaphore_liste_threads);
Line 709  liberation_threads(struct_processus *s_e Line 714  liberation_threads(struct_processus *s_e
                     }                      }
   
                     pthread_mutex_destroy(&((*s_argument_thread).mutex));                      pthread_mutex_destroy(&((*s_argument_thread).mutex));
                       pthread_mutex_destroy(&((*s_argument_thread)
                               .mutex_nombre_references));
   
                     if ((*s_argument_thread).processus_detache == d_faux)                      if ((*s_argument_thread).processus_detache == d_faux)
                     {                      {
Line 723  liberation_threads(struct_processus *s_e Line 730  liberation_threads(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
                     if (pthread_mutex_unlock(&((*s_argument_thread).mutex))                      if (pthread_mutex_unlock(&((*s_argument_thread)
                             != 0)                              .mutex_nombre_references)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         sem_post(&semaphore_liste_threads);                          sem_post(&semaphore_liste_threads);
Line 796  liberation_threads(struct_processus *s_e Line 803  liberation_threads(struct_processus *s_e
                 }                  }
             }              }
   
   #if 0
             for(i = 0; i < (*s_etat_processus).nombre_variables; i++)              for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
             {              {
                 pthread_mutex_trylock(&((*(*s_etat_processus)                  pthread_mutex_trylock(&((*(*s_etat_processus)
Line 815  liberation_threads(struct_processus *s_e Line 823  liberation_threads(struct_processus *s_e
             }              }
   
             free((*s_etat_processus).s_liste_variables);              free((*s_etat_processus).s_liste_variables);
   #endif
   
             for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)              for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
             {              {
Line 1350  liberation_threads(struct_processus *s_e Line 1359  liberation_threads(struct_processus *s_e
         s_argument_thread = (struct_descripteur_thread *)          s_argument_thread = (struct_descripteur_thread *)
                 (*l_element_courant).donnee;                  (*l_element_courant).donnee;
   
         if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             sem_post(&semaphore_liste_threads);              sem_post(&semaphore_liste_threads);
Line 1373  liberation_threads(struct_processus *s_e Line 1383  liberation_threads(struct_processus *s_e
             close((*s_argument_thread).pipe_interruptions[0]);              close((*s_argument_thread).pipe_interruptions[0]);
             close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);              close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);
   
             if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_argument_thread)
                       .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 sem_post(&semaphore_liste_threads);                  sem_post(&semaphore_liste_threads);
Line 1381  liberation_threads(struct_processus *s_e Line 1392  liberation_threads(struct_processus *s_e
             }              }
   
             pthread_mutex_destroy(&((*s_argument_thread).mutex));              pthread_mutex_destroy(&((*s_argument_thread).mutex));
               pthread_mutex_destroy(&((*s_argument_thread)
                       .mutex_nombre_references));
   
             if ((*s_argument_thread).processus_detache == d_faux)              if ((*s_argument_thread).processus_detache == d_faux)
             {              {
Line 1394  liberation_threads(struct_processus *s_e Line 1407  liberation_threads(struct_processus *s_e
         }          }
         else          else
         {          {
             if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_argument_thread)
                       .mutex_nombre_references)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 sem_post(&semaphore_liste_threads);                  sem_post(&semaphore_liste_threads);
Line 1592  verrouillage_gestionnaire_signaux() Line 1606  verrouillage_gestionnaire_signaux()
         // ce que ce soit possible.          // ce que ce soit possible.
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_trywait(&semaphore_liste_threads) == -1)          while(sem_wait(&semaphore_liste_threads) == -1)
 #       else  #       else
         while(sem_trywait(semaphore_liste_threads) == -1)          while(sem_wait(semaphore_liste_threads) == -1)
 #       endif  #       endif
         {          {
             if ((errno != EINTR) && (errno != EAGAIN))              if (errno != EINTR)
             {              {
                 pthread_sigmask(SIG_SETMASK, &oldset, NULL);                  pthread_sigmask(SIG_SETMASK, &oldset, NULL);
   
Line 1613  verrouillage_gestionnaire_signaux() Line 1627  verrouillage_gestionnaire_signaux()
                 BUG(1, uprintf("Lock error !\n"));                  BUG(1, uprintf("Lock error !\n"));
                 return;                  return;
             }              }
   
             sched_yield();  
         }          }
     }      }
   
Line 1724  deverrouillage_gestionnaire_signaux() Line 1736  deverrouillage_gestionnaire_signaux()
     return;      return;
 }  }
   
 #ifdef _BROKEN_SIGINFO  
   
 static int              *fifos;  
 static int              segment;  
 static int              segment_mutexes;  
 static int              longueur_queue;  
 static int              nombre_queues;  
   
 static pthread_mutex_t  *mutexes;  
   
 static unsigned char    *chemin = NULL;  
   
 unsigned char *  
 nom_segment(unsigned char *chemin, pid_t pid)  
 {  
     unsigned char               *fichier;  
   
     if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *  
             sizeof(unsigned char))) == NULL)  
     {  
         return(NULL);  
     }  
   
     sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);  
   
     return(fichier);  
 }  
   
 unsigned char *  
 nom_segment_mutexes(unsigned char *chemin, pid_t pid)  
 {  
     unsigned char               *fichier;  
   
     if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *  
             sizeof(unsigned char))) == NULL)  
     {  
         return(NULL);  
     }  
   
     sprintf(fichier, "%s/RPL-SIGMUTEXES-%d", chemin, (int) pid);  
   
     return(fichier);  
 }  
   
 int  
 queue_de_signal(int signal)  
 {  
     switch(signal)  
     {  
         case SIGINT:  
             return(0);  
         case SIGTSTP:  
             return(1);  
         case SIGCONT:  
             return(2);  
         case SIGURG:  
             return(3);  
         case SIGPIPE:  
             return(4);  
         case SIGALRM:  
             return(5);  
         case SIGFSTOP:  
             return(6);  
         case SIGSTART:  
             return(7);  
         case SIGINJECT:  
             return(8);  
         case SIGABORT:  
             return(9);  
         case SIGFABORT:  
             return(10);  
     }  
   
     return(-1);  
 }  
   
 void  
 creation_fifos_signaux(struct_processus *s_etat_processus)  
 {  
     file                            *desc;  
   
     int                             i;  
   
     key_t                           clef;  
   
     pthread_mutexattr_t             attributs_mutex;  
   
     unsigned char                   *nom;  
   
     /*  
      * Signaux utilisés  
      * SIGINT, SIGTSTP, SIGCONT, SIGURG, SIGPIPE, SIGALRM, SIGFSTOP,  
      * SIGSTART, SIGINJECT, SIGABORT, SIGFABORT  
      */  
   
     // Création d'un segment de données associé au PID du processus courant  
   
     chemin = (*s_etat_processus).chemin_fichiers_temporaires;  
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,  
             getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     /*  
      * Structure d'une queue  
      * 0 : pointeur en lecture sur le premier emplacement libre (int)  
      * 1 : pointeur en écriture sur le premier emplacement à lire (int)  
      * 2 : longueur de la queue (int)  
      * 3 : éléments restants (int)  
      * 4 à 4 + (2) : queue (int)  
      * 5 : mutex  
      */  
   
     nombre_queues = 11;  
     longueur_queue = 256;  
   
     if ((desc = fopen(nom, "w")) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
         return;  
     }  
   
     fclose(desc);  
   
     if ((clef = ftok(nom, 1)) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     free(nom);  
   
     if ((segment = shmget(clef,  
             nombre_queues * (longueur_queue + 4) * sizeof(int),  
             IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     fifos = shmat(segment, NULL, 0);  
   
     if (((void *) fifos) == ((void *) -1))  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     for(i = 0; i < nombre_queues; i++)  
     {  
         fifos[(i * (longueur_queue + 4))] = 0;  
         fifos[(i * (longueur_queue + 4)) + 1] = 0;  
         fifos[(i * (longueur_queue + 4)) + 2] = longueur_queue;  
         fifos[(i * (longueur_queue + 4)) + 3] = longueur_queue;  
     }  
   
     if ((nom = nom_segment_mutexes((*s_etat_processus)  
             .chemin_fichiers_temporaires, getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if ((desc = fopen(nom, "w")) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
         return;  
     }  
   
     fclose(desc);  
   
     if ((clef = ftok(nom, 1)) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     free(nom);  
   
     if ((segment_mutexes = shmget(clef,  
             nombre_queues * sizeof(pthread_mutex_t),  
             IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     mutexes = shmat(segment_mutexes, NULL, 0);  
   
     if (((void *) mutexes) == ((void *) -1))  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     /*  
      * Création et initialisation d'un mutex par queue. Ce mutex n'est pas  
      * dans le premier segment parce qu'il peut y avoir des problèmes  
      * d'alignements sur certaines architectures.  
      */  
   
     pthread_mutexattr_init(&attributs_mutex);  
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);  
   
     for(i = 0; i < nombre_queues; i++)  
     {  
         pthread_mutex_init(&(mutexes[i]), &attributs_mutex);  
     }  
   
     pthread_mutexattr_destroy(&attributs_mutex);  
     return;  
 }  
   
 void  
 liberation_fifos_signaux(struct_processus *s_etat_processus)  
 {  
     if (shmdt(fifos) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if (shmdt(mutexes) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     return;  
 }  
   
 void  void
 destruction_fifos_signaux(struct_processus *s_etat_processus)  interruption1(SIGHANDLER_ARGS)
 {  
     int                 i;  
     unsigned char       *nom;  
   
     if (shmdt(fifos) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if (shmctl(segment, IPC_RMID, 0) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     for(i = 0; i < nombre_queues; i++)  
     {  
         pthread_mutex_destroy(&(mutexes[i]));  
     }  
   
     if (shmdt(mutexes) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if (shmctl(segment_mutexes, IPC_RMID, 0) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if ((nom = nom_segment_mutexes((*s_etat_processus)  
             .chemin_fichiers_temporaires, getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     unlink(nom);  
     free(nom);  
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,  
             getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     unlink(nom);  
     free(nom);  
   
     return;  
 }  
   
 int  
 queue_in(pid_t pid, int signal)  
 {  {
     int             *base;      pid_t                   pid;
     int             *buffer;  
     int             *projection_fifos;  
     int             queue;  
     int             identifiant;  
   
     key_t           clef;  
   
     pthread_mutex_t *projection_mutexes;  
   
     unsigned char   *nom;  
   
     queue = queue_de_signal(signal);  
   
     // Ouverture des projections  
   
     if ((nom = nom_segment(chemin, pid)) == NULL)  
     {  
         return(-1);  
     }  
   
     if ((clef = ftok(nom, 1)) == -1)  
     {  
         free(nom);  
         return(-1);  
     }  
   
     free(nom);  
   
     while((identifiant = shmget(clef,  
             nombre_queues * (longueur_queue + 4) * sizeof(int),  
             S_IRUSR | S_IWUSR)) == -1);  
   
     projection_fifos = shmat(identifiant, NULL, 0);  
   
     if ((nom = nom_segment_mutexes(chemin, pid)) == NULL)  
     {  
         return(-1);  
     }  
   
     if ((clef = ftok(nom, 1)) == -1)  
     {  
         free(nom);  
         return(-1);  
     }  
   
     free(nom);  
   
     while((identifiant = shmget(clef,  
             nombre_queues * sizeof(pthread_mutex_t),  
             S_IRUSR | S_IWUSR)) == -1);  
   
     projection_mutexes = shmat(identifiant, NULL, 0);      pthread_t               thread;
   
     if (pthread_mutex_lock(&(projection_mutexes[queue])) != 0)      struct_processus        *s_etat_processus;
     {  
         return(-1);  
     }  
   
     base = &(projection_fifos[(longueur_queue + 4) * queue]);      volatile sig_atomic_t   exclusion = 0;
     buffer = &(base[4]);  
   
     // base[1] contient le prochain élément à écrire      verrouillage_gestionnaire_signaux();
     buffer[base[1]++] = (int) pid;  
     base[1] %= base[2];  
   
     // base[3] contient le nombre d'éléments non lus  #   ifdef _BROKEN_SIGINFO
     if (base[3] <= 0)      if ((signal == SIGINT) || (signal == SIGTERM))
     {      {
         pthread_mutex_unlock(&(projection_mutexes[queue]));          // Si l'interruption provient du clavier, il n'y a pas eu d'appel
         shmdt(projection_mutexes);          // à queue_in().
         shmdt(projection_fifos);  
         return(-1);  
     }  
   
     base[3]--;  
   
     if (pthread_mutex_unlock(&(projection_mutexes[queue])) != 0)          pid = getpid();
     {  
         shmdt(projection_mutexes);  
         shmdt(projection_fifos);  
         return(-1);  
     }      }
       else
     // Fermeture des projections  
     shmdt(projection_mutexes);  
     shmdt(projection_fifos);  
     return(0);  
 }  
   
 pid_t  
 origine_signal(int signal)  
 {  
     int             *base;  
     int             *buffer;  
     int             pid;  
     int             queue;  
   
     queue = queue_de_signal(signal);  
   
     BUG(queue == -1, uprintf("[%d] Unknown signal %d in this context\n",  
             (int) getpid(), signal));  
   
     if (pthread_mutex_lock(&(mutexes[queue])) != 0)  
     {      {
         perror("lock");          pid = origine_signal(signal);
         return(-1);  
     }      }
   #   else
     base = &(fifos[(longueur_queue + 4) * queue]);      if (siginfo != NULL)
     buffer = &(base[4]);  
     pid = buffer[base[0]++];  
     base[0] %= base[2];  
     base[3]++;  
   
     if (base[3] > base[2])  
     {      {
         uprintf("Base\n");          pid = (*siginfo).si_pid;
         pthread_mutex_unlock(&(mutexes[queue]));  
         return(-1);  
     }      }
     if (pthread_mutex_unlock(&(mutexes[queue])) != 0)      else
     {      {
         perror("unlock");          pid = getpid();
         return(-1);  
     }      }
   
     return((pid_t) pid);  
 }  
   
 #endif  
   
 void  
 interruption1(SIGHANDLER_ARGS)  
 {  
     pid_t                   pid;  
   
     pthread_t               thread;  
   
     struct_processus        *s_etat_processus;  
   
     volatile sig_atomic_t   exclusion = 0;  
   
 #   ifdef _BROKEN_SIGINFO  
     pid = origine_signal(signal);  
 #   else  
     pid = (*siginfo).si_pid;  
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     switch(signal)      switch(signal)
     {      {
         case SIGALRM :          case SIGALRM :
Line 2212  interruption1(SIGHANDLER_ARGS) Line 1814  interruption1(SIGHANDLER_ARGS)
         }          }
   
         case SIGINT :          case SIGINT :
           case SIGTERM :
         {          {
             /*              /*
              * Une vieille spécification POSIX permet au pointeur siginfo               * Une vieille spécification POSIX permet au pointeur siginfo
Line 2237  interruption1(SIGHANDLER_ARGS) Line 1840  interruption1(SIGHANDLER_ARGS)
   
                 if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)                  if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
                 {                  {
                     printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),                      if (signal == SIGINT)
                             (unsigned long long) pthread_self());                      {
                           printf("[%d] SIGINT (thread %llu)\n", (int) getpid(),
                                   (unsigned long long) pthread_self());
                       }
                       else
                       {
                           printf("[%d] SIGTERM (thread %llu)\n", (int) getpid(),
                                   (unsigned long long) pthread_self());
                       }
   
                     fflush(stdout);                      fflush(stdout);
                 }                  }
   
Line 2260  interruption1(SIGHANDLER_ARGS) Line 1872  interruption1(SIGHANDLER_ARGS)
                         return;                          return;
                     }                      }
   
                     if (strncmp(getenv("LANG"), "fr", 2) == 0)                      if (signal == SIGINT)
                     {  
                         printf("+++Interruption\n");  
                     }  
                     else  
                     {                      {
                         printf("+++Interrupt\n");                          if (strncmp(getenv("LANG"), "fr", 2) == 0)
                     }                          {
                               printf("+++Interruption\n");
                           }
                           else
                           {
                               printf("+++Interrupt\n");
                           }
   
                     fflush(stdout);                          fflush(stdout);
                       }
   
                     (*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;
Line 2309  interruption2(SIGHANDLER_ARGS) Line 1924  interruption2(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      if (siginfo != NULL)
       {
           pid = (*siginfo).si_pid;
       }
       else
       {
           pid = getpid();
       }
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
 #   ifndef _BROKEN_SIGINFO  #   ifndef _BROKEN_SIGINFO
     if (siginfo == NULL)      if (siginfo == NULL)
     {      {
Line 2393  interruption3(SIGHANDLER_ARGS) Line 2015  interruption3(SIGHANDLER_ARGS)
   
     static int              compteur = 0;      static int              compteur = 0;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     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 2459  interruption4(SIGHANDLER_ARGS) Line 2081  interruption4(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     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 2497  interruption5(SIGHANDLER_ARGS) Line 2119  interruption5(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
Line 2567  interruption6(SIGHANDLER_ARGS) Line 2189  interruption6(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     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 2599  interruption7(SIGHANDLER_ARGS) Line 2221  interruption7(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     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 2636  interruption8(SIGHANDLER_ARGS) Line 2258  interruption8(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
Line 2686  interruption9(SIGHANDLER_ARGS) Line 2308  interruption9(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     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 2707  interruption9(SIGHANDLER_ARGS) Line 2329  interruption9(SIGHANDLER_ARGS)
         fflush(stdout);          fflush(stdout);
     }      }
   
     deverrouillage_gestionnaire_signaux();  
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     if (queue_in(getpid(), signal) != 0)      if (queue_in(getpid(), signal) != 0)
     {      {
         return;          return;
     }      }
   
       deverrouillage_gestionnaire_signaux();
     interruption11(signal);      interruption11(signal);
 #   else  #   else
       deverrouillage_gestionnaire_signaux();
     interruption11(signal, siginfo, context);      interruption11(signal, siginfo, context);
 #   endif  #   endif
     return;      return;
Line 2733  interruption10(SIGHANDLER_ARGS) Line 2355  interruption10(SIGHANDLER_ARGS)
   
     unsigned char           nom[8 + 64 + 1];      unsigned char           nom[8 + 64 + 1];
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     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 2780  interruption11(SIGHANDLER_ARGS) Line 2402  interruption11(SIGHANDLER_ARGS)
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
       verrouillage_gestionnaire_signaux();
   
 #   ifdef _BROKEN_SIGINFO  #   ifdef _BROKEN_SIGINFO
     pid = origine_signal(signal);      pid = origine_signal(signal);
 #   else  #   else
     pid = (*siginfo).si_pid;      pid = (*siginfo).si_pid;
 #   endif  #   endif
   
     verrouillage_gestionnaire_signaux();  
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
Line 2866  traitement_exceptions_gsl(const char *re Line 2488  traitement_exceptions_gsl(const char *re
     return;      return;
 }  }
   
 #ifdef _BROKEN_SIGINFO  
   
 #undef kill  
 #undef pthread_kill  
   
 int  
 rpl_kill(pid_t pid, int signal)  
 {  
     /*  
      * Lorsqu'on veut interrompre le processus pid, on ouvre le segment  
      * correspondant au processus en question et ou ajoute le pid dans la  
      * queue.  
      */  
   
     if (signal != 0)  
     {  
         if (queue_in(pid, signal) != 0)  
         {  
             return(-1);  
         }  
     }  
   
     return(kill(pid, signal));  
 }  
   
 int  
 rpl_pthread_kill(pthread_t tid, int signal)  
 {  
     if (signal != 0)  
     {  
         if (queue_in(getpid(), signal) != 0)  
         {  
             return(-1);  
         }  
     }  
   
     return(pthread_kill(tid, signal));  
 }  
   
 #endif  
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.30  
changed lines
  Added in v.1.50

CVSweb interface <joel.bertrand@systella.fr>