--- rpl/src/interruptions.c 2010/08/22 16:38:36 1.33 +++ rpl/src/interruptions.c 2011/09/20 15:45:53 1.80 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.18 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.3 + Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -57,6 +57,12 @@ static volatile struct_liste_chainee_vol = NULL; static volatile struct_liste_chainee_volatile *liste_threads_surveillance = NULL; +static volatile int code_erreur_gsl = 0; + +unsigned char *racine_segment; + +static pthread_mutex_t mutex_interruptions + = PTHREAD_MUTEX_INITIALIZER; void modification_pid_thread_pere(struct_processus *s_etat_processus) @@ -74,29 +80,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,40 +102,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; } @@ -149,93 +124,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)); + pthread_mutex_lock(&((*s_argument_thread).mutex_nombre_references)); (*s_argument_thread).nombre_references++; - pthread_mutex_unlock(&((*s_argument_thread).mutex)); + 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; @@ -256,14 +187,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; } @@ -277,38 +201,15 @@ 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 - { - (*s_etat_processus).erreur_systeme = d_es_processus; - - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } free((void *) (*l_element_courant).donnee); free((struct_liste_chainee_volatile *) l_element_courant); - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); return; } @@ -316,29 +217,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; @@ -357,14 +242,7 @@ 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; } @@ -378,16 +256,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; } @@ -400,58 +272,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; } @@ -460,17 +310,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; @@ -482,18 +325,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; } } @@ -517,28 +357,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) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } -# else - if (sem_post(semaphore_liste_threads) != 0) + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -548,11 +380,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; @@ -566,9 +394,6 @@ 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; @@ -582,21 +407,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; @@ -676,10 +490,11 @@ liberation_threads(struct_processus *s_e s_argument_thread = (struct_descripteur_thread *) (*((struct_liste_chainee *) element_courant)).donnee; - 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; } @@ -700,15 +515,17 @@ liberation_threads(struct_processus *s_e close((*s_argument_thread) .pipe_nombre_interruptions_attente[0]); - 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; } pthread_mutex_destroy(&((*s_argument_thread).mutex)); + pthread_mutex_destroy(&((*s_argument_thread) + .mutex_nombre_references)); if ((*s_argument_thread).processus_detache == d_faux) { @@ -723,11 +540,11 @@ liberation_threads(struct_processus *s_e } 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; } } @@ -796,25 +613,8 @@ 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); + liberation_arbre_variables(s_etat_processus, + (*s_etat_processus).s_arbre_variables, d_faux); for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) { @@ -1321,13 +1121,14 @@ 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 + liberation_contexte_cas(s_etat_processus); free(s_etat_processus); s_etat_processus = candidat; @@ -1350,10 +1151,11 @@ liberation_threads(struct_processus *s_e s_argument_thread = (struct_descripteur_thread *) (*l_element_courant).donnee; - 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; } @@ -1373,14 +1175,17 @@ liberation_threads(struct_processus *s_e close((*s_argument_thread).pipe_interruptions[0]); close((*s_argument_thread).pipe_nombre_interruptions_attente[0]); - 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; } pthread_mutex_destroy(&((*s_argument_thread).mutex)); + pthread_mutex_destroy(&((*s_argument_thread) + .mutex_nombre_references)); if ((*s_argument_thread).processus_detache == d_faux) { @@ -1394,10 +1199,11 @@ liberation_threads(struct_processus *s_e } 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; } } @@ -1409,19 +1215,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; } @@ -1461,8 +1260,8 @@ recherche_thread(pid_t pid, pthread_t ti 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; @@ -1486,12 +1285,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); } @@ -1512,42 +1310,31 @@ recherche_thread_principal(pid_t pid, pt // 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); - -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) -# endif + if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; - } +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif + BUG(1, uprintf("Unlock error !\n")); + return; } # ifndef SEMAPHORES_NOMMES @@ -1556,7 +1343,11 @@ verrouillage_gestionnaire_signaux() if (sem_post(semaphore_gestionnaires_signaux) == -1) # endif { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Lock error !\n")); return; } @@ -1567,18 +1358,22 @@ verrouillage_gestionnaire_signaux() if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) # endif { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Lock error !\n")); return; } -# ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) -# else - if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) -# endif + if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Unlock error !\n")); return; } @@ -1591,66 +1386,37 @@ verrouillage_gestionnaire_signaux() // par un thread concurrent. On essaye donc de le bloquer jusqu'à // ce que ce soit possible. -# ifndef SEMAPHORES_NOMMES - while(sem_trywait(&semaphore_liste_threads) == -1) -# else - while(sem_trywait(semaphore_liste_threads) == -1) -# endif + if (pthread_mutex_lock(&mutex_liste_threads) != 0) { - if ((errno != EINTR) && (errno != EAGAIN)) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - - while(sem_wait(sem) == -1) - { - if (errno != EINTR) - { - BUG(1, uprintf("Lock error !\n")); - return; - } - } - - BUG(1, uprintf("Lock error !\n")); - return; - } - - sched_yield(); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif + BUG(1, uprintf("Lock error !\n")); + return; } } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - return; } static inline void -deverrouillage_gestionnaire_signaux() +deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { int semaphore; - sem_t *sem; - - sigset_t oldset; - sigset_t set; - // Il faut respecteur l'atomicité des deux opérations suivantes ! - sigfillset(&set); - pthread_sigmask(SIG_BLOCK, &set, &oldset); - -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux_atomique) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux_atomique) == -1) -# endif + if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; - } +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif + BUG(1, uprintf("Unlock error !\n")); + return; } # ifndef SEMAPHORES_NOMMES @@ -1659,7 +1425,11 @@ deverrouillage_gestionnaire_signaux() if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) # endif { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Unlock error !\n")); return; } @@ -1672,770 +1442,279 @@ deverrouillage_gestionnaire_signaux() { if (errno != EINTR) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Unlock error !\n")); return; } } -# ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_gestionnaires_signaux_atomique) != 0) -# else - if (sem_post(semaphore_gestionnaires_signaux_atomique) != 0) -# endif + if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); +# ifndef SEMAPHORES_NOMMES + sem_wait(&((*s_etat_processus).semaphore_fork)); +# else + sem_wait((*s_etat_processus).semaphore_fork); +# endif BUG(1, uprintf("Unlock error !\n")); return; } - if ((sem = pthread_getspecific(semaphore_fork_processus_courant)) - != NULL) +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) +# else + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) +# endif { - while(sem_wait(sem) == -1) + if (errno != EINTR) { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - BUG(1, uprintf("Unlock error !\n")); - return; - } + BUG(1, uprintf("Unlock error !\n")); + return; } } if (semaphore == 1) { -# 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); - BUG(1, uprintf("Unlock error !\n")); return; } } - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - return; } -#ifdef _BROKEN_SIGINFO +#define test_signal(signal) \ + if (signal_test == SIGTEST) { signal_test = signal; return; } -// Remplacer les mutexes par des sémaphores SysV +// Récupération des signaux +// - SIGINT (arrêt au clavier) +// - SIGTERM (signal d'arrêt en provenance du système) -#define longueur_queue 256 -#define nombre_queues 13 - -static int *fifos; -static int segment; -static sem_t *semaphores[nombre_queues]; -static sem_t *semaphore_global; - -#ifdef IPCS_SYSV -static unsigned char *chemin = NULL; -#endif - -unsigned char * -nom_segment(unsigned char *chemin, pid_t pid) -{ - unsigned char *fichier; - -# ifdef IPCS_SYSV - if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) * - sizeof(unsigned char))) == NULL) - { - return(NULL); - } - - sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); -# else - if ((fichier = malloc((1 + 256 + 1) * - sizeof(unsigned char))) == NULL) - { - return(NULL); - } - - sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid); -# endif - - return(fichier); -} - -unsigned char * -nom_semaphore(pid_t pid, int queue) +void +interruption1(int signal) { - unsigned char *fichier; - - if ((fichier = malloc((256 + 1) * sizeof(unsigned char))) == NULL) - { - return(NULL); - } - - sprintf(fichier, "/RPL-SIGESMAPHORES-%d-%d", (int) pid, queue); - - return(fichier); -} + test_signal(signal); -inline int -queue_de_signal(int signal) -{ switch(signal) { case SIGINT: - return(0); - case SIGTSTP: - return(1); - case SIGCONT: - return(2); - case SIGURG: - return(3); - case SIGPIPE: - return(4); + envoi_signal_processus(getpid(), rpl_sigint); + break; + + case SIGTERM: + envoi_signal_processus(getpid(), rpl_sigterm); + break; + case SIGALRM: - return(5); - case SIGFSTOP: - return(6); - case SIGSTART: - return(7); - case SIGINJECT: - return(8); - case SIGABORT: - return(9); - case SIGFABORT: - return(10); - case SIGSEGV: - return(11); - case SIGBUS: - return(12); + envoi_signal_processus(getpid(), rpl_sigalrm); + break; } - return(-1); + return; } -void -creation_fifos_signaux(struct_processus *s_etat_processus) +inline static void +signal_alrm(struct_processus *s_etat_processus, pid_t pid) { - /* - * Signaux utilisés - * SIGINT, SIGTSTP, SIGCONT, SIGURG, SIGPIPE, SIGALRM, SIGFSTOP, - * SIGSTART, SIGINJECT, SIGABORT, SIGFABORT - */ - -# ifndef IPCS_SYSV // POSIX -# else // SystemV - - file *desc; - - int i; - - key_t clef; - - unsigned char *nom; - - // Création d'un segment de données associé au PID du processus courant - - chemin = (*s_etat_processus).chemin_fichiers_temporaires; - - if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires, - getpid())) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - if ((desc = fopen(nom, "w")) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; - return; - } + struct_processus *s_thread_principal; - fclose(desc); + verrouillage_gestionnaire_signaux(s_etat_processus); - if ((clef = ftok(nom, 1)) == -1) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - free(nom); - - if ((segment = shmget(clef, - nombre_queues * (longueur_queue + 4) * sizeof(int), - IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1) + if (pid == getpid()) { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } + // 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. - fifos = shmat(segment, NULL, 0); - - if (((void *) fifos) == ((void *) -1)) - { - if (shmctl(segment, IPC_RMID, 0) == -1) + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; + printf("[%d] RPL/SIGALRM (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); } - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - -# endif - - /* - * Structure d'une queue - * 0 : pointeur en lecture sur le premier emplacement libre (int) - * 1 : pointeur en écriture sur le premier emplacement à lire (int) - * 2 : longueur de la queue (int) - * 3 : éléments restants (int) - * 4 à 4 + (2) : queue (int) - */ - - for(i = 0; i < nombre_queues; i++) - { - fifos[(i * (longueur_queue + 4))] = 0; - fifos[(i * (longueur_queue + 4)) + 1] = 0; - fifos[(i * (longueur_queue + 4)) + 2] = longueur_queue; - fifos[(i * (longueur_queue + 4)) + 3] = longueur_queue; - } - - // Création des sémaphores : un sémaphore par signal et par queue - // plus un sémaphore global pour tous les threads. - - for(i = 0; i < nombre_queues; i++) - { - if ((nom = nom_semaphore(getpid(), i)) == NULL) + if ((*s_etat_processus).pid_processus_pere != getpid()) { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; + // On n'est pas dans le processus père, on remonte le signal. + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigalrm); } - - // Le sémaphore est créé en écrasant si nécessaire un sémaphore - // préexistant. Comme le nom du sémaphore contient l'identifiant du - // processus, il est anormal d'avoir un sémaphore de même nom - // préexistant. - - if ((semaphores[i] = sem_open(nom, O_CREAT, S_IRUSR | S_IWUSR, - 1)) == SEM_FAILED) + else { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; + // 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; } - - free(nom); } - - - if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - if ((semaphore_global = sem_open(nom, O_CREAT, S_IRUSR | S_IWUSR, - 1)) == SEM_FAILED) - { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; - } - - free(nom); - - return; -} - -void -liberation_fifos_signaux(struct_processus *s_etat_processus) -{ - int i; - - if (shmdt(fifos) == -1) + else { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } + // Le signal est issu d'un processus différent. On recherche le + // thread principal pour remonter le signal. - for(i = 0; i < nombre_queues; i++) - { - if (sem_close(semaphores[i]) != 0) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; + envoi_signal_contexte(s_thread_principal, rpl_sigalrm); } } - if (sem_close(semaphore_global) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; - } - + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -destruction_fifos_signaux(struct_processus *s_etat_processus) +inline static void +signal_term(struct_processus *s_etat_processus, pid_t pid) { - int i; - - unsigned char *nom; - - if (shmdt(fifos) == -1) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - if (shmctl(segment, 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; - } + struct_processus *s_thread_principal; + volatile sig_atomic_t exclusion = 0; - unlink(nom); - free(nom); + verrouillage_gestionnaire_signaux(s_etat_processus); - for(i = 0; i < nombre_queues; i++) + if (pid == getpid()) { - if ((nom = nom_semaphore(getpid(), i)) == NULL) + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; + printf("[%d] RPL/SIGTERM (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + fflush(stdout); } - if (sem_unlink(nom) != 0) + if ((*s_etat_processus).pid_processus_pere != getpid()) { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigterm); } + else + { + (*s_etat_processus).var_volatile_traitement_sigint = -1; - free(nom); - } - - if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - if (sem_unlink(nom) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; - } - - free(nom); - - return; -} - -int -queue_in(pid_t pid, int signal) -{ -#undef printf -// Transformer ce truc en POSIX ! On ne fait du SysV que si on n'a pas le choix - -# ifndef IPCS_SYSV -# else // Traitement à l'aide d'IPCS SystemV - - int *base; - int *buffer; - int *projection_fifos; - int queue; - int identifiant; - - key_t clef; - - sem_t *semaphore; - - struct stat s_stat; - - unsigned char *nom; - - queue = queue_de_signal(signal); - - // Ouverture des projections - - if ((nom = nom_segment(chemin, pid)) == NULL) - { - return(-1); - } - - // Dans le cas de SIGSTART, premier signal envoyé à un processus fils, - // il convient d'attendre que le fichier support soit effectivement - // accessible. Dans tous les autres cas, ce fichier doit exister. S'il - // n'existe plus, le processus associé n'existe plus. - - if (signal == SIGSTART) - { - // On attend que le fichier sois présent - - while(stat(nom, &s_stat) != 0); - } + while(exclusion == 1); + exclusion = 1; - if ((clef = ftok(nom, 1)) == -1) - { - return(-1); - } + if ((*s_etat_processus).var_volatile_requete_arret == -1) + { + deverrouillage_gestionnaire_signaux(s_etat_processus); + exclusion = 0; + return; + } - free(nom); + (*s_etat_processus).var_volatile_requete_arret = -1; + (*s_etat_processus).var_volatile_alarme = -1; - if (signal == SIGSTART) - { - while((identifiant = shmget(clef, - nombre_queues * (longueur_queue + 4) * sizeof(int), - S_IRUSR | S_IWUSR)) == -1); + exclusion = 0; + } } else { - if ((identifiant = shmget(clef, - nombre_queues * (longueur_queue + 4) * sizeof(int), - S_IRUSR | S_IWUSR)) == -1) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - return(-1); + envoi_signal_contexte(s_thread_principal, rpl_sigterm); } } - projection_fifos = shmat(identifiant, NULL, 0); - - if (((void *) projection_fifos) == ((void *) -1)) - { - return(-1); - } - - if ((nom = nom_semaphore(pid, queue)) == NULL) - { - shmdt(projection_fifos); - return(-1); - } - - while((semaphore = sem_open(nom, 0)) == SEM_FAILED); - - if (sem_wait(semaphore) != 0) - { - shmdt(projection_fifos); - return(-1); - } - - // Il ne faut pas empiler plusieurs SIGSTART car SIGSTART peut provenir - // de l'instruction SWI. Plusieurs threads peuvent interrompre de façon - // asynchrone le processus père durant une phase de signaux masqués. - - base = &(projection_fifos[(longueur_queue + 4) * queue]); - buffer = &(base[4]); - - // base[3] contient le nombre d'éléments restants - - if (base[3] <= 0) - { - sem_post(semaphore); - sem_close(semaphore); - shmdt(projection_fifos); - return(-1); - } - - base[3]--; - - // base[1] contient le prochain élément à écrire - buffer[base[1]++] = (int) pid; - base[1] %= base[2]; - - if (sem_post(semaphore) != 0) - { - shmdt(projection_fifos); - sem_close(semaphore); - return(-1); - } - - sem_close(semaphore); - - // Fermeture des projections - shmdt(projection_fifos); - -# endif - - return(0); -} - -pid_t -origine_signal(int signal) -{ - int *base; - int *buffer; - int pid; - int queue; - - queue = queue_de_signal(signal); - - BUG(queue == -1, uprintf("[%d] Unknown signal %d in this context\n", - (int) getpid(), signal)); - - if (sem_wait(semaphores[queue]) != 0) - { - return(-1); - } - - // Le signal SIGCONT peut être envoyé de façon totalement asynchrone. - // Il peut y avoir plus de signaux envoyés que d'interruptions traitées. - // Il convient donc de rectifier la queue lors du traitement de - // l'interruption correspondante. Le gestionnaire étant installé sans - // l'option NODEFER, la queue reste cohérente. - - if (signal == SIGCONT) - { - base = &(fifos[(longueur_queue + 4) * queue]); - buffer = &(base[4]); - base[0] = (base[1] - 1) % base[2]; - pid = buffer[base[0]++]; - base[3] = base[2]; - } - else - { - base = &(fifos[(longueur_queue + 4) * queue]); - buffer = &(base[4]); - pid = buffer[base[0]++]; - base[0] %= base[2]; - base[3]++; - } - - if (base[3] > base[2]) - { - sem_post(semaphores[queue]); - return(-1); - } - - if (sem_post(semaphores[queue]) != 0) - { - return(-1); - } - - return((pid_t) pid); + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; } -#endif - -#ifdef printf -# undef printf -#endif - -void -interruption1(SIGHANDLER_ARGS) +inline static void +signal_int(struct_processus *s_etat_processus, pid_t pid) { - 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); -# ifdef _BROKEN_SIGINFO - if (signal == SIGINT) - { - // Si l'interruption provient du clavier, il n'y a pas eu d'appel - // à queue_in(). - - pid = getpid(); - } - else + if (pid == getpid()) { - pid = origine_signal(signal); - } -# else - pid = (*siginfo).si_pid; -# endif + 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); + } - switch(signal) - { - case SIGALRM : + if ((*s_etat_processus).pid_processus_pere != getpid()) { - if (pid == getpid()) - { - if ((s_etat_processus = recherche_thread(getpid(), - pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigint); + } + else + { + (*s_etat_processus).var_volatile_traitement_sigint = -1; - 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); - } + while(exclusion == 1); + exclusion = 1; - 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 ((*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); + exclusion = 0; + return; } - break; - } - - case SIGINT : - { - /* - * 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. - */ - -# ifndef _BROKEN_SIGINFO - if (siginfo == NULL) + if ((*s_etat_processus).langue == 'F') { - kill(getpid(), signal); + printf("+++Interruption\n"); } else -# endif - if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), - pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } - - 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_etat_processus).pid_processus_pere != getpid()) - { - kill((*s_etat_processus).pid_processus_pere, signal); - } - 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(); - exclusion = 0; - return; - } - - if (strncmp(getenv("LANG"), "fr", 2) == 0) - { - printf("+++Interruption\n"); - } - else - { - printf("+++Interrupt\n"); - } - - fflush(stdout); + printf("+++Interrupt\n"); + } - (*s_etat_processus).var_volatile_requete_arret = -1; - (*s_etat_processus).var_volatile_alarme = -1; + fflush(stdout); - exclusion = 0; - } - } - else - { - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - pthread_kill(thread, signal); - } - } + (*s_etat_processus).var_volatile_requete_arret = -1; + (*s_etat_processus).var_volatile_alarme = -1; - break; + exclusion = 0; } - - default : + } + 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_sigint); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); 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(SIGHANDLER_ARGS) +interruption2(int signal) { - pid_t pid; - - pthread_t thread; - - struct_processus *s_etat_processus; - - verrouillage_gestionnaire_signaux(); + test_signal(signal); + envoi_signal_processus(getpid(), rpl_sigtstp); + return; +} -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif +static inline void +signal_tstp(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; -# ifndef _BROKEN_SIGINFO - if (siginfo == NULL) - { - /* - * 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. - */ + verrouillage_gestionnaire_signaux(s_etat_processus); - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - pthread_kill(thread, SIGHUP); - deverrouillage_gestionnaire_signaux(); - return; - } - } - else -# endif if (pid == getpid()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } - /* * 0 => fonctionnement normal * -1 => requête @@ -2444,14 +1723,15 @@ interruption2(SIGHANDLER_ARGS) 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); } else { @@ -2462,38 +1742,52 @@ interruption2(SIGHANDLER_ARGS) { // 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; } void -interruption3(SIGHANDLER_ARGS) +interruption3(int signal) { - pid_t pid; + // 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. - struct_processus *s_etat_processus; + unsigned char message[] = "+++System : Uncaught access violation\n" + "+++System : Aborting !\n"; - static int compteur = 0; + test_signal(signal); - verrouillage_gestionnaire_signaux(); + if (pid_processus_pere == getpid()) + { + kill(pid_processus_pere, SIGALRM); + } -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif + write(STDERR_FILENO, message, strlen(message)); + _exit(EXIT_FAILURE); +} + +#if 0 +// Utiliser libsigsegv +void INTERRUPTION3_A_FIXER() +{ + pthread_t thread; + + struct_processus *s_etat_processus; + + test_signal(signal); + 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; } @@ -2507,7 +1801,7 @@ interruption3(SIGHANDLER_ARGS) if ((*s_etat_processus).var_volatile_recursivite == -1) { // Segfault dans un appel de fonction récursive - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); longjmp(contexte, -1); } else @@ -2515,98 +1809,166 @@ interruption3(SIGHANDLER_ARGS) // Segfault dans une routine interne if (strncmp(getenv("LANG"), "fr", 2) == 0) { - printf("+++Système : Violation d'accès (dépassement de pile)\n"); + printf("+++Système : Violation d'accès\n"); } else { - printf("+++System : Access violation (stack overflow)\n"); + printf("+++System : Access violation\n"); } fflush(stdout); - compteur++; + (*s_etat_processus).compteur_violation_d_acces++; - if (compteur > 1) + if ((*s_etat_processus).compteur_violation_d_acces > 1) { - deverrouillage_gestionnaire_signaux(); + // On vient de récupérer plus d'une erreur de segmentation + // dans le même processus ou le même thread. L'erreur n'est pas + // récupérable et on sort autoritairement du programme. Il peut + // rester des processus orphelins en attente ! + + if (strncmp(getenv("LANG"), "fr", 2) == 0) + { + printf("+++Système : Violation d'accès, tentative de " + "terminaison de la tâche\n"); + printf(" (defauts multiples)\n"); + } + else + { + printf("+++System : Access violation, trying to kill task " + "(multiple defaults)\n"); + } + + fflush(stdout); + + deverrouillage_gestionnaire_signaux(s_etat_processus); exit(EXIT_FAILURE); } else { - deverrouillage_gestionnaire_signaux(); + // Première erreur de segmentation. On essaie de terminer + // proprement le thread ou le processus. Le signal ne peut être + // envoyé que depuis le même processus. + + if (recherche_thread_principal(getpid(), &thread) == d_vrai) + { + if (pthread_equal(thread, pthread_self()) != 0) + { + deverrouillage_gestionnaire_signaux(s_etat_processus); + + if ((*s_etat_processus).pid_processus_pere != getpid()) + { + // On est dans le thread principal d'un processus. + + longjmp(contexte_processus, -1); + } + else + { + // On est dans le thread principal du processus + // père. + + longjmp(contexte_initial, -1); + } + } + else + { + // On est dans un thread fils d'un thread principal. + + deverrouillage_gestionnaire_signaux(s_etat_processus); + longjmp(contexte_thread, -1); + } + } + + // Là, on ramasse les miettes puisque le thread n'existe plus + // dans la base (corruption de la mémoire). + + deverrouillage_gestionnaire_signaux(s_etat_processus); longjmp(contexte_initial, -1); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } +#endif -void -interruption4(SIGHANDLER_ARGS) -{ - pid_t pid; - - struct_processus *s_etat_processus; +// Traitement de rpl_sigstart - verrouillage_gestionnaire_signaux(); +static inline void +signal_start(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif + verrouillage_gestionnaire_signaux(s_etat_processus); - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) + if (pid == getpid()) { - deverrouillage_gestionnaire_signaux(); - return; + (*s_etat_processus).demarrage_fils = d_vrai; } - - /* - * Démarrage d'un processus fils ou gestion de SIGCONT (SUSPEND) - */ - - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + else { - printf("[%d] SIGSTART/SIGCONT (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + // 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_sigstart); + } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption5(SIGHANDLER_ARGS) +// Traitement de rpl_sigcont + +static inline void +signal_cont(struct_processus *s_etat_processus, pid_t pid) { - pid_t pid; + struct_processus *s_thread_principal; - pthread_t thread; + verrouillage_gestionnaire_signaux(s_etat_processus); - struct_processus *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) + { + envoi_signal_contexte(s_thread_principal, rpl_sigcont); + } + } - verrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; +} -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif +// 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 = 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) { - printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGSTOP (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } @@ -2629,123 +1991,82 @@ interruption5(SIGHANDLER_ARGS) } else { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } - // 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_sigstop); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption6(SIGHANDLER_ARGS) -{ - pid_t pid; - - struct_processus *s_etat_processus; - - verrouillage_gestionnaire_signaux(); +// Traitement de rpl_siginject -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif +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; } if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGINJECT/SIGQUIT (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; } +// Récupération des signaux +// - SIGPIPE + void -interruption7(SIGHANDLER_ARGS) +interruption5(int signal) { - pid_t pid; - - struct_processus *s_etat_processus; - - verrouillage_gestionnaire_signaux(); + unsigned char message[] = "+++System : SIGPIPE\n" + "+++System : Aborting !\n"; -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif - - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + test_signal(signal); - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) + if (pid_processus_pere == getpid()) { - printf("[%d] SIGPIPE (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); + envoi_signal_processus(pid_processus_pere, rpl_sigalrm); } - (*s_etat_processus).var_volatile_requete_arret = -1; - deverrouillage_gestionnaire_signaux(); - - BUG(1, printf("[%d] SIGPIPE\n", (int) getpid())); + write(STDERR_FILENO, message, strlen(message)); return; } -void -interruption8(SIGHANDLER_ARGS) +static inline void +signal_urg(struct_processus *s_etat_processus, pid_t pid) { - pid_t pid; - - pthread_t thread; + struct_processus *s_thread_principal; - struct_processus *s_etat_processus; - - verrouillage_gestionnaire_signaux(); - -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif + verrouillage_gestionnaire_signaux(s_etat_processus); if (pid == getpid()) { 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) { - printf("[%d] SIGURG (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGURG (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } @@ -2757,83 +2078,106 @@ interruption8(SIGHANDLER_ARGS) { // 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, SIGURG); - deverrouillage_gestionnaire_signaux(); - return; + envoi_signal_contexte(s_thread_principal, rpl_sigurg); } } - deverrouillage_gestionnaire_signaux(); + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } -void -interruption9(SIGHANDLER_ARGS) -{ - pid_t pid; - - struct_processus *s_etat_processus; +// Traitement de rpl_sigabort - verrouillage_gestionnaire_signaux(); +static inline void +signal_abort(struct_processus *s_etat_processus, pid_t pid) +{ + struct_processus *s_thread_principal; -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif + 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) { - printf("[%d] SIGABORT/SIGPROF (thread %llu)\n", (int) getpid(), + printf("[%d] RPL/SIGABORT (thread %llu)\n", (int) getpid(), (unsigned long long) pthread_self()); fflush(stdout); } -# ifdef _BROKEN_SIGINFO - if (queue_in(getpid(), signal) != 0) + if (pid == getpid()) { - return; + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) + == NULL) + { + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; + } + + (*s_etat_processus).arret_depuis_abort = -1; + + /* + * var_globale_traitement_retarde_stop : + * 0 -> traitement immédiat + * 1 -> traitement retardé (aucun signal reçu) + * -1 -> traitement retardé (un ou plusieurs signaux stop reçus) + */ + + if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0) + { + (*s_etat_processus).var_volatile_requete_arret = -1; + } + else + { + (*s_etat_processus).var_volatile_traitement_retarde_stop = -1; + } } + else + { + (*s_etat_processus).arret_depuis_abort = -1; - deverrouillage_gestionnaire_signaux(); - interruption11(signal); -# else - deverrouillage_gestionnaire_signaux(); - interruption11(signal, siginfo, context); -# endif + // 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_sigabort); + } + } + + deverrouillage_gestionnaire_signaux(s_etat_processus); return; } +// Récupération des signaux +// - SIGHUP + void -interruption10(SIGHANDLER_ARGS) +interruption4(int signal) { - file *fichier; - - pid_t pid; + test_signal(signal); + envoi_signal_processus(getpid(), rpl_sighup); + return; +} - struct_processus *s_etat_processus; +static inline void +signal_hup(struct_processus *s_etat_processus, pid_t pid) +{ + file *fichier; unsigned char nom[8 + 64 + 1]; - verrouillage_gestionnaire_signaux(); - -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif + 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; } @@ -2852,219 +2196,823 @@ interruption10(SIGHANDLER_ARGS) if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGHUP (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 -interruption11(SIGHANDLER_ARGS) +traitement_exceptions_gsl(const char *reason, const char *file, + int line, int gsl_errno) { - pid_t pid; + code_erreur_gsl = gsl_errno; + envoi_signal_processus(getpid(), rpl_sigexcept); + return; +} - pthread_t thread; +static inline void +signal_except(struct_processus *s_etat_processus, pid_t pid) +{ + verrouillage_gestionnaire_signaux(s_etat_processus); - struct_processus *s_etat_processus; + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) + { + deverrouillage_gestionnaire_signaux(s_etat_processus); + return; + } - verrouillage_gestionnaire_signaux(); + (*s_etat_processus).var_volatile_exception_gsl = code_erreur_gsl; + deverrouillage_gestionnaire_signaux(s_etat_processus); -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif + return; +} - if (pid == getpid()) +static inline void +envoi_interruptions(struct_processus *s_etat_processus, enum signaux_rpl signal, + pid_t pid_source) +{ + switch(signal) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + case rpl_signull: + break; - (*s_etat_processus).arret_depuis_abort = -1; + case rpl_sigint: + signal_int(s_etat_processus, pid_source); + break; - if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) - { - printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); - fflush(stdout); - } + case rpl_sigterm: + signal_term(s_etat_processus, pid_source); + break; - /* - * 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) - */ + case rpl_sigstart: + signal_start(s_etat_processus, pid_source); + break; - if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0) - { - (*s_etat_processus).var_volatile_requete_arret = -1; - } - else - { - (*s_etat_processus).var_volatile_traitement_retarde_stop = -1; - } + case rpl_sigcont: + signal_cont(s_etat_processus, pid_source); + break; + + case rpl_sigstop: + signal_stop(s_etat_processus, pid_source); + break; + + 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 : Spurious signal (%d) !\n", signal); + } + else + { + printf("+++System : Signal inconnu (%d) !\n", signal); + } + + break; } - else + + return; +} + +void +scrutation_interruptions(struct_processus *s_etat_processus) +{ + // Interruptions qui arrivent sur le processus depuis un + // processus externe. + + // Les pointeurs de lecture pointent sur les prochains éléments + // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à + // écrire. + +# ifndef SEMAPHORES_NOMMES + if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0) +# else + if (sem_trywait(semaphore_queue_signaux) == 0) +# endif { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) + if ((*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; } - (*s_etat_processus).arret_depuis_abort = -1; +# ifndef SEMAPHORES_NOMMES + sem_post(&((*s_queue_signaux).semaphore)); +# else + sem_post(semaphore_queue_signaux); +# endif + } - // Envoi d'un signal au thread maître du groupe. + // Interruptions qui arrivent depuis le groupe courant de threads. - if (recherche_thread_principal(getpid(), &thread) == d_vrai) + if (pthread_mutex_trylock(&mutex_interruptions) == 0) + { + if ((*s_etat_processus).pointeur_signal_lecture != + (*s_etat_processus).pointeur_signal_ecriture) { - pthread_kill(thread, signal); - deverrouillage_gestionnaire_signaux(); - return; + // 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; } + + pthread_mutex_unlock(&mutex_interruptions); } - deverrouillage_gestionnaire_signaux(); return; } -void -traitement_exceptions_gsl(const char *reason, const char *file, - int line, int gsl_errno) +/* +================================================================================ + 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) { - struct_processus *s_etat_processus; + unsigned char *fichier; - verrouillage_gestionnaire_signaux(); +# ifdef IPCS_SYSV // !POSIX +# ifndef OS2 // !OS2 - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) * + sizeof(unsigned char))) == NULL) + { + return(NULL); + } - (*s_etat_processus).var_volatile_exception_gsl = gsl_errno; - deverrouillage_gestionnaire_signaux(); - return; + sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); +# else // OS2 + if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char))) + == NULL) + { + return(NULL); + } + + sprintf(fichier, "\\SHAREMEM\\RPL-SIGQUEUES-%d", (int) pid); +# endif // OS2 +# else // POSIX + + if ((fichier = malloc((1 + 256 + 1) * + sizeof(unsigned char))) == NULL) + { + return(NULL); + } + + sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid); +# endif + + return(fichier); } -#ifdef _BROKEN_SIGINFO -#undef kill -#undef pthread_kill +/* +================================================================================ + Fonctions d'envoi d'un signal à un thread ou à un processus. +================================================================================ + Entrée : processus et signal +-------------------------------------------------------------------------------- + Sortie : erreur +-------------------------------------------------------------------------------- + Effet de bord : Néant +================================================================================ +*/ int -kill_broken_siginfo(pid_t pid, int signal) +envoi_signal_processus(pid_t pid, enum signaux_rpl signal) { - int ios; + int segment; - sem_t *semaphore; +# ifndef IPCS_SYSV +# ifdef SEMAPHORES_NOMMES + sem_t *semaphore; +# endif +# else + int desc; + key_t clef; +# endif - unsigned char *nom; + struct_queue_signaux *queue; - /* - * Lorsqu'on veut interrompre le processus pid, on ouvre le segment - * correspondant au processus en question et ou ajoute le pid dans la - * queue. - * - * Le sémaphore global à tous les threads d'un même processus sert - * à garantir que les signaux seront traités dans l'ordre de ce qui est - * effectivement mis dans la queue. - */ + unsigned char *nom; - // Sémaphore acquis + // 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 ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL) + if (pid == getpid()) { - return(-1); - } + // Le signal est envoyé au même processus. - if ((semaphore = sem_open(nom, 0)) == SEM_FAILED) - { - free(nom); - return(-1); - } + if (s_queue_signaux == NULL) + { + return(1); + } + +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_queue_signaux).semaphore)) != 0) +# else + while(sem_wait(semaphore_queue_signaux) != 0) +# endif + { + if (errno != EINTR) + { + return(1); + } + } - free(nom); + (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] + .pid = pid; + (*s_queue_signaux).queue[(*s_queue_signaux).pointeur_ecriture] + .signal = signal; - if (sem_wait(semaphore) == -1) - { - return(-1); - } + (*s_queue_signaux).pointeur_ecriture = + ((*s_queue_signaux).pointeur_ecriture + 1) + % LONGUEUR_QUEUE_SIGNAUX; - if ((signal != 0) && (signal != SIGINT)) - { - if (queue_in(pid, signal) != 0) +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*s_queue_signaux).semaphore)) != 0) +# else + if (sem_post(semaphore_queue_signaux) != 0) +# endif { - sem_post(semaphore); - sem_close(semaphore); - return(-1); + return(1); } } + else + { + // Le signal est envoyé depuis un processus distinct. + +# ifdef IPCS_SYSV + if ((nom = nom_segment(racine_segment, pid)) == NULL) + { + return(1); + } + + if ((desc = open(nom, O_RDWR)) == -1) + { + free(nom); + return(1); + } + + close(desc); + + if ((clef = ftok(nom, 1)) == -1) + { + free(nom); + return(1); + } + + free(nom); + + if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1) + { + return(1); + } + + queue = shmat(segment, NULL, 0); +# else // POSIX + if ((nom = nom_segment(racine_segment, pid)) == NULL) + { + return(1); + } + + if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + free(nom); + return(1); + } + + 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 + + // À ce moment, le segment de mémoire partagée est projeté + // dans l'espace du processus. + +# ifndef IPCS_SYSV // POSIX +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*queue).semaphore)) != 0) + { + if (errno != EINTR) + { + return(1); + } + } +# else + if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) + { + return(1); + } + + while(sem_wait(semaphore) != 0) + { + if (errno != EINTR) + { + sem_close(semaphore); + return(1); + } + } +# endif +# else // IPCS_SYSV + while(sem_wait(&((*queue).semaphore)) != 0) + { + if (errno != EINTR) + { + return(1); + } + } +# endif + + (*queue).queue[(*queue).pointeur_ecriture].pid = getpid(); + (*queue).queue[(*queue).pointeur_ecriture].signal = signal; + + (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1) + % LONGUEUR_QUEUE_SIGNAUX; + +# ifndef IPCS_SYSV // POSIX +# ifndef SEMAPHORES_NOMMES + if (sem_post(&((*queue).semaphore)) != 0) + { + return(1); + } +# else + if (sem_post(semaphore) != 0) + { + sem_close(semaphore); + return(1); + } - ios = kill(pid, signal); + if (sem_close(semaphore) != 0) + { + return(1); + } +# endif - // Sémaphore relâché + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } +# else // IPCS_SYSV + if (sem_post(&((*queue).semaphore)) != 0) + { + return(1); + } - sem_post(semaphore); - sem_close(semaphore); + if (shmdt(queue) != 0) + { + return(1); + } +# endif + } - return(ios); + return(0); } int -pthread_kill_broken_siginfo(pthread_t tid, int signal) +envoi_signal_thread(pthread_t tid, enum signaux_rpl signal) { - int ios; + // Un signal est envoyé d'un thread à un autre thread du même processus. - sem_t *semaphore; + volatile struct_liste_chainee_volatile *l_element_courant; - unsigned char *nom; + struct_processus *s_etat_processus; + + if (pthread_mutex_lock(&mutex_liste_threads) != 0) + { + return(1); + } + + l_element_courant = liste_threads; + + while(l_element_courant != NULL) + { + 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; + } - if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL) + if (l_element_courant == NULL) { - return(-1); + pthread_mutex_unlock(&mutex_liste_threads); + return(1); } - if ((semaphore = sem_open(nom, 0)) == SEM_FAILED) + if (pthread_mutex_lock(&mutex_interruptions) != 0) { - free(nom); - return(-1); + pthread_mutex_unlock(&mutex_liste_threads); + return(1); } - free(nom); + 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 (sem_wait(semaphore) == -1) + if (pthread_mutex_unlock(&mutex_interruptions) != 0) { - return(-1); + pthread_mutex_unlock(&mutex_liste_threads); + return(1); } - if ((signal != 0) && (signal != SIGINT)) + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) { - if (queue_in(getpid(), signal) != 0) + return(1); + } + + return(0); +} + +int +envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler, + enum signaux_rpl signal) +{ + pthread_mutex_lock(&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); + + 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 +creation_queue_signaux(struct_processus *s_etat_processus) +{ + unsigned char *nom; + + racine_segment = (*s_etat_processus).chemin_fichiers_temporaires; + +# ifndef IPCS_SYSV // POSIX + if ((nom = nom_segment((*s_etat_processus).chemin_fichiers_temporaires, + getpid())) == NULL) { - sem_post(semaphore); - sem_close(semaphore); - return(-1); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; } - } - ios = pthread_kill(tid, signal); + if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL, + S_IRUSR | S_IWUSR)) == -1) + { + free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } - sem_post(semaphore); - sem_close(semaphore); + if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1) + { + 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); - return(ios); + if (((void *) s_queue_signaux) == ((void *) -1)) + { + if (shm_unlink(nom) == -1) + { + free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + free(nom); + +# ifndef SEMAPHORES_NOMMES + sem_init(&((*s_queue_signaux).semaphore), 1, 1); +# else + if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) + == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } +# endif + + (*s_queue_signaux).pointeur_lecture = 0; + (*s_queue_signaux).pointeur_ecriture = 0; + + if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 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); + 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; + } + + sem_init(&((*s_queue_signaux).semaphore), 1, 1); + (*s_queue_signaux).pointeur_lecture = 0; + (*s_queue_signaux).pointeur_ecriture = 0; +# else // OS/2 + if ((nom = nom_segment(NULL, getpid())) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (DosAllocSharedMem(&ptr_os2, nom, nombre_queues * + ((2 * longueur_queue) + 4) * sizeof(int), + PAG_WRITE | PAG_READ | PAG_COMMIT) != 0) + { + free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + free(nom); + fifos = ptr_os2; +# endif +# endif + + return; } -#endif + +/* +================================================================================ + 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 +liberation_queue_signaux(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 +# ifndef SEMAPHORES_NOMMES + sem_close(&((*s_queue_signaux).semaphore)); +# else + sem_close(semaphore_queue_signaux); +# endif + + if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + 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) +{ + unsigned char *nom; + +# ifdef IPCS_SYSV // SystemV +# ifndef OS2 + // Il faut commencer par éliminer le sémaphore. + + if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*s_queue_signaux).semaphore.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); + free(nom); +# else + if (DosFreeMem(fifos) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + // FERMER LE FICHIER + +# endif +# else // POSIX +# ifndef SEMAPHORES_NOMMES + sem_close(&((*s_queue_signaux).semaphore)); + sem_destroy(&((*s_queue_signaux).semaphore)); +# else + sem_close(semaphore_queue_signaux); + sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); +# endif + + 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) + { + free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + free(nom); +# endif + + return; +} // vim: ts=4