--- rpl/src/interruptions.c 2010/08/22 16:38:36 1.33 +++ rpl/src/interruptions.c 2011/09/10 20:45:06 1.66 @@ -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. @@ -183,9 +183,9 @@ insertion_thread_surveillance(struct_pro } } - 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; @@ -378,7 +378,8 @@ 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); @@ -400,7 +401,8 @@ 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); @@ -415,11 +417,13 @@ 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); @@ -676,7 +680,8 @@ 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); @@ -700,8 +705,8 @@ 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); @@ -709,6 +714,8 @@ liberation_threads(struct_processus *s_e } 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,8 +730,8 @@ 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); @@ -796,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++) { @@ -1328,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; @@ -1350,7 +1341,8 @@ 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); @@ -1373,7 +1365,8 @@ 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); @@ -1381,6 +1374,8 @@ liberation_threads(struct_processus *s_e } 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,7 +1389,8 @@ 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); @@ -1461,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; @@ -1486,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); } @@ -1592,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); @@ -1613,8 +1608,6 @@ verrouillage_gestionnaire_signaux() BUG(1, uprintf("Lock error !\n")); return; } - - sched_yield(); } } @@ -1724,541 +1717,109 @@ deverrouillage_gestionnaire_signaux() return; } -#ifdef _BROKEN_SIGINFO - -// Remplacer les mutexes par des sémaphores SysV +#define test_signal(signal) \ + if (signal_test == SIGTEST) \ + { signal_test = initialisation_queue_interruptions(signal); return; } -#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 +/* + * 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. + */ -unsigned char * -nom_segment(unsigned char *chemin, pid_t pid) +static struct { - unsigned char *fichier; +# define SIGNAL_MAX 32 +# define SIGNAL_BUFFER 1024 +# define ECRITURE 0 +# define LECTURE 1 -# ifdef IPCS_SYSV - if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) * - sizeof(unsigned char))) == NULL) - { - return(NULL); - } + sig_atomic_t nombre_interruptions_en_queue; + int pointeur[SIGNAL_MAX][2]; - sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); -# else - if ((fichier = malloc((1 + 256 + 1) * - sizeof(unsigned char))) == NULL) - { - return(NULL); - } + pid_t pid[SIGNAL_MAX][SIGNAL_BUFFER]; +} queue_interruptions; - sprintf(fichier, "/RPL-SIGQUEUES-%d", (int) pid); -# endif +pthread_mutex_t mutex_signal = PTHREAD_MUTEX_INITIALIZER; - return(fichier); -} - -unsigned char * -nom_semaphore(pid_t pid, int queue) +static inline int +initialisation_queue_interruptions(int signal) { - unsigned char *fichier; + int i; - if ((fichier = malloc((256 + 1) * sizeof(unsigned char))) == NULL) + if (signal > SIGNAL_MAX) { - return(NULL); + return(signal + 1); } - sprintf(fichier, "/RPL-SIGESMAPHORES-%d-%d", (int) pid, queue); + queue_interruptions.nombre_interruptions_en_queue = 0; - return(fichier); -} - -inline int -queue_de_signal(int signal) -{ - switch(signal) + for(i = 0; i < SIGNAL_MAX; i++) { - case SIGINT: - return(0); - case SIGTSTP: - return(1); - case SIGCONT: - return(2); - case SIGURG: - return(3); - case SIGPIPE: - return(4); - 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); + queue_interruptions.pointeur[i][ECRITURE] = 0; + queue_interruptions.pointeur[i][LECTURE] = 0; } - return(-1); + return(signal); } void -creation_fifos_signaux(struct_processus *s_etat_processus) +interruption1(SIGHANDLER_ARGS) { - /* - * 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; - } - - fclose(desc); - - 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) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } + pid_t pid; - fifos = shmat(segment, NULL, 0); + test_signal(signal); - if (((void *) fifos) == ((void *) -1)) - { - if (shmctl(segment, IPC_RMID, 0) == -1) +# ifdef _BROKEN_SIGINFO + if ((signal == SIGINT) || (signal == SIGTERM)) { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } + // Si l'interruption provient du clavier, il n'y a pas eu d'appel + // à queue_in(). -# 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) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; + pid = getpid(); } - - // 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) - { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; - } - - 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) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } - - for(i = 0; i < nombre_queues; i++) - { - if (sem_close(semaphores[i]) != 0) + else { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; + pid = origine_signal(signal); } - } - - if (sem_close(semaphore_global) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; - } - - return; -} - -void -destruction_fifos_signaux(struct_processus *s_etat_processus) -{ - 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; - } - - unlink(nom); - free(nom); +# else - for(i = 0; i < nombre_queues; i++) - { - if ((nom = nom_semaphore(getpid(), i)) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; - } + /* + * 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 (sem_unlink(nom) != 0) + if (siginfo != NULL) { - (*s_etat_processus).erreur_systeme = d_es_semaphore; - return; + pid = (*siginfo).si_pid; } - - 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); - } - - if ((clef = ftok(nom, 1)) == -1) - { - return(-1); - } - - free(nom); - - if (signal == SIGSTART) - { - while((identifiant = shmget(clef, - nombre_queues * (longueur_queue + 4) * sizeof(int), - S_IRUSR | S_IWUSR)) == -1); - } - else - { - if ((identifiant = shmget(clef, - nombre_queues * (longueur_queue + 4) * sizeof(int), - S_IRUSR | S_IWUSR)) == -1) + else { - return(-1); + pid = getpid(); } - } - - 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); + 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; } -#endif - -#ifdef printf -# undef printf -#endif - -void -interruption1(SIGHANDLER_ARGS) +static void +corps_interruption1(struct_processus *s_etat_processus, int signal, pid_t pid) { - pid_t pid; - - pthread_t thread; - - struct_processus *s_etat_processus; - volatile sig_atomic_t exclusion = 0; - verrouillage_gestionnaire_signaux(); - -# ifdef _BROKEN_SIGINFO - if (signal == SIGINT) - { - // Si l'interruption provient du clavier, il n'y a pas eu d'appel - // à queue_in(). + struct_processus *s_thread_principal; - pid = getpid(); - } - else - { - pid = origine_signal(signal); - } -# else - pid = (*siginfo).si_pid; -# endif + verrouillage_gestionnaire_signaux(); switch(signal) { @@ -2266,13 +1827,6 @@ interruption1(SIGHANDLER_ARGS) { 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(), @@ -2292,9 +1846,13 @@ interruption1(SIGHANDLER_ARGS) } 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; } } @@ -2302,33 +1860,23 @@ interruption1(SIGHANDLER_ARGS) } 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. - */ - -# ifndef _BROKEN_SIGINFO - if (siginfo == NULL) - { - kill(getpid(), signal); - } - 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()); + 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); } @@ -2350,16 +1898,19 @@ interruption1(SIGHANDLER_ARGS) 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; @@ -2369,9 +1920,13 @@ interruption1(SIGHANDLER_ARGS) } 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; } } @@ -2393,49 +1948,59 @@ interruption1(SIGHANDLER_ARGS) void interruption2(SIGHANDLER_ARGS) { - pid_t pid; - - pthread_t thread; - - struct_processus *s_etat_processus; + pid_t pid; - verrouillage_gestionnaire_signaux(); + test_signal(signal); # ifdef _BROKEN_SIGINFO pid = origine_signal(signal); # else - pid = (*siginfo).si_pid; + if (siginfo != NULL) + { + pid = (*siginfo).si_pid; + } + else + { + pid = getpid(); + } # endif -# ifndef _BROKEN_SIGINFO + 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) { - /* - * 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; - } + 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; } - else -# endif + + 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()) { - if ((s_etat_processus = recherche_thread(getpid(), pthread_self())) - == NULL) - { - deverrouillage_gestionnaire_signaux(); - return; - } - /* * 0 => fonctionnement normal * -1 => requête @@ -2462,11 +2027,13 @@ 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; + 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; } } @@ -2477,19 +2044,30 @@ interruption2(SIGHANDLER_ARGS) void interruption3(SIGHANDLER_ARGS) { - 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; + if (pid_processus_pere == getpid()) + { + kill(pid_processus_pere, SIGALRM); + } - verrouillage_gestionnaire_signaux(); + write(STDERR_FILENO, message, strlen(message)); + _exit(EXIT_FAILURE); +} -# ifdef _BROKEN_SIGINFO - pid = origine_signal(signal); -# else - pid = (*siginfo).si_pid; -# endif +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) { @@ -2515,24 +2093,79 @@ 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) { + // 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); } @@ -2545,18 +2178,11 @@ interruption3(SIGHANDLER_ARGS) void interruption4(SIGHANDLER_ARGS) { - pid_t pid; - 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 ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { deverrouillage_gestionnaire_signaux(); @@ -2587,6 +2213,7 @@ interruption5(SIGHANDLER_ARGS) struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); # ifdef _BROKEN_SIGINFO @@ -2653,18 +2280,11 @@ interruption5(SIGHANDLER_ARGS) void interruption6(SIGHANDLER_ARGS) { - pid_t pid; - 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 ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { deverrouillage_gestionnaire_signaux(); @@ -2685,18 +2305,11 @@ interruption6(SIGHANDLER_ARGS) void interruption7(SIGHANDLER_ARGS) { - pid_t pid; - 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 ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { deverrouillage_gestionnaire_signaux(); @@ -2726,6 +2339,7 @@ interruption8(SIGHANDLER_ARGS) struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); # ifdef _BROKEN_SIGINFO @@ -2772,18 +2386,11 @@ interruption8(SIGHANDLER_ARGS) void interruption9(SIGHANDLER_ARGS) { - pid_t pid; - 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 ((s_etat_processus = recherche_thread(getpid(), pthread_self())) == NULL) { deverrouillage_gestionnaire_signaux(); @@ -2817,20 +2424,13 @@ interruption10(SIGHANDLER_ARGS) { file *fichier; - pid_t pid; - struct_processus *s_etat_processus; unsigned char nom[8 + 64 + 1]; + test_signal(signal); verrouillage_gestionnaire_signaux(); -# 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(); @@ -2870,6 +2470,7 @@ interruption11(SIGHANDLER_ARGS) struct_processus *s_etat_processus; + test_signal(signal); verrouillage_gestionnaire_signaux(); # ifdef _BROKEN_SIGINFO @@ -2956,115 +2557,78 @@ traitement_exceptions_gsl(const char *re return; } -#ifdef _BROKEN_SIGINFO - -#undef kill -#undef pthread_kill - -int -kill_broken_siginfo(pid_t pid, int signal) +static inline void +structation_interruptions_elementaires(struct_processus *s_etat_processus, + int signal, pid_t pid) { - int ios; - - sem_t *semaphore; - - unsigned char *nom; - - /* - * 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. - */ - - // Sémaphore acquis - - if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL) - { - return(-1); - } - - if ((semaphore = sem_open(nom, 0)) == SEM_FAILED) - { - free(nom); - return(-1); - } - - free(nom); - - if (sem_wait(semaphore) == -1) + switch(signal) { - return(-1); - } + case SIGINT: + case SIGTERM: + case SIGALRM: + { + corps_interruption1(s_etat_processus, signal, pid); + break; + } - if ((signal != 0) && (signal != SIGINT)) - { - if (queue_in(pid, signal) != 0) + case SIGTSTP: { - sem_post(semaphore); - sem_close(semaphore); - return(-1); + corps_interruption2(s_etat_processus, signal, pid); } } - ios = kill(pid, signal); - - // Sémaphore relâché - - sem_post(semaphore); - sem_close(semaphore); - - return(ios); + return; } -int -pthread_kill_broken_siginfo(pthread_t tid, int signal) +void +scrutation_interruptions(struct_processus *s_etat_processus) { - int ios; - - sem_t *semaphore; + int i; - unsigned char *nom; + // Interruption par processus. - if ((nom = nom_semaphore(getpid(), nombre_queues)) == NULL) + if (pthread_mutex_lock(&mutex_signal) != 0) { - return(-1); + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } - if ((semaphore = sem_open(nom, 0)) == SEM_FAILED) + if (queue_interruptions.nombre_interruptions_en_queue > 0) { - free(nom); - return(-1); - } - - free(nom); + 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. - if (sem_wait(semaphore) == -1) - { - return(-1); + 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 ((signal != 0) && (signal != SIGINT)) + if (pthread_mutex_unlock(&mutex_signal) != 0) { - if (queue_in(getpid(), signal) != 0) - { - sem_post(semaphore); - sem_close(semaphore); - return(-1); - } + (*s_etat_processus).erreur_systeme = d_es_processus; + return; } - ios = pthread_kill(tid, signal); + // Interruption par thread - sem_post(semaphore); - sem_close(semaphore); + 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(ios); + return; } -#endif - // vim: ts=4