--- rpl/src/interruptions.c 2010/04/07 13:45:09 1.7 +++ rpl/src/interruptions.c 2010/05/07 09:17:52 1.15 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.0.14 + RPL/2 (R) version 4.0.15 Copyright (C) 1989-2010 Dr. BERTRAND Joël This file is part of RPL/2. @@ -82,22 +82,9 @@ insertion_thread(struct_processus *s_eta sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); - while(sem_wait(&semaphore_liste_threads) == -1) - { - 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) { - sem_post(&semaphore_liste_threads); pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -105,11 +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) { - sem_post(&semaphore_liste_threads); pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -124,9 +108,31 @@ 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 if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -152,7 +158,21 @@ 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 + while(sem_wait(semaphore_liste_threads) == -1) +# endif { if (errno != EINTR) { @@ -164,23 +184,16 @@ insertion_thread_surveillance(struct_pro } } - if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) - == NULL) - { - sem_post(&semaphore_liste_threads); - 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; liste_threads_surveillance = l_nouvel_objet; +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -206,7 +219,11 @@ retrait_thread(struct_processus *s_etat_ 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) { @@ -236,7 +253,11 @@ retrait_thread(struct_processus *s_etat_ if (l_element_courant == NULL) { +# ifndef SEMAPHORES_NOMMES sem_post(&semaphore_liste_threads); +# else + sem_post(semaphore_liste_threads); +# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -253,20 +274,25 @@ 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; +# ifndef SEMAPHORES_NOMMES sem_post(&semaphore_liste_threads); +# else + sem_post(semaphore_liste_threads); +# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); return; } +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -275,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; @@ -293,7 +322,11 @@ retrait_thread_surveillance(struct_proce 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) { @@ -321,7 +354,11 @@ retrait_thread_surveillance(struct_proce if (l_element_courant == NULL) { +# ifndef SEMAPHORES_NOMMES sem_post(&semaphore_liste_threads); +# else + sem_post(semaphore_liste_threads); +# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -329,6 +366,7 @@ retrait_thread_surveillance(struct_proce return; } + // l_element_courant->donnee n'est pas bonne lorsque ça part en vrille. if (l_element_precedent == NULL) { liste_threads_surveillance = (*l_element_courant).suivant; @@ -338,10 +376,13 @@ 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 + sem_post(&semaphore_liste_threads); +# else + sem_post(semaphore_liste_threads); +# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -359,6 +400,11 @@ retrait_thread_surveillance(struct_proce { if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&semaphore_liste_threads); +# else + sem_post(semaphore_liste_threads); +# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -373,6 +419,11 @@ retrait_thread_surveillance(struct_proce { if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) { +# ifndef SEMAPHORES_NOMMES + sem_post(&semaphore_liste_threads); +# else + sem_post(semaphore_liste_threads); +# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -381,7 +432,11 @@ retrait_thread_surveillance(struct_proce } } +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -390,6 +445,8 @@ retrait_thread_surveillance(struct_proce return; } + free((struct_liste_chainee_volatile *) l_element_courant); + pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); return; @@ -400,7 +457,11 @@ verrouillage_threads_concurrents(struct_ { volatile struct_liste_chainee_volatile *l_element_courant; +# ifndef SEMAPHORES_NOMMES while(sem_wait(&semaphore_liste_threads) == -1) +# else + while(sem_wait(semaphore_liste_threads) == -1) +# endif { if (errno != EINTR) { @@ -417,8 +478,13 @@ verrouillage_threads_concurrents(struct_ == getpid()) && (pthread_equal((*((struct_thread *) (*l_element_courant).donnee)).tid, pthread_self()) == 0)) { +# ifndef SEMAPHORES_NOMMES while(sem_wait(&((*(*((struct_thread *) (*l_element_courant) .donnee)).s_etat_processus).semaphore_fork)) == -1) +# else + while(sem_wait((*(*((struct_thread *) (*l_element_courant) + .donnee)).s_etat_processus).semaphore_fork) == -1) +# endif { if (errno != EINTR) { @@ -447,15 +513,29 @@ deverrouillage_threads_concurrents(struc == getpid()) && (pthread_equal((*((struct_thread *) (*l_element_courant).donnee)).tid, pthread_self()) == 0)) { +# ifndef SEMAPHORES_NOMMES if (sem_post(&((*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) .semaphore_fork)) != 0) +# else + if (sem_post((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .semaphore_fork) != 0) +# endif { +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } +# else + if (sem_post(semaphore_liste_threads) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -465,7 +545,11 @@ deverrouillage_threads_concurrents(struc l_element_courant = (*l_element_courant).suivant; } +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -498,7 +582,11 @@ liberation_threads(struct_processus *s_e 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) { @@ -539,6 +627,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); @@ -1066,6 +1156,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) { @@ -1149,6 +1245,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) @@ -1163,8 +1262,13 @@ liberation_threads(struct_processus *s_e liberation_allocateur(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_destroy2((*s_etat_processus).semaphore_fork, sem_fork); +# endif free(s_etat_processus); @@ -1199,6 +1303,7 @@ liberation_threads(struct_processus *s_e if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; + sem_post(&semaphore_liste_threads); return; } @@ -1213,6 +1318,7 @@ liberation_threads(struct_processus *s_e if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; + sem_post(&semaphore_liste_threads); return; } @@ -1224,6 +1330,7 @@ liberation_threads(struct_processus *s_e if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; + sem_post(&semaphore_liste_threads); return; } } @@ -1235,7 +1342,11 @@ liberation_threads(struct_processus *s_e liste_threads_surveillance = NULL; +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); (*s_etat_processus).erreur_systeme = d_es_processus; @@ -1358,7 +1469,11 @@ verrouillage_gestionnaire_signaux() sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); +# ifndef SEMAPHORES_NOMMES while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) +# else + while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) +# endif { if (errno != EINTR) { @@ -1368,21 +1483,33 @@ verrouillage_gestionnaire_signaux() } } +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_gestionnaires_signaux) == -1) +# else + if (sem_post(semaphore_gestionnaires_signaux) == -1) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); BUG(1, uprintf("Lock error !\n")); return; } +# ifndef SEMAPHORES_NOMMES if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) +# else + if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); BUG(1, uprintf("Lock error !\n")); return; } +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) +# else + if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); BUG(1, uprintf("Unlock error !\n")); @@ -1397,7 +1524,11 @@ verrouillage_gestionnaire_signaux() // par un thread concurrent. On essaye donc de le bloquer jusqu'à // ce que ce soit possible. +# ifndef SEMAPHORES_NOMMES while(sem_trywait(&semaphore_liste_threads) == -1) +# else + while(sem_trywait(semaphore_liste_threads) == -1) +# endif { if ((errno != EINTR) && (errno != EAGAIN)) { @@ -1441,7 +1572,11 @@ deverrouillage_gestionnaire_signaux() sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); +# ifndef SEMAPHORES_NOMMES while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) +# else + while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) +# endif { if (errno != EINTR) { @@ -1451,14 +1586,22 @@ deverrouillage_gestionnaire_signaux() } } +# ifndef SEMAPHORES_NOMMES if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) +# else + if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); BUG(1, uprintf("Unlock error !\n")); return; } +# ifndef SEMAPHORES_NOMMES while(sem_wait(&semaphore_gestionnaires_signaux) == -1) +# else + while(sem_wait(semaphore_gestionnaires_signaux) == -1) +# endif { if (errno != EINTR) { @@ -1468,7 +1611,11 @@ deverrouillage_gestionnaire_signaux() } } +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) +# else + if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); BUG(1, uprintf("Unlock error !\n")); @@ -1491,7 +1638,11 @@ deverrouillage_gestionnaire_signaux() if (semaphore == 1) { +# ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_liste_threads) != 0) +# else + if (sem_post(semaphore_liste_threads) != 0) +# endif { pthread_sigmask(SIG_SETMASK, &oldset, NULL); @@ -1821,11 +1972,25 @@ 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) { - printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + 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); + } } /* @@ -1846,11 +2011,23 @@ interruption5(int signal, siginfo_t *sig } else { + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) + == NULL) + { + deverrouillage_gestionnaire_signaux(); + 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) { - pthread_kill(thread, SIGFSTOP); + pthread_kill(thread, signal); deverrouillage_gestionnaire_signaux(); return; } @@ -1974,7 +2151,7 @@ interruption9(int signal, siginfo_t *sig fflush(stdout); } - pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP); + pthread_kill((*s_etat_processus).tid_processus_pere, SIGFABORT); deverrouillage_gestionnaire_signaux(); return; }