--- rpl/src/interruptions.c 2010/04/29 15:47:25 1.12 +++ rpl/src/interruptions.c 2010/05/22 21:45:50 1.17 @@ -82,30 +82,9 @@ insertion_thread(struct_processus *s_eta sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_liste_threads) == -1) -# else - while(sem_wait(semaphore_liste_threads) == -1) -# endif - { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } - } - if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) == NULL) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -113,15 +92,8 @@ insertion_thread(struct_processus *s_eta return; } - (*l_nouvel_objet).suivant = liste_threads; - if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -136,6 +108,24 @@ insertion_thread(struct_processus *s_eta (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus = s_etat_processus; +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&semaphore_liste_threads) == -1) +# else + while(sem_wait(semaphore_liste_threads) == -1) +# endif + { + if (errno != EINTR) + { + pthread_sigmask(SIG_SETMASK, &oldset, NULL); + sigpending(&set); + + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + + (*l_nouvel_objet).suivant = liste_threads; + liste_threads = l_nouvel_objet; # ifndef SEMAPHORES_NOMMES @@ -168,6 +158,16 @@ insertion_thread_surveillance(struct_pro sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); + if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) + == NULL) + { + pthread_sigmask(SIG_SETMASK, &oldset, NULL); + sigpending(&set); + + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + # ifndef SEMAPHORES_NOMMES while(sem_wait(&semaphore_liste_threads) == -1) # else @@ -184,21 +184,6 @@ insertion_thread_surveillance(struct_pro } } - if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) - == NULL) - { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - (*l_nouvel_objet).suivant = liste_threads_surveillance; (*l_nouvel_objet).donnee = (void *) s_argument_thread; @@ -289,9 +274,6 @@ retrait_thread(struct_processus *s_etat_ (*l_element_precedent).suivant = (*l_element_courant).suivant; } - free((void *) (*l_element_courant).donnee); - free((struct_liste_chainee_volatile *) l_element_courant); - if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -319,6 +301,9 @@ retrait_thread(struct_processus *s_etat_ return; } + free((void *) (*l_element_courant).donnee); + free((struct_liste_chainee_volatile *) l_element_courant); + pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); return; @@ -390,8 +375,6 @@ retrait_thread_surveillance(struct_proce (*l_element_precedent).suivant = (*l_element_courant).suivant; } - free((struct_liste_chainee_volatile *) l_element_courant); - if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) { # ifndef SEMAPHORES_NOMMES @@ -461,6 +444,8 @@ retrait_thread_surveillance(struct_proce return; } + free((struct_liste_chainee_volatile *) l_element_courant); + pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); return; @@ -641,6 +626,8 @@ liberation_threads(struct_processus *s_e close((*s_etat_processus).pipe_nombre_objets_attente); close((*s_etat_processus).pipe_nombre_interruptions_attente); + liberation(s_etat_processus, (*s_etat_processus).at_exit); + if ((*s_etat_processus).nom_fichier_impression != NULL) { free((*s_etat_processus).nom_fichier_impression); @@ -1168,6 +1155,12 @@ liberation_threads(struct_processus *s_e element_courant = element_suivant; } +/* +================================================================================ + À noter : on ne ferme pas la connexion car la conséquence immédiate est + une destruction de l'objet pour le processus père. +================================================================================ + element_courant = (*s_etat_processus).s_connecteurs_sql; while(element_courant != NULL) { @@ -1251,6 +1244,9 @@ liberation_threads(struct_processus *s_e element_courant = element_suivant; } +*/ + + (*s_etat_processus).s_connecteurs_sql = NULL; element_courant = (*s_etat_processus).s_marques; while(element_courant != NULL) @@ -1444,7 +1440,7 @@ recherche_thread_principal(pid_t pid, pt */ // Les routines suivantes sont uniquement appelées depuis les gestionnaires -// des signaux asynchrones. Elles de doivent pas bloquer dans le cas où +// des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où // les sémaphores sont déjà bloqués par un gestionnaire de signal. static inline void @@ -1975,25 +1971,11 @@ interruption5(int signal, siginfo_t *sig return; } - if (signal == SIGFABORT) - { - (*s_etat_processus).arret_depuis_abort = -1; - } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - if (signal == SIGFSTOP) - { - printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } - else - { - printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); } /* @@ -2021,11 +2003,6 @@ interruption5(int signal, siginfo_t *sig return; } - if (signal == SIGFABORT) - { - (*s_etat_processus).arret_depuis_abort = -1; - } - // Envoi d'un signal au thread maître du groupe. if (recherche_thread_principal(getpid(), &thread) == d_vrai) @@ -2154,8 +2131,8 @@ interruption9(int signal, siginfo_t *sig fflush(stdout); } - pthread_kill((*s_etat_processus).tid_processus_pere, SIGFABORT); deverrouillage_gestionnaire_signaux(); + interruption11(signal, siginfo, context); return; } @@ -2197,6 +2174,73 @@ interruption10(int signal, siginfo_t *si } deverrouillage_gestionnaire_signaux(); + return; +} + +void +interruption11(int signal, siginfo_t *siginfo, void *context) +{ + pthread_t thread; + struct_processus *s_etat_processus; + + verrouillage_gestionnaire_signaux(); + + if ((*siginfo).si_pid == getpid()) + { + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) + == NULL) + { + deverrouillage_gestionnaire_signaux(); + return; + } + + (*s_etat_processus).arret_depuis_abort = -1; + + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + { + printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); + } + + /* + * var_globale_traitement_retarde_stop : + * 0 -> traitement immédiat + * 1 -> traitement retardé (aucun signal reçu) + * -1 -> traitement retardé (un ou plusieurs signaux stop reçus) + */ + + if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0) + { + (*s_etat_processus).var_volatile_requete_arret = -1; + } + else + { + (*s_etat_processus).var_volatile_traitement_retarde_stop = -1; + } + } + else + { + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) + == NULL) + { + deverrouillage_gestionnaire_signaux(); + return; + } + + (*s_etat_processus).arret_depuis_abort = -1; + + // Envoi d'un signal au thread maître du groupe. + + if (recherche_thread_principal(getpid(), &thread) == d_vrai) + { + pthread_kill(thread, signal); + deverrouillage_gestionnaire_signaux(); + return; + } + } + + deverrouillage_gestionnaire_signaux(); return; }