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

Diff for /rpl/src/rpl.c between versions 1.83 and 1.93

version 1.83, 2011/09/14 14:34:28 version 1.93, 2011/09/20 19:28:39
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 105  rplinit(int argc, char *argv[], unsigned Line 99  rplinit(int argc, char *argv[], unsigned
     volatile unsigned char              traitement_fichier_temporaire;      volatile unsigned char              traitement_fichier_temporaire;
   
     errno = 0;      errno = 0;
       s_queue_signaux = NULL;
     pid_processus_pere = getpid();      pid_processus_pere = getpid();
   
 #   ifdef DEBUG_MEMOIRE  #   ifdef DEBUG_MEMOIRE
Line 115  rplinit(int argc, char *argv[], unsigned Line 110  rplinit(int argc, char *argv[], unsigned
     setvbuf(stderr, NULL, _IOLBF, 0);      setvbuf(stderr, NULL, _IOLBF, 0);
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_init(&semaphore_liste_threads, 0, 1);  
     sem_init(&semaphore_gestionnaires_signaux, 0, 0);      sem_init(&semaphore_gestionnaires_signaux, 0, 0);
     sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);  
 #   else  #   else
     semaphore_liste_threads = sem_init2(1, sem_liste_threads);      semaphore_gestionnaires_signaux = sem_init2(0, getpid(), SEM_SIGNAUX);
     semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);      
     semaphore_gestionnaires_signaux_atomique = sem_init2(1,      if (semaphore_gestionnaires_signaux == SEM_FAILED)
             sem_gestionnaires_signaux_atomique);  
   
     if ((semaphore_liste_threads == SEM_FAILED) ||  
             (semaphore_gestionnaires_signaux == SEM_FAILED) ||  
             (semaphore_gestionnaires_signaux_atomique == SEM_FAILED))  
     {      {
         erreur = d_es_allocation_memoire;          erreur = d_es_allocation_memoire;
   
Line 189  rplinit(int argc, char *argv[], unsigned Line 177  rplinit(int argc, char *argv[], unsigned
     (*s_etat_processus).erreur_systeme = d_es;      (*s_etat_processus).erreur_systeme = d_es;
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
     (*s_etat_processus).compteur_violation_d_acces = 0;      (*s_etat_processus).compteur_violation_d_acces = 0;
     (*s_etat_processus).tid_courant = pthread_self();  
   
     (*s_etat_processus).rpl_home = rpl_home;      (*s_etat_processus).rpl_home = rpl_home;
   
Line 205  rplinit(int argc, char *argv[], unsigned Line 192  rplinit(int argc, char *argv[], unsigned
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);          sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
 #   else  #   else
     if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==          if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
             SEM_FAILED)                  pthread_self(), SEM_FORK)) == SEM_FAILED)
     {  
         if ((*s_etat_processus).langue == 'F')  
         {  
             uprintf("+++Système : Mémoire insuffisante\n");  
         }  
         else  
         {          {
             uprintf("+++System : Not enough memory\n");              if ((*s_etat_processus).langue == 'F')
         }              {
                   uprintf("+++Système : Mémoire insuffisante\n");
               }
               else
               {
                   uprintf("+++System : Not enough memory\n");
               }
   
         return(EXIT_FAILURE);              return(EXIT_FAILURE);
     }          }
 #   endif  #   endif
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
Line 244  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 334  rplinit(int argc, char *argv[], unsigned Line 314  rplinit(int argc, char *argv[], unsigned
         home = "";          home = "";
     }      }
   
     // Initialisation d'une clef  
   
     if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)  
     {  
         if ((*s_etat_processus).langue == 'F')  
         {  
             printf("+++Système : Mémoire insuffisante\n");  
         }  
         else  
         {  
             printf("+++System : Not enough memory\n");  
         }  
   
         return(EXIT_FAILURE);  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  
     if (pthread_setspecific(semaphore_fork_processus_courant,  
             &((*s_etat_processus).semaphore_fork)) != 0)  
 #   else  
     if (pthread_setspecific(semaphore_fork_processus_courant,  
             (*s_etat_processus).semaphore_fork) != 0)  
 #   endif  
     {  
         if ((*s_etat_processus).langue == 'F')  
         {  
             printf("+++Système : Mémoire insuffisante\n");  
         }  
         else  
         {  
             printf("+++System : Not enough memory\n");  
         }  
   
         return(EXIT_FAILURE);  
     }  
   
     // Initialisation d'une pile de signal pour récupérer les      // Initialisation d'une pile de signal pour récupérer les
     // débordement de pile      // débordement de pile
   
Line 655  rplinit(int argc, char *argv[], unsigned Line 599  rplinit(int argc, char *argv[], unsigned
         option_t = d_faux;          option_t = d_faux;
         option_v = d_faux;          option_v = d_faux;
   
           // Lorsque le programme est appelé depuis un shebang, argv[0] contient
           // le chemin du programme et argv[1] tous les arguments.
           // argv[2] contient quant à lui le nom du script RPL/2.
           //
           // Exemple :
           // argv[0] : /usr/local/bin/rpl
           // argv[1] : -csdp -t 800
           // argv[2] : ./on_exit.rpl
   
         while((--argc) > 0)          while((--argc) > 0)
         {          {
             if ((*(++argv))[0] == '-')              if ((*(++argv))[0] == '-')
Line 1450  rplinit(int argc, char *argv[], unsigned Line 1403  rplinit(int argc, char *argv[], unsigned
                             break;                              break;
                         }                          }
   
                           case '-':
                           case ' ':
                           {
                               break;
                           }
   
                         default :                          default :
                         {                          {
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
Line 2679  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 2723  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 3005  rplinit(int argc, char *argv[], unsigned Line 2960  rplinit(int argc, char *argv[], unsigned
                         }                          }
   
                         nanosleep(&attente, NULL);                          nanosleep(&attente, NULL);
                           scrutation_interruptions(s_etat_processus);
                         pthread_mutex_lock(&((*s_etat_processus).mutex));                          pthread_mutex_lock(&((*s_etat_processus).mutex));
                     }                      }
   
Line 3535  rplinit(int argc, char *argv[], unsigned Line 3491  rplinit(int argc, char *argv[], unsigned
     sem_destroy(&((*s_etat_processus).semaphore_fork));      sem_destroy(&((*s_etat_processus).semaphore_fork));
 #   else  #   else
     sem_post((*s_etat_processus).semaphore_fork);      sem_post((*s_etat_processus).semaphore_fork);
     sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);      sem_destroy3((*s_etat_processus).semaphore_fork, getpid(), pthread_self(),
               SEM_FORK);
 #   endif  #   endif
   
     free((*s_etat_processus).localisation);      free((*s_etat_processus).localisation);
   
 #   ifndef SEMAPHORES_NOMMES      pthread_mutex_destroy(&mutex_liste_threads);
     sem_destroy(&semaphore_liste_threads);      pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique);
 #   else  
     sem_destroy2(semaphore_liste_threads, sem_liste_threads);  
 #   endif  
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_post(&semaphore_gestionnaires_signaux);      sem_post(&semaphore_gestionnaires_signaux);
     sem_destroy(&semaphore_gestionnaires_signaux);      sem_destroy(&semaphore_gestionnaires_signaux);
     sem_destroy(&semaphore_gestionnaires_signaux_atomique);  
 #   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);
     sem_destroy2(semaphore_gestionnaires_signaux_atomique,  
             sem_gestionnaires_signaux_atomique);  
 #   endif  #   endif
   
     destruction_queue_signaux(s_etat_processus);      destruction_queue_signaux(s_etat_processus);
Removed from v.1.83  
changed lines
  Added in v.1.93

CVSweb interface <joel.bertrand@systella.fr>