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

Diff for /rpl/src/interruptions.c between versions 1.146 and 1.153

version 1.146, 2014/06/05 20:51:54 version 1.153, 2015/01/27 14:18:08
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.18    RPL/2 (R) version 4.1.20
   Copyright (C) 1989-2014 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 99  thread_surveillance_signaux(void *argume Line 99  thread_surveillance_signaux(void *argume
   
             if ((*s_queue_signaux).requete_arret == d_vrai)              if ((*s_queue_signaux).requete_arret == d_vrai)
             {              {
 uprintf("Fin du thread\n");  
                 sem_post(semaphore_arret_signalisation);                  sem_post(semaphore_arret_signalisation);
                 sem_post(semaphore_signalisation);                  sem_post(semaphore_signalisation);
   
Line 189  uprintf("Fin du thread\n"); Line 188  uprintf("Fin du thread\n");
         }          }
     }      }
   
 uprintf("Zouh...\n");  
     pthread_exit(NULL);      pthread_exit(NULL);
 }  }
   
Line 1267  liberation_threads(struct_processus *s_e Line 1265  liberation_threads(struct_processus *s_e
 #           endif  #           endif
   
             liberation_contexte_cas(s_etat_processus);              liberation_contexte_cas(s_etat_processus);
             free(s_etat_processus);              sys_free(s_etat_processus);
   
             s_etat_processus = candidat;              s_etat_processus = candidat;
         }          }
Line 1470  verrouillage_gestionnaire_signaux(struct Line 1468  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 2560  nom_segment(unsigned char *chemin, pid_t Line 2543  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 2568  nom_segment(unsigned char *chemin, pid_t Line 2551  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 2578  nom_segment(unsigned char *chemin, pid_t Line 2561  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 2686  envoi_signal_processus(pid_t pid, enum s Line 2669  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 2694  envoi_signal_processus(pid_t pid, enum s Line 2677  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 2711  envoi_signal_processus(pid_t pid, enum s Line 2694  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 2725  envoi_signal_processus(pid_t pid, enum s Line 2708  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 2946  creation_queue_signaux(struct_processus Line 2929  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 2965  creation_queue_signaux(struct_processus Line 2948  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 3003  creation_queue_signaux(struct_processus Line 2986  creation_queue_signaux(struct_processus
   
         (*s_queue_signaux).requete_arret = d_faux;          (*s_queue_signaux).requete_arret = d_faux;
   
 #       ifndef IPCS_SYSV  
         if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))          if (msync(s_queue_signaux, sizeof(struct_queue_signaux), MS_SYNC))
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       endif  
 #   else // IPCS_SYSV  #   else // IPCS_SYSV
 #       ifndef OS2  #       ifndef OS2
             int                             segment;              int                             segment;
Line 3041  creation_queue_signaux(struct_processus Line 3022  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 3101  creation_queue_signaux(struct_processus Line 3082  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 3264  destruction_queue_signaux(struct_process Line 3245  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);
     uprintf("Requête arrêt\n");      pthread_join((*s_queue_signaux).thread_signaux, NULL);
     int ios;  
     ios = pthread_join((*s_queue_signaux).thread_signaux, NULL);  
     if (ios) perror("pthread_join");  
   
 #   ifdef IPCS_SYSV // SystemV  #   ifdef IPCS_SYSV // SystemV
 #       ifndef OS2  #       ifndef OS2
Line 3280  destruction_queue_signaux(struct_process Line 3258  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 3289  destruction_queue_signaux(struct_process Line 3267  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 3298  destruction_queue_signaux(struct_process Line 3276  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 3320  destruction_queue_signaux(struct_process Line 3298  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 3359  destruction_queue_signaux(struct_process Line 3337  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.146  
changed lines
  Added in v.1.153

CVSweb interface <joel.bertrand@systella.fr>