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

Diff for /rpl/src/interruptions.c between versions 1.17 and 1.34

version 1.17, 2010/05/22 21:45:50 version 1.34, 2010/08/23 08:04:40
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.15    RPL/2 (R) version 4.0.18
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2010 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 125  insertion_thread(struct_processus *s_eta Line 125  insertion_thread(struct_processus *s_eta
     }      }
   
     (*l_nouvel_objet).suivant = liste_threads;      (*l_nouvel_objet).suivant = liste_threads;
   
     liste_threads = l_nouvel_objet;      liste_threads = l_nouvel_objet;
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
Line 184  insertion_thread_surveillance(struct_pro Line 183  insertion_thread_surveillance(struct_pro
         }          }
     }      }
   
       pthread_mutex_lock(&((*s_argument_thread).mutex));
       (*s_argument_thread).nombre_references++;
       pthread_mutex_unlock(&((*s_argument_thread).mutex));
   
     (*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 448  retrait_thread_surveillance(struct_proce Line 451  retrait_thread_surveillance(struct_proce
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);      pthread_sigmask(SIG_SETMASK, &oldset, NULL);
     sigpending(&set);      sigpending(&set);
   
     return;      return;
 }  }
   
Line 669  liberation_threads(struct_processus *s_e Line 673  liberation_threads(struct_processus *s_e
                     .l_base_pile_processus;                      .l_base_pile_processus;
             while(element_courant != NULL)              while(element_courant != NULL)
             {              {
                 pthread_mutex_trylock(&((*(*((struct_liste_chainee *)                  s_argument_thread = (struct_descripteur_thread *)
                         element_courant)).donnee).mutex));                          (*((struct_liste_chainee *) element_courant)).donnee;
                 pthread_mutex_unlock(&((*(*((struct_liste_chainee *)  
                         element_courant)).donnee).mutex));                  if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
                 liberation(s_etat_processus,                  {
                         (*((struct_liste_chainee *) element_courant)).donnee);                      (*s_etat_processus).erreur_systeme = d_es_processus;
                       sem_post(&semaphore_liste_threads);
                       return;
                   }
   
                   (*s_argument_thread).nombre_references--;
   
                   BUG((*s_argument_thread).nombre_references < 0,
                           printf("(*s_argument_thread).nombre_references = %d\n",
                           (int) (*s_argument_thread).nombre_references));
   
                   if ((*s_argument_thread).nombre_references == 0)
                   {
                       close((*s_argument_thread).pipe_objets[0]);
                       close((*s_argument_thread).pipe_acquittement[1]);
                       close((*s_argument_thread).pipe_injections[1]);
                       close((*s_argument_thread).pipe_nombre_injections[1]);
                       close((*s_argument_thread).pipe_nombre_objets_attente[0]);
                       close((*s_argument_thread).pipe_interruptions[0]);
                       close((*s_argument_thread)
                               .pipe_nombre_interruptions_attente[0]);
   
                       if (pthread_mutex_unlock(&((*s_argument_thread).mutex))
                               != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           sem_post(&semaphore_liste_threads);
                           return;
                       }
   
                       pthread_mutex_destroy(&((*s_argument_thread).mutex));
   
                       if ((*s_argument_thread).processus_detache == d_faux)
                       {
                           if ((*s_argument_thread).destruction_objet == d_vrai)
                           {
                               liberation(s_etat_processus, (*s_argument_thread)
                                       .argument);
                           }
                       }
   
                       free(s_argument_thread);
                   }
                   else
                   {
                       if (pthread_mutex_unlock(&((*s_argument_thread).mutex))
                               != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           sem_post(&semaphore_liste_threads);
                           return;
                       }
                   }
   
                 element_suivant = (*((struct_liste_chainee *) element_courant))                  element_suivant = (*((struct_liste_chainee *) element_courant))
                         .suivant;                          .suivant;
                 free((struct_liste_chainee *) element_courant);                  free(element_courant);
                 element_courant = element_suivant;                  element_courant = element_suivant;
             }              }
   
               (*s_etat_processus).l_base_pile_processus = NULL;
   
             pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));              pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex));
             pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));              pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex));
             liberation(s_etat_processus, (*s_etat_processus).indep);              liberation(s_etat_processus, (*s_etat_processus).indep);
Line 1291  liberation_threads(struct_processus *s_e Line 1350  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;
   
         close((*s_argument_thread).pipe_objets[0]);  
         close((*s_argument_thread).pipe_acquittement[1]);  
         close((*s_argument_thread).pipe_injections[1]);  
         close((*s_argument_thread).pipe_nombre_injections[1]);  
         close((*s_argument_thread).pipe_nombre_objets_attente[0]);  
         close((*s_argument_thread).pipe_interruptions[0]);  
         close((*s_argument_thread).pipe_nombre_interruptions_attente[0]);  
   
         if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)          if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1314  liberation_threads(struct_processus *s_e Line 1365  liberation_threads(struct_processus *s_e
   
         if ((*s_argument_thread).nombre_references == 0)          if ((*s_argument_thread).nombre_references == 0)
         {          {
               close((*s_argument_thread).pipe_objets[0]);
               close((*s_argument_thread).pipe_acquittement[1]);
               close((*s_argument_thread).pipe_injections[1]);
               close((*s_argument_thread).pipe_nombre_injections[1]);
               close((*s_argument_thread).pipe_nombre_objets_attente[0]);
               close((*s_argument_thread).pipe_interruptions[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)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1322  liberation_threads(struct_processus *s_e Line 1381  liberation_threads(struct_processus *s_e
             }              }
   
             pthread_mutex_destroy(&((*s_argument_thread).mutex));              pthread_mutex_destroy(&((*s_argument_thread).mutex));
   
               if ((*s_argument_thread).processus_detache == d_faux)
               {
                   if ((*s_argument_thread).destruction_objet == d_vrai)
                   {
                       liberation(s_etat_processus, (*s_argument_thread).argument);
                   }
               }
   
             free(s_argument_thread);              free(s_argument_thread);
         }          }
         else          else
Line 1656  deverrouillage_gestionnaire_signaux() Line 1724  deverrouillage_gestionnaire_signaux()
     return;      return;
 }  }
   
   #ifdef _BROKEN_SIGINFO
   
   #define longueur_queue  256
   #define nombre_queues   13
   
   static int              *fifos;
   static int              segment;
   static sem_t            *semaphores[nombre_queues];
   static sem_t            *semaphore_global;
   
   #ifdef IPCS_SYSV
   static unsigned char    *chemin = NULL;
   #endif
   
   unsigned char *
   nom_segment(unsigned char *chemin, pid_t pid)
   {
       unsigned char               *fichier;
   
   #   ifdef IPCS_SYSV
       if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *
               sizeof(unsigned char))) == NULL)
       {
           return(NULL);
       }
   
       sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
   #   else
       if ((fichier = malloc((1 + 256 + 1) *
               sizeof(unsigned char))) == NULL)
       {
           return(NULL);
       }
   
       sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid);
   #   endif
   
       return(fichier);
   }
   
   unsigned char *
   nom_semaphore(pid_t pid, int queue)
   {
       unsigned char               *fichier;
   
       if ((fichier = malloc((256 + 1) * sizeof(unsigned char))) == NULL)
       {
           return(NULL);
       }
   
       sprintf(fichier, "/RPL-SIGESMAPHORES-%d-%d", (int) pid, queue);
   
       return(fichier);
   }
   
   inline 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);
           case SIGSEGV:
               return(11);
           case SIGBUS:
               return(12);
       }
   
       return(-1);
   }
   
   void
   creation_fifos_signaux(struct_processus *s_etat_processus)
   {
       /*
        * Signaux utilisés
        * SIGINT, SIGTSTP, SIGCONT, SIGURG, SIGPIPE, SIGALRM, SIGFSTOP,
        * SIGSTART, SIGINJECT, SIGABORT, SIGFABORT
        */
   
   #   ifndef IPCS_SYSV // POSIX
   #   else // SystemV
   
       file                            *desc;
   
       int                             i;
   
       key_t                           clef;
   
       unsigned char                   *nom;
   
       // 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;
       }
   
       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))
       {
           if (shmctl(segment, IPC_RMID, 0) == -1)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
   #   endif
   
       /*
        * 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)
        */
   
       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;
       }
   
       // Création des sémaphores : un sémaphore par signal et par queue
       // plus un sémaphore global pour tous les threads.
   
       for(i = 0; i < nombre_queues; i++)
       {
           if ((nom = nom_semaphore(getpid(), i)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           // Le sémaphore est créé en écrasant si nécessaire un sémaphore
           // préexistant. Comme le nom du sémaphore contient l'identifiant du
           // processus, il est anormal d'avoir un sémaphore de même nom
           // préexistant.
   
           if ((semaphores[i] = sem_open(nom, O_CREAT, S_IRUSR | S_IWUSR,
                   1)) == SEM_FAILED)
           {
               (*s_etat_processus).erreur_systeme = d_es_semaphore;
               return;
           }
   
           free(nom);
       }
   
   
       if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       if ((semaphore_global = sem_open(nom, O_CREAT, S_IRUSR | S_IWUSR,
               1)) == SEM_FAILED)
       {
           (*s_etat_processus).erreur_systeme = d_es_semaphore;
           return;
       }
   
       free(nom);
   
       return;
   }
   
   void
   liberation_fifos_signaux(struct_processus *s_etat_processus)
   {
       int                 i;
   
       if (shmdt(fifos) == -1)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       for(i = 0; i < nombre_queues; i++)
       {
           if (sem_close(semaphores[i]) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_semaphore;
               return;
           }
       }
   
       if (sem_close(semaphore_global) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_semaphore;
           return;
       }
   
       return;
   }
   
   void
   destruction_fifos_signaux(struct_processus *s_etat_processus)
   {
       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;
       }
   
       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);
   
       for(i = 0; i < nombre_queues; i++)
       {
           if ((nom = nom_semaphore(getpid(), i)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (sem_unlink(nom) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_semaphore;
               return;
           }
   
           free(nom);
       }
   
       if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       if (sem_unlink(nom) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_semaphore;
           return;
       }
   
       free(nom);
   
       return;
   }
   
   int
   queue_in(pid_t pid, int signal)
   {
   #undef printf
   // Transformer ce truc en POSIX ! On ne fait du SysV que si on n'a pas le choix
   
   #   ifndef IPCS_SYSV
   #   else // Traitement à l'aide d'IPCS SystemV
   
       int             *base;
       int             *buffer;
       int             *projection_fifos;
       int             queue;
       int             identifiant;
   
       key_t           clef;
   
       sem_t           *semaphore;
   
       struct stat     s_stat;
   
       unsigned char   *nom;
   
       queue = queue_de_signal(signal);
   
       // Ouverture des projections
   
       if ((nom = nom_segment(chemin, pid)) == NULL)
       {
           return(-1);
       }
   
       // Dans le cas de SIGSTART, premier signal envoyé à un processus fils,
       // il convient d'attendre que le fichier support soit effectivement
       // accessible. Dans tous les autres cas, ce fichier doit exister. S'il
       // n'existe plus, le processus associé n'existe plus.
   
       if (signal == SIGSTART)
       {
           // On attend que le fichier sois présent
   
           while(stat(nom, &s_stat) != 0);
       }
   
       if ((clef = ftok(nom, 1)) == -1)
       {
           return(-1);
       }
   
       free(nom);
   
       if (signal == SIGSTART)
       {
           while((identifiant = shmget(clef,
                   nombre_queues * (longueur_queue + 4) * sizeof(int),
                   S_IRUSR | S_IWUSR)) == -1);
       }
       else
       {
           if ((identifiant = shmget(clef,
                   nombre_queues * (longueur_queue + 4) * sizeof(int),
                   S_IRUSR | S_IWUSR)) == -1)
           {
               return(-1);
           }
       }
   
       projection_fifos = shmat(identifiant, NULL, 0);
   
       if (((void *) projection_fifos) == ((void *) -1))
       {
           return(-1);
       }
   
       if ((nom = nom_semaphore(pid, queue)) == NULL)
       {
           shmdt(projection_fifos);
           return(-1);
       }
   
       while((semaphore = sem_open(nom, 0)) == SEM_FAILED);
   
       if (sem_wait(semaphore) != 0)
       {
           shmdt(projection_fifos);
           return(-1);
       }
   
       // Il ne faut pas empiler plusieurs SIGSTART car SIGSTART peut provenir
       // de l'instruction SWI. Plusieurs threads peuvent interrompre de façon
       // asynchrone le processus père durant une phase de signaux masqués.
   
       base = &(projection_fifos[(longueur_queue + 4) * queue]);
       buffer = &(base[4]);
   
       // base[3] contient le nombre d'éléments restants
   
       if (base[3] <= 0)
       {
           sem_post(semaphore);
           sem_close(semaphore);
           shmdt(projection_fifos);
           return(-1);
       }
   
       base[3]--;
   
       // base[1] contient le prochain élément à écrire
       buffer[base[1]++] = (int) pid;
       base[1] %= base[2];
   
       if (sem_post(semaphore) != 0)
       {
           shmdt(projection_fifos);
           sem_close(semaphore);
           return(-1);
       }
   
       sem_close(semaphore);
   
       // Fermeture des projections
       shmdt(projection_fifos);
   
   #   endif
   
       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 (sem_wait(semaphores[queue]) != 0)
       {
           return(-1);
       }
   
       // Le signal SIGCONT peut être envoyé de façon totalement asynchrone.
       // Il peut y avoir plus de signaux envoyés que d'interruptions traitées.
       // Il convient donc de rectifier la queue lors du traitement de
       // l'interruption correspondante. Le gestionnaire étant installé sans
       // l'option NODEFER, la queue reste cohérente.
   
       if (signal == SIGCONT)
       {
           base = &(fifos[(longueur_queue + 4) * queue]);
           buffer = &(base[4]);
           base[0] = (base[1] - 1) % base[2];
           pid = buffer[base[0]++];
           base[3] = base[2];
       }
       else
       {
           base = &(fifos[(longueur_queue + 4) * queue]);
           buffer = &(base[4]);
           pid = buffer[base[0]++];
           base[0] %= base[2];
           base[3]++;
       }
   
       if (base[3] > base[2])
       {
           sem_post(semaphores[queue]);
           return(-1);
       }
   
       if (sem_post(semaphores[queue]) != 0)
       {
           return(-1);
       }
   
       return((pid_t) pid);
   }
   
   #endif
   
 void  void
 interruption1(int signal, siginfo_t *siginfo, void *context)  interruption1(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
Line 1667  interruption1(int signal, siginfo_t *sig Line 2238  interruption1(int signal, siginfo_t *sig
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
   #   ifdef _BROKEN_SIGINFO
       if (signal == SIGINT)
       {
           // Si l'interruption provient du clavier, il n'y a pas eu d'appel
           // à queue_in().
   
           pid = getpid();
       }
       else
       {
           pid = origine_signal(signal);
       }
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
     switch(signal)      switch(signal)
     {      {
         case SIGALRM :          case SIGALRM :
         {          {
             if ((*siginfo).si_pid == getpid())              if (pid == getpid())
             {              {
                 if ((s_etat_processus = recherche_thread(getpid(),                  if ((s_etat_processus = recherche_thread(getpid(),
                         pthread_self())) == NULL)                          pthread_self())) == NULL)
                 {                  {
                     deverrouillage_gestionnaire_signaux();                      deverrouillage_gestionnaire_signaux();
                     return;                       return;
                 }                  }
   
                 if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)                  if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
Line 1716  interruption1(int signal, siginfo_t *sig Line 2303  interruption1(int signal, siginfo_t *sig
              * Solaris suit en particulier cette spécification.               * Solaris suit en particulier cette spécification.
              */               */
   
   #           ifndef _BROKEN_SIGINFO
             if (siginfo == NULL)              if (siginfo == NULL)
             {              {
                 kill(getpid(), signal);                  kill(getpid(), signal);
             }              }
             else if ((*siginfo).si_pid == getpid())              else
   #           endif
               if (pid == getpid())
             {              {
                 if ((s_etat_processus = recherche_thread(getpid(),                  if ((s_etat_processus = recherche_thread(getpid(),
                         pthread_self())) == NULL)                          pthread_self())) == NULL)
Line 1795  interruption1(int signal, siginfo_t *sig Line 2385  interruption1(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption2(int signal, siginfo_t *siginfo, void *context)  interruption2(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     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
   
   #   ifndef _BROKEN_SIGINFO
     if (siginfo == NULL)      if (siginfo == NULL)
     {      {
         /*          /*
Line 1819  interruption2(int signal, siginfo_t *sig Line 2419  interruption2(int signal, siginfo_t *sig
             return;              return;
         }          }
     }      }
     else if ((*siginfo).si_pid == getpid())      else
   #   endif
       if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
Line 1867  interruption2(int signal, siginfo_t *sig Line 2469  interruption2(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption3(int signal, siginfo_t *siginfo, void *context)  interruption3(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     static int              compteur = 0;      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 1927  interruption3(int signal, siginfo_t *sig Line 2537  interruption3(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption4(int signal, siginfo_t *siginfo, void *context)  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 1955  interruption4(int signal, siginfo_t *sig Line 2573  interruption4(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption5(int signal, siginfo_t *siginfo, void *context)  interruption5(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((*siginfo).si_pid == getpid())  #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
       if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
Line 2018  interruption5(int signal, siginfo_t *sig Line 2645  interruption5(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption6(int signal, siginfo_t *siginfo, void *context)  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 2042  interruption6(int signal, siginfo_t *sig Line 2677  interruption6(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption7(int signal, siginfo_t *siginfo, void *context)  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 2069  interruption7(int signal, siginfo_t *sig Line 2712  interruption7(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption8(int signal, siginfo_t *siginfo, void *context)  interruption8(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((*siginfo).si_pid == getpid())  #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
       if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
Line 2112  interruption8(int signal, siginfo_t *sig Line 2764  interruption8(int signal, siginfo_t *sig
 }  }
   
 void  void
 interruption9(int signal, siginfo_t *siginfo, void *context)  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 2131  interruption9(int signal, siginfo_t *sig Line 2791  interruption9(int signal, siginfo_t *sig
         fflush(stdout);          fflush(stdout);
     }      }
   
   #   ifdef _BROKEN_SIGINFO
       if (queue_in(getpid(), signal) != 0)
       {
           return;
       }
   
       deverrouillage_gestionnaire_signaux();
       interruption11(signal);
   #   else
     deverrouillage_gestionnaire_signaux();      deverrouillage_gestionnaire_signaux();
     interruption11(signal, siginfo, context);      interruption11(signal, siginfo, context);
   #   endif
     return;      return;
 }  }
   
 void  void
 interruption10(int signal, siginfo_t *siginfo, void *context)  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();
Line 2178  interruption10(int signal, siginfo_t *si Line 2856  interruption10(int signal, siginfo_t *si
 }  }
   
 void  void
 interruption11(int signal, siginfo_t *siginfo, void *context)  interruption11(SIGHANDLER_ARGS)
 {  {
       pid_t                   pid;
   
     pthread_t               thread;      pthread_t               thread;
   
     struct_processus        *s_etat_processus;      struct_processus        *s_etat_processus;
   
     verrouillage_gestionnaire_signaux();      verrouillage_gestionnaire_signaux();
   
     if ((*siginfo).si_pid == getpid())  #   ifdef _BROKEN_SIGINFO
       pid = origine_signal(signal);
   #   else
       pid = (*siginfo).si_pid;
   #   endif
   
       if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))          if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
                 == NULL)                  == NULL)
Line 2263  traitement_exceptions_gsl(const char *re Line 2950  traitement_exceptions_gsl(const char *re
     return;      return;
 }  }
   
   #ifdef _BROKEN_SIGINFO
   
   #undef kill
   #undef pthread_kill
   
   int
   kill_broken_siginfo(pid_t pid, int signal)
   {
       int                 ios;
   
       sem_t               *semaphore;
   
       unsigned char       *nom;
   
       /*
        * Lorsqu'on veut interrompre le processus pid, on ouvre le segment
        * correspondant au processus en question et ou ajoute le pid dans la
        * queue.
        *
        * Le sémaphore global à tous les threads d'un même processus sert
        * à garantir que les signaux seront traités dans l'ordre de ce qui est
        * effectivement mis dans la queue.
        */
   
       // Sémaphore acquis
   
       if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
       {
           return(-1);
       }
   
       if ((semaphore = sem_open(nom, 0)) == SEM_FAILED)
       {
           free(nom);
           return(-1);
       }
   
       free(nom);
   
       if (sem_wait(semaphore) == -1)
       {
           return(-1);
       }
   
       if ((signal != 0) && (signal != SIGINT))
       {
           if (queue_in(pid, signal) != 0)
           {
               sem_post(semaphore);
               sem_close(semaphore);
               return(-1);
           }
       }
   
       ios = kill(pid, signal);
   
       // Sémaphore relâché
   
       sem_post(semaphore);
       sem_close(semaphore);
   
       return(ios);
   }
   
   int
   pthread_kill_broken_siginfo(pthread_t tid, int signal)
   {
       int                 ios;
   
       sem_t               *semaphore;
   
       unsigned char       *nom;
   
       if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL)
       {
           return(-1);
       }
   
       if ((semaphore = sem_open(nom, 0)) == SEM_FAILED)
       {
           free(nom);
           return(-1);
       }
   
       free(nom);
   
       if (sem_wait(semaphore) == -1)
       {
           return(-1);
       }
   
       if ((signal != 0) && (signal != SIGINT))
       {
           if (queue_in(getpid(), signal) != 0)
           {
               sem_post(semaphore);
               sem_close(semaphore);
               return(-1);
           }
       }
   
       ios = pthread_kill(tid, signal);
   
       sem_post(semaphore);
       sem_close(semaphore);
   
       return(ios);
   }
   
   #endif
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.17  
changed lines
  Added in v.1.34

CVSweb interface <joel.bertrand@systella.fr>