--- rpl/src/instructions_d5.c 2011/09/20 08:56:23 1.71 +++ rpl/src/instructions_d5.c 2017/01/18 15:44:19 1.156 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.3 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.26 + Copyright (C) 1989-2017 Dr. BERTRAND Joël This file is part of RPL/2. @@ -40,12 +40,13 @@ instruction_dft(struct_processus *s_etat { integer4 erreur; integer4 inverse; + integer4 longueur_dft; integer4 nombre_colonnes; integer4 nombre_lignes; logical1 presence_longueur_dft; - long longueur_dft_signee; + integer8 longueur_dft_signee; struct_complexe16 *matrice_f77; @@ -53,10 +54,9 @@ instruction_dft(struct_processus *s_etat struct_objet *s_objet_longueur_dft; struct_objet *s_objet_resultat; - unsigned long i; - unsigned long j; - unsigned long k; - unsigned long longueur_dft; + integer8 i; + integer8 j; + integer8 k; (*s_etat_processus).erreur_execution = d_ex; @@ -135,7 +135,7 @@ instruction_dft(struct_processus *s_etat return; } - longueur_dft = longueur_dft_signee; + longueur_dft = (integer4) longueur_dft_signee; } else { @@ -170,11 +170,11 @@ instruction_dft(struct_processus *s_etat { if (presence_longueur_dft == d_faux) { - longueur_dft = (*((struct_vecteur *) + longueur_dft = (integer4) (*((struct_vecteur *) (*s_objet_argument).objet)).taille; } - if ((matrice_f77 = malloc(longueur_dft * + if ((matrice_f77 = malloc(((size_t) longueur_dft) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -260,13 +260,13 @@ instruction_dft(struct_processus *s_etat { if (presence_longueur_dft == d_faux) { - longueur_dft = (*((struct_matrice *) + longueur_dft = (integer4) (*((struct_matrice *) (*s_objet_argument).objet)).nombre_colonnes; } - if ((matrice_f77 = malloc(longueur_dft * + if ((matrice_f77 = malloc(((size_t) longueur_dft) * ((size_t) (*((struct_matrice *) (*s_objet_argument).objet)) - .nombre_lignes * sizeof(struct_complexe16))) == NULL) + .nombre_lignes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -342,8 +342,8 @@ instruction_dft(struct_processus *s_etat } } - nombre_lignes = (*((struct_matrice *) (*s_objet_argument).objet)) - .nombre_lignes; + nombre_lignes = (integer4) (*((struct_matrice *) (*s_objet_argument) + .objet)).nombre_lignes; nombre_colonnes = longueur_dft; inverse = 0; @@ -371,8 +371,8 @@ instruction_dft(struct_processus *s_etat longueur_dft; if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = - malloc((*((struct_matrice *) (*s_objet_resultat).objet)) - .nombre_lignes * sizeof(struct_complexe16 *))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat) + .objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -383,8 +383,8 @@ instruction_dft(struct_processus *s_etat { if ((((struct_complexe16 **) (*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i] = - malloc((*((struct_matrice *) - (*s_objet_resultat).objet)).nombre_colonnes * + malloc(((size_t) (*((struct_matrice *) + (*s_objet_resultat).objet)).nombre_colonnes) * sizeof(struct_complexe16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -767,6 +767,7 @@ instruction_der(struct_processus *s_etat if ((s_objet_simplifie = simplification(s_etat_processus, s_objet_resultat)) == NULL) { + liberation(s_etat_processus, s_objet_resultat); return; } @@ -814,47 +815,57 @@ instruction_der(struct_processus *s_etat void instruction_detach(struct_processus *s_etat_processus) { - int pipe_initialisation_segment_signaux[2]; +#ifndef EXPERIMENTAL_CODE + printf("DETACH currently broken is replaced by SPAWN...\n"); + instruction_spawn(s_etat_processus); +#else + int pipe_initialisation_segment_signaux[2]; - logical1 drapeau; - logical1 variable_partagee; + logical1 drapeau; - pid_t ppid; - pid_t pid_final; + pid_t ppid; - pthread_attr_t attributs; + pthread_attr_t attributs; - pthread_mutexattr_t attributs_mutex; + pthread_mutexattr_t attributs_mutex; - pthread_t thread_surveillance; + pthread_t thread_surveillance; - sig_atomic_t registre_stop; + sig_atomic_t registre_stop; - ssize_t longueur_ecriture; + ssize_t longueur_ecriture; - struct_descripteur_thread *s_argument_thread; - struct_descripteur_thread *s_argument_thread2; + struct_descripteur_thread *s_argument_thread; + struct_descripteur_thread *s_argument_thread2; - struct_liste_chainee *l_element_courant; - struct_liste_chainee *l_element_precedent; - struct_liste_chainee *l_element_suivant; + struct_liste_chainee *l_element_courant; + struct_liste_chainee *l_element_precedent; + struct_liste_chainee *l_element_suivant; + + struct_liste_variables_partagees *l_element_partage_courant; + struct_liste_variables_partagees *l_element_partage_suivant; - struct_objet *s_copie; - struct_objet *s_objet; - struct_objet *s_objet_systeme; - struct_objet *s_objet_temporaire; + struct_liste_variables_statiques *l_element_statique_courant; + struct_liste_variables_statiques *l_element_statique_suivant; - struct sigaction action; - struct sigaction registre; + struct_objet *s_copie; + struct_objet *s_objet; + struct_objet *s_objet_systeme; + struct_objet *s_objet_temporaire; - struct timespec attente; + struct sigaction action; + struct sigaction registre; - unsigned char caractere; - unsigned char *message; + struct timespec attente; - unsigned int erreur; + unsigned char caractere; + unsigned char *message; - unsigned long i; + unsigned int erreur; + + integer8 i; + + volatile logical1 variable_partagee; (*s_etat_processus).erreur_execution = d_ex; @@ -930,26 +941,12 @@ instruction_detach(struct_processus *s_e if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) { - if (pthread_mutex_lock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } - if (recherche_variable_partagee(s_etat_processus, (*(*s_etat_processus).pointeur_variable_courante).nom, (*(*s_etat_processus).pointeur_variable_courante) .variable_partagee, (*(*s_etat_processus) - .pointeur_variable_courante).origine) == d_faux) + .pointeur_variable_courante).origine) == NULL) { - if (pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } - liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_systeme = d_es; @@ -958,16 +955,14 @@ instruction_detach(struct_processus *s_e return; } - if (((*(*(*s_etat_processus).s_liste_variables_partagees) - .table[(*(*s_etat_processus) - .s_liste_variables_partagees).position_variable].objet) - .type != RPN) && ((*(*(*s_etat_processus) - .s_liste_variables_partagees).table - [(*(*s_etat_processus).s_liste_variables_partagees) - .position_variable].objet).type != ADR)) + if (((*(*(*s_etat_processus) + .pointeur_variable_partagee_courante).objet).type + == RPN) && ((*(*(*s_etat_processus) + .pointeur_variable_partagee_courante).objet).type + == ADR)) { if (pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) != 0) + .pointeur_variable_partagee_courante).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -981,12 +976,12 @@ instruction_detach(struct_processus *s_e } if ((s_copie = copie_objet(s_etat_processus, - (*(*s_etat_processus).s_liste_variables_partagees).table - [(*(*s_etat_processus).s_liste_variables_partagees) - .position_variable].objet, 'P')) == NULL) + (*(*s_etat_processus) + .pointeur_variable_partagee_courante).objet, 'P')) + == NULL) { if (pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) != 0) + .pointeur_variable_partagee_courante).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1001,7 +996,7 @@ instruction_detach(struct_processus *s_e variable_partagee = d_vrai; if (pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) != 0) + .pointeur_variable_partagee_courante).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1049,7 +1044,7 @@ instruction_detach(struct_processus *s_e return; } - if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0) + if (pipe((*s_argument_thread).pipe_nombre_elements_attente) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1067,12 +1062,6 @@ instruction_detach(struct_processus *s_e return; } - if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } - if (pipe((*s_argument_thread).pipe_injections) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -1097,7 +1086,21 @@ instruction_detach(struct_processus *s_e * Le mutex suivant permet de copier un contexte propre. */ - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (pthread_mutex_lock(&mutex_liste_variables_partagees) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + verrouillage_threads_concurrents(s_etat_processus); + + if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation_buffer)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -1110,9 +1113,21 @@ instruction_detach(struct_processus *s_e * de mémoire, ni libération, ni copie d'objet concurrent au fork(). */ - verrouillage_threads_concurrents(s_etat_processus); (*s_argument_thread).pid = fork(); - deverrouillage_threads_concurrents(s_etat_processus); + + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation_buffer)) + != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if ((*s_argument_thread).pid > 0) + { + // On ne déverrouille les threads concurrents que dans le processus + // père. Dans le fils, les valeurs sont non initialisées. + deverrouillage_threads_concurrents(s_etat_processus); + } (*s_argument_thread).thread_pere = pthread_self(); (*s_argument_thread).processus_detache = d_vrai; @@ -1134,6 +1149,12 @@ instruction_detach(struct_processus *s_e * Processus père */ + if (pthread_mutex_unlock(&mutex_liste_variables_partagees) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + if (variable_partagee == d_vrai) { liberation(s_etat_processus, s_copie); @@ -1181,7 +1202,7 @@ instruction_detach(struct_processus *s_e return; } - if (close((*s_argument_thread).pipe_nombre_interruptions_attente[1]) + if (close((*s_argument_thread).pipe_nombre_elements_attente[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -1194,12 +1215,6 @@ instruction_detach(struct_processus *s_e return; } - if (close((*s_argument_thread).pipe_nombre_objets_attente[1]) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } - if (close((*s_argument_thread).pipe_injections[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -1231,28 +1246,30 @@ instruction_detach(struct_processus *s_e return; } -# ifndef OS2 -# ifndef Cygwin +# ifdef SCHED_OTHER if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } +# endif +# ifdef PTHREAD_EXPLICIT_SCHED if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } +# endif +# ifdef PTHREAD_SCOPE_SYSTEM if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } # endif -# endif (*s_argument_thread).s_etat_processus = s_etat_processus; @@ -1275,9 +1292,44 @@ instruction_detach(struct_processus *s_e * Processus fils */ + // EPERM +#if 0 + pthread_mutex_destroy(&mutex_liste_variables_partagees); + 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_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&mutex_liste_variables_partagees, &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, &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); + +#if 0 liberation_queue_signaux(s_etat_processus); +#endif creation_queue_signaux(s_etat_processus); + routine_recursive = 0; + nombre_thread_surveillance_processus = 0; + (*s_etat_processus).pointeur_signal_lecture = 0; (*s_etat_processus).pointeur_signal_ecriture = 0; @@ -1288,6 +1340,7 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).erreur_systeme = d_es_processus; } +#if 0 close(pipe_initialisation_segment_signaux[0]); close(pipe_initialisation_segment_signaux[1]); @@ -1318,7 +1371,7 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).erreur_systeme = d_es_processus; } else if (close((*s_argument_thread) - .pipe_nombre_interruptions_attente[0]) != 0) + .pipe_nombre_elements_attente[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; } @@ -1326,10 +1379,6 @@ instruction_detach(struct_processus *s_e { (*s_etat_processus).erreur_systeme = d_es_processus; } - else if (close((*s_argument_thread).pipe_nombre_objets_attente[0]) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - } else if (close((*s_argument_thread).pipe_injections[1]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -1363,47 +1412,35 @@ instruction_detach(struct_processus *s_e l_element_courant = (*s_etat_processus).liste_mutexes; while(l_element_courant != NULL) { - pthread_mutex_trylock(&((*((struct_mutex *) (*(*l_element_courant) - .donnee).objet)).mutex)); - pthread_mutex_unlock(&((*((struct_mutex *) (*(*l_element_courant) - .donnee).objet)).mutex)); - pthread_mutex_destroy(&((*((struct_mutex *) (*(*l_element_courant) - .donnee).objet)).mutex)); - liberation(s_etat_processus, (*l_element_courant).donnee); l_element_suivant = (*l_element_courant).suivant; free(l_element_courant); l_element_courant = l_element_suivant; } +#endif (*s_etat_processus).liste_mutexes = NULL; +#if 0 liberation_threads(s_etat_processus); - - (*(*s_etat_processus).s_liste_variables_partagees) - .table = NULL; - (*(*s_etat_processus).s_liste_variables_partagees) - .nombre_variables = 0; - (*(*s_etat_processus).s_liste_variables_partagees) - .nombre_variables_allouees = 0; - +#endif insertion_thread(s_etat_processus, d_vrai); // Envoi d'une donnée pour signaler le démarrage du processus au thread // de surveillance. + caractere = 0; + if (write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - "-", sizeof(unsigned char)) != sizeof(unsigned char)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere)) != sizeof(caractere)) { - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); (*s_etat_processus).erreur_systeme = d_es_processus; - pid_final = -2; - while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1411,9 +1448,19 @@ instruction_detach(struct_processus *s_e } } + destruction_queue_signaux(s_etat_processus); + BUG(1, uprintf("Process management error line %d\n", __LINE__)); + exit(EXIT_FAILURE); + } + +#if 0 + if (pthread_mutex_destroy(&mutex_sections_critiques) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1425,16 +1472,23 @@ instruction_detach(struct_processus *s_e BUG(1, uprintf("Process management error line %d\n", __LINE__)); exit(EXIT_FAILURE); } +#endif + + pthread_mutexattr_init(&attributs_mutex); + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex); + pthread_mutexattr_destroy(&attributs_mutex); - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - pid_final = -2; + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1442,9 +1496,23 @@ instruction_detach(struct_processus *s_e } } + 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_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1457,18 +1525,18 @@ instruction_detach(struct_processus *s_e exit(EXIT_FAILURE); } - pthread_mutex_trylock(&((*s_etat_processus).protection_liste_mutexes)); + pthread_mutex_trylock(&((*s_etat_processus).mutex_interruptions)); - if (pthread_mutex_unlock(&((*s_etat_processus) - .protection_liste_mutexes)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) + != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - pid_final = -2; + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1476,9 +1544,23 @@ instruction_detach(struct_processus *s_e } } + 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_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1493,10 +1575,13 @@ instruction_detach(struct_processus *s_e if ((*s_etat_processus).evaluation_expression_compilee == 'N') { +#if 0 free((*s_etat_processus).instruction_courante); +#endif (*s_etat_processus).instruction_courante = NULL; } +#if 0 (*s_etat_processus).var_volatile_processus_pere = 0; (*s_etat_processus).var_volatile_processus_racine = 0; @@ -1513,16 +1598,20 @@ instruction_detach(struct_processus *s_e liberation(s_etat_processus, (*s_etat_processus).at_poke); (*s_etat_processus).at_poke = NULL; (*s_etat_processus).traitement_at_poke = 'N'; +#endif for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++) { +#if 0 liberation(s_etat_processus, (*s_etat_processus).corps_interruptions[i]); +#endif (*s_etat_processus).corps_interruptions[i] = NULL; (*s_etat_processus).masque_interruptions[i] = 'N'; (*s_etat_processus).queue_interruptions[i] = 0; +#if 0 l_element_courant = (*s_etat_processus) .pile_origine_interruptions[i]; @@ -1533,6 +1622,7 @@ instruction_detach(struct_processus *s_e free(l_element_courant); l_element_courant = l_element_suivant; } +#endif (*s_etat_processus).pile_origine_interruptions[i] = NULL; } @@ -1547,28 +1637,22 @@ instruction_detach(struct_processus *s_e // 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); - - if ((*s_etat_processus).demarrage_fils == d_vrai) - { - break; - } - - nanosleep(&attente, NULL); } +#if 0 (*s_etat_processus).niveau_initial = (*s_etat_processus).niveau_courant; (*s_etat_processus).presence_pipes = d_vrai; (*s_etat_processus).debug_programme = d_faux; (*s_etat_processus).pipe_donnees = (*s_argument_thread).pipe_objets[1]; - (*s_etat_processus).pipe_nombre_objets_attente = (*s_argument_thread) - .pipe_nombre_objets_attente[1]; + (*s_etat_processus).pipe_nombre_elements_attente = (*s_argument_thread) + .pipe_nombre_elements_attente[1]; (*s_etat_processus).pipe_interruptions = (*s_argument_thread) .pipe_interruptions[1]; - (*s_etat_processus).pipe_nombre_interruptions_attente = - (*s_argument_thread).pipe_nombre_interruptions_attente[1]; (*s_etat_processus).pipe_injections = (*s_argument_thread).pipe_injections[0]; (*s_etat_processus).pipe_nombre_injections = @@ -1581,18 +1665,25 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).presence_fusible = d_faux; (*s_etat_processus).thread_fusible = 0; (*s_etat_processus).pid_erreur_processus_fils = getpid(); + (*s_etat_processus).sections_critiques = 0; + (*s_etat_processus).initialisation_scheduler = d_faux; +#endif +#if 0 if ((*s_etat_processus).profilage == d_vrai) { liberation_profil(s_etat_processus); } +#endif (*s_etat_processus).pile_profilage = NULL; +#if 0 if ((*s_etat_processus).generateur_aleatoire != NULL) { liberation_generateur_aleatoire(s_etat_processus); } +#endif (*s_etat_processus).generateur_aleatoire = NULL; @@ -1607,25 +1698,16 @@ instruction_detach(struct_processus *s_e * par liberation_threads(). */ - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { (*s_etat_processus).erreur_systeme = d_es; - pid_final = -2; - - while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) - { - if (longueur_ecriture == -1) - { - break; - } - } + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1654,16 +1736,15 @@ instruction_detach(struct_processus *s_e printf("(*s_argument_thread2).nombre_references = %d\n", (int) (*s_argument_thread2).nombre_references)); +#if 0 if ((*s_argument_thread2).nombre_references == 0) { close((*s_argument_thread2).pipe_objets[0]); close((*s_argument_thread2).pipe_acquittement[1]); close((*s_argument_thread2).pipe_injections[1]); close((*s_argument_thread2).pipe_nombre_injections[1]); - close((*s_argument_thread2).pipe_nombre_objets_attente[0]); + close((*s_argument_thread2).pipe_nombre_elements_attente[0]); close((*s_argument_thread2).pipe_interruptions[0]); - close((*s_argument_thread2) - .pipe_nombre_interruptions_attente[0]); pthread_mutex_destroy(&((*s_argument_thread2).mutex)); @@ -1680,6 +1761,7 @@ instruction_detach(struct_processus *s_e free((*(*l_element_courant).donnee).objet); free((*l_element_courant).donnee); } +#endif l_element_suivant = (*l_element_courant).suivant; free((struct_liste_chainee *) l_element_courant); @@ -1688,25 +1770,16 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).l_base_pile_processus = NULL; - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) + != 0) { (*s_etat_processus).erreur_systeme = d_es; - pid_final = -2; + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) - { - if (longueur_ecriture == -1) - { - break; - } - } - - while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1723,6 +1796,7 @@ instruction_detach(struct_processus *s_e * Initialisation de la pile système */ +#if 0 l_element_courant = (struct_liste_chainee *) (*s_etat_processus).l_base_pile_systeme; while(l_element_courant != NULL) @@ -1749,29 +1823,21 @@ instruction_detach(struct_processus *s_e l_element_courant = l_element_suivant; } +#endif (*s_etat_processus).l_base_pile_systeme = NULL; (*s_etat_processus).hauteur_pile_systeme = 0; +#if 0 empilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { - pid_final = -2; - - while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) - { - if (longueur_ecriture == -1) - { - break; - } - } + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1785,7 +1851,9 @@ instruction_detach(struct_processus *s_e } (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y'; +#endif +#if 0 l_element_courant = (struct_liste_chainee *) (*s_etat_processus).s_marques; @@ -1798,6 +1866,7 @@ instruction_detach(struct_processus *s_e free((struct_marque *) l_element_courant); l_element_courant = l_element_suivant; } +#endif (*s_etat_processus).s_marques = NULL; @@ -1806,25 +1875,16 @@ instruction_detach(struct_processus *s_e * les variables dans le cas d'un programme compilé. */ +#if 0 empilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { - pid_final = -2; - - while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) - { - if (longueur_ecriture == -1) - { - break; - } - } + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -1838,11 +1898,13 @@ instruction_detach(struct_processus *s_e } (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y'; +#endif /* * Destruction des sorties graphiques et PostScript */ +#if 0 while((*s_etat_processus).fichiers_graphiques != NULL) { free((*(*s_etat_processus).fichiers_graphiques).nom); @@ -1864,6 +1926,7 @@ instruction_detach(struct_processus *s_e pclose((*s_etat_processus).entree_standard); (*s_etat_processus).entree_standard = NULL; } +#endif (*s_etat_processus).requete_nouveau_plan = d_vrai; (*s_etat_processus).mise_a_jour_trace_requise = d_faux; @@ -1878,6 +1941,7 @@ instruction_detach(struct_processus *s_e * Destruction des piles de fichiers */ +#if 0 l_element_courant = (*s_etat_processus).s_fichiers; while(l_element_courant != NULL) @@ -1902,6 +1966,8 @@ instruction_detach(struct_processus *s_e l_element_courant = l_element_suivant; } + (*s_etat_processus).s_fichiers = NULL; + /* * Destruction des piles de connecteurs SQL */ @@ -1924,14 +1990,13 @@ instruction_detach(struct_processus *s_e 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 * pour traiter plusieurs connexions simultanées sur les sockets */ - (*s_etat_processus).s_fichiers = NULL; + (*s_etat_processus).s_connecteurs_sql = NULL; +#endif if ((*s_etat_processus).debug == d_vrai) { @@ -1949,8 +2014,21 @@ instruction_detach(struct_processus *s_e } } +#if 0 if ((*s_etat_processus).erreur_systeme == d_es) { + // Évite le warning variable s_copie might be clobbered by + // longjmp or vfork + struct_objet **s; + + if ((s = malloc(sizeof(struct_objet *))) == NULL) + { + (*s_etat_processus).erreur_execution = d_es_allocation_memoire; + return; + } + + (*s) = s_copie; + if (setjmp(contexte_processus) == 0) { if (variable_partagee == d_faux) @@ -1966,11 +2044,18 @@ instruction_detach(struct_processus *s_e } else { - if (((*s_etat_processus).var_volatile_alarme == 0) - && ((*s_etat_processus).arret_depuis_abort == 0) + if (((*s_etat_processus).arret_depuis_abort == 0) && ((*s_etat_processus).at_exit != NULL)) { (*s_etat_processus).var_volatile_requete_arret = 0; + (*s_etat_processus).var_volatile_alarme = 0; + (*s_etat_processus).var_volatile_traitement_sigint + = 0; + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, "ATEXIT"); + } if (evaluation(s_etat_processus, (*s_etat_processus).at_exit, 'E') == @@ -1979,12 +2064,17 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation; } + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, NULL); + } } } } else { - if (evaluation(s_etat_processus, s_copie, 'E') == d_erreur) + if (evaluation(s_etat_processus, (*s), 'E') == d_erreur) { if (((*s_etat_processus).erreur_execution == d_ex) && ((*s_etat_processus).erreur_systeme == d_es)) @@ -1995,9 +2085,18 @@ instruction_detach(struct_processus *s_e } else { - if ((*s_etat_processus).at_exit != NULL) + if (((*s_etat_processus).arret_depuis_abort == 0) + && ((*s_etat_processus).at_exit != NULL)) { (*s_etat_processus).var_volatile_requete_arret = 0; + (*s_etat_processus).var_volatile_alarme = 0; + (*s_etat_processus).var_volatile_traitement_sigint + = 0; + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, "ATEXIT"); + } if (evaluation(s_etat_processus, (*s_etat_processus).at_exit, 'E') == @@ -2006,12 +2105,26 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation; } + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, NULL); + } } } - liberation(s_etat_processus, s_copie); + liberation(s_etat_processus, (*s)); } } + + free(s); + } +#endif + +#if 0 + for(i = 0; i < (*s_etat_processus).sections_critiques; i++) + { + pthread_mutex_unlock(&mutex_sections_critiques); } liberation(s_etat_processus, (*s_etat_processus).at_exit); @@ -2020,13 +2133,6 @@ instruction_detach(struct_processus *s_e l_element_courant = (*s_etat_processus).liste_mutexes; while(l_element_courant != NULL) { - pthread_mutex_trylock(&((*((struct_mutex *) - (*(*l_element_courant).donnee).objet)).mutex)); - pthread_mutex_unlock(&((*((struct_mutex *) - (*(*l_element_courant).donnee).objet)).mutex)); - pthread_mutex_destroy(&((*((struct_mutex *) - (*(*l_element_courant).donnee).objet)).mutex)); - liberation(s_etat_processus, (*l_element_courant).donnee); l_element_suivant = (*l_element_courant).suivant; free(l_element_courant); @@ -2037,22 +2143,13 @@ instruction_detach(struct_processus *s_e { pthread_cancel((*s_etat_processus).thread_fusible); } +#endif - pid_final = -2; - - while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_interruptions_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) - { - if (longueur_ecriture == -1) - { - break; - } - } + caractere = 0; while((longueur_ecriture = write_atomic(s_etat_processus, - (*s_argument_thread).pipe_nombre_objets_attente[1], - &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + (*s_argument_thread).pipe_nombre_elements_attente[1], + &caractere, sizeof(caractere))) != sizeof(caractere)) { if (longueur_ecriture == -1) { @@ -2081,7 +2178,7 @@ instruction_detach(struct_processus *s_e { while((longueur_ecriture = write_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[1], - &((*s_etat_processus).erreur_execution), + (int *) &((*s_etat_processus).erreur_execution), sizeof((*s_etat_processus).erreur_execution))) != sizeof((*s_etat_processus).erreur_execution)) { @@ -2113,7 +2210,7 @@ instruction_detach(struct_processus *s_e { while((longueur_ecriture = write_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[1], - &((*s_etat_processus).erreur_systeme), + (int *) &((*s_etat_processus).erreur_systeme), sizeof((*s_etat_processus).erreur_systeme))) != sizeof((*s_etat_processus).erreur_systeme)) { @@ -2151,15 +2248,7 @@ instruction_detach(struct_processus *s_e } } - close((*s_argument_thread).pipe_erreurs[1]); - close((*s_argument_thread).pipe_interruptions[1]); - close((*s_argument_thread).pipe_nombre_interruptions_attente[1]); - close((*s_argument_thread).pipe_objets[1]); - close((*s_argument_thread).pipe_nombre_objets_attente[1]); - close((*s_argument_thread).pipe_injections[0]); - close((*s_argument_thread).pipe_nombre_injections[0]); - close((*s_argument_thread).pipe_acquittement[0]); - +#if 0 l_element_courant = (*s_etat_processus).s_fichiers; while(l_element_courant != NULL) @@ -2197,7 +2286,7 @@ instruction_detach(struct_processus *s_e l_element_courant = l_element_suivant; } - pthread_mutex_lock(&((*s_etat_processus).mutex)); + pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)); l_element_courant = (struct_liste_chainee *) (*s_etat_processus).l_base_pile_processus; @@ -2239,7 +2328,7 @@ instruction_detach(struct_processus *s_e { envoi_signal_processus((*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet)).thread).pid, - rpl_sigurg); + rpl_sigurg, d_faux); } else { @@ -2247,13 +2336,13 @@ instruction_detach(struct_processus *s_e { envoi_signal_processus((*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet)).thread) - .pid, rpl_sigabort); + .pid, rpl_sigabort, d_faux); } else { envoi_signal_processus((*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet)).thread) - .pid, rpl_sigstop); + .pid, rpl_sigstop, d_faux); } } } @@ -2342,7 +2431,7 @@ instruction_detach(struct_processus *s_e .var_volatile_traitement_retarde_stop; (*s_etat_processus).var_volatile_traitement_retarde_stop = 1; - for(i = 0; i < (unsigned long) (*(*((struct_processus_fils *) + for(i = 0; i < (*(*((struct_processus_fils *) (*(*l_element_courant) .donnee).objet)).thread).nombre_objets_dans_pipe; i++) { @@ -2360,7 +2449,8 @@ instruction_detach(struct_processus *s_e if (sigaction(SIGPIPE, &action, ®istre) != 0) { - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); if (registre_stop == 0) { @@ -2414,27 +2504,49 @@ instruction_detach(struct_processus *s_e { destruction_queue_signaux(s_etat_processus); - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); (*s_etat_processus).erreur_systeme = d_es_signal; exit(EXIT_FAILURE); } } } - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) + != 0) + { + destruction_queue_signaux(s_etat_processus); + + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); + (*s_etat_processus).erreur_systeme = d_es_processus; + exit(EXIT_FAILURE); + } if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) { affectation_interruptions_logicielles(s_etat_processus); } + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_interruptions)) != 0) + { + destruction_queue_signaux(s_etat_processus); + + pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)); + (*s_etat_processus).erreur_systeme = d_es_processus; + exit(EXIT_FAILURE); + } + + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); nanosleep(&attente, NULL); - pthread_mutex_lock(&((*s_etat_processus).mutex)); + pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)); scrutation_interruptions(s_etat_processus); } - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); l_element_courant = (*s_etat_processus).s_sockets; @@ -2532,6 +2644,26 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).arbre_instructions); free((*s_etat_processus).pointeurs_caracteres); + l_element_statique_courant = (*s_etat_processus) + .l_liste_variables_statiques; + + while(l_element_statique_courant != NULL) + { + l_element_statique_suivant = (*l_element_statique_courant).suivant; + free(l_element_statique_courant); + l_element_statique_courant = l_element_statique_suivant; + } + + l_element_partage_courant = (*(*s_etat_processus) + .l_liste_variables_partagees); + + while(l_element_partage_courant != NULL) + { + l_element_partage_suivant = (*l_element_partage_courant).suivant; + free(l_element_partage_courant); + l_element_partage_courant = l_element_partage_suivant; + } + if ((*s_etat_processus).entree_standard != NULL) { pclose((*s_etat_processus).entree_standard); @@ -2556,39 +2688,12 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).instruction_derniere_erreur = NULL; } + liberation_arbre_variables_partagees(s_etat_processus, + (*(*s_etat_processus).s_arbre_variables_partagees)); liberation_arbre_variables(s_etat_processus, (*s_etat_processus).s_arbre_variables, d_vrai); free((*s_etat_processus).pointeurs_caracteres_variables); - for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) - { - liberation(s_etat_processus, - (*s_etat_processus).s_liste_variables_statiques[i].objet); - free((*s_etat_processus).s_liste_variables_statiques[i].nom); - } - - free((*s_etat_processus).s_liste_variables_statiques); - - for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees) - .nombre_variables; i++) - { - liberation(s_etat_processus, - (*(*s_etat_processus).s_liste_variables_partagees) - .table[i].objet); - free((*(*s_etat_processus).s_liste_variables_partagees) - .table[i].nom); - } - - if ((*(*s_etat_processus).s_liste_variables_partagees).table - != NULL) - { - free((struct_variable_partagee *) - (*(*s_etat_processus).s_liste_variables_partagees).table); - } - - pthread_mutex_destroy(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); - l_element_courant = (*s_etat_processus).l_base_pile; while(l_element_courant != NULL) { @@ -2706,8 +2811,6 @@ instruction_detach(struct_processus *s_e l_element_courant = l_element_suivant; } - free((*s_etat_processus).chemin_fichiers_temporaires); - if ((*s_etat_processus).debug == d_vrai) if (((*s_etat_processus).type_debug & d_debug_processus) != 0) @@ -2759,31 +2862,68 @@ instruction_detach(struct_processus *s_e liberation_profil(s_etat_processus); } +#endif + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while(nombre_thread_surveillance_processus != 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + +#if 0 closelog(); - liberation_allocateur(s_etat_processus); retrait_thread(s_etat_processus); + liberation_contexte_cas(s_etat_processus); +#endif + destruction_queue_signaux(s_etat_processus); - pthread_mutex_destroy(&((*s_etat_processus).mutex)); - pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation)); - pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes)); - +# 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 + +#if 0 + clear_history(); + + close((*s_argument_thread).pipe_erreurs[1]); + close((*s_argument_thread).pipe_interruptions[1]); + close((*s_argument_thread).pipe_nombre_elements_attente[1]); + close((*s_argument_thread).pipe_objets[1]); + close((*s_argument_thread).pipe_injections[0]); + close((*s_argument_thread).pipe_nombre_injections[0]); + close((*s_argument_thread).pipe_acquittement[0]); free((*s_etat_processus).localisation); + free((*s_etat_processus).chemin_fichiers_temporaires); free(s_argument_thread); - clear_history(); + liberation_allocateur(s_etat_processus); + liberation_allocateur_buffer(s_etat_processus); - destruction_queue_signaux(s_etat_processus); - liberation_contexte_cas(s_etat_processus); - free(s_etat_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_interruptions)); + pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux)); + pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes)); + pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation_buffer)); + pthread_mutex_destroy(&mutex_sections_critiques); + pthread_mutex_destroy(&mutex_liste_variables_partagees); + pthread_mutex_destroy(&mutex_liste_threads); + + sys_free(s_etat_processus); # ifdef DEBUG_MEMOIRE debug_memoire_verification(); analyse_post_mortem(); # endif +#endif exit(EXIT_SUCCESS); } @@ -2816,7 +2956,8 @@ instruction_detach(struct_processus *s_e (*(*l_element_courant).donnee).objet)).thread).pid == (*s_argument_thread).pid) { - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -2825,7 +2966,8 @@ instruction_detach(struct_processus *s_e nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); - if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_lock(&((*s_etat_processus) + .mutex_pile_processus)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -2845,14 +2987,14 @@ instruction_detach(struct_processus *s_e (struct_liste_chainee **) &((*s_etat_processus) .l_base_pile_processus), s_objet_systeme) == d_erreur) { - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); return; } if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) { - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); return; } @@ -2876,20 +3018,22 @@ instruction_detach(struct_processus *s_e // Le fils peut être présent sans être en attente du signal de départ. - if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart) != 0) + if (envoi_signal_processus((*s_argument_thread).pid, rpl_sigstart, + d_vrai) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - pthread_mutex_unlock(&((*s_etat_processus).mutex)); + pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)); return; } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } return; +#endif } // vim: ts=4