--- rpl/src/interruptions.c 2010/05/06 15:02:43 1.14 +++ rpl/src/interruptions.c 2017/08/02 14:41:36 1.193 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.15 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.27 + Copyright (C) 1989-2017 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -52,11 +52,154 @@ typedef struct liste_chainee_volatile volatile void *donnee; } struct_liste_chainee_volatile; - static volatile struct_liste_chainee_volatile *liste_threads = NULL; static volatile struct_liste_chainee_volatile *liste_threads_surveillance = NULL; +static volatile int code_erreur_gsl = 0; + +unsigned char *racine_segment; + +static void * +thread_surveillance_signaux(void *argument) +{ + // Cette fonction est lancée dans un thread créé par processus pour + // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du + // signal SIGUSR2. Les processus externes n'envoient plus un signal au + // processus ou au thread à signaler mais positionnent les informations + // nécessaires dans la queue des signaux et incrémentent le sémaphore. + // Le sémaphore est décrémenté lorsque le signal est effectivement traité. + + int ios; + int nombre_signaux_envoyes; + + struct_processus *s_etat_processus; + + struct timespec attente; + + 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(;;) + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + if (sem_wait(semaphore_signalisation) == 0) + { + while((ios = sem_wait(semaphore_arret_signalisation)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } + + if ((*s_queue_signaux).requete_arret == d_vrai) + { + sem_post(semaphore_arret_signalisation); + sem_post(semaphore_signalisation); + + break; + } + + sem_post(semaphore_signalisation); + + nombre_signaux_envoyes = 0; + + // Dans un premier temps, on verrouille la queue des signaux + // affectée au processus courant pour vérifier s'il y a quelque + // chose à traiter. + + while((ios = sem_wait(semaphore_queue_signaux)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } + + if ((*s_queue_signaux).pointeur_lecture != + (*s_queue_signaux).pointeur_ecriture) + { + // Attention : raise() envoit le signal au thread appelant ! + // kill() l'envoie au processus appelant, donc dans notre + // cas à un thread aléatoire du processus, ce qui nous + // convient tout à fait puisqu'il s'agit de débloquer les + // appels système lents. + + nombre_signaux_envoyes++; + kill(getpid(), SIGUSR2); + sched_yield(); + } + + sem_post(semaphore_queue_signaux); + sem_post(semaphore_arret_signalisation); + + // 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) + { + 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) + { + nombre_signaux_envoyes++; + pthread_kill((*((struct_thread *) + (*l_element_courant).donnee)).tid, SIGUSR2); + sched_yield(); + } + + pthread_mutex_unlock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); + } + + l_element_courant = (*l_element_courant).suivant; + } + + pthread_mutex_unlock(&mutex_liste_threads); + + // Nanosleep + + if (nombre_signaux_envoyes > 0) + { + nanosleep(&attente, NULL); + } + } + else + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } + } + + pthread_exit(NULL); +} void modification_pid_thread_pere(struct_processus *s_etat_processus) @@ -74,29 +217,17 @@ modification_pid_thread_pere(struct_proc void insertion_thread(struct_processus *s_etat_processus, logical1 thread_principal) { - sigset_t oldset; - sigset_t set; - volatile struct_liste_chainee_volatile *l_nouvel_objet; - 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; } if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } @@ -108,41 +239,21 @@ 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 (pthread_mutex_lock(&mutex_liste_threads) != 0) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*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 + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - (*s_etat_processus).erreur_systeme = d_es_processus; return; } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } @@ -150,89 +261,49 @@ void insertion_thread_surveillance(struct_processus *s_etat_processus, struct_descripteur_thread *s_argument_thread) { - sigset_t oldset; - sigset_t set; - volatile struct_liste_chainee_volatile *l_nouvel_objet; - 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 (pthread_mutex_lock(&mutex_liste_threads) != 0) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } + pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)); + (*s_argument_thread).nombre_references++; + pthread_mutex_unlock(&((*s_argument_thread).mutex_nombre_references)); + (*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 + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - (*s_etat_processus).erreur_systeme = d_es_processus; return; } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } void retrait_thread(struct_processus *s_etat_processus) { - sigset_t oldset; - sigset_t set; - volatile struct_liste_chainee_volatile *l_element_precedent; volatile struct_liste_chainee_volatile *l_element_courant; - 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 (pthread_mutex_lock(&mutex_liste_threads) != 0) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } l_element_precedent = NULL; @@ -253,14 +324,7 @@ 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); - + pthread_mutex_unlock(&mutex_liste_threads); (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -274,38 +338,38 @@ retrait_thread(struct_processus *s_etat_ (*l_element_precedent).suivant = (*l_element_courant).suivant; } - if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0) + if (pthread_mutex_unlock(&mutex_liste_threads) != 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 + // Le thread ne peut plus traiter de signaux explicites. Il convient + // alors de corriger le sémaphore pour annuler les signaux en attente. + + while((*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_ecriture != (*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture) { - (*s_etat_processus).erreur_systeme = d_es_processus; + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - return; + (*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture = ((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .pointeur_signal_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; } free((void *) (*l_element_courant).donnee); free((struct_liste_chainee_volatile *) l_element_courant); - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } @@ -313,29 +377,13 @@ void retrait_thread_surveillance(struct_processus *s_etat_processus, struct_descripteur_thread *s_argument_thread) { - sigset_t set; - sigset_t oldset; - volatile struct_liste_chainee_volatile *l_element_precedent; volatile struct_liste_chainee_volatile *l_element_courant; - 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 (pthread_mutex_lock(&mutex_liste_threads) != 0) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } l_element_precedent = NULL; @@ -354,19 +402,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); - + pthread_mutex_unlock(&mutex_liste_threads); (*s_etat_processus).erreur_systeme = d_es_processus; 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; @@ -376,16 +416,10 @@ retrait_thread_surveillance(struct_proce (*l_element_precedent).suivant = (*l_element_courant).suivant; } - if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) + if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)) + != 0) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - + pthread_mutex_unlock(&mutex_liste_threads); (*s_etat_processus).erreur_systeme = d_es_processus; return; } @@ -398,57 +432,36 @@ retrait_thread_surveillance(struct_proce if ((*s_argument_thread).nombre_references == 0) { - if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - + pthread_mutex_unlock(&mutex_liste_threads); (*s_etat_processus).erreur_systeme = d_es_processus; return; } pthread_mutex_destroy(&((*s_argument_thread).mutex)); + pthread_mutex_destroy(&((*s_argument_thread).mutex_nombre_references)); free(s_argument_thread); } else { - if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - + pthread_mutex_unlock(&mutex_liste_threads); (*s_etat_processus).erreur_systeme = d_es_processus; return; } } -# ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_liste_threads) != 0) -# else - if (sem_post(semaphore_liste_threads) != 0) -# endif + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - (*s_etat_processus).erreur_systeme = d_es_processus; return; } free((struct_liste_chainee_volatile *) l_element_courant); - - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } @@ -457,17 +470,10 @@ 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 (pthread_mutex_lock(&mutex_liste_threads) != 0) { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } l_element_courant = liste_threads; @@ -479,18 +485,15 @@ verrouillage_threads_concurrents(struct_ (*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) + 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) + while(sem_wait((*(*((struct_thread *) (*l_element_courant) + .donnee)).s_etat_processus).semaphore_fork) == -1) # endif { - if (errno != EINTR) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } } @@ -514,28 +517,20 @@ deverrouillage_threads_concurrents(struc (*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) + 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) + 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) + if (pthread_mutex_unlock(&mutex_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; @@ -545,11 +540,7 @@ 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 + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -563,14 +554,17 @@ liberation_threads(struct_processus *s_e { logical1 suppression_variables_partagees; - sigset_t oldset; - sigset_t set; - struct_descripteur_thread *s_argument_thread; 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; @@ -579,21 +573,10 @@ liberation_threads(struct_processus *s_e volatile struct_liste_chainee_volatile *l_element_courant; volatile struct_liste_chainee_volatile *l_element_suivant; - 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 (pthread_mutex_lock(&mutex_liste_threads) == -1) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } l_element_courant = liste_threads; @@ -624,8 +607,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); @@ -670,18 +652,74 @@ liberation_threads(struct_processus *s_e .l_base_pile_processus; while(element_courant != NULL) { - pthread_mutex_trylock(&((*(*((struct_liste_chainee *) - element_courant)).donnee).mutex)); - pthread_mutex_unlock(&((*(*((struct_liste_chainee *) - element_courant)).donnee).mutex)); - liberation(s_etat_processus, - (*((struct_liste_chainee *) element_courant)).donnee); + s_argument_thread = (struct_descripteur_thread *) + (*((struct_liste_chainee *) element_courant)).donnee; + + if (pthread_mutex_lock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + pthread_mutex_unlock(&mutex_liste_threads); + return; + } + + (*s_argument_thread).nombre_references--; + + BUG((*s_argument_thread).nombre_references < 0, + printf("(*s_argument_thread).nombre_references = %d\n", + (int) (*s_argument_thread).nombre_references)); + + if ((*s_argument_thread).nombre_references == 0) + { + close((*s_argument_thread).pipe_objets[0]); + 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_elements_attente[0]); + close((*s_argument_thread).pipe_interruptions[0]); + + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + pthread_mutex_unlock(&mutex_liste_threads); + return; + } + + pthread_mutex_destroy(&((*s_argument_thread).mutex)); + pthread_mutex_destroy(&((*s_argument_thread) + .mutex_nombre_references)); + + if ((*s_argument_thread).processus_detache == d_faux) + { + if ((*s_argument_thread).destruction_objet == d_vrai) + { + liberation(s_etat_processus, (*s_argument_thread) + .argument); + } + } + + free(s_argument_thread); + } + else + { + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + pthread_mutex_unlock(&mutex_liste_threads); + return; + } + } + element_suivant = (*((struct_liste_chainee *) element_courant)) .suivant; - free((struct_liste_chainee *) element_courant); + free(element_courant); element_courant = element_suivant; } + (*s_etat_processus).l_base_pile_processus = NULL; + pthread_mutex_trylock(&((*(*s_etat_processus).indep).mutex)); pthread_mutex_unlock(&((*(*s_etat_processus).indep).mutex)); liberation(s_etat_processus, (*s_etat_processus).indep); @@ -738,72 +776,41 @@ liberation_threads(struct_processus *s_e } } - for(i = 0; i < (*s_etat_processus).nombre_variables; i++) - { - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables[i].objet).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables[i].objet).mutex)); - - // Les variables de niveau 0 sont des définitions qui - // ne sont pas copiées entre threads. - if ((*s_etat_processus).s_liste_variables[i].niveau > 0) - { - liberation(s_etat_processus, - (*s_etat_processus).s_liste_variables[i].objet); - } - - free((*s_etat_processus).s_liste_variables[i].nom); - } - - free((*s_etat_processus).s_liste_variables); - - for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) - { - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables_statiques[i].objet).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_statiques[i].objet).mutex)); - - liberation(s_etat_processus, (*s_etat_processus) - .s_liste_variables_statiques[i].objet); - free((*s_etat_processus).s_liste_variables_statiques[i].nom); - } - - free((*s_etat_processus).s_liste_variables_statiques); - // 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)); + (*(*s_etat_processus).s_arbre_variables_partagees) = NULL; - 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; } - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); + (*(*s_etat_processus).l_liste_variables_partagees) = NULL; + } + + liberation_arbre_variables(s_etat_processus, + (*s_etat_processus).s_arbre_variables, d_faux); + + 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; @@ -1247,6 +1254,8 @@ liberation_threads(struct_processus *s_e } */ + (*s_etat_processus).s_connecteurs_sql = NULL; + element_courant = (*s_etat_processus).s_marques; while(element_courant != NULL) { @@ -1261,14 +1270,16 @@ 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)); + 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); + sem_post((*s_etat_processus).semaphore_fork); + sem_close((*s_etat_processus).semaphore_fork); # endif - free(s_etat_processus); + liberation_contexte_cas(s_etat_processus); + liberation_allocateur_buffer(s_etat_processus); + sys_free(s_etat_processus); s_etat_processus = candidat; } @@ -1290,18 +1301,11 @@ liberation_threads(struct_processus *s_e s_argument_thread = (struct_descripteur_thread *) (*l_element_courant).donnee; - close((*s_argument_thread).pipe_objets[0]); - 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_interruptions[0]); - close((*s_argument_thread).pipe_nombre_interruptions_attente[0]); - - if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) + if (pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)) + != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - sem_post(&semaphore_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads); return; } @@ -1313,22 +1317,42 @@ liberation_threads(struct_processus *s_e if ((*s_argument_thread).nombre_references == 0) { - if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) + close((*s_argument_thread).pipe_objets[0]); + 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_elements_attente[0]); + close((*s_argument_thread).pipe_interruptions[0]); + + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - sem_post(&semaphore_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads); return; } pthread_mutex_destroy(&((*s_argument_thread).mutex)); + pthread_mutex_destroy(&((*s_argument_thread) + .mutex_nombre_references)); + + if ((*s_argument_thread).processus_detache == d_faux) + { + if ((*s_argument_thread).destruction_objet == d_vrai) + { + liberation(s_etat_processus, (*s_argument_thread).argument); + } + } + free(s_argument_thread); } else { - if (pthread_mutex_unlock(&((*s_argument_thread).mutex)) != 0) + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; - sem_post(&semaphore_liste_threads); + pthread_mutex_unlock(&mutex_liste_threads); return; } } @@ -1340,19 +1364,12 @@ 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 + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); (*s_etat_processus).erreur_systeme = d_es_processus; return; } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } @@ -1363,6 +1380,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) @@ -1383,17 +1405,23 @@ 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); } -static logical1 -recherche_thread_principal(pid_t pid, pthread_t *thread) +static struct_processus * +recherche_thread_principal(pid_t pid) { volatile struct_liste_chainee_volatile *l_element_courant; @@ -1417,12 +1445,11 @@ recherche_thread_principal(pid_t pid, pt * Le processus n'existe plus. On ne distribue aucun signal. */ - return(d_faux); + return(NULL); } - (*thread) = (*((struct_thread *) (*l_element_courant).donnee)).tid; - - return(d_vrai); + return((*((struct_thread *) (*l_element_courant).donnee)) + .s_etat_processus); } @@ -1439,394 +1466,513 @@ 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 -verrouillage_gestionnaire_signaux() +verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { - int semaphore; - - sigset_t oldset; - sigset_t set; - - sem_t *sem; - - if ((sem = pthread_getspecific(semaphore_fork_processus_courant)) - != NULL) +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) +# else + if (sem_post((*s_etat_processus).semaphore_fork) != 0) +# endif { - if (sem_post(sem) != 0) - { - BUG(1, uprintf("Lock error !\n")); - return; - } + BUG(1, uprintf("Lock error !\n")); + return; } - // Il faut respecteur l'atomicité des deux opérations suivantes ! - - sigfillset(&set); - pthread_sigmask(SIG_BLOCK, &set, &oldset); + return; +} +static inline void +deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) +{ # ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno != EINTR) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); BUG(1, uprintf("Unlock error !\n")); return; } } -# ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_gestionnaires_signaux) == -1) -# else - if (sem_post(semaphore_gestionnaires_signaux) == -1) -# endif + return; +} + +/* +================================================================================ + Fonctions de gestion des signaux dans les threads. + + Lorsqu'un processus reçoit un signal, il appelle le gestionnaire de signal + associé qui ne fait qu'envoyer au travers de write() le signal + reçus dans un pipe. Un second thread est bloqué sur ce pipe et + effectue le traitement adéquat pour le signal donné. +================================================================================ +*/ + +#define test_signal(signal) \ + if (signal_test == SIGTEST) { signal_test = signal; return; } + +static int pipe_signaux; + +logical1 +lancement_thread_signaux(struct_processus *s_etat_processus) +{ + pthread_attr_t attributs; + + if (pipe((*s_etat_processus).pipe_signaux) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Lock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } -# ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) -# else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) -# endif + pipe_signaux = (*s_etat_processus).pipe_signaux[1]; + + if (pthread_attr_init(&attributs) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Lock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } -# ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) -# else - if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) -# endif + if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - if (semaphore == 1) + if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs, + thread_signaux, s_etat_processus) != 0) { - // 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. + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } -# ifndef SEMAPHORES_NOMMES - while(sem_trywait(&semaphore_liste_threads) == -1) -# else - while(sem_trywait(semaphore_liste_threads) == -1) -# endif - { - if ((errno != EINTR) && (errno != EAGAIN)) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); + if (pthread_attr_destroy(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } - while(sem_wait(sem) == -1) - { - if (errno != EINTR) - { - BUG(1, uprintf("Lock error !\n")); - return; - } - } + return(d_absence_erreur); +} - BUG(1, uprintf("Lock error !\n")); - return; - } +logical1 +arret_thread_signaux(struct_processus *s_etat_processus) +{ + unsigned char signal; + ssize_t n; + + signal = (unsigned char ) (rpl_sigmax & 0xFF); - sched_yield(); + do + { + n = write_atomic(s_etat_processus, (*s_etat_processus).pipe_signaux[1], + &signal, sizeof(signal)); + + if (n < 0) + { + return(d_erreur); } - } + } while(n != 1); - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); + pthread_join((*s_etat_processus).thread_signaux, NULL); - return; + close((*s_etat_processus).pipe_signaux[1]); + return(d_absence_erreur); } -static inline void -deverrouillage_gestionnaire_signaux() +void * +thread_signaux(void *argument) { - int semaphore; + int *pipe; - sem_t *sem; + sigset_t masque; - sigset_t oldset; - sigset_t set; + struct pollfd fds; - // Il faut respecteur l'atomicité des deux opérations suivantes ! + struct_processus *s_etat_processus; - sigfillset(&set); - pthread_sigmask(SIG_BLOCK, &set, &oldset); + unsigned char signal; -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) -# endif + s_etat_processus = (struct_processus *) argument; + pipe = (*s_etat_processus).pipe_signaux; + fds.fd = pipe[0]; + fds.events = POLLIN; + + sigfillset(&masque); + pthread_sigmask(SIG_BLOCK, &masque, NULL); + + do { - if (errno != EINTR) + fds.revents = 0; + + while(poll(&fds, 1, -1) == -1) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; + if (errno != EINTR) + { + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); + } } - } -# 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; - } + if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1) + { + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); + } -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux) == -1) -# endif + if (signal != (0xFF & rpl_sigmax)) + { + envoi_signal_processus(getpid(), signal, d_faux); + // Un signal SIGUSR2 est envoyé par le thread de surveillance + // des signaux jusqu'à ce que les signaux soient tous traités. + } + } while(signal != (0xFF & rpl_sigmax)); + + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); +} + + +static inline void +_write(int fd, const void *buf, size_t count) +{ + ssize_t ios; + + while((ios = write(fd, buf, count)) == -1) { if (errno != EINTR) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; + break; } } -# ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) -# else - if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) -# endif + return; +} + + +// Récupération des signaux +// - SIGINT (arrêt au clavier) +// - SIGTERM (signal d'arrêt en provenance du système) + +void +interruption1(int signal) +{ + unsigned char signal_tronque; + + test_signal(signal); + + switch(signal) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; + case SIGINT: + signal_tronque = (unsigned char) (rpl_sigint & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + break; + + case SIGTERM: + signal_tronque = (unsigned char) (rpl_sigterm & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + break; + + case SIGUSR1: + signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + break; + + default: + // SIGUSR2 + break; } - if ((sem = pthread_getspecific(semaphore_fork_processus_courant)) - != NULL) + return; +} + +// Récupération des signaux +// - SIGFSTP +// +// ATTENTION : +// Le signal SIGFSTP provient de la mort du processus de contrôle. +// Sous certains systèmes (Linux...), la mort du terminal de contrôle +// se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres +// (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo +// non initialisée (pointeur NULL) issue de TERMIO. + +void +interruption2(int signal) +{ + unsigned char signal_tronque; + + test_signal(signal); + + signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + + return; +} + +void +interruption3(int signal) +{ + // Si on passe par ici, c'est qu'il est impossible de récupérer + // l'erreur d'accès à la mémoire. On sort donc du programme quitte à + // ce qu'il reste des processus orphelins. + + unsigned char message_1[] = "+++System : Uncaught access violation\n" + "+++System : Aborting !\n"; + unsigned char message_2[] = "+++System : Stack overflow\n" + "+++System : Aborting !\n"; + + test_signal(signal); + + if (pid_processus_pere == getpid()) { - while(sem_wait(sem) == -1) - { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; - } - } + kill(pid_processus_pere, SIGUSR1); } - 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); +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" - BUG(1, uprintf("Unlock error !\n")); - return; - } + if (signal != SIGUSR2) + { + write(STDERR_FILENO, message_1, strlen(message_1)); + } + else + { + write(STDERR_FILENO, message_2, strlen(message_2)); } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); +# pragma GCC diagnostic pop - return; + _exit(EXIT_FAILURE); } +// Récupération des signaux +// - SIGHUP + void -interruption1(int signal, siginfo_t *siginfo, void *context) +interruption4(int signal) { - pthread_t thread; + unsigned char signal_tronque; - struct_processus *s_etat_processus; + test_signal(signal); - volatile sig_atomic_t exclusion = 0; + signal_tronque = (unsigned char) (rpl_sighup & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + + return; +} - verrouillage_gestionnaire_signaux(); +// Récupération des signaux +// - SIGPIPE - switch(signal) +void +interruption5(int signal) +{ + unsigned char message[] = "+++System : SIGPIPE\n" + "+++System : Aborting !\n"; + unsigned char signal_tronque; + + test_signal(signal); + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + if (pid_processus_pere == getpid()) { - case SIGALRM : - { - if ((*siginfo).si_pid == getpid()) - { - if ((s_etat_processus = recherche_thread(getpid(), - pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) - { - printf("[%d] SIGALRM (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + write(STDERR_FILENO, message, strlen(message)); - if ((*s_etat_processus).pid_processus_pere != getpid()) - { - kill((*s_etat_processus).pid_processus_pere, signal); - } - else - { - (*s_etat_processus).var_volatile_alarme = -1; - (*s_etat_processus).var_volatile_requete_arret = -1; - } - } - else - { - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - pthread_kill(thread, signal); - } - } +# pragma GCC diagnostic pop - break; - } + return; +} + +inline static void +signal_alrm(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { + // Si pid est égal à getpid(), le signal à traiter est issu + // du même processus que celui qui va le traiter, mais d'un thread + // différent. - case SIGINT : + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - /* - * Une vieille spécification POSIX permet au pointeur siginfo - * d'être nul dans le cas d'un ^C envoyé depuis le clavier. - * Solaris suit en particulier cette spécification. - */ + printf("[%d] RPL/SIGALRM (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); + } - if (siginfo == NULL) - { - kill(getpid(), signal); - } - else if ((*siginfo).si_pid == getpid()) - { - if ((s_etat_processus = recherche_thread(getpid(), - pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + if ((*s_etat_processus).pid_processus_pere != getpid()) + { + // On n'est pas dans le processus père, on remonte le signal. + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigalrm, d_faux); + } + else + { + // On est dans le processus père, on effectue un arrêt d'urgence. + (*s_etat_processus).var_volatile_alarme = -1; + (*s_etat_processus).var_volatile_requete_arret = -1; + } + } + else + { + // Le signal est issu d'un processus différent. On recherche le + // thread principal pour remonter le signal. - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) - { - printf("[%d] SIGINT (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) + { + envoi_signal_contexte(s_thread_principal, rpl_sigalrm); + } + } - if ((*s_etat_processus).pid_processus_pere != getpid()) - { - kill((*s_etat_processus).pid_processus_pere, signal); - } - else - { - (*s_etat_processus).var_volatile_traitement_sigint = -1; + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} - while(exclusion == 1); - exclusion = 1; +inline static void +signal_term(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + pthread_mutex_t exclusion = PTHREAD_MUTEX_INITIALIZER; - if ((*s_etat_processus).var_volatile_requete_arret == -1) - { - deverrouillage_gestionnaire_signaux(); - exclusion = 0; - return; - } + verrouillage_gestionnaire_signaux(s_etat_processus); - if (strncmp(getenv("LANG"), "fr", 2) == 0) - { - printf("+++Interruption\n"); - } - else - { - printf("+++Interrupt\n"); - } + if (pid == getpid()) + { + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + { + printf("[%d] RPL/SIGTERM (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); + } - fflush(stdout); + if ((*s_etat_processus).pid_processus_pere != getpid()) + { + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigterm, d_faux); + } + else + { + (*s_etat_processus).var_volatile_traitement_sigint = -1; - (*s_etat_processus).var_volatile_requete_arret = -1; - (*s_etat_processus).var_volatile_alarme = -1; + pthread_mutex_lock(&exclusion); - exclusion = 0; - } - } - else + if ((*s_etat_processus).var_volatile_requete_arret == -1) { - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - pthread_kill(thread, signal); - } + deverrouillage_gestionnaire_signaux(s_etat_processus); + pthread_mutex_unlock(&exclusion); + return; } - break; - } + (*s_etat_processus).var_volatile_requete_arret = -1; + (*s_etat_processus).var_volatile_alarme = -1; - default : + pthread_mutex_unlock(&exclusion); + } + } + else + { + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - BUG(1, uprintf("[%d] Unknown signal %d in this context\n", - (int) getpid(), signal)); - break; + envoi_signal_contexte(s_thread_principal, rpl_sigterm); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption2(int signal, siginfo_t *siginfo, void *context) +inline static void +signal_int(struct_processus *s_etat_processus, pid_t pid) { - pthread_t thread; - struct_processus *s_etat_processus; + struct_processus *s_thread_principal; + volatile sig_atomic_t exclusion = 0; - verrouillage_gestionnaire_signaux(); + verrouillage_gestionnaire_signaux(s_etat_processus); - if (siginfo == NULL) + if (pid == getpid()) { - /* - * Le signal SIGFSTP provient de la mort du processus de contrôle. - * Sous certains systèmes (Linux...), la mort du terminal de contrôle - * se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres - * (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo - * non initialisée (pointeur NULL) issue de TERMIO. - */ + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + { + printf("[%d] RPL/SIGINT (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); + } - if (recherche_thread_principal(getpid(), &thread) == d_vrai) + if ((*s_etat_processus).pid_processus_pere != getpid()) { - pthread_kill(thread, SIGHUP); - deverrouillage_gestionnaire_signaux(); - return; + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigint, d_faux); + } + else + { + (*s_etat_processus).var_volatile_traitement_sigint = -1; + + while(exclusion == 1); + exclusion = 1; + + if ((*s_etat_processus).var_volatile_requete_arret == -1) + { + deverrouillage_gestionnaire_signaux(s_etat_processus); + exclusion = 0; + return; + } + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Interruption\n"); + } + else + { + printf("+++Interrupt\n"); + } + + fflush(stdout); + + (*s_etat_processus).var_volatile_requete_arret = -1; + (*s_etat_processus).var_volatile_alarme = -1; + + exclusion = 0; } } - else if ((*siginfo).si_pid == getpid()) + else { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - deverrouillage_gestionnaire_signaux(); - return; + envoi_signal_contexte(s_thread_principal, rpl_sigint); } + } + + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} +static inline void +signal_tstp(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { /* * 0 => fonctionnement normal * -1 => requête @@ -1835,14 +1981,15 @@ interruption2(int signal, siginfo_t *sig if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGTSTP (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGTSTP (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } if ((*s_etat_processus).var_volatile_processus_pere == 0) { - kill((*s_etat_processus).pid_processus_pere, signal); + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigtstp, d_faux); } else { @@ -1853,143 +2000,298 @@ interruption2(int signal, siginfo_t *sig { // Envoi d'un signal au thread maître du groupe. - if (recherche_thread_principal(getpid(), &thread) == d_vrai) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - pthread_kill(thread, SIGTSTP); - deverrouillage_gestionnaire_signaux(); - return; + envoi_signal_contexte(s_thread_principal, rpl_sigtstp); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} + +static void +sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3) +{ + switch((*((volatile int *) arg1))) + { + case 1: + longjmp(contexte_ecriture, -1); + break; + + case 2: + longjmp(contexte_impression, -1); + break; + } + return; } +#ifdef HAVE_SIGSEGV_RECOVERY void -interruption3(int signal, siginfo_t *siginfo, void *context) +interruption_depassement_pile(int urgence, stackoverflow_context_t scp) { - struct_processus *s_etat_processus; + if ((urgence == 0) && (routine_recursive != 0)) + { + // On peut tenter de récupérer le dépassement de pile. Si la variable + // 'routine_recursive' est non nulle, on récupère l'erreur. - static int compteur = 0; + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); + } - verrouillage_gestionnaire_signaux(); + // Ici, la panique est totale et il vaut mieux quitter l'application. + interruption3(SIGUSR2); + return; +} +#endif - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) +int +interruption_violation_access(void *adresse_fautive, int gravite) +{ + unsigned char message[] = "+++System : Trying to catch access " + "violation\n"; + + static int compteur_erreur = 0; + + if ((gravite == 0) && (routine_recursive != 0)) { - deverrouillage_gestionnaire_signaux(); - return; + // Il peut s'agir d'un dépassement de pile. + +# ifdef HAVE_SIGSEGV_RECOVERY + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); +# else + sortie_interruption_depassement_pile((void *) &routine_recursive, + NULL, NULL); +# endif } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + // On est dans une bonne vieille violation d'accès. On essaie + // de fermer au mieux l'application. + + compteur_erreur++; + + if (compteur_erreur >= 2) { - printf("[%d] SIGSEGV (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + // Erreurs multiples, on arrête l'application. + interruption3(SIGSEGV); + return(0); } - if ((*s_etat_processus).var_volatile_recursivite == -1) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + write(STDERR_FILENO, message, strlen(message)); + +# pragma GCC diagnostic pop + + if (pid_processus_pere == getpid()) { - // Segfault dans un appel de fonction récursive - deverrouillage_gestionnaire_signaux(); - longjmp(contexte, -1); + longjmp(contexte_initial, -1); + return(1); } else { - // Segfault dans une routine interne - if (strncmp(getenv("LANG"), "fr", 2) == 0) + longjmp(contexte_processus, -1); + return(1); + } + + // On renvoie 0 parce qu'on décline toute responsabilité quant à la + // suite des événements... + return(0); +} + +// Traitement de rpl_sigstart + +static inline void +signal_start(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { + (*s_etat_processus).demarrage_fils = d_vrai; + } + else + { + // Envoi d'un signal au thread maître du groupe. + + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - printf("+++Système : Violation d'accès (dépassement de pile)\n"); + envoi_signal_contexte(s_thread_principal, rpl_sigstart); } - else + } + + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} + +// Traitement de rpl_sigcont + +static inline void +signal_cont(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { + (*s_etat_processus).redemarrage_processus = d_vrai; + } + else + { + // Envoi d'un signal au thread maître du groupe. + + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - printf("+++System : Access violation (stack overflow)\n"); + envoi_signal_contexte(s_thread_principal, rpl_sigcont); } + } - fflush(stdout); + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} + +// Traitement de rpl_sigstop + +static inline void +signal_stop(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if (pid == getpid()) + { + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + { + printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); + } - compteur++; + /* + * 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 (compteur > 1) + if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0) { - deverrouillage_gestionnaire_signaux(); - exit(EXIT_FAILURE); + (*s_etat_processus).var_volatile_requete_arret = -1; } else { - deverrouillage_gestionnaire_signaux(); - longjmp(contexte_initial, -1); + (*s_etat_processus).var_volatile_traitement_retarde_stop = -1; + } + } + else + { + // Envoi d'un signal au thread maître du groupe. + + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) + { + envoi_signal_contexte(s_thread_principal, rpl_sigstop); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption4(int signal, siginfo_t *siginfo, void *context) -{ - struct_processus *s_etat_processus; +// Traitement de rpl_siginject - verrouillage_gestionnaire_signaux(); +static inline void +signal_inject(struct_processus *s_etat_processus, pid_t pid) +{ + verrouillage_gestionnaire_signaux(s_etat_processus); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } - /* - * Démarrage d'un processus fils ou gestion de SIGCONT (SUSPEND) - */ - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGSTART/SIGCONT (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGINJECT (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption5(int signal, siginfo_t *siginfo, void *context) + +static inline void +signal_urg(struct_processus *s_etat_processus, pid_t pid) { - pthread_t thread; - struct_processus *s_etat_processus; + struct_processus *s_thread_principal; - verrouillage_gestionnaire_signaux(); + verrouillage_gestionnaire_signaux(s_etat_processus); - if ((*siginfo).si_pid == getpid()) + if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - deverrouillage_gestionnaire_signaux(); - return; + printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); } - if (signal == SIGFABORT) - { - (*s_etat_processus).arret_depuis_abort = -1; - } + (*s_etat_processus).var_volatile_alarme = -1; + (*s_etat_processus).var_volatile_requete_arret = -1; + } + else + { + // Envoi d'un signal au thread maître du groupe. - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - 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); - } + envoi_signal_contexte(s_thread_principal, rpl_sigurg); } + } + + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} + +// Traitement de rpl_sigabort + +static inline void +signal_abort(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(s_etat_processus); + + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) + { + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; + } + + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + { + printf("[%d] RPL/SIGABORT (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); + } + + if (pid == getpid()) + { + (*s_etat_processus).arret_depuis_abort = -1; /* * var_globale_traitement_retarde_stop : @@ -2009,208 +2311,1360 @@ 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; - } + (*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) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - pthread_kill(thread, signal); - deverrouillage_gestionnaire_signaux(); - return; + envoi_signal_contexte(s_thread_principal, rpl_sigabort); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption6(int signal, siginfo_t *siginfo, void *context) + +static inline void +signal_hup(struct_processus *s_etat_processus, pid_t pid) { - struct_processus *s_etat_processus; + file *fichier; + + unsigned char nom[8 + 64 + 1]; - verrouillage_gestionnaire_signaux(); + verrouillage_gestionnaire_signaux(s_etat_processus); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } + snprintf(nom, 8 + 64 + 1, "rpl-out-%llu-%llu", + (unsigned long long) getpid(), + (unsigned long long) pthread_self()); + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + if ((fichier = fopen(nom, "w+")) != NULL) + { + fclose(fichier); + + freopen(nom, "w", stdout); + freopen(nom, "w", stderr); + } + + freopen("/dev/null", "r", stdin); + +# pragma GCC diagnostic pop + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGINJECT/SIGQUIT (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } void -interruption7(int signal, siginfo_t *siginfo, void *context) +traitement_exceptions_gsl(const char *reason, const char *file, + int line, int gsl_errno) { - struct_processus *s_etat_processus; + code_erreur_gsl = gsl_errno; + envoi_signal_processus(getpid(), rpl_sigexcept, d_faux); + return; +} - verrouillage_gestionnaire_signaux(); +static inline void +signal_except(struct_processus *s_etat_processus, pid_t pid) +{ + verrouillage_gestionnaire_signaux(s_etat_processus); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + (*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl; + deverrouillage_gestionnaire_signaux(s_etat_processus); + + return; +} + +static inline void +envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal, + pid_t pid_source) +{ + switch(signal) { - printf("[%d] SIGPIPE (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + case rpl_signull: + break; + + case rpl_sigint: + signal_int(s_etat_processus, pid_source); + break; + + case rpl_sigterm: + signal_term(s_etat_processus, pid_source); + break; + + case rpl_sigstart: + signal_start(s_etat_processus, pid_source); + break; + + case rpl_sigcont: + signal_cont(s_etat_processus, pid_source); + break; + + case rpl_sigstop: + signal_stop(s_etat_processus, pid_source); + break; - (*s_etat_processus).var_volatile_requete_arret = -1; - deverrouillage_gestionnaire_signaux(); + case rpl_sigabort: + signal_abort(s_etat_processus, pid_source); + break; + + case rpl_sigurg: + signal_urg(s_etat_processus, pid_source); + break; + + case rpl_siginject: + signal_inject(s_etat_processus, pid_source); + break; + + case rpl_sigalrm: + signal_alrm(s_etat_processus, pid_source); + break; + + case rpl_sighup: + signal_hup(s_etat_processus, pid_source); + break; + + case rpl_sigtstp: + signal_tstp(s_etat_processus, pid_source); + break; + + case rpl_sigexcept: + signal_except(s_etat_processus, pid_source); + break; + + default: + if ((*s_etat_processus).langue == 'F') + { + printf("+++System : Signal inconnu (%d) !\n", signal); + } + else + { + printf("+++System : Spurious signal (%d) !\n", signal); + } + + break; + } - BUG(1, printf("[%d] SIGPIPE\n", (int) getpid())); return; } void -interruption8(int signal, siginfo_t *siginfo, void *context) +scrutation_interruptions(struct_processus *s_etat_processus) { - pthread_t thread; - struct_processus *s_etat_processus; + // Interruptions qui arrivent sur le processus depuis un + // processus externe. - verrouillage_gestionnaire_signaux(); + // Les pointeurs de lecture pointent sur les prochains éléments + // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à + // écrire. - if ((*siginfo).si_pid == getpid()) + if (sem_trywait(semaphore_queue_signaux) == 0) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) + while((*s_queue_signaux).pointeur_lecture != + (*s_queue_signaux).pointeur_ecriture) { - deverrouillage_gestionnaire_signaux(); - return; + // Il y a un signal en attente dans le segment partagé. On le + // traite. + + envoi_interruptions(s_etat_processus, + (*s_queue_signaux).queue[(*s_queue_signaux) + .pointeur_lecture].signal, (*s_queue_signaux).queue + [(*s_queue_signaux).pointeur_lecture].pid); + (*s_queue_signaux).pointeur_lecture = + ((*s_queue_signaux).pointeur_lecture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) + { + sem_post(semaphore_queue_signaux); + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + sem_post(semaphore_queue_signaux); + } + + // Interruptions qui arrivent depuis le groupe courant de threads. + + if (pthread_mutex_trylock(&mutex_liste_threads) == 0) + { + if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) { - printf("[%d] SIGURG (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + while((*s_etat_processus).pointeur_signal_lecture != + (*s_etat_processus).pointeur_signal_ecriture) + { + // Il y a un signal dans la queue du thread courant. + // On le traite. + + envoi_interruptions(s_etat_processus, + (*s_etat_processus).signaux_en_queue + [(*s_etat_processus).pointeur_signal_lecture], + getpid()); + (*s_etat_processus).pointeur_signal_lecture = + ((*s_etat_processus).pointeur_signal_lecture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + } + + pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); } - (*s_etat_processus).var_volatile_alarme = -1; - (*s_etat_processus).var_volatile_requete_arret = -1; + pthread_mutex_unlock(&mutex_liste_threads); + } + + return; +} + + +/* +================================================================================ + Fonction renvoyant le nom du segment de mémoire partagée en fonction + du pid du processus. +================================================================================ + Entrée : Chemin absolue servant de racine, pid du processus +-------------------------------------------------------------------------------- + Sortie : NULL ou nom du segment +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ + +static unsigned char * +nom_segment(unsigned char *chemin, pid_t pid) +{ + unsigned char *fichier; + +# ifdef IPCS_SYSV // !POSIX +# ifndef OS2 // !OS2 + + if ((fichier = sys_malloc((strlen(chemin) + 1 + 256 + 1) * + sizeof(unsigned char))) == NULL) + { + return(NULL); + } + + sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); +# else // OS2 + if ((fichier = sys_malloc((10 + 256 + 1) * sizeof(unsigned char))) + == NULL) + { + return(NULL); + } + + sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid); +# endif // OS2 +# else // POSIX + + if ((fichier = sys_malloc((1 + 256 + 1) * + sizeof(unsigned char))) == NULL) + { + return(NULL); + } + + sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid); +# endif + + return(fichier); +} + + +/* +================================================================================ + Fonctions d'envoi d'un signal à un thread ou à un processus. +================================================================================ + Entrée : processus et signal +-------------------------------------------------------------------------------- + Sortie : erreur +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ + +int +envoi_signal_processus(pid_t pid, enum signaux_rpl signal, + logical1 test_ouverture) +{ +# ifndef OS2 + int segment; +# endif + +# ifndef IPCS_SYSV + sem_t *semaphore; + sem_t *signalisation; +# else + sem_t *semaphore; + sem_t *signalisation; +# ifndef OS2 + int desc; + key_t clef; +# endif +# endif + + struct_queue_signaux *queue; + + struct timespec attente; + + unsigned char *nom; + + // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en + // mémoire puis d'y inscrire le signal à traiter. + + if (pid == getpid()) + { + // Le signal est envoyé au même processus. + + if (s_queue_signaux == NULL) + { + return(1); + } + + while(sem_wait(semaphore_queue_signaux) != 0) + { + if (errno != EINTR) + { + return(1); + } + } + + (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] + .pid = pid; + (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] + .signal = signal; + + (*s_queue_signaux).pointeur_ecriture = + ((*s_queue_signaux).pointeur_ecriture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) + { + sem_post(semaphore_queue_signaux); + return(1); + } +# endif + + if (sem_post(semaphore_queue_signaux) != 0) + { + return(1); + } + + if (sem_post(semaphore_signalisation) != 0) + { + return(1); + } } else { - // Envoi d'un signal au thread maître du groupe. + // Le signal est envoyé depuis un processus distinct. + +# ifdef IPCS_SYSV + if ((nom = nom_segment(racine_segment, pid)) == NULL) + { + return(1); + } + +# ifndef OS2 // SysV + if (test_ouverture == d_vrai) + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((desc = open(nom, O_RDWR)) == -1) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if ((desc = open(nom, O_RDWR)) == -1) + { + sys_free(nom); + return(1); + } + } + + close(desc); + + if ((clef = ftok(nom, 1)) == -1) + { + sys_free(nom); + return(1); + } + + sys_free(nom); + + if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) + == -1) + { + return(1); + } + + queue = shmat(segment, NULL, 0); +# else // OS/2 + if (test_ouverture == d_vrai) + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while(DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if (DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + sys_free(nom); + return(1); + } + } + + sys_free(nom); +# endif +# else // POSIX + if ((nom = nom_segment(racine_segment, pid)) == NULL) + { + return(1); + } + + if (test_ouverture == d_vrai) + { + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + sys_free(nom); + return(1); + } + } + + sys_free(nom); + + if ((queue = mmap(NULL, sizeof(struct_queue_signaux), + PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) == + MAP_FAILED) + { + close(segment); + return(1); + } +# endif - if (recherche_thread_principal(getpid(), &thread) == d_vrai) + // À ce moment, le segment de mémoire partagée est projeté + // dans l'espace du processus. + + if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) { - pthread_kill(thread, SIGURG); - deverrouillage_gestionnaire_signaux(); - return; +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + return(1); + } + + if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) + == SEM_FAILED) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(semaphore); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(semaphore); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); + return(1); + } + + while(sem_wait(semaphore) != 0) + { + if (errno != EINTR) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) + != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + sem_close(semaphore); + sem_close(signalisation); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + } + + (*queue).queue[(*queue).pointeur_ecriture].pid = getpid(); + (*queue).queue[(*queue).pointeur_ecriture].signal = signal; + + (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + + if (sem_post(semaphore) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + if (sem_close(semaphore) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(signalisation); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(signalisation); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(signalisation); + return(1); } + + if (sem_post(signalisation) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(signalisation); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + sem_close(signalisation); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(signalisation); + return(1); + } + + if (sem_close(signalisation) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + return(1); + } + +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif } - deverrouillage_gestionnaire_signaux(); - return; + return(0); } -void -interruption9(int signal, siginfo_t *siginfo, void *context) +int +envoi_signal_thread(pthread_t tid, enum signaux_rpl signal) { - struct_processus *s_etat_processus; + // Un signal est envoyé d'un thread à un autre thread du même processus. - verrouillage_gestionnaire_signaux(); + volatile struct_liste_chainee_volatile *l_element_courant; - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) + struct_processus *s_etat_processus; + + if (pthread_mutex_lock(&mutex_liste_threads) != 0) { - deverrouillage_gestionnaire_signaux(); - return; + return(1); } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + l_element_courant = liste_threads; + + while(l_element_courant != NULL) { - printf("[%d] SIGABORT/SIGPROF (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + if (((*((struct_thread *) (*l_element_courant).donnee)).pid + == getpid()) && (pthread_equal((*((struct_thread *) + (*l_element_courant).donnee)).tid, tid) != 0)) + { + break; + } + + l_element_courant = (*l_element_courant).suivant; } - pthread_kill((*s_etat_processus).tid_processus_pere, SIGFABORT); - deverrouillage_gestionnaire_signaux(); - return; + if (l_element_courant == NULL) + { + pthread_mutex_unlock(&mutex_liste_threads); + return(1); + } + + 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(&((*s_etat_processus).mutex_signaux)) != 0) + { + pthread_mutex_unlock(&mutex_liste_threads); + return(1); + } + + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + return(1); + } + + if (sem_post(semaphore_signalisation) != 0) + { + return(1); + } + + return(0); +} + +int +envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler, + enum signaux_rpl signal) +{ + 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(&((*s_etat_processus_a_signaler).mutex_signaux)); + + if (sem_post(semaphore_signalisation) != 0) + { + return(1); + } + + return(0); } + +/* +================================================================================ + Fonction créant un segment de mémoire partagée destiné à contenir + la queue des signaux. +================================================================================ + Entrée : structure de description du processus +-------------------------------------------------------------------------------- + Sortie : Néant +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ + void -interruption10(int signal, siginfo_t *siginfo, void *context) +creation_queue_signaux(struct_processus *s_etat_processus) { - file *fichier; + pthread_attr_t attributs; - struct_processus *s_etat_processus; + unsigned char *nom; - unsigned char nom[8 + 64 + 1]; + racine_segment = (*s_etat_processus).chemin_fichiers_temporaires; - verrouillage_gestionnaire_signaux(); +# ifndef IPCS_SYSV // POSIX + if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires, + getpid())) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) + if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL, + S_IRUSR | S_IWUSR)) == -1) + { + if (errno != EEXIST) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Le segment de mémoire %s préexiste !\n", + nom); + } + else + { + printf("+++Warning: %s memory segment preexists!\n", nom); + } + + if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR)) == -1) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + } + + if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + s_queue_signaux = mmap(NULL, sizeof(struct_queue_signaux), + PROT_READ | PROT_WRITE, MAP_SHARED, f_queue_signaux, 0); + + if (((void *) s_queue_signaux) == ((void *) -1)) + { + if (shm_unlink(nom) == -1) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + sys_free(nom); + + if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) + == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + 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; + } + + (*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), + MS_ASYNC | MS_INVALIDATE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# else // IPCS_SYSV +# ifndef OS2 + int segment; + int support; + + key_t clef; + + // Création d'un segment de données associé au PID du processus + // courant + + if ((nom = nom_segment((*s_etat_processus) + .chemin_fichiers_temporaires, getpid())) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((support = open(nom, O_RDWR | O_CREAT | O_EXCL, + S_IRUSR | S_IWUSR)) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + return; + } + + if ((clef = ftok(nom, 1)) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + close(support); + sys_free(nom); + + if ((segment = shmget(clef, sizeof(struct_queue_signaux), + IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + s_queue_signaux = shmat(segment, NULL, 0); + f_queue_signaux = segment; + + if (((void *) s_queue_signaux) == ((void *) -1)) + { + if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) + == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + 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; + } + + (*s_queue_signaux).pointeur_lecture = 0; + (*s_queue_signaux).pointeur_ecriture = 0; + (*s_queue_signaux).requete_arret = d_faux; +# else // OS/2 + if ((nom = nom_segment(NULL, getpid())) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (DosAllocSharedMem((PVOID) &s_queue_signaux, nom, + sizeof(struct_queue_signaux), + PAG_WRITE | PAG_READ | PAG_COMMIT) != 0) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + sys_free(nom); + + 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; +# endif +# endif + + (*s_queue_signaux).controle = getpid(); + + if (lancement_thread_signaux(s_etat_processus) == d_erreur) { - deverrouillage_gestionnaire_signaux(); + (*s_etat_processus).erreur_systeme = d_es_processus; return; } - snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(), - (unsigned long) pthread_self()); + // Lancement du thread de récupération des signaux. - if ((fichier = fopen(nom, "w+")) != NULL) + if (pthread_attr_init(&attributs) != 0) { - fclose(fichier); + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } - freopen(nom, "w", stdout); - freopen(nom, "w", stderr); + if (pthread_attr_setdetachstate(&attributs, + PTHREAD_CREATE_JOINABLE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } - freopen("/dev/null", "r", stdin); + if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs, + thread_surveillance_signaux, s_etat_processus) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + if (pthread_attr_destroy(&attributs) != 0) { - printf("[%d] SIGHUP (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } - deverrouillage_gestionnaire_signaux(); +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + return; } + +/* +================================================================================ + Fonction libérant le segment de mémoire partagée destiné à contenir + la queue des signaux. +================================================================================ + Entrée : structure de description du processus +-------------------------------------------------------------------------------- + Sortie : Néant +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ + void -traitement_exceptions_gsl(const char *reason, const char *file, - int line, int gsl_errno) +liberation_queue_signaux(struct_processus *s_etat_processus) { - struct_processus *s_etat_processus; +# ifdef IPCS_SYSV // SystemV +# ifndef OS2 + if (shmdt(s_queue_signaux) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } +# else // OS/2 +# endif +# else // POSIX + sem_close(semaphore_queue_signaux); + sem_close(semaphore_signalisation); + sem_close(semaphore_arret_signalisation); - verrouillage_gestionnaire_signaux(); + if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) + close(f_queue_signaux); +# endif + + return; +} + + +/* +================================================================================ + Fonction détruisant le segment de mémoire partagée destiné à contenir + la queue des signaux. +================================================================================ + Entrée : structure de description du processus +-------------------------------------------------------------------------------- + Sortie : Néant +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ + +void +destruction_queue_signaux(struct_processus *s_etat_processus) +{ +# ifndef OS2 + unsigned char *nom; +# endif + + // On dépile les interruptions pour arrêter les SIGUSR2 sur + // le processus courant. + + scrutation_interruptions(s_etat_processus); + + while(sem_wait(semaphore_arret_signalisation) != 0) { - deverrouillage_gestionnaire_signaux(); + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + + (*s_queue_signaux).requete_arret = d_vrai; + +# ifndef IPCS_SYSV + msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE); +# endif + + sem_post(semaphore_arret_signalisation); + + // Incrémenter le sémaphore pour être sûr de le débloquer. + + sem_post(semaphore_signalisation); + + if ((*s_queue_signaux).controle == getpid()) + { + pthread_join((*s_queue_signaux).thread_signaux, NULL); + } + else + { + (*s_etat_processus).erreur_systeme = d_es_processus; return; } - (*s_etat_processus).var_volatile_exception_gsl = gsl_errno; - deverrouillage_gestionnaire_signaux(); + arret_thread_signaux(s_etat_processus); + +# ifdef IPCS_SYSV // SystemV +# ifndef OS2 + // Il faut commencer par éliminer le sémaphore. + + if (semctl((*semaphore_queue_signaux).sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*semaphore_queue_signaux).path); + sys_free((*semaphore_queue_signaux).path); + + if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*semaphore_signalisation).path); + sys_free((*semaphore_signalisation).path); + + if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*semaphore_arret_signalisation).path); + sys_free((*semaphore_arret_signalisation).path); + + if (shmdt(s_queue_signaux) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (shmctl(f_queue_signaux, IPC_RMID, 0) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((nom = nom_segment((*s_etat_processus) + .chemin_fichiers_temporaires, getpid())) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + unlink(nom); + sys_free(nom); +# else + 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_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; + return; + } +# endif +# else // POSIX + sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); + sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION); + sem_destroy2(semaphore_arret_signalisation, getpid(), + SEM_ARRET_SIGNALISATION); + + if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((nom = nom_segment(NULL, getpid())) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + close(f_queue_signaux); + + if (shm_unlink(nom) != 0) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + sys_free(nom); +# endif + return; }