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

Diff for /rpl/src/interruptions.c between versions 1.141 and 1.167

version 1.141, 2014/04/23 13:43:01 version 1.167, 2016/03/09 22:12:06
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.17    RPL/2 (R) version 4.1.25
   Copyright (C) 1989-2014 Dr. BERTRAND Joël    Copyright (C) 1989-2016 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 109  thread_surveillance_signaux(void *argume Line 109  thread_surveillance_signaux(void *argume
             sem_post(semaphore_signalisation);              sem_post(semaphore_signalisation);
   
             nombre_signaux_envoyes = 0;              nombre_signaux_envoyes = 0;
             sched_yield();  
   
             // Dans un premier temps, on verrouille la queue des signaux              // Dans un premier temps, on verrouille la queue des signaux
             // affectée au processus courant pour vérifier s'il y a quelque              // affectée au processus courant pour vérifier s'il y a quelque
Line 128  thread_surveillance_signaux(void *argume Line 127  thread_surveillance_signaux(void *argume
   
                 nombre_signaux_envoyes++;                  nombre_signaux_envoyes++;
                 kill(getpid(), SIGALRM);                  kill(getpid(), SIGALRM);
                   sched_yield();
             }              }
   
             sem_post(semaphore_queue_signaux);              sem_post(semaphore_queue_signaux);
Line 160  thread_surveillance_signaux(void *argume Line 160  thread_surveillance_signaux(void *argume
                         nombre_signaux_envoyes++;                          nombre_signaux_envoyes++;
                         pthread_kill((*((struct_thread *)                          pthread_kill((*((struct_thread *)
                                 (*l_element_courant).donnee)).tid, SIGALRM);                                  (*l_element_courant).donnee)).tid, SIGALRM);
                           sched_yield();
                     }                      }
   
                     pthread_mutex_unlock(&((*(*((struct_thread *)                      pthread_mutex_unlock(&((*(*((struct_thread *)
Line 766  liberation_threads(struct_processus *s_e Line 767  liberation_threads(struct_processus *s_e
                 }                  }
             }              }
   
             // ne peut être effacé qu'une seule fois              // Ne peut être effacé qu'une seule fois
             if (suppression_variables_partagees == d_faux)              if (suppression_variables_partagees == d_faux)
             {              {
                 suppression_variables_partagees = d_vrai;                  suppression_variables_partagees = d_vrai;
   
                 liberation_arbre_variables_partagees(s_etat_processus,                  liberation_arbre_variables_partagees(s_etat_processus,
                         (*(*s_etat_processus).s_arbre_variables_partagees));                          (*(*s_etat_processus).s_arbre_variables_partagees));
                   (*(*s_etat_processus).s_arbre_variables_partagees) = NULL;
   
                 l_element_partage_courant = (*(*s_etat_processus)                  l_element_partage_courant = (*(*s_etat_processus)
                         .l_liste_variables_partagees);                          .l_liste_variables_partagees);
Line 784  liberation_threads(struct_processus *s_e Line 786  liberation_threads(struct_processus *s_e
                     free(l_element_partage_courant);                      free(l_element_partage_courant);
                     l_element_partage_courant = l_element_partage_suivant;                      l_element_partage_courant = l_element_partage_suivant;
                 }                  }
   
                   (*(*s_etat_processus).l_liste_variables_partagees) = NULL;
             }              }
   
             liberation_arbre_variables(s_etat_processus,              liberation_arbre_variables(s_etat_processus,
Line 1265  liberation_threads(struct_processus *s_e Line 1269  liberation_threads(struct_processus *s_e
 #           endif  #           endif
   
             liberation_contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              liberation_allocateur_buffer(s_etat_processus);
               sys_free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
         }          }
Line 1468  verrouillage_gestionnaire_signaux(struct Line 1473  verrouillage_gestionnaire_signaux(struct
         return;          return;
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  
     if (sem_post(&semaphore_gestionnaires_signaux) == -1)  
 #   else  
     if (sem_post(semaphore_gestionnaires_signaux) == -1)  
 #   endif  
     {  
 #       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"));  
         return;  
     }  
   
     return;      return;
 }  }
   
Line 1612  thread_signaux(void *argument) Line 1602  thread_signaux(void *argument)
             pthread_exit(NULL);              pthread_exit(NULL);
         }          }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
         read(fds.fd, &signal, 1);          read(fds.fd, &signal, 1);
   
   #   pragma GCC diagnostic pop
   
         if (signal != (0xFF & rpl_sigmax))          if (signal != (0xFF & rpl_sigmax))
         {          {
             envoi_signal_processus(getpid(), signal);              envoi_signal_processus(getpid(), signal);
Line 1636  interruption1(int signal) Line 1631  interruption1(int signal)
   
     test_signal(signal);      test_signal(signal);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     switch(signal)      switch(signal)
     {      {
         case SIGINT:          case SIGINT:
Line 1658  interruption1(int signal) Line 1656  interruption1(int signal)
             break;              break;
     }      }
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1679  interruption2(int signal) Line 1679  interruption2(int signal)
     test_signal(signal);      test_signal(signal);
   
     signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);      signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));      write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1702  interruption3(int signal) Line 1709  interruption3(int signal)
         kill(pid_processus_pere, SIGUSR1);          kill(pid_processus_pere, SIGUSR1);
     }      }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if (signal != SIGUSR2)      if (signal != SIGUSR2)
     {      {
         write(STDERR_FILENO, message_1, strlen(message_1));          write(STDERR_FILENO, message_1, strlen(message_1));
Line 1711  interruption3(int signal) Line 1721  interruption3(int signal)
         write(STDERR_FILENO, message_2, strlen(message_2));          write(STDERR_FILENO, message_2, strlen(message_2));
     }      }
   
   #   pragma GCC diagnostic pop
   
     _exit(EXIT_FAILURE);      _exit(EXIT_FAILURE);
 }  }
   
Line 1725  interruption4(int signal) Line 1737  interruption4(int signal)
     test_signal(signal);      test_signal(signal);
   
     signal_tronque = (unsigned char) (rpl_sighup & 0xFF);      signal_tronque = (unsigned char) (rpl_sighup & 0xFF);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));      write(pipe_signaux, &signal_tronque, sizeof(signal_tronque));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 1741  interruption5(int signal) Line 1760  interruption5(int signal)
   
     test_signal(signal);      test_signal(signal);
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);          signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF);
Line 1748  interruption5(int signal) Line 1770  interruption5(int signal)
     }      }
   
     write(STDERR_FILENO, message, strlen(message));      write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
     return;      return;
 }  }
   
Line 2029  interruption_violation_access(void *adre Line 2054  interruption_violation_access(void *adre
         return(0);          return(0);
     }      }
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     write(STDERR_FILENO, message, strlen(message));      write(STDERR_FILENO, message, strlen(message));
   
   #   pragma GCC diagnostic pop
   
     if (pid_processus_pere == getpid())      if (pid_processus_pere == getpid())
     {      {
         longjmp(contexte_initial, -1);          longjmp(contexte_initial, -1);
Line 2290  signal_hup(struct_processus *s_etat_proc Line 2320  signal_hup(struct_processus *s_etat_proc
             (unsigned long long) getpid(),              (unsigned long long) getpid(),
             (unsigned long long) pthread_self());              (unsigned long long) pthread_self());
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wunused-result"
   
     if ((fichier = fopen(nom, "w+")) != NULL)      if ((fichier = fopen(nom, "w+")) != NULL)
     {      {
         fclose(fichier);          fclose(fichier);
Line 2300  signal_hup(struct_processus *s_etat_proc Line 2333  signal_hup(struct_processus *s_etat_proc
   
     freopen("/dev/null", "r", stdin);      freopen("/dev/null", "r", stdin);
   
   #   pragma GCC diagnostic pop
   
     if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)      if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
     {      {
         printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),          printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(),
Line 2436  scrutation_interruptions(struct_processu Line 2471  scrutation_interruptions(struct_processu
                     ((*s_queue_signaux).pointeur_lecture + 1)                      ((*s_queue_signaux).pointeur_lecture + 1)
                     % LONGUEUR_QUEUE_SIGNAUX;                      % LONGUEUR_QUEUE_SIGNAUX;
   
   #           ifndef IPCS_SYSV
             if (msync(s_queue_signaux, sizeof(s_queue_signaux),              if (msync(s_queue_signaux, sizeof(s_queue_signaux),
                     MS_ASYNC | MS_INVALIDATE) != 0)                      MS_ASYNC | MS_INVALIDATE) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   #           endif
   
             while(sem_wait(semaphore_signalisation) != 0)              while(sem_wait(semaphore_signalisation) != 0)
             {              {
Line 2458  scrutation_interruptions(struct_processu Line 2495  scrutation_interruptions(struct_processu
   
     // Interruptions qui arrivent depuis le groupe courant de threads.      // Interruptions qui arrivent depuis le groupe courant de threads.
   
     if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)      if (pthread_mutex_trylock(&mutex_liste_threads) == 0)
     {      {
         while((*s_etat_processus).pointeur_signal_lecture !=          if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0)
                 (*s_etat_processus).pointeur_signal_ecriture)  
         {          {
             // Il y a un signal dans la queue du thread courant. On le traite.              while((*s_etat_processus).pointeur_signal_lecture !=
                       (*s_etat_processus).pointeur_signal_ecriture)
               {
                   // Il y a un signal dans la queue du thread courant.
                   // On le traite.
   
             envoi_interruptions(s_etat_processus,                  envoi_interruptions(s_etat_processus,
                     (*s_etat_processus).signaux_en_queue                          (*s_etat_processus).signaux_en_queue
                     [(*s_etat_processus).pointeur_signal_lecture],                          [(*s_etat_processus).pointeur_signal_lecture],
                     getpid());                          getpid());
             (*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;
   
             while(sem_wait(semaphore_signalisation) != 0)                  while(sem_wait(semaphore_signalisation) != 0)
             {  
                 if (errno != EINTR)  
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      if (errno != EINTR)
                     return;                      {
                           if (pthread_mutex_unlock(&mutex_liste_threads) != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
   
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
                 }                  }
             }              }
   
               pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));
         }          }
   
         pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux));          pthread_mutex_unlock(&mutex_liste_threads);
     }      }
   
     return;      return;
Line 2511  nom_segment(unsigned char *chemin, pid_t Line 2560  nom_segment(unsigned char *chemin, pid_t
 #   ifdef IPCS_SYSV // !POSIX  #   ifdef IPCS_SYSV // !POSIX
 #       ifndef OS2 // !OS2  #       ifndef OS2 // !OS2
   
             if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) *              if ((fichier = sys_malloc((strlen(chemin) + 1 + 256 + 1) *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                 return(NULL);                  return(NULL);
Line 2519  nom_segment(unsigned char *chemin, pid_t Line 2568  nom_segment(unsigned char *chemin, pid_t
   
             sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);              sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid);
 #       else // OS2  #       else // OS2
             if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char)))              if ((fichier = sys_malloc((10 + 256 + 1) * sizeof(unsigned char)))
                     == NULL)                      == NULL)
             {              {
                 return(NULL);                  return(NULL);
Line 2529  nom_segment(unsigned char *chemin, pid_t Line 2578  nom_segment(unsigned char *chemin, pid_t
 #       endif // OS2  #       endif // OS2
 #   else // POSIX  #   else // POSIX
   
         if ((fichier = malloc((1 + 256 + 1) *          if ((fichier = sys_malloc((1 + 256 + 1) *
                 sizeof(unsigned char))) == NULL)                  sizeof(unsigned char))) == NULL)
         {          {
             return(NULL);              return(NULL);
Line 2606  envoi_signal_processus(pid_t pid, enum s Line 2655  envoi_signal_processus(pid_t pid, enum s
                 ((*s_queue_signaux).pointeur_ecriture + 1)                  ((*s_queue_signaux).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
   #       ifndef IPCS_SYSV
         if (msync(s_queue_signaux, sizeof(s_queue_signaux),          if (msync(s_queue_signaux, sizeof(s_queue_signaux),
                 MS_ASYNC | MS_INVALIDATE) != 0)                  MS_ASYNC | MS_INVALIDATE) != 0)
         {          {
               sem_post(semaphore_queue_signaux);
             return(1);              return(1);
         }          }
   #       endif
   
         if (sem_post(semaphore_queue_signaux) != 0)          if (sem_post(semaphore_queue_signaux) != 0)
         {          {
Line 2635  envoi_signal_processus(pid_t pid, enum s Line 2687  envoi_signal_processus(pid_t pid, enum s
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if ((desc = open(nom, O_RDWR)) == -1)                  if ((desc = open(nom, O_RDWR)) == -1)
                 {                  {
                     free(nom);                      sys_free(nom);
                     return(1);                      return(1);
                 }                  }
   
Line 2643  envoi_signal_processus(pid_t pid, enum s Line 2695  envoi_signal_processus(pid_t pid, enum s
   
                 if ((clef = ftok(nom, 1)) == -1)                  if ((clef = ftok(nom, 1)) == -1)
                 {                  {
                     free(nom);                      sys_free(nom);
                     return(1);                      return(1);
                 }                  }
   
                 free(nom);                  sys_free(nom);
   
                 if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))                  if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0))
                         == -1)                          == -1)
Line 2660  envoi_signal_processus(pid_t pid, enum s Line 2712  envoi_signal_processus(pid_t pid, enum s
                 if (DosGetNamedSharedMem((PVOID) &queue, nom,                  if (DosGetNamedSharedMem((PVOID) &queue, nom,
                         PAG_WRITE | PAG_READ) != 0)                          PAG_WRITE | PAG_READ) != 0)
                 {                  {
                     free(nom);                      sys_free(nom);
                     return(1);                      return(1);
                 }                  }
   
                 free(nom);                  sys_free(nom);
 #           endif  #           endif
 #       else // POSIX  #       else // POSIX
             if ((nom = nom_segment(racine_segment, pid)) == NULL)              if ((nom = nom_segment(racine_segment, pid)) == NULL)
Line 2674  envoi_signal_processus(pid_t pid, enum s Line 2726  envoi_signal_processus(pid_t pid, enum s
   
             if ((segment = shm_open(nom, O_RDWR, 0)) == -1)              if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
             {              {
                 free(nom);                  sys_free(nom);
                 return(1);                  return(1);
             }              }
   
             free(nom);              sys_free(nom);
   
             if ((queue = mmap(NULL, sizeof(struct_queue_signaux),              if ((queue = mmap(NULL, sizeof(struct_queue_signaux),
                     PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==                      PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) ==
Line 2719  envoi_signal_processus(pid_t pid, enum s Line 2771  envoi_signal_processus(pid_t pid, enum s
         (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)          (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1)
                 % LONGUEUR_QUEUE_SIGNAUX;                  % LONGUEUR_QUEUE_SIGNAUX;
   
   #       ifndef IPCS_SYSV
         if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)          if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
         {          {
             sem_close(semaphore);              sem_close(semaphore);
             sem_close(signalisation);              sem_close(signalisation);
             return(1);              return(1);
         }          }
   #       endif
   
         if (sem_post(semaphore) != 0)          if (sem_post(semaphore) != 0)
         {          {
Line 2893  creation_queue_signaux(struct_processus Line 2947  creation_queue_signaux(struct_processus
         if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,          if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL,
                 S_IRUSR | S_IWUSR)) == -1)                  S_IRUSR | S_IWUSR)) == -1)
         {          {
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)          if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
         {          {
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 2912  creation_queue_signaux(struct_processus Line 2966  creation_queue_signaux(struct_processus
         {          {
             if (shm_unlink(nom) == -1)              if (shm_unlink(nom) == -1)
             {              {
                 free(nom);                  sys_free(nom);
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         free(nom);          sys_free(nom);
   
         if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))          if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE))
                 == SEM_FAILED)                  == SEM_FAILED)
Line 2950  creation_queue_signaux(struct_processus Line 3004  creation_queue_signaux(struct_processus
   
         (*s_queue_signaux).requete_arret = d_faux;          (*s_queue_signaux).requete_arret = d_faux;
   
         if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))          if (msync(s_queue_signaux, sizeof(struct_queue_signaux),
                   MS_ASYNC | MS_INVALIDATE) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 2986  creation_queue_signaux(struct_processus Line 3041  creation_queue_signaux(struct_processus
             }              }
   
             close(support);              close(support);
             free(nom);              sys_free(nom);
   
             if ((segment = shmget(clef, sizeof(struct_queue_signaux),              if ((segment = shmget(clef, sizeof(struct_queue_signaux),
                     IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)                      IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1)
Line 3046  creation_queue_signaux(struct_processus Line 3101  creation_queue_signaux(struct_processus
                     sizeof(struct_queue_signaux),                      sizeof(struct_queue_signaux),
                     PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)                      PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
             {              {
                 free(nom);                  sys_free(nom);
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             free(nom);              sys_free(nom);
   
             sem_init(&((*s_queue_signaux).semaphore), 1, 1);              sem_init(&((*s_queue_signaux).semaphore), 1, 1);
             sem_init(&((*s_queue_signaux).signalisation), 1, 0);              sem_init(&((*s_queue_signaux).signalisation), 1, 0);
Line 3115  creation_queue_signaux(struct_processus Line 3170  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
       (*s_queue_signaux).controle = getpid();
   
   #   ifndef IPCS_SYSV
       if (msync(s_queue_signaux, sizeof(s_queue_signaux),
               MS_ASYNC | MS_INVALIDATE) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   #           endif
   
     return;      return;
 }  }
   
Line 3136  void Line 3202  void
 liberation_queue_signaux(struct_processus *s_etat_processus)  liberation_queue_signaux(struct_processus *s_etat_processus)
 {  {
     sem_wait(semaphore_arret_signalisation);      sem_wait(semaphore_arret_signalisation);
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
   #   ifndef IPCS_SYSV
     msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);      msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
   #   endif
   
     sem_post(semaphore_arret_signalisation);      sem_post(semaphore_arret_signalisation);
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      if (getpid() == (*s_queue_signaux).controle)
       {
           pthread_join((*s_queue_signaux).thread_signaux, NULL);
       }
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
Line 3198  destruction_queue_signaux(struct_process Line 3269  destruction_queue_signaux(struct_process
     sem_wait(semaphore_arret_signalisation);      sem_wait(semaphore_arret_signalisation);
   
     (*s_queue_signaux).requete_arret = d_vrai;      (*s_queue_signaux).requete_arret = d_vrai;
   
   #   ifndef IPCS_SYSV
     msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);      msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);
   #   endif
   
     sem_post(semaphore_arret_signalisation);      sem_post(semaphore_arret_signalisation);
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.      // Incrémenter le sémaphore pour être sûr de le débloquer.
   
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
   
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
Line 3218  destruction_queue_signaux(struct_process Line 3292  destruction_queue_signaux(struct_process
             }              }
   
             unlink((*semaphore_queue_signaux).path);              unlink((*semaphore_queue_signaux).path);
             free((*semaphore_queue_signaux).path);              sys_free((*semaphore_queue_signaux).path);
   
             if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1)              if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1)
             {              {
Line 3227  destruction_queue_signaux(struct_process Line 3301  destruction_queue_signaux(struct_process
             }              }
   
             unlink((*semaphore_signalisation).path);              unlink((*semaphore_signalisation).path);
             free((*semaphore_signalisation).path);              sys_free((*semaphore_signalisation).path);
   
             if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1)              if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1)
             {              {
Line 3236  destruction_queue_signaux(struct_process Line 3310  destruction_queue_signaux(struct_process
             }              }
   
             unlink((*semaphore_arret_signalisation).path);              unlink((*semaphore_arret_signalisation).path);
             free((*semaphore_arret_signalisation).path);              sys_free((*semaphore_arret_signalisation).path);
   
             if (shmdt(s_queue_signaux) == -1)              if (shmdt(s_queue_signaux) == -1)
             {              {
Line 3258  destruction_queue_signaux(struct_process Line 3332  destruction_queue_signaux(struct_process
             }              }
   
             unlink(nom);              unlink(nom);
             free(nom);              sys_free(nom);
 #       else  #       else
             sem_close(&((*s_queue_signaux).semaphore));              sem_close(&((*s_queue_signaux).semaphore));
             sem_destroy(&((*s_queue_signaux).semaphore));              sem_destroy(&((*s_queue_signaux).semaphore));
Line 3276  destruction_queue_signaux(struct_process Line 3350  destruction_queue_signaux(struct_process
             }              }
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
         sem_close(semaphore_queue_signaux);  
         sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);          sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE);
   
         sem_close(semaphore_signalisation);  
         sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);          sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION);
   
         sem_close(semaphore_arret_signalisation);  
         sem_destroy2(semaphore_arret_signalisation, getpid(),          sem_destroy2(semaphore_arret_signalisation, getpid(),
                 SEM_ARRET_SIGNALISATION);                  SEM_ARRET_SIGNALISATION);
   
Line 3302  destruction_queue_signaux(struct_process Line 3371  destruction_queue_signaux(struct_process
   
         if (shm_unlink(nom) != 0)          if (shm_unlink(nom) != 0)
         {          {
             free(nom);              sys_free(nom);
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
   
         free(nom);          sys_free(nom);
 #   endif  #   endif
   
     return;      return;
Removed from v.1.141  
changed lines
  Added in v.1.167

CVSweb interface <joel.bertrand@systella.fr>