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

Diff for /rpl/src/interruptions.c between versions 1.173 and 1.180

version 1.173, 2016/03/22 09:22:23 version 1.180, 2016/07/20 16:23:59
Line 106  thread_surveillance_signaux(void *argume Line 106  thread_surveillance_signaux(void *argume
                 break;                  break;
             }              }
   
             sem_post(semaphore_arret_signalisation);  
             sem_post(semaphore_signalisation);              sem_post(semaphore_signalisation);
   
             nombre_signaux_envoyes = 0;              nombre_signaux_envoyes = 0;
Line 138  thread_surveillance_signaux(void *argume Line 137  thread_surveillance_signaux(void *argume
             }              }
   
             sem_post(semaphore_queue_signaux);              sem_post(semaphore_queue_signaux);
               sem_post(semaphore_arret_signalisation);
   
             // Dans un second temps, on balaye toutes les queues de signaux              // Dans un second temps, on balaye toutes les queues de signaux
             // des threads du processus courant.              // des threads du processus courant.
Line 1549  lancement_thread_signaux(struct_processu Line 1549  lancement_thread_signaux(struct_processu
         return(d_erreur);          return(d_erreur);
     }      }
   
       if (pthread_attr_destroy(&attributs) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(d_erreur);
       }
   
     return(d_absence_erreur);      return(d_absence_erreur);
 }  }
   
Line 1573  arret_thread_signaux(struct_processus *s Line 1579  arret_thread_signaux(struct_processus *s
   
     pthread_join((*s_etat_processus).thread_signaux, NULL);      pthread_join((*s_etat_processus).thread_signaux, NULL);
   
     close((*s_etat_processus).pipe_signaux[0]);  
     close((*s_etat_processus).pipe_signaux[1]);      close((*s_etat_processus).pipe_signaux[1]);
   
     return(d_absence_erreur);      return(d_absence_erreur);
 }  }
   
Line 1596  thread_signaux(void *argument) Line 1600  thread_signaux(void *argument)
     pipe = (*s_etat_processus).pipe_signaux;      pipe = (*s_etat_processus).pipe_signaux;
     fds.fd = pipe[0];      fds.fd = pipe[0];
     fds.events = POLLIN;      fds.events = POLLIN;
     fds.revents = 0;  
   
     sigfillset(&masque);      sigfillset(&masque);
     pthread_sigmask(SIG_BLOCK, &masque, NULL);      pthread_sigmask(SIG_BLOCK, &masque, NULL);
   
     do      do
     {      {
         if (poll(&fds, 1, -1) == -1)          fds.revents = 0;
   
           while(poll(&fds, 1, -1) == -1)
         {          {
             pthread_exit(NULL);              if (errno != EINTR)
               {
                   close((*s_etat_processus).pipe_signaux[0]);
                   pthread_exit(NULL);
               }
         }          }
   
         if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)          if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1)
         {          {
               close((*s_etat_processus).pipe_signaux[0]);
             pthread_exit(NULL);              pthread_exit(NULL);
         }          }
   
Line 1621  thread_signaux(void *argument) Line 1631  thread_signaux(void *argument)
         }          }
     } while(signal != (0xFF & rpl_sigmax));      } while(signal != (0xFF & rpl_sigmax));
   
       close((*s_etat_processus).pipe_signaux[0]);
     pthread_exit(NULL);      pthread_exit(NULL);
 }  }
   
Line 2480  scrutation_interruptions(struct_processu Line 2491  scrutation_interruptions(struct_processu
             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);
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
Line 2731  envoi_signal_processus(pid_t pid, enum s Line 2743  envoi_signal_processus(pid_t pid, enum s
   
                 queue = shmat(segment, NULL, 0);                  queue = shmat(segment, NULL, 0);
 #           else // OS/2  #           else // OS/2
                 if (DosGetNamedSharedMem((PVOID) &queue, nom,                  if (test_ouverture == d_vrai)
                         PAG_WRITE | PAG_READ) != 0)  
                 {                  {
                     sys_free(nom);                      attente.tv_sec = 0;
                     return(1);                      attente.tv_nsec = GRANULARITE_us * 1000;
   
                       while(DosGetNamedSharedMem((PVOID) &queue, nom,
                               PAG_WRITE | PAG_READ) != 0)
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                   }
                   else
                   {
                       if (DosGetNamedSharedMem((PVOID) &queue, nom,
                               PAG_WRITE | PAG_READ) != 0)
                       {
                           sys_free(nom);
                           return(1);
                       }
                 }                  }
   
                 sys_free(nom);                  sys_free(nom);
Line 2786  envoi_signal_processus(pid_t pid, enum s Line 2813  envoi_signal_processus(pid_t pid, enum s
                 if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     munmap(queue, sizeof(struct_queue_signaux));                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                     return(1);                      return(1);
                 }                  }
   
Line 2794  envoi_signal_processus(pid_t pid, enum s Line 2822  envoi_signal_processus(pid_t pid, enum s
                     close(segment);                      close(segment);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
 #           else // IPCS_SYSV  #           else // IPCS_SYSV
 #               ifndef OS2 // SysV  #               ifndef OS2 // SysV
                     if (shmdt(queue) != 0)                      if (shmdt(queue) != 0)
Line 2804  envoi_signal_processus(pid_t pid, enum s Line 2834  envoi_signal_processus(pid_t pid, enum s
                     // Pendant de DosGetNamedSHaredMem()                      // Pendant de DosGetNamedSHaredMem()
 #               endif  #               endif
 #           endif  #           endif
   
             return(1);              return(1);
         }          }
   
Line 2815  envoi_signal_processus(pid_t pid, enum s Line 2844  envoi_signal_processus(pid_t pid, enum s
                 if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     munmap(queue, sizeof(struct_queue_signaux));                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(semaphore);
                     return(1);                      return(1);
                 }                  }
   
                 if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                     close(segment);                      close(segment);
                       sem_close(semaphore);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
 #           else // IPCS_SYSV  #           else // IPCS_SYSV
 #               ifndef OS2 // SysV  #               ifndef OS2 // SysV
                     if (shmdt(queue) != 0)                      if (shmdt(queue) != 0)
                     {                      {
                           sem_close(semaphore);
                         return(1);                          return(1);
                     }                      }
 #               else // OS/2  #               else // OS/2
Line 2847  envoi_signal_processus(pid_t pid, enum s Line 2882  envoi_signal_processus(pid_t pid, enum s
                             != 0)                              != 0)
                     {                      {
                         munmap(queue, sizeof(struct_queue_signaux));                          munmap(queue, sizeof(struct_queue_signaux));
                           sem_close(semaphore);
                           sem_close(signalisation);
                           close(segment);
                         return(1);                          return(1);
                     }                      }
   
                     if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                      if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                     {                      {
                           sem_close(semaphore);
                           sem_close(signalisation);
                         close(segment);                          close(segment);
                     return(1);                          return(1);
                 }                      }
   
                       close(segment);
 #               else // IPCS_SYSV  #               else // IPCS_SYSV
 #                   ifndef OS2 // SysV  #                   ifndef OS2 // SysV
                         if (shmdt(queue) != 0)                          if (shmdt(queue) != 0)
                         {                          {
                               sem_close(semaphore);
                               sem_close(signalisation);
                             return(1);                              return(1);
                         }                          }
 #                   else // OS/2  #                   else // OS/2
Line 2884  envoi_signal_processus(pid_t pid, enum s Line 2928  envoi_signal_processus(pid_t pid, enum s
                 if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     munmap(queue, sizeof(struct_queue_signaux));                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(semaphore);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                     close(segment);                      close(segment);
                       sem_close(semaphore);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
 #           else // IPCS_SYSV  #           else // IPCS_SYSV
 #               ifndef OS2 // SysV  #               ifndef OS2 // SysV
                     if (shmdt(queue) != 0)                      if (shmdt(queue) != 0)
                     {                      {
                           sem_close(semaphore);
                           sem_close(signalisation);
                         return(1);                          return(1);
                     }                      }
 #               else // OS/2  #               else // OS/2
Line 2914  envoi_signal_processus(pid_t pid, enum s Line 2967  envoi_signal_processus(pid_t pid, enum s
                 if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     munmap(queue, sizeof(struct_queue_signaux));                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                     close(segment);                      close(segment);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
 #           else // IPCS_SYSV  #           else // IPCS_SYSV
 #               ifndef OS2 // SysV  #               ifndef OS2 // SysV
                     if (shmdt(queue) != 0)                      if (shmdt(queue) != 0)
                     {                      {
                           sem_close(signalisation);
                         return(1);                          return(1);
                     }                      }
 #               else // OS/2  #               else // OS/2
Line 2943  envoi_signal_processus(pid_t pid, enum s Line 3002  envoi_signal_processus(pid_t pid, enum s
                 if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     munmap(queue, sizeof(struct_queue_signaux));                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                 if (munmap(queue, sizeof(struct_queue_signaux)) != 0)                  if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
                 {                  {
                     close(segment);                      close(segment);
                       sem_close(signalisation);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
 #           else // IPCS_SYSV  #           else // IPCS_SYSV
 #               ifndef OS2 // SysV  #               ifndef OS2 // SysV
                     if (shmdt(queue) != 0)                      if (shmdt(queue) != 0)
                     {                      {
                           sem_close(signalisation);
                         return(1);                          return(1);
                     }                      }
 #               else // OS/2  #               else // OS/2
Line 2972  envoi_signal_processus(pid_t pid, enum s Line 3037  envoi_signal_processus(pid_t pid, enum s
                 if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)                  if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
                 {                  {
                     munmap(queue, sizeof(struct_queue_signaux));                      munmap(queue, sizeof(struct_queue_signaux));
                       close(segment);
                     return(1);                      return(1);
                 }                  }
   
Line 2980  envoi_signal_processus(pid_t pid, enum s Line 3046  envoi_signal_processus(pid_t pid, enum s
                     close(segment);                      close(segment);
                     return(1);                      return(1);
                 }                  }
   
                   close(segment);
 #           else // IPCS_SYSV  #           else // IPCS_SYSV
 #               ifndef OS2 // SysV  #               ifndef OS2 // SysV
                     if (shmdt(queue) != 0)                      if (shmdt(queue) != 0)
Line 2998  envoi_signal_processus(pid_t pid, enum s Line 3066  envoi_signal_processus(pid_t pid, enum s
             if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)              if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0)
             {              {
                 munmap(queue, sizeof(struct_queue_signaux));                  munmap(queue, sizeof(struct_queue_signaux));
                   close(segment);
                 return(1);                  return(1);
             }              }
   
Line 3008  envoi_signal_processus(pid_t pid, enum s Line 3077  envoi_signal_processus(pid_t pid, enum s
             }              }
   
             close(segment);              close(segment);
   
 #       else // IPCS_SYSV  #       else // IPCS_SYSV
 #           ifndef OS2 // SysV  #           ifndef OS2 // SysV
                 if (shmdt(queue) != 0)                  if (shmdt(queue) != 0)
Line 3354  creation_queue_signaux(struct_processus Line 3422  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
 #   ifdef SCHED_OTHER      if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,
     if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)              thread_surveillance_signaux, s_etat_processus) != 0)
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
 #   endif  
   
 #   ifdef PTHREAD_EXPLICIT_SCHED  
     if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
 #   endif  
   
 #   ifdef PTHREAD_SCOPE_SYSTEM  
     if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
     if (pthread_attr_destroy(&attributs) != 0)      if (pthread_attr_destroy(&attributs) != 0)
     {      {
Line 3384  creation_queue_signaux(struct_processus Line 3435  creation_queue_signaux(struct_processus
         return;          return;
     }      }
   
     if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs,  
             thread_surveillance_signaux, s_etat_processus) != 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
     (*s_queue_signaux).controle = getpid();      (*s_queue_signaux).controle = getpid();
   
 #   ifndef IPCS_SYSV  #   ifndef IPCS_SYSV
Line 3428  creation_queue_signaux(struct_processus Line 3472  creation_queue_signaux(struct_processus
 void  void
 liberation_queue_signaux(struct_processus *s_etat_processus)  liberation_queue_signaux(struct_processus *s_etat_processus)
 {  {
     sem_wait(semaphore_arret_signalisation);  
     (*s_queue_signaux).requete_arret = d_vrai;  
   
 #   ifndef IPCS_SYSV  
     msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE);  
 #   endif  
   
     sem_post(semaphore_arret_signalisation);  
   
     // Incrémenter le sémaphore pour être sûr de le débloquer.  
   
     sem_post(semaphore_signalisation);  
   
     if (getpid() == (*s_queue_signaux).controle)  
     {  
         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
             if (shmdt(s_queue_signaux) == -1)              if (shmdt(s_queue_signaux) == -1)
Line 3506  destruction_queue_signaux(struct_process Line 3531  destruction_queue_signaux(struct_process
     // 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);
     arret_thread_signaux(s_etat_processus);  
     pthread_join((*s_queue_signaux).thread_signaux, NULL);      pthread_join((*s_queue_signaux).thread_signaux, NULL);
       arret_thread_signaux(s_etat_processus);
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
Removed from v.1.173  
changed lines
  Added in v.1.180

CVSweb interface <joel.bertrand@systella.fr>