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

Diff for /rpl/src/rpl.c between versions 1.195 and 1.215

version 1.195, 2017/07/04 10:28:08 version 1.215, 2021/01/20 08:49:33
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.27    RPL/2 (R) version 4.1.32
   Copyright (C) 1989-2017 Dr. BERTRAND Joël    Copyright (C) 1989-2020 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 127  rplinit(int argc, char *argv[], char *en Line 127  rplinit(int argc, char *argv[], char *en
     errno = 0;      errno = 0;
     s_queue_signaux = NULL;      s_queue_signaux = NULL;
     routine_recursive = 0;      routine_recursive = 0;
     nombre_thread_surveillance_processus = 0;      nombre_threads_surveillance_processus = 0;
     pid_processus_pere = getpid();      pid_processus_pere = getpid();
     affichage_rplso = d_vrai;  
   
 #   ifdef DEBUG_PROC  #   ifdef DEBUG_PROC
     __proc = 0;      __proc = 0;
Line 314  rplinit(int argc, char *argv[], char *en Line 313  rplinit(int argc, char *argv[], char *en
     pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);      pthread_mutex_init(&mutex_liste_threads, &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
       pthread_mutex_init(&mutex_liste_threads_surveillance, &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
       pthread_mutex_init(&mutex_sigaction, &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
         sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);          if (sem_init(&((*s_etat_processus).semaphore_fork), 0, 0) != 0)
 #   else  #   else
         if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),          if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
                 pthread_self(), SEM_FORK)) == SEM_FAILED)                  pthread_self(), SEM_FORK)) == SEM_FAILED)
         {  #   endif
             liberation_contexte_cas(s_etat_processus);      {
           liberation_contexte_cas(s_etat_processus);
             if ((*s_etat_processus).langue == 'F')  
             {  
                 uprintf("+++Système : Mémoire insuffisante\n");  
             }  
             else  
             {  
                 uprintf("+++System : Not enough memory\n");  
             }  
   
             return(EXIT_FAILURE);          if ((*s_etat_processus).langue == 'F')
           {
               uprintf("+++Système : Mémoire insuffisante\n");
           }
           else
           {
               uprintf("+++System : Not enough memory\n");
         }          }
 #   endif  
           return(EXIT_FAILURE);
       }
   
     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 450  rplinit(int argc, char *argv[], char *en Line 459  rplinit(int argc, char *argv[], char *en
   
         if ((*s_etat_processus).langue == 'F')          if ((*s_etat_processus).langue == 'F')
         {          {
             printf("+++Copyright (C) 1989 à 2016, 2017 BERTRAND Joël\n");              printf("+++Copyright (C) 1989 à 2020, 2021 BERTRAND Joël\n");
         }          }
         else          else
         {          {
             printf("+++Copyright (C) 1989 to 2016, 2017 BERTRAND Joel\n");              printf("+++Copyright (C) 1989 to 2020, 2021 BERTRAND Joel\n");
         }          }
     }      }
   
Line 4134  rplinit(int argc, char *argv[], char *en Line 4143  rplinit(int argc, char *argv[], char *en
                             return(EXIT_FAILURE);                              return(EXIT_FAILURE);
                         }                          }
   
                         affichage_rplso = d_faux;  
                         instruction_use(s_etat_processus);                          instruction_use(s_etat_processus);
                         affichage_rplso = d_vrai;  
   
                         if (depilement(s_etat_processus, &((*s_etat_processus)                          if (depilement(s_etat_processus, &((*s_etat_processus)
                                 .l_base_pile), &((*l_bibliotheque_courante)                                  .l_base_pile), &((*l_bibliotheque_courante)
Line 5085  rplinit(int argc, char *argv[], char *en Line 5092  rplinit(int argc, char *argv[], char *en
                         {                          {
                             if (setjmp(contexte_initial) == 0)                              if (setjmp(contexte_initial) == 0)
                             {                              {
                                 // Libération des bibliothèques  
   
                                 l_bibliotheque_courante = l_bibliotheques;  
   
                                 while(l_bibliotheque_courante != NULL)  
                                 {  
                                     if (empilement(s_etat_processus,  
                                             &((*s_etat_processus).l_base_pile),  
                                             (*l_bibliotheque_courante).donnee)  
                                             == d_erreur)  
                                     {  
 #                                       ifndef SEMAPHORES_NOMMES  
                                             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  
   
                                         liberation_contexte_cas(  
                                                 s_etat_processus);  
                                         destruction_queue_signaux(  
                                                 s_etat_processus);  
   
 #                                       ifdef HAVE_STACK_OVERFLOW_RECOVERY  
                                             stackoverflow_deinstall_handler();  
 #                                       endif  
   
 #                                       ifdef HAVE_SIGSEGV_RECOVERY  
                                             if (debug == d_faux)  
                                             {  
                                                 sigsegv_deinstall_handler();  
                                             }  
 #                                       endif  
   
                                         erreur = d_es_allocation_memoire;  
   
                                         if ((*s_etat_processus).langue == 'F')  
                                         {  
                                             printf("+++Système : Mémoire "  
                                                     "insuffisante\n");  
                                         }  
                                         else  
                                         {  
                                             printf("+++System : Not enough "  
                                                     "memory\n");  
                                         }  
   
                                         return(EXIT_FAILURE);  
                                     }  
   
                                     affichage_rplso = d_faux;  
                                     instruction_remove(s_etat_processus);  
                                     affichage_rplso = d_vrai;  
   
                                     l_nouvelle_bibliotheque =  
                                             (*l_bibliotheque_courante).suivant;  
                                     free(l_bibliotheque_courante);  
                                     l_bibliotheque_courante =  
                                             l_nouvelle_bibliotheque;  
                                 }  
   
                                 erreur = sequenceur(s_etat_processus);                                  erreur = sequenceur(s_etat_processus);
   
                                 if (erreur == d_absence_erreur)                                  if (erreur == d_absence_erreur)
Line 5503  rplinit(int argc, char *argv[], char *en Line 5443  rplinit(int argc, char *argv[], char *en
                                 if ((*s_etat_processus).var_volatile_alarme                                  if ((*s_etat_processus).var_volatile_alarme
                                         != 0)                                          != 0)
                                 {                                  {
                                     envoi_signal_thread(                                      envoi_signal_thread(s_etat_processus,
                                             (*(*((struct_processus_fils *)                                              (*(*((struct_processus_fils *)
                                             (*(*((struct_liste_chainee *)                                              (*(*((struct_liste_chainee *)
                                             l_element_courant)).donnee).objet))                                              l_element_courant)).donnee).objet))
Line 5514  rplinit(int argc, char *argv[], char *en Line 5454  rplinit(int argc, char *argv[], char *en
                                     if ((*s_etat_processus).arret_depuis_abort                                      if ((*s_etat_processus).arret_depuis_abort
                                             == -1)                                              == -1)
                                     {                                      {
                                         envoi_signal_thread(                                          envoi_signal_thread(s_etat_processus,
                                                 (*(*((struct_processus_fils *)                                                  (*(*((struct_processus_fils *)
                                                 (*(*((struct_liste_chainee *)                                                  (*(*((struct_liste_chainee *)
                                                 l_element_courant)).donnee)                                                  l_element_courant)).donnee)
Line 5523  rplinit(int argc, char *argv[], char *en Line 5463  rplinit(int argc, char *argv[], char *en
                                     }                                      }
                                     else                                      else
                                     {                                      {
                                         envoi_signal_thread(                                          envoi_signal_thread(s_etat_processus,
                                                 (*(*((struct_processus_fils *)                                                  (*(*((struct_processus_fils *)
                                                 (*(*((struct_liste_chainee *)                                                  (*(*((struct_liste_chainee *)
                                                 l_element_courant)).donnee)                                                  l_element_courant)).donnee)
Line 5970  rplinit(int argc, char *argv[], char *en Line 5910  rplinit(int argc, char *argv[], char *en
                         l_element_courant = l_element_suivant;                          l_element_courant = l_element_suivant;
                     }                      }
   
                     for(i = 0; i < (*s_etat_processus)  
                             .nombre_instructions_externes; i++)  
                     {  
                         free((*s_etat_processus).s_instructions_externes[i]  
                                 .nom);  
                         free((*s_etat_processus).s_instructions_externes[i]  
                                 .nom_bibliotheque);  
                     }  
   
                     if ((*s_etat_processus).nombre_instructions_externes != 0)  
                     {  
                         free((*s_etat_processus).s_instructions_externes);  
                     }  
   
                     l_element_courant = (void *) (*s_etat_processus)  
                             .s_bibliotheques;  
                       
                     while(l_element_courant != NULL)  
                     {  
                         l_element_suivant = (*((struct_liste_chainee *)  
                                 l_element_courant)).suivant;  
   
                         free((*((struct_bibliotheque *)  
                                 (*((struct_liste_chainee *)  
                                 l_element_courant)).donnee)).nom);  
                         dlclose((*((struct_bibliotheque *)  
                                 (*((struct_liste_chainee *)  
                                 l_element_courant)).donnee)).descripteur);  
                         free((*((struct_liste_chainee *) l_element_courant))  
                                 .donnee);  
                         free(l_element_courant);  
   
                         l_element_courant = l_element_suivant;  
                     }  
   
                     l_element_courant = (void *) (*s_etat_processus)                      l_element_courant = (void *) (*s_etat_processus)
                             .l_base_pile_last;                              .l_base_pile_last;
                     while(l_element_courant != NULL)                      while(l_element_courant != NULL)
Line 6020  rplinit(int argc, char *argv[], char *en Line 5925  rplinit(int argc, char *argv[], char *en
                         l_element_courant = l_element_suivant;                          l_element_courant = l_element_suivant;
                     }                      }
   
                       while((*s_etat_processus).s_bibliotheques != NULL)
                       {
                           retrait_bibliotheque(s_etat_processus,
                                   (struct_bibliotheque *)
                                   (*((struct_liste_chainee *)
                                   (*s_etat_processus).s_bibliotheques)).donnee);
                       }
   
                     l_element_courant = (void *) (*s_etat_processus)                      l_element_courant = (void *) (*s_etat_processus)
                             .l_base_pile_systeme;                              .l_base_pile_systeme;
                     while(l_element_courant != NULL)                      while(l_element_courant != NULL)
Line 6207  rplinit(int argc, char *argv[], char *en Line 6120  rplinit(int argc, char *argv[], char *en
     attente.tv_sec = 0;      attente.tv_sec = 0;
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
     while(nombre_thread_surveillance_processus != 0)      pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
   
       while(nombre_threads_surveillance_processus != 0)
       {
           pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
           nanosleep(&attente, NULL);
           INCR_GRANULARITE(attente.tv_nsec);
           pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus));
       }
   
       pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
   
       attente.tv_sec = 0;
       attente.tv_nsec = GRANULARITE_us * 1000;
   
       while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus))
               == EBUSY)
     {      {
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
     }      }
   
       pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));      pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));      pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));  
     pthread_mutex_destroy(&mutex_sections_critiques);      pthread_mutex_destroy(&mutex_sections_critiques);
     pthread_mutex_destroy(&mutex_liste_variables_partagees);      pthread_mutex_destroy(&mutex_liste_variables_partagees);
   
       free((*s_etat_processus).localisation);
   
       destruction_queue_signaux(s_etat_processus);
       pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
       liberation_contexte_cas(s_etat_processus);
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_post(&((*s_etat_processus).semaphore_fork));      sem_post(&((*s_etat_processus).semaphore_fork));
     sem_destroy(&((*s_etat_processus).semaphore_fork));      sem_destroy(&((*s_etat_processus).semaphore_fork));
Line 6229  rplinit(int argc, char *argv[], char *en Line 6164  rplinit(int argc, char *argv[], char *en
             SEM_FORK);              SEM_FORK);
 #   endif  #   endif
   
     free((*s_etat_processus).localisation);  
   
     destruction_queue_signaux(s_etat_processus);  
     liberation_contexte_cas(s_etat_processus);  
   
     free((*s_etat_processus).chemin_fichiers_temporaires);      free((*s_etat_processus).chemin_fichiers_temporaires);
   
     if ((*s_etat_processus).requete_redemarrage == d_vrai)      if ((*s_etat_processus).requete_redemarrage == d_vrai)
Line 6250  rplinit(int argc, char *argv[], char *en Line 6180  rplinit(int argc, char *argv[], char *en
   
     liberation_allocateur_buffer(s_etat_processus);      liberation_allocateur_buffer(s_etat_processus);
     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
       pthread_mutex_destroy(&mutex_liste_threads);
       pthread_mutex_destroy(&mutex_liste_threads_surveillance);
       pthread_mutex_destroy(&mutex_sigaction);
   
     sys_free(s_etat_processus);      sys_free(s_etat_processus);
     sys_free(arg_exec);      sys_free(arg_exec);
Removed from v.1.195  
changed lines
  Added in v.1.215

CVSweb interface <joel.bertrand@systella.fr>