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

Diff for /rpl/src/rpl.c between versions 1.86 and 1.92

version 1.86, 2011/09/16 09:09:35 version 1.92, 2011/09/20 15:45:53
Line 23 Line 23
 #define  MAIN_RPL  #define  MAIN_RPL
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
 #ifdef IPCS_SYSV  
 #ifndef OS2  
     unsigned char       *chemin_semaphores_SysV;  
 #endif  
 #endif  
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 118  rplinit(int argc, char *argv[], unsigned Line 112  rplinit(int argc, char *argv[], unsigned
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_init(&semaphore_gestionnaires_signaux, 0, 0);      sem_init(&semaphore_gestionnaires_signaux, 0, 0);
 #   else  #   else
     semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);      semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);
           
     if (semaphore_gestionnaires_signaux == SEM_FAILED)      if (semaphore_gestionnaires_signaux == SEM_FAILED)
     {      {
Line 197  rplinit(int argc, char *argv[], unsigned Line 191  rplinit(int argc, char *argv[], unsigned
             &attributs_mutex);              &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
     pthread_mutexattr_init(&attributs_mutex);  #   ifndef SEMAPHORES_NOMMES
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);          sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
     pthread_mutex_init(&((*s_etat_processus).mutex_fork),  #   else
             &attributs_mutex);          if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
     pthread_mutexattr_destroy(&attributs_mutex);                  pthread_self(), SEM_FORK)) == SEM_FAILED)
     pthread_mutex_lock(&((*s_etat_processus).mutex_fork));          {
               if ((*s_etat_processus).langue == 'F')
               {
                   uprintf("+++Système : Mémoire insuffisante\n");
               }
               else
               {
                   uprintf("+++System : Not enough memory\n");
               }
   
               return(EXIT_FAILURE);
           }
   #   endif
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
Line 225  rplinit(int argc, char *argv[], unsigned Line 231  rplinit(int argc, char *argv[], unsigned
     (*s_etat_processus).chemin_fichiers_temporaires =      (*s_etat_processus).chemin_fichiers_temporaires =
             recherche_chemin_fichiers_temporaires(s_etat_processus);              recherche_chemin_fichiers_temporaires(s_etat_processus);
   
 #   ifdef IPCS_SYSV  
 #       ifndef OS2  
             chemin_semaphores_SysV =  
                     (*s_etat_processus).chemin_fichiers_temporaires;  
 #       endif  
 #   endif  
   
     insertion_thread(s_etat_processus, d_vrai);      insertion_thread(s_etat_processus, d_vrai);
     creation_queue_signaux(s_etat_processus);      creation_queue_signaux(s_etat_processus);
   
Line 2639  rplinit(int argc, char *argv[], unsigned Line 2638  rplinit(int argc, char *argv[], unsigned
                             lancement_daemon(s_etat_processus);                              lancement_daemon(s_etat_processus);
                         }                          }
   
 // A FIXER  
 // création signaux  
                         if (option_p == d_faux)                          if (option_p == d_faux)
                         {                          {
                             if (setjmp(contexte_initial) == 0)                              if (setjmp(contexte_initial) == 0)
Line 2683  rplinit(int argc, char *argv[], unsigned Line 2680  rplinit(int argc, char *argv[], unsigned
                                 }                                  }
                             }                              }
                         }                          }
 // A FIXER  
 // destruction signaux  
                     }                      }
   
                     liberation(s_etat_processus, (*s_etat_processus).at_exit);                      liberation(s_etat_processus, (*s_etat_processus).at_exit);
Line 3491  rplinit(int argc, char *argv[], unsigned Line 3486  rplinit(int argc, char *argv[], unsigned
     pthread_mutex_destroy(&((*s_etat_processus).mutex));      pthread_mutex_destroy(&((*s_etat_processus).mutex));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
   
     pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));  #   ifndef SEMAPHORES_NOMMES
     pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));      sem_post(&((*s_etat_processus).semaphore_fork);
       sem_destroy(&((*s_etat_processus).semaphore_fork);
   #   else
       sem_post((*s_etat_processus).semaphore_fork);
       sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(),
               SEM_FORK);
   #   endif
   
     free((*s_etat_processus).localisation);      free((*s_etat_processus).localisation);
   
Line 3504  rplinit(int argc, char *argv[], unsigned Line 3505  rplinit(int argc, char *argv[], unsigned
     sem_destroy(&semaphore_gestionnaires_signaux);      sem_destroy(&semaphore_gestionnaires_signaux);
 #   else  #   else
     sem_post(semaphore_gestionnaires_signaux);      sem_post(semaphore_gestionnaires_signaux);
     sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);      sem_destroy2(semaphore_gestionnaires_signaux, getpid(), SEM_SIGNAUX);
 #   endif  #   endif
   
     destruction_queue_signaux(s_etat_processus);      destruction_queue_signaux(s_etat_processus);
Removed from v.1.86  
changed lines
  Added in v.1.92

CVSweb interface <joel.bertrand@systella.fr>