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

Diff for /rpl/src/interruptions.c between versions 1.168 and 1.170

version 1.168, 2016/03/15 16:31:15 version 1.170, 2016/03/17 16:31:36
Line 1615  thread_signaux(void *argument) Line 1615  thread_signaux(void *argument)
   
         if (signal != (0xFF & rpl_sigmax))          if (signal != (0xFF & rpl_sigmax))
         {          {
             envoi_signal_processus(getpid(), signal);              envoi_signal_processus(getpid(), signal, d_faux);
             // Un signal SIGALRM est envoyé par le thread de surveillance              // Un signal SIGALRM est envoyé par le thread de surveillance
             // des signaux jusqu'à ce que les signaux soient tous traités.              // des signaux jusqu'à ce que les signaux soient tous traités.
         }          }
Line 1805  signal_alrm(struct_processus *s_etat_pro Line 1805  signal_alrm(struct_processus *s_etat_pro
         {          {
             // On n'est pas dans le processus père, on remonte le signal.              // On n'est pas dans le processus père, on remonte le signal.
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigalrm);                      rpl_sigalrm, d_faux);
         }          }
         else          else
         {          {
Line 1850  signal_term(struct_processus *s_etat_pro Line 1850  signal_term(struct_processus *s_etat_pro
         if ((*s_etat_processus).pid_processus_pere != getpid())          if ((*s_etat_processus).pid_processus_pere != getpid())
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigterm);                      rpl_sigterm, d_faux);
         }          }
         else          else
         {          {
Line 1904  signal_int(struct_processus *s_etat_proc Line 1904  signal_int(struct_processus *s_etat_proc
         if ((*s_etat_processus).pid_processus_pere != getpid())          if ((*s_etat_processus).pid_processus_pere != getpid())
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigint);                      rpl_sigint, d_faux);
         }          }
         else          else
         {          {
Line 1975  signal_tstp(struct_processus *s_etat_pro Line 1975  signal_tstp(struct_processus *s_etat_pro
         if ((*s_etat_processus).var_volatile_processus_pere == 0)          if ((*s_etat_processus).var_volatile_processus_pere == 0)
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigtstp);                      rpl_sigtstp, d_faux);
         }          }
         else          else
         {          {
Line 2356  traitement_exceptions_gsl(const char *re Line 2356  traitement_exceptions_gsl(const char *re
         int line, int gsl_errno)          int line, int gsl_errno)
 {  {
     code_erreur_gsl = gsl_errno;      code_erreur_gsl = gsl_errno;
     envoi_signal_processus(getpid(), rpl_sigexcept);      envoi_signal_processus(getpid(), rpl_sigexcept, d_faux);
     return;      return;
 }  }
   
Line 2609  nom_segment(unsigned char *chemin, pid_t Line 2609  nom_segment(unsigned char *chemin, pid_t
 */  */
   
 int  int
 envoi_signal_processus(pid_t pid, enum signaux_rpl signal)  envoi_signal_processus(pid_t pid, enum signaux_rpl signal,
           logical1 test_ouverture)
 {  {
 #   ifndef OS2  #   ifndef OS2
         int                         segment;          int                         segment;
Line 2629  envoi_signal_processus(pid_t pid, enum s Line 2630  envoi_signal_processus(pid_t pid, enum s
   
     struct_queue_signaux            *queue;      struct_queue_signaux            *queue;
   
       struct timespec                 attente;
   
     unsigned char                   *nom;      unsigned char                   *nom;
   
     // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en      // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en
Line 2690  envoi_signal_processus(pid_t pid, enum s Line 2693  envoi_signal_processus(pid_t pid, enum s
             }              }
   
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if ((desc = open(nom, O_RDWR)) == -1)                  if (test_ouverture == d_vrai)
                 {                  {
                     sys_free(nom);                      attente.tv_sec = 0;
                     return(1);                      attente.tv_nsec = GRANULARITE_us * 1000;
   
                       while((desc = open(nom, O_RDWR)) == -1)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                   }
                   else
                   {
                       if ((desc = open(nom, O_RDWR)) == -1)
                       {
                           sys_free(nom);
                           return(1);
                       }
                 }                  }
   
                 close(desc);                  close(desc);
Line 2729  envoi_signal_processus(pid_t pid, enum s Line 2746  envoi_signal_processus(pid_t pid, enum s
                 return(1);                  return(1);
             }              }
   
             if ((segment = shm_open(nom, O_RDWR, 0)) == -1)              if (test_ouverture == d_vrai)
             {              {
                 sys_free(nom);                  attente.tv_sec = 0;
                 return(1);                  attente.tv_nsec = GRANULARITE_us * 1000;
   
                   while((segment = shm_open(nom, O_RDWR, 0)) == -1)
                   {
                       nanosleep(&attente, NULL);
                       INCR_GRANULARITE(attente.tv_nsec);
                   }
               }
               else
               {
                   if ((segment = shm_open(nom, O_RDWR, 0)) == -1)
                   {
                       sys_free(nom);
                       return(1);
                   }
             }              }
   
             sys_free(nom);              sys_free(nom);
Line 2749  envoi_signal_processus(pid_t pid, enum s Line 2780  envoi_signal_processus(pid_t pid, enum s
         // À ce moment, le segment de mémoire partagée est projeté          // À ce moment, le segment de mémoire partagée est projeté
         // dans l'espace du processus.          // dans l'espace du processus.
   
   
         if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)          if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED)
         {          {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
             return(1);              return(1);
         }          }
   
         if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))          if ((signalisation = sem_open2(pid, SEM_SIGNALISATION))
                 == SEM_FAILED)                  == SEM_FAILED)
         {          {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(semaphore);
             return(1);              return(1);
         }          }
   
Line 2764  envoi_signal_processus(pid_t pid, enum s Line 2843  envoi_signal_processus(pid_t pid, enum s
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
   #               ifndef IPCS_SYSV // POSIX
                       if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE)
                               != 0)
                       {
                           munmap(queue, sizeof(struct_queue_signaux));
                           return(1);
                       }
   
                       if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                       {
                           close(segment);
                       return(1);
                   }
   #               else // IPCS_SYSV
   #                   ifndef OS2 // SysV
                           if (shmdt(queue) != 0)
                           {
                               return(1);
                           }
   #                   else // OS/2
                           // Pendant de DosGetNamedSHaredMem()
   #                   endif
   #               endif
   
                 sem_close(semaphore);                  sem_close(semaphore);
                 sem_close(signalisation);                  sem_close(signalisation);
                 return(1);                  return(1);
Line 2776  envoi_signal_processus(pid_t pid, enum s Line 2879  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)  
         {  
             sem_close(semaphore);  
             sem_close(signalisation);  
             return(1);  
         }  
 #       endif  
   
         if (sem_post(semaphore) != 0)          if (sem_post(semaphore) != 0)
         {          {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
             sem_close(semaphore);              sem_close(semaphore);
             sem_close(signalisation);              sem_close(signalisation);
             return(1);              return(1);
Line 2794  envoi_signal_processus(pid_t pid, enum s Line 2911  envoi_signal_processus(pid_t pid, enum s
   
         if (sem_close(semaphore) != 0)          if (sem_close(semaphore) != 0)
         {          {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
               sem_close(signalisation);
             return(1);              return(1);
         }          }
   
         if (sem_post(signalisation) != 0)          if (sem_post(signalisation) != 0)
         {          {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
             sem_close(signalisation);              sem_close(signalisation);
             return(1);              return(1);
         }          }
   
         if (sem_close(signalisation) != 0)          if (sem_close(signalisation) != 0)
         {          {
   #           ifndef IPCS_SYSV // POSIX
                   if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                   {
                       munmap(queue, sizeof(struct_queue_signaux));
                       return(1);
                   }
   
                   if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                   {
                       close(segment);
                       return(1);
                   }
   #           else // IPCS_SYSV
   #               ifndef OS2 // SysV
                       if (shmdt(queue) != 0)
                       {
                           return(1);
                       }
   #               else // OS/2
                       // Pendant de DosGetNamedSHaredMem()
   #               endif
   #           endif
   
             return(1);              return(1);
         }          }
   
 #       ifndef IPCS_SYSV // POSIX  #       ifndef IPCS_SYSV // POSIX
               if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
               {
                   munmap(queue, sizeof(struct_queue_signaux));
                   return(1);
               }
   
             if (munmap(queue, sizeof(struct_queue_signaux)) != 0)              if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
             {              {
                 close(segment);                  close(segment);
Line 3285  destruction_queue_signaux(struct_process Line 3478  destruction_queue_signaux(struct_process
   
     sem_post(semaphore_signalisation);      sem_post(semaphore_signalisation);
     arret_thread_signaux(s_etat_processus);      arret_thread_signaux(s_etat_processus);
       pthread_join((*s_queue_signaux).thread_signaux, NULL);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
Removed from v.1.168  
changed lines
  Added in v.1.170

CVSweb interface <joel.bertrand@systella.fr>