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

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

version 1.69, 2011/09/15 17:51:43 version 1.99, 2012/07/04 13:02:49
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.3    RPL/2 (R) version 4.1.9
   Copyright (C) 1989-2011 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 52  typedef struct liste_chainee_volatile Line 52  typedef struct liste_chainee_volatile
     volatile void                           *donnee;      volatile void                           *donnee;
 } struct_liste_chainee_volatile;  } struct_liste_chainee_volatile;
   
   
 static volatile struct_liste_chainee_volatile   *liste_threads  static volatile struct_liste_chainee_volatile   *liste_threads
         = NULL;          = NULL;
 static volatile struct_liste_chainee_volatile   *liste_threads_surveillance  static volatile struct_liste_chainee_volatile   *liste_threads_surveillance
         = NULL;          = NULL;
 static volatile int                             code_erreur_gsl = 0;  static volatile int                             code_erreur_gsl = 0;
   
 static unsigned char                            *racine_segment;  unsigned char                                   *racine_segment;
   
 static pthread_mutex_t                          mutex_interruptions  static pthread_mutex_t                          mutex_interruptions
         = PTHREAD_MUTEX_INITIALIZER;          = PTHREAD_MUTEX_INITIALIZER;
   
   static void *
   thread_surveillance_signaux(void *argument)
   {
       // Cette fonction est lancée dans un thread créé par processus pour
       // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du
       // signal SIGALRM. Les processus externes n'envoient plus un signal au
       // processus ou au thread à signaler mais positionnent les informations
       // nécessaires dans la queue des signaux et incrémentent le sémaphore.
       // Le sémaphore est décrémenté lorsque le signal est effectivement traité.
   
       int                                     nombre_signaux_envoyes;
   
       struct_processus                        *s_etat_processus;
   
       struct timespec                         attente;
   
       volatile struct_liste_chainee_volatile  *l_element_courant;
   
       s_etat_processus = (struct_processus *) argument;
   
       for(;;)
       {
           attente.tv_sec = 0;
           attente.tv_nsec = GRANULARITE_us * 1000;
   
   #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
           if (sem_wait(&(*s_queue_signaux).signalisation) == 0)
   #       else
           if(sem_wait(semaphore_signalisation) == 0)
   #       endif
           {
               if ((*s_queue_signaux).requete_arret == d_vrai)
               {
                   break;
               }
   
   #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_post(&(*s_queue_signaux).signalisation);
   #           else
               sem_post(semaphore_signalisation);
   #           endif
   
               nombre_signaux_envoyes = 0;
               sched_yield();
   
               // Dans un premier temps, on verrouille la queue des signaux
               // affectée au processus courant pour vérifier s'il y a quelque
               // chose à traiter.
   
   #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_wait(&(*s_queue_signaux).semaphore);
   #           else
               sem_wait(semaphore_queue_signaux);
   #           endif
   
               if ((*s_queue_signaux).pointeur_lecture !=
                       (*s_queue_signaux).pointeur_ecriture)
               {
                   nombre_signaux_envoyes++;
                   raise(SIGALRM);
               }
   
   #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_post(&(*s_queue_signaux).semaphore);
   #           else
               sem_post(semaphore_queue_signaux);
   #           endif
   
               // Dans un second temps, on balaye toutes les queues de signaux
               // des threads du processus courant.
   
               pthread_mutex_lock(&mutex_liste_threads);
               l_element_courant = liste_threads;
   
               while(l_element_courant != NULL)
               {
                   if ((*((struct_thread *) (*l_element_courant).donnee)).pid
                           == getpid())
                   {
                       if ((*(*((struct_thread *) (*l_element_courant).donnee))
                               .s_etat_processus).pointeur_signal_ecriture !=
                               (*(*((struct_thread *) (*l_element_courant).donnee))
                               .s_etat_processus).pointeur_signal_lecture)
                       {
                           nombre_signaux_envoyes++;
                           pthread_kill((*((struct_thread *) (*l_element_courant)
                                   .donnee)).tid, SIGALRM);
                       }
                   }
   
                   l_element_courant = (*l_element_courant).suivant;
               }
   
               pthread_mutex_unlock(&mutex_liste_threads);
   
               // Nanosleep
   
               if (nombre_signaux_envoyes > 0)
               {
                   nanosleep(&attente, NULL);
               }
           }
           else
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
           }
       }
   
       pthread_exit(NULL);
   }
   
 void  void
 modification_pid_thread_pere(struct_processus *s_etat_processus)  modification_pid_thread_pere(struct_processus *s_etat_processus)
 {  {
Line 207  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 324  verrouillage_threads_concurrents(struct_ Line 454  verrouillage_threads_concurrents(struct_
                 == getpid()) && (pthread_equal((*((struct_thread *)                  == getpid()) && (pthread_equal((*((struct_thread *)
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
             if (pthread_mutex_lock(&((*(*((struct_thread *) (*l_element_courant)  #           ifndef SEMAPHORES_NOMMES
                     .donnee)).s_etat_processus).mutex_fork)) == -1)                  while(sem_wait(&((*(*((struct_thread *) (*l_element_courant)
                           .donnee)).s_etat_processus).semaphore_fork)) == -1)
   #           else
                   while(sem_wait((*(*((struct_thread *) (*l_element_courant)
                           .donnee)).s_etat_processus).semaphore_fork) == -1)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 351  deverrouillage_threads_concurrents(struc Line 486  deverrouillage_threads_concurrents(struc
                 == getpid()) && (pthread_equal((*((struct_thread *)                  == getpid()) && (pthread_equal((*((struct_thread *)
                 (*l_element_courant).donnee)).tid, pthread_self()) == 0))                  (*l_element_courant).donnee)).tid, pthread_self()) == 0))
         {          {
             if (pthread_mutex_unlock(&((*(*((struct_thread *)  #           ifndef SEMAPHORES_NOMMES
                     (*l_element_courant).donnee)).s_etat_processus)                  if (sem_post(&((*(*((struct_thread *)
                     .mutex_fork)) != 0)                          (*l_element_courant).donnee)).s_etat_processus)
                           .semaphore_fork)) != 0)
   #           else
                   if (sem_post((*(*((struct_thread *)
                           (*l_element_courant).donnee)).s_etat_processus)
                           .semaphore_fork) != 0)
   #           endif
             {              {
                 if (pthread_mutex_unlock(&mutex_liste_threads) != 0)                  if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                 {                  {
Line 1109  liberation_threads(struct_processus *s_e Line 1250  liberation_threads(struct_processus *s_e
   
             liberation_allocateur(s_etat_processus);              liberation_allocateur(s_etat_processus);
   
             pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));  #           ifndef SEMAPHORES_NOMMES
             pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));                  sem_post(&((*s_etat_processus).semaphore_fork));
                   sem_destroy(&((*s_etat_processus).semaphore_fork));
   #           else
                   sem_post((*s_etat_processus).semaphore_fork);
                   sem_close((*s_etat_processus).semaphore_fork);
   #           endif
   
             liberation_contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              free(s_etat_processus);
Line 1298  verrouillage_gestionnaire_signaux(struct Line 1444  verrouillage_gestionnaire_signaux(struct
 {  {
     int         semaphore;      int         semaphore;
   
     if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)  #   ifndef SEMAPHORES_NOMMES
       if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         BUG(1, uprintf("Lock error !\n"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
Line 1308  verrouillage_gestionnaire_signaux(struct Line 1458  verrouillage_gestionnaire_signaux(struct
   
     if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)      if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1319  verrouillage_gestionnaire_signaux(struct Line 1473  verrouillage_gestionnaire_signaux(struct
     if (sem_post(semaphore_gestionnaires_signaux) == -1)      if (sem_post(semaphore_gestionnaires_signaux) == -1)
 #   endif  #   endif
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Lock error !\n"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
     }      }
Line 1330  verrouillage_gestionnaire_signaux(struct Line 1488  verrouillage_gestionnaire_signaux(struct
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)      if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
 #   endif  #   endif
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Lock error !\n"));          BUG(1, uprintf("Lock error !\n"));
         return;          return;
     }      }
   
     if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)      if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1352  verrouillage_gestionnaire_signaux(struct Line 1518  verrouillage_gestionnaire_signaux(struct
   
         if (pthread_mutex_lock(&mutex_liste_threads) != 0)          if (pthread_mutex_lock(&mutex_liste_threads) != 0)
         {          {
             pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #           ifndef SEMAPHORES_NOMMES
               sem_wait(&((*s_etat_processus).semaphore_fork));
   #           else
               sem_wait((*s_etat_processus).semaphore_fork);
   #           endif
             BUG(1, uprintf("Lock error !\n"));              BUG(1, uprintf("Lock error !\n"));
             return;              return;
         }          }
Line 1370  deverrouillage_gestionnaire_signaux(stru Line 1540  deverrouillage_gestionnaire_signaux(stru
   
     if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)      if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1381  deverrouillage_gestionnaire_signaux(stru Line 1555  deverrouillage_gestionnaire_signaux(stru
     if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)      if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0)
 #   endif  #   endif
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
Line 1394  deverrouillage_gestionnaire_signaux(stru Line 1572  deverrouillage_gestionnaire_signaux(stru
     {      {
         if (errno != EINTR)          if (errno != EINTR)
         {          {
             pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #           ifndef SEMAPHORES_NOMMES
               sem_wait(&((*s_etat_processus).semaphore_fork));
   #           else
               sem_wait((*s_etat_processus).semaphore_fork);
   #           endif
             BUG(1, uprintf("Unlock error !\n"));              BUG(1, uprintf("Unlock error !\n"));
             return;              return;
         }          }
Line 1402  deverrouillage_gestionnaire_signaux(stru Line 1584  deverrouillage_gestionnaire_signaux(stru
   
     if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)      if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0)
     {      {
         pthread_mutex_lock(&((*s_etat_processus).mutex_fork));  #       ifndef SEMAPHORES_NOMMES
           sem_wait(&((*s_etat_processus).semaphore_fork));
   #       else
           sem_wait((*s_etat_processus).semaphore_fork);
   #       endif
         BUG(1, uprintf("Unlock error !\n"));          BUG(1, uprintf("Unlock error !\n"));
         return;          return;
     }      }
   
     if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)  #   ifndef SEMAPHORES_NOMMES
       while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
   #   else
       while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         BUG(1, uprintf("Unlock error !\n"));          if (errno != EINTR)
         return;          {
               BUG(1, uprintf("Unlock error !\n"));
               return;
           }
     }      }
   
     if (semaphore == 1)      if (semaphore == 1)
Line 1429  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 1447  interruption1(int signal) Line 1640  interruption1(int signal)
             envoi_signal_processus(getpid(), rpl_sigterm);              envoi_signal_processus(getpid(), rpl_sigterm);
             break;              break;
   
         case SIGALRM:          case SIGUSR1:
             envoi_signal_processus(getpid(), rpl_sigalrm);              envoi_signal_processus(getpid(), rpl_sigalrm);
             break;              break;
     }      }
Line 1508  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 1530  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 1697  interruption3(int signal) Line 1889  interruption3(int signal)
     // l'erreur d'accès à la mémoire. On sort donc du programme quitte à      // l'erreur d'accès à la mémoire. On sort donc du programme quitte à
     // ce qu'il reste des processus orphelins.      // ce qu'il reste des processus orphelins.
   
     unsigned char       message[] = "+++System : Uncaught access violation\n"      unsigned char       message_1[] = "+++System : Uncaught access violation\n"
                                   "+++System : Aborting !\n";
       unsigned char       message_2[] = "+++System : Stack overflow\n"
                                 "+++System : Aborting !\n";                                  "+++System : Aborting !\n";
   
     test_signal(signal);      test_signal(signal);
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         kill(pid_processus_pere, SIGALRM);          kill(pid_processus_pere, SIGUSR1);
       }
   
       if (signal != SIGUSR2)
       {
           write(STDERR_FILENO, message_1, strlen(message_1));
       }
       else
       {
           write(STDERR_FILENO, message_2, strlen(message_2));
     }      }
   
     write(STDERR_FILENO, message, strlen(message));  
     _exit(EXIT_FAILURE);      _exit(EXIT_FAILURE);
 }  }
   
 #if 0  
 // Utiliser libsigsegv  static void
 void INTERRUPTION3_A_FIXER()  sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3)
 {  {
     pthread_t               thread;      switch((*((volatile int *) arg1)))
       {
           case 1:
               longjmp(contexte_ecriture, -1);
               break;
   
     struct_processus        *s_etat_processus;          case 2:
               longjmp(contexte_impression, -1);
               break;
       }
   
     test_signal(signal);      return;
     verrouillage_gestionnaire_signaux(s_etat_processus);  }
   
     if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL)  
     {  
         deverrouillage_gestionnaire_signaux(s_etat_processus);  
         return;  
     }  
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)  void
   interruption_depassement_pile(int urgence, stackoverflow_context_t scp)
   {
       if ((urgence == 0) && (routine_recursive != 0))
     {      {
         printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(),          // On peut tenter de récupérer le dépassement de pile. Si la variable
                 (unsigned long long) pthread_self());          // 'routine_recursive' est non nulle, on récupère l'erreur.
         fflush(stdout);  
     }  
   
     if ((*s_etat_processus).var_volatile_recursivite == -1)          sigsegv_leave_handler(sortie_interruption_depassement_pile,
     {                  (void *) &routine_recursive, NULL, NULL);
         // Segfault dans un appel de fonction récursive  
         deverrouillage_gestionnaire_signaux(s_etat_processus);  
         longjmp(contexte, -1);  
     }      }
     else  
     {  
         // Segfault dans une routine interne  
         if (strncmp(getenv("LANG"), "fr", 2) == 0)  
         {  
             printf("+++Système : Violation d'accès\n");  
         }  
         else  
         {  
             printf("+++System : Access violation\n");  
         }  
   
         fflush(stdout);      // Ici, la panique est totale et il vaut mieux quitter l'application.
       interruption3(SIGUSR2);
         (*s_etat_processus).compteur_violation_d_acces++;      return;
   }
         if ((*s_etat_processus).compteur_violation_d_acces > 1)  
         {  
             // On vient de récupérer plus d'une erreur de segmentation  
             // dans le même processus ou le même thread. L'erreur n'est pas  
             // récupérable et on sort autoritairement du programme. Il peut  
             // rester des processus orphelins en attente !  
   
             if (strncmp(getenv("LANG"), "fr", 2) == 0)  
             {  
                 printf("+++Système : Violation d'accès, tentative de "  
                         "terminaison de la tâche\n");  
                 printf("             (defauts multiples)\n");  
             }  
             else  
             {  
                 printf("+++System : Access violation, trying to kill task "  
                         "(multiple defaults)\n");  
             }  
   
             fflush(stdout);  int
   interruption_violation_access(void *adresse_fautive, int gravite)
   {
       unsigned char       message[] = "+++System : Trying to catch access "
                                   "violation\n";
   
             deverrouillage_gestionnaire_signaux(s_etat_processus);      static int          compteur_erreur = 0;
             exit(EXIT_FAILURE);  
         }  
         else  
         {  
             // Première erreur de segmentation. On essaie de terminer  
             // proprement le thread ou le processus. Le signal ne peut être  
             // envoyé que depuis le même processus.  
   
             if (recherche_thread_principal(getpid(), &thread) == d_vrai)      if ((gravite == 0) && (routine_recursive != 0))
             {      {
                 if (pthread_equal(thread, pthread_self()) != 0)          // Il peut s'agir d'un dépassement de pile.
                 {  
                     deverrouillage_gestionnaire_signaux(s_etat_processus);  
   
                     if ((*s_etat_processus).pid_processus_pere != getpid())          sigsegv_leave_handler(sortie_interruption_depassement_pile,
                     {                  (void *) &routine_recursive, NULL, NULL);
                         // On est dans le thread principal d'un processus.      }
   
                         longjmp(contexte_processus, -1);      // On est dans une bonne vieille violation d'accès. On essaie
                     }      // de fermer au mieux l'application.
                     else  
                     {  
                         // On est dans le thread principal du processus  
                         // père.  
   
                         longjmp(contexte_initial, -1);      compteur_erreur++;
                     }  
                 }  
                 else  
                 {  
                     // On est dans un thread fils d'un thread principal.  
   
                     deverrouillage_gestionnaire_signaux(s_etat_processus);      if (compteur_erreur >= 2)
                     longjmp(contexte_thread, -1);      {
                 }          // Erreurs multiples, on arrête l'application.
             }          interruption3(SIGSEGV);
           return(0);
       }
   
             // Là, on ramasse les miettes puisque le thread n'existe plus      write(STDERR_FILENO, message, strlen(message));
             // dans la base (corruption de la mémoire).  
   
             deverrouillage_gestionnaire_signaux(s_etat_processus);      if (pid_processus_pere == getpid())
             longjmp(contexte_initial, -1);      {
         }          longjmp(contexte_initial, -1);
           return(1);
       }
       else
       {
           longjmp(contexte_processus, -1);
           return(1);
     }      }
   
     deverrouillage_gestionnaire_signaux(s_etat_processus);      // On renvoie 0 parce qu'on décline toute responsabilité quant à la
     return;      // suite des événements...
       return(0);
 }  }
 #endif  
   
 // Traitement de rpl_sigstart  // Traitement de rpl_sigstart
   
Line 1896  signal_stop(struct_processus *s_etat_pro Line 2063  signal_stop(struct_processus *s_etat_pro
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  
                 == NULL)  
         {  
             deverrouillage_gestionnaire_signaux(s_etat_processus);  
             return;  
         }  
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),              printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(),
Line 1994  signal_urg(struct_processus *s_etat_proc Line 2154  signal_urg(struct_processus *s_etat_proc
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))  
                 == NULL)  
         {  
             deverrouillage_gestionnaire_signaux(s_etat_processus);  
             return;  
         }  
   
         if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)          if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
         {          {
             printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),              printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(),
Line 2050  signal_abort(struct_processus *s_etat_pr Line 2203  signal_abort(struct_processus *s_etat_pr
   
     if (pid == getpid())      if (pid == getpid())
     {      {
         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;
   
         /*          /*
Line 2172  static inline void Line 2318  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)
 {  {
 uprintf("Signal : %d\n", signal);  
     switch(signal)      switch(signal)
     {      {
         case rpl_signull:          case rpl_signull:
Line 2252  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.
   
     if (pthread_mutex_trylock(&((*s_queue_signaux).mutex)) == 0)  #   if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
           if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
   #   else
           if (sem_trywait(semaphore_queue_signaux) == 0)
   #   endif
     {      {
         if ((*s_queue_signaux).pointeur_lecture !=          while((*s_queue_signaux).pointeur_lecture !=
                 (*s_queue_signaux).pointeur_ecriture)                  (*s_queue_signaux).pointeur_ecriture)
         {          {
             // Il y a un signal en attente dans le segment partagé. On le              // Il y a un signal en attente dans le segment partagé. On le
Line 2267  scrutation_interruptions(struct_processu Line 2416  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");  
   #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_wait(&((*s_queue_signaux).signalisation));
   #           else
               sem_wait(semaphore_signalisation);
   #           endif
         }          }
   
         pthread_mutex_unlock(&((*s_queue_signaux).mutex));  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_post(&((*s_queue_signaux).semaphore));
   #       else
               sem_post(semaphore_queue_signaux);
   #       endif
     }      }
   
     // Interruptions qui arrivent depuis le groupe courant de threads.      // Interruptions qui arrivent depuis le groupe courant de threads.
   
     if (pthread_mutex_trylock(&mutex_interruptions) == 0)      if (pthread_mutex_trylock(&mutex_interruptions) == 0)
     {      {
         if ((*s_etat_processus).pointeur_signal_lecture !=          while((*s_etat_processus).pointeur_signal_lecture !=
                 (*s_etat_processus).pointeur_signal_ecriture)                  (*s_etat_processus).pointeur_signal_ecriture)
         {          {
             // Il y a un signal dans la queue du thread courant. On le traite.              // Il y a un signal dans la queue du thread courant. On le traite.
Line 2289  uprintf("Traité\n"); Line 2447  uprintf("Traité\n");
             (*s_etat_processus).pointeur_signal_lecture =              (*s_etat_processus).pointeur_signal_lecture =
                     ((*s_etat_processus).pointeur_signal_lecture + 1)                      ((*s_etat_processus).pointeur_signal_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
   #           if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               sem_wait(&((*s_queue_signaux).signalisation));
   #           else
               sem_wait(semaphore_signalisation);
   #           endif
         }          }
   
         pthread_mutex_unlock(&mutex_interruptions);          pthread_mutex_unlock(&mutex_interruptions);
Line 2349  nom_segment(unsigned char *chemin, pid_t Line 2513  nom_segment(unsigned char *chemin, pid_t
 }  }
   
   
   /*
   ================================================================================
     Fonctions d'envoi d'un signal à un thread ou à un processus.
   ================================================================================
     Entrée : processus et signal
   --------------------------------------------------------------------------------
     Sortie : erreur
   --------------------------------------------------------------------------------
     Effet de bord : Néant
   ================================================================================
   */
   
 int  int
 envoi_signal_processus(pid_t pid, enum signaux_rpl signal)  envoi_signal_processus(pid_t pid, enum signaux_rpl signal)
 {  {
     int                             segment;  #   ifndef OS2
           int                         segment;
   #   endif
   
   #   ifndef IPCS_SYSV
   #       ifdef SEMAPHORES_NOMMES
               sem_t                   *semaphore;
               sem_t                   *signalisation;
   #       endif
   #   else
   #       ifndef OS2
               int                     desc;
               key_t                   clef;
   #       endif
   #   endif
   
     struct_queue_signaux            *queue;      struct_queue_signaux            *queue;
   
Line 2370  envoi_signal_processus(pid_t pid, enum s Line 2560  envoi_signal_processus(pid_t pid, enum s
             return(1);              return(1);
         }          }
   
         if (pthread_mutex_lock(&((*s_queue_signaux).mutex)) != 0)  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               while(sem_wait(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               while(sem_wait(semaphore_queue_signaux) != 0)
   #       endif
         {          {
             return(1);              if (errno != EINTR)
               {
                   return(1);
               }
         }          }
   
         (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]          (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture]
Line 2384  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;
   
         if (pthread_mutex_unlock(&((*s_queue_signaux).mutex)) != 0)  #       if defined(SEMAPHORES_NOMMES) || defined(IPCS_SYSV)
               if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               if (sem_post(semaphore_queue_signaux) != 0)
   #       endif
           {
               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);              return(1);
         }          }
Line 2393  envoi_signal_processus(pid_t pid, enum s Line 2603  envoi_signal_processus(pid_t pid, enum s
     {      {
         // Le signal est envoyé depuis un processus distinct.          // Le signal est envoyé depuis un processus distinct.
   
         if ((nom = nom_segment(racine_segment, pid)) == NULL)  #       ifdef IPCS_SYSV
         {              if ((nom = nom_segment(racine_segment, pid)) == NULL)
             return(1);              {
         }                  return(1);
               }
   
   #           ifndef OS2 // SysV
                   if ((desc = open(nom, O_RDWR)) == -1)
                   {
                       free(nom);
                       return(1);
                   }
   
                   close(desc);
   
                   if ((clef = ftok(nom, 1)) == -1)
                   {
                       free(nom);
                       return(1);
                   }
   
                   free(nom);
   
                   if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
                           == -1)
                   {
                       return(1);
                   }
   
                   queue = shmat(segment, NULL, 0);
   #           else // OS/2
                   if (DosGetNamedSharedMem((PVOID) &queue, nom,
                           PAG_WRITE | PAG_READ) != 0)
                   {
                       free(nom);
                       return(1);
                   }
   
                   free(nom);
   #           endif
   #       else // POSIX
               if ((nom = nom_segment(racine_segment, pid)) == NULL)
               {
                   return(1);
               }
   
               if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
               {
                   free(nom);
                   return(1);
               }
   
         if ((segment = shm_open(nom, O_RDWR, 0)) == -1)  
         {  
             free(nom);              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);
               }
   #       endif
   
         if ((queue = mmap(NULL, sizeof(struct_queue_signaux),              // À ce moment, le segment de mémoire partagée est projeté
                 PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==              // dans l'espace du processus.
                 MAP_FAILED)  
         {  
             close(segment);  
             return(1);  
         }  
   
 uprintf("Lock\n");  #       ifndef IPCS_SYSV // POSIX
         if (pthread_mutex_lock(&((*queue).mutex)) != 0)  #           ifndef SEMAPHORES_NOMMES
         {                  while(sem_wait(&((*queue).semaphore)) != 0)
 uprintf("Unlock (error)\n");                  {
             return(1);                      if (errno != EINTR)
         }                      {
                           return(1);
                       }
                   }
   #           else
                   if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
                   {
                       return(1);
                   }
   
                   if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
                           == SEM_FAILED)
                   {
                       return(1);
                   }
   
                   while(sem_wait(semaphore) != 0)
                   {
                       if (errno != EINTR)
                       {
                           sem_close(semaphore);
                           sem_close(signalisation);
                           return(1);
                       }
                   }
   #           endif
   #       else // IPCS_SYSV
               while(sem_wait(&((*queue).semaphore)) != 0)
               {
                   if (errno != EINTR)
                   {
                       return(1);
                   }
               }
   #       endif
   
         (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();          (*queue).queue[(*queue).pointeur_ecriture].pid = getpid();
         (*queue).queue[(*queue).pointeur_ecriture].signal = signal;          (*queue).queue[(*queue).pointeur_ecriture].signal = signal;
Line 2427  uprintf("Unlock (error)\n"); Line 2716  uprintf("Unlock (error)\n");
         (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)          (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
 uprintf("Unlock\n");  #       ifndef IPCS_SYSV // POSIX
         if (pthread_mutex_unlock(&((*queue).mutex)) != 0)  #           ifndef SEMAPHORES_NOMMES
         {                  if (sem_post(&((*queue).semaphore)) != 0)
 uprintf("Unlock failed\n");                  {
             return(1);                      return(1);
         }                  }
   
         if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                  if (sem_post(&((*queue).signalisation)) != 0)
         {                  {
             close(segment);                      return(1);
             return(1);                  }
         }  #           else
                   if (sem_post(semaphore) != 0)
                   {
                       sem_close(semaphore);
                       sem_close(signalisation);
                       return(1);
                   }
   
                   if (sem_close(semaphore) != 0)
                   {
                       return(1);
                   }
   
                   if (sem_post(signalisation) != 0)
                   {
                       sem_close(signalisation);
                       return(1);
                   }
   
                   if (sem_close(signalisation) != 0)
                   {
                       return(1);
                   }
   
         close(segment);  #           endif
   
               if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
               {
                   close(segment);
                   return(1);
               }
   #       else // IPCS_SYSV
               if (sem_post(&((*queue).semaphore)) != 0)
               {
                   return(1);
               }
   
               if (sem_post(&((*queue).signalisation)) != 0)
               {
                   return(1);
               }
   
   #           ifndef OS2 // SysV
                   if (shmdt(queue) != 0)
                   {
                       return(1);
                   }
   #           else // OS/2
                   // Pendant de DosGetNamedSHaredMem()
   #           endif
   #       endif
     }      }
   
     return(0);      return(0);
Line 2506  envoi_signal_thread(pthread_t tid, enum Line 2843  envoi_signal_thread(pthread_t tid, enum
         return(1);          return(1);
     }      }
   
   #   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 2522  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);
   
   #   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 2542  envoi_signal_contexte(struct_processus * Line 2903  envoi_signal_contexte(struct_processus *
 void  void
 creation_queue_signaux(struct_processus *s_etat_processus)  creation_queue_signaux(struct_processus *s_etat_processus)
 {  {
     pthread_mutexattr_t             attributs_mutex;      pthread_attr_t                  attributs;
   
     unsigned char                   *nom;      unsigned char                   *nom;
   
     racine_segment = (*s_etat_processus).chemin_fichiers_temporaires;      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,
                   getpid())) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,          if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
             getpid())) == NULL)                  S_IRUSR | S_IWUSR)) == -1)
     {          {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              free(nom);
         return;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
     }              return;
           }
     if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,  
             S_IRUSR | S_IWUSR)) == -1)  
     {  
         free(nom);  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if (ftruncate(f_queue_signaux, 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;
         return;              return;
     }          }
   
     s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),          s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
             PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);                  PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
   
     if (((void *) s_queue_signaux) == ((void *) -1))          if (((void *) s_queue_signaux) == ((void *) -1))
     {  
         if (shm_unlink(nom) == -1)  
         {          {
               if (shm_unlink(nom) == -1)
               {
                   free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
             free(nom);              free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         free(nom);          free(nom);
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     free(nom);  #       ifndef SEMAPHORES_NOMMES
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
               sem_init(&((*s_queue_signaux).signalisation), 1, 0);
   #       else
               if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
                       == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   
     pthread_mutexattr_init(&attributs_mutex);              if ((semaphore_signalisation = sem_init2(1, getpid(),
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);                      SEM_SIGNALISATION)) == SEM_FAILED)
     pthread_mutex_init(&((*s_queue_signaux).mutex), &attributs_mutex);              {
     pthread_mutexattr_destroy(&attributs_mutex);                  (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   #       endif
   
     (*s_queue_signaux).pointeur_lecture = 0;          (*s_queue_signaux).pointeur_lecture = 0;
     (*s_queue_signaux).pointeur_ecriture = 0;          (*s_queue_signaux).pointeur_ecriture = 0;
           (*s_queue_signaux).requete_arret = d_faux;
   
     if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))          if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
     {          {
         (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         return;              return;
     }          }
   #   else // IPCS_SYSV
   #       ifndef OS2
               int                             segment;
               int                             support;
   
 #   else // SystemV              key_t                           clef;
 #   ifndef OS2  
   
     file                            *desc;              // Création d'un segment de données associé au PID du processus
               // courant
   
     key_t                           clef;              if ((nom = nom_segment((*s_etat_processus)
                       .chemin_fichiers_temporaires, getpid())) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
     // Création d'un segment de données associé au PID du processus courant              if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL,
                       S_IRUSR | S_IWUSR)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
   
     chemin = (*s_etat_processus).chemin_fichiers_temporaires;              if ((clef = ftok(nom, 1)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               close(support);
               free(nom);
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,              if ((segment = shmget(clef, sizeof(struct_queue_signaux),
             getpid())) == NULL)                      IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               s_queue_signaux = shmat(segment, NULL, 0);
               f_queue_signaux = segment;
   
               if (((void *) s_queue_signaux) == ((void *) -1))
               {
                   if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
               sem_init(&((*s_queue_signaux).signalisation), 1, 0);
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
               (*s_queue_signaux).requete_arret = d_faux;
   #       else // OS/2
               if ((nom = nom_segment(NULL, getpid())) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom,
                       sizeof(struct_queue_signaux),
                       PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
               {
                   free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               free(nom);
   
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
               sem_init(&((*s_queue_signaux).signalisation), 1, 0);
               (*s_queue_signaux).pointeur_lecture = 0;
               (*s_queue_signaux).pointeur_ecriture = 0;
               (*s_queue_signaux).requete_arret = d_faux;
   #       endif
   #   endif
   
       // Lancement du thread de récupération des signaux.
   
       if (pthread_attr_init(&attributs) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     if ((desc = fopen(nom, "w")) == NULL)      if (pthread_attr_setdetachstate(&attributs,
               PTHREAD_CREATE_JOINABLE) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     fclose(desc);  #   ifdef SCHED_OTHER
       if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
     if ((clef = ftok(nom, 1)) == -1)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   #   endif
   
     free(nom);  #   ifdef PTHREAD_EXPLICIT_SCHED
       if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)
     if ((segment = shmget(clef,  
             nombre_queues * ((2 * longueur_queue) + 4) * sizeof(int),  
             IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   #   endif
   
     fifos = shmat(segment, NULL, 0);  #   ifdef PTHREAD_SCOPE_SYSTEM
       if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
     if (((void *) fifos) == ((void *) -1))  
     {      {
         if (shmctl(segment, IPC_RMID, 0) == -1)          (*s_etat_processus).erreur_systeme = d_es_processus;
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return;  
         }  
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;          return;
     }      }
   #   endif
   
 #   else      if (pthread_attr_destroy(&attributs) != 0)
   
     if ((nom = nom_segment(NULL, getpid())) == NULL)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues *      if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
             ((2 * longueur_queue) + 4) * sizeof(int),              thread_surveillance_signaux, s_etat_processus) != 0)
             PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)  
     {      {
         free(nom);          (*s_etat_processus).erreur_systeme = d_es_processus;
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;          return;
     }      }
   
     free(nom);  
     fifos = ptr_os2;  
   
 #   endif  
 #   endif  
   
     return;      return;
 }  }
   
Line 2704  creation_queue_signaux(struct_processus Line 3138  creation_queue_signaux(struct_processus
 void  void
 liberation_queue_signaux(struct_processus *s_etat_processus)  liberation_queue_signaux(struct_processus *s_etat_processus)
 {  {
       // 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
               if (shmdt(s_queue_signaux) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
 #       else // OS/2  #       else // OS/2
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
   #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
               sem_close(&((*s_queue_signaux).signalisation));
   #       else
               sem_close(semaphore_queue_signaux);
               sem_close(semaphore_signalisation);
   #       endif
   
         if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2738  liberation_queue_signaux(struct_processu Line 3197  liberation_queue_signaux(struct_processu
 void  void
 destruction_queue_signaux(struct_processus *s_etat_processus)  destruction_queue_signaux(struct_processus *s_etat_processus)
 {  {
     unsigned char       *nom;  #   ifndef OS2
           unsigned char       *nom;
   #   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.
   
     if (shmdt(fifos) == -1)              if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1)
     {              {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_processus;
         return;                  return;
     }              }
   
     if (shmctl(segment, IPC_RMID, 0) == -1)              unlink((*s_queue_signaux).semaphore.path);
     {              free((*s_queue_signaux).semaphore.path);
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,              if (semctl((*s_queue_signaux).signalisation.sem, 0, IPC_RMID) == -1)
             getpid())) == NULL)              {
     {                  (*s_etat_processus).erreur_systeme = d_es_processus;
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  return;
         return;              }
     }  
   
     // FERMER LE FICHIER              unlink((*s_queue_signaux).signalisation.path);
               free((*s_queue_signaux).signalisation.path);
   
     unlink(nom);              if (shmdt(s_queue_signaux) == -1)
     free(nom);              {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
 #   else              if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
     if (DosFreeMem(fifos) != 0)              if ((nom = nom_segment((*s_etat_processus)
     {                      .chemin_fichiers_temporaires, getpid())) == NULL)
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              {
         return;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
     }                  return;
               }
   
     // FERMER LE FICHIER              unlink(nom);
               free(nom);
   #       else
               sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   
 #   endif              sem_close(&((*s_queue_signaux).signalisation));
               sem_destroy(&((*s_queue_signaux).signalisation));
   
               if (DosFreeMem(s_queue_signaux) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   #       endif
 #   else // POSIX  #   else // POSIX
   #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   
               sem_close(&((*s_queue_signaux).signalisation));
               sem_destroy(&((*s_queue_signaux).signalisation));
   #       else
               sem_close(semaphore_queue_signaux);
               sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
   
     if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)              sem_close(semaphore_signalisation);
     {              sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  #       endif
         return;  
     }  
   
     if ((nom = nom_segment(NULL, getpid())) == NULL)          if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)
     {          {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;              return;
     }          }
   
     close(f_queue_signaux);          if ((nom = nom_segment(NULL, getpid())) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
     if (shm_unlink(nom) != 0)          close(f_queue_signaux);
     {  
         free(nom);  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     free(nom);          if (shm_unlink(nom) != 0)
           {
               free(nom);
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           free(nom);
 #   endif  #   endif
   
     return;      return;
Removed from v.1.69  
changed lines
  Added in v.1.99

CVSweb interface <joel.bertrand@systella.fr>