--- rpl/src/gestion_processus.c 2010/04/07 13:45:03 1.6 +++ rpl/src/gestion_processus.c 2013/02/23 15:20:21 1.59 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.14 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.12 + Copyright (C) 1989-2012 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -53,11 +53,10 @@ surveillance_processus(void *argument) pid_t pid; pid_t pid_candidat; + pid_t pid_erreur; pthread_t tid_candidat; - sigset_t masque; - ssize_t longueur_ecriture; struct_descripteur_thread *s_argument_thread; @@ -71,21 +70,31 @@ surveillance_processus(void *argument) unsigned char caractere; - unsigned int tampon_erreur; + unsigned int tampon_erreur_execution; + unsigned int tampon_erreur_systeme; + + sigset_t set; - sigemptyset(&masque); - sigaddset(&masque, SIGINJECT); - sigaddset(&masque, SIGFSTOP); - sigaddset(&masque, SIGURG); - sigaddset(&masque, SIGALRM); - sigaddset(&masque, SIGCONT); - sigaddset(&masque, SIGINT); - pthread_sigmask(SIG_BLOCK, &masque, NULL); + sigfillset(&set); + pthread_sigmask(SIG_BLOCK, &set, NULL); s_argument_thread = argument; s_etat_processus = (*s_argument_thread).s_etat_processus; + + if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + BUG(1, uprintf("General mutex error!\n")); + } + insertion_thread_surveillance(s_etat_processus, s_argument_thread); + if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + BUG(1, uprintf("General mutex error!\n")); + } + attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; @@ -328,8 +337,8 @@ surveillance_processus(void *argument) d_es_processus; } - pthread_kill((*s_argument_thread).thread_pere, - SIGINJECT); + envoi_signal_thread((*s_argument_thread).thread_pere, + rpl_siginject); } } else @@ -514,8 +523,8 @@ surveillance_processus(void *argument) d_es_processus; } - pthread_kill((*s_argument_thread).thread_pere, - SIGINJECT); + envoi_signal_thread((*s_argument_thread).thread_pere, + rpl_siginject); } } else @@ -713,7 +722,7 @@ surveillance_processus(void *argument) } BUG(l_element_courant == NULL, - printf("Process or thread not found")); + printf("Process or thread not found\n")); if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) @@ -909,6 +918,9 @@ surveillance_processus(void *argument) (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus; } + + envoi_signal_thread((*s_argument_thread).thread_pere, + rpl_siginject); } } else @@ -1428,7 +1440,7 @@ surveillance_processus(void *argument) attente.tv_nsec = GRANULARITE_us * 1000; while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], - &((*s_etat_processus).erreur_execution_processus_fils), + &tampon_erreur_execution, sizeof((*s_etat_processus).erreur_execution_processus_fils)) != sizeof((*s_etat_processus).erreur_execution_processus_fils)) { @@ -1440,7 +1452,7 @@ surveillance_processus(void *argument) attente.tv_nsec = GRANULARITE_us * 1000; while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], - &tampon_erreur, + &tampon_erreur_systeme, sizeof((*s_etat_processus).erreur_systeme_processus_fils)) != sizeof((*s_etat_processus).erreur_systeme_processus_fils)) { @@ -1448,13 +1460,11 @@ surveillance_processus(void *argument) INCR_GRANULARITE(attente.tv_nsec); } - (*s_etat_processus).erreur_systeme_processus_fils = tampon_erreur; - attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; while(read_atomic(s_etat_processus, (*s_argument_thread).pipe_erreurs[0], - &((*s_etat_processus).pid_erreur_processus_fils), + &pid_erreur, sizeof((*s_etat_processus).pid_erreur_processus_fils)) != sizeof((*s_etat_processus).pid_erreur_processus_fils)) { @@ -1463,18 +1473,6 @@ surveillance_processus(void *argument) } /* - * Si une erreur est déclarée dans le processus fils, le message - * d'erreur a déjà été affiché. - */ - - if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) || - ((*s_etat_processus).erreur_execution_processus_fils != d_ex)) - { - (*s_etat_processus).erreur_processus_fils = d_vrai; - (*s_etat_processus).invalidation_message_erreur = d_vrai; - } - - /* * Retrait du processus de la pile des processus */ @@ -1489,6 +1487,24 @@ surveillance_processus(void *argument) } else { + (*s_etat_processus).erreur_execution_processus_fils = + tampon_erreur_execution; + (*s_etat_processus).erreur_systeme_processus_fils = + tampon_erreur_systeme; + (*s_etat_processus).pid_erreur_processus_fils = pid_erreur; + + /* + * Si une erreur est déclarée dans le processus fils, le message + * d'erreur a déjà été affiché. + */ + + if (((*s_etat_processus).erreur_systeme_processus_fils != d_es) || + ((*s_etat_processus).erreur_execution_processus_fils != d_ex)) + { + (*s_etat_processus).erreur_processus_fils = d_vrai; + (*s_etat_processus).invalidation_message_erreur = d_vrai; + } + do { drapeau_fin = d_faux; @@ -1752,19 +1768,16 @@ surveillance_processus(void *argument) { (*s_etat_processus).l_base_pile_processus = (*l_element_courant).suivant; - - free(l_element_courant); - - l_element_courant = (struct_liste_chainee *) - (*s_etat_processus).l_base_pile_processus; } else { (*l_element_precedent).suivant = (*l_element_courant).suivant; - free(l_element_courant); } + liberation(s_etat_processus, (*l_element_courant).donnee); + free(l_element_courant); + break; } else @@ -1774,53 +1787,55 @@ surveillance_processus(void *argument) } } - if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus; - } - } - - if ((*s_etat_processus).debug == d_vrai) - if (((*s_etat_processus).type_debug & - d_debug_processus) != 0) - { - if ((*s_argument_thread).processus_detache == d_vrai) + if ((*s_etat_processus).debug == d_vrai) + if (((*s_etat_processus).type_debug & + d_debug_processus) != 0) { - if ((*s_etat_processus).langue == 'F') + if ((*s_argument_thread).processus_detache == d_vrai) { - printf("[%d] Arrêt du thread de surveillance du" - " processus %d\n", (int) getpid(), - (int) (*s_argument_thread).pid); + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Arrêt du thread de surveillance du" + " processus %d\n", (int) getpid(), + (int) (*s_argument_thread).pid); + } + else + { + printf("[%d] Stop monitoring of process %d", (int) getpid(), + (int) (*s_argument_thread).pid); + } } else { - printf("[%d] Stop monitoring of process %d", (int) getpid(), - (int) (*s_argument_thread).pid); + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Arrêt du thread de surveillance du" + " thread %llu\n", (int) getpid(), + (unsigned long long) (*s_argument_thread) + .tid); + } + else + { + printf("[%d] Stop monitoring of thread %llu", + (int) getpid(), + (unsigned long long) (*s_argument_thread) + .tid); + } } + + fflush(stdout); } - else + + retrait_thread_surveillance(s_etat_processus, s_argument_thread); + + if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) { - if ((*s_etat_processus).langue == 'F') - { - printf("[%d] Arrêt du thread de surveillance du" - " thread %llu\n", (int) getpid(), - (unsigned long long) (*s_argument_thread) - .tid); - } - else - { - printf("[%d] Stop monitoring of thread %llu", (int) getpid(), - (unsigned long long) (*s_argument_thread) - .tid); - } + (*s_etat_processus).erreur_systeme_processus_fils = d_es_processus; } - - fflush(stdout); } - retrait_thread_surveillance(s_etat_processus, s_argument_thread); - pthread_exit(NULL); + return(NULL); } @@ -3378,28 +3393,46 @@ lecture_pipe(struct_processus *s_etat_pr ================================================================================ */ -inline void +void scrutation_injection(struct_processus *s_etat_processus) { fd_set ensemble_descripteurs; - struct timespec timeout; + logical1 drapeau_erreur; + logical1 registre_arret_si_exception; + +# ifdef PSELECT + struct timespec timeout; +# else + struct timeval timeout; +# endif unsigned char tampon; + unsigned char tampon_profilage[20]; // Si on est dans le processus père, il n'y a rien à surveiller. - if ((*s_etat_processus).var_volatile_processus_pere == 0) + scrutation_interruptions(s_etat_processus); + + if ((*s_etat_processus).var_volatile_processus_racine == 0) { FD_ZERO(&ensemble_descripteurs); FD_SET((*s_etat_processus).pipe_nombre_injections, &ensemble_descripteurs); +# ifdef PSELECT timeout.tv_sec = 0; timeout.tv_nsec = 0; if (pselect((*s_etat_processus).pipe_nombre_injections + 1, &ensemble_descripteurs, NULL, NULL, &timeout, NULL) > 0) +# else + timeout.tv_sec = 0; + timeout.tv_usec = 0; + + if (select((*s_etat_processus).pipe_nombre_injections + 1, + &ensemble_descripteurs, NULL, NULL, &timeout) > 0) +# endif { if (read_atomic(s_etat_processus, (*s_etat_processus).pipe_nombre_injections, @@ -3424,6 +3457,139 @@ scrutation_injection(struct_processus *s } } } + + /* + * Traitement de l'interruption d'injection + */ + + if (((*s_etat_processus).nombre_objets_injectes != 0) && + ((*s_etat_processus).traitement_at_poke == 'N')) + { + if ((*s_etat_processus).at_poke != NULL) + { + registre_arret_si_exception = + (*s_etat_processus).arret_si_exception; + (*s_etat_processus).arret_si_exception = d_vrai; + + if ((*s_etat_processus).debug == d_vrai) + if (((*s_etat_processus).type_debug & + d_traitement_interruption) != 0) + { + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Traitement de l'interruption " + "d'injection\n", (int) getpid()); + } + else + { + printf("[%d] Start injection interrupt\n", + (int) getpid()); + } + + fflush(stdout); + } + + if ((*s_etat_processus).profilage == d_vrai) + { + sprintf(tampon_profilage, "Injection interrupt"); + profilage(s_etat_processus, tampon_profilage); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + return; + } + } + + (*s_etat_processus).traitement_at_poke = 'Y'; + drapeau_erreur = evaluation(s_etat_processus, + (*s_etat_processus).at_poke, 'E'); + (*s_etat_processus).traitement_at_poke = 'N'; + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, NULL); + } + + if (drapeau_erreur == d_absence_erreur) + { + (*s_etat_processus).arret_si_exception = + registre_arret_si_exception; + } + else + { + if ((((*s_etat_processus).erreur_execution != d_ex) || + ((*s_etat_processus).exception != d_ep) || + ((*s_etat_processus).erreur_systeme != d_es)) && + ((*s_etat_processus).core == d_vrai) && + ((*s_etat_processus) + .var_volatile_traitement_sigint == 0)) + { + printf("\n"); + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Information : " + "Génération du fichier rpl-core " + "[%d]\n", (int) getpid()); + } + else + { + printf("+++Information : " + "Writing rpl-core file [%d]\n", + (int) getpid()); + } + + rplcore(s_etat_processus); + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Information : " + "Processus tracé [%d]\n", + (int) getpid()); + } + else + { + printf("+++Information : Done [%d]\n", + (int) getpid()); + } + + printf("\n"); + fflush(stdout); + } + + } + + if ((*s_etat_processus).debug == d_vrai) + if (((*s_etat_processus).type_debug & + d_traitement_interruption) != 0) + { + if ((*s_etat_processus).langue == 'F') + { + printf("[%d] Fin de l'interruption d'injection\n", + (int) getpid()); + } + else + { + printf("[%d] Stop injection interrupt\n", + (int) getpid()); + } + + fflush(stdout); + } + + if ((drapeau_erreur == d_erreur) && + ((*s_etat_processus).erreur_execution == d_ex)) + { + if (((*s_etat_processus).erreur_execution == d_ex) && + ((*s_etat_processus).erreur_systeme == d_es)) + { + (*s_etat_processus).erreur_execution = + d_ex_erreur_evaluation; + } + } + } + } + } return; @@ -3432,7 +3598,7 @@ scrutation_injection(struct_processus *s /* ================================================================================ - Fonction de test du draeau d'arrêt + Fonction de test du drapeau d'arrêt ================================================================================ Entrées : pointeur sur une structure -------------------------------------------------------------------------------- @@ -3442,7 +3608,8 @@ scrutation_injection(struct_processus *s ================================================================================ */ -inline int test_arret(struct_processus *s_etat_processus) +int +test_arret(struct_processus *s_etat_processus) { return((int) (*s_etat_processus).var_volatile_requete_arret); }