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

Diff for /rpl/src/instructions_d5.c between versions 1.144 and 1.164

version 1.144, 2016/03/16 12:19:34 version 1.164, 2019/01/01 09:02:57
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.25    RPL/2 (R) version 4.1.30
   Copyright (C) 1989-2016 Dr. BERTRAND Joël    Copyright (C) 1989-2019 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 1088  instruction_detach(struct_processus *s_e Line 1088  instruction_detach(struct_processus *s_e
         return;          return;
     }      }
   
       verrouillage_threads_concurrents(s_etat_processus);
   
     if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)      if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
   
     verrouillage_threads_concurrents(s_etat_processus);  
   
     if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)      if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
Line 1288  instruction_detach(struct_processus *s_e Line 1288  instruction_detach(struct_processus *s_e
          * Processus fils           * Processus fils
          */           */
   
           // EPERM
   #if 0
         pthread_mutex_destroy(&mutex_liste_variables_partagees);          pthread_mutex_destroy(&mutex_liste_variables_partagees);
         pthread_mutex_destroy(&mutex_liste_threads);          pthread_mutex_destroy(&mutex_liste_threads);
           pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus);
           pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
   #endif
         pthread_mutexattr_init(&attributs_mutex);          pthread_mutexattr_init(&attributs_mutex);
         pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);          pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
         pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);          pthread_mutex_init(&mutex_liste_variables_partagees, &attributs_mutex);
Line 1301  instruction_detach(struct_processus *s_e Line 1305  instruction_detach(struct_processus *s_e
         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_NORMAL);
           pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus),
                   &attributs_mutex);
           pthread_mutexattr_destroy(&attributs_mutex);
   
           pthread_mutexattr_init(&attributs_mutex);
           pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
           pthread_mutex_init(&((*s_etat_processus).mutex_allocation),
                   &attributs_mutex);
           pthread_mutexattr_destroy(&attributs_mutex);
   
         liberation_queue_signaux(s_etat_processus);          liberation_queue_signaux(s_etat_processus);
         creation_queue_signaux(s_etat_processus);          creation_queue_signaux(s_etat_processus);
   
         if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
         }  
   
         routine_recursive = 0;          routine_recursive = 0;
           nombre_thread_surveillance_processus = 0;
   
         (*s_etat_processus).pointeur_signal_lecture = 0;          (*s_etat_processus).pointeur_signal_lecture = 0;
         (*s_etat_processus).pointeur_signal_ecriture = 0;          (*s_etat_processus).pointeur_signal_ecriture = 0;
Line 1412  instruction_detach(struct_processus *s_e Line 1424  instruction_detach(struct_processus *s_e
                 (*s_argument_thread).pipe_nombre_elements_attente[1],                  (*s_argument_thread).pipe_nombre_elements_attente[1],
                 &caractere, sizeof(caractere)) != sizeof(caractere))                  &caractere, sizeof(caractere)) != sizeof(caractere))
         {          {
             pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));  
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
   
             while((longueur_ecriture = write_atomic(s_etat_processus,              while((longueur_ecriture = write_atomic(s_etat_processus,
Line 1454  instruction_detach(struct_processus *s_e Line 1465  instruction_detach(struct_processus *s_e
         pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);          pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
         pthread_mutexattr_destroy(&attributs_mutex);          pthread_mutexattr_destroy(&attributs_mutex);
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))  
                 != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
   
             caractere = 0;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_elements_attente[1],  
                     &caractere, sizeof(caractere))) != sizeof(caractere))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             destruction_queue_signaux(s_etat_processus);  
             BUG(1, uprintf("Process management error line %d\n", __LINE__));  
             exit(EXIT_FAILURE);  
         }  
   
         pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes));  
   
         if (pthread_mutex_unlock(&((*s_etat_processus)  
                 .protection_liste_mutexes)) != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
   
             caractere = 0;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_elements_attente[1],  
                     &caractere, sizeof(caractere))) != sizeof(caractere))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             destruction_queue_signaux(s_etat_processus);  
             BUG(1, uprintf("Process management error line %d\n", __LINE__));  
             exit(EXIT_FAILURE);  
         }  
   
         pthread_mutex_trylock(&((*s_etat_processus).mutex_interruptions));  
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions))  
                 != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
   
             caractere = 0;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_elements_attente[1],  
                     &caractere, sizeof(caractere))) != sizeof(caractere))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             destruction_queue_signaux(s_etat_processus);  
             BUG(1, uprintf("Process management error line %d\n", __LINE__));  
             exit(EXIT_FAILURE);  
         }  
   
         pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux));  
   
         if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux))  
                 != 0)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
   
             caractere = 0;  
   
             while((longueur_ecriture = write_atomic(s_etat_processus,  
                     (*s_argument_thread).pipe_nombre_elements_attente[1],  
                     &caractere, sizeof(caractere))) != sizeof(caractere))  
             {  
                 if (longueur_ecriture == -1)  
                 {  
                     break;  
                 }  
             }  
   
             destruction_queue_signaux(s_etat_processus);  
             BUG(1, uprintf("Process management error line %d\n", __LINE__));  
             exit(EXIT_FAILURE);  
         }  
   
         if ((*s_etat_processus).evaluation_expression_compilee == 'N')          if ((*s_etat_processus).evaluation_expression_compilee == 'N')
         {          {
             free((*s_etat_processus).instruction_courante);              free((*s_etat_processus).instruction_courante);
Line 1604  instruction_detach(struct_processus *s_e Line 1521  instruction_detach(struct_processus *s_e
   
         // Attente de la réception du signal rpl_sigstart.          // Attente de la réception du signal rpl_sigstart.
   
         for((*s_etat_processus).demarrage_fils = d_faux;;)          for((*s_etat_processus).demarrage_fils = d_faux;
                   (*s_etat_processus).demarrage_fils != d_vrai;
                   nanosleep(&attente, NULL))
         {          {
             scrutation_interruptions(s_etat_processus);              scrutation_interruptions(s_etat_processus);
   
             if ((*s_etat_processus).demarrage_fils == d_vrai)  
             {  
                 break;  
             }  
   
             nanosleep(&attente, NULL);  
         }          }
   
         (*s_etat_processus).niveau_initial = (*s_etat_processus).niveau_courant;          (*s_etat_processus).niveau_initial = (*s_etat_processus).niveau_courant;
Line 1919  instruction_detach(struct_processus *s_e Line 1831  instruction_detach(struct_processus *s_e
             l_element_courant = l_element_suivant;              l_element_courant = l_element_suivant;
         }          }
   
           (*s_etat_processus).s_fichiers = NULL;
   
         /*          /*
          * Destruction des piles de connecteurs SQL           * Destruction des piles de connecteurs SQL
          */           */
Line 1941  instruction_detach(struct_processus *s_e Line 1855  instruction_detach(struct_processus *s_e
             l_element_courant = l_element_suivant;              l_element_courant = l_element_suivant;
         }          }
   
         (*s_etat_processus).s_connecteurs_sql = NULL;  
   
         /*          /*
          * On ne détruit pas les sockets car il faut utiliser DETACH           * On ne détruit pas les sockets car il faut utiliser DETACH
          * pour traiter plusieurs connexions simultanées sur les sockets           * pour traiter plusieurs connexions simultanées sur les sockets
          */           */
   
         (*s_etat_processus).s_fichiers = NULL;          (*s_etat_processus).s_connecteurs_sql = NULL;
   
         if ((*s_etat_processus).debug == d_vrai)          if ((*s_etat_processus).debug == d_vrai)
         {          {
Line 2809  instruction_detach(struct_processus *s_e Line 2721  instruction_detach(struct_processus *s_e
             liberation_profil(s_etat_processus);              liberation_profil(s_etat_processus);
         }          }
   
           attente.tv_sec = 0;
           attente.tv_nsec = GRANULARITE_us * 1000;
   
           while(nombre_thread_surveillance_processus != 0)
           {
               nanosleep(&attente, NULL);
               INCR_GRANULARITE(attente.tv_nsec);
           }
   
         closelog();          closelog();
   
           retrait_thread(s_etat_processus);
           liberation_contexte_cas(s_etat_processus);
   
           clear_history();
   
         close((*s_argument_thread).pipe_erreurs[1]);          close((*s_argument_thread).pipe_erreurs[1]);
         close((*s_argument_thread).pipe_interruptions[1]);          close((*s_argument_thread).pipe_interruptions[1]);
         close((*s_argument_thread).pipe_nombre_elements_attente[1]);          close((*s_argument_thread).pipe_nombre_elements_attente[1]);
Line 2819  instruction_detach(struct_processus *s_e Line 2745  instruction_detach(struct_processus *s_e
         close((*s_argument_thread).pipe_nombre_injections[0]);          close((*s_argument_thread).pipe_nombre_injections[0]);
         close((*s_argument_thread).pipe_acquittement[0]);          close((*s_argument_thread).pipe_acquittement[0]);
   
         retrait_thread(s_etat_processus);          free((*s_etat_processus).localisation);
           free((*s_etat_processus).chemin_fichiers_temporaires);
           free(s_argument_thread);
   
 #       ifndef SEMAPHORES_NOMMES          liberation_allocateur(s_etat_processus);
         sem_post(&((*s_etat_processus).semaphore_fork));          liberation_allocateur_buffer(s_etat_processus);
         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  
   
         clear_history();          // Permet d'attendre la libération du mutex de la part
           // de surveillance_processus().
   
         liberation_contexte_cas(s_etat_processus);          attente.tv_sec = 0;
         destruction_queue_signaux(s_etat_processus);          attente.tv_nsec = GRANULARITE_us * 1000;
   
         liberation_allocateur(s_etat_processus);          while(pthread_mutex_trylock(&((*s_etat_processus).mutex_pile_processus))
         liberation_allocateur_buffer(s_etat_processus);                  == EBUSY)
           {
               nanosleep(&attente, NULL);
               INCR_GRANULARITE(attente.tv_nsec);
           }
   
         free((*s_etat_processus).localisation);          pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
         free((*s_etat_processus).chemin_fichiers_temporaires);  
         free(s_argument_thread);          // Libération des mutexes.
   
         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));
Line 2849  instruction_detach(struct_processus *s_e Line 2776  instruction_detach(struct_processus *s_e
         pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));          pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
         pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));          pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer));
         pthread_mutex_destroy(&mutex_sections_critiques);          pthread_mutex_destroy(&mutex_sections_critiques);
           pthread_mutex_destroy(&mutex_liste_variables_partagees);
   
           destruction_queue_signaux(s_etat_processus);
           pthread_mutex_destroy(&mutex_liste_threads);
   
   #       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
   
         sys_free(s_etat_processus);          sys_free(s_etat_processus);
   
Removed from v.1.144  
changed lines
  Added in v.1.164

CVSweb interface <joel.bertrand@systella.fr>