[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.72

version 1.69, 2011/09/15 17:51:43 version 1.72, 2011/09/18 12:42:50
Line 2172  static inline void Line 2172  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 2251  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)  #   ifndef SEMAPHORES_NOMMES
           if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0)
   #   else
           if (sem_trywait(semaphore_queue_signaux) == 0)
   #   endif
     {      {
         if ((*s_queue_signaux).pointeur_lecture !=          if ((*s_queue_signaux).pointeur_lecture !=
                 (*s_queue_signaux).pointeur_ecriture)                  (*s_queue_signaux).pointeur_ecriture)
Line 2267  scrutation_interruptions(struct_processu Line 2270  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");  
         }          }
   
         pthread_mutex_unlock(&((*s_queue_signaux).mutex));  #       ifndef SEMAPHORES_NOMMES
               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.
Line 2349  nom_segment(unsigned char *chemin, pid_t Line 2355  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;      int                             segment;
   
       sem_t                           *semaphore;
   
     struct_queue_signaux            *queue;      struct_queue_signaux            *queue;
   
     unsigned char                   *nom;      unsigned char                   *nom;
Line 2370  envoi_signal_processus(pid_t pid, enum s Line 2390  envoi_signal_processus(pid_t pid, enum s
             return(1);              return(1);
         }          }
   
         if (pthread_mutex_lock(&((*s_queue_signaux).mutex)) != 0)  #       ifndef SEMAPHORES_NOMMES
               if (sem_wait(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               if (sem_wait(semaphore_queue_signaux) != 0)
   #       endif
         {          {
             return(1);              return(1);
         }          }
Line 2384  envoi_signal_processus(pid_t pid, enum s Line 2408  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)  #       ifndef SEMAPHORES_NOMMES
               if (sem_post(&((*s_queue_signaux).semaphore)) != 0)
   #       else
               if (sem_post(semaphore_queue_signaux) != 0)
   #       endif
         {          {
             return(1);              return(1);
         }          }
Line 2414  envoi_signal_processus(pid_t pid, enum s Line 2442  envoi_signal_processus(pid_t pid, enum s
             return(1);              return(1);
         }          }
   
 uprintf("Lock\n");  #       ifndef SEMAPHORES_NOMMES
         if (pthread_mutex_lock(&((*queue).mutex)) != 0)              if (sem_wait(&((*queue).semaphore)) != 0)
         {              {
 uprintf("Unlock (error)\n");                  return(1);
             return(1);              }
         }  #       else
               if ((semaphore = sem_open2(pid)) == SEM_FAILED)
               {
                   return(1);
               }
   
               if (sem_wait(semaphore) != 0)
               {
                   sem_close(semaphore);
                   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 2466  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 SEMAPHORES_NOMMES
         if (pthread_mutex_unlock(&((*queue).mutex)) != 0)              if (sem_post(&((*queue).semaphore)) != 0)
         {              {
 uprintf("Unlock failed\n");                  return(1);
             return(1);              }
         }  #       else
               if (sem_post(semaphore) != 0)
               {
                   sem_close(semaphore);
                   return(1);
               }
   
               if (sem_close(semaphore) != 0)
               {
                   reeturn(1);
               }
   #       endif
   
         if (munmap(queue, sizeof(struct_queue_signaux)) != 0)          if (munmap(queue, sizeof(struct_queue_signaux)) != 0)
         {          {
Line 2542  envoi_signal_contexte(struct_processus * Line 2592  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;  
   
     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)  
     {  
         free(nom);  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),  
             PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);  
   
     if (((void *) s_queue_signaux) == ((void *) -1))          if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1)
     {  
         if (shm_unlink(nom) == -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;
         }          }
   
         free(nom);          s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux),
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0);
         return;  
     }  
   
     free(nom);          if (((void *) s_queue_signaux) == ((void *) -1))
           {
               if (shm_unlink(nom) == -1)
               {
                   free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
     pthread_mutexattr_init(&attributs_mutex);              free(nom);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
     pthread_mutex_init(&((*s_queue_signaux).mutex), &attributs_mutex);              return;
     pthread_mutexattr_destroy(&attributs_mutex);          }
   
     (*s_queue_signaux).pointeur_lecture = 0;          free(nom);
     (*s_queue_signaux).pointeur_ecriture = 0;  #       ifndef SEMAPHORES_NOMMES
               sem_init(&((*s_queue_signaux).semaphore), 1, 1);
   #       else
               if ((semaphore_queue_signaux = sem_init2(0, getpid()))
                       == SEM_FAILED)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   #       endif
   
     if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))          (*s_queue_signaux).pointeur_lecture = 0;
     {          (*s_queue_signaux).pointeur_ecriture = 0;
         (*s_etat_processus).erreur_systeme = d_es_processus;  
         return;  
     }  
   
           if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0))
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
 #   else // SystemV  #   else // SystemV
 #   ifndef OS2  #       ifndef OS2
               file                            *desc;
     file                            *desc;  
   
     key_t                           clef;  
   
     // Création d'un segment de données associé au PID du processus courant  
   
     chemin = (*s_etat_processus).chemin_fichiers_temporaires;  
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,              key_t                           clef;
             getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if ((desc = fopen(nom, "w")) == NULL)              // Création d'un segment de données associé au PID du processus
     {              // courant
         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
         return;  
     }  
   
     fclose(desc);              chemin = (*s_etat_processus).chemin_fichiers_temporaires;
   
     if ((clef = ftok(nom, 1)) == -1)              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;
               }
   
     free(nom);              if ((desc = fopen(nom, "w")) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
   
     if ((segment = shmget(clef,              fclose(desc);
             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;  
         return;  
     }  
   
     fifos = shmat(segment, NULL, 0);              if ((clef = ftok(nom, 1)) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
     if (((void *) fifos) == ((void *) -1))              free(nom);
     {  
         if (shmctl(segment, IPC_RMID, 0) == -1)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return;  
         }  
   
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              if ((segment = shmget(clef,
         return;                      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;
                   return;
               }
   
 #   else              fifos = shmat(segment, NULL, 0);
   
     if ((nom = nom_segment(NULL, getpid())) == NULL)              if (((void *) fifos) == ((void *) -1))
     {              {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  if (shmctl(segment, IPC_RMID, 0) == -1)
         return;                  {
     }                      (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
     if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues *                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             ((2 * longueur_queue) + 4) * sizeof(int),                  return;
             PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)              }
     {  #       else // OS/2
         free(nom);              if ((nom = nom_segment(NULL, getpid())) == NULL)
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              {
         return;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
     }                  return;
               }
   
     free(nom);              if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues *
     fifos = ptr_os2;                      ((2 * longueur_queue) + 4) * sizeof(int),
                       PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
               {
                   free(nom);
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
 #   endif              free(nom);
               fifos = ptr_os2;
   #       endif
 #   endif  #   endif
   
     return;      return;
Line 2709  liberation_queue_signaux(struct_processu Line 2758  liberation_queue_signaux(struct_processu
 #       else // OS/2  #       else // OS/2
 #       endif  #       endif
 #   else // POSIX  #   else // POSIX
   #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
   #       else
               sem_close(semaphore_queue_signaux);
   #       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 2741  destruction_queue_signaux(struct_process Line 2796  destruction_queue_signaux(struct_process
     unsigned char       *nom;      unsigned char       *nom;
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #   ifndef OS2  #       ifndef OS2
               if (shmdt(fifos) == -1)
     if (shmdt(fifos) == -1)              {
     {                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  return;
         return;              }
     }  
   
     if (shmctl(segment, IPC_RMID, 0) == -1)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires,  
             getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return;  
     }  
   
     // FERMER LE FICHIER              if (shmctl(segment, IPC_RMID, 0) == -1)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
     unlink(nom);              if ((nom = nom_segment((*s_etat_processus)
     free(nom);                      .chemin_fichiers_temporaires, getpid())) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
 #   else              // FERMER LE FICHIER
   
     if (DosFreeMem(fifos) != 0)              unlink(nom);
     {              free(nom);
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  #       else
         return;              if (DosFreeMem(fifos) != 0)
     }              {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
     // FERMER LE FICHIER          // FERMER LE FICHIER
   
 #   endif  #       endif
 #   else // POSIX  #   else // POSIX
   #       ifndef SEMAPHORES_NOMMES
               sem_close(&((*s_queue_signaux).semaphore));
               sem_destroy(&((*s_queue_signaux).semaphore));
   #       else
               sem_close(semaphore_queue_signaux);
               sem_destroy2(semaphore_queue_signaux, getpid());
   #       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;
         return;              return;
     }          }
   
     if ((nom = nom_segment(NULL, getpid())) == NULL)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         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.72

CVSweb interface <joel.bertrand@systella.fr>