--- rpl/src/interruptions.c 2013/05/21 13:30:56 1.126 +++ rpl/src/interruptions.c 2014/01/26 18:21:34 1.139 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.14 - Copyright (C) 1989-2013 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.17 + Copyright (C) 1989-2014 Dr. BERTRAND Joël This file is part of RPL/2. @@ -60,9 +60,6 @@ static volatile int code_erreur_g unsigned char *racine_segment; -static pthread_mutex_t mutex_interruptions - = PTHREAD_MUTEX_INITIALIZER; - static void * thread_surveillance_signaux(void *argument) { @@ -100,16 +97,35 @@ thread_surveillance_signaux(void *argume # endif { # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&(*s_queue_signaux).signalisation); + if (sem_wait(&(*s_queue_signaux).arret_signalisation) != 0) # else - sem_post(semaphore_signalisation); + if (sem_wait(semaphore_arret_signalisation) != 0) # endif + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } if ((*s_queue_signaux).requete_arret == d_vrai) { +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_post(&(*s_queue_signaux).arret_signalisation); + sem_post(&(*s_queue_signaux).signalisation); +# else + sem_post(semaphore_arret_signalisation); + sem_post(semaphore_signalisation); +# endif + break; } +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_post(&(*s_queue_signaux).arret_signalisation); + sem_post(&(*s_queue_signaux).signalisation); +# else + sem_post(semaphore_arret_signalisation); + sem_post(semaphore_signalisation); +# endif + nombre_signaux_envoyes = 0; sched_yield(); @@ -145,7 +161,11 @@ thread_surveillance_signaux(void *argume // Dans un second temps, on balaye toutes les queues de signaux // des threads du processus courant. + // Attention : l'ordre de verrouillage des mutexes est important + // pour éviter les conditions bloquantes ! + pthread_mutex_lock(&mutex_liste_threads); + l_element_courant = liste_threads; while(l_element_courant != NULL) @@ -153,15 +173,24 @@ thread_surveillance_signaux(void *argume if ((*((struct_thread *) (*l_element_courant).donnee)).pid == getpid()) { + pthread_mutex_lock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); + if ((*(*((struct_thread *) (*l_element_courant).donnee)) .s_etat_processus).pointeur_signal_ecriture != - (*(*((struct_thread *) (*l_element_courant).donnee)) - .s_etat_processus).pointeur_signal_lecture) + (*(*((struct_thread *) (*l_element_courant) + .donnee)).s_etat_processus) + .pointeur_signal_lecture) { nombre_signaux_envoyes++; - pthread_kill((*((struct_thread *) (*l_element_courant) - .donnee)).tid, SIGALRM); + pthread_kill((*((struct_thread *) + (*l_element_courant).donnee)).tid, SIGALRM); } + + pthread_mutex_unlock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); } l_element_courant = (*l_element_courant).suivant; @@ -1367,6 +1396,11 @@ recherche_thread(pid_t pid, pthread_t ti struct_processus *s_etat_processus; + if (pthread_mutex_lock(&mutex_liste_threads) != 0) + { + return(NULL); + } + l_element_courant = liste_threads; while(l_element_courant != NULL) @@ -1387,12 +1421,18 @@ recherche_thread(pid_t pid, pthread_t ti * Le processus n'existe plus. On ne distribue aucun signal. */ + pthread_mutex_unlock(&mutex_liste_threads); return(NULL); } s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus; + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + return(NULL); + } + return(s_etat_processus); } @@ -1448,8 +1488,6 @@ recherche_thread_principal(pid_t pid) static inline void verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { - int semaphore; - # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else @@ -1460,19 +1498,6 @@ verrouillage_gestionnaire_signaux(struct return; } - // Il faut respecteur l'atomicité des deux opérations suivantes ! - - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } - # ifndef SEMAPHORES_NOMMES if (sem_post(&semaphore_gestionnaires_signaux) == -1) # else @@ -1488,117 +1513,12 @@ verrouillage_gestionnaire_signaux(struct return; } -# ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) -# else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) -# endif - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Lock error !\n")); - return; - } - - if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } - - if (semaphore == 1) - { - // Le semaphore ne peut être pris par le thread qui a appelé - // le gestionnaire de signal car le signal est bloqué par ce thread - // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que - // par un thread concurrent. On essaye donc de le bloquer jusqu'à - // ce que ce soit possible. - - if (pthread_mutex_lock(&mutex_liste_threads) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Lock error !\n")); - return; - } - } - return; } static inline void deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { - int semaphore; - - // Il faut respecteur l'atomicité des deux opérations suivantes ! - - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } - -# ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) -# else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) -# endif - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - 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) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } - } - - if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } - # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else @@ -1612,15 +1532,6 @@ deverrouillage_gestionnaire_signaux(stru } } - if (semaphore == 1) - { - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) - { - BUG(1, uprintf("Unlock error !\n")); - return; - } - } - return; } @@ -2582,7 +2493,7 @@ scrutation_interruptions(struct_processu // Interruptions qui arrivent depuis le groupe courant de threads. - if (pthread_mutex_trylock(&mutex_interruptions) == 0) + if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) { while((*s_etat_processus).pointeur_signal_lecture != (*s_etat_processus).pointeur_signal_ecriture) @@ -2611,7 +2522,7 @@ scrutation_interruptions(struct_processu } } - pthread_mutex_unlock(&mutex_interruptions); + pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); } return; @@ -2948,12 +2859,6 @@ envoi_signal_thread(pthread_t tid, enum struct_processus *s_etat_processus; - if (pthread_mutex_lock(&mutex_interruptions) != 0) - { - pthread_mutex_unlock(&mutex_liste_threads); - return(1); - } - if (pthread_mutex_lock(&mutex_liste_threads) != 0) { return(1); @@ -2982,13 +2887,19 @@ envoi_signal_thread(pthread_t tid, enum s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) .s_etat_processus; + if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0) + { + pthread_mutex_unlock(&mutex_liste_threads); + return(1); + } + (*s_etat_processus).signaux_en_queue [(*s_etat_processus).pointeur_signal_ecriture] = signal; (*s_etat_processus).pointeur_signal_ecriture = ((*s_etat_processus).pointeur_signal_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; - if (pthread_mutex_unlock(&mutex_interruptions) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0) { pthread_mutex_unlock(&mutex_liste_threads); return(1); @@ -3018,14 +2929,14 @@ int envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler, enum signaux_rpl signal) { - pthread_mutex_lock(&mutex_interruptions); + pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_signaux)); (*s_etat_processus_a_signaler).signaux_en_queue [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] = signal; (*s_etat_processus_a_signaler).pointeur_signal_ecriture = ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; - pthread_mutex_unlock(&mutex_interruptions); + pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux)); # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) if (sem_post(&((*s_queue_signaux).signalisation)) != 0) @@ -3110,6 +3021,7 @@ creation_queue_signaux(struct_processus # ifndef SEMAPHORES_NOMMES sem_init(&((*s_queue_signaux).semaphore), 1, 1); sem_init(&((*s_queue_signaux).signalisation), 1, 0); + sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1); # else if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) == SEM_FAILED) @@ -3118,16 +3030,24 @@ creation_queue_signaux(struct_processus return; } - if ((semaphore_signalisation = sem_init2(1, getpid(), + if ((semaphore_signalisation = sem_init2(0, getpid(), SEM_SIGNALISATION)) == SEM_FAILED) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } + + if ((semaphore_arret_signalisation = sem_init2(1, getpid(), + SEM_ARRET_SIGNALISATION)) == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } # endif (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; + (*s_queue_signaux).requete_arret = d_faux; if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0)) @@ -3193,6 +3113,8 @@ creation_queue_signaux(struct_processus sem_init(&((*s_queue_signaux).semaphore), 1, 1); sem_init(&((*s_queue_signaux).signalisation), 1, 0); + sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1); + (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; (*s_queue_signaux).requete_arret = d_faux; @@ -3216,6 +3138,8 @@ creation_queue_signaux(struct_processus sem_init(&((*s_queue_signaux).semaphore), 1, 1); sem_init(&((*s_queue_signaux).signalisation), 1, 0); + sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1); + (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; (*s_queue_signaux).requete_arret = d_faux; @@ -3294,11 +3218,23 @@ creation_queue_signaux(struct_processus void liberation_queue_signaux(struct_processus *s_etat_processus) { - // Incrémenter le sémaphore pour être sûr de le débloquer. +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_wait(&((*s_queue_signaux).arret_signalisation)); +# else + sem_wait(semaphore_arret_signalisation); +# endif (*s_queue_signaux).requete_arret = d_vrai; # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_post(&((*s_queue_signaux).arret_signalisation)); +# else + sem_post(semaphore_arret_signalisation); +# endif + + // Incrémenter le sémaphore pour être sûr de le débloquer. + +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) sem_post(&((*s_queue_signaux).signalisation)); # else sem_post(semaphore_signalisation); @@ -3321,6 +3257,7 @@ liberation_queue_signaux(struct_processu # else sem_close(semaphore_queue_signaux); sem_close(semaphore_signalisation); + sem_close(semaphore_arret_signalisation); # endif if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) @@ -3356,11 +3293,23 @@ destruction_queue_signaux(struct_process unsigned char *nom; # endif - // Incrémenter le sémaphore pour être sûr de le débloquer. +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_wait(&((*s_queue_signaux).arret_signalisation)); +# else + sem_wait(semaphore_arret_signalisation); +# endif (*s_queue_signaux).requete_arret = d_vrai; # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + sem_post(&((*s_queue_signaux).arret_signalisation)); +# else + sem_post(semaphore_arret_signalisation); +# endif + + // Incrémenter le sémaphore pour être sûr de le débloquer. + +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) sem_post(&((*s_queue_signaux).signalisation)); # else sem_post(semaphore_signalisation); @@ -3390,6 +3339,16 @@ destruction_queue_signaux(struct_process unlink((*s_queue_signaux).signalisation.path); free((*s_queue_signaux).signalisation.path); + if (semctl((*s_queue_signaux).arret_signalisation.sem, 0, IPC_RMID) + == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*s_queue_signaux).arret_signalisation.path); + free((*s_queue_signaux).arret_signalisation.path); + if (shmdt(s_queue_signaux) == -1) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3418,6 +3377,9 @@ destruction_queue_signaux(struct_process sem_close(&((*s_queue_signaux).signalisation)); sem_destroy(&((*s_queue_signaux).signalisation)); + sem_close(&((*s_queue_signaux).arret_signalisation)); + sem_destroy(&((*s_queue_signaux).arret_signalisation)); + if (DosFreeMem(s_queue_signaux) != 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3428,12 +3390,17 @@ destruction_queue_signaux(struct_process # ifndef SEMAPHORES_NOMMES sem_destroy(&((*s_queue_signaux).semaphore)); sem_destroy(&((*s_queue_signaux).signalisation)); + sem_destroy(&((*s_queue_signaux).arret_signalisation)); # else sem_close(semaphore_queue_signaux); sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); sem_close(semaphore_signalisation); sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION); + + sem_close(semaphore_arret_signalisation); + sem_destroy2(semaphore_arret_signalisation, getpid(), + SEM_ARRET_SIGNALISATION); # endif if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0)