--- rpl/src/interruptions.c 2010/04/21 13:45:50 1.9 +++ rpl/src/interruptions.c 2011/09/10 20:45:06 1.66 @@ -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.3 + Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -82,30 +82,9 @@ insertion_thread(struct_processus *s_eta sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_liste_threads) == -1) -# else - while(sem_wait(semaphore_liste_threads) == -1) -# endif - { - if (errno != EINTR) - { - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } - } - if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) == NULL) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -113,15 +92,8 @@ insertion_thread(struct_processus *s_eta return; } - (*l_nouvel_objet).suivant = liste_threads; - if (((*l_nouvel_objet).donnee = malloc(sizeof(struct_thread))) == NULL) { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); @@ -136,6 +108,23 @@ insertion_thread(struct_processus *s_eta (*((struct_thread *) (*l_nouvel_objet).donnee)).s_etat_processus = s_etat_processus; +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&semaphore_liste_threads) == -1) +# else + while(sem_wait(semaphore_liste_threads) == -1) +# endif + { + if (errno != EINTR) + { + pthread_sigmask(SIG_SETMASK, &oldset, NULL); + sigpending(&set); + + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + + (*l_nouvel_objet).suivant = liste_threads; liste_threads = l_nouvel_objet; # ifndef SEMAPHORES_NOMMES @@ -168,6 +157,16 @@ insertion_thread_surveillance(struct_pro sigfillset(&set); pthread_sigmask(SIG_BLOCK, &set, &oldset); + if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) + == NULL) + { + pthread_sigmask(SIG_SETMASK, &oldset, NULL); + sigpending(&set); + + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + # ifndef SEMAPHORES_NOMMES while(sem_wait(&semaphore_liste_threads) == -1) # else @@ -184,20 +183,9 @@ insertion_thread_surveillance(struct_pro } } - if ((l_nouvel_objet = malloc(sizeof(struct_liste_chainee_volatile))) - == NULL) - { -# ifndef SEMAPHORES_NOMMES - sem_post(&semaphore_liste_threads); -# else - sem_post(semaphore_liste_threads); -# endif - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); - - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - 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; @@ -289,9 +277,6 @@ retrait_thread(struct_processus *s_etat_ (*l_element_precedent).suivant = (*l_element_courant).suivant; } - free((void *) (*l_element_courant).donnee); - free((struct_liste_chainee_volatile *) l_element_courant); - if (pthread_setspecific(semaphore_fork_processus_courant, NULL) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -319,6 +304,9 @@ retrait_thread(struct_processus *s_etat_ return; } + free((void *) (*l_element_courant).donnee); + free((struct_liste_chainee_volatile *) l_element_courant); + pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); return; @@ -390,10 +378,14 @@ retrait_thread_surveillance(struct_proce (*l_element_precedent).suivant = (*l_element_courant).suivant; } - free((struct_liste_chainee_volatile *) l_element_courant); - - if (pthread_mutex_lock(&((*s_argument_thread).mutex)) != 0) + 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); @@ -409,8 +401,14 @@ 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); @@ -419,12 +417,19 @@ retrait_thread_surveillance(struct_proce } 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); @@ -446,8 +451,11 @@ retrait_thread_surveillance(struct_proce return; } + free((struct_liste_chainee_volatile *) l_element_courant); + pthread_sigmask(SIG_SETMASK, &oldset, NULL); sigpending(&set); + return; } @@ -626,6 +634,8 @@ liberation_threads(struct_processus *s_e close((*s_etat_processus).pipe_nombre_objets_attente); close((*s_etat_processus).pipe_nombre_interruptions_attente); + liberation(s_etat_processus, (*s_etat_processus).at_exit); + if ((*s_etat_processus).nom_fichier_impression != NULL) { free((*s_etat_processus).nom_fichier_impression); @@ -667,18 +677,76 @@ 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; + sem_post(&semaphore_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_objets_attente[0]); + close((*s_argument_thread).pipe_interruptions[0]); + close((*s_argument_thread) + .pipe_nombre_interruptions_attente[0]); + + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + sem_post(&semaphore_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; + sem_post(&semaphore_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); @@ -735,25 +803,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++) { @@ -1153,6 +1204,12 @@ liberation_threads(struct_processus *s_e element_courant = element_suivant; } +/* +================================================================================ + À noter : on ne ferme pas la connexion car la conséquence immédiate est + une destruction de l'objet pour le processus père. +================================================================================ + element_courant = (*s_etat_processus).s_connecteurs_sql; while(element_courant != NULL) { @@ -1236,6 +1293,9 @@ liberation_threads(struct_processus *s_e element_courant = element_suivant; } +*/ + + (*s_etat_processus).s_connecteurs_sql = NULL; element_courant = (*s_etat_processus).s_marques; while(element_courant != NULL) @@ -1258,6 +1318,7 @@ liberation_threads(struct_processus *s_e sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork); # endif + liberation_contexte_cas(s_etat_processus); free(s_etat_processus); s_etat_processus = candidat; @@ -1280,17 +1341,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); return; } @@ -1302,20 +1357,43 @@ 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_objets_attente[0]); + close((*s_argument_thread).pipe_interruptions[0]); + close((*s_argument_thread).pipe_nombre_interruptions_attente[0]); + + if (pthread_mutex_unlock(&((*s_argument_thread) + .mutex_nombre_references)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; + sem_post(&semaphore_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); return; } } @@ -1379,8 +1457,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; @@ -1404,12 +1482,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); } @@ -1426,7 +1503,7 @@ 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 @@ -1510,12 +1587,12 @@ verrouillage_gestionnaire_signaux() // ce que ce soit possible. # ifndef SEMAPHORES_NOMMES - while(sem_trywait(&semaphore_liste_threads) == -1) + while(sem_wait(&semaphore_liste_threads) == -1) # else - while(sem_trywait(semaphore_liste_threads) == -1) + while(sem_wait(semaphore_liste_threads) == -1) # endif { - if ((errno != EINTR) && (errno != EAGAIN)) + if (errno != EINTR) { pthread_sigmask(SIG_SETMASK, &oldset, NULL); @@ -1531,8 +1608,6 @@ verrouillage_gestionnaire_signaux() BUG(1, uprintf("Lock error !\n")); return; } - - sched_yield(); } } @@ -1642,30 +1717,116 @@ deverrouillage_gestionnaire_signaux() return; } +#define test_signal(signal) \ + if (signal_test == SIGTEST) \ + { signal_test = initialisation_queue_interruptions(signal); return; } + +/* + * Les interruptions sont mise en mémoire puis traitées depuis + * la fonction scrutation_injection() parce que les fonctions pthread*() + * ne sont pas 'async signal safe'. + * + * Les interruptions sont ainsi empilées dans un buffer circulaire puis + * traitées au fur et à mesure. + */ + +static struct +{ +# define SIGNAL_MAX 32 +# define SIGNAL_BUFFER 1024 +# define ECRITURE 0 +# define LECTURE 1 + + sig_atomic_t nombre_interruptions_en_queue; + int pointeur[SIGNAL_MAX][2]; + + pid_t pid[SIGNAL_MAX][SIGNAL_BUFFER]; +} queue_interruptions; + +pthread_mutex_t mutex_signal = PTHREAD_MUTEX_INITIALIZER; + +static inline int +initialisation_queue_interruptions(int signal) +{ + int i; + + if (signal > SIGNAL_MAX) + { + return(signal + 1); + } + + queue_interruptions.nombre_interruptions_en_queue = 0; + + for(i = 0; i < SIGNAL_MAX; i++) + { + queue_interruptions.pointeur[i][ECRITURE] = 0; + queue_interruptions.pointeur[i][LECTURE] = 0; + } + + return(signal); +} + void -interruption1(int signal, siginfo_t *siginfo, void *context) +interruption1(SIGHANDLER_ARGS) { - pthread_t thread; + pid_t pid; - struct_processus *s_etat_processus; + test_signal(signal); + +# ifdef _BROKEN_SIGINFO + if ((signal == SIGINT) || (signal == SIGTERM)) + { + // Si l'interruption provient du clavier, il n'y a pas eu d'appel + // à queue_in(). + + pid = getpid(); + } + else + { + pid = origine_signal(signal); + } +# else + + /* + * 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. + */ + + if (siginfo != NULL) + { + pid = (*siginfo).si_pid; + } + else + { + pid = getpid(); + } +# endif + + queue_interruptions.pid[signal][queue_interruptions.pointeur + [signal][ECRITURE]] = pid; + queue_interruptions.pointeur[signal][ECRITURE] = + (queue_interruptions.pointeur[signal][ECRITURE] + 1) + % SIGNAL_BUFFER; + queue_interruptions.nombre_interruptions_en_queue++; + return; +} +static void +corps_interruption1(struct_processus *s_etat_processus, int signal, pid_t pid) +{ volatile sig_atomic_t exclusion = 0; + struct_processus *s_thread_principal; + verrouillage_gestionnaire_signaux(); switch(signal) { case SIGALRM : { - if ((*siginfo).si_pid == getpid()) + 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] SIGALRM (thread %llu)\n", (int) getpid(), @@ -1685,9 +1846,13 @@ interruption1(int signal, siginfo_t *sig } else { - if (recherche_thread_principal(getpid(), &thread) == d_vrai) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - pthread_kill(thread, signal); + while((*s_etat_processus).signal_a_traiter == d_vrai); + (*s_etat_processus).signal = signal; + (*s_etat_processus).origine_signal = getpid(); + (*s_etat_processus).signal_a_traiter = d_vrai; } } @@ -1695,30 +1860,23 @@ interruption1(int signal, siginfo_t *sig } case SIGINT : + case SIGTERM : { - /* - * 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. - */ - - if (siginfo == NULL) + if (pid == getpid()) { - 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).type_debug & d_debug_signaux) != 0) { - printf("[%d] SIGINT (thread %llu)\n", (int) getpid(), - (unsigned long long) pthread_self()); + if (signal == SIGINT) + { + printf("[%d] SIGINT (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + } + else + { + printf("[%d] SIGTERM (thread %llu)\n", (int) getpid(), + (unsigned long long) pthread_self()); + } + fflush(stdout); } @@ -1740,16 +1898,19 @@ interruption1(int signal, siginfo_t *sig return; } - if (strncmp(getenv("LANG"), "fr", 2) == 0) - { - printf("+++Interruption\n"); - } - else + if (signal == SIGINT) { - printf("+++Interrupt\n"); - } + if (strncmp(getenv("LANG"), "fr", 2) == 0) + { + printf("+++Interruption\n"); + } + else + { + printf("+++Interrupt\n"); + } - fflush(stdout); + fflush(stdout); + } (*s_etat_processus).var_volatile_requete_arret = -1; (*s_etat_processus).var_volatile_alarme = -1; @@ -1759,9 +1920,13 @@ interruption1(int signal, siginfo_t *sig } else { - if (recherche_thread_principal(getpid(), &thread) == d_vrai) + if ((s_thread_principal = recherche_thread_principal(getpid())) + != NULL) { - pthread_kill(thread, signal); + while((*s_etat_processus).signal_a_traiter == d_vrai); + (*s_etat_processus).signal = signal; + (*s_etat_processus).origine_signal = getpid(); + (*s_etat_processus).signal_a_traiter = d_vrai; } } @@ -1781,39 +1946,61 @@ interruption1(int signal, siginfo_t *sig } void -interruption2(int signal, siginfo_t *siginfo, void *context) +interruption2(SIGHANDLER_ARGS) { - pthread_t thread; - struct_processus *s_etat_processus; + pid_t pid; - verrouillage_gestionnaire_signaux(); + test_signal(signal); - if (siginfo == NULL) +# ifdef _BROKEN_SIGINFO + pid = origine_signal(signal); +# else + 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. - */ - - if (recherche_thread_principal(getpid(), &thread) == d_vrai) - { - pthread_kill(thread, SIGHUP); - deverrouillage_gestionnaire_signaux(); - return; - } + pid = (*siginfo).si_pid; } - else if ((*siginfo).si_pid == getpid()) + else { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } + pid = getpid(); + } +# endif + + queue_interruptions.pid[signal][queue_interruptions.pointeur + [signal][ECRITURE]] = pid; + queue_interruptions.pointeur[signal][ECRITURE] = + (queue_interruptions.pointeur[signal][ECRITURE] + 1) + % SIGNAL_BUFFER; + + /* + * 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 (siginfo == NULL) + { + queue_interruptions.pid[SIGHUP][queue_interruptions.pointeur + [SIGHUP][ECRITURE]] = pid; + queue_interruptions.pointeur[SIGHUP][ECRITURE] = + (queue_interruptions.pointeur[SIGHUP][ECRITURE] + 1) + % SIGNAL_BUFFER; + queue_interruptions.nombre_interruptions_en_queue += 2; + } + + return; +} + +static void +corps_interruption2(struct_processus *s_etat_processus, int signal, pid_t pid) +{ + struct_processus *s_thread_principal; + + verrouillage_gestionnaire_signaux(); + if (pid == getpid()) + { /* * 0 => fonctionnement normal * -1 => requête @@ -1840,11 +2027,13 @@ 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; + while((*s_etat_processus).signal_a_traiter == d_vrai); + (*s_etat_processus).signal = signal; + (*s_etat_processus).origine_signal = getpid(); + (*s_etat_processus).signal_a_traiter = d_vrai; } } @@ -1853,12 +2042,31 @@ interruption2(int signal, siginfo_t *sig } void -interruption3(int signal, siginfo_t *siginfo, void *context) +interruption3(SIGHANDLER_ARGS) { - struct_processus *s_etat_processus; + // 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[] = "+++System : Uncaught access violation\n" + "+++System : Aborting !\n; - static int compteur = 0; + if (pid_processus_pere == getpid()) + { + kill(pid_processus_pere, SIGALRM); + } + write(STDERR_FILENO, message, strlen(message)); + _exit(EXIT_FAILURE); +} + +void INTERRUPTION3_A_FIXER() +{ + pthread_t thread; + + struct_processus *s_etat_processus; + + test_signal(signal); verrouillage_gestionnaire_signaux(); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -1885,24 +2093,79 @@ interruption3(int signal, siginfo_t *sig // 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) { + // 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(); exit(EXIT_FAILURE); } else { + // 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(); + + 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(); + 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(); longjmp(contexte_initial, -1); } @@ -1913,10 +2176,11 @@ interruption3(int signal, siginfo_t *sig } void -interruption4(int signal, siginfo_t *siginfo, void *context) +interruption4(SIGHANDLER_ARGS) { struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -1941,14 +2205,24 @@ interruption4(int signal, siginfo_t *sig } void -interruption5(int signal, siginfo_t *siginfo, void *context) +interruption5(SIGHANDLER_ARGS) { + pid_t pid; + pthread_t thread; + struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); - if ((*siginfo).si_pid == getpid()) +# ifdef _BROKEN_SIGINFO + pid = origine_signal(signal); +# else + pid = (*siginfo).si_pid; +# endif + + if (pid == getpid()) { if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -1982,11 +2256,18 @@ interruption5(int signal, siginfo_t *sig } 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) { - pthread_kill(thread, SIGFSTOP); + pthread_kill(thread, signal); deverrouillage_gestionnaire_signaux(); return; } @@ -1997,10 +2278,11 @@ interruption5(int signal, siginfo_t *sig } void -interruption6(int signal, siginfo_t *siginfo, void *context) +interruption6(SIGHANDLER_ARGS) { struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -2021,10 +2303,11 @@ interruption6(int signal, siginfo_t *sig } void -interruption7(int signal, siginfo_t *siginfo, void *context) +interruption7(SIGHANDLER_ARGS) { struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -2048,14 +2331,24 @@ interruption7(int signal, siginfo_t *sig } void -interruption8(int signal, siginfo_t *siginfo, void *context) +interruption8(SIGHANDLER_ARGS) { + pid_t pid; + pthread_t thread; + struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); - if ((*siginfo).si_pid == getpid()) +# ifdef _BROKEN_SIGINFO + pid = origine_signal(signal); +# else + pid = (*siginfo).si_pid; +# endif + + if (pid == getpid()) { if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -2091,10 +2384,11 @@ interruption8(int signal, siginfo_t *sig } void -interruption9(int signal, siginfo_t *siginfo, void *context) +interruption9(SIGHANDLER_ARGS) { struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -2110,13 +2404,23 @@ interruption9(int signal, siginfo_t *sig fflush(stdout); } - pthread_kill((*s_etat_processus).tid_processus_pere, SIGFSTOP); +# ifdef _BROKEN_SIGINFO + if (queue_in(getpid(), signal) != 0) + { + return; + } + deverrouillage_gestionnaire_signaux(); + interruption11(signal); +# else + deverrouillage_gestionnaire_signaux(); + interruption11(signal, siginfo, context); +# endif return; } void -interruption10(int signal, siginfo_t *siginfo, void *context) +interruption10(SIGHANDLER_ARGS) { file *fichier; @@ -2124,6 +2428,7 @@ interruption10(int signal, siginfo_t *si unsigned char nom[8 + 64 + 1]; + test_signal(signal); verrouillage_gestionnaire_signaux(); if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) @@ -2157,6 +2462,83 @@ interruption10(int signal, siginfo_t *si } void +interruption11(SIGHANDLER_ARGS) +{ + pid_t pid; + + pthread_t thread; + + struct_processus *s_etat_processus; + + test_signal(signal); + verrouillage_gestionnaire_signaux(); + +# ifdef _BROKEN_SIGINFO + pid = origine_signal(signal); +# else + pid = (*siginfo).si_pid; +# endif + + if (pid == getpid()) + { + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) + == NULL) + { + deverrouillage_gestionnaire_signaux(); + return; + } + + (*s_etat_processus).arret_depuis_abort = -1; + + 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); + } + + /* + * 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 + { + if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) + == NULL) + { + deverrouillage_gestionnaire_signaux(); + return; + } + + (*s_etat_processus).arret_depuis_abort = -1; + + // Envoi d'un signal au thread maître du groupe. + + if (recherche_thread_principal(getpid(), &thread) == d_vrai) + { + pthread_kill(thread, signal); + deverrouillage_gestionnaire_signaux(); + return; + } + } + + deverrouillage_gestionnaire_signaux(); + return; +} + +void traitement_exceptions_gsl(const char *reason, const char *file, int line, int gsl_errno) { @@ -2175,4 +2557,78 @@ traitement_exceptions_gsl(const char *re return; } +static inline void +structation_interruptions_elementaires(struct_processus *s_etat_processus, + int signal, pid_t pid) +{ + switch(signal) + { + case SIGINT: + case SIGTERM: + case SIGALRM: + { + corps_interruption1(s_etat_processus, signal, pid); + break; + } + + case SIGTSTP: + { + corps_interruption2(s_etat_processus, signal, pid); + } + } + + return; +} + +void +scrutation_interruptions(struct_processus *s_etat_processus) +{ + int i; + + // Interruption par processus. + + if (pthread_mutex_lock(&mutex_signal) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if (queue_interruptions.nombre_interruptions_en_queue > 0) + { + for(i = 0; i < SIGNAL_MAX; i++) + { + if ((queue_interruptions.pointeur[i][ECRITURE] - + queue_interruptions.pointeur[i][LECTURE]) != 0) + { + // Il y a une interruption dans la queue. + + queue_interruptions.nombre_interruptions_en_queue--; + scrutation_interruptions_elementaires(s_etat_processus, i, + queue_interruptions.pid[signal] + [queue_interruptions.pointeur[signal][LECTURE]]); + queue_interruptions.pointeur[signal][LECTURE] = + (queue_interruptions.pointeur[signal][LECTURE] + 1) + % SIGNAL_BUFFER; + } + } + } + + if (pthread_mutex_unlock(&mutex_signal) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + // Interruption par thread + + if ((*s_etat_processus).signal_a_traiter == d_vrai) + { + (*s_etat_processus).signal_a_traiter = d_faux; + scrutation_interruptions_elementaires(s_etat_processus, + (*s_etat_processus).signal, (*s_etat_processus).origine_signal); + } + + return; +} + // vim: ts=4