--- rpl/src/interruptions.c 2012/08/22 10:47:18 1.101 +++ rpl/src/interruptions.c 2017/01/18 15:44:23 1.191 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.10 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.26 + Copyright (C) 1989-2017 Dr. BERTRAND Joël This file is part of RPL/2. @@ -60,19 +60,17 @@ static volatile int code_erreur_g unsigned char *racine_segment; -static pthread_mutex_t mutex_interruptions - = PTHREAD_MUTEX_INITIALIZER; - static void * thread_surveillance_signaux(void *argument) { // Cette fonction est lancée dans un thread créé par processus pour // gérer le cas des appels système qui seraient bloqués lors de l'arrivée du - // signal SIGALRM. Les processus externes n'envoient plus un signal au + // signal SIGUSR2. Les processus externes n'envoient plus un signal au // processus ou au thread à signaler mais positionnent les informations // nécessaires dans la queue des signaux et incrémentent le sémaphore. // Le sémaphore est décrémenté lorsque le signal est effectivement traité. + int ios; int nombre_signaux_envoyes; struct_processus *s_etat_processus; @@ -81,6 +79,11 @@ thread_surveillance_signaux(void *argume volatile struct_liste_chainee_volatile *l_element_courant; + sigset_t set; + + sigfillset(&set); + pthread_sigmask(SIG_BLOCK, &set, NULL); + s_etat_processus = (struct_processus *) argument; for(;;) @@ -88,53 +91,65 @@ thread_surveillance_signaux(void *argume attente.tv_sec = 0; attente.tv_nsec = GRANULARITE_us * 1000; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - if (sem_wait(&(*s_queue_signaux).signalisation) == 0) -# else - if(sem_wait(semaphore_signalisation) == 0) -# endif + if (sem_wait(semaphore_signalisation) == 0) { + while((ios = sem_wait(semaphore_arret_signalisation)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } + if ((*s_queue_signaux).requete_arret == d_vrai) { + sem_post(semaphore_arret_signalisation); + sem_post(semaphore_signalisation); + break; } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&(*s_queue_signaux).signalisation); -# else sem_post(semaphore_signalisation); -# endif nombre_signaux_envoyes = 0; - sched_yield(); // Dans un premier temps, on verrouille la queue des signaux // affectée au processus courant pour vérifier s'il y a quelque // chose à traiter. -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&(*s_queue_signaux).semaphore); -# else - sem_wait(semaphore_queue_signaux); -# endif + while((ios = sem_wait(semaphore_queue_signaux)) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } + } if ((*s_queue_signaux).pointeur_lecture != (*s_queue_signaux).pointeur_ecriture) { + // Attention : raise() envoit le signal au thread appelant ! + // kill() l'envoie au processus appelant, donc dans notre + // cas à un thread aléatoire du processus, ce qui nous + // convient tout à fait puisqu'il s'agit de débloquer les + // appels système lents. + nombre_signaux_envoyes++; - raise(SIGALRM); + kill(getpid(), SIGUSR2); + sched_yield(); } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&(*s_queue_signaux).semaphore); -# else sem_post(semaphore_queue_signaux); -# endif + sem_post(semaphore_arret_signalisation); // Dans un second temps, on balaye toutes les queues de signaux // des threads du processus courant. + // Attention : l'ordre de verrouillage des mutexes est important + // pour éviter les conditions bloquantes ! + pthread_mutex_lock(&mutex_liste_threads); + l_element_courant = liste_threads; while(l_element_courant != NULL) @@ -142,15 +157,24 @@ thread_surveillance_signaux(void *argume if ((*((struct_thread *) (*l_element_courant).donnee)).pid == getpid()) { + pthread_mutex_lock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); + if ((*(*((struct_thread *) (*l_element_courant).donnee)) .s_etat_processus).pointeur_signal_ecriture != - (*(*((struct_thread *) (*l_element_courant).donnee)) - .s_etat_processus).pointeur_signal_lecture) + (*(*((struct_thread *) (*l_element_courant) + .donnee)).s_etat_processus).pointeur_signal_lecture) { nombre_signaux_envoyes++; - pthread_kill((*((struct_thread *) (*l_element_courant) - .donnee)).tid, SIGALRM); + pthread_kill((*((struct_thread *) + (*l_element_courant).donnee)).tid, SIGUSR2); + sched_yield(); } + + pthread_mutex_unlock(&((*(*((struct_thread *) + (*l_element_courant).donnee)).s_etat_processus) + .mutex_signaux)); } l_element_courant = (*l_element_courant).suivant; @@ -167,7 +191,10 @@ thread_surveillance_signaux(void *argume } else { - (*s_etat_processus).erreur_systeme = d_es_processus; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + } } } @@ -325,11 +352,14 @@ retrait_thread(struct_processus *s_etat_ (*l_element_courant).donnee)).s_etat_processus) .pointeur_signal_lecture) { -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&((*s_queue_signaux).signalisation)); -# else - sem_wait(semaphore_signalisation); -# endif + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } (*(*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus) .pointeur_signal_lecture = ((*(*((struct_thread *) @@ -528,7 +558,13 @@ liberation_threads(struct_processus *s_e struct_processus *candidat; - unsigned long i; + struct_liste_variables_partagees *l_element_partage_courant; + struct_liste_variables_partagees *l_element_partage_suivant; + + struct_liste_variables_statiques *l_element_statique_courant; + struct_liste_variables_statiques *l_element_statique_suivant; + + integer8 i; void *element_candidat; void *element_courant; @@ -571,8 +607,7 @@ liberation_threads(struct_processus *s_e close((*s_etat_processus).pipe_injections); close((*s_etat_processus).pipe_nombre_injections); close((*s_etat_processus).pipe_interruptions); - close((*s_etat_processus).pipe_nombre_objets_attente); - close((*s_etat_processus).pipe_nombre_interruptions_attente); + close((*s_etat_processus).pipe_nombre_elements_attente); liberation(s_etat_processus, (*s_etat_processus).at_exit); @@ -640,10 +675,8 @@ liberation_threads(struct_processus *s_e 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_nombre_elements_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) @@ -743,55 +776,41 @@ liberation_threads(struct_processus *s_e } } - 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++) - { - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables_statiques[i].objet).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_statiques[i].objet).mutex)); - - liberation(s_etat_processus, (*s_etat_processus) - .s_liste_variables_statiques[i].objet); - free((*s_etat_processus).s_liste_variables_statiques[i].nom); - } - - free((*s_etat_processus).s_liste_variables_statiques); - // Ne peut être effacé qu'une seule fois if (suppression_variables_partagees == d_faux) { suppression_variables_partagees = d_vrai; - for(i = 0; i < (*(*s_etat_processus) - .s_liste_variables_partagees).nombre_variables; i++) - { - pthread_mutex_trylock(&((*(*(*s_etat_processus) - .s_liste_variables_partagees).table[i].objet) - .mutex)); - pthread_mutex_unlock(&((*(*(*s_etat_processus) - .s_liste_variables_partagees).table[i].objet) - .mutex)); + liberation_arbre_variables_partagees(s_etat_processus, + (*(*s_etat_processus).s_arbre_variables_partagees)); + (*(*s_etat_processus).s_arbre_variables_partagees) = NULL; - liberation(s_etat_processus, (*(*s_etat_processus) - .s_liste_variables_partagees).table[i].objet); - free((*(*s_etat_processus).s_liste_variables_partagees) - .table[i].nom); - } + l_element_partage_courant = (*(*s_etat_processus) + .l_liste_variables_partagees); - if ((*(*s_etat_processus).s_liste_variables_partagees).table - != NULL) + while(l_element_partage_courant != NULL) { - free((struct_variable_partagee *) (*(*s_etat_processus) - .s_liste_variables_partagees).table); + l_element_partage_suivant = + (*l_element_partage_courant).suivant; + free(l_element_partage_courant); + l_element_partage_courant = l_element_partage_suivant; } - pthread_mutex_trylock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); - pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)); + (*(*s_etat_processus).l_liste_variables_partagees) = NULL; + } + + liberation_arbre_variables(s_etat_processus, + (*s_etat_processus).s_arbre_variables, d_faux); + + l_element_statique_courant = (*s_etat_processus) + .l_liste_variables_statiques; + + while(l_element_statique_courant != NULL) + { + l_element_statique_suivant = + (*l_element_statique_courant).suivant; + free(l_element_statique_courant); + l_element_statique_courant = l_element_statique_suivant; } element_courant = (*s_etat_processus).l_base_pile; @@ -1259,7 +1278,8 @@ liberation_threads(struct_processus *s_e # endif liberation_contexte_cas(s_etat_processus); - free(s_etat_processus); + liberation_allocateur_buffer(s_etat_processus); + sys_free(s_etat_processus); s_etat_processus = candidat; } @@ -1301,9 +1321,8 @@ liberation_threads(struct_processus *s_e 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_nombre_elements_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) @@ -1361,6 +1380,11 @@ recherche_thread(pid_t pid, pthread_t ti struct_processus *s_etat_processus; + if (pthread_mutex_lock(&mutex_liste_threads) != 0) + { + return(NULL); + } + l_element_courant = liste_threads; while(l_element_courant != NULL) @@ -1381,12 +1405,18 @@ recherche_thread(pid_t pid, pthread_t ti * Le processus n'existe plus. On ne distribue aucun signal. */ + pthread_mutex_unlock(&mutex_liste_threads); return(NULL); } s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)).s_etat_processus; + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + return(NULL); + } + return(s_etat_processus); } @@ -1442,8 +1472,6 @@ recherche_thread_principal(pid_t pid) static inline void verrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) { - int semaphore; - # ifndef SEMAPHORES_NOMMES if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else @@ -1454,172 +1482,179 @@ verrouillage_gestionnaire_signaux(struct return; } - // Il faut respecteur l'atomicité des deux opérations suivantes ! - - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } + return; +} +static inline void +deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) +{ # ifndef SEMAPHORES_NOMMES - if (sem_post(&semaphore_gestionnaires_signaux) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_post(semaphore_gestionnaires_signaux) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Lock error !\n")); - return; + if (errno != EINTR) + { + BUG(1, uprintf("Unlock error !\n")); + return; + } } -# ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) -# else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) -# endif + return; +} + +/* +================================================================================ + Fonctions de gestion des signaux dans les threads. + + Lorsqu'un processus reçoit un signal, il appelle le gestionnaire de signal + associé qui ne fait qu'envoyer au travers de write() le signal + reçus dans un pipe. Un second thread est bloqué sur ce pipe et + effectue le traitement adéquat pour le signal donné. +================================================================================ +*/ + +#define test_signal(signal) \ + if (signal_test == SIGTEST) { signal_test = signal; return; } + +static int pipe_signaux; + +logical1 +lancement_thread_signaux(struct_processus *s_etat_processus) +{ + pthread_attr_t attributs; + + if (pipe((*s_etat_processus).pipe_signaux) != 0) { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Lock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) + pipe_signaux = (*s_etat_processus).pipe_signaux[1]; + + if (pthread_attr_init(&attributs) != 0) { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - if (semaphore == 1) + if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0) { - // Le semaphore ne peut être pris par le thread qui a appelé - // le gestionnaire de signal car le signal est bloqué par ce thread - // dans les zones critiques. Ce sémaphore ne peut donc être bloqué que - // par un thread concurrent. On essaye donc de le bloquer jusqu'à - // ce que ce soit possible. + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } - if (pthread_mutex_lock(&mutex_liste_threads) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Lock error !\n")); - return; - } + if (pthread_create(&((*s_etat_processus).thread_signaux), &attributs, + thread_signaux, s_etat_processus) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); } - return; + if (pthread_attr_destroy(&attributs) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return(d_erreur); + } + + return(d_absence_erreur); } -static inline void -deverrouillage_gestionnaire_signaux(struct_processus *s_etat_processus) +logical1 +arret_thread_signaux(struct_processus *s_etat_processus) { - int semaphore; + unsigned char signal; + ssize_t n; - // Il faut respecteur l'atomicité des deux opérations suivantes ! + signal = (unsigned char ) (rpl_sigmax & 0xFF); - if (pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique) == -1) + do { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } + n = write_atomic(s_etat_processus, (*s_etat_processus).pipe_signaux[1], + &signal, sizeof(signal)); -# ifndef SEMAPHORES_NOMMES - if (sem_getvalue(&semaphore_gestionnaires_signaux, &semaphore) != 0) -# else - if (sem_getvalue(semaphore_gestionnaires_signaux, &semaphore) != 0) -# endif - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } + if (n < 0) + { + return(d_erreur); + } + } while(n != 1); -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&semaphore_gestionnaires_signaux) == -1) -# else - while(sem_wait(semaphore_gestionnaires_signaux) == -1) -# endif + pthread_join((*s_etat_processus).thread_signaux, NULL); + + close((*s_etat_processus).pipe_signaux[1]); + return(d_absence_erreur); +} + +void * +thread_signaux(void *argument) +{ + int *pipe; + + sigset_t masque; + + struct pollfd fds; + + struct_processus *s_etat_processus; + + unsigned char signal; + + s_etat_processus = (struct_processus *) argument; + pipe = (*s_etat_processus).pipe_signaux; + fds.fd = pipe[0]; + fds.events = POLLIN; + + sigfillset(&masque); + pthread_sigmask(SIG_BLOCK, &masque, NULL); + + do { - if (errno != EINTR) + fds.revents = 0; + + while(poll(&fds, 1, -1) == -1) { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; + if (errno != EINTR) + { + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); + } } - } - if (pthread_mutex_unlock(&mutex_gestionnaires_signaux_atomique) != 0) - { -# ifndef SEMAPHORES_NOMMES - sem_wait(&((*s_etat_processus).semaphore_fork)); -# else - sem_wait((*s_etat_processus).semaphore_fork); -# endif - BUG(1, uprintf("Unlock error !\n")); - return; - } + if (read_atomic(s_etat_processus, fds.fd, &signal, 1) != 1) + { + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); + } -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) -# else - while(sem_wait((*s_etat_processus).semaphore_fork) != 0) -# endif - { - if (errno != EINTR) + if (signal != (0xFF & rpl_sigmax)) { - BUG(1, uprintf("Unlock error !\n")); - return; + envoi_signal_processus(getpid(), signal, d_faux); + // Un signal SIGUSR2 est envoyé par le thread de surveillance + // des signaux jusqu'à ce que les signaux soient tous traités. } - } + } while(signal != (0xFF & rpl_sigmax)); + + close((*s_etat_processus).pipe_signaux[0]); + pthread_exit(NULL); +} + + +static inline void +_write(int fd, const void *buf, size_t count) +{ + ssize_t ios; - if (semaphore == 1) + while((ios = write(fd, buf, count)) == -1) { - if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + if (errno != EINTR) { - BUG(1, uprintf("Unlock error !\n")); - return; + break; } } return; } -#define test_signal(signal) \ - if (signal_test == SIGTEST) { signal_test = signal; return; } // Récupération des signaux // - SIGINT (arrêt au clavier) @@ -1628,26 +1663,138 @@ deverrouillage_gestionnaire_signaux(stru void interruption1(int signal) { + unsigned char signal_tronque; + test_signal(signal); switch(signal) { case SIGINT: - envoi_signal_processus(getpid(), rpl_sigint); + signal_tronque = (unsigned char) (rpl_sigint & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); break; case SIGTERM: - envoi_signal_processus(getpid(), rpl_sigterm); + signal_tronque = (unsigned char) (rpl_sigterm & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); break; case SIGUSR1: - envoi_signal_processus(getpid(), rpl_sigalrm); + signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + break; + + default: + // SIGUSR2 break; } return; } +// Récupération des signaux +// - SIGFSTP +// +// ATTENTION : +// Le signal SIGFSTP provient de la mort du processus de contrôle. +// Sous certains systèmes (Linux...), la mort du terminal de contrôle +// se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres +// (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo +// non initialisée (pointeur NULL) issue de TERMIO. + +void +interruption2(int signal) +{ + unsigned char signal_tronque; + + test_signal(signal); + + signal_tronque = (unsigned char) (rpl_sigtstp & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + + return; +} + +void +interruption3(int signal) +{ + // 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_1[] = "+++System : Uncaught access violation\n" + "+++System : Aborting !\n"; + unsigned char message_2[] = "+++System : Stack overflow\n" + "+++System : Aborting !\n"; + + test_signal(signal); + + if (pid_processus_pere == getpid()) + { + kill(pid_processus_pere, SIGUSR1); + } + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + if (signal != SIGUSR2) + { + write(STDERR_FILENO, message_1, strlen(message_1)); + } + else + { + write(STDERR_FILENO, message_2, strlen(message_2)); + } + +# pragma GCC diagnostic pop + + _exit(EXIT_FAILURE); +} + +// Récupération des signaux +// - SIGHUP + +void +interruption4(int signal) +{ + unsigned char signal_tronque; + + test_signal(signal); + + signal_tronque = (unsigned char) (rpl_sighup & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + + return; +} + +// Récupération des signaux +// - SIGPIPE + +void +interruption5(int signal) +{ + unsigned char message[] = "+++System : SIGPIPE\n" + "+++System : Aborting !\n"; + unsigned char signal_tronque; + + test_signal(signal); + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + + if (pid_processus_pere == getpid()) + { + signal_tronque = (unsigned char) (rpl_sigalrm & 0xFF); + _write(pipe_signaux, &signal_tronque, sizeof(signal_tronque)); + } + + write(STDERR_FILENO, message, strlen(message)); + +# pragma GCC diagnostic pop + + return; +} + inline static void signal_alrm(struct_processus *s_etat_processus, pid_t pid) { @@ -1672,7 +1819,7 @@ signal_alrm(struct_processus *s_etat_pro { // On n'est pas dans le processus père, on remonte le signal. envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigalrm); + rpl_sigalrm, d_faux); } else { @@ -1717,7 +1864,7 @@ signal_term(struct_processus *s_etat_pro if ((*s_etat_processus).pid_processus_pere != getpid()) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigterm); + rpl_sigterm, d_faux); } else { @@ -1771,7 +1918,7 @@ signal_int(struct_processus *s_etat_proc if ((*s_etat_processus).pid_processus_pere != getpid()) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigint); + rpl_sigint, d_faux); } else { @@ -1817,24 +1964,6 @@ signal_int(struct_processus *s_etat_proc return; } -// Récupération des signaux -// - SIGFSTP -// -// ATTENTION : -// Le signal SIGFSTP provient de la mort du processus de contrôle. -// Sous certains systèmes (Linux...), la mort du terminal de contrôle -// se traduit par l'envoi d'un SIGHUP au processus. Sur d'autres -// (SunOS), le processus reçoit un SIGFSTP avec une structure siginfo -// non initialisée (pointeur NULL) issue de TERMIO. - -void -interruption2(int signal) -{ - test_signal(signal); - envoi_signal_processus(getpid(), rpl_sigtstp); - return; -} - static inline void signal_tstp(struct_processus *s_etat_processus, pid_t pid) { @@ -1860,7 +1989,7 @@ signal_tstp(struct_processus *s_etat_pro if ((*s_etat_processus).var_volatile_processus_pere == 0) { envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigtstp); + rpl_sigtstp, d_faux); } else { @@ -1882,38 +2011,6 @@ signal_tstp(struct_processus *s_etat_pro return; } -void -interruption3(int signal) -{ - // 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_1[] = "+++System : Uncaught access violation\n" - "+++System : Aborting !\n"; - unsigned char message_2[] = "+++System : Stack overflow\n" - "+++System : Aborting !\n"; - - test_signal(signal); - - if (pid_processus_pere == getpid()) - { - kill(pid_processus_pere, SIGUSR1); - } - - if (signal != SIGUSR2) - { - write(STDERR_FILENO, message_1, strlen(message_1)); - } - else - { - write(STDERR_FILENO, message_2, strlen(message_2)); - } - - _exit(EXIT_FAILURE); -} - - static void sortie_interruption_depassement_pile(void *arg1, void *arg2, void *arg3) { @@ -1931,7 +2028,7 @@ sortie_interruption_depassement_pile(voi return; } - +#ifdef HAVE_SIGSEGV_RECOVERY void interruption_depassement_pile(int urgence, stackoverflow_context_t scp) { @@ -1948,7 +2045,7 @@ interruption_depassement_pile(int urgenc interruption3(SIGUSR2); return; } - +#endif int interruption_violation_access(void *adresse_fautive, int gravite) @@ -1962,8 +2059,13 @@ interruption_violation_access(void *adre { // Il peut s'agir d'un dépassement de pile. - sigsegv_leave_handler(sortie_interruption_depassement_pile, - (void *) &routine_recursive, NULL, NULL); +# ifdef HAVE_SIGSEGV_RECOVERY + sigsegv_leave_handler(sortie_interruption_depassement_pile, + (void *) &routine_recursive, NULL, NULL); +# else + sortie_interruption_depassement_pile((void *) &routine_recursive, + NULL, NULL); +# endif } // On est dans une bonne vieille violation d'accès. On essaie @@ -1978,8 +2080,13 @@ interruption_violation_access(void *adre return(0); } +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" + write(STDERR_FILENO, message, strlen(message)); +# pragma GCC diagnostic pop + if (pid_processus_pere == getpid()) { longjmp(contexte_initial, -1); @@ -2125,25 +2232,6 @@ signal_inject(struct_processus *s_etat_p return; } -// Récupération des signaux -// - SIGPIPE - -void -interruption5(int signal) -{ - unsigned char message[] = "+++System : SIGPIPE\n" - "+++System : Aborting !\n"; - - test_signal(signal); - - if (pid_processus_pere == getpid()) - { - envoi_signal_processus(pid_processus_pere, rpl_sigalrm); - } - - write(STDERR_FILENO, message, strlen(message)); - return; -} static inline void signal_urg(struct_processus *s_etat_processus, pid_t pid) @@ -2238,16 +2326,6 @@ signal_abort(struct_processus *s_etat_pr return; } -// Récupération des signaux -// - SIGHUP - -void -interruption4(int signal) -{ - test_signal(signal); - envoi_signal_processus(getpid(), rpl_sighup); - return; -} static inline void signal_hup(struct_processus *s_etat_processus, pid_t pid) @@ -2264,8 +2342,12 @@ signal_hup(struct_processus *s_etat_proc return; } - snprintf(nom, 8 + 64 + 1, "rpl-out-%lu-%lu", (unsigned long) getpid(), - (unsigned long) pthread_self()); + snprintf(nom, 8 + 64 + 1, "rpl-out-%llu-%llu", + (unsigned long long) getpid(), + (unsigned long long) pthread_self()); + +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-result" if ((fichier = fopen(nom, "w+")) != NULL) { @@ -2277,6 +2359,8 @@ signal_hup(struct_processus *s_etat_proc freopen("/dev/null", "r", stdin); +# pragma GCC diagnostic pop + if (((*s_etat_processus).type_debug & d_debug_signaux) != 0) { printf("[%d] RPL/SIGHUP (thread %llu)\n", (int) getpid(), @@ -2293,7 +2377,7 @@ traitement_exceptions_gsl(const char *re int line, int gsl_errno) { code_erreur_gsl = gsl_errno; - envoi_signal_processus(getpid(), rpl_sigexcept); + envoi_signal_processus(getpid(), rpl_sigexcept, d_faux); return; } @@ -2374,11 +2458,11 @@ envoi_interruptions(struct_processus *s_ default: if ((*s_etat_processus).langue == 'F') { - printf("+++System : Spurious signal (%d) !\n", signal); + printf("+++System : Signal inconnu (%d) !\n", signal); } else { - printf("+++System : Signal inconnu (%d) !\n", signal); + printf("+++System : Spurious signal (%d) !\n", signal); } break; @@ -2397,11 +2481,7 @@ scrutation_interruptions(struct_processu // à lire. Les pointeurs d'écriture pointent sur les prochains éléments à // écrire. -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - if (sem_trywait(&((*s_queue_signaux).semaphore)) == 0) -# else - if (sem_trywait(semaphore_queue_signaux) == 0) -# endif + if (sem_trywait(semaphore_queue_signaux) == 0) { while((*s_queue_signaux).pointeur_lecture != (*s_queue_signaux).pointeur_ecriture) @@ -2417,50 +2497,75 @@ scrutation_interruptions(struct_processu ((*s_queue_signaux).pointeur_lecture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&((*s_queue_signaux).signalisation)); -# else - sem_wait(semaphore_signalisation); +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) + { + sem_post(semaphore_queue_signaux); + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } # endif + + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&((*s_queue_signaux).semaphore)); -# else - sem_post(semaphore_queue_signaux); -# endif + sem_post(semaphore_queue_signaux); } // Interruptions qui arrivent depuis le groupe courant de threads. - if (pthread_mutex_trylock(&mutex_interruptions) == 0) + if (pthread_mutex_trylock(&mutex_liste_threads) == 0) { - while((*s_etat_processus).pointeur_signal_lecture != - (*s_etat_processus).pointeur_signal_ecriture) + if (pthread_mutex_trylock(&((*s_etat_processus).mutex_signaux)) == 0) { - // Il y a un signal dans la queue du thread courant. On le traite. + while((*s_etat_processus).pointeur_signal_lecture != + (*s_etat_processus).pointeur_signal_ecriture) + { + // Il y a un signal dans la queue du thread courant. + // On le traite. - envoi_interruptions(s_etat_processus, - (*s_etat_processus).signaux_en_queue - [(*s_etat_processus).pointeur_signal_lecture], - getpid()); - (*s_etat_processus).pointeur_signal_lecture = - ((*s_etat_processus).pointeur_signal_lecture + 1) - % LONGUEUR_QUEUE_SIGNAUX; + envoi_interruptions(s_etat_processus, + (*s_etat_processus).signaux_en_queue + [(*s_etat_processus).pointeur_signal_lecture], + getpid()); + (*s_etat_processus).pointeur_signal_lecture = + ((*s_etat_processus).pointeur_signal_lecture + 1) + % LONGUEUR_QUEUE_SIGNAUX; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_wait(&((*s_queue_signaux).signalisation)); -# else - sem_wait(semaphore_signalisation); -# endif + while(sem_wait(semaphore_signalisation) != 0) + { + if (errno != EINTR) + { + if (pthread_mutex_unlock(&mutex_liste_threads) != 0) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } + } + + pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)); } - pthread_mutex_unlock(&mutex_interruptions); + pthread_mutex_unlock(&mutex_liste_threads); } return; } + /* ================================================================================ Fonction renvoyant le nom du segment de mémoire partagée en fonction @@ -2482,7 +2587,7 @@ nom_segment(unsigned char *chemin, pid_t # ifdef IPCS_SYSV // !POSIX # ifndef OS2 // !OS2 - if ((fichier = malloc((strlen(chemin) + 1 + 256 + 1) * + if ((fichier = sys_malloc((strlen(chemin) + 1 + 256 + 1) * sizeof(unsigned char))) == NULL) { return(NULL); @@ -2490,7 +2595,7 @@ nom_segment(unsigned char *chemin, pid_t sprintf(fichier, "%s/RPL-SIGQUEUES-%d", chemin, (int) pid); # else // OS2 - if ((fichier = malloc((10 + 256 + 1) * sizeof(unsigned char))) + if ((fichier = sys_malloc((10 + 256 + 1) * sizeof(unsigned char))) == NULL) { return(NULL); @@ -2500,7 +2605,7 @@ nom_segment(unsigned char *chemin, pid_t # endif // OS2 # else // POSIX - if ((fichier = malloc((1 + 256 + 1) * + if ((fichier = sys_malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL) { return(NULL); @@ -2526,18 +2631,19 @@ nom_segment(unsigned char *chemin, pid_t */ int -envoi_signal_processus(pid_t pid, enum signaux_rpl signal) +envoi_signal_processus(pid_t pid, enum signaux_rpl signal, + logical1 test_ouverture) { # ifndef OS2 int segment; # endif # ifndef IPCS_SYSV -# ifdef SEMAPHORES_NOMMES - sem_t *semaphore; - sem_t *signalisation; -# endif + sem_t *semaphore; + sem_t *signalisation; # else + sem_t *semaphore; + sem_t *signalisation; # ifndef OS2 int desc; key_t clef; @@ -2546,6 +2652,8 @@ envoi_signal_processus(pid_t pid, enum s struct_queue_signaux *queue; + struct timespec attente; + unsigned char *nom; // Il s'agit d'ouvrir le segment de mémoire partagée, de le projeter en @@ -2560,11 +2668,7 @@ envoi_signal_processus(pid_t pid, enum s return(1); } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - while(sem_wait(&((*s_queue_signaux).semaphore)) != 0) -# else - while(sem_wait(semaphore_queue_signaux) != 0) -# endif + while(sem_wait(semaphore_queue_signaux) != 0) { if (errno != EINTR) { @@ -2581,20 +2685,21 @@ envoi_signal_processus(pid_t pid, enum s ((*s_queue_signaux).pointeur_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - if (sem_post(&((*s_queue_signaux).semaphore)) != 0) -# else - if (sem_post(semaphore_queue_signaux) != 0) +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) + { + sem_post(semaphore_queue_signaux); + return(1); + } # endif + + if (sem_post(semaphore_queue_signaux) != 0) { return(1); } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - if (sem_post(&((*s_queue_signaux).signalisation)) != 0) -# else - if (sem_post(semaphore_signalisation) != 0) -# endif + if (sem_post(semaphore_signalisation) != 0) { return(1); } @@ -2610,21 +2715,35 @@ envoi_signal_processus(pid_t pid, enum s } # ifndef OS2 // SysV - if ((desc = open(nom, O_RDWR)) == -1) + if (test_ouverture == d_vrai) { - free(nom); - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((desc = open(nom, O_RDWR)) == -1) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if ((desc = open(nom, O_RDWR)) == -1) + { + sys_free(nom); + return(1); + } } close(desc); if ((clef = ftok(nom, 1)) == -1) { - free(nom); + sys_free(nom); return(1); } - free(nom); + sys_free(nom); if ((segment = shmget(clef, sizeof(struct_queue_signaux), 0)) == -1) @@ -2634,14 +2753,29 @@ envoi_signal_processus(pid_t pid, enum s queue = shmat(segment, NULL, 0); # else // OS/2 - if (DosGetNamedSharedMem((PVOID) &queue, nom, - PAG_WRITE | PAG_READ) != 0) + if (test_ouverture == d_vrai) { - free(nom); - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while(DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if (DosGetNamedSharedMem((PVOID) &queue, nom, + PAG_WRITE | PAG_READ) != 0) + { + sys_free(nom); + return(1); + } } - free(nom); + sys_free(nom); # endif # else // POSIX if ((nom = nom_segment(racine_segment, pid)) == NULL) @@ -2649,13 +2783,27 @@ envoi_signal_processus(pid_t pid, enum s return(1); } - if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + if (test_ouverture == d_vrai) { - free(nom); - return(1); + attente.tv_sec = 0; + attente.tv_nsec = GRANULARITE_us * 1000; + + while((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + nanosleep(&attente, NULL); + INCR_GRANULARITE(attente.tv_nsec); + } + } + else + { + if ((segment = shm_open(nom, O_RDWR, 0)) == -1) + { + sys_free(nom); + return(1); + } } - free(nom); + sys_free(nom); if ((queue = mmap(NULL, sizeof(struct_queue_signaux), PROT_READ | PROT_WRITE, MAP_SHARED, segment, 0)) == @@ -2666,49 +2814,117 @@ envoi_signal_processus(pid_t pid, enum s } # endif - // À ce moment, le segment de mémoire partagée est projeté - // dans l'espace du processus. + // À ce moment, le segment de mémoire partagée est projeté + // dans l'espace du processus. -# ifndef IPCS_SYSV // POSIX -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*queue).semaphore)) != 0) + if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) { - if (errno != EINTR) + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) { return(1); } - } -# else - if ((semaphore = sem_open2(pid, SEM_QUEUE)) == SEM_FAILED) +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + return(1); + } + + if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) + == SEM_FAILED) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(semaphore); return(1); } - if ((signalisation = sem_open2(pid, SEM_SIGNALISATION)) - == SEM_FAILED) + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { + close(segment); + sem_close(semaphore); return(1); } - while(sem_wait(semaphore) != 0) - { - if (errno != EINTR) + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) { sem_close(semaphore); - sem_close(signalisation); return(1); } - } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif # endif -# else // IPCS_SYSV - while(sem_wait(&((*queue).semaphore)) != 0) + + sem_close(semaphore); + return(1); + } + + while(sem_wait(semaphore) != 0) + { + if (errno != EINTR) { - if (errno != EINTR) - { - return(1); - } +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) + != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + sem_close(semaphore); + sem_close(signalisation); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + close(segment); + return(1); + } + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); + sem_close(signalisation); + return(1); } -# endif + } (*queue).queue[(*queue).pointeur_ecriture].pid = getpid(); (*queue).queue[(*queue).pointeur_ecriture].signal = signal; @@ -2716,59 +2932,162 @@ envoi_signal_processus(pid_t pid, enum s (*queue).pointeur_ecriture = ((*queue).pointeur_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; -# ifndef IPCS_SYSV // POSIX -# ifndef SEMAPHORES_NOMMES - if (sem_post(&((*queue).semaphore)) != 0) + if (sem_post(semaphore) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + sem_close(semaphore); + sem_close(signalisation); return(1); } - if (sem_post(&((*queue).signalisation)) != 0) + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { + close(segment); + sem_close(semaphore); + sem_close(signalisation); return(1); } -# else - if (sem_post(semaphore) != 0) + + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(semaphore); + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(semaphore); + sem_close(signalisation); + return(1); + } + + if (sem_close(semaphore) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) { - sem_close(semaphore); + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); sem_close(signalisation); return(1); } - if (sem_close(semaphore) != 0) + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { + close(segment); + sem_close(signalisation); return(1); } - if (sem_post(signalisation) != 0) + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + sem_close(signalisation); + return(1); + } + + if (sem_post(signalisation) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); sem_close(signalisation); return(1); } - if (sem_close(signalisation) != 0) + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { + close(segment); + sem_close(signalisation); return(1); } + close(segment); +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + sem_close(signalisation); + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif # endif - if (munmap(queue, sizeof(struct_queue_signaux)) != 0) - { + sem_close(signalisation); + return(1); + } + + if (sem_close(signalisation) != 0) + { +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) + { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); + return(1); + } + + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) + { + close(segment); + return(1); + } + close(segment); - return(1); - } -# else // IPCS_SYSV - if (sem_post(&((*queue).semaphore)) != 0) +# else // IPCS_SYSV +# ifndef OS2 // SysV + if (shmdt(queue) != 0) + { + return(1); + } +# else // OS/2 + // Pendant de DosGetNamedSHaredMem() +# endif +# endif + + return(1); + } + +# ifndef IPCS_SYSV // POSIX + if (msync(queue, sizeof(queue), MS_ASYNC | MS_INVALIDATE) != 0) { + munmap(queue, sizeof(struct_queue_signaux)); + close(segment); return(1); } - if (sem_post(&((*queue).signalisation)) != 0) + if (munmap(queue, sizeof(struct_queue_signaux)) != 0) { + close(segment); return(1); } + close(segment); +# else // IPCS_SYSV # ifndef OS2 // SysV if (shmdt(queue) != 0) { @@ -2817,22 +3136,22 @@ envoi_signal_thread(pthread_t tid, enum return(1); } - if (pthread_mutex_lock(&mutex_interruptions) != 0) + s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) + .s_etat_processus; + + if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0) { pthread_mutex_unlock(&mutex_liste_threads); return(1); } - s_etat_processus = (*((struct_thread *) (*l_element_courant).donnee)) - .s_etat_processus; - (*s_etat_processus).signaux_en_queue [(*s_etat_processus).pointeur_signal_ecriture] = signal; (*s_etat_processus).pointeur_signal_ecriture = ((*s_etat_processus).pointeur_signal_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; - if (pthread_mutex_unlock(&mutex_interruptions) != 0) + if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0) { pthread_mutex_unlock(&mutex_liste_threads); return(1); @@ -2843,17 +3162,10 @@ envoi_signal_thread(pthread_t tid, enum return(1); } -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - if (sem_post(&((*s_queue_signaux).signalisation)) != 0) - { - return(1); - } -# else if (sem_post(semaphore_signalisation) != 0) { return(1); } -# endif return(0); } @@ -2862,26 +3174,19 @@ int envoi_signal_contexte(struct_processus *s_etat_processus_a_signaler, enum signaux_rpl signal) { - pthread_mutex_lock(&mutex_interruptions); + pthread_mutex_lock(&((*s_etat_processus_a_signaler).mutex_signaux)); (*s_etat_processus_a_signaler).signaux_en_queue [(*s_etat_processus_a_signaler).pointeur_signal_ecriture] = signal; (*s_etat_processus_a_signaler).pointeur_signal_ecriture = ((*s_etat_processus_a_signaler).pointeur_signal_ecriture + 1) % LONGUEUR_QUEUE_SIGNAUX; - pthread_mutex_unlock(&mutex_interruptions); + pthread_mutex_unlock(&((*s_etat_processus_a_signaler).mutex_signaux)); -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - if (sem_post(&((*s_queue_signaux).signalisation)) != 0) - { - return(1); - } -# else if (sem_post(semaphore_signalisation) != 0) { return(1); } -# endif return(0); } @@ -2907,6 +3212,12 @@ creation_queue_signaux(struct_processus unsigned char *nom; + if (lancement_thread_signaux(s_etat_processus) == d_erreur) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + racine_segment = (*s_etat_processus).chemin_fichiers_temporaires; # ifndef IPCS_SYSV // POSIX @@ -2920,14 +3231,35 @@ creation_queue_signaux(struct_processus if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)) == -1) { - free(nom); - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return; + if (errno != EEXIST) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if ((*s_etat_processus).langue == 'F') + { + printf("+++Attention : Le segment de mémoire %s préexiste !\n", + nom); + } + else + { + printf("+++Warning: %s memory segment preexists!\n", nom); + } + + if ((f_queue_signaux = shm_open(nom, O_RDWR | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR)) == -1) + { + sys_free(nom); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } } if (ftruncate(f_queue_signaux, sizeof(struct_queue_signaux)) == -1) { - free(nom); + sys_free(nom); (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } @@ -2939,42 +3271,46 @@ creation_queue_signaux(struct_processus { if (shm_unlink(nom) == -1) { - free(nom); + sys_free(nom); (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - free(nom); + sys_free(nom); (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - free(nom); + sys_free(nom); -# ifndef SEMAPHORES_NOMMES - sem_init(&((*s_queue_signaux).semaphore), 1, 1); - sem_init(&((*s_queue_signaux).signalisation), 1, 0); -# else - if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) - == SEM_FAILED) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } + if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) + == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } - if ((semaphore_signalisation = sem_init2(1, getpid(), - SEM_SIGNALISATION)) == SEM_FAILED) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } -# endif + if ((semaphore_signalisation = sem_init2(0, getpid(), + SEM_SIGNALISATION)) == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if ((semaphore_arret_signalisation = sem_init2(1, getpid(), + SEM_ARRET_SIGNALISATION)) == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; + (*s_queue_signaux).requete_arret = d_faux; - if (msync(s_queue_signaux, sizeof(struct_queue_signaux), 0)) + if (msync(s_queue_signaux, sizeof(struct_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; @@ -3010,7 +3346,7 @@ creation_queue_signaux(struct_processus } close(support); - free(nom); + sys_free(nom); if ((segment = shmget(clef, sizeof(struct_queue_signaux), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) == -1) @@ -3035,8 +3371,27 @@ creation_queue_signaux(struct_processus return; } - sem_init(&((*s_queue_signaux).semaphore), 1, 1); - sem_init(&((*s_queue_signaux).signalisation), 1, 0); + if ((semaphore_queue_signaux = sem_init2(1, getpid(), SEM_QUEUE)) + == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if ((semaphore_signalisation = sem_init2(0, getpid(), + SEM_SIGNALISATION)) == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + if ((semaphore_arret_signalisation = sem_init2(1, getpid(), + SEM_ARRET_SIGNALISATION)) == SEM_FAILED) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; (*s_queue_signaux).requete_arret = d_faux; @@ -3051,15 +3406,17 @@ creation_queue_signaux(struct_processus sizeof(struct_queue_signaux), PAG_WRITE | PAG_READ | PAG_COMMIT) != 0) { - free(nom); + sys_free(nom); (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - free(nom); + sys_free(nom); sem_init(&((*s_queue_signaux).semaphore), 1, 1); sem_init(&((*s_queue_signaux).signalisation), 1, 0); + sem_init(&((*s_queue_signaux).arret_signalisation), 1, 1); + (*s_queue_signaux).pointeur_lecture = 0; (*s_queue_signaux).pointeur_ecriture = 0; (*s_queue_signaux).requete_arret = d_faux; @@ -3081,29 +3438,14 @@ creation_queue_signaux(struct_processus return; } -# ifdef SCHED_OTHER - if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } -# endif - -# ifdef PTHREAD_EXPLICIT_SCHED - if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0) - { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; - } -# endif + (*s_queue_signaux).controle = getpid(); -# ifdef PTHREAD_SCOPE_SYSTEM - if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) + if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs, + thread_surveillance_signaux, s_etat_processus) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } -# endif if (pthread_attr_destroy(&attributs) != 0) { @@ -3111,12 +3453,14 @@ creation_queue_signaux(struct_processus return; } - if (pthread_create(&((*s_queue_signaux).thread_signaux), &attributs, - thread_surveillance_signaux, s_etat_processus) != 0) +# ifndef IPCS_SYSV + if (msync(s_queue_signaux, sizeof(s_queue_signaux), + MS_ASYNC | MS_INVALIDATE) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } +# endif return; } @@ -3138,18 +3482,6 @@ creation_queue_signaux(struct_processus void liberation_queue_signaux(struct_processus *s_etat_processus) { - // Incrémenter le sémaphore pour être sûr de le débloquer. - - (*s_queue_signaux).requete_arret = d_vrai; - -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&((*s_queue_signaux).signalisation)); -# else - sem_post(semaphore_signalisation); -# endif - - pthread_join((*s_queue_signaux).thread_signaux, NULL); - # ifdef IPCS_SYSV // SystemV # ifndef OS2 if (shmdt(s_queue_signaux) == -1) @@ -3160,13 +3492,9 @@ liberation_queue_signaux(struct_processu # else // OS/2 # endif # else // POSIX -# ifndef SEMAPHORES_NOMMES - sem_close(&((*s_queue_signaux).semaphore)); - sem_close(&((*s_queue_signaux).signalisation)); -# else - sem_close(semaphore_queue_signaux); - sem_close(semaphore_signalisation); -# endif + sem_close(semaphore_queue_signaux); + sem_close(semaphore_signalisation); + sem_close(semaphore_arret_signalisation); if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) { @@ -3201,39 +3529,72 @@ destruction_queue_signaux(struct_process unsigned char *nom; # endif - // Incrémenter le sémaphore pour être sûr de le débloquer. + // On dépile les interruptions pour arrêter les SIGUSR2 sur + // le processus courant. + + scrutation_interruptions(s_etat_processus); + + while(sem_wait(semaphore_arret_signalisation) != 0) + { + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + } (*s_queue_signaux).requete_arret = d_vrai; -# if (!defined(SEMAPHORES_NOMMES)) || defined(IPCS_SYSV) - sem_post(&((*s_queue_signaux).signalisation)); -# else - sem_post(semaphore_signalisation); +# ifndef IPCS_SYSV + msync(s_queue_signaux, sizeof(s_queue_signaux), MS_ASYNC | MS_INVALIDATE); # endif - pthread_join((*s_queue_signaux).thread_signaux, NULL); + sem_post(semaphore_arret_signalisation); + + // Incrémenter le sémaphore pour être sûr de le débloquer. + + sem_post(semaphore_signalisation); + + if ((*s_queue_signaux).controle == getpid()) + { + pthread_join((*s_queue_signaux).thread_signaux, NULL); + } + else + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } # ifdef IPCS_SYSV // SystemV # ifndef OS2 // Il faut commencer par éliminer le sémaphore. - if (semctl((*s_queue_signaux).semaphore.sem, 0, IPC_RMID) == -1) + if (semctl((*semaphore_queue_signaux).sem, 0, IPC_RMID) == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } - unlink((*s_queue_signaux).semaphore.path); - free((*s_queue_signaux).semaphore.path); + unlink((*semaphore_queue_signaux).path); + sys_free((*semaphore_queue_signaux).path); - if (semctl((*s_queue_signaux).signalisation.sem, 0, IPC_RMID) == -1) + if (semctl((*semaphore_signalisation).sem, 0, IPC_RMID) == -1) { (*s_etat_processus).erreur_systeme = d_es_processus; return; } - unlink((*s_queue_signaux).signalisation.path); - free((*s_queue_signaux).signalisation.path); + unlink((*semaphore_signalisation).path); + sys_free((*semaphore_signalisation).path); + + if (semctl((*semaphore_arret_signalisation).sem, 0, IPC_RMID) == -1) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } + + unlink((*semaphore_arret_signalisation).path); + sys_free((*semaphore_arret_signalisation).path); if (shmdt(s_queue_signaux) == -1) { @@ -3255,7 +3616,7 @@ destruction_queue_signaux(struct_process } unlink(nom); - free(nom); + sys_free(nom); # else sem_close(&((*s_queue_signaux).semaphore)); sem_destroy(&((*s_queue_signaux).semaphore)); @@ -3263,6 +3624,9 @@ destruction_queue_signaux(struct_process sem_close(&((*s_queue_signaux).signalisation)); sem_destroy(&((*s_queue_signaux).signalisation)); + sem_close(&((*s_queue_signaux).arret_signalisation)); + sem_destroy(&((*s_queue_signaux).arret_signalisation)); + if (DosFreeMem(s_queue_signaux) != 0) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3270,19 +3634,10 @@ destruction_queue_signaux(struct_process } # endif # else // POSIX -# ifndef SEMAPHORES_NOMMES - sem_close(&((*s_queue_signaux).semaphore)); - sem_destroy(&((*s_queue_signaux).semaphore)); - - sem_close(&((*s_queue_signaux).signalisation)); - sem_destroy(&((*s_queue_signaux).signalisation)); -# else - sem_close(semaphore_queue_signaux); - sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); - - sem_close(semaphore_signalisation); - sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION); -# endif + sem_destroy2(semaphore_queue_signaux, getpid(), SEM_QUEUE); + sem_destroy2(semaphore_signalisation, getpid(), SEM_SIGNALISATION); + sem_destroy2(semaphore_arret_signalisation, getpid(), + SEM_ARRET_SIGNALISATION); if (munmap(s_queue_signaux, sizeof(struct_queue_signaux)) != 0) { @@ -3300,14 +3655,15 @@ destruction_queue_signaux(struct_process if (shm_unlink(nom) != 0) { - free(nom); + sys_free(nom); (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - free(nom); + sys_free(nom); # endif + arret_thread_signaux(s_etat_processus); return; }