[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.158 and 1.165

version 1.158, 2017/08/02 14:41:35 version 1.165, 2019/02/03 14:40:38
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.27    RPL/2 (R) version 4.1.31
   Copyright (C) 1989-2017 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 815  instruction_der(struct_processus *s_etat Line 815  instruction_der(struct_processus *s_etat
 void  void
 instruction_detach(struct_processus *s_etat_processus)  instruction_detach(struct_processus *s_etat_processus)
 {  {
 #ifndef EXPERIMENTAL_CODE  
     printf("DETACH currently broken is replaced by SPAWN...\n");  
     instruction_spawn(s_etat_processus);  
 #else  
     int                                 pipe_initialisation_segment_signaux[2];      int                                 pipe_initialisation_segment_signaux[2];
   
     logical1                            drapeau;      logical1                            drapeau;
Line 1299  instruction_detach(struct_processus *s_e Line 1295  instruction_detach(struct_processus *s_e
         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));
 #endif  #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 1429  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 1471  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 2834  instruction_detach(struct_processus *s_e Line 2734  instruction_detach(struct_processus *s_e
   
         retrait_thread(s_etat_processus);          retrait_thread(s_etat_processus);
         liberation_contexte_cas(s_etat_processus);          liberation_contexte_cas(s_etat_processus);
         destruction_queue_signaux(s_etat_processus);  
   
 #       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  
   
         clear_history();          clear_history();
   
Line 2862  instruction_detach(struct_processus *s_e Line 2752  instruction_detach(struct_processus *s_e
         liberation_allocateur(s_etat_processus);          liberation_allocateur(s_etat_processus);
         liberation_allocateur_buffer(s_etat_processus);          liberation_allocateur_buffer(s_etat_processus);
   
           // Permet d'attendre la libération du mutex de la part
           // de surveillance_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);
               INCR_GRANULARITE(attente.tv_nsec);
           }
   
           pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
   
           // 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));
         pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));          pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
Line 2870  instruction_detach(struct_processus *s_e Line 2777  instruction_detach(struct_processus *s_e
         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);          pthread_mutex_destroy(&mutex_liste_variables_partagees);
   
           destruction_queue_signaux(s_etat_processus);
         pthread_mutex_destroy(&mutex_liste_threads);          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);
   
 #       ifdef DEBUG_MEMOIRE  #       ifdef DEBUG_MEMOIRE
Line 2987  instruction_detach(struct_processus *s_e Line 2905  instruction_detach(struct_processus *s_e
     }      }
   
     return;      return;
 #endif  
 }  }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.158  
changed lines
  Added in v.1.165

CVSweb interface <joel.bertrand@systella.fr>