--- rpl/src/interruptions.c 2012/10/14 21:37:11 1.106 +++ rpl/src/interruptions.c 2013/05/28 22:09:55 1.133 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.11 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.14 + Copyright (C) 1989-2013 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) { @@ -81,6 +78,11 @@ thread_surveillance_signaux(void *argume volatile struct_liste_chainee_volatile *l_element_courant; + sigset_t set; + + sigfillset(&set); + pthread_sigmask(SIG_BLOCK, &set, NULL); + s_etat_processus = (struct_processus *) argument; for(;;) @@ -91,17 +93,36 @@ thread_surveillance_signaux(void *argume # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) if (sem_wait(&(*s_queue_signaux).signalisation) == 0) # else - if(sem_wait(semaphore_signalisation) == 0) + if (sem_wait(semaphore_signalisation) == 0) # endif { +# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) + if (sem_wait(&(*s_queue_signaux).arret_signalisation) != 0) +# else + 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 @@ -140,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) @@ -148,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_interruptions)); + 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_interruptions)); } l_element_courant = (*l_element_courant).suivant; @@ -173,7 +207,10 @@ thread_surveillance_signaux(void *argume } else { - (*s_etat_processus).erreur_systeme = d_es_processus; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } } } @@ -332,10 +369,17 @@ retrait_thread(struct_processus *s_etat_ .pointeur_signal_lecture) { # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&((*s_queue_signaux).signalisation)); + while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) # else - sem_wait(semaphore_signalisation); + while(sem_wait(semaphore_signalisation) != 0) # endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } (*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) .pointeur_signal_lecture = ((*(*((struct_thread *) @@ -534,7 +578,13 @@ liberation_threads(struct_processus *s_e struct_processus *candidat; - unsigned long i; + struct_liste_variables_partagees *l_element_partage_courant; + struct_liste_variables_partagees *l_element_partage_suivant; + + struct_liste_variables_statiques *l_element_statique_courant; + struct_liste_variables_statiques *l_element_statique_suivant; + + integer8 i; void *element_candidat; void *element_courant; @@ -577,8 +627,7 @@ liberation_threads(struct_processus *s_e close((*s_etat_processus).pipe_injections); close((*s_etat_processus).pipe_nombre_injections); close((*s_etat_processus).pipe_interruptions); - close((*s_etat_processus).pipe_nombre_objets_attente); - close((*s_etat_processus).pipe_nombre_interruptions_attente); + close((*s_etat_processus).pipe_nombre_elements_attente); liberation(s_etat_processus, (*s_etat_processus).at_exit); @@ -646,10 +695,8 @@ liberation_threads(struct_processus *s_e close((*s_argument_thread).pipe_acquittement[1]); close((*s_argument_thread).pipe_injections[1]); close((*s_argument_thread).pipe_nombre_injections[1]); - close((*s_argument_thread).pipe_nombre_objets_attente[0]); + close((*s_argument_thread).pipe_nombre_elements_attente[0]); close((*s_argument_thread).pipe_interruptions[0]); - close((*s_argument_thread) - .pipe_nombre_interruptions_attente[0]); if (pthread_mutex_unlock(&((*s_argument_thread) .mutex_nombre_references)) != 0) @@ -749,41 +796,38 @@ liberation_threads(struct_processus *s_e } } - liberation_arbre_variables(s_etat_processus, - (*s_etat_processus).s_arbre_variables, d_faux); - - // Ne peut être effacé qu'une seule fois + // ne peut être effacé qu'une seule fois if (suppression_variables_partagees == d_faux) { suppression_variables_partagees = d_vrai; - for(i = 0; i < (*(*s_etat_processus) - .s_liste_variables_partagees).nombre_variables; i++) - { - pthread_mutex_trylock(&((*(*(*s_etat_processus) - .s_liste_variables_partagees).table[i].objet) - .mutex)); - pthread_mutex_unlock(&((*(*(*s_etat_processus) - .s_liste_variables_partagees).table[i].objet) - .mutex)); + liberation_arbre_variables_partagees(s_etat_processus, + (*(*s_etat_processus).s_arbre_variables_partagees)); - 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); - } + l_element_partage_courant = (*(*s_etat_processus) + .l_liste_variables_partagees); - if ((*(*s_etat_processus).s_liste_variables_partagees).table - != NULL) + while(l_element_partage_courant != NULL) { - free((struct_variable_partagee *) (*(*s_etat_processus) - .s_liste_variables_partagees).table); + l_element_partage_suivant = + (*l_element_partage_courant).suivant; + free(l_element_partage_courant); + l_element_partage_courant = l_element_partage_suivant; } + } + + liberation_arbre_variables(s_etat_processus, + (*s_etat_processus).s_arbre_variables, d_faux); - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); + 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; } element_courant = (*s_etat_processus).l_base_pile; @@ -1293,9 +1337,8 @@ liberation_threads(struct_processus *s_e close((*s_argument_thread).pipe_acquittement[1]); close((*s_argument_thread).pipe_injections[1]); close((*s_argument_thread).pipe_nombre_injections[1]); - close((*s_argument_thread).pipe_nombre_objets_attente[0]); + close((*s_argument_thread).pipe_nombre_elements_attente[0]); close((*s_argument_thread).pipe_interruptions[0]); - close((*s_argument_thread).pipe_nombre_interruptions_attente[0]); if (pthread_mutex_unlock(&((*s_argument_thread) .mutex_nombre_references)) != 0) @@ -1353,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) @@ -1373,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); } @@ -1500,6 +1554,7 @@ verrouillage_gestionnaire_signaux(struct return; } +/* if (semaphore == 1) { // Le semaphore ne peut être pris par le thread qui a appelé @@ -1519,6 +1574,7 @@ verrouillage_gestionnaire_signaux(struct return; } } + */ return; } @@ -1598,6 +1654,7 @@ deverrouillage_gestionnaire_signaux(stru } } + /* if (semaphore == 1) { if (pthread_mutex_unlock(&mutex_liste_threads) != 0) @@ -1606,6 +1663,7 @@ deverrouillage_gestionnaire_signaux(stru return; } } + */ return; } @@ -2391,8 +2449,9 @@ signal_hup(struct_processus *s_etat_proc return; } - snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(), - (unsigned long) pthread_self()); + snprintf(nom, 8 + 64 + 1, "rpl-out-%llu-%llu", + (unsigned long long) getpid(), + (unsigned long long) pthread_self()); if ((fichier = fopen(nom, "w+")) != NULL) { @@ -2501,11 +2560,11 @@ envoi_interruptions(struct_processus *s_ default: if ((*s_etat_processus).langue == 'F') { - printf("+++System : Spurious signal (%d) !\n", signal); + printf("+++System : Signal inconnu (%d) !\n", signal); } else { - printf("+++System : Signal inconnu (%d) !\n", signal); + printf("+++System : Spurious signal (%d) !\n", signal); } break; @@ -2545,10 +2604,17 @@ scrutation_interruptions(struct_processu % LONGUEUR_QUEUE_SIGNAUX; # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&((*s_queue_signaux).signalisation)); + while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) # else - sem_wait(semaphore_signalisation); + while(sem_wait(semaphore_signalisation) != 0) # endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) @@ -2560,7 +2626,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_interruptions)) == 0) { while((*s_etat_processus).pointeur_signal_lecture != (*s_etat_processus).pointeur_signal_ecriture) @@ -2576,13 +2642,20 @@ scrutation_interruptions(struct_processu % LONGUEUR_QUEUE_SIGNAUX; # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&((*s_queue_signaux).signalisation)); + while(sem_wait(&((*s_queue_signaux).signalisation)) != 0) # else - sem_wait(semaphore_signalisation); + while(sem_wait(semaphore_signalisation) != 0) # endif + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } - pthread_mutex_unlock(&mutex_interruptions); + pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)); } return; @@ -2944,22 +3017,22 @@ envoi_signal_thread(pthread_t tid, enum return(1); } - if (pthread_mutex_lock(&mutex_interruptions) != 0) + s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) + .s_etat_processus; + + if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0) { pthread_mutex_unlock(&mutex_liste_threads); return(1); } - s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) - .s_etat_processus; - (*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_interruptions)) != 0) { pthread_mutex_unlock(&mutex_liste_threads); return(1); @@ -2989,14 +3062,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_interruptions)); (*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_interruptions)); # if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) if (sem_post(&((*s_queue_signaux).signalisation)) != 0) @@ -3081,6 +3154,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) @@ -3089,16 +3163,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)) @@ -3164,6 +3246,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; @@ -3187,6 +3271,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; @@ -3265,11 +3351,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); @@ -3288,11 +3386,11 @@ liberation_queue_signaux(struct_processu # endif # else // POSIX # ifndef SEMAPHORES_NOMMES - sem_close(&((*s_queue_signaux).semaphore)); - sem_close(&((*s_queue_signaux).signalisation)); + // Rien à faire, les sémaphores sont anonymes. # 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) @@ -3328,11 +3426,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); @@ -3362,6 +3472,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; @@ -3390,6 +3510,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; @@ -3398,17 +3521,19 @@ destruction_queue_signaux(struct_process # endif # else // POSIX # ifndef SEMAPHORES_NOMMES - sem_close(&((*s_queue_signaux).semaphore)); sem_destroy(&((*s_queue_signaux).semaphore)); - - sem_close(&((*s_queue_signaux).signalisation)); 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)