--- rpl/src/gestion_processus.c 2010/01/26 15:22:45 1.1 +++ rpl/src/gestion_processus.c 2013/03/21 16:34:08 1.64 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.9 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.13 + Copyright (C) 1989-2013 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,7 +20,7 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* @@ -40,7 +40,6 @@ void * surveillance_processus(void *argument) { - int iostat; int status; integer8 nombre_donnees; @@ -53,11 +52,11 @@ surveillance_processus(void *argument) pid_t pid; pid_t pid_candidat; + pid_t pid_erreur; pthread_t tid_candidat; - sigset_t masque; - + ssize_t iostat; 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; + int tampon_erreur_execution; + 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); } @@ -1845,8 +1860,8 @@ ecriture_pipe(struct_processus *s_etat_p struct timespec attente; - unsigned long i; - unsigned long j; + integer8 i; + integer8 j; size_t longueur; ssize_t longueur_ecriture; @@ -1976,7 +1991,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) (*s_objet).objet)) - .taille), sizeof(unsigned long))) != sizeof(unsigned long)) + .taille), sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2029,7 +2044,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) (*s_objet).objet)) - .taille), sizeof(unsigned long))) != sizeof(unsigned long)) + .taille), sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2082,7 +2097,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) (*s_objet).objet)) - .taille), sizeof(unsigned long))) != sizeof(unsigned long)) + .taille), sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2135,7 +2150,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2151,7 +2166,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2210,7 +2225,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2226,7 +2241,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2285,7 +2300,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2301,7 +2316,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2495,7 +2510,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_fonction *) (*s_objet).objet)).nombre_arguments), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2637,7 +2652,7 @@ ecriture_pipe(struct_processus *s_etat_p while((longueur_ecriture = write_atomic(s_etat_processus, pipe, &((*((struct_tableau *) (*s_objet).objet)).nombre_elements), - sizeof(unsigned long))) != sizeof(unsigned long)) + sizeof(integer8))) != sizeof(integer8)) { if (longueur_ecriture == -1) { @@ -2693,8 +2708,8 @@ lecture_pipe(struct_processus *s_etat_pr struct timespec attente; - unsigned long i; - unsigned long j; + integer8 i; + integer8 j; if ((s_objet = allocation(s_etat_processus, NON)) == NULL) { @@ -2781,15 +2796,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) (*s_objet).objet)).taille), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_vecteur *) (*s_objet).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet).objet)).taille * - sizeof(integer8))) == NULL) + malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet)) + .taille) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -2825,15 +2840,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) (*s_objet).objet)).taille), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_vecteur *) (*s_objet).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet).objet)).taille * - sizeof(real8))) == NULL) + malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet)) + .taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -2869,15 +2884,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_vecteur *) (*s_objet).objet)).taille), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_vecteur *) (*s_objet).objet)).tableau = - malloc((*((struct_vecteur *) (*s_objet).objet)).taille * - sizeof(complex16))) == NULL) + malloc(((size_t) (*((struct_vecteur *) (*s_objet).objet)) + .taille) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -2913,7 +2928,7 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); @@ -2924,15 +2939,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_matrice *) (*s_objet).objet)).tableau = - malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes * - sizeof(integer8 *))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) + .nombre_lignes) * sizeof(integer8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -2942,8 +2957,8 @@ lecture_pipe(struct_processus *s_etat_pr (*s_objet).objet)).nombre_lignes; i++) { if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet).objet)) - .nombre_colonnes * sizeof(integer8))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) + .nombre_colonnes) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -2981,7 +2996,7 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); @@ -2992,15 +3007,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_matrice *) (*s_objet).objet)).tableau = - malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes * - sizeof(real8 *))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) + .nombre_lignes) * sizeof(real8 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -3010,8 +3025,8 @@ lecture_pipe(struct_processus *s_etat_pr (*s_objet).objet)).nombre_lignes; i++) { if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet).objet)) - .nombre_colonnes * sizeof(real8))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) + .nombre_colonnes) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -3049,7 +3064,7 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_lignes), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); @@ -3060,15 +3075,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_matrice *) (*s_objet).objet)).nombre_colonnes), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_matrice *) (*s_objet).objet)).tableau = - malloc((*((struct_matrice *) (*s_objet).objet)).nombre_lignes * - sizeof(complex16 *))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) + .nombre_lignes) * sizeof(complex16 *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -3078,8 +3093,8 @@ lecture_pipe(struct_processus *s_etat_pr (*s_objet).objet)).nombre_lignes; i++) { if ((((*((struct_matrice *) (*s_objet).objet)).tableau)[i] = - malloc((*((struct_matrice *) (*s_objet).objet)) - .nombre_colonnes * sizeof(complex16))) == NULL) + malloc(((size_t) (*((struct_matrice *) (*s_objet).objet)) + .nombre_colonnes) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -3207,8 +3222,8 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_fonction *) (*s_objet).objet)) - .nombre_arguments), sizeof(unsigned long)) != - sizeof(unsigned long)) + .nombre_arguments), sizeof(integer8)) != + sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); @@ -3328,15 +3343,15 @@ lecture_pipe(struct_processus *s_etat_pr while(read_atomic(s_etat_processus, pipe, &((*((struct_tableau *) (*s_objet).objet)).nombre_elements), - sizeof(unsigned long)) != sizeof(unsigned long)) + sizeof(integer8)) != sizeof(integer8)) { nanosleep(&attente, NULL); INCR_GRANULARITE(attente.tv_nsec); } if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc( - (*((struct_tableau *) (*s_objet).objet)).nombre_elements * - sizeof(struct_objet *))) == NULL) + ((size_t) (*((struct_tableau *) (*s_objet).objet)) + .nombre_elements) * sizeof(struct_objet *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 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); }