--- rpl/src/instructions_d5.c 2010/05/16 19:36:20 1.20 +++ rpl/src/instructions_d5.c 2010/06/04 07:48:20 1.25 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.0.15 + RPL/2 (R) version 4.0.16 Copyright (C) 1989-2010 Dr. BERTRAND Joël This file is part of RPL/2. @@ -838,6 +838,7 @@ instruction_detach(struct_processus *s_e ssize_t longueur_ecriture; struct_descripteur_thread *s_argument_thread; + struct_descripteur_thread *s_argument_thread2; struct_liste_chainee *l_element_courant; struct_liste_chainee *l_element_precedent; @@ -1296,6 +1297,24 @@ instruction_detach(struct_processus *s_e * Processus fils */ + if ((*s_etat_processus).debug == d_vrai) + if (((*s_etat_processus).type_debug & + d_debug_processus) != 0) + { + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Lancement du processus fils %d de %d\n", + (int) getpid(), (int) getpid(), (int) ppid); + } + else + { + printf("[%d] Start child process %d from %d\n", (int) getpid(), + (int) getpid(), (int) ppid); + } + + fflush(stdout); + } + # ifndef SEMAPHORES_NOMMES sem_post(&semaphore_gestionnaires_signaux); sem_destroy(&semaphore_gestionnaires_signaux); @@ -1389,6 +1408,23 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).erreur_systeme = d_es_processus; } + if ((*s_etat_processus).debug == d_vrai) + if (((*s_etat_processus).type_debug & + d_debug_processus) != 0) + { + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Libération des objets du processus père\n", + (int) getpid()); + } + else + { + printf("[%d] Freeing parent process memory\n", getpid()); + } + + fflush(stdout); + } + l_element_courant = (*s_etat_processus).liste_mutexes; while(l_element_courant != NULL) { @@ -1450,6 +1486,7 @@ instruction_detach(struct_processus *s_e } } + BUG(1, uprintf("Process management error line %d\n", __LINE__)); exit(EXIT_FAILURE); } @@ -1479,6 +1516,7 @@ instruction_detach(struct_processus *s_e } } + BUG(1, uprintf("Process management error line %d\n", __LINE__)); exit(EXIT_FAILURE); } @@ -1509,6 +1547,7 @@ instruction_detach(struct_processus *s_e } } + BUG(1, uprintf("Process management error line %d\n", __LINE__)); exit(EXIT_FAILURE); } @@ -1554,24 +1593,6 @@ instruction_detach(struct_processus *s_e (*s_etat_processus).pile_origine_interruptions[i] = NULL; } - if ((*s_etat_processus).debug == d_vrai) - if (((*s_etat_processus).type_debug & - d_debug_processus) != 0) - { - if ((*s_etat_processus).langue == 'F') - { - printf("[%d] Lancement du processus fils %d de %d\n", - (int) getpid(), (int) getpid(), (int) ppid); - } - else - { - printf("[%d] Start child process %d from %d\n", (int) getpid(), - (int) getpid(), (int) ppid); - } - - fflush(stdout); - } - /* * On bloque l'exécution du processus fils jusqu'à ce que * le père ait renseigné correctement la pile des processus. @@ -1641,11 +1662,114 @@ instruction_detach(struct_processus *s_e } /* - * Initialisation de la pile des processus + * Initialisation de la pile des processus. Cette pile est effacée + * par liberation_threads(). */ + if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 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; + } + } + + while((longueur_ecriture = write_atomic(s_etat_processus, + (*s_argument_thread).pipe_nombre_objets_attente[1], + &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + { + if (longueur_ecriture == -1) + { + break; + } + } + + BUG(1, uprintf("Process management error line %d\n", __LINE__)); + exit(EXIT_FAILURE); + } + + l_element_courant = (struct_liste_chainee *) + (*s_etat_processus).l_base_pile_processus; + while(l_element_courant != NULL) + { + s_argument_thread2 = (struct_descripteur_thread *) + (*l_element_courant).donnee; + + (*s_argument_thread2).nombre_references--; + + BUG((*s_argument_thread2).nombre_references < 0, + printf("(*s_argument_thread).nombre_references = %d\n", + (int) (*s_argument_thread2).nombre_references)); + + 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_interruptions[0]); + close((*s_argument_thread2) + .pipe_nombre_interruptions_attente[0]); + + pthread_mutex_destroy(&((*s_argument_thread2).mutex)); + + if ((*s_argument_thread2).processus_detache == d_faux) + { + if ((*s_argument_thread2).destruction_objet == d_vrai) + { + liberation(s_etat_processus, + (*s_argument_thread2).argument); + } + } + + free(s_argument_thread2); + } + + l_element_suivant = (*l_element_courant).suivant; + free((struct_liste_chainee *) l_element_courant); + l_element_courant = l_element_suivant; + } + (*s_etat_processus).l_base_pile_processus = NULL; - // Les données associées sont déjà effacées par liberation_thread(). + + if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 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; + } + } + + while((longueur_ecriture = write_atomic(s_etat_processus, + (*s_argument_thread).pipe_nombre_objets_attente[1], + &pid_final, sizeof(pid_final))) != sizeof(pid_final)) + { + if (longueur_ecriture == -1) + { + break; + } + } + + BUG(1, uprintf("Process management error line %d\n", __LINE__)); + exit(EXIT_FAILURE); + } /* * Initialisation de la pile système @@ -1707,6 +1831,7 @@ instruction_detach(struct_processus *s_e } } + BUG(1, uprintf("Process management error line %d\n", __LINE__)); exit(EXIT_FAILURE); } @@ -1758,6 +1883,7 @@ instruction_detach(struct_processus *s_e } } + BUG(1, uprintf("Process management error line %d\n", __LINE__)); exit(EXIT_FAILURE); } @@ -1835,6 +1961,7 @@ instruction_detach(struct_processus *s_e À noter : on ne ferme pas la connexion car la conséquence immédiate est une destruction de l'objet pour le processus père. ================================================================================ +*/ l_element_courant = (*s_etat_processus).s_connecteurs_sql; @@ -1842,11 +1969,10 @@ instruction_detach(struct_processus *s_e { l_element_suivant = (*l_element_courant).suivant; - sqlclose((*l_element_courant).donnee); +// sqlclose((*l_element_courant).donnee); liberation(s_etat_processus, (*l_element_courant).donnee); l_element_courant = l_element_suivant; } -*/ (*s_etat_processus).s_connecteurs_sql = NULL; @@ -1864,6 +1990,22 @@ instruction_detach(struct_processus *s_e sigpending(&set); + if ((*s_etat_processus).debug == d_vrai) + { + if (((*s_etat_processus).type_debug & d_debug_processus) + != 0) + { + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Évaluation de l'objet détaché\n", getpid()); + } + else + { + printf("[%d] Évaluation of detached object\n", getpid()); + } + } + } + if ((*s_etat_processus).erreur_systeme == d_es) { if (variable_partagee == d_faux) @@ -2639,6 +2781,8 @@ instruction_detach(struct_processus *s_e liberation(s_etat_processus, s_objet); # ifndef Cygwin + (*s_etat_processus).pile_signal.ss_flags = SS_DISABLE; + sigaltstack(&((*s_etat_processus).pile_signal), NULL); free((*s_etat_processus).pile_signal.ss_sp); # endif